kylc · kylc · Nov 3, 2025 · Nov 3, 2025
diff --git a/examples/main.rs b/examples/main.rs
@@ -3,10 +3,7 @@ use std::{env, path::PathBuf, time::Instant};
 use miniacd::{
     Config,
     io::{self, load_obj},
-    mesh::Mesh,
-    ops::{self},
 };
-use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 
 fn main() {
     let args: Vec<String> = env::args().collect();
@@ -31,11 +28,5 @@ fn main() {
     let tf = Instant::now();
     println!("main:\t{:.2}s", (tf - t0).as_secs_f64());
 
-    // PARALLEL: compute the output convex hulls in parallel.
-    let convex_meshes: Vec<Mesh> = components
-        .par_iter()
-        .map(|c| ops::convex_hull(&c.mesh))
-        .collect();
-
-    io::write_meshes_to_obj(&output_path, &convex_meshes).unwrap();
+    io::write_meshes_to_obj(&output_path, &components).unwrap();
 }
diff --git a/python/miniacd/cli.py b/python/miniacd/cli.py
@@ -88,7 +88,7 @@ def main(
 
     # Run the miniacd algorithm.
     mesh = miniacd.Mesh(input_mesh.vertices, input_mesh.faces)
-    parts = miniacd.run(
+    hulls = miniacd.run(
         mesh,
         threshold=threshold,
         mcts_depth=mcts_depth,
@@ -98,24 +98,21 @@ def main(
         print=True,
     )
 
-    # Convexify the output slices.
-    parts = [part.convex_hull() for part in parts]
-
     # Build Trimesh objects from the miniacd meshes.
-    output_parts = [
+    output_hulls = [
         trimesh.Trimesh(
-            part.vertices(), part.faces(), vertex_colors=random_rgb(), process=False
+            hull.vertices(), hull.faces(), vertex_colors=random_rgb(), process=False
         )
-        for part in parts
+        for hull in hulls
     ]
 
     # Output a single file of multiple objects or multiple files.
     output_path = Path(output_path)
     if output_split:
-        for i, part in enumerate(output_parts):
-            part.export(output_path.with_stem(output_path.stem + f"_{i}"))
+        for i, hull in enumerate(output_hulls):
+            hull.export(output_path.with_stem(output_path.stem + f"_{i}"))
     else:
-        trimesh.Scene(output_parts).export(output_path)
+        trimesh.Scene(output_hulls).export(output_path)
 
 
 if __name__ == "__main__":

diff --git a/src/lib.rs b/src/lib.rs
@@ -99,7 +99,7 @@ fn run_inner(input: Part, config: &Config, progress: &ProgressBar, prev_cost: f6
     components
 }
 
-pub fn run(input: Mesh, config: &Config) -> Vec<Part> {
+pub fn run(input: Mesh, config: &Config) -> Vec<Mesh> {
     let progress_bar = ProgressBar::new(1)
         .with_message("Slicing parts...")
         .with_style(
@@ -127,7 +127,7 @@ pub fn run(input: Mesh, config: &Config) -> Vec<Part> {
     // Unapply the transform so the outputs part positions match the input.
     output_parts
         .into_iter()
-        .map(|p| Part::from_mesh(Arc::unwrap_or_clone(p.mesh).transform(&normalization_tfm_inv)))
-        .filter(|p| !p.mesh.is_empty())
+        .map(|p| Arc::unwrap_or_clone(p.convex_hull).transform(&normalization_tfm_inv))
+        .filter(|m| !m.is_empty())
         .collect()
 }
diff --git a/src/py.rs b/src/py.rs
@@ -1,7 +1,5 @@
 #[pyo3::pymodule(name = "miniacd")]
 mod pyminiacd {
-    use std::sync::Arc;
-
     use nalgebra::Point3;
     use pyo3::prelude::*;
 
@@ -66,9 +64,6 @@ mod pyminiacd {
         };
 
         let components = crate::run(mesh.0.clone(), &config);
-        components
-            .into_iter()
-            .map(|c| PyMesh(Arc::unwrap_or_clone(c.mesh)))
-            .collect()
+        components.into_iter().map(PyMesh).collect()
     }
 }