Improve error output of mesh checks

Author: w1th0utnam3

splashsurf/src/reconstruction.rs

@@ -2,7 +2,7 @@ use crate::{io, logging};
 use anyhow::{anyhow, Context};
 use clap::value_parser;
 use indicatif::{ProgressBar, ProgressStyle};
-use log::info;
+use log::{error, info, warn};
 use rayon::prelude::*;
 use splashsurf_lib::mesh::{AttributeData, Mesh3d, MeshAttribute, MeshWithData};
 use splashsurf_lib::nalgebra::{Unit, Vector3};
@@ -897,6 +897,10 @@ pub(crate) fn reconstruction_pipeline_generic<I: Index, R: Real>(
 ) -> Result<(), anyhow::Error> {
     profile!("surface reconstruction");
 
+    let check_mesh = postprocessing.check_mesh_closed
+        || postprocessing.check_mesh_manifold
+        || postprocessing.check_mesh_debug;
+
     // Load particle positions and attributes to interpolate
     let (particle_positions, attributes) = io::read_particle_positions_with_attributes(
         &paths.input_file,
@@ -948,7 +952,6 @@ pub(crate) fn reconstruction_pipeline_generic<I: Index, R: Real>(
     // Perform post-processing
     {
         profile!("postprocessing");
-
         let mut vertex_connectivity = None;
 
         if postprocessing.mesh_cleanup {
@@ -1272,10 +1275,6 @@ pub(crate) fn reconstruction_pipeline_generic<I: Index, R: Real>(
     // Store the surface mesh
     {
         profile!("write surface mesh to file");
-        info!(
-            "Writing surface mesh to \"{}\"...",
-            paths.output_file.display()
-        );
 
         match (&tri_mesh, &tri_quad_mesh) {
             (Some(mesh), None) => {
@@ -1293,13 +1292,9 @@ pub(crate) fn reconstruction_pipeline_generic<I: Index, R: Real>(
                 paths.output_file.display()
             )
         })?;
-        info!("Done.");
     }
 
-    if postprocessing.check_mesh_closed
-        || postprocessing.check_mesh_manifold
-        || postprocessing.check_mesh_debug
-    {
+    if check_mesh {
         if let Err(err) = match (&tri_mesh, &tri_quad_mesh) {
             (Some(mesh), None) => splashsurf_lib::marching_cubes::check_mesh_consistency(
                 grid,
@@ -1314,7 +1309,11 @@ pub(crate) fn reconstruction_pipeline_generic<I: Index, R: Real>(
             }
             _ => unreachable!(),
         } {
-            return Err(anyhow!("{}", err));
+            error!("Checked mesh for problems (holes: {}, non-manifold edges/vertices: {}), problems were found!", postprocessing.check_mesh_closed, postprocessing.check_mesh_manifold);
+            error!("{}", err);
+            return Err(anyhow!("{}", err))
+                .context(format!("Checked mesh for problems (holes: {}, non-manifold edges/vertices: {}), problems were found!", postprocessing.check_mesh_closed, postprocessing.check_mesh_manifold))
+                .context(format!("Problem found with mesh file \"{}\"", paths.output_file.display()));
         } else {
             info!("Checked mesh for problems (holes: {}, non-manifold edges/vertices: {}), no problems were found.", postprocessing.check_mesh_closed, postprocessing.check_mesh_manifold);
         }

splashsurf_lib/src/marching_cubes.rs

@@ -155,7 +155,7 @@ pub fn check_mesh_consistency<I: Index, R: Real>(
         return Ok(());
     }
 
-    let add_edge_errors = |error_string: &mut String, edge: ([usize; 2], usize, usize)| {
+    let add_edge_errors = |error_strings: &mut Vec<String>, edge: ([usize; 2], usize, usize)| {
         let (edge, tri_idx, _) = edge;
 
         let v0 = mesh.vertices[edge[0]];
@@ -169,45 +169,46 @@ pub fn check_mesh_consistency<I: Index, R: Real>(
             let cell_center = grid.point_coordinates(&point_index)
                 + Vector3::repeat(grid.cell_size().times_f64(0.5));
 
-            *error_string += &format!("\n\tTriangle {}, boundary edge {:?} is located in cell with {:?} with center coordinates {:?} and edge length {}.", tri_idx, edge, cell_index, cell_center, grid.cell_size());
+            error_strings.push(format!("\n\tTriangle {}, boundary edge {:?} is located in cell with {:?} with center coordinates {:?} and edge length {}.", tri_idx, edge, cell_index, cell_center, grid.cell_size()));
         } else {
-            *error_string += &format!(
+            error_strings.push(format!(
                 "\n\tCannot get cell index for edge {:?} of triangle {}",
                 edge, tri_idx
-            );
+            ));
         }
     };
 
-    let mut error_string = String::new();
+    let mut error_strings = Vec::new();
 
     if check_closed && !boundary_edges.is_empty() {
-        error_string += &format!("Mesh is not closed. It has {} boundary edges (edges that are connected to only one triangle).", boundary_edges.len());
+        error_strings.push(format!("Mesh is not closed. It has {} boundary edges (edges that are connected to only one triangle).", boundary_edges.len()));
         if debug {
             for e in boundary_edges {
-                add_edge_errors(&mut error_string, e);
+                add_edge_errors(&mut error_strings, e);
             }
         }
-        error_string += "\n";
     }
 
     if check_manifold && !non_manifold_edges.is_empty() {
-        error_string += &format!("Mesh is not manifold. It has {} non-manifold edges (edges that are connected to more than twi triangles).", non_manifold_edges.len());
+        error_strings.push(format!("Mesh is not manifold. It has {} non-manifold edges (edges that are connected to more than twi triangles).", non_manifold_edges.len()));
         if debug {
             for e in non_manifold_edges {
-                add_edge_errors(&mut error_string, e);
+                add_edge_errors(&mut error_strings, e);
             }
         }
-        error_string += "\n";
     }
 
     if check_manifold && !non_manifold_vertices.is_empty() {
-        error_string += &format!("Mesh is not manifold. It has {} non-manifold vertices (vertices with more than one triangle fan).", non_manifold_vertices.len());
+        error_strings.push(format!("Mesh is not manifold. It has {} non-manifold vertices (vertices with more than one triangle fan).", non_manifold_vertices.len()));
         if debug {
-            error_string += &format!("\n\t{:?}", non_manifold_vertices);
+            error_strings.push(format!(
+                "\tNon-manifold vertices: {:?}",
+                non_manifold_vertices
+            ));
         }
-        error_string += "\n";
     }
 
+    let error_string = error_strings.join("\n");
     Err(error_string)
 }
 

splashsurf_lib/src/mesh.rs

@@ -991,9 +991,9 @@ impl<R: Real> TriMesh3d<R> {
     /// A non-manifold vertex is generated by pinching two surface sheets together at that vertex
     /// such that the vertex is incident to more than one fan of triangles.
     ///
-    /// Note: This function assumes that all edges in the mesh are manifold edges! If there are non-
-    ///  manifold edges, it is possible to connect two triangle fans using a third fan which is not
-    ///  detected by this function.
+    /// Note: This function assumes that all edges in the mesh are manifold edges! If there are
+    ///  non-manifold edges, it is possible to connect two triangle fans using a third fan which is
+    ///  not detected by this function.
     pub fn find_non_manifold_vertices(&self) -> Vec<usize> {
         let mut non_manifold_verts = Vec::new();
         let mut tri_fan = Vec::new();