use std::fmt::Write as _;
use std::path::Path;
use crate::{Error, Point, Result};
#[derive(Debug, Clone, Copy)]
pub struct ObjMesh<'a> {
pub name: &'a str,
pub vertices: &'a [Point],
pub faces: &'a [[u32; 3]],
}
pub fn fixed4(x: f64) -> String {
if x.is_nan() {
return "nan".into();
}
if x.is_infinite() {
return if x > 0.0 { "inf".into() } else { "-inf".into() };
}
format!("{x:.4}")
}
pub fn obj_text(meshes: &[ObjMesh]) -> String {
let mut s = String::from("# sylva QSM mesh\n");
let mut offset = 1u64;
for m in meshes {
let _ = writeln!(s, "o {}", m.name);
for v in m.vertices {
let _ = writeln!(s, "v {} {} {}", fixed4(v[0]), fixed4(v[1]), fixed4(v[2]));
}
for f in m.faces {
let _ = writeln!(s, "f {} {} {}", f[0] as u64 + offset, f[1] as u64 + offset, f[2] as u64 + offset);
}
offset += m.vertices.len() as u64;
}
s
}
pub fn write_obj(path: impl AsRef<Path>, meshes: &[ObjMesh]) -> Result<()> {
std::fs::write(path, obj_text(meshes))?;
Ok(())
}
pub fn parse_obj(text: &str) -> Result<(Vec<Point>, Vec<[i64; 3]>)> {
let mut v: Vec<Point> = Vec::new();
let mut dims: Option<usize> = None;
let mut f: Vec<[i64; 3]> = Vec::new();
for line in text.lines() {
let w: Vec<&str> = line.split_whitespace().collect();
if w.is_empty() {
continue;
}
if w[0] == "v" {
let c = w[1..].iter().take(3).map(|x| x.parse::<f64>().map_err(|_| Error::invalid(format!("could not convert string to float: {x:?}")))).collect::<Result<Vec<f64>>>()?;
if dims.is_some_and(|d| d != c.len()) || c.len() < 2 {
return Err(Error::invalid("vertices must be (V, 3) or (V, 2)"));
}
dims = Some(c.len());
v.push([c[0], c[1], c.get(2).copied().unwrap_or(0.0)]);
} else if w[0] == "f" {
let idx = w[1..]
.iter()
.map(|p| {
let s = p.split('/').next().unwrap_or("");
s.parse::<i64>().map_err(|_| Error::invalid(format!("invalid literal for int() with base 10: {s:?}")))
})
.collect::<Result<Vec<i64>>>()?;
let idx: Vec<i64> = idx.iter().map(|&i| if i > 0 { i - 1 } else { v.len() as i64 + i }).collect();
for t in 1..idx.len().saturating_sub(1) {
f.push([idx[0], idx[t], idx[t + 1]]);
}
}
}
Ok((v, f))
}
pub fn read_obj(path: impl AsRef<Path>) -> Result<(Vec<Point>, Vec<[u32; 3]>)> {
let path = path.as_ref();
let (v, f) = parse_obj(&std::fs::read_to_string(path)?)?;
if f.is_empty() {
return Err(Error::invalid(format!("{} holds no faces", path.display())));
}
let faces = f
.iter()
.map(|t| {
let mut out = [0u32; 3];
for k in 0..3 {
out[k] = u32::try_from(t[k]).map_err(|_| Error::invalid(format!("{}: face index {} out of range", path.display(), t[k] + 1)))?;
}
Ok(out)
})
.collect::<Result<Vec<_>>>()?;
Ok((v, faces))
}
pub fn ply_bytes(vertices: &[Point], faces: &[[i32; 3]], face_rgb: Option<&[[u8; 3]]>) -> Result<Vec<u8>> {
if face_rgb.is_some_and(|c| c.len() != faces.len()) {
return Err(Error::invalid("face_rgb must have one colour per face"));
}
let mut header = vec![
"ply".to_string(),
"format binary_little_endian 1.0".into(),
"comment sylva QSM mesh".into(),
format!("element vertex {}", vertices.len()),
"property float x".into(),
"property float y".into(),
"property float z".into(),
format!("element face {}", faces.len()),
"property list uchar int vertex_indices".into(),
];
if face_rgb.is_some() {
header.extend(["property uchar red".into(), "property uchar green".into(), "property uchar blue".into()]);
}
header.push("end_header".into());
let mut out = (header.join("\n") + "\n").into_bytes();
out.reserve(vertices.len() * 12 + faces.len() * 16);
for v in vertices {
for c in v {
out.extend_from_slice(&(*c as f32).to_le_bytes());
}
}
for (i, f) in faces.iter().enumerate() {
out.push(3);
for k in f {
out.extend_from_slice(&k.to_le_bytes());
}
if let Some(rgb) = face_rgb {
out.extend_from_slice(&rgb[i]);
}
}
Ok(out)
}
pub fn write_ply(path: impl AsRef<Path>, vertices: &[Point], faces: &[[i32; 3]], face_rgb: Option<&[[u8; 3]]>) -> Result<()> {
std::fs::write(path, ply_bytes(vertices, faces, face_rgb)?)?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn four_decimals_as_c() {
assert_eq!(fixed4(0.03125), "0.0312");
assert_eq!(fixed4(0.09375), "0.0938");
assert_eq!(fixed4(-0.00004), "-0.0000");
assert_eq!(fixed4(-0.0), "-0.0000");
assert_eq!(fixed4(1e9), "1000000000.0000");
assert_eq!(fixed4(1.23455), "1.2346");
assert_eq!(fixed4(f64::NAN), "nan");
}
#[test]
fn objects_number_their_faces_on() {
let v = [[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]];
let f = [[0, 1, 2]];
let t = obj_text(&[ObjMesh { name: "a", vertices: &v, faces: &f }, ObjMesh { name: "b", vertices: &v, faces: &f }]);
assert!(t.starts_with("# sylva QSM mesh\no a\nv 0.0000 0.0000 0.0000\n"));
assert!(t.ends_with("o b\nv 0.0000 0.0000 0.0000\nv 1.0000 0.0000 0.0000\nv 0.0000 1.0000 0.0000\nf 4 5 6\n"));
}
#[test]
fn ply_records_are_packed() {
let v = [[0.0, 1.0, 2.0]];
let b = ply_bytes(&v, &[[0, 0, 0]], Some(&[[1, 2, 3]])).unwrap();
let head = "ply\nformat binary_little_endian 1.0\ncomment sylva QSM mesh\nelement vertex 1\nproperty float x\nproperty float y\nproperty float z\nelement face 1\nproperty list uchar int vertex_indices\nproperty uchar red\nproperty uchar green\nproperty uchar blue\nend_header\n";
assert!(b.starts_with(head.as_bytes()));
assert_eq!(b.len(), head.len() + 12 + 16);
assert_eq!(&b[b.len() - 4..], &[0, 1, 2, 3]);
assert!(ply_bytes(&v, &[[0, 0, 0]], Some(&[])).is_err());
}
#[test]
fn polygons_fan_and_negative_indices_count_back() {
let (v, f) = parse_obj("v 0 0 0\nv 1 0 0\nv 1 1 0\nv 0 1 0\nvt 0 0\nf 1/1 2/1 3/1 4/1\nf -4 -2 -1\n").unwrap();
assert_eq!(v.len(), 4);
assert_eq!(f, vec![[0, 1, 2], [0, 2, 3], [0, 2, 3]]);
let (v, _) = parse_obj("v 1 2\nv 3 4\n").unwrap();
assert_eq!(v[1], [3.0, 4.0, 0.0]);
assert!(parse_obj("v 1 2 3\nv 1 2\n").is_err());
}
}