cardio 2025.8.1__py3-none-any.whl → 2025.10.0__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,8 +6,14 @@ import pydantic as pc
 import vtk
 
 from .object import Object
-from .transfer_functions import load_preset
-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
 
 
 class Volume(Object):
@@ -17,8 +23,13 @@ class Volume(Object):
         default="${frame}.nii.gz",
         description="Filename pattern with $frame placeholder",
     )
-    transfer_function_preset: str = pc.Field(description="Transfer function preset key")
+    transfer_function_preset: str = pc.Field(
+        default="bone", description="Transfer function preset key"
+    )
     _actors: list[vtk.vtkVolume] = pc.PrivateAttr(default_factory=list)
+    _mpr_actors: dict[str, list[vtk.vtkImageActor]] = pc.PrivateAttr(
+        default_factory=dict
+    )
 
     @pc.model_validator(mode="after")
     def initialize_volume(self):
@@ -27,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()
@@ -47,7 +58,7 @@ class Volume(Object):
     @property
     def preset(self):
         """Load preset based on transfer_function_preset."""
-        return load_preset(self.transfer_function_preset)
+        return load_volume_property_preset(self.transfer_function_preset)
 
     def configure_actors(self):
         """Configure volume properties without adding to renderer."""
@@ -59,3 +70,214 @@ class Volume(Object):
         """Apply the current preset to all actors."""
         for actor in self._actors:
             actor.SetProperty(self.preset.vtk_property)
+
+    def create_mpr_actors(self, frame: int = 0):
+        """Create MPR (reslice) actors for axial, sagittal, and coronal views."""
+        if frame >= len(self._actors):
+            frame = 0
+
+        # Get the image data from the volume actor
+        volume_actor = self._actors[frame]
+        image_data = volume_actor.GetMapper().GetInput()
+
+        # Create reslice actors for each orientation
+        mpr_actors = {}
+
+        for orientation in ["axial", "sagittal", "coronal"]:
+            # Create reslice filter
+            reslice = vtk.vtkImageReslice()
+            reslice.SetInputData(image_data)
+            reslice.SetOutputDimensionality(2)
+            reslice.SetInterpolationModeToLinear()
+            reslice.SetBackgroundLevel(-1000.0)
+
+            # Create image actor
+            actor = vtk.vtkImageActor()
+            actor.GetMapper().SetInputConnection(reslice.GetOutputPort())
+            actor.SetVisibility(False)
+
+            mpr_actors[orientation] = {"reslice": reslice, "actor": actor}
+
+        # Store actors for this frame
+        if frame not in self._mpr_actors:
+            self._mpr_actors[frame] = {}
+        self._mpr_actors[frame] = mpr_actors
+
+        # Set up initial reslice matrices for center slices
+        self._setup_center_slices(image_data, frame)
+
+        return mpr_actors
+
+    def _setup_center_slices(self, image_data, frame: int):
+        """Set up reslice matrices to show center slices using axcode-based coordinate systems."""
+        center = image_data.GetCenter()
+        actors = self._mpr_actors[frame]
+
+        # Get coordinate system transformations for each MPR view
+        transforms = self._get_mpr_coordinate_systems()
+
+        # Create reslice matrices directly from transforms
+        origin = [center[0], center[1], center[2]]
+
+        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]]:
+        """Get MPR actors for all frames."""
+        return self._mpr_actors
+
+    def get_mpr_actors_for_frame(self, frame: int) -> dict:
+        """Get MPR actors for a specific frame."""
+        if frame not in self._mpr_actors:
+            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_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.
+
+        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
+
+        volume_actor = self._actors[frame]
+        image_data = volume_actor.GetMapper().GetInput()
+        bounds = image_data.GetBounds()
+
+        actors = self._mpr_actors[frame]
+
+        # 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 = euler_angle_to_rotation_matrix(
+                    EulerAxis(rotation["axis"]), angle
+                )
+                cumulative_rotation = cumulative_rotation @ rotation_matrix
+
+            # 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 transforms without rotation
+            axial_transform = transforms["axial"]
+            sagittal_transform = transforms["sagittal"]
+            coronal_transform = transforms["coronal"]
+
+        # Update slices with translated origins and rotated transforms
+        axial_matrix = create_vtk_reslice_matrix(axial_transform, axial_origin)
+        actors["axial"]["reslice"].SetResliceAxes(axial_matrix)
+
+        sagittal_matrix = create_vtk_reslice_matrix(sagittal_transform, sagittal_origin)
+        actors["sagittal"]["reslice"].SetResliceAxes(sagittal_matrix)
+
+        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):
+        """Update window/level properties for MPR actors."""
+        if frame not in self._mpr_actors:
+            return
+
+        actors = self._mpr_actors[frame]
+
+        for orientation in ["axial", "sagittal", "coronal"]:
+            if orientation in actors:
+                actor = actors[orientation]["actor"]
+                property_obj = actor.GetProperty()
+                property_obj.SetColorWindow(window)
+                property_obj.SetColorLevel(level)

cardio/volume_property.py

@@ -0,0 +1,46 @@
+# Third Party
+import pydantic as pc
+import vtk
+
+# Internal
+from .blend_transfer_functions import blend_transfer_functions
+from .transfer_function_pair import TransferFunctionPairConfig
+from .types import ScalarComponent
+
+
+class VolumePropertyConfig(pc.BaseModel):
+    """Configuration for volume rendering properties and transfer functions."""
+
+    name: str = pc.Field(description="Display name of the preset")
+    description: str = pc.Field(description="Description of the preset")
+
+    # Lighting parameters
+    ambient: ScalarComponent
+    diffuse: ScalarComponent
+    specular: ScalarComponent
+
+    # Transfer functions
+    transfer_functions: list[TransferFunctionPairConfig] = pc.Field(
+        min_length=1, description="List of transfer function pairs to blend"
+    )
+
+    @property
+    def vtk_property(self) -> vtk.vtkVolumeProperty:
+        """Create a fully configured VTK volume property from this configuration."""
+        # Get VTK transfer functions from each pair config
+        tfs = [pair.vtk_functions for pair in self.transfer_functions]
+
+        # Blend all transfer functions into a single composite
+        blended_otf, blended_ctf = blend_transfer_functions(tfs)
+
+        # Create and configure the volume property
+        _vtk_property = vtk.vtkVolumeProperty()
+        _vtk_property.SetScalarOpacity(blended_otf)
+        _vtk_property.SetColor(blended_ctf)
+        _vtk_property.ShadeOn()
+        _vtk_property.SetInterpolationTypeToLinear()
+        _vtk_property.SetAmbient(self.ambient)
+        _vtk_property.SetDiffuse(self.diffuse)
+        _vtk_property.SetSpecular(self.specular)
+
+        return _vtk_property

cardio/volume_property_presets.py

@@ -0,0 +1,53 @@
+# System
+import pathlib as pl
+
+# Third Party
+import pydantic as pc
+import tomlkit as tk
+
+# Internal
+from .volume_property import VolumePropertyConfig
+
+
+def load_volume_property_preset(preset_name: str) -> VolumePropertyConfig:
+    """Load a specific volume property preset from its individual file."""
+    assets_dir = pl.Path(__file__).parent / "assets"
+    preset_file = assets_dir / f"{preset_name}.toml"
+
+    if not preset_file.exists():
+        available = list(list_volume_property_presets().keys())
+        raise KeyError(
+            f"Volume property preset '{preset_name}' not found. "
+            f"Available presets: {available}"
+        )
+
+    try:
+        with preset_file.open("rt", encoding="utf-8") as fp:
+            raw_data = tk.load(fp)
+        return VolumePropertyConfig.model_validate(raw_data)
+    except (pc.ValidationError, Exception) as e:
+        raise ValueError(f"Invalid preset file '{preset_name}.toml': {e}") from e
+
+
+def list_volume_property_presets() -> dict[str, str]:
+    """
+    List all available volume property presets.
+
+    Returns:
+        Dictionary mapping preset names to descriptions
+    """
+    assets_dir = pl.Path(__file__).parent / "assets"
+    preset_files = assets_dir.glob("*.toml")
+
+    presets = {}
+    for preset_file in preset_files:
+        preset_name = preset_file.stem
+        try:
+            with preset_file.open("rt", encoding="utf-8") as fp:
+                preset_data = tk.load(fp)
+                presets[preset_name] = preset_data["description"]
+        except (KeyError, OSError):
+            # Skip files that don't have the expected structure
+            continue
+
+    return presets

cardio/window_level.py

@@ -0,0 +1,35 @@
+# System
+import functools as ft
+
+# Third Party
+import pydantic as pc
+
+
+@pc.dataclasses.dataclass(config=dict(frozen=True))
+class WindowLevel:
+    name: str
+    window: float
+    level: float
+
+    @pc.computed_field
+    @ft.cached_property
+    def lower(self) -> float:
+        return self.level - self.window / 2
+
+    @pc.computed_field
+    @ft.cached_property
+    def upper(self) -> float:
+        return self.level + self.window / 2
+
+
+presets = {
+    1: WindowLevel("Abdomen", 400, 40),
+    2: WindowLevel("Lung", 1500, -700),
+    3: WindowLevel("Liver", 100, 110),
+    4: WindowLevel("Bone", 1500, 500),
+    5: WindowLevel("Brain", 85, 42),
+    6: WindowLevel("Stroke", 36, 28),
+    7: WindowLevel("Vascular", 800, 200),
+    8: WindowLevel("Subdural", 160, 60),
+    9: WindowLevel("Normalized", 0, 1),
+}

{cardio-2025.8.1.dist-info → cardio-2025.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cardio
-Version: 2025.8.1
+Version: 2025.10.0
 Summary: A simple web-based viewer for 3D and 4D ('cine') medical imaging data.
 Keywords: Medical,Imaging,3D,4D,Visualization
 Author: Davis Marc Vigneault
@@ -34,17 +34,19 @@ Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
 Classifier: Topic :: Scientific/Engineering :: Visualization
 Requires-Dist: trame-vuetify>=3.0.2
 Requires-Dist: trame-vtk>=2.9.1
-Requires-Dist: trame>=3.11.0
 Requires-Dist: itk>=5.4.4.post1
 Requires-Dist: vtk>=9.5.0
 Requires-Dist: tomlkit>=0.13.3
 Requires-Dist: numpy>=2.2.6
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: trame>=3.12.0
+Requires-Dist: trame-client>=3.10.1
 Requires-Dist: ruff>=0.12.10 ; extra == 'dev'
 Requires-Dist: isort>=6.0.1 ; extra == 'dev'
 Requires-Dist: bumpver>=2025.1131 ; extra == 'dev'
 Requires-Dist: pytest>=8.4.1 ; extra == 'dev'
+Requires-Dist: coverage>=7.10.4 ; extra == 'dev'
 Maintainer: Davis Marc Vigneault
 Maintainer-email: Davis Marc Vigneault <davis.vigneault@gmail.com>
 Requires-Python: >=3.10
@@ -74,7 +76,7 @@ $ uv init
 $ uv add cardio
 $ . ./.venv/bin/activate
 (project) cardio --version
-cardio 2025.8.1
+cardio 2025.10.0
 ```
 
 ### Developing

cardio-2025.10.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+cardio/__init__.py,sha256=5lINeD9qQQm_u9eJfPIzdEMfYW62UZ2asOmQIS4PcFk,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=a73JJ2b8t-TYggYMGI1IGpn0Q6AFD8I1JNz9fn6QeDk,37557
+cardio/mesh.py,sha256=xL4hadrVF3GVtMFxpq79DKApbmstZEI_HEwTAqc4ZMI,9391
+cardio/object.py,sha256=fvLSZtWf1zDbYMh-AMpgVLwD-9S1LCzuRt7HmkXxb3A,6215
+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=9jskdEARyJjk7QBIcMt5X2HsnikTAJdoRoLSI0LxcJE,14301
+cardio/screenshot.py,sha256=l8bLgxnU5O0FlnmsyVAzKwM9Y0401IzcdnDP0WqFSTY,640
+cardio/segmentation.py,sha256=QqeG2C3BVbO9fUJDSWf0mZXzgfrTx4LHWwaz4vtv8ZM,6677
+cardio/transfer_function_pair.py,sha256=90PQXByCL6mMaODo7Yfd-lmdFtCKhcBZbNaiH-PTds0,805
+cardio/types.py,sha256=DYDgA5QmYdU3QQrEgZMouEbMEIf40DJCeXo4V7cDXtg,356
+cardio/ui.py,sha256=wsRujwiNtMeq65R4bx-myxSPDhJT0RskwvBWlGenmHk,42901
+cardio/utils.py,sha256=tFUQ4FxfidTH6GjEIKQwguqhO9T_wJ2Vk0IhbEfxRGA,1616
+cardio/volume.py,sha256=TxUfOvEoQw-kbEAQLSTfVOU3DhJjnjB8iy4qygCmVXA,10378
+cardio/volume_property.py,sha256=6T2r67SSIDl8F6ZlQvgMCZESLxuXVVAUjOC50lgQEmk,1644
+cardio/volume_property_presets.py,sha256=U2a2MnyCjryzOLEADs3OLSMMmAUnXq82mYK7OVXbQV0,1659
+cardio/window_level.py,sha256=gjk39Iv6jMJ52y6jydOjxBZBsI1nZQMs2CdWWTshQoE,807
+cardio-2025.10.0.dist-info/WHEEL,sha256=4n27za1eEkOnA7dNjN6C5-O2rUiw6iapszm14Uj-Qmk,79
+cardio-2025.10.0.dist-info/entry_points.txt,sha256=xRd1otqKtW9xmidJ4CFRX1V9KWmsBbtxrgMtDColq3w,40
+cardio-2025.10.0.dist-info/METADATA,sha256=VIqGgz8ueoxxEahbi1hshAnK90zWx_IUlyihRJHdwH8,3540
+cardio-2025.10.0.dist-info/RECORD,,