cardio 2025.9.0__py3-none-any.whl → 2025.10.1__py3-none-any.whl

cardio/utils.py

@@ -2,9 +2,6 @@
 
 import enum
 
-import itk
-import numpy as np
-
 
 class InterpolatorType(enum.Enum):
     """Interpolation methods for image resampling."""
@@ -13,51 +10,11 @@ class InterpolatorType(enum.Enum):
     NEAREST = "nearest"
 
 
-def reset_direction(
-    image, interpolator_type: InterpolatorType = InterpolatorType.LINEAR
-):
-    """Reset image direction to identity matrix, preserving origin.
-
-    This function handles the VTK reader issue where origin is not retained
-    by using ITK to properly transform the image coordinates.
+class AngleUnit(enum.Enum):
+    """Units for angle measurements."""
 
-    Args:
-        image: ITK image object
-        interpolator_type: InterpolatorType enum for interpolation method
-    """
-    origin = np.asarray(itk.origin(image))
-    spacing = np.asarray(itk.spacing(image))
-    size = np.asarray(itk.size(image))
-    direction = np.asarray(image.GetDirection())
-
-    direction[direction == 1] = 0
-    origin += np.dot(size, np.dot(np.diag(spacing), direction))
-    direction = np.identity(3)
-
-    origin = itk.Point[itk.F, 3](origin)
-    spacing = itk.spacing(image)
-    size = itk.size(image)
-    direction = itk.matrix_from_array(direction)
-
-    # Select interpolator based on type
-    match interpolator_type:
-        case InterpolatorType.NEAREST:
-            interpolator = itk.NearestNeighborInterpolateImageFunction.New(image)
-        case InterpolatorType.LINEAR:
-            interpolator = itk.LinearInterpolateImageFunction.New(image)
-        case _:
-            raise ValueError(f"Unsupported interpolator type: {interpolator_type}")
-
-    output = itk.resample_image_filter(
-        image,
-        size=size,
-        interpolator=interpolator,
-        output_spacing=spacing,
-        output_origin=origin,
-        output_direction=direction,
-    )
-
-    return output
+    DEGREES = "degrees"
+    RADIANS = "radians"
 
 
 def calculate_combined_bounds(actors):

cardio/volume.py

@@ -6,45 +6,21 @@ import pydantic as pc
 import vtk
 
 from .object import Object
-from .utils import InterpolatorType, reset_direction
+from .orientation import (
+    EulerAxis,
+    axcode_transform_matrix,
+    create_vtk_reslice_matrix,
+    euler_angle_to_rotation_matrix,
+    reset_direction,
+)
 from .volume_property_presets import load_volume_property_preset
 
 
-def create_rotation_matrix(axis, angle_degrees):
-    """Create rotation matrix for given axis and angle."""
-    angle = np.radians(angle_degrees)
-    cos_a, sin_a = np.cos(angle), np.sin(angle)
-    if axis == "X":
-        return np.array([[1, 0, 0], [0, cos_a, -sin_a], [0, sin_a, cos_a]])
-    elif axis == "Y":
-        return np.array([[cos_a, 0, sin_a], [0, 1, 0], [-sin_a, 0, cos_a]])
-    elif axis == "Z":
-        return np.array([[cos_a, -sin_a, 0], [sin_a, cos_a, 0], [0, 0, 1]])
-    return np.eye(3)
-
-
-def create_reslice_matrix(normal, up, origin):
-    """Create a 4x4 reslice matrix from normal vector, up vector, and origin"""
-    normal = normal / np.linalg.norm(normal)
-    up = up / np.linalg.norm(up)
-    right = np.cross(normal, up)
-    right = right / np.linalg.norm(right)
-    up = np.cross(right, normal)
-    matrix = vtk.vtkMatrix4x4()
-    for i in range(3):
-        matrix.SetElement(i, 0, right[i])
-        matrix.SetElement(i, 1, up[i])
-        matrix.SetElement(i, 2, normal[i])
-        matrix.SetElement(i, 3, origin[i])
-    matrix.SetElement(3, 3, 1.0)
-    return matrix
-
-
 class Volume(Object):
     """Volume object with transfer functions and clipping support."""
 
     pattern: str = pc.Field(
-        default="${frame}.nii.gz",
+        default="{frame}.nii.gz",
         description="Filename pattern with $frame placeholder",
     )
     transfer_function_preset: str = pc.Field(
@@ -62,7 +38,7 @@ class Volume(Object):
             logging.info(f"{self.label}: Loading frame {frame}.")
 
             image = itk.imread(path)
-            image = reset_direction(image, InterpolatorType.LINEAR)
+            image = reset_direction(image)
             image = itk.vtk_image_from_image(image)
 
             mapper = vtk.vtkGPUVolumeRayCastMapper()
@@ -113,12 +89,12 @@ class Volume(Object):
             reslice.SetInputData(image_data)
             reslice.SetOutputDimensionality(2)
             reslice.SetInterpolationModeToLinear()
-            reslice.SetBackgroundLevel(-1000.0)  # Set background to air value
+            reslice.SetBackgroundLevel(-1000.0)
 
             # Create image actor
             actor = vtk.vtkImageActor()
             actor.GetMapper().SetInputConnection(reslice.GetOutputPort())
-            actor.SetVisibility(False)  # Start hidden
+            actor.SetVisibility(False)
 
             mpr_actors[orientation] = {"reslice": reslice, "actor": actor}
 
@@ -133,40 +109,19 @@ class Volume(Object):
         return mpr_actors
 
     def _setup_center_slices(self, image_data, frame: int):
-        """Set up reslice matrices to show center slices using LAS coordinate system."""
+        """Set up reslice matrices to show center slices using axcode-based coordinate systems."""
         center = image_data.GetCenter()
-
         actors = self._mpr_actors[frame]
 
-        # Base LAS vectors (Left-Anterior-Superior coordinate system)
-        base_axial_normal = np.array([0.0, 0.0, 1.0])  # Z axis (Superior)
-        base_axial_up = np.array([0.0, -1.0, 0.0])  # -Y axis (Anterior)
-
-        base_sagittal_normal = np.array([1.0, 0.0, 0.0])  # X axis (Left)
-        base_sagittal_up = np.array([0.0, 0.0, 1.0])  # Z axis (Superior)
-
-        base_coronal_normal = np.array([0.0, 1.0, 0.0])  # Y axis (Posterior in data)
-        base_coronal_up = np.array([0.0, 0.0, 1.0])  # Z axis (Superior)
+        # Get coordinate system transformations for each MPR view
+        transforms = self._get_mpr_coordinate_systems()
 
-        # Create reslice matrices with proper LAS vectors
-        axial_origin = [center[0], center[1], center[2]]
-        axial_matrix = create_reslice_matrix(
-            base_axial_normal, base_axial_up, axial_origin
-        )
-        actors["axial"]["reslice"].SetResliceAxes(axial_matrix)
-
-        sagittal_origin = [center[0], center[1], center[2]]
-        sagittal_matrix = create_reslice_matrix(
-            base_sagittal_normal, base_sagittal_up, sagittal_origin
-        )
-        actors["sagittal"]["reslice"].SetResliceAxes(sagittal_matrix)
+        # Create reslice matrices directly from transforms
+        origin = [center[0], center[1], center[2]]
 
-        # Coronal view: LPS->LAS Y coordinate conversion
-        coronal_origin = [center[0], center[1], center[2]]
-        coronal_matrix = create_reslice_matrix(
-            base_coronal_normal, base_coronal_up, coronal_origin
-        )
-        actors["coronal"]["reslice"].SetResliceAxes(coronal_matrix)
+        for orientation in ["axial", "sagittal", "coronal"]:
+            mat = create_vtk_reslice_matrix(transforms[orientation], origin)
+            actors[orientation]["reslice"].SetResliceAxes(mat)
 
     @property
     def mpr_actors(self) -> dict[str, list[vtk.vtkImageActor]]:
@@ -179,16 +134,86 @@ class Volume(Object):
             return self.create_mpr_actors(frame)
         return self._mpr_actors[frame]
 
+    def _get_mpr_coordinate_systems(self):
+        """Get coordinate system transformation matrices for MPR views."""
+        view_axcodes = {
+            "axial": "LAS",  # Left-Anterior-Superior
+            "sagittal": "ASL",  # Anterior-Superior-Left
+            "coronal": "LSA",  # Left-Superior-Anterior
+        }
+
+        transforms = {}
+        for view, target_axcode in view_axcodes.items():
+            transforms[view] = axcode_transform_matrix("LPS", target_axcode)
+
+        return transforms
+
+    def get_physical_bounds(
+        self, frame: int = 0
+    ) -> tuple[float, float, float, float, float, float]:
+        """Get physical coordinate bounds for the volume.
+
+        Returns:
+            (x_min, x_max, y_min, y_max, z_min, z_max) in LAS coordinate system
+        """
+        if not self._actors:
+            raise RuntimeError(f"No actors configured for volume '{self.label}'")
+        if frame >= len(self._actors):
+            raise IndexError(
+                f"Frame {frame} out of range for volume '{self.label}' (max: {len(self._actors) - 1})"
+            )
+
+        volume_actor = self._actors[frame]
+        image_data = volume_actor.GetMapper().GetInput()
+
+        # Get VTK image metadata
+        origin = np.array(image_data.GetOrigin())
+        spacing = np.array(image_data.GetSpacing())
+        dimensions = np.array(image_data.GetDimensions())
+        direction_matrix = np.array(
+            [
+                [image_data.GetDirectionMatrix().GetElement(i, j) for j in range(3)]
+                for i in range(3)
+            ]
+        )
+
+        # Calculate antiorigin using direction matrix
+        antiorigin = origin + direction_matrix @ (spacing * (dimensions - 1))
+
+        # Transform both corners from LPS to LAS
+        transform = axcode_transform_matrix("LPS", "LAS")
+        origin_las = origin @ transform.T
+        antiorigin_las = antiorigin @ transform.T
+
+        # Interleave coordinates directly without min/max
+        bounds = (
+            origin_las[0],
+            antiorigin_las[0],  # x bounds
+            origin_las[1],
+            antiorigin_las[1],  # y bounds
+            origin_las[2],
+            antiorigin_las[2],  # z bounds
+        )
+
+        return bounds
+
     def update_slice_positions(
         self,
         frame: int,
-        axial_frac: float,
-        sagittal_frac: float,
-        coronal_frac: float,
+        axial_pos: float,
+        sagittal_pos: float,
+        coronal_pos: float,
         rotation_sequence: list = None,
         rotation_angles: dict = None,
     ):
-        """Update slice positions for MPR views with optional rotation."""
+        """Update slice positions for MPR views with optional rotation.
+
+        Args:
+            frame: Frame index
+            axial_pos: Physical position along Z axis (LAS Superior)
+            sagittal_pos: Physical position along X axis (LAS Left)
+            coronal_pos: Physical position along Y axis (LAS Anterior)
+        """
         if frame not in self._mpr_actors:
             return
 
@@ -198,65 +223,49 @@ class Volume(Object):
 
         actors = self._mpr_actors[frame]
 
-        # Calculate slice positions from fractions
-        axial_pos = bounds[4] + axial_frac * (bounds[5] - bounds[4])  # Z bounds
-        sagittal_pos = bounds[0] + sagittal_frac * (bounds[1] - bounds[0])  # X bounds
-        # Coronal: LPS->LAS Y coordinate conversion (flip direction)
-        coronal_pos = bounds[3] - coronal_frac * (
-            bounds[3] - bounds[2]
-        )  # Flipped Y bounds
-
-        # Base LAS vectors (Left-Anterior-Superior coordinate system)
-        base_axial_normal = np.array([0.0, 0.0, 1.0])  # Z axis (Superior)
-        base_axial_up = np.array([0.0, -1.0, 0.0])  # -Y axis (Anterior)
-        base_sagittal_normal = np.array([1.0, 0.0, 0.0])  # X axis (Left)
-        base_sagittal_up = np.array([0.0, 0.0, 1.0])  # Z axis (Superior)
-        base_coronal_normal = np.array([0.0, 1.0, 0.0])  # Y axis (Posterior in data)
-        base_coronal_up = np.array([0.0, 0.0, 1.0])  # Z axis (Superior)
-
-        # Apply cumulative rotation if provided
+        # Clamp positions to volume bounds
+        axial_pos = max(bounds[4], min(bounds[5], axial_pos))  # Z bounds
+        sagittal_pos = max(bounds[0], min(bounds[1], sagittal_pos))  # X bounds
+        coronal_pos = max(bounds[2], min(bounds[3], coronal_pos))  # Y bounds
+
+        # Get coordinate system transformations for each MPR view
+        transforms = self._get_mpr_coordinate_systems()
+
+        center = image_data.GetCenter()
+
+        # Step 1: Apply translation to determine slice origins in physical space
+        axial_origin = [center[0], center[1], axial_pos]
+        sagittal_origin = [sagittal_pos, center[1], center[2]]
+        coronal_origin = [center[0], coronal_pos, center[2]]
+
+        # Step 2: Apply cumulative rotation around the translated origins
         if rotation_sequence and rotation_angles:
             cumulative_rotation = np.eye(3)
             for i, rotation in enumerate(rotation_sequence):
                 angle = rotation_angles.get(i, 0)
-                rotation_matrix = create_rotation_matrix(rotation["axis"], angle)
+                rotation_matrix = euler_angle_to_rotation_matrix(
+                    EulerAxis(rotation["axis"]), angle
+                )
                 cumulative_rotation = cumulative_rotation @ rotation_matrix
 
-            # Apply rotation to base view vectors
-            axial_normal = cumulative_rotation @ base_axial_normal
-            axial_up = cumulative_rotation @ base_axial_up
-            sagittal_normal = cumulative_rotation @ base_sagittal_normal
-            sagittal_up = cumulative_rotation @ base_sagittal_up
-            coronal_normal = cumulative_rotation @ base_coronal_normal
-            coronal_up = cumulative_rotation @ base_coronal_up
+            # Apply rotation to base transforms
+            axial_transform = cumulative_rotation @ transforms["axial"]
+            sagittal_transform = cumulative_rotation @ transforms["sagittal"]
+            coronal_transform = cumulative_rotation @ transforms["coronal"]
         else:
-            # Use base vectors without rotation
-            axial_normal = base_axial_normal
-            axial_up = base_axial_up
-            sagittal_normal = base_sagittal_normal
-            sagittal_up = base_sagittal_up
-            coronal_normal = base_coronal_normal
-            coronal_up = base_coronal_up
+            # Use base transforms without rotation
+            axial_transform = transforms["axial"]
+            sagittal_transform = transforms["sagittal"]
+            coronal_transform = transforms["coronal"]
 
-        center = image_data.GetCenter()
-
-        # Update axial slice
-        axial_origin = [center[0], center[1], axial_pos]
-        axial_matrix = create_reslice_matrix(axial_normal, axial_up, axial_origin)
+        # Update slices with translated origins and rotated transforms
+        axial_matrix = create_vtk_reslice_matrix(axial_transform, axial_origin)
         actors["axial"]["reslice"].SetResliceAxes(axial_matrix)
 
-        # Update sagittal slice
-        sagittal_origin = [sagittal_pos, center[1], center[2]]
-        sagittal_matrix = create_reslice_matrix(
-            sagittal_normal, sagittal_up, sagittal_origin
-        )
+        sagittal_matrix = create_vtk_reslice_matrix(sagittal_transform, sagittal_origin)
         actors["sagittal"]["reslice"].SetResliceAxes(sagittal_matrix)
 
-        # Update coronal slice
-        coronal_origin = [center[0], coronal_pos, center[2]]
-        coronal_matrix = create_reslice_matrix(
-            coronal_normal, coronal_up, coronal_origin
-        )
+        coronal_matrix = create_vtk_reslice_matrix(coronal_transform, coronal_origin)
         actors["coronal"]["reslice"].SetResliceAxes(coronal_matrix)
 
     def update_mpr_window_level(self, frame: int, window: float, level: float):

{cardio-2025.9.0.dist-info → cardio-2025.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cardio
-Version: 2025.9.0
+Version: 2025.10.1
 Summary: A simple web-based viewer for 3D and 4D ('cine') medical imaging data.
 Keywords: Medical,Imaging,3D,4D,Visualization
 Author: Davis Marc Vigneault
@@ -76,7 +76,7 @@ $ uv init
 $ uv add cardio
 $ . ./.venv/bin/activate
 (project) cardio --version
-cardio 2025.9.0
+cardio 2025.10.1
 ```
 
 ### Developing

{cardio-2025.9.0.dist-info → cardio-2025.10.1.dist-info}/RECORD

@@ -1,28 +1,29 @@
-cardio/__init__.py,sha256=tEZTwdKZnx4WPaNTsZZSwBqLfCQgB0e3Rzov5-ci1GI,581
-cardio/app.py,sha256=jcT0AUccoB6CPAKQ_gAJE3Q-jsrc9OT4XlK1XskdrI4,1791
+cardio/__init__.py,sha256=cVW5yofdKIbjqc0sf_VVnIMah9BvAgELy7IzZR50IZQ,602
+cardio/app.py,sha256=TEzgA03EAgI7HSCHhYwYb8tsnAptsrpcysV5CytfAq4,1379
 cardio/assets/bone.toml,sha256=vv8uVYSHIoKuHkNCoBOkGe2_qoEbXMvQO6ypm3mMOtA,675
 cardio/assets/vascular_closed.toml,sha256=XtaZS_Zd6NSAtY3ZlUfiog3T86u9Ii0oSutU2wBQy78,1267
 cardio/assets/vascular_open.toml,sha256=1M3sV1IGt3zh_3vviysKEk9quKfjF9xUBcIq3kxVHFM,879
 cardio/assets/xray.toml,sha256=siPem0OZ2OkWH0e5pizftpItJKGJgxKJ_S2K0316ubQ,693
 cardio/blend_transfer_functions.py,sha256=s5U4hO810oE434wIkPmAP2mrAfqFb4xxxi3hHf_k8og,2982
 cardio/color_transfer_function.py,sha256=KV4j11AXYeaYGeJWBc9I-WZf7Shrm5xjQVq-0bq9Qc8,817
-cardio/logic.py,sha256=usIAZkF68op3apQJXR8m2y8ozuulVHlGSgX7qqyctV4,31462
-cardio/mesh.py,sha256=Q-5MgEoX3nInwUZe4o2MU4nKy9oR34Qj41JwevxW8bc,9410
-cardio/object.py,sha256=zly-2bGnB7K45gRLnMgxE-q7cUtdlOLLr4z4QoVkZJ0,6172
+cardio/logic.py,sha256=a73JJ2b8t-TYggYMGI1IGpn0Q6AFD8I1JNz9fn6QeDk,37557
+cardio/mesh.py,sha256=XIJX2Ldv1Bw82yykE0N4IlQ0xE2r6xitjxsbEvEKrcI,9390
+cardio/object.py,sha256=FvMzhO9gyHhXgME8B6fcnWH74HmsYNoUjpVKUWEpWhM,6191
+cardio/orientation.py,sha256=J3bqZbv8vfl4loGl7ksmuyqWb3zFAz-TVSIahKcg0pc,6145
 cardio/piecewise_function.py,sha256=bwtwgrAMGkgu1krnvsOF9gRMaZb6smsS9jLrgBecSbo,789
 cardio/property_config.py,sha256=XJYcKeRcq8s9W9jqxzVer75r5jBLuvebv780FYdPV8U,1723
-cardio/scene.py,sha256=2GAbSvFMPQAHoNz2EO4ukXkIXmfy3-Km3ik5OHdDzJE,13015
+cardio/scene.py,sha256=9jskdEARyJjk7QBIcMt5X2HsnikTAJdoRoLSI0LxcJE,14301
 cardio/screenshot.py,sha256=l8bLgxnU5O0FlnmsyVAzKwM9Y0401IzcdnDP0WqFSTY,640
-cardio/segmentation.py,sha256=enj1V5Rw42dxjqSRUiylEQcdgvj8A-Do9Z638tf7nc8,6706
+cardio/segmentation.py,sha256=SK9f834lld08qYH9l2Ligml212u7MzfcOEgTz8wnpzs,6676
 cardio/transfer_function_pair.py,sha256=90PQXByCL6mMaODo7Yfd-lmdFtCKhcBZbNaiH-PTds0,805
 cardio/types.py,sha256=DYDgA5QmYdU3QQrEgZMouEbMEIf40DJCeXo4V7cDXtg,356
-cardio/ui.py,sha256=ON8SUuxyo1W3m1IX18K-8wxd1dCFlNcRufxH88iXEZk,33738
-cardio/utils.py,sha256=zgyJ2PWTAWIaU8SVA9KF_XFB4251QxYAT6w3cqaIerA,3051
-cardio/volume.py,sha256=Wt1EoOJ_U2RZLjK67_iIYMjFiXIKV2DNLkXd-8qFslU,10613
+cardio/ui.py,sha256=wsRujwiNtMeq65R4bx-myxSPDhJT0RskwvBWlGenmHk,42901
+cardio/utils.py,sha256=tFUQ4FxfidTH6GjEIKQwguqhO9T_wJ2Vk0IhbEfxRGA,1616
+cardio/volume.py,sha256=k7NYZCwsmoAbs8mNWDC51gS6nlzPqD9JhDr1iyUQ0cs,10377
 cardio/volume_property.py,sha256=6T2r67SSIDl8F6ZlQvgMCZESLxuXVVAUjOC50lgQEmk,1644
 cardio/volume_property_presets.py,sha256=U2a2MnyCjryzOLEADs3OLSMMmAUnXq82mYK7OVXbQV0,1659
 cardio/window_level.py,sha256=gjk39Iv6jMJ52y6jydOjxBZBsI1nZQMs2CdWWTshQoE,807
-cardio-2025.9.0.dist-info/WHEEL,sha256=4n27za1eEkOnA7dNjN6C5-O2rUiw6iapszm14Uj-Qmk,79
-cardio-2025.9.0.dist-info/entry_points.txt,sha256=xRd1otqKtW9xmidJ4CFRX1V9KWmsBbtxrgMtDColq3w,40
-cardio-2025.9.0.dist-info/METADATA,sha256=5Sf5ChcVgdhHQNZM45oqsIVPCKGkhPqqCkunHvpR0vQ,3538
-cardio-2025.9.0.dist-info/RECORD,,
+cardio-2025.10.1.dist-info/WHEEL,sha256=4n27za1eEkOnA7dNjN6C5-O2rUiw6iapszm14Uj-Qmk,79
+cardio-2025.10.1.dist-info/entry_points.txt,sha256=xRd1otqKtW9xmidJ4CFRX1V9KWmsBbtxrgMtDColq3w,40
+cardio-2025.10.1.dist-info/METADATA,sha256=0GkZB7yixZKd4nFaAHgWtgCA6VxlV_pbUYdHokFROD4,3540
+cardio-2025.10.1.dist-info/RECORD,,