use std::fmt::Write as _;
use std::io::Write;
use std::path::Path;
use crate::error::{Error, Result};
use crate::mesh::{Mesh, PatchKind};
pub fn msms_type(patch: PatchKind) -> u8 {
match patch {
PatchKind::Saddle => 1,
PatchKind::Concave => 2,
PatchKind::Convex => 3,
}
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub struct MsmsHeader {
pub description: String,
pub spheres: usize,
pub density: f64,
pub probe_radius: f64,
}
impl MsmsHeader {
pub fn new(
description: impl Into<String>,
spheres: usize,
density: f64,
probe_radius: f64,
) -> Self {
Self {
description: description.into(),
spheres,
density,
probe_radius,
}
}
}
pub fn write_msms<V: Write, F: Write>(
mut vert: V,
mut face: F,
mesh: &Mesh,
header: &MsmsHeader,
) -> Result<()> {
let n = mesh.positions.len();
if mesh.normals.len() != n || mesh.vertex_atom.len() != n || mesh.vertex_patch.len() != n {
return Err(Error::InvalidInput(
"MSMS output needs normals, atoms and patches for every vertex".into(),
));
}
let io = |source| Error::Io { path: None, source };
let comp = |v: usize| mesh.vertex_component.get(v).map_or(1, |&c| c as usize + 1);
let head = |what: &str, count: usize| {
format!(
"# MSMS solvent excluded surface {what} for {}\n#{what} #sphere density probe_r\n{count:7} {:7} {:5.2} {:5.2}\n",
header.description.replace(['\n', '\r'], " "),
header.spheres,
header.density,
header.probe_radius
)
};
vert.write_all(head("vertices", n).as_bytes()).map_err(io)?;
let mut buf = String::with_capacity(1 << 16);
for v in 0..n {
let p = mesh.positions[v];
let q = mesh.normals[v];
let _ = writeln!(
buf,
"{:9.3} {:9.3} {:9.3} {:9.3} {:9.3} {:9.3} {:7} {:7} {:2}",
p[0],
p[1],
p[2],
q[0],
q[1],
q[2],
comp(v),
mesh.vertex_atom[v] + 1,
msms_type(mesh.vertex_patch[v])
);
if buf.len() >= 1 << 16 {
vert.write_all(buf.as_bytes()).map_err(io)?;
buf.clear();
}
}
vert.write_all(buf.as_bytes()).map_err(io)?;
buf.clear();
face.write_all(head("faces", mesh.triangles.len()).as_bytes())
.map_err(io)?;
for t in &mesh.triangles {
let types = t.map(|v| msms_type(mesh.vertex_patch[v as usize]));
let ty = if types[0] == types[1] && types[1] == types[2] {
types[0]
} else {
1
};
let _ = writeln!(
buf,
"{:6} {:6} {:6} {:2} {:6}",
t[0] + 1,
t[1] + 1,
t[2] + 1,
ty,
comp(t[0] as usize)
);
if buf.len() >= 1 << 16 {
face.write_all(buf.as_bytes()).map_err(io)?;
buf.clear();
}
}
face.write_all(buf.as_bytes()).map_err(io)?;
Ok(())
}
pub fn write_msms_files(stem: impl AsRef<Path>, mesh: &Mesh, header: &MsmsHeader) -> Result<()> {
let stem = stem.as_ref();
write_msms_paths(
&stem.with_extension("vert"),
&stem.with_extension("face"),
mesh,
header,
)
}
pub fn write_msms_paths(vert: &Path, face: &Path, mesh: &Mesh, header: &MsmsHeader) -> Result<()> {
let (mut v, mut f) = (super::Sink::create(vert)?, super::Sink::create(face)?);
write_msms(&mut v, &mut f, mesh, header)?;
for (w, p) in [(v, vert), (f, face)] {
w.finish().map_err(|source| Error::Io {
path: Some(p.to_path_buf()),
source,
})?;
}
Ok(())
}