use crate::common::IndexMask;
use crate::geom3::half_edge3::HalfEdgeMesh3;
use crate::geom3::mesh::algorithms::normals::compute_face_normal;
use crate::geom3::mesh::edges::edge_key;
use crate::{Mesh3, Point3, Result};
use faer::prelude::default;
use parry3d_f64::utils::hashmap::HashMap;
use parry3d_f64::utils::hashset::HashSet;
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RepairOpts {
pub drop_degenerate: bool,
pub drop_duplicate_faces: bool,
pub resolve_nonmanifold_edges: bool,
pub split_bowtie_vertices: bool,
pub orient_consistently: bool,
pub drop_isolated_vertices: bool,
}
impl Default for RepairOpts {
fn default() -> Self {
Self {
drop_degenerate: true,
drop_duplicate_faces: true,
resolve_nonmanifold_edges: true,
split_bowtie_vertices: true,
orient_consistently: true,
drop_isolated_vertices: true,
}
}
}
impl RepairOpts {
pub fn none() -> Self {
Self {
drop_degenerate: false,
drop_duplicate_faces: false,
resolve_nonmanifold_edges: false,
split_bowtie_vertices: false,
orient_consistently: false,
drop_isolated_vertices: false,
}
}
pub fn with_drop_degenerate(mut self, value: bool) -> Self {
self.drop_degenerate = value;
self
}
pub fn with_drop_duplicate_faces(mut self, value: bool) -> Self {
self.drop_duplicate_faces = value;
self
}
pub fn with_resolve_nonmanifold_edges(mut self, value: bool) -> Self {
self.resolve_nonmanifold_edges = value;
self
}
pub fn with_split_bowtie_vertices(mut self, value: bool) -> Self {
self.split_bowtie_vertices = value;
self
}
pub fn with_orient_consistently(mut self, value: bool) -> Self {
self.orient_consistently = value;
self
}
pub fn with_drop_isolated_vertices(mut self, value: bool) -> Self {
self.drop_isolated_vertices = value;
self
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct RepairReport {
pub degenerate_removed: usize,
pub duplicate_faces_removed: usize,
pub nonmanifold_edges: usize,
pub faces_dropped_at_nonmanifold: usize,
pub faces_dropped_for_orientation: usize,
pub bowtie_vertices_split: usize,
pub points_added_by_splitting: usize,
pub faces_reoriented: usize,
pub nonorientable_components: usize,
pub isolated_vertices_removed: usize,
pub faces_rejected_by_ingest: usize,
}
impl RepairReport {
pub fn is_clean(&self) -> bool {
*self == Self::default()
}
pub fn faces_removed(&self) -> usize {
self.degenerate_removed
+ self.duplicate_faces_removed
+ self.faces_dropped_at_nonmanifold
+ self.faces_dropped_for_orientation
+ self.faces_rejected_by_ingest
}
}
impl std::fmt::Display for RepairReport {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if self.is_clean() {
return write!(f, "mesh was already manifold, nothing changed");
}
let mut parts = Vec::new();
let mut push = |n: usize, label: &str| {
if n > 0 {
parts.push(format!("{} {}", n, label));
}
};
push(self.degenerate_removed, "degenerate faces removed");
push(self.duplicate_faces_removed, "duplicate faces removed");
push(self.nonmanifold_edges, "non-manifold edges");
push(self.faces_dropped_at_nonmanifold, "faces dropped there");
push(
self.faces_dropped_for_orientation,
"faces dropped as unorientable",
);
push(self.bowtie_vertices_split, "bowtie vertices split");
push(self.points_added_by_splitting, "points added");
push(self.faces_reoriented, "faces reoriented");
push(self.nonorientable_components, "non-orientable components");
push(self.isolated_vertices_removed, "isolated vertices removed");
push(self.faces_rejected_by_ingest, "faces rejected by ingest");
write!(f, "{}", parts.join(", "))
}
}
#[derive(Debug, Clone)]
pub struct Repaired {
pub points: Vec<Point3>,
pub faces: Vec<[u32; 3]>,
pub report: RepairReport,
}
pub fn repair_buffers(
points: &[Point3],
faces: &[[u32; 3]],
opts: &RepairOpts,
) -> Result<Repaired> {
for (i, face) in faces.iter().enumerate() {
for &v in face.iter() {
if v as usize >= points.len() {
return Err(format!(
"Face {} references point {}, but the mesh has only {} points",
i,
v,
points.len()
)
.into());
}
}
}
let mut report = RepairReport::default();
let mut points = points.to_vec();
let mut faces = faces.to_vec();
if opts.drop_degenerate {
let before = faces.len();
faces.retain(|face| !is_degenerate(&points, face));
report.degenerate_removed = before - faces.len();
}
if opts.drop_duplicate_faces {
let before = faces.len();
let mut seen = HashSet::with_hasher(default());
faces.retain(|face| {
let mut key = *face;
key.sort_unstable();
seen.insert(key)
});
report.duplicate_faces_removed = before - faces.len();
}
if opts.resolve_nonmanifold_edges {
resolve_nonmanifold_edges(&points, &mut faces, &mut report);
}
if opts.orient_consistently {
orient_consistently(&mut faces, &mut report);
resolve_directed_collisions(&points, &mut faces, &mut report);
}
if opts.split_bowtie_vertices {
split_bowtie_vertices(&mut points, &mut faces, &mut report);
}
if opts.drop_isolated_vertices {
drop_isolated_vertices(&mut points, &mut faces, &mut report);
}
Ok(Repaired {
points,
faces,
report,
})
}
fn is_degenerate(points: &[Point3], face: &[u32; 3]) -> bool {
if face[0] == face[1] || face[1] == face[2] || face[2] == face[0] {
return true;
}
let p = [
points[face[0] as usize],
points[face[1] as usize],
points[face[2] as usize],
];
compute_face_normal(&p).is_none()
}
fn triangle_quality(points: &[Point3], face: &[u32; 3]) -> f64 {
let p = [
points[face[0] as usize],
points[face[1] as usize],
points[face[2] as usize],
];
let e = [p[1] - p[0], p[2] - p[1], p[0] - p[2]];
let sum_sq: f64 = e.iter().map(|v| v.norm_squared()).sum();
if sum_sq <= 0.0 {
return 0.0;
}
let area = e[0].cross(&e[1]).norm() * 0.5;
(4.0 * 3.0_f64.sqrt() * area) / sum_sq
}
fn edge_to_faces(faces: &[[u32; 3]]) -> HashMap<[u32; 2], Vec<u32>> {
let mut map: HashMap<[u32; 2], Vec<u32>> = HashMap::with_hasher(default());
for (i, face) in faces.iter().enumerate() {
for k in 0..3 {
let key = edge_key(&[face[k], face[(k + 1) % 3]]);
map.entry(key).or_default().push(i as u32);
}
}
map
}
fn resolve_nonmanifold_edges(
points: &[Point3],
faces: &mut Vec<[u32; 3]>,
report: &mut RepairReport,
) {
let map = edge_to_faces(faces);
let mut drop = IndexMask::new(faces.len(), false);
let mut nonmanifold = 0usize;
for (key, users) in map.iter() {
if users.len() <= 2 {
continue;
}
nonmanifold += 1;
let mut ranked = users.clone();
ranked.sort_by(|&a, &b| {
let qa = triangle_quality(points, &faces[a as usize]);
let qb = triangle_quality(points, &faces[b as usize]);
qb.partial_cmp(&qa)
.unwrap_or(std::cmp::Ordering::Equal)
.then(a.cmp(&b))
});
let first = ranked[0];
let first_forward = walks_forward(&faces[first as usize], key);
let second = ranked
.iter()
.skip(1)
.copied()
.find(|&f| walks_forward(&faces[f as usize], key) != first_forward)
.unwrap_or(ranked[1]);
for &f in ranked.iter() {
if f != first && f != second {
drop.set(f as usize, true);
}
}
}
report.nonmanifold_edges = nonmanifold;
report.faces_dropped_at_nonmanifold = drop.count_true();
if report.faces_dropped_at_nonmanifold > 0 {
let mut index = 0usize;
faces.retain(|_| {
let keep = !drop.get(index);
index += 1;
keep
});
}
}
fn walks_forward(face: &[u32; 3], key: &[u32; 2]) -> bool {
(0..3).any(|k| face[k] == key[0] && face[(k + 1) % 3] == key[1])
}
fn resolve_directed_collisions(
points: &[Point3],
faces: &mut Vec<[u32; 3]>,
report: &mut RepairReport,
) {
let mut directed: HashMap<[u32; 2], Vec<u32>> = HashMap::with_hasher(default());
for (i, face) in faces.iter().enumerate() {
for k in 0..3 {
directed
.entry([face[k], face[(k + 1) % 3]])
.or_default()
.push(i as u32);
}
}
let mut drop = IndexMask::new(faces.len(), false);
for users in directed.values() {
if users.len() <= 1 {
continue;
}
let mut ranked = users.clone();
ranked.sort_by(|&a, &b| {
let qa = triangle_quality(points, &faces[a as usize]);
let qb = triangle_quality(points, &faces[b as usize]);
qb.partial_cmp(&qa)
.unwrap_or(std::cmp::Ordering::Equal)
.then(a.cmp(&b))
});
for &f in ranked.iter().skip(1) {
drop.set(f as usize, true);
}
}
let dropped = drop.count_true();
if dropped == 0 {
return;
}
let mut index = 0usize;
faces.retain(|_| {
let keep = !drop.get(index);
index += 1;
keep
});
report.faces_dropped_for_orientation = dropped;
}
fn split_bowtie_vertices(
points: &mut Vec<Point3>,
faces: &mut [[u32; 3]],
report: &mut RepairReport,
) {
let mut vertex_faces: Vec<Vec<u32>> = vec![Vec::new(); points.len()];
for (i, face) in faces.iter().enumerate() {
for &v in face.iter() {
vertex_faces[v as usize].push(i as u32);
}
}
let mut split_count = 0usize;
let mut added = 0usize;
for v in 0..vertex_faces.len() {
let incident = &vertex_faces[v];
if incident.len() < 2 {
continue;
}
let fans = group_into_fans(faces, incident, v as u32);
if fans.len() < 2 {
continue;
}
split_count += 1;
for fan in fans.iter().skip(1) {
let new_index = points.len() as u32;
points.push(points[v]);
added += 1;
for &f in fan.iter() {
let face = &mut faces[f as usize];
for slot in face.iter_mut() {
if *slot == v as u32 {
*slot = new_index;
}
}
}
}
}
report.bowtie_vertices_split = split_count;
report.points_added_by_splitting = added;
}
fn group_into_fans(faces: &[[u32; 3]], incident: &[u32], vertex: u32) -> Vec<Vec<u32>> {
let spokes: Vec<[u32; 2]> = incident
.iter()
.map(|&f| {
let face = &faces[f as usize];
let mut others = [u32::MAX; 2];
let mut n = 0;
for &v in face.iter() {
if v != vertex && n < 2 {
others[n] = v;
n += 1;
}
}
others
})
.collect();
let mut spoke_owner: HashMap<u32, Vec<usize>> = HashMap::with_hasher(default());
for (local, pair) in spokes.iter().enumerate() {
for &end in pair.iter() {
if end != u32::MAX {
spoke_owner.entry(end).or_default().push(local);
}
}
}
let mut fan_of = vec![usize::MAX; incident.len()];
let mut fans: Vec<Vec<u32>> = Vec::new();
let mut stack = Vec::new();
for start in 0..incident.len() {
if fan_of[start] != usize::MAX {
continue;
}
let fan_index = fans.len();
let mut fan = Vec::new();
fan_of[start] = fan_index;
stack.push(start);
while let Some(local) = stack.pop() {
fan.push(incident[local]);
for &end in spokes[local].iter() {
let Some(neighbors) = spoke_owner.get(&end) else {
continue;
};
for &other in neighbors.iter() {
if fan_of[other] == usize::MAX {
fan_of[other] = fan_index;
stack.push(other);
}
}
}
}
fans.push(fan);
}
fans
}
fn orient_consistently(faces: &mut [[u32; 3]], report: &mut RepairReport) {
let map = edge_to_faces(faces);
let mut visited = IndexMask::new(faces.len(), false);
let mut flipped = 0usize;
let mut nonorientable = 0usize;
let mut stack: Vec<u32> = Vec::new();
for start in 0..faces.len() {
if visited.get(start) {
continue;
}
visited.set(start, true);
stack.push(start as u32);
let mut component_conflict = false;
while let Some(current) = stack.pop() {
let face = faces[current as usize];
for k in 0..3 {
let a = face[k];
let b = face[(k + 1) % 3];
let key = edge_key(&[a, b]);
let Some(users) = map.get(&key) else {
continue;
};
for &other in users.iter() {
if other == current {
continue;
}
let neighbor = faces[other as usize];
let agrees = (0..3).any(|j| neighbor[j] == b && neighbor[(j + 1) % 3] == a);
if visited.get(other as usize) {
if !agrees {
component_conflict = true;
}
continue;
}
visited.set(other as usize, true);
if !agrees {
faces[other as usize].swap(1, 2);
flipped += 1;
}
stack.push(other);
}
}
}
if component_conflict {
nonorientable += 1;
}
}
report.faces_reoriented = flipped;
report.nonorientable_components = nonorientable;
}
fn drop_isolated_vertices(
points: &mut Vec<Point3>,
faces: &mut [[u32; 3]],
report: &mut RepairReport,
) {
let mut used = vec![false; points.len()];
for face in faces.iter() {
for &v in face.iter() {
used[v as usize] = true;
}
}
let removed = used.iter().filter(|u| !**u).count();
if removed == 0 {
return;
}
let mut remap = vec![u32::MAX; points.len()];
let mut kept = Vec::with_capacity(points.len() - removed);
for (old, is_used) in used.iter().enumerate() {
if *is_used {
remap[old] = kept.len() as u32;
kept.push(points[old]);
}
}
for face in faces.iter_mut() {
for slot in face.iter_mut() {
*slot = remap[*slot as usize];
}
}
*points = kept;
report.isolated_vertices_removed = removed;
}
impl HalfEdgeMesh3 {
pub fn from_mesh_repaired(mesh: &Mesh3, opts: &RepairOpts) -> Result<(Self, RepairReport)> {
let repaired = repair_buffers(mesh.points(), mesh.faces(), opts)?;
Self::from_repaired(repaired)
}
pub fn from_repaired(repaired: Repaired) -> Result<(Self, RepairReport)> {
let Repaired {
points,
faces,
mut report,
} = repaired;
let mut result = Self::new();
let inner = result.as_alum_mut();
let mut handles = Vec::with_capacity(points.len());
for p in points.iter() {
let handle = inner
.add_vertex(p.coords)
.map_err(|e| format!("Failed to add vertex: {:?}", e))?;
handles.push(handle);
}
for face in faces.iter() {
if inner
.add_tri_face(
handles[face[0] as usize],
handles[face[1] as usize],
handles[face[2] as usize],
)
.is_err()
{
report.faces_rejected_by_ingest += 1;
}
}
Ok((result, report))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn tri(a: u32, b: u32, c: u32) -> [u32; 3] {
[a, b, c]
}
fn square() -> (Vec<Point3>, Vec<[u32; 3]>) {
let points = vec![
Point3::new(0.0, 0.0, 0.0),
Point3::new(1.0, 0.0, 0.0),
Point3::new(0.0, 1.0, 0.0),
Point3::new(1.0, 1.0, 0.0),
];
let faces = vec![tri(0, 1, 2), tri(1, 3, 2)];
(points, faces)
}
#[test]
fn a_clean_mesh_is_left_alone() {
let (points, faces) = square();
let out = repair_buffers(&points, &faces, &RepairOpts::default()).unwrap();
assert!(out.report.is_clean(), "report was {}", out.report);
assert_eq!(out.points, points);
assert_eq!(out.faces, faces);
}
#[test]
fn a_face_referencing_a_missing_point_is_an_error() {
let (points, _) = square();
let faces = vec![tri(0, 1, 9)];
assert!(repair_buffers(&points, &faces, &RepairOpts::default()).is_err());
}
#[test]
fn degenerate_faces_are_dropped() {
let (mut points, mut faces) = square();
points.push(Point3::new(2.0, 0.0, 0.0));
points.push(Point3::new(3.0, 0.0, 0.0));
points.push(Point3::new(4.0, 0.0, 0.0));
faces.push(tri(0, 1, 1));
faces.push(tri(4, 5, 6));
let out = repair_buffers(&points, &faces, &RepairOpts::default()).unwrap();
assert_eq!(out.report.degenerate_removed, 2);
assert_eq!(out.faces.len(), 2);
}
#[test]
fn duplicate_faces_are_dropped_in_either_winding() {
let (points, mut faces) = square();
faces.push(tri(0, 1, 2)); faces.push(tri(0, 2, 1));
let out = repair_buffers(&points, &faces, &RepairOpts::default()).unwrap();
assert_eq!(out.report.duplicate_faces_removed, 2);
assert_eq!(out.faces.len(), 2);
}
#[test]
fn a_nonmanifold_edge_keeps_the_two_best_faces() {
let mut points = vec![
Point3::new(0.0, 0.0, 0.0),
Point3::new(1.0, 0.0, 0.0),
Point3::new(0.5, 1.0, 0.0),
Point3::new(0.5, -1.0, 0.0),
];
points.push(Point3::new(0.5, 0.001, 0.0));
let faces = vec![tri(0, 1, 2), tri(1, 0, 3), tri(0, 1, 4)];
let out = repair_buffers(&points, &faces, &RepairOpts::default()).unwrap();
assert_eq!(out.report.nonmanifold_edges, 1);
assert_eq!(out.report.faces_dropped_at_nonmanifold, 1);
assert_eq!(out.faces.len(), 2);
assert_eq!(out.report.isolated_vertices_removed, 1);
assert_eq!(out.points.len(), 4);
}
#[test]
fn a_bowtie_vertex_is_split() {
let points = vec![
Point3::new(0.0, 0.0, 0.0), Point3::new(-1.0, 1.0, 0.0),
Point3::new(-1.0, -1.0, 0.0),
Point3::new(1.0, 1.0, 0.0),
Point3::new(1.0, -1.0, 0.0),
];
let faces = vec![tri(0, 1, 2), tri(0, 4, 3)];
let out = repair_buffers(&points, &faces, &RepairOpts::default()).unwrap();
assert_eq!(out.report.bowtie_vertices_split, 1);
assert_eq!(out.report.points_added_by_splitting, 1);
assert_eq!(out.points.len(), 6);
assert_eq!(out.faces.len(), 2, "no face should have been dropped");
let apexes: Vec<_> = out
.points
.iter()
.filter(|p| (*p - Point3::new(0.0, 0.0, 0.0)).norm() < 1e-12)
.collect();
assert_eq!(apexes.len(), 2);
let a = out.faces[0];
let b = out.faces[1];
assert!(a.iter().all(|v| !b.contains(v)));
}
#[test]
fn a_normal_fan_is_not_split() {
let mut points = vec![Point3::new(0.0, 0.0, 0.0)];
for i in 0..6 {
let a = std::f64::consts::TAU * (i as f64) / 6.0;
points.push(Point3::new(a.cos(), a.sin(), 0.0));
}
let faces: Vec<_> = (0..6).map(|i| tri(0, 1 + i, 1 + (i + 1) % 6)).collect();
let out = repair_buffers(&points, &faces, &RepairOpts::default()).unwrap();
assert_eq!(out.report.bowtie_vertices_split, 0);
assert_eq!(out.points.len(), 7);
}
#[test]
fn inconsistent_winding_is_corrected() {
let (points, mut faces) = square();
faces[1].swap(1, 2);
let out = repair_buffers(&points, &faces, &RepairOpts::default()).unwrap();
assert_eq!(out.report.faces_reoriented, 1);
assert_eq!(out.report.nonorientable_components, 0);
assert_eq!(out.faces, square().1);
}
#[test]
fn a_wholly_reversed_component_is_left_alone() {
let (points, faces) = square();
let reversed: Vec<_> = faces
.iter()
.map(|f| {
let mut g = *f;
g.swap(1, 2);
g
})
.collect();
let out = repair_buffers(&points, &reversed, &RepairOpts::default()).unwrap();
assert_eq!(out.report.faces_reoriented, 0);
assert_eq!(out.faces, reversed);
}
#[test]
fn isolated_vertices_are_dropped_and_faces_reindexed() {
let (mut points, faces) = square();
points.insert(0, Point3::new(9.0, 9.0, 9.0));
let shifted: Vec<_> = faces
.iter()
.map(|f| tri(f[0] + 1, f[1] + 1, f[2] + 1))
.collect();
let out = repair_buffers(&points, &shifted, &RepairOpts::default()).unwrap();
assert_eq!(out.report.isolated_vertices_removed, 1);
assert_eq!(out.points.len(), 4);
assert_eq!(out.faces, faces);
}
#[test]
fn opts_can_turn_a_pass_off() {
let (points, mut faces) = square();
faces.push(tri(0, 2, 1));
let opts = RepairOpts::default().with_drop_duplicate_faces(false);
let out = repair_buffers(&points, &faces, &opts).unwrap();
assert_eq!(out.report.duplicate_faces_removed, 0);
}
#[test]
fn none_opts_change_nothing() {
let (points, mut faces) = square();
faces.push(tri(0, 1, 1));
let out = repair_buffers(&points, &faces, &RepairOpts::none()).unwrap();
assert!(out.report.is_clean());
assert_eq!(out.faces.len(), 3);
}
#[test]
fn ingest_accepts_what_try_from_rejects() {
let points = vec![
Point3::new(0.0, 0.0, 0.0),
Point3::new(1.0, 0.0, 0.0),
Point3::new(0.5, 1.0, 0.0),
Point3::new(0.5, -1.0, 0.0),
Point3::new(0.5, 0.0, 1.0),
];
let faces = vec![tri(0, 1, 2), tri(1, 0, 3), tri(0, 1, 4)];
let mesh = Mesh3::new(points, faces, false);
assert!(
HalfEdgeMesh3::try_from(&mesh).is_err(),
"three faces on one edge should be refused by the strict path"
);
let (he, report) =
HalfEdgeMesh3::from_mesh_repaired(&mesh, &RepairOpts::default()).unwrap();
assert_eq!(report.nonmanifold_edges, 1);
assert_eq!(report.faces_rejected_by_ingest, 0);
assert_eq!(he.clone_faces().unwrap().len(), 2);
}
#[test]
fn a_fold_is_resolved_by_dropping_a_face() {
let points = vec![
Point3::new(0.0, 0.0, 0.0),
Point3::new(1.0, 0.0, 0.0),
Point3::new(0.5, 1.0, 0.0),
Point3::new(0.5, -1.0, 0.0),
];
let faces = vec![tri(0, 1, 2), tri(0, 1, 3)];
let mesh = Mesh3::new(points.clone(), faces.clone(), false);
assert!(HalfEdgeMesh3::try_from(&mesh).is_err());
let out = repair_buffers(&points, &faces, &RepairOpts::default()).unwrap();
assert_eq!(out.faces.len(), 2);
assert_eq!(out.report.faces_reoriented, 1);
assert_eq!(out.report.faces_dropped_for_orientation, 0);
let (_, report) = HalfEdgeMesh3::from_mesh_repaired(&mesh, &RepairOpts::default()).unwrap();
assert_eq!(report.faces_rejected_by_ingest, 0);
}
#[test]
fn the_bunny_fixture_is_repaired() {
let mesh = Mesh3::stanford_bunny_res4();
let out = repair_buffers(mesh.points(), mesh.faces(), &RepairOpts::default()).unwrap();
assert_eq!(out.report.duplicate_faces_removed, 40);
assert_eq!(out.report.nonmanifold_edges, 47);
assert_eq!(out.report.faces_dropped_at_nonmanifold, 40);
assert_eq!(out.report.bowtie_vertices_split, 15);
assert_eq!(out.report.isolated_vertices_removed, 5);
assert_eq!(out.faces.len(), 868);
assert_no_nonmanifold_edges(&out.faces);
assert_no_directed_collisions(&out.faces);
}
#[test]
fn the_bunnies_round_trip_through_the_half_edge_structure() {
for mesh in [
Mesh3::stanford_bunny_res4(),
Mesh3::stanford_bunny_res3(),
Mesh3::stanford_bunny_res2(),
] {
let repaired =
repair_buffers(mesh.points(), mesh.faces(), &RepairOpts::default()).unwrap();
let expected = repaired.faces.len();
let (he, report) =
HalfEdgeMesh3::from_mesh_repaired(&mesh, &RepairOpts::default()).unwrap();
assert_eq!(
report.faces_rejected_by_ingest, 0,
"every repaired face should have been accepted"
);
let back = Mesh3::try_from(&he).unwrap();
assert_eq!(back.faces().len(), expected);
}
}
#[test]
fn a_clean_fixture_is_untouched() {
let mesh = crate::tests::engine_blade();
let out = repair_buffers(mesh.points(), mesh.faces(), &RepairOpts::default()).unwrap();
assert!(out.report.is_clean(), "report was {}", out.report);
assert_eq!(out.faces.len(), mesh.faces().len());
assert_eq!(out.points.len(), mesh.points().len());
}
#[test]
fn the_bowtie_pass_is_load_bearing() {
let mesh = Mesh3::stanford_bunny_res4();
let without = RepairOpts::default().with_split_bowtie_vertices(false);
let (_, report) = HalfEdgeMesh3::from_mesh_repaired(&mesh, &without).unwrap();
assert_eq!(
report.faces_rejected_by_ingest, 13,
"without the split, alum should refuse these faces"
);
let (_, report) = HalfEdgeMesh3::from_mesh_repaired(&mesh, &RepairOpts::default()).unwrap();
assert_eq!(report.faces_rejected_by_ingest, 0);
}
fn assert_no_nonmanifold_edges(faces: &[[u32; 3]]) {
let map = edge_to_faces(faces);
let worst = map.values().map(|v| v.len()).max().unwrap_or(0);
assert!(worst <= 2, "an edge is still shared by {} faces", worst);
}
fn assert_no_directed_collisions(faces: &[[u32; 3]]) {
let mut directed: HashMap<[u32; 2], usize> = HashMap::with_hasher(default());
for face in faces.iter() {
for k in 0..3 {
*directed.entry([face[k], face[(k + 1) % 3]]).or_default() += 1;
}
}
let worst = directed.values().copied().max().unwrap_or(0);
assert!(worst <= 1, "a directed edge is still used {} times", worst);
}
#[test]
fn a_clean_report_displays_as_such() {
assert_eq!(
RepairReport::default().to_string(),
"mesh was already manifold, nothing changed"
);
let report = RepairReport {
duplicate_faces_removed: 3,
isolated_vertices_removed: 1,
..Default::default()
};
assert_eq!(
report.to_string(),
"3 duplicate faces removed, 1 isolated vertices removed"
);
}
}