Add tests for CLI pipeline functionality

Author: w1th0utnam3

Cargo.lock

@@ -27,3 +27,6 @@ lexical-sort = "0.3"
 indicatif = "0.18"
 parking_lot = "0.12"
 once_cell = "1.18"
+
+[dev-dependencies]
+all_asserts = "2.3.3"

splashsurf/Cargo.toml

@@ -0,0 +1,352 @@
+use splashsurf_lib::io::vtk_format;
+use splashsurf_lib::nalgebra::Vector3;
+use splashsurf_lib::{Aabb3d, GridDecompositionParameters, SpatialDecomposition};
+
+use all_asserts::assert_range;
+
+#[test]
+fn test_basic_pipeline() -> Result<(), Box<dyn std::error::Error>> {
+    let particles =
+        splashsurf_lib::io::particles_from_file("../data/bunny_frame_14_7705_particles.vtk")?;
+
+    let particle_radius = 0.025;
+    let mut params = splashsurf_lib::Parameters::new_relative(particle_radius, 4.0, 1.0);
+    params.spatial_decomposition = SpatialDecomposition::None;
+
+    let mut postprocessing = splashsurf::reconstruct::ReconstructionPostprocessingParameters::new();
+    postprocessing.output_raw_mesh = true;
+
+    let reconstruction = splashsurf::reconstruct::reconstruction_pipeline::<i64, _>(
+        &particles,
+        &[],
+        &params,
+        &postprocessing,
+    )?;
+    let mesh = &reconstruction
+        .tri_mesh
+        .as_ref()
+        .expect("reconstruction should produce a triangle mesh")
+        .mesh;
+    let raw_mesh = reconstruction
+        .raw_reconstruction
+        .as_ref()
+        .expect("raw surface should be present")
+        .mesh();
+    vtk_format::write_vtk(mesh, "../out/bunny_test_basic_pipeline.vtk", "mesh")?;
+
+    // Compare raw and final mesh
+    assert_eq!(
+        mesh.triangles.len(),
+        raw_mesh.triangles.len(),
+        "Number of triangles should match between raw and final mesh"
+    );
+    assert_eq!(
+        mesh.vertices.len(),
+        raw_mesh.vertices.len(),
+        "Number of vertices should match between raw and final mesh"
+    );
+    assert_eq!(
+        mesh.triangles, raw_mesh.triangles,
+        "Triangle indices should match between raw and final mesh"
+    );
+    // Check number of triangles and vertices
+    assert_range!(
+        (35000..40000),
+        raw_mesh.triangles.len(),
+        "Number of triangles should be in expected range"
+    );
+    assert_range!(
+        (15000..20000),
+        raw_mesh.vertices.len(),
+        "Number of vertices should be in expected range"
+    );
+    // Check manifoldness
+    let mesh_manifold_information = mesh.compute_manifold_information();
+    assert!(
+        mesh_manifold_information.is_closed(),
+        "Mesh should be closed"
+    );
+    assert!(
+        mesh_manifold_information.is_manifold(),
+        "Mesh should be manifold"
+    );
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(debug_assertions, ignore)]
+fn test_basic_pipeline_fine() -> Result<(), Box<dyn std::error::Error>> {
+    let particles =
+        splashsurf_lib::io::particles_from_file("../data/bunny_frame_14_7705_particles.vtk")?;
+
+    let particle_radius = 0.025;
+    let mut params = splashsurf_lib::Parameters::new_relative(particle_radius, 4.0, 0.2);
+    params.spatial_decomposition = SpatialDecomposition::UniformGrid(GridDecompositionParameters {
+        subdomain_num_cubes_per_dim: 48,
+        auto_disable: false,
+    });
+
+    let postprocessing = splashsurf::reconstruct::ReconstructionPostprocessingParameters::new();
+
+    let reconstruction = splashsurf::reconstruct::reconstruction_pipeline::<i64, _>(
+        &particles,
+        &[],
+        &params,
+        &postprocessing,
+    )?;
+    let mesh = &reconstruction
+        .tri_mesh
+        .as_ref()
+        .expect("reconstruction should produce a triangle mesh")
+        .mesh;
+    vtk_format::write_vtk(mesh, "../out/bunny_test_basic_pipeline_fine.vtk", "mesh")?;
+
+    assert_range!(
+        (920000..930000),
+        mesh.triangles.len(),
+        "Number of triangles should be in expected range"
+    );
+    assert_range!(
+        (455000..465000),
+        mesh.vertices.len(),
+        "Number of vertices should be in expected range"
+    );
+
+    let mesh_manifold_information = mesh.compute_manifold_information();
+    assert!(
+        mesh_manifold_information.is_closed(),
+        "Mesh should be closed"
+    );
+    assert!(
+        mesh_manifold_information.is_manifold(),
+        "Mesh should be manifold"
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_basic_pipeline_particle_aabb() -> Result<(), Box<dyn std::error::Error>> {
+    let particles =
+        splashsurf_lib::io::particles_from_file("../data/bunny_frame_14_7705_particles.vtk")?;
+    let particle_radius = 0.025;
+
+    let mut params = splashsurf_lib::Parameters::new_relative(particle_radius, 4.0, 1.0);
+    params.particle_aabb = Some(Aabb3d::new(
+        Vector3::new(-0.7, 0.6, -0.2),
+        Vector3::new(0.8, 2.1, 0.7),
+    ));
+
+    let postprocessing = splashsurf::reconstruct::ReconstructionPostprocessingParameters::new();
+
+    let reconstruction = splashsurf::reconstruct::reconstruction_pipeline::<i64, _>(
+        &particles,
+        &[],
+        &params,
+        &postprocessing,
+    )?;
+    let mesh = &reconstruction
+        .tri_mesh
+        .as_ref()
+        .expect("reconstruction should produce a triangle mesh")
+        .mesh;
+    vtk_format::write_vtk(
+        mesh,
+        "../out/bunny_test_basic_pipeline_particle_aabb.vtk",
+        "mesh",
+    )?;
+
+    assert_range!(
+        (19000..23000),
+        mesh.triangles.len(),
+        "Number of triangles should be in expected range"
+    );
+    assert_range!(
+        (9500..11500),
+        mesh.vertices.len(),
+        "Number of vertices should be in expected range"
+    );
+
+    let mesh_manifold_information = mesh.compute_manifold_information();
+    assert!(
+        mesh_manifold_information.is_closed(),
+        "Mesh should be closed"
+    );
+    assert!(
+        mesh_manifold_information.is_manifold(),
+        "Mesh should be manifold"
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_basic_pipeline_postprocessing() -> Result<(), Box<dyn std::error::Error>> {
+    let particles =
+        splashsurf_lib::io::particles_from_file("../data/bunny_frame_14_7705_particles.vtk")?;
+    let particle_radius = 0.025;
+
+    let params = splashsurf_lib::Parameters::new_relative(particle_radius, 4.0, 1.0);
+
+    let mut postprocessing = splashsurf::reconstruct::ReconstructionPostprocessingParameters::new();
+    postprocessing.mesh_cleanup = true;
+    postprocessing.mesh_smoothing_weights = true;
+    postprocessing.mesh_smoothing_iters = Some(5);
+    postprocessing.output_mesh_smoothing_weights = true;
+    postprocessing.output_raw_mesh = true;
+
+    let reconstruction = splashsurf::reconstruct::reconstruction_pipeline::<i64, _>(
+        &particles,
+        &[],
+        &params,
+        &postprocessing,
+    )?;
+    let mesh = &reconstruction
+        .tri_mesh
+        .as_ref()
+        .expect("reconstruction should produce a triangle mesh")
+        .mesh;
+    let raw_mesh = reconstruction
+        .raw_reconstruction
+        .as_ref()
+        .expect("raw surface should be present")
+        .mesh();
+    vtk_format::write_vtk(
+        mesh,
+        "../out/bunny_test_basic_pipeline_postprocessing.vtk",
+        "mesh",
+    )?;
+
+    assert_ne!(
+        mesh.triangles.len(),
+        raw_mesh.triangles.len(),
+        "Number of triangles should differ between raw and postprocessed mesh"
+    );
+    assert_ne!(
+        mesh.vertices.len(),
+        raw_mesh.vertices.len(),
+        "Number of vertices should differ between raw and postprocessed mesh"
+    );
+
+    assert_eq!(
+        reconstruction
+            .tri_mesh
+            .as_ref()
+            .unwrap()
+            .point_attributes
+            .len(),
+        2,
+        "There should be two point attributes (number of neighbors and smoothing weights)"
+    );
+
+    assert_range!(
+        (18000..22000),
+        mesh.triangles.len(),
+        "Number of triangles should be in expected range"
+    );
+    assert_range!(
+        (8000..12000),
+        mesh.vertices.len(),
+        "Number of vertices should be in expected range"
+    );
+
+    let mesh_manifold_information = mesh.compute_manifold_information();
+    assert!(
+        mesh_manifold_information.is_closed(),
+        "Mesh should be closed"
+    );
+    assert!(
+        mesh_manifold_information.is_manifold(),
+        "Mesh should be manifold"
+    );
+
+    Ok(())
+}
+
+#[test]
+fn test_basic_pipeline_postprocessing_with_aabb() -> Result<(), Box<dyn std::error::Error>> {
+    let particles =
+        splashsurf_lib::io::particles_from_file("../data/bunny_frame_14_7705_particles.vtk")?;
+    let particle_radius = 0.025;
+
+    let mut params = splashsurf_lib::Parameters::new_relative(particle_radius, 4.0, 1.0);
+    params.particle_aabb = Some(Aabb3d::new(
+        Vector3::new(-0.7, 0.6, -0.2),
+        Vector3::new(0.8, 2.1, 0.7),
+    ));
+
+    let mut postprocessing = splashsurf::reconstruct::ReconstructionPostprocessingParameters::new();
+    postprocessing.mesh_cleanup = true;
+    postprocessing.mesh_smoothing_weights = true;
+    postprocessing.mesh_smoothing_iters = Some(5);
+    postprocessing.output_mesh_smoothing_weights = true;
+    postprocessing.output_raw_mesh = true;
+
+    let reconstruction = splashsurf::reconstruct::reconstruction_pipeline::<i64, _>(
+        &particles,
+        &[],
+        &params,
+        &postprocessing,
+    )?;
+    let mesh = &reconstruction
+        .tri_mesh
+        .as_ref()
+        .expect("reconstruction should produce a triangle mesh")
+        .mesh;
+    let raw_mesh = reconstruction
+        .raw_reconstruction
+        .as_ref()
+        .expect("raw surface should be present")
+        .mesh();
+    vtk_format::write_vtk(
+        mesh,
+        "../out/bunny_test_basic_pipeline_postprocessing_aabb.vtk",
+        "mesh",
+    )?;
+
+    assert_ne!(
+        mesh.triangles.len(),
+        raw_mesh.triangles.len(),
+        "Number of triangles should differ between raw and postprocessed mesh"
+    );
+    assert_ne!(
+        mesh.vertices.len(),
+        raw_mesh.vertices.len(),
+        "Number of vertices should differ between raw and postprocessed mesh"
+    );
+
+    assert_eq!(
+        reconstruction
+            .tri_mesh
+            .as_ref()
+            .unwrap()
+            .point_attributes
+            .len(),
+        2,
+        "There should be two point attributes (number of neighbors and smoothing weights)"
+    );
+
+    assert_range!(
+        (11000..13000),
+        mesh.triangles.len(),
+        "Number of triangles should be in expected range"
+    );
+    assert_range!(
+        (5000..7000),
+        mesh.vertices.len(),
+        "Number of vertices should be in expected range"
+    );
+
+    let mesh_manifold_information = mesh.compute_manifold_information();
+    assert!(
+        mesh_manifold_information.is_closed(),
+        "Mesh should be closed"
+    );
+    assert!(
+        mesh_manifold_information.is_manifold(),
+        "Mesh should be manifold"
+    );
+
+    Ok(())
+}

splashsurf/tests/test_pipeline.rs

@@ -190,7 +190,7 @@ pub fn check_mesh_consistency<I: Index, R: Real>(
     }
 
     if check_manifold && !non_manifold_edges.is_empty() {
-        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()));
+        error_strings.push(format!("Mesh is not manifold. It has {} non-manifold edges (edges that are connected to more than two triangles).", non_manifold_edges.len()));
         if debug {
             for e in non_manifold_edges {
                 add_edge_errors(&mut error_strings, e);