Small refactoring

Author: w1th0utnam3

pysplashsurf/src/pipeline.rs

@@ -10,7 +10,6 @@ use pyo3::{
     prelude::*,
     types::{PyDict, PyString},
 };
-use splashsurf::PipelineResult;
 use splashsurf_lib::{
     Aabb3d, GridDecompositionParameters, Index, Real, SpatialDecomposition,
     mesh::{AttributeData, MeshAttribute},
@@ -54,7 +53,7 @@ fn reconstruction_pipeline_generic<I: Index, R: Real>(
     mesh_aabb_min: Option<[f64; 3]>,
     mesh_aabb_max: Option<[f64; 3]>,
     mesh_aabb_clamp_vertices: bool,
-) -> Result<PipelineResult<I, R>, anyhow::Error> {
+) -> Result<splashsurf::reconstruct::ReconstructionResult<I, R>, anyhow::Error> {
     let aabb = if let (Some(aabb_min), Some(aabb_max)) = (aabb_min, aabb_max) {
         // Convert the min and max arrays to Vector3
         Some(Aabb3d::new(
@@ -65,15 +64,13 @@ fn reconstruction_pipeline_generic<I: Index, R: Real>(
         None
     };
 
-    let spatial_decomposition = if use_custom_grid_decomposition {
+    let spatial_decomposition = use_custom_grid_decomposition.then(|| {
         let mut grid_params = GridDecompositionParameters::default();
         grid_params.subdomain_num_cubes_per_dim = subdomain_num_cubes_per_dim;
-        Some(SpatialDecomposition::UniformGrid(grid_params))
-    } else {
-        None
-    };
+        SpatialDecomposition::UniformGrid(grid_params)
+    });
 
-    let params: splashsurf_lib::Parameters<R> = splashsurf_lib::Parameters {
+    let params = splashsurf_lib::Parameters {
         particle_radius,
         rest_density,
         compact_support_radius: R::from_f64(2.0).unwrap() * smoothing_length * particle_radius,
@@ -96,35 +93,34 @@ fn reconstruction_pipeline_generic<I: Index, R: Real>(
             None
         };
 
-    let postprocessing_args: splashsurf::ReconstructionRunnerPostprocessingArgs =
-        splashsurf::ReconstructionRunnerPostprocessingArgs {
-            check_mesh_closed,
-            check_mesh_manifold,
-            check_mesh_orientation,
-            check_mesh_debug,
-            mesh_cleanup,
-            mesh_cleanup_snap_dist: max_rel_snap_dist,
-            decimate_barnacles,
-            keep_vertices,
-            compute_normals,
-            sph_normals,
-            normals_smoothing_iters,
-            interpolate_attributes: Vec::new(),
-            mesh_smoothing_iters,
-            mesh_smoothing_weights,
-            mesh_smoothing_weights_normalization,
-            generate_quads,
-            quad_max_edge_diag_ratio,
-            quad_max_normal_angle,
-            quad_max_interior_angle,
-            output_mesh_smoothing_weights,
-            output_raw_normals,
-            output_raw_mesh,
-            mesh_aabb,
-            mesh_aabb_clamp_vertices,
-        };
+    let postprocessing_args = splashsurf::reconstruct::ReconstructionPostprocessingParameters {
+        check_mesh_closed,
+        check_mesh_manifold,
+        check_mesh_orientation,
+        check_mesh_debug,
+        mesh_cleanup,
+        mesh_cleanup_snap_dist: max_rel_snap_dist,
+        decimate_barnacles,
+        keep_vertices,
+        compute_normals,
+        sph_normals,
+        normals_smoothing_iters,
+        interpolate_attributes: Vec::new(),
+        mesh_smoothing_iters,
+        mesh_smoothing_weights,
+        mesh_smoothing_weights_normalization,
+        generate_quads,
+        quad_max_edge_diag_ratio,
+        quad_max_normal_angle,
+        quad_max_interior_angle,
+        output_mesh_smoothing_weights,
+        output_raw_normals,
+        output_raw_mesh,
+        mesh_aabb,
+        mesh_aabb_clamp_vertices,
+    };
 
-    splashsurf::reconstruction_pipeline(
+    splashsurf::reconstruct::reconstruction_pipeline(
         particle_positions,
         attributes,
         &params,
@@ -227,19 +223,19 @@ pub fn reconstruction_pipeline_py_f32<'py>(
     mesh_aabb_min: Option<[f64; 3]>,
     mesh_aabb_max: Option<[f64; 3]>,
     mesh_aabb_clamp_vertices: bool,
-) -> (
+) -> PyResult<(
     Option<TriMeshWithDataF32>,
     Option<MixedTriQuadMeshWithDataF32>,
     Option<SurfaceReconstructionF32>,
-) {
-    let particles: PyReadonlyArray2<f32> = particles.extract().unwrap();
+)> {
+    let particles: PyReadonlyArray2<f32> = particles.extract()?;
 
-    let particle_positions = particles.as_slice().unwrap();
+    let particle_positions = particles.as_slice()?;
     let particle_positions: &[Vector3<f32>] = bytemuck::cast_slice(particle_positions);
 
     let attrs = attrs_conversion(attributes_to_interpolate);
 
-    let PipelineResult {
+    let splashsurf::reconstruct::ReconstructionResult {
         tri_mesh,
         tri_quad_mesh,
         raw_reconstruction: reconstruction,
@@ -283,25 +279,11 @@ pub fn reconstruction_pipeline_py_f32<'py>(
     )
     .unwrap();
 
-    let tri_mesh = if let Some(tri_mesh) = tri_mesh {
-        Some(TriMeshWithDataF32::new(tri_mesh))
-    } else {
-        None
-    };
-
-    let tri_quad_mesh = if let Some(tri_quad_mesh) = tri_quad_mesh {
-        Some(MixedTriQuadMeshWithDataF32::new(tri_quad_mesh))
-    } else {
-        None
-    };
-
-    let reconstruction = if let Some(reconstruction) = reconstruction {
-        Some(SurfaceReconstructionF32::new(reconstruction))
-    } else {
-        None
-    };
-
-    (tri_mesh, tri_quad_mesh, reconstruction)
+    Ok((
+        tri_mesh.map(TriMeshWithDataF32::new),
+        tri_quad_mesh.map(MixedTriQuadMeshWithDataF32::new),
+        reconstruction.map(SurfaceReconstructionF32::new),
+    ))
 }
 
 #[pyfunction]
@@ -354,19 +336,19 @@ pub fn reconstruction_pipeline_py_f64<'py>(
     mesh_aabb_min: Option<[f64; 3]>,
     mesh_aabb_max: Option<[f64; 3]>,
     mesh_aabb_clamp_vertices: bool,
-) -> (
+) -> PyResult<(
     Option<TriMeshWithDataF64>,
     Option<MixedTriQuadMeshWithDataF64>,
     Option<SurfaceReconstructionF64>,
-) {
-    let particles: PyReadonlyArray2<f64> = particles.extract().unwrap();
+)> {
+    let particles: PyReadonlyArray2<f64> = particles.extract()?;
 
-    let particle_positions = particles.as_slice().unwrap();
+    let particle_positions = particles.as_slice()?;
     let particle_positions: &[Vector3<f64>] = bytemuck::cast_slice(particle_positions);
 
     let attrs = attrs_conversion(attributes_to_interpolate);
 
-    let PipelineResult {
+    let splashsurf::reconstruct::ReconstructionResult {
         tri_mesh,
         tri_quad_mesh,
         raw_reconstruction: reconstruction,
@@ -410,23 +392,9 @@ pub fn reconstruction_pipeline_py_f64<'py>(
     )
     .unwrap();
 
-    let tri_mesh = if let Some(tri_mesh) = tri_mesh {
-        Some(TriMeshWithDataF64::new(tri_mesh))
-    } else {
-        None
-    };
-
-    let tri_quad_mesh = if let Some(tri_quad_mesh) = tri_quad_mesh {
-        Some(MixedTriQuadMeshWithDataF64::new(tri_quad_mesh))
-    } else {
-        None
-    };
-
-    let reconstruction = if let Some(reconstruction) = reconstruction {
-        Some(SurfaceReconstructionF64::new(reconstruction))
-    } else {
-        None
-    };
-
-    (tri_mesh, tri_quad_mesh, reconstruction)
+    Ok((
+        tri_mesh.map(TriMeshWithDataF64::new),
+        tri_quad_mesh.map(MixedTriQuadMeshWithDataF64::new),
+        reconstruction.map(SurfaceReconstructionF64::new),
+    ))
 }

splashsurf/src/cli.rs

@@ -82,7 +82,9 @@ impl Switch {
 
 /// Runs the splashsurf CLI with the provided command line arguments.
 ///
-/// This function behaves like the binary `splashsurf` command line tool including output to stdout and stderr.
+/// This function behaves like the binary `splashsurf` command line tool including output to stdout
+/// and stderr. It will also exit the process depending on the command line arguments, so it should
+/// not be used in typical library contexts.
 /// Note that the first argument is always ignored - this is typically the binary name when called using
 /// `std::env::args()` from the terminal:
 /// ```

splashsurf/src/lib.rs

@@ -1,11 +1,26 @@
+//! Library target of the `splashsurf` CLI.
+//!
+//! To use the CLI you can install it via Cargo:
+//! ```bash
+//! cargo install splashsurf
+//! ```
+//! For documentation of the CLI see the [README](https://github.com/InteractiveComputerGraphics/splashsurf) in the project repository.
+//!
+//! This library target exposes some high-level functionality such as [running the CLI](cli) with a
+//! list of command line arguments or specifically running the [reconstruction pipeline](reconstruct)
+//! of the CLI (including a set of postprocessing steps) as a library function.
+//! This functionality is mainly used by the `pySplashsurf` Pythong bindings and the CLI binary
+//! target itself.
+//!
+//! If you only want to use a subset of this functionality (e.g. only the reconstruction itself,
+//! without any postprocessing) in your crates, please refer to the [`splashsurf_lib`] crate instead.
+
 pub mod cli;
 mod convert;
 mod io;
-mod reconstruct;
+pub mod reconstruct;
 #[macro_use]
 mod allocator;
 mod logging;
 
-pub use reconstruct::arguments::ReconstructionRunnerPostprocessingArgs;
-pub use reconstruct::{PipelineResult, reconstruction_pipeline};
 pub(crate) use register_counting_allocator;