Add argument to set distance limit for snapping in MC cleanup

Author: w1th0utnam3

splashsurf/src/reconstruction.rs

@@ -186,6 +186,12 @@ pub struct ReconstructSubcommandArgs {
         require_equals = true
     )]
     pub mesh_cleanup: Switch,
+    /// If MC mesh cleanup is enabled, vertex snapping can be limited to this distance relative to the MC edge length (should be in range of [0.0,0.5])
+    #[arg(
+        help_heading = ARGS_DECIMATE,
+        long,
+    )]
+    pub mesh_cleanup_snap_dist: Option<f64>,
     /// Enable decimation of some typical bad marching cubes triangle configurations (resulting in "barnacles" after Laplacian smoothing)
     #[arg(
         help_heading = ARGS_DECIMATE,
@@ -433,6 +439,7 @@ mod arguments {
         pub check_mesh_orientation: bool,
         pub check_mesh_debug: bool,
         pub mesh_cleanup: bool,
+        pub mesh_cleanup_snap_dist: Option<f64>,
         pub decimate_barnacles: bool,
         pub keep_vertices: bool,
         pub compute_normals: bool,
@@ -564,6 +571,7 @@ mod arguments {
                     || args.check_mesh_orientation.into_bool(),
                 check_mesh_debug: args.check_mesh_debug.into_bool(),
                 mesh_cleanup: args.mesh_cleanup.into_bool(),
+                mesh_cleanup_snap_dist: args.mesh_cleanup_snap_dist,
                 decimate_barnacles: args.decimate_barnacles.into_bool(),
                 keep_vertices: args.keep_verts.into_bool(),
                 compute_normals: args.normals.into_bool(),
@@ -971,6 +979,9 @@ pub(crate) fn reconstruction_pipeline_generic<I: Index, R: Real>(
             vertex_connectivity = Some(splashsurf_lib::postprocessing::marching_cubes_cleanup(
                 mesh_with_data.mesh.to_mut(),
                 reconstruction.grid(),
+                postprocessing
+                    .mesh_cleanup_snap_dist
+                    .map(|d| R::from_float(d)),
                 5,
                 postprocessing.keep_vertices,
             ));

splashsurf_lib/src/postprocessing.rs

@@ -87,12 +87,15 @@ pub fn par_laplacian_smoothing_normals_inplace<R: Real>(
 pub fn marching_cubes_cleanup<I: Index, R: Real>(
     mesh: &mut TriMesh3d<R>,
     grid: &UniformCartesianCubeGrid3d<I, R>,
+    max_rel_snap_distance: Option<R>,
     max_iter: usize,
     keep_vertices: bool,
 ) -> Vec<Vec<usize>> {
     profile!("marching_cubes_cleanup");
 
     let half_dx = grid.cell_size() / (R::one() + R::one());
+    let max_snap_distance_sq =
+        max_rel_snap_distance.map(|factor| (factor * grid.cell_size()).powi(2));
 
     let nearest_grid_point = {
         profile!("determine nearest grid points");
@@ -154,10 +157,35 @@ pub fn marching_cubes_cleanup<I: Index, R: Real>(
                     continue;
                 }
 
-                for he in mesh.outgoing_half_edges(v0) {
-                    let v1 = he.to;
-                    if nearest_grid_point[v0] == nearest_grid_point[v1] {
-                        vertex_buffer.push(v1);
+                let grid_point = grid
+                    .try_unflatten_point_index(nearest_grid_point[v0])
+                    .map(|p| grid.point_coordinates(&p));
+
+                if let Some(max_snap_distance_sq) = max_snap_distance_sq {
+                    if let Some(grid_point) = grid_point {
+                        // Check if this vertex is close enough to the grid vertex
+                        if (mesh.vertices[v0] - grid_point).norm_squared() <= max_snap_distance_sq {
+                            // Check for collapse with all neighbors
+                            for he in mesh.outgoing_half_edges(v0) {
+                                let v1 = he.to;
+                                if nearest_grid_point[v0] == nearest_grid_point[v1] {
+                                    // Ensure that other vertex is close enough to grid vertex
+                                    if (mesh.vertices[v1] - grid_point).norm_squared()
+                                        <= max_snap_distance_sq
+                                    {
+                                        vertex_buffer.push(v1);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    // Check for collapse with all neighbors
+                    for he in mesh.outgoing_half_edges(v0) {
+                        let v1 = he.to;
+                        if nearest_grid_point[v0] == nearest_grid_point[v1] {
+                            vertex_buffer.push(v1);
+                        }
                     }
                 }