mod decimate;
#[cfg(test)]
pub(crate) mod difference;
mod repair;
mod smoothing;
use crate::{Mesh3, Point3, Result, Vector3};
use alum::{
Adaptor, CrossProductAdaptor, DotProductAdaptor, FloatScalarAdaptor, Handle, HasIterators,
HasTopology, VectorAngleAdaptor, VectorLengthAdaptor, VectorNormalizeAdaptor,
};
pub use decimate::{
BestEffortDecimator, BestEffortOpts, DecimateOpts, DecimateReport, DecimateStats,
DecimateTarget, ErrorMethod, Placement, QuadricKind, ToleranceVolumeDecimator,
};
pub use repair::{RepairOpts, RepairReport, Repaired, repair_buffers};
use std::collections::HashMap;
use std::error::Error;
pub type AlumMesh = alum::PolyMeshT<3, NaAdaptor>;
pub struct HalfEdgeMesh3 {
inner: AlumMesh,
vertex_scalars: HashMap<String, alum::VProperty<f64>>,
error_volume_stale: bool,
}
impl Default for HalfEdgeMesh3 {
fn default() -> Self {
Self::new()
}
}
impl HalfEdgeMesh3 {
pub fn new() -> Self {
Self {
inner: AlumMesh::new(),
vertex_scalars: HashMap::new(),
error_volume_stale: false,
}
}
pub fn vertex_prop_f64(&mut self, name: &str, default: f64) -> Result<alum::VProperty<f64>> {
if let Some(p) = self.vertex_scalars.get(name) {
return Ok(p.clone());
}
let prop = self.inner.create_vertex_prop(default);
self.vertex_scalars.insert(name.to_string(), prop.clone());
Ok(prop)
}
pub fn as_alum(&self) -> &AlumMesh {
&self.inner
}
pub fn as_alum_mut(&mut self) -> &mut AlumMesh {
&mut self.inner
}
pub fn into_alum(self) -> AlumMesh {
self.inner
}
pub fn from_alum(inner: AlumMesh) -> Self {
Self {
inner,
vertex_scalars: HashMap::new(),
error_volume_stale: false,
}
}
pub fn error_volume_is_current(&self) -> bool {
!self.error_volume_stale
}
pub fn invalidate_error_volume(&mut self) {
self.error_volume_stale = true;
}
pub(crate) fn set_error_volume_stale(&mut self) {
self.error_volume_stale = true;
}
pub(crate) fn error_volume_stale(&self) -> bool {
self.error_volume_stale
}
pub fn to_mesh(&mut self, is_solid: bool) -> Result<Mesh3> {
self.garbage_collect()?;
let vertices = self.clone_vertices()?;
let faces = self.clone_faces()?;
if faces.is_empty() {
return Err(
"The half-edge mesh has no faces left, and a mesh needs at least one".into(),
);
}
Ok(Mesh3::new(vertices, faces, is_solid))
}
pub fn vertex_count(&self) -> usize {
self.inner.num_vertices()
}
pub fn face_count(&self) -> usize {
self.inner.num_faces()
}
pub fn edge_count(&self) -> usize {
self.inner.num_edges()
}
pub fn garbage_collect(&mut self) -> Result<()> {
self.inner
.garbage_collection()
.map_err(|e| format!("Garbage collection failed: {:?}", e).into())
}
pub fn clone_vertices(&self) -> Result<Vec<Point3>> {
let points = self.inner.points();
let points = points.try_borrow().map_err(|_| "Failed to borrow points")?;
Ok(points.iter().map(|v| Point3::from(*v)).collect())
}
pub fn clone_faces(&self) -> Result<Vec<[u32; 3]>> {
let f_status = self.inner.face_status_prop();
let f_status = f_status
.try_borrow()
.map_err(|_| "Failed to borrow face status")?;
Ok(self
.inner
.triangulated_vertices(&f_status)
.map(|f| [f[0].index(), f[1].index(), f[2].index()])
.collect())
}
}
impl TryFrom<&HalfEdgeMesh3> for Mesh3 {
type Error = Box<dyn Error>;
fn try_from(value: &HalfEdgeMesh3) -> std::result::Result<Self, Self::Error> {
let vertices = value.clone_vertices()?;
let faces = value.clone_faces()?;
Ok(Mesh3::new(vertices, faces, false))
}
}
impl TryFrom<&Mesh3> for HalfEdgeMesh3 {
type Error = Box<dyn Error>;
fn try_from(value: &Mesh3) -> std::result::Result<Self, Self::Error> {
let mut result = HalfEdgeMesh3::new();
let mut indices = Vec::new();
for v in value.points() {
let handle = result
.inner
.add_vertex(v.coords)
.map_err(|e| format!("Failed to add vertex: {:?}", e))?;
indices.push(handle);
}
for f in value.faces() {
result
.inner
.add_tri_face(
indices[f[0] as usize],
indices[f[1] as usize],
indices[f[2] as usize],
)
.map_err(|e| format!("Failed to add face: {:?}", e))?;
}
Ok(result)
}
}
pub struct NaAdaptor {}
impl Adaptor<3> for NaAdaptor {
type Vector = Vector3;
type Scalar = f64;
fn vector(coords: [Self::Scalar; 3]) -> Self::Vector {
Vector3::new(coords[0], coords[1], coords[2])
}
fn zero_vector() -> Self::Vector {
Vector3::zeros()
}
fn vector_coord(v: &Self::Vector, i: usize) -> Self::Scalar {
v[i]
}
}
impl VectorLengthAdaptor<3> for NaAdaptor {
fn vector_length(v: Self::Vector) -> Self::Scalar {
v.norm()
}
fn vector_length_squared(v: Self::Vector) -> Self::Scalar {
v.norm_squared()
}
}
impl VectorNormalizeAdaptor<3> for NaAdaptor {
fn normalized_vec(v: Self::Vector) -> Self::Vector {
v.normalize()
}
}
impl DotProductAdaptor<3> for NaAdaptor {
fn dot_product(a: Self::Vector, b: Self::Vector) -> Self::Scalar {
a.dot(&b)
}
}
impl VectorAngleAdaptor for NaAdaptor {
fn vector_angle(a: Self::Vector, b: Self::Vector) -> Self::Scalar {
a.angle(&b)
}
}
impl CrossProductAdaptor for NaAdaptor {
fn cross_product(a: Self::Vector, b: Self::Vector) -> Self::Vector {
a.cross(&b)
}
}
impl FloatScalarAdaptor<3> for NaAdaptor {
fn scalarf32(val: f32) -> Self::Scalar {
val as f64
}
fn scalarf64(val: f64) -> Self::Scalar {
val
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn an_empty_mesh_has_nothing_in_it() {
let he = HalfEdgeMesh3::new();
assert_eq!(he.vertex_count(), 0);
assert_eq!(he.face_count(), 0);
assert_eq!(he.edge_count(), 0);
assert!(he.clone_vertices().unwrap().is_empty());
assert!(he.clone_faces().unwrap().is_empty());
}
#[test]
fn a_clean_mesh_round_trips() {
let mesh = crate::tests::engine_blade();
let he = HalfEdgeMesh3::try_from(&mesh).unwrap();
assert_eq!(he.vertex_count(), mesh.points().len());
assert_eq!(he.face_count(), mesh.faces().len());
let back = Mesh3::try_from(&he).unwrap();
assert_eq!(back.points().len(), mesh.points().len());
assert_eq!(back.faces().len(), mesh.faces().len());
}
#[test]
fn a_guarantee_cannot_follow_a_best_effort_pass() {
use crate::geom3::half_edge3::{BestEffortOpts, DecimateOpts};
let mesh = Mesh3::stanford_bunny_res4();
let (mut he, _) = HalfEdgeMesh3::from_mesh_repaired(&mesh, &RepairOpts::default()).unwrap();
assert!(he.error_volume_is_current());
he.decimate_best_effort(&BestEffortOpts::to_tolerance(0.01))
.unwrap();
assert!(!he.error_volume_is_current());
let err = he
.decimate_guaranteed(&DecimateOpts::to_tolerance(0.01))
.expect_err("a guaranteed pass should refuse to follow a best-effort one");
assert!(
err.to_string().contains("best-effort"),
"the refusal should say why: {err}"
);
}
#[test]
fn a_refused_best_effort_call_leaves_the_volume_alone() {
use crate::geom3::half_edge3::BestEffortOpts;
let mesh = Mesh3::stanford_bunny_res4();
let (mut he, _) = HalfEdgeMesh3::from_mesh_repaired(&mesh, &RepairOpts::default()).unwrap();
assert!(
he.decimate_best_effort(&BestEffortOpts::to_tolerance(-1.0))
.is_err()
);
assert!(he.error_volume_is_current());
}
#[test]
fn the_escape_hatch_reaches_alum_decimation() {
use alum::decimate::HasDecimation;
use alum::decimate::quadric::{QuadricDecimater, QuadricType};
let mesh = crate::tests::engine_blade();
let mut he = HalfEdgeMesh3::try_from(&mesh).unwrap();
let before = he.face_count();
let mut decimator = QuadricDecimater::new(he.as_alum(), QuadricType::Triangle).unwrap();
let collapses = he
.as_alum_mut()
.decimate_to_face_count(&mut decimator, before / 2)
.unwrap();
assert!(collapses > 0, "decimation should have collapsed something");
he.garbage_collect().unwrap();
assert!(
he.face_count() < before,
"face count should have dropped from {}",
before
);
}
#[test]
fn wrapping_and_unwrapping_preserves_the_mesh() {
let mesh = crate::tests::stanford_bun_4();
let he = HalfEdgeMesh3::from_mesh_repaired(&mesh, &RepairOpts::default())
.unwrap()
.0;
let faces = he.face_count();
let rewrapped = HalfEdgeMesh3::from_alum(he.into_alum());
assert_eq!(rewrapped.face_count(), faces);
}
}