multimodars 0.4.0__tar.gz → 0.4.2__tar.gz

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

@@ -3,11 +3,26 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.4.2] - 2026-06-04
+Large internal refactor to improve readability and decouple modules. No behaviour change.
+
+### Changed
+- All native types and Python bindings extracted from scattered files into a unified `src/types/native/` and
+  `src/types/binding/` module. 
+- Several large files split into focused submodules (`binding/classes.rs` removed, `io/geometry.rs`, `centerline_align.rs`, `to_object.rs` split).
+- `Point3D` trait added and shared across `ContourPoint`, `CenterlinePoint`, and `(f64, f64, f64)`, simplified some functions with this. 
+
+## [0.4.1] - 2026-06-02
+
+### Changed
+- Rust `use` declarations now follow the idiomatic convention of importing the parent module for
+  functions (e.g. `use crate::ccta::discretizing;` -> `discretizing::discretize_vessel_rs(...)`)
+  and importing types/structs/enums directly.  No behaviour change; purely internal style cleanup
+  across 14 source files.
+
 ## [0.4.0] - 2026-05-25
-This version introduces backwards compatibility breaking changes.
 
 ### Added
-
 **Vessel-tree discretization pipeline**
 
 - `prepare_centerlines(rca_cl, lca_cl, results_dict, branch_sigma, control_plot)`: one-call
@@ -47,7 +62,6 @@ the style of `label_geometry`'s control plot and working correctly in all enviro
 - `plot_results_key`, `compare_centerline_scaling`: migrated from Plotly to trimesh.
 
 ### Changed
-
 **Alignment reference point naming** (`align_three_point`, `align_combined`, `align_manual`)
 
 The three landmark parameters have been renamed for anatomical clarity:

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

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

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

@@ -1,6 +1,6 @@
 [package]
 name = "multimodars"
-version = "0.4.0"
+version = "0.4.2"
 edition = "2021"
 license = "MIT"
 readme = "README.md"
@@ -15,7 +15,7 @@ csv = "1.4.0"
 serde = { version = "1.0.228", features = ["derive"]}
 image = "0.25.10"
 nalgebra = "0.35.0"
-toml = "1.1.2+spec-1.1.0"
+toml = "1.1.2"
 rayon = "1.12.0"
 crossbeam = "0.8.4"
 anyhow = "1.0.102"

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

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

{multimodars-0.4.0 → multimodars-0.4.2}/src/ccta/adjust_mesh/label_coronary.rs

@@ -1,5 +1,4 @@
-use super::calculate_squared_distance;
-use crate::intravascular::io::input::{Centerline, CenterlinePoint};
+use crate::types::native::{Centerline, CenterlinePoint};
 use rayon::prelude::*;
 use std::collections::HashSet;
 
@@ -178,9 +177,9 @@ pub fn remove_occluded_points_ray_triangle_rust(
 }
 
 fn point_to_triangle_distance(point: &(f64, f64, f64), triangle: &Triangle) -> f64 {
-    let dist_v0 = calculate_squared_distance(point, &triangle.v0);
-    let dist_v1 = calculate_squared_distance(point, &triangle.v1);
-    let dist_v2 = calculate_squared_distance(point, &triangle.v2);
+    let dist_v0 = super::calculate_squared_distance(point, &triangle.v0);
+    let dist_v1 = super::calculate_squared_distance(point, &triangle.v1);
+    let dist_v2 = super::calculate_squared_distance(point, &triangle.v2);
 
     dist_v0.min(dist_v1).min(dist_v2)
 }
@@ -299,7 +298,7 @@ fn find_points_inside_of_sphere(sphere: &BoundingSphere, point: &(f64, f64, f64)
 #[cfg(test)]
 mod test_find_cl_bounded_points {
     use super::*;
-    use crate::intravascular::io::input::ContourPoint;
+    use crate::types::native::ContourPoint;
 
     #[test]
     fn test_find_points_simple_geometry() {

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

@@ -1,6 +1,4 @@
-use super::calculate_squared_distance;
-use crate::intravascular::io::geometry::Frame;
-use crate::intravascular::io::input::{Centerline, CenterlinePoint};
+use crate::types::native::{Centerline, CenterlinePoint, Frame};
 use rayon::prelude::*;
 use std::collections::HashSet;
 
@@ -17,8 +15,8 @@ pub fn centerline_based_wall_diameter_optimization(
 
     // find closest centerline point
     let closest_cl = match centerline.points.iter().min_by(|a, b| {
-        let dist_a = calculate_squared_distance(*a, ref_point_coronary);
-        let dist_b = calculate_squared_distance(*b, ref_point_coronary);
+        let dist_a = super::calculate_squared_distance(*a, ref_point_coronary);
+        let dist_b = super::calculate_squared_distance(*b, ref_point_coronary);
         dist_a
             .partial_cmp(&dist_b)
             .unwrap_or(std::cmp::Ordering::Equal)
@@ -28,8 +26,8 @@ pub fn centerline_based_wall_diameter_optimization(
     };
 
     let closest_aortic: &Point3D = match aortic_points.iter().min_by(|a, b| {
-        let dist_a = calculate_squared_distance(*a, ref_point_coronary);
-        let dist_b = calculate_squared_distance(*b, ref_point_coronary);
+        let dist_a = super::calculate_squared_distance(*a, ref_point_coronary);
+        let dist_b = super::calculate_squared_distance(*b, ref_point_coronary);
         dist_a
             .partial_cmp(&dist_b)
             .unwrap_or(std::cmp::Ordering::Equal)
@@ -150,7 +148,7 @@ fn find_region_points(
         .map(|(i, a_pt)| {
             let min_sq = reference_points
                 .iter()
-                .map(|r_pt| calculate_squared_distance(a_pt, r_pt))
+                .map(|r_pt| super::calculate_squared_distance(a_pt, r_pt))
                 .fold(f64::INFINITY, |m, v| if v < m { v } else { m });
             (i, min_sq)
         })
@@ -199,7 +197,7 @@ fn symmetric_nn_distance(a: &[Point3D], b: &[Point3D]) -> f64 {
         .par_iter()
         .map(|pa| {
             b.iter()
-                .map(|pb| calculate_squared_distance(pa, pb))
+                .map(|pb| super::calculate_squared_distance(pa, pb))
                 .fold(f64::INFINITY, |m, v| if v < m { v } else { m })
         })
         .sum();
@@ -210,7 +208,7 @@ fn symmetric_nn_distance(a: &[Point3D], b: &[Point3D]) -> f64 {
         .par_iter()
         .map(|pb| {
             a.iter()
-                .map(|pa| calculate_squared_distance(pb, pa))
+                .map(|pa| super::calculate_squared_distance(pb, pa))
                 .fold(f64::INFINITY, |m, v| if v < m { v } else { m })
         })
         .sum();
@@ -265,7 +263,7 @@ fn find_closest_centerline_point_optimized(
     let mut closest_point = &centerline.points[0];
 
     for centerline_point in &centerline.points {
-        let distance_squared = calculate_squared_distance(&point, centerline_point);
+        let distance_squared = super::calculate_squared_distance(&point, centerline_point);
         if distance_squared < min_distance_squared {
             min_distance_squared = distance_squared;
             closest_point = centerline_point;
@@ -419,7 +417,7 @@ pub fn clean_up_non_section_points(
 
 #[cfg(test)]
 mod tests {
-    use crate::intravascular::io::input::{CenterlinePoint, ContourPoint};
+    use crate::types::native::{CenterlinePoint, ContourPoint};
     use nalgebra::Vector3;
 
     use super::*;

multimodars-0.4.2/src/ccta/adjust_mesh.rs

@@ -0,0 +1,12 @@
+pub mod label_coronary;
+pub mod scale_coronary;
+use crate::types::native::Point3D;
+
+/// Squared Euclidean distance between any two [`Point3D`] values.
+/// Use the squared form to avoid a `sqrt` when only ordering matters.
+pub(super) fn calculate_squared_distance<A: Point3D, B: Point3D>(a: &A, b: &B) -> f64 {
+    let dx = a.x() - b.x();
+    let dy = a.y() - b.y();
+    let dz = a.z() - b.z();
+    dx * dx + dy * dy + dz * dz
+}

{multimodars-0.4.0 → multimodars-0.4.2}/src/ccta/binding/ccta_py.rs

@@ -1,177 +1,16 @@
-// src/ccta/binding/label_py.rs
+// src/ccta/binding/ccta_py.rs
 use std::collections::{HashMap, HashSet};
 
-use crate::ccta::adjust_mesh::label_coronary::find_centerline_bounded_points;
-use crate::ccta::adjust_mesh::label_coronary::{
-    remove_occluded_points_ray_triangle_rust, Triangle,
-};
-use crate::ccta::adjust_mesh::scale_coronary::{
-    centerline_based_aortic_diameter_optimization, centerline_based_diameter_morphing,
-    centerline_based_diameter_optimization, centerline_based_wall_diameter_optimization,
-    clean_up_non_section_points, find_points_by_cl_region_rs,
-};
-use crate::ccta::discretizing::discretize_vessel_rs;
-use crate::ccta::discretizing::vessel_tree::DiscretizedVesselTree;
-use crate::intravascular::binding::classes::{PyCenterline, PyContour, PyFrame};
+use crate::ccta::adjust_mesh::label_coronary;
+use crate::ccta::adjust_mesh::label_coronary::Triangle;
+use crate::ccta::adjust_mesh::scale_coronary;
+use crate::ccta::discretizing;
+use crate::types::binding::{PyCenterline, PyContour, PyDiscretizedVesselTree, PyFrame};
+use crate::types::native::DiscretizedVesselTree;
 use pyo3::prelude::*;
 
 type Point3D = (f64, f64, f64);
 type TriangleTuple = (Point3D, Point3D, Point3D);
-/// (main_ref, clock_ref, counter_clock_ref) — all three as plain xyz tuples.
-type RefTriplet = (Point3D, Point3D, Point3D);
-
-// ─── PyDiscretizedVesselTree ──────────────────────────────────────────────────
-
-/// Fully discretized coronary vessel tree (aorta + RCA + LCA + side branches).
-///
-/// Attributes
-/// ----------
-/// discretized_aorta : list of PyContour
-///     Cross-sectional contours along the aortic centerline.
-/// discretized_rca_main : list of PyContour
-///     Cross-sectional contours along the RCA main vessel.
-/// discretized_lca_main : list of PyContour
-///     Cross-sectional contours along the LCA main vessel.
-/// rca_branches : list of list of PyContour
-///     Per-side-branch contour lists for the RCA.  ``rca_branches[i]``
-///     corresponds to RCA branch_id ``i + 1``.
-/// lca_branches : list of list of PyContour
-///     Per-side-branch contour lists for the LCA.
-/// rca_references : list of tuple
-///     Orientation triplets ``(main_ref, clock_ref, counter_clock_ref)`` along
-///     the RCA, sorted proximal → distal.  Each element is a 3-tuple of
-///     ``(x, y, z)`` coordinate tuples.
-/// lca_references : list of tuple
-///     Same structure for the LCA.
-/// ao_rca : tuple of float
-///     Centroid ``(x, y, z)`` of the aorta slice closest to the RCA ostium.
-/// ao_lca : tuple of float
-///     Centroid ``(x, y, z)`` of the aorta slice closest to the LCA ostium.
-#[pyclass(skip_from_py_object)]
-#[derive(Debug, Clone)]
-pub struct PyDiscretizedVesselTree {
-    #[pyo3(get, set)]
-    pub discretized_aorta: Vec<PyContour>,
-    #[pyo3(get, set)]
-    pub discretized_rca_main: Vec<PyContour>,
-    #[pyo3(get, set)]
-    pub discretized_lca_main: Vec<PyContour>,
-    #[pyo3(get, set)]
-    pub rca_branches: Vec<Vec<PyContour>>,
-    #[pyo3(get, set)]
-    pub lca_branches: Vec<Vec<PyContour>>,
-    #[pyo3(get)]
-    pub rca_references: Vec<RefTriplet>,
-    #[pyo3(get)]
-    pub lca_references: Vec<RefTriplet>,
-    #[pyo3(get, set)]
-    pub ao_rca: Point3D,
-    #[pyo3(get, set)]
-    pub ao_lca: Point3D,
-}
-
-#[pymethods]
-impl PyDiscretizedVesselTree {
-    fn __repr__(&self) -> String {
-        format!(
-            "DiscretizedVesselTree(ao={}, rca_main={}, lca_main={}, rca_branches={}, lca_branches={}, rca_refs={}, lca_refs={})",
-            self.discretized_aorta.len(),
-            self.discretized_rca_main.len(),
-            self.discretized_lca_main.len(),
-            self.rca_branches.len(),
-            self.lca_branches.len(),
-            self.rca_references.len(),
-            self.lca_references.len(),
-        )
-    }
-
-    /// Recompute orientation reference triplets and aortic ostium centroids
-    /// from the current contour data.
-    ///
-    /// Call this after replacing contours (e.g. with B-spline fits) so that
-    /// ``rca_references``, ``lca_references``, ``ao_rca``, and ``ao_lca``
-    /// reflect the updated geometry.
-    pub fn calculate_ref_pts(&mut self) -> PyResult<()> {
-        let convert =
-            |contours: &[PyContour]| -> PyResult<Vec<crate::intravascular::io::geometry::Contour>> {
-                contours.iter().map(|c| c.to_rust_contour()).collect()
-            };
-
-        let rust_aorta = convert(&self.discretized_aorta)?;
-        let rust_rca = convert(&self.discretized_rca_main)?;
-        let rust_lca = convert(&self.discretized_lca_main)?;
-        let rust_rca_branches: PyResult<Vec<Vec<_>>> =
-            self.rca_branches.iter().map(|b| convert(b)).collect();
-        let rust_lca_branches: PyResult<Vec<Vec<_>>> =
-            self.lca_branches.iter().map(|b| convert(b)).collect();
-
-        let tree = DiscretizedVesselTree {
-            discretized_aorta: rust_aorta,
-            discretized_rca_main: rust_rca,
-            discretized_lca_main: rust_lca,
-            rca_branches: rust_rca_branches?,
-            lca_branches: rust_lca_branches?,
-            spacing: 1.0,
-            rca_references: vec![],
-            lca_references: vec![],
-            ao_rca: (0.0, 0.0, 0.0),
-            ao_lca: (0.0, 0.0, 0.0),
-            pts_cusp_rcc: None,
-            pts_cusp_lcc: None,
-            pts_cusp_acc: None,
-            index_stj_slice: None,
-            index_aa: None,
-        };
-
-        let updated = tree.calculate_ref_pts();
-        self.rca_references = updated
-            .rca_references
-            .into_iter()
-            .map(|r| (r.main_ref, r.clock_ref, r.counter_clock_ref))
-            .collect();
-        self.lca_references = updated
-            .lca_references
-            .into_iter()
-            .map(|r| (r.main_ref, r.clock_ref, r.counter_clock_ref))
-            .collect();
-        self.ao_rca = updated.ao_rca;
-        self.ao_lca = updated.ao_lca;
-
-        Ok(())
-    }
-}
-
-impl From<DiscretizedVesselTree> for PyDiscretizedVesselTree {
-    fn from(t: DiscretizedVesselTree) -> Self {
-        Self {
-            discretized_aorta: t.discretized_aorta.iter().map(PyContour::from).collect(),
-            discretized_rca_main: t.discretized_rca_main.iter().map(PyContour::from).collect(),
-            discretized_lca_main: t.discretized_lca_main.iter().map(PyContour::from).collect(),
-            rca_branches: t
-                .rca_branches
-                .iter()
-                .map(|b| b.iter().map(PyContour::from).collect())
-                .collect(),
-            lca_branches: t
-                .lca_branches
-                .iter()
-                .map(|b| b.iter().map(PyContour::from).collect())
-                .collect(),
-            rca_references: t
-                .rca_references
-                .into_iter()
-                .map(|r| (r.main_ref, r.clock_ref, r.counter_clock_ref))
-                .collect(),
-            lca_references: t
-                .lca_references
-                .into_iter()
-                .map(|r| (r.main_ref, r.clock_ref, r.counter_clock_ref))
-                .collect(),
-            ao_rca: t.ao_rca,
-            ao_lca: t.ao_lca,
-        }
-    }
-}
 
 /// Find points bounded by spheres along a coronary vessel centerline.
 ///
@@ -211,7 +50,8 @@ pub fn find_centerline_bounded_points_simple(
     let rust_centerline = centerline.to_rust_centerline();
 
     // Call Rust function directly - no complex conversions needed
-    let result_points = find_centerline_bounded_points(rust_centerline, &points, radius);
+    let result_points =
+        label_coronary::find_centerline_bounded_points(rust_centerline, &points, radius);
 
     Ok(result_points)
 }
@@ -257,7 +97,7 @@ pub fn remove_occluded_points_ray_triangle(
         .map(|(v0, v1, v2)| Triangle::new(v0, v1, v2))
         .collect();
 
-    let result = remove_occluded_points_ray_triangle_rust(
+    let result = label_coronary::remove_occluded_points_ray_triangle_rust(
         &rust_centerline_coronary,
         &rust_centerline_aorta,
         range_coronary,
@@ -291,8 +131,11 @@ pub fn adjust_diameter_centerline_morphing_simple(
 ) -> PyResult<Vec<Point3D>> {
     let rust_centerline = centerline.to_rust_centerline();
 
-    let result_points =
-        centerline_based_diameter_morphing(&rust_centerline, &points, diameter_adjustment_mm);
+    let result_points = scale_coronary::centerline_based_diameter_morphing(
+        &rust_centerline,
+        &points,
+        diameter_adjustment_mm,
+    );
 
     Ok(result_points)
 }
@@ -332,7 +175,8 @@ pub fn find_points_by_cl_region(
         .map(|f| f.to_rust_frame())
         .collect::<Result<_, _>>()?;
 
-    let result_points = find_points_by_cl_region_rs(&rust_centerline, &rust_frames, &points);
+    let result_points =
+        scale_coronary::find_points_by_cl_region_rs(&rust_centerline, &rust_frames, &points);
 
     Ok(result_points)
 }
@@ -367,7 +211,7 @@ pub fn clean_outlier_points(
     neighborhood_radius: f64,
     min_neigbor_ratio: f64,
 ) -> PyResult<(Vec<Point3D>, Vec<Point3D>)> {
-    let result_points = clean_up_non_section_points(
+    let result_points = scale_coronary::clean_up_non_section_points(
         points_to_cleanup,
         reference_points,
         neighborhood_radius,
@@ -414,7 +258,7 @@ pub fn find_proximal_distal_scaling(
     distal_reference: Vec<Point3D>,
 ) -> PyResult<(f64, f64)> {
     let rust_centerline = centerline.to_rust_centerline();
-    let (prox_dist, distal_dist) = centerline_based_diameter_optimization(
+    let (prox_dist, distal_dist) = scale_coronary::centerline_based_diameter_optimization(
         &anomalous_points,
         n_proximal,
         n_distal,
@@ -451,7 +295,7 @@ pub fn find_aortic_scaling(
     centerline: PyCenterline,
 ) -> PyResult<f64> {
     let rust_centerline = centerline.to_rust_centerline();
-    let dist = centerline_based_aortic_diameter_optimization(
+    let dist = scale_coronary::centerline_based_aortic_diameter_optimization(
         &intramural_points,
         &reference_points,
         &rust_centerline,
@@ -490,7 +334,7 @@ pub fn find_aortic_wall_scaling(
     aortic_pts: Vec<Point3D>,
 ) -> PyResult<f64> {
     let rust_centerline = cl_aorta.to_rust_centerline();
-    let dist = centerline_based_wall_diameter_optimization(
+    let dist = scale_coronary::centerline_based_wall_diameter_optimization(
         &rust_centerline,
         &ref_pt_coronary,
         &aortic_pts,
@@ -586,7 +430,13 @@ pub fn discretize_vessel(
     n_points: usize,
 ) -> PyResult<Vec<PyContour>> {
     let rust_centerline = centerline.to_rust_centerline();
-    let contours = discretize_vessel_rs(&rust_centerline, &points, branch_id, step_size, n_points);
+    let contours = discretizing::discretize_vessel_rs(
+        &rust_centerline,
+        &points,
+        branch_id,
+        step_size,
+        n_points,
+    );
     Ok(contours.iter().map(PyContour::from).collect())
 }
 

{multimodars-0.4.0 → multimodars-0.4.2}/src/ccta/discretizing/projecting.rs

@@ -1,5 +1,4 @@
-use crate::intravascular::io::geometry::{Contour, ContourType};
-use crate::intravascular::io::input::{Centerline, CenterlinePoint, ContourPoint};
+use crate::types::native::{Centerline, CenterlinePoint, Contour, ContourPoint, ContourType};
 use nalgebra::Vector3;
 
 /// Walks branch `branch_id` at uniform arc-length steps of `step_size`, assigns each mesh point
@@ -206,7 +205,7 @@ fn interpolate_branch_at_s(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::intravascular::io::input::{Centerline, CenterlinePoint, ContourPoint};
+    use crate::types::native::{Centerline, CenterlinePoint, ContourPoint};
     use nalgebra::Vector3;
 
     fn cp(idx: u32, x: f64, y: f64, z: f64) -> ContourPoint {

{multimodars-0.4.0 → multimodars-0.4.2}/src/ccta/discretizing/resampling.rs

@@ -1,5 +1,4 @@
-use crate::intravascular::io::geometry::Contour;
-use crate::intravascular::io::input::ContourPoint;
+use crate::types::native::{Contour, ContourPoint};
 use nalgebra::Vector3;
 
 /// Filters and resamples raw projected slices from `walk_centerline_slices`:
@@ -230,8 +229,7 @@ fn catmull_rom(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::intravascular::io::geometry::{Contour, ContourType};
-    use crate::intravascular::io::input::ContourPoint;
+    use crate::types::native::{Contour, ContourPoint, ContourType};
 
     fn make_point(x: f64, y: f64, z: f64) -> ContourPoint {
         ContourPoint {

{multimodars-0.4.0 → multimodars-0.4.2}/src/ccta/discretizing/utils.rs

@@ -1,4 +1,4 @@
-use crate::intravascular::io::input::{Centerline, CenterlinePoint, ContourPoint};
+use crate::types::native::{Centerline, CenterlinePoint, ContourPoint};
 use nalgebra::Vector3;
 
 /// Smooths centerline positions with a Gaussian kernel (per branch) and recomputes normals.
@@ -149,7 +149,7 @@ pub fn smooth_centerline(centerline: &Centerline, sigma: f64) -> Centerline {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::intravascular::io::input::ContourPoint;
+    use crate::types::native::ContourPoint;
 
     fn make_centerline(pts: &[(f64, f64, f64)]) -> Centerline {
         let contour_pts: Vec<ContourPoint> = pts

multimodars-0.4.2/src/ccta/discretizing/vessel_tree.rs

@@ -0,0 +1,82 @@
+use crate::types::native::{Centerline, Contour, DiscretizedVesselTree};
+use anyhow::Result;
+
+impl DiscretizedVesselTree {
+    /// Discretize the full vessel tree from pre-labelled point sets.
+    ///
+    /// Smooths all three centerlines with a Gaussian (σ = 2.5 points) before
+    /// discretizing, then processes:
+    /// - aorta (branch 0)
+    /// - RCA main vessel (`branch_id_rca`, usually 0)
+    /// - LCA main vessel (`branch_id_lca`, usually 0)
+    /// - every RCA side branch: `side_branches_rca[i]` → branch_id `i + 1`
+    /// - every LCA side branch: `side_branches_lca[i]` → branch_id `i + 1`
+    ///
+    /// `side_branches_rca` / `side_branches_lca` come from `label_branches` results:
+    /// `results["rca_points_side_1"]`, `results["rca_points_side_2"]`, …, in order.
+    pub fn from_results_dict(
+        ao_cl: &Centerline,
+        rca_cl: &Centerline,
+        lca_cl: &Centerline,
+        points_ao: &[(f64, f64, f64)],
+        points_rca_main: &[(f64, f64, f64)],
+        points_lca_main: &[(f64, f64, f64)],
+        side_branches_rca: Vec<Vec<(f64, f64, f64)>>,
+        side_branches_lca: Vec<Vec<(f64, f64, f64)>>,
+        branch_id_rca: u32,
+        branch_id_lca: u32,
+        step_size: f64,
+        n_points: usize,
+    ) -> Result<DiscretizedVesselTree> {
+        let discretized_aorta =
+            super::discretize_vessel_rs(ao_cl, points_ao, 0, step_size, n_points);
+        let discretized_rca_main = super::discretize_vessel_rs(
+            rca_cl,
+            points_rca_main,
+            branch_id_rca,
+            step_size,
+            n_points,
+        );
+        let discretized_lca_main = super::discretize_vessel_rs(
+            lca_cl,
+            points_lca_main,
+            branch_id_lca,
+            step_size,
+            n_points,
+        );
+
+        let rca_branches: Vec<Vec<Contour>> = side_branches_rca
+            .iter()
+            .enumerate()
+            .map(|(i, pts)| {
+                super::discretize_vessel_rs(rca_cl, pts, (i + 1) as u32, step_size, n_points)
+            })
+            .collect();
+
+        let lca_branches: Vec<Vec<Contour>> = side_branches_lca
+            .iter()
+            .enumerate()
+            .map(|(i, pts)| {
+                super::discretize_vessel_rs(lca_cl, pts, (i + 1) as u32, step_size, n_points)
+            })
+            .collect();
+
+        Ok(DiscretizedVesselTree {
+            discretized_aorta,
+            discretized_rca_main,
+            discretized_lca_main,
+            spacing: step_size,
+            rca_branches,
+            lca_branches,
+            rca_references: vec![],
+            lca_references: vec![],
+            ao_lca: (0.0, 0.0, 0.0),
+            ao_rca: (0.0, 0.0, 0.0),
+            pts_cusp_rcc: None,
+            pts_cusp_lcc: None,
+            pts_cusp_acc: None,
+            index_stj_slice: None,
+            index_aa: None,
+        })
+    }
+}

multimodars-0.4.0/src/ccta/discretizing/mod.rs → multimodars-0.4.2/src/ccta/discretizing.rs

@@ -3,10 +3,7 @@ pub mod resampling;
 mod utils;
 pub mod vessel_tree;
 
-use crate::ccta::discretizing::projecting::walk_centerline_slices;
-use crate::ccta::discretizing::resampling::create_uniform_contours;
-use crate::intravascular::io::geometry::Contour;
-use crate::intravascular::io::input::Centerline;
+use crate::types::native::{Centerline, Contour};
 
 /// Walk `branch_id` of `centerline` at uniform `step_size` intervals, project the supplied
 /// mesh `points` onto each perpendicular cross-section, filter incomplete slices, and
@@ -21,6 +18,6 @@ pub fn discretize_vessel_rs(
     const SMOOTH_SIGMA: f64 = 2.5;
 
     let cl_smooth = utils::smooth_centerline(centerline, SMOOTH_SIGMA);
-    let raw = walk_centerline_slices(&cl_smooth, points, branch_id, step_size);
-    create_uniform_contours(raw, n_points)
+    let raw = projecting::walk_centerline_slices(&cl_smooth, points, branch_id, step_size);
+    resampling::create_uniform_contours(raw, n_points)
 }

{multimodars-0.4.0 → multimodars-0.4.2}/src/intravascular/binding/align.rs

@@ -1,7 +1,7 @@
-use crate::intravascular::{
-    binding::classes::{PyCenterline, PyContourType, PyGeometry, PyGeometryPair},
-    centerline_align::{align_combined_rs, align_manual_rs, align_three_point_rs},
+use crate::intravascular::centerline_align::{
+    align_combined_rs, align_manual_rs, align_three_point_rs,
 };
+use crate::types::binding::{PyCenterline, PyContourType, PyGeometry, PyGeometryPair};
 use pyo3::prelude::*;
 
 /// Align a geometry (or geometry pair) to the centerline using three reference points.