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

cardio/volume.py

@@ -6,8 +6,38 @@ import pydantic as pc
 import vtk
 
 from .object import Object
-from .transfer_functions import load_preset
 from .utils import InterpolatorType, 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):
@@ -17,8 +47,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):
@@ -47,7 +82,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 +94,181 @@ 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)  # Set background to air value
+
+            # Create image actor
+            actor = vtk.vtkImageActor()
+            actor.GetMapper().SetInputConnection(reslice.GetOutputPort())
+            actor.SetVisibility(False)  # Start hidden
+
+            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 LAS coordinate system."""
+        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)
+
+        # 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)
+
+        # 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)
+
+    @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 update_slice_positions(
+        self,
+        frame: int,
+        axial_frac: float,
+        sagittal_frac: float,
+        coronal_frac: float,
+        rotation_sequence: list = None,
+        rotation_angles: dict = None,
+    ):
+        """Update slice positions for MPR views with optional rotation."""
+        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]
+
+        # 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
+        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)
+                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
+        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
+
+        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)
+        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
+        )
+        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
+        )
+        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.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cardio
-Version: 2025.8.1
+Version: 2025.9.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.9.0
 ```
 
 ### Developing

cardio-2025.9.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+cardio/__init__.py,sha256=tEZTwdKZnx4WPaNTsZZSwBqLfCQgB0e3Rzov5-ci1GI,581
+cardio/app.py,sha256=jcT0AUccoB6CPAKQ_gAJE3Q-jsrc9OT4XlK1XskdrI4,1791
+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/piecewise_function.py,sha256=bwtwgrAMGkgu1krnvsOF9gRMaZb6smsS9jLrgBecSbo,789
+cardio/property_config.py,sha256=XJYcKeRcq8s9W9jqxzVer75r5jBLuvebv780FYdPV8U,1723
+cardio/scene.py,sha256=2GAbSvFMPQAHoNz2EO4ukXkIXmfy3-Km3ik5OHdDzJE,13015
+cardio/screenshot.py,sha256=l8bLgxnU5O0FlnmsyVAzKwM9Y0401IzcdnDP0WqFSTY,640
+cardio/segmentation.py,sha256=enj1V5Rw42dxjqSRUiylEQcdgvj8A-Do9Z638tf7nc8,6706
+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/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,,