use crate::{MeshData3, MeshView3, Point3, Result};
use std::io::{Read, Write};
use std::path::Path;
use tol_compress::{Mesh3 as TcMesh, mesh as tc};
fn refuse_attributes(mesh: MeshView3<'_>) -> Result<()> {
if !mesh.has_attrs() {
return Ok(());
}
Err(format!(
"The tcmesh format cannot yet represent the attributes on this mesh ({}), so writing it \
would discard them. Remove them from the mesh explicitly if that is what you want.",
mesh.attr_labels().join(", ")
)
.into())
}
fn to_container(mesh: MeshView3<'_>) -> Result<TcMesh> {
refuse_attributes(mesh)?;
let points = mesh.points().iter().map(|p| [p.x, p.y, p.z]).collect();
Ok(TcMesh::new(points, mesh.faces().to_vec()))
}
fn from_container(item: TcMesh) -> Result<MeshData3> {
let points = item
.points
.iter()
.map(|p| Point3::new(p[0], p[1], p[2]))
.collect();
MeshData3::new(points, item.faces)
}
pub fn write_tc_mesh_to<'a, W: Write>(
writer: &mut W,
mesh: impl Into<MeshView3<'a>>,
tol: f64,
) -> Result<()> {
tc::write_one_to(writer, &to_container(mesh.into())?, tol)?;
Ok(())
}
pub fn read_tc_mesh_from<R: Read>(reader: &mut R) -> Result<MeshData3> {
from_container(tc::read_one_from(reader)?)
}
pub fn write_tc_mesh_file<'a>(path: &Path, mesh: impl Into<MeshView3<'a>>, tol: f64) -> Result<()> {
tc::write_one_file(path, &to_container(mesh.into())?, tol)?;
Ok(())
}
pub fn read_tc_mesh_file(path: &Path) -> Result<MeshData3> {
from_container(tc::read_one_file(path)?)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::tests::{stanford_bun_2, stanford_bun_4};
use std::io::Cursor;
use tol_compress::reorder;
fn check_round_trip(original: &MeshData3, recovered: &MeshData3, tol: f64) {
assert_eq!(original.points().len(), recovered.points().len());
assert_eq!(original.faces().len(), recovered.faces().len());
let plan = reorder::optimize(original.faces(), original.points().len()).unwrap();
for (new, &old) in plan.face_order.iter().enumerate() {
for corner in 0..3 {
let got = recovered.points()[recovered.faces()[new][corner] as usize];
let want = original.points()[original.faces()[old as usize][corner] as usize];
let d = (got - want).norm();
assert!(d <= tol, "face {new} corner {corner} moved {d}, tol {tol}");
}
}
for (i, &old) in plan.vertex_order.iter().enumerate() {
let d = (recovered.points()[i] - original.points()[old as usize]).norm();
assert!(d <= tol, "vertex {i} moved {d}, tol {tol}");
}
}
#[test]
fn round_trip_bytes() {
let mesh = stanford_bun_2().to_data();
let tol = 1e-4;
let mut buf = Vec::new();
write_tc_mesh_to(&mut buf, &mesh, tol).unwrap();
let mut cursor = Cursor::new(&buf);
let recovered = read_tc_mesh_from(&mut cursor).unwrap();
check_round_trip(&mesh, &recovered, tol);
}
#[test]
fn round_trip_file() {
let mesh = stanford_bun_2().to_data();
let tol = 1e-4;
let path = std::env::temp_dir().join("stanford_bun_2_round_trip.tcmesh");
write_tc_mesh_file(&path, &mesh, tol).unwrap();
let recovered = read_tc_mesh_file(&path).unwrap();
check_round_trip(&mesh, &recovered, tol);
}
#[test]
fn round_trip_high_res() {
let mesh = stanford_bun_4().to_data();
let tol = 1e-4;
let mut buf = Vec::new();
write_tc_mesh_to(&mut buf, &mesh, tol).unwrap();
let mut cursor = Cursor::new(&buf);
let recovered = read_tc_mesh_from(&mut cursor).unwrap();
check_round_trip(&mesh, &recovered, tol);
}
#[test]
fn writing_refuses_a_mesh_carrying_attributes() {
let mut mesh = stanford_bun_2().to_data();
mesh.set_face_labels(Some(vec![1; mesh.face_count()]))
.unwrap();
let mut buf = Vec::new();
let err = match write_tc_mesh_to(&mut buf, &mesh, 1e-4) {
Err(e) => e.to_string(),
Ok(()) => panic!("an attributed mesh must not be silently written"),
};
assert!(
err.contains("face_labels"),
"the error must name what would be lost, got: {err}"
);
}
#[test]
fn invalid_magic_rejected() {
let bad = b"NOPE\x00\x01\x00\x00\x00";
let mut cursor = Cursor::new(bad);
assert!(read_tc_mesh_from(&mut cursor).is_err());
}
#[test]
fn writing_renumbers_a_badly_ordered_mesh() {
let mesh = stanford_bun_2().to_data();
let mut faces = mesh.faces().to_vec();
faces.reverse();
let scrambled = MeshData3::new(mesh.points().to_vec(), faces).unwrap();
let mut buf = Vec::new();
write_tc_mesh_to(&mut buf, &scrambled, 1e-4).unwrap();
let recovered = read_tc_mesh_from(&mut Cursor::new(&buf)).unwrap();
assert_ne!(
recovered.faces(),
scrambled.faces(),
"a reversed face order cannot also be a good one"
);
}
#[test]
fn rewriting_a_mesh_reaches_a_cycle() {
let mesh = stanford_bun_2().to_data();
let tol = 3e-6;
let mut current = mesh.clone();
let mut seen: Vec<Vec<u8>> = Vec::new();
let mut closed = None;
for round in 0..8 {
let mut buf = Vec::new();
write_tc_mesh_to(&mut buf, ¤t, tol).unwrap();
if seen.contains(&buf) {
closed = Some(round);
break;
}
seen.push(buf.clone());
current = read_tc_mesh_from(&mut Cursor::new(&buf)).unwrap();
assert_eq!(
current.faces(),
mesh.faces(),
"connectivity must not move, round {round}"
);
}
assert!(
matches!(closed, Some(r) if r <= 4),
"rewriting must close its orbit, got {closed:?}"
);
}
#[test]
fn either_container_writes_identical_bytes() -> Result<()> {
let mesh = stanford_bun_2();
let data = mesh.to_data();
let mut from_data = Vec::new();
write_tc_mesh_to(&mut from_data, &data, 1e-3)?;
let mut from_mesh = Vec::new();
write_tc_mesh_to(&mut from_mesh, &mesh, 1e-3)?;
assert_eq!(from_data, from_mesh);
let mut attributed = data.clone();
attributed.set_face_labels(Some(vec![0; attributed.face_count()]))?;
assert!(write_tc_mesh_to(&mut Vec::new(), &attributed, 1e-3).is_err());
let attributed = crate::Mesh3::from_data(attributed, false)?;
assert!(write_tc_mesh_to(&mut Vec::new(), &attributed, 1e-3).is_err());
Ok(())
}
}