multimodars 0.4.2__tar.gz → 0.4.3__tar.gz

{multimodars-0.4.2 → multimodars-0.4.3}/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.4.3] - 2026-06-04
+Small refactor based on cargo modules analysis (https://github.com/regexident/cargo-modules)
+
+### Changed
+- Moved downsample points to top layer module `types`
+- Renamed duplicate functions and names
+
 ## [0.4.2] - 2026-06-04
 Large internal refactor to improve readability and decouple modules. No behaviour change.
 

{multimodars-0.4.2 → multimodars-0.4.3}/Cargo.lock

@@ -665,7 +665,7 @@ dependencies = [
 
 [[package]]
 name = "multimodars"
-version = "0.4.2"
+version = "0.4.3"
 dependencies = [
  "anyhow",
  "approx",

{multimodars-0.4.2 → multimodars-0.4.3}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "multimodars"
-version = "0.4.2"
+version = "0.4.3"
 edition = "2021"
 license = "MIT"
 readme = "README.md"

{multimodars-0.4.2 → multimodars-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multimodars
-Version: 0.4.2
+Version: 0.4.3
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{multimodars-0.4.2 → multimodars-0.4.3}/src/ccta/adjust_mesh/scale_coronary.rs

@@ -2,12 +2,12 @@ use crate::types::native::{Centerline, CenterlinePoint, Frame};
 use rayon::prelude::*;
 use std::collections::HashSet;
 
-type Point3D = (f64, f64, f64);
+type Coords3 = (f64, f64, f64);
 
 pub fn centerline_based_wall_diameter_optimization(
     centerline: &Centerline,
-    ref_point_coronary: &Point3D,
-    aortic_points: &[Point3D],
+    ref_point_coronary: &Coords3,
+    aortic_points: &[Coords3],
 ) -> f64 {
     if centerline.points.is_empty() || aortic_points.is_empty() {
         return 0.0;
@@ -25,7 +25,7 @@ pub fn centerline_based_wall_diameter_optimization(
         None => return 0.0,
     };
 
-    let closest_aortic: &Point3D = match aortic_points.iter().min_by(|a, b| {
+    let closest_aortic: &Coords3 = match aortic_points.iter().min_by(|a, b| {
         let dist_a = super::calculate_squared_distance(*a, ref_point_coronary);
         let dist_b = super::calculate_squared_distance(*b, ref_point_coronary);
         dist_a
@@ -66,8 +66,8 @@ pub fn centerline_based_wall_diameter_optimization(
 }
 
 pub fn centerline_based_aortic_diameter_optimization(
-    intramural_points: &[Point3D],
-    reference_points: &[Point3D],
+    intramural_points: &[Coords3],
+    reference_points: &[Coords3],
     centerline: &Centerline,
 ) -> f64 {
     let start = -2.0f64;
@@ -91,12 +91,12 @@ pub fn centerline_based_aortic_diameter_optimization(
 }
 
 pub fn centerline_based_diameter_optimization(
-    anomalous_points: &[Point3D],
+    anomalous_points: &[Coords3],
     n_proximal: usize,
     n_distal: usize,
     centerline: &Centerline,
-    proximal_reference: &[Point3D],
-    distal_reference: &[Point3D],
+    proximal_reference: &[Coords3],
+    distal_reference: &[Coords3],
 ) -> (f64, f64) {
     let (proximal_points, anomalous_points_new) =
         find_region_points(anomalous_points, proximal_reference, n_proximal);
@@ -134,10 +134,10 @@ pub fn centerline_based_diameter_optimization(
 }
 
 fn find_region_points(
-    anomalous_points: &[Point3D],
-    reference_points: &[Point3D],
+    anomalous_points: &[Coords3],
+    reference_points: &[Coords3],
     n_points: usize,
-) -> (Vec<Point3D>, Vec<Point3D>) {
+) -> (Vec<Coords3>, Vec<Coords3>) {
     if anomalous_points.is_empty() || reference_points.is_empty() || n_points == 0 {
         return (Vec::new(), anomalous_points.to_vec());
     }
@@ -165,12 +165,12 @@ fn find_region_points(
 
     let selected_indices: HashSet<usize> = selected_slice.iter().map(|(i, _)| *i).collect();
 
-    let selected_points: Vec<Point3D> = selected_slice
+    let selected_points: Vec<Coords3> = selected_slice
         .iter()
         .map(|(i, _)| anomalous_points[*i])
         .collect();
 
-    let remaining_points: Vec<Point3D> = anomalous_points
+    let remaining_points: Vec<Coords3> = anomalous_points
         .iter()
         .enumerate()
         .filter_map(|(i, pt)| {
@@ -188,7 +188,7 @@ fn find_region_points(
 /// Symmetric average nearest-neighbor distance between two point sets.
 /// Returns sqrt of average squared distance for readability (i.e., RMS of nearest neighbor distances).
 /// If either set is empty returns f64::INFINITY.
-fn symmetric_nn_distance(a: &[Point3D], b: &[Point3D]) -> f64 {
+fn symmetric_nn_distance(a: &[Coords3], b: &[Coords3]) -> f64 {
     if a.is_empty() || b.is_empty() {
         return f64::INFINITY;
     }
@@ -220,9 +220,9 @@ fn symmetric_nn_distance(a: &[Point3D], b: &[Point3D]) -> f64 {
 
 pub fn centerline_based_diameter_morphing(
     centerline: &Centerline,
-    points: &[Point3D],
+    points: &[Coords3],
     diameter_adjustment_mm: f64,
-) -> Vec<Point3D> {
+) -> Vec<Coords3> {
     points
         .par_iter()
         .map(|point| {
@@ -257,7 +257,7 @@ pub fn centerline_based_diameter_morphing(
 
 fn find_closest_centerline_point_optimized(
     centerline: &Centerline,
-    point: Point3D,
+    point: Coords3,
 ) -> &CenterlinePoint {
     let mut min_distance_squared = f64::MAX;
     let mut closest_point = &centerline.points[0];
@@ -276,24 +276,24 @@ fn find_closest_centerline_point_optimized(
 pub fn find_points_by_cl_region_rs(
     centerline: &Centerline,
     frames: &[Frame],
-    points: &[Point3D],
-) -> (Vec<Point3D>, Vec<Point3D>, Vec<Point3D>) {
+    points: &[Coords3],
+) -> (Vec<Coords3>, Vec<Coords3>, Vec<Coords3>) {
     let mut cumulative_z_dist_frames = 0.0;
     for i in 1..frames.len() {
         cumulative_z_dist_frames += (frames[i].centroid.2 - frames[i - 1].centroid.2).abs();
     }
     cumulative_z_dist_frames /= (frames.len() - 1) as f64;
 
-    let centroids_to_match = frames.iter().map(|f| f.centroid).collect::<Vec<Point3D>>();
+    let centroids_to_match = frames.iter().map(|f| f.centroid).collect::<Vec<Coords3>>();
     let cl_points_indices: Vec<usize> =
         find_cl_points_in_range(centerline, &centroids_to_match, cumulative_z_dist_frames);
 
     // needed for proximal/distal classification
     let dist_ref = centroids_to_match[centroids_to_match.len() - 1];
 
-    let mut proximal_points: Vec<Point3D> = Vec::new();
-    let mut distal_points: Vec<Point3D> = Vec::new();
-    let mut points_between: Vec<Point3D> = Vec::new();
+    let mut proximal_points: Vec<Coords3> = Vec::new();
+    let mut distal_points: Vec<Coords3> = Vec::new();
+    let mut points_between: Vec<Coords3> = Vec::new();
 
     let mut remaining_points = points.to_vec();
 
@@ -327,7 +327,7 @@ pub fn find_points_by_cl_region_rs(
 
 fn find_cl_points_in_range(
     centerline: &Centerline,
-    points: &[Point3D],
+    points: &[Coords3],
     search_radius: f64,
 ) -> Vec<usize> {
     let mut selected_points = Vec::new();
@@ -355,11 +355,11 @@ fn find_cl_points_in_range(
 }
 
 pub fn clean_up_non_section_points(
-    points_to_cleanup: Vec<Point3D>,
-    reference_points: Vec<Point3D>,
+    points_to_cleanup: Vec<Coords3>,
+    reference_points: Vec<Coords3>,
     neighborhood_radius: f64,
     min_neigbor_ratio: f64,
-) -> (Vec<Point3D>, Vec<Point3D>) {
+) -> (Vec<Coords3>, Vec<Coords3>) {
     let neighborhood_radius_sq = neighborhood_radius * neighborhood_radius;
 
     let mut cleaned_points = Vec::new();

{multimodars-0.4.2 → multimodars-0.4.3}/src/intravascular/binding/entry.rs

@@ -4,7 +4,7 @@ use std::fs::File;
 use std::io::Write;
 use std::path::Path;
 
-use crate::intravascular::io::geometry::{Contour, ContourType, Geometry};
+use crate::intravascular::io::geometry::{ContourType, Geometry};
 use crate::intravascular::io::input::InputData;
 use crate::intravascular::io::output;
 use crate::intravascular::processing::align_between;
@@ -778,33 +778,9 @@ pub fn single_processing_rs(
     Ok((geom, logs))
 }
 
-/// Helper function to extract contours of a specific type from a geometry
-pub fn extract_contours_by_type(geometry: &Geometry, contour_type: ContourType) -> Vec<Contour> {
-    match contour_type {
-        ContourType::Lumen => geometry
-            .frames
-            .iter()
-            .map(|frame| frame.lumen.clone())
-            .collect(),
-        _ => geometry
-            .frames
-            .iter()
-            .filter_map(|frame| frame.extras.get(&contour_type).cloned())
-            .collect(),
-    }
-}
-
-/// Helper function to get contour type name for file naming
-pub fn get_contour_type_name(contour_type: ContourType) -> &'static str {
-    match contour_type {
-        ContourType::Lumen => "lumen",
-        ContourType::Eem => "eem",
-        ContourType::Calcification => "calcification",
-        ContourType::Sidebranch => "sidebranch",
-        ContourType::Catheter => "catheter",
-        ContourType::Wall => "wall",
-    }
-}
+pub use crate::intravascular::processing::process_utils::{
+    extract_contours_by_type, get_contour_type_name,
+};
 
 /// Helper function to create appropriate MTL file for each contour type
 pub fn create_mtl_for_contour_type(

{multimodars-0.4.2 → multimodars-0.4.3}/src/intravascular/centerline_align/align_algorithms.rs

@@ -2,9 +2,8 @@ use crate::intravascular::io::geometry::{Contour, Geometry};
 use crate::intravascular::io::input::ContourPoint;
 use crate::intravascular::io::input::{Centerline, CenterlinePoint};
 use crate::intravascular::processing::align_between::GeometryPair;
-use crate::intravascular::processing::process_utils::{
-    downsample_contour_points, hausdorff_distance,
-};
+use crate::intravascular::processing::process_utils::hausdorff_distance;
+use crate::types::native;
 use nalgebra::{Point3, Rotation3, Unit, Vector3};
 
 /// Allows alignment algorithms to operate on either a single [`Geometry`] or a [`GeometryPair`].
@@ -408,7 +407,8 @@ pub fn refine_alignment_hausdorff<T: AlignTarget>(
 
             for frame in frames.iter() {
                 if n_downsample < n_points_per_frame {
-                    let downsampled = downsample_contour_points(&frame.lumen.points, n_downsample);
+                    let downsampled =
+                        native::downsample_contour_points(&frame.lumen.points, n_downsample);
                     nested.push(downsampled);
                 } else {
                     nested.push(frame.lumen.points.clone());

{multimodars-0.4.2 → multimodars-0.4.3}/src/intravascular/processing/align_between.rs

@@ -3,9 +3,8 @@ use rayon::prelude::*;
 
 use crate::intravascular::io::geometry::Geometry;
 use crate::intravascular::io::input::ContourPoint;
-use crate::intravascular::processing::process_utils::{
-    downsample_contour_points, hausdorff_distance, search_range,
-};
+use crate::intravascular::processing::process_utils::{hausdorff_distance, search_range};
+use crate::types::native;
 
 pub use crate::types::native::GeometryPair;
 
@@ -163,7 +162,8 @@ fn extract_geometry_points_with_frame_info(
     let mut all_points = Vec::new();
     for frame in &geometry.frames {
         let frame_sample_size = (frame.lumen.points.len() as f64 * sample_ratio).ceil() as usize;
-        let sampled = downsample_contour_points(&frame.lumen.points, frame_sample_size.max(1));
+        let sampled =
+            native::downsample_contour_points(&frame.lumen.points, frame_sample_size.max(1));
 
         for point in sampled {
             all_points.push(PointWithFrameInfo {

{multimodars-0.4.2 → multimodars-0.4.3}/src/intravascular/processing/align_within.rs

@@ -5,9 +5,8 @@ use std::sync::{Arc, Mutex};
 use super::wall;
 use crate::intravascular::io::geometry::{Contour, ContourType, Frame, Geometry};
 use crate::intravascular::io::input::ContourPoint;
-use crate::intravascular::processing::process_utils::{
-    downsample_contour_points, hausdorff_distance, search_range,
-};
+use crate::intravascular::processing::process_utils::{hausdorff_distance, search_range};
+use crate::types::native;
 
 #[derive(Debug)]
 pub struct AlignLog {
@@ -170,10 +169,11 @@ fn catheter_lumen_vec_from_frames(
     sample_size_lumen: usize,
     sample_size_catheter: Option<usize>,
 ) -> Vec<ContourPoint> {
-    let mut lumen_points = downsample_contour_points(&frame.lumen.points, sample_size_lumen);
+    let mut lumen_points =
+        native::downsample_contour_points(&frame.lumen.points, sample_size_lumen);
     let mut catheter_points = if let Some(sample_size_catheter) = sample_size_catheter {
         if let Some(catheter_contour) = frame.extras.get(&ContourType::Catheter) {
-            downsample_contour_points(&catheter_contour.points, sample_size_catheter)
+            native::downsample_contour_points(&catheter_contour.points, sample_size_catheter)
         } else {
             Vec::new()
         }
@@ -562,13 +562,7 @@ fn interp_point(
     }
 }
 
-fn interpolate_contour(
-    c1: &Contour,
-    c2: &Contour,
-    t: f64,
-    id: u32,
-    original_frame: u32,
-) -> Contour {
+fn fill_frame_gap(c1: &Contour, c2: &Contour, t: f64, id: u32, original_frame: u32) -> Contour {
     let len = c1.points.len().min(c2.points.len());
     let points: Vec<ContourPoint> = (0..len)
         .map(|i| interp_point(&c1.points[i], &c2.points[i], t, original_frame, i as u32))
@@ -601,7 +595,7 @@ fn create_interpolated_frame(frame_1: &Frame, frame_2: &Frame, t: f64) -> Frame
         frame_1.centroid.2 + (frame_2.centroid.2 - frame_1.centroid.2) * t,
     );
 
-    let lumen = interpolate_contour(
+    let lumen = fill_frame_gap(
         &frame_1.lumen,
         &frame_2.lumen,
         t,
@@ -616,10 +610,7 @@ fn create_interpolated_frame(frame_1: &Frame, frame_2: &Frame, t: f64) -> Frame
         }
         match (frame_1.extras.get(key), frame_2.extras.get(key)) {
             (Some(c1), Some(c2)) => {
-                extras.insert(
-                    *key,
-                    interpolate_contour(c1, c2, t, c2.id, c2.original_frame),
-                );
+                extras.insert(*key, fill_frame_gap(c1, c2, t, c2.id, c2.original_frame));
             }
             (Some(c1), None) => {
                 extras.insert(*key, c1.clone());

{multimodars-0.4.2 → multimodars-0.4.3}/src/intravascular/processing/postprocessing.rs

@@ -226,7 +226,7 @@ fn new_frames_by_sample_rate(geometry: &Geometry, mut z_coords: Vec<f64>) -> Geo
         let t = (z_coord - lower.centroid.2) / (upper.centroid.2 - lower.centroid.2);
 
         // Interpolate lumen contour
-        let new_lumen = interpolate_contour(&lower.lumen, &upper.lumen, t);
+        let new_lumen = blend_contour(&lower.lumen, &upper.lumen, t);
 
         // Interpolate extra contours
         let mut new_extras = HashMap::new();
@@ -241,7 +241,7 @@ fn new_frames_by_sample_rate(geometry: &Geometry, mut z_coords: Vec<f64>) -> Geo
         {
             if let (Some(l_extra), Some(u_extra)) = (lower.extras.get(kind), upper.extras.get(kind))
             {
-                new_extras.insert(*kind, interpolate_contour(l_extra, u_extra, t));
+                new_extras.insert(*kind, blend_contour(l_extra, u_extra, t));
             }
         }
 
@@ -297,7 +297,7 @@ fn new_frames_by_sample_rate(geometry: &Geometry, mut z_coords: Vec<f64>) -> Geo
     }
 }
 
-fn interpolate_contour(c1: &Contour, c2: &Contour, t: f64) -> Contour {
+fn blend_contour(c1: &Contour, c2: &Contour, t: f64) -> Contour {
     let new_points: Vec<ContourPoint> = c1
         .points
         .iter()
@@ -716,7 +716,7 @@ mod tests {
     }
 
     #[test]
-    fn test_interpolate_contour() {
+    fn test_blend_contour() {
         let contour1 = create_test_contour(0, 0.0, None, ContourType::Lumen);
         let mut contour2 = create_test_contour(1, 2.0, None, ContourType::Lumen);
 
@@ -726,7 +726,7 @@ mod tests {
         contour2.points[1].x = 7.0;
         contour2.points[1].y = 8.0;
 
-        let interpolated = interpolate_contour(&contour1, &contour2, 0.5);
+        let interpolated = blend_contour(&contour1, &contour2, 0.5);
 
         // Points should be interpolated - using the correct calculation
         // p1.x = 1.0, p2.x = 5.0, t=0.5 → 1.0 + 0.5*(5.0-1.0) = 3.0

{multimodars-0.4.2 → multimodars-0.4.3}/src/intravascular/processing/process_utils.rs

@@ -1,20 +1,35 @@
+use crate::intravascular::io::geometry::{Contour, ContourType, Geometry};
 use crate::intravascular::io::input::ContourPoint;
 use rayon::prelude::*;
 use std::f64::consts::PI;
 
-pub fn downsample_contour_points(points: &[ContourPoint], n: usize) -> Vec<ContourPoint> {
-    if points.len() <= n {
-        return points.to_vec();
+pub fn extract_contours_by_type(geometry: &Geometry, contour_type: ContourType) -> Vec<Contour> {
+    match contour_type {
+        ContourType::Lumen => geometry
+            .frames
+            .iter()
+            .map(|frame| frame.lumen.clone())
+            .collect(),
+        _ => geometry
+            .frames
+            .iter()
+            .filter_map(|frame| frame.extras.get(&contour_type).cloned())
+            .collect(),
     }
-    let step = points.len() as f64 / n as f64;
-    (0..n)
-        .map(|i| {
-            let index = (i as f64 * step) as usize;
-            points[index]
-        })
-        .collect()
 }
 
+pub fn get_contour_type_name(contour_type: ContourType) -> &'static str {
+    match contour_type {
+        ContourType::Lumen => "lumen",
+        ContourType::Eem => "eem",
+        ContourType::Calcification => "calcification",
+        ContourType::Sidebranch => "sidebranch",
+        ContourType::Catheter => "catheter",
+        ContourType::Wall => "wall",
+    }
+}
+
+
 pub fn search_range<F>(
     cost_fn: F,
     step_deg: f64,
@@ -110,72 +125,8 @@ fn directed_hausdorff(contour_a: &[ContourPoint], contour_b: &[ContourPoint]) ->
 #[cfg(test)]
 mod process_utils_tests {
     use super::*;
-    use crate::intravascular::utils::test_utils::dummy_geometry;
     use approx::assert_relative_eq;
 
-    #[test]
-    fn test_downsample_geometry() {
-        let dummy = dummy_geometry();
-        let cont_points = dummy.frames[0].lumen.points.clone();
-        let downsampled_contour = downsample_contour_points(&cont_points, 3);
-
-        assert_eq!(downsampled_contour.len(), 3);
-        assert_eq!(downsampled_contour[0].point_index, 0);
-        assert_eq!(downsampled_contour[1].point_index, 2);
-
-        let downsampled_contour = downsample_contour_points(&cont_points, 6);
-
-        assert_eq!(downsampled_contour.len(), 6);
-        assert_eq!(downsampled_contour[0].point_index, 0);
-        assert_eq!(downsampled_contour[1].point_index, 1);
-
-        let downsampled_contour = downsample_contour_points(&cont_points, 5);
-        let n = downsampled_contour.len();
-        assert_eq!(downsampled_contour[n - 1].point_index, 4);
-    }
-
-    // tests from here are AI generated!!
-    #[test]
-    fn test_downsample_edge_cases() {
-        let points = vec![
-            ContourPoint {
-                frame_index: 1,
-                point_index: 0,
-                x: 1.0,
-                y: 2.0,
-                z: 0.0,
-                aortic: false,
-            },
-            ContourPoint {
-                frame_index: 1,
-                point_index: 1,
-                x: 3.0,
-                y: 4.0,
-                z: 0.0,
-                aortic: false,
-            },
-        ];
-
-        // Test n > points.len()
-        let result = downsample_contour_points(&points, 5);
-        assert_eq!(result.len(), 2);
-        assert_eq!(result[0].point_index, 0);
-        assert_eq!(result[1].point_index, 1);
-
-        // Test n == points.len()
-        let result = downsample_contour_points(&points, 2);
-        assert_eq!(result.len(), 2);
-
-        // Test n == 0
-        let result = downsample_contour_points(&points, 0);
-        assert_eq!(result.len(), 0);
-
-        // Test empty input
-        let empty: Vec<ContourPoint> = Vec::new();
-        let result = downsample_contour_points(&empty, 3);
-        assert_eq!(result.len(), 0);
-    }
-
     #[test]
     fn test_search_range_quadratic_function() {
         // Test with a simple quadratic cost function: (angle - 0.5)^2

{multimodars-0.4.2 → multimodars-0.4.3}/src/intravascular/to_object/write_mtl.rs

@@ -3,6 +3,9 @@ use super::texture::{
     create_displacement_texture, create_transparent_texture,
 };
 use crate::intravascular::io::geometry::{Contour, ContourType, Geometry};
+use crate::intravascular::processing::process_utils::{
+    extract_contours_by_type, get_contour_type_name,
+};
 use ::std::fs::File;
 use ::std::io::Write;
 use std::collections::HashMap;
@@ -246,22 +249,6 @@ fn write_transparent_texture(
     uv_coords
 }
 
-/// Extracts contours of a specific type from a geometry
-fn extract_contours_by_type(geometry: &Geometry, contour_type: ContourType) -> Vec<Contour> {
-    match contour_type {
-        ContourType::Lumen => geometry
-            .frames
-            .iter()
-            .map(|frame| frame.lumen.clone())
-            .collect(),
-        _ => geometry
-            .frames
-            .iter()
-            .filter_map(|frame| frame.extras.get(&contour_type).cloned())
-            .collect(),
-    }
-}
-
 /// Computes displacements between two sets of contours (alternative implementation)
 /// This is used for max displacement calculation since the texture.rs version only works on Geometry
 fn compute_displacements_for_contours(reference: &[Contour], target: &[Contour]) -> Vec<f64> {
@@ -283,15 +270,3 @@ fn compute_displacements_for_contours(reference: &[Contour], target: &[Contour])
         })
         .collect()
 }
-
-/// Gets the string name for a contour type for file naming
-fn get_contour_type_name(contour_type: ContourType) -> &'static str {
-    match contour_type {
-        ContourType::Lumen => "lumen",
-        ContourType::Eem => "eem",
-        ContourType::Calcification => "calcification",
-        ContourType::Sidebranch => "sidebranch",
-        ContourType::Catheter => "catheter",
-        ContourType::Wall => "wall",
-    }
-}

{multimodars-0.4.2 → multimodars-0.4.3}/src/types/binding/py_geometry.rs

@@ -1,8 +1,7 @@
 use super::py_contour::{PyContour, PyContourType};
 use super::py_contour_point::PyContourPoint;
 use super::py_frame::PyFrame;
-use crate::intravascular::processing::process_utils;
-use crate::types::native::{ContourPoint, ContourType, Geometry};
+use crate::types::native::{self as native, ContourPoint, ContourType, Geometry};
 use pyo3::prelude::*;
 
 type GeomSummary = (f64, f64, f64);
@@ -400,7 +399,7 @@ impl PyGeometry {
         let downsample_contour = |contour: &PyContour| -> PyContour {
             let rust_points: Vec<ContourPoint> =
                 contour.points.iter().map(ContourPoint::from).collect();
-            let downsampled = process_utils::downsample_contour_points(&rust_points, n_points);
+            let downsampled = native::downsample_contour_points(&rust_points, n_points);
             PyContour {
                 points: downsampled.iter().map(PyContourPoint::from).collect(),
                 ..contour.clone()