cardio 2025.12.0__py3-none-any.whl → 2026.1.2__py3-none-any.whl

cardio/__init__.py

@@ -26,4 +26,4 @@ __all__ = [
     "window_level",
 ]
 
-__version__ = "2025.12.0"
+__version__ = "2026.1.2"

cardio/logic.py

@@ -9,15 +9,40 @@ from .screenshot import Screenshot
 
 class Logic:
     def _get_visible_rotation_data(self):
-        """Get rotation sequence and angles for visible rotations only."""
-        rotation_sequence = getattr(self.server.state, "mpr_rotation_sequence", [])
+        """Get rotation sequence and angles for visible rotations only.
+
+        Returns data in ITK convention, as required by VTK.
+        Converts from current convention if necessary.
+        """
+        from .orientation import IndexOrder
+
+        rotation_data = getattr(
+            self.server.state, "mpr_rotation_data", {"angles_list": []}
+        )
+        angles_list = rotation_data.get("angles_list", [])
+
+        # Build rotation_sequence (list of {"axis": ...}) for visible rotations
+        rotation_sequence = []
         rotation_angles = {}
-        for i in range(len(rotation_sequence)):
-            is_visible = getattr(self.server.state, f"mpr_rotation_visible_{i}", True)
-            if is_visible:
-                rotation_angles[i] = getattr(
-                    self.server.state, f"mpr_rotation_angle_{i}", 0
-                )
+
+        visible_index = 0
+        for rotation in angles_list:
+            if rotation.get("visible", True):
+                rotation_sequence.append({"axis": rotation["axes"]})
+                rotation_angles[visible_index] = rotation["angles"][0]
+                visible_index += 1
+
+        # CRITICAL: VTK always needs rotations in ITK convention
+        # Convert from current convention to ITK if necessary
+        current_convention = self.scene.mpr_rotation_sequence.metadata.index_order
+        if current_convention == IndexOrder.ROMA:
+            # Convert ROMA to ITK: X→Z, Y→Y, Z→X, angle→-angle
+            rotation_sequence = [
+                {"axis": {"X": "Z", "Y": "Y", "Z": "X"}[rot["axis"]]}
+                for rot in rotation_sequence
+            ]
+            rotation_angles = {idx: -angle for idx, angle in rotation_angles.items()}
+
         return rotation_sequence, rotation_angles
 
     def __init__(self, server, scene: Scene):
@@ -39,6 +64,12 @@ class Logic:
             {"text": "Radians", "value": "radians"},
         ]
 
+        # Initialize axis convention items for dropdown
+        self.server.state.index_order_items = [
+            {"text": "ITK (X=L, Y=P, Z=S)", "value": "itk"},
+            {"text": "Roma (X=S, Y=P, Z=L)", "value": "roma"},
+        ]
+
         # Initialize MPR origin (will be updated when active volume changes)
         self.server.state.mpr_origin = [0.0, 0.0, 0.0]
         self.server.state.mpr_crosshairs_enabled = self.scene.mpr_crosshairs_enabled
@@ -55,17 +86,9 @@ class Logic:
             self.update_mpr_window_level
         )
         self.server.state.change("mpr_window_level_preset")(self.update_mpr_preset)
-        self.server.state.change("mpr_rotation_sequence")(self.update_mpr_rotation)
+        self.server.state.change("mpr_rotation_data")(self.update_mpr_rotation)
         self.server.state.change("angle_units")(self.sync_angle_units)
-
-        # Add handlers for individual rotation angles and visibility
-        for i in range(self.scene.max_mpr_rotations):
-            self.server.state.change(f"mpr_rotation_angle_{i}")(
-                self.update_mpr_rotation
-            )
-            self.server.state.change(f"mpr_rotation_visible_{i}")(
-                self.update_mpr_rotation
-            )
+        self.server.state.change("index_order")(self.sync_index_order)
 
         # Initialize visibility state variables
         for m in self.scene.meshes:
@@ -160,6 +183,7 @@ class Logic:
         self.server.controller.add_y_rotation = lambda: self.add_mpr_rotation("Y")
         self.server.controller.add_z_rotation = lambda: self.add_mpr_rotation("Z")
         self.server.controller.remove_rotation_event = self.remove_mpr_rotation
+        self.server.controller.reset_rotation_angle = self.reset_rotation_angle
         self.server.controller.reset_rotations = self.reset_mpr_rotations
 
         # Initialize MPR state
@@ -176,8 +200,18 @@ class Logic:
         self.server.state.mpr_window = self.scene.mpr_window
         self.server.state.mpr_level = self.scene.mpr_level
         self.server.state.mpr_window_level_preset = self.scene.mpr_window_level_preset
-        self.server.state.mpr_rotation_sequence = self.scene.mpr_rotation_sequence
-        self.server.state.angle_units = self.scene.angle_units.value
+
+        # Initialize rotation data from RotationSequence
+        self.server.state.mpr_rotation_data = (
+            self.scene.mpr_rotation_sequence.to_dict_for_ui()
+        )
+
+        self.server.state.angle_units = (
+            self.scene.mpr_rotation_sequence.metadata.angle_units.value
+        )
+        self.server.state.index_order = (
+            self.scene.mpr_rotation_sequence.metadata.index_order.value
+        )
 
         # Initialize MPR presets data
         try:
@@ -190,12 +224,6 @@ class Logic:
             print(f"Error initializing MPR presets: {e}")
             self.server.state.mpr_presets = []
 
-        # Initialize rotation angle states
-        for i in range(self.scene.max_mpr_rotations):
-            setattr(self.server.state, f"mpr_rotation_angle_{i}", 0)
-            setattr(self.server.state, f"mpr_rotation_axis_{i}", f"Rotation {i + 1}")
-            setattr(self.server.state, f"mpr_rotation_visible_{i}", True)
-
         # Apply initial preset to ensure window/level values are set correctly
         # Only update state values, don't call update methods yet since MPR may not be enabled
         from .window_level import presets
@@ -319,6 +347,7 @@ class Logic:
             origin,
             rotation_sequence,
             rotation_angles,
+            self.scene.mpr_rotation_sequence.metadata.angle_units,
         )
 
         # Apply window/level
@@ -490,63 +519,40 @@ class Logic:
 
     @asynchronous.task
     async def save_rotation_angles(self):
-        """Save current rotation angles to a TOML file."""
-        import tomlkit as tk
+        """Save current rotation angles to TOML file."""
+        from .rotation import RotationSequence
 
-        # Get current timestamp
         timestamp = dt.datetime.now()
         timestamp_str = timestamp.strftime(self.scene.timestamp_format)
-        iso_timestamp = timestamp.isoformat()
-
-        # Get active volume label
         active_volume_label = getattr(self.server.state, "active_volume_label", "")
+
         if not active_volume_label:
-            print("Warning: No active volume selected for rotation saving")
+            print("Warning: No active volume selected")
             return
 
-        # Create directory structure
         save_dir = self.scene.rotations_directory / active_volume_label
         save_dir.mkdir(parents=True, exist_ok=True)
 
-        # Create TOML structure
-        doc = tk.document()
-
-        # Metadata section
-        metadata = tk.table()
-        metadata["coordinate_system"] = self.scene.coordinate_system
-        metadata["units"] = self.scene.angle_units.value
-        metadata["timestamp"] = iso_timestamp
-        metadata["volume_label"] = active_volume_label
-        doc["metadata"] = metadata
+        rotation_data = getattr(
+            self.server.state, "mpr_rotation_data", {"angles_list": []}
+        )
+        rotation_seq = RotationSequence.from_ui_dict(rotation_data, active_volume_label)
 
-        # Origin position section
-        origin = getattr(self.server.state, "mpr_origin", [0.0, 0.0, 0.0])
-        origin_table = tk.table()
-        origin_table["x"] = origin[0]
-        origin_table["y"] = origin[1]
-        origin_table["z"] = origin[2]
-        doc["origin"] = origin_table
-
-        # Rotations section (array of tables)
-        rotation_sequence = getattr(self.server.state, "mpr_rotation_sequence", [])
-        rotations_array = tk.aot()
-
-        for i, rotation_def in enumerate(rotation_sequence):
-            rotation = tk.table()
-            rotation["axis"] = rotation_def["axis"]
-            angle = getattr(self.server.state, f"mpr_rotation_angle_{i}", 0)
-            rotation["angle"] = float(angle)
-            rotation["visible"] = getattr(
-                self.server.state, f"mpr_rotation_visible_{i}", True
-            )
-            rotations_array.append(rotation)
+        mpr_origin = getattr(self.server.state, "mpr_origin", [0.0, 0.0, 0.0])
+        rotation_seq.mpr_origin = list(mpr_origin)
 
-        doc["rotations"] = rotations_array
+        rotation_seq.metadata.timestamp = timestamp.isoformat()
+        rotation_seq.metadata.volume_label = active_volume_label
+        rotation_seq.metadata.coordinate_system = self.scene.coordinate_system
+        rotation_seq.metadata.index_order = (
+            self.scene.mpr_rotation_sequence.metadata.index_order
+        )
+        rotation_seq.metadata.angle_units = (
+            self.scene.mpr_rotation_sequence.metadata.angle_units
+        )
 
-        # Save to file
         output_path = save_dir / f"{timestamp_str}.toml"
-        with open(output_path, "w") as f:
-            f.write(tk.dumps(doc))
+        rotation_seq.to_file(output_path)
 
     def reset_all(self):
         self.server.state.frame = 0
@@ -573,13 +579,87 @@ class Logic:
 
     def sync_angle_units(self, angle_units, **kwargs):
         """Sync angle units selection - updates the scene configuration."""
-        from .utils import AngleUnit
+        import copy
+
+        import numpy as np
 
-        # Update the scene's angle_units field based on UI selection
+        from .orientation import AngleUnits
+
+        # Get current units before changing
+        old_units = self.scene.mpr_rotation_sequence.metadata.angle_units
+
+        # Update based on UI selection
+        new_units = None
         if angle_units == "degrees":
-            self.scene.angle_units = AngleUnit.DEGREES
+            new_units = AngleUnits.DEGREES
         elif angle_units == "radians":
-            self.scene.angle_units = AngleUnit.RADIANS
+            new_units = AngleUnits.RADIANS
+
+        if new_units is None or old_units == new_units:
+            return
+
+        # Convert all existing rotation angles
+        rotation_data = getattr(
+            self.server.state, "mpr_rotation_data", {"angles_list": []}
+        )
+        if rotation_data.get("angles_list"):
+            updated_data = copy.deepcopy(rotation_data)
+
+            for rotation in updated_data["angles_list"]:
+                current_angle = rotation.get("angles", [0])[0]
+
+                # Convert based on old -> new units
+                if old_units == AngleUnits.DEGREES and new_units == AngleUnits.RADIANS:
+                    rotation["angles"][0] = np.radians(current_angle)
+                elif (
+                    old_units == AngleUnits.RADIANS and new_units == AngleUnits.DEGREES
+                ):
+                    rotation["angles"][0] = np.degrees(current_angle)
+
+            self.server.state.mpr_rotation_data = updated_data
+
+        self.scene.mpr_rotation_sequence.metadata.angle_units = new_units
+
+    def sync_index_order(self, index_order, **kwargs):
+        """Sync index order selection - converts existing rotations and updates scene."""
+        import copy
+
+        from .orientation import IndexOrder
+
+        old_convention = self.scene.mpr_rotation_sequence.metadata.index_order
+
+        # Convert string input to enum
+        if isinstance(index_order, str):
+            match index_order.lower():
+                case "itk":
+                    new_convention = IndexOrder.ITK
+                case "roma":
+                    new_convention = IndexOrder.ROMA
+                case _:
+                    raise ValueError(f"Unrecognized index order: {index_order}")
+        else:
+            new_convention = index_order
+
+        if old_convention == new_convention:
+            return
+
+        rotation_data = getattr(
+            self.server.state, "mpr_rotation_data", {"angles_list": []}
+        )
+        if rotation_data.get("angles_list"):
+            updated_data = copy.deepcopy(rotation_data)
+
+            for rotation in updated_data["angles_list"]:
+                current_axis = rotation.get("axes")
+                current_angle = rotation.get("angles", [0])[0]
+
+                # Conversion is the same for both ITK<->ROMA directions
+                rotation["axes"] = {"X": "Z", "Y": "Y", "Z": "X"}[current_axis]
+                rotation["angles"][0] = -current_angle
+
+            self.server.state.mpr_rotation_data = updated_data
+
+        self.scene.mpr_rotation_sequence.metadata.index_order = new_convention
 
     def _initialize_clipping_state(self):
         """Initialize clipping state variables for all objects."""
@@ -771,6 +851,7 @@ class Logic:
             origin,
             rotation_sequence,
             rotation_angles,
+            self.scene.mpr_rotation_sequence.metadata.angle_units,
         )
 
         # Update all views
@@ -869,6 +950,7 @@ class Logic:
             origin,
             rotation_sequence,
             rotation_angles,
+            self.scene.mpr_rotation_sequence.metadata.angle_units,
         )
 
         # Update all views
@@ -901,46 +983,56 @@ class Logic:
         """Add a new rotation to the MPR rotation sequence."""
         import copy
 
-        current_sequence = copy.deepcopy(
-            getattr(self.server.state, "mpr_rotation_sequence", [])
+        current_data = copy.deepcopy(
+            getattr(self.server.state, "mpr_rotation_data", {"angles_list": []})
         )
-        current_sequence.append({"axis": axis, "angle": 0})
-        self.server.state.mpr_rotation_sequence = current_sequence
-        self.update_mpr_rotation_labels()
+        angles_list = current_data["angles_list"]
+        new_index = len(angles_list)
+
+        angles_list.append(
+            {
+                "axes": axis,
+                "angles": [0],
+                "visible": True,
+                "name": "",
+                "name_editable": True,
+                "deletable": True,
+            }
+        )
+
+        self.server.state.mpr_rotation_data = current_data
 
     def remove_mpr_rotation(self, index):
-        """Remove a rotation at given index and all subsequent rotations."""
-        sequence = list(getattr(self.server.state, "mpr_rotation_sequence", []))
-        if 0 <= index < len(sequence):
-            sequence = sequence[:index]
-            self.server.state.mpr_rotation_sequence = sequence
+        """Remove a rotation at given index."""
+        import copy
 
-            # Reset angle states for all removed rotations
-            for i in range(index, self.scene.max_mpr_rotations):
-                setattr(self.server.state, f"mpr_rotation_angle_{i}", 0)
+        current_data = copy.deepcopy(
+            getattr(self.server.state, "mpr_rotation_data", {"angles_list": []})
+        )
+        angles_list = current_data["angles_list"]
 
-            self.update_mpr_rotation_labels()
+        if 0 <= index < len(angles_list):
+            angles_list.pop(index)
+            current_data["angles_list"] = angles_list
+            self.server.state.mpr_rotation_data = current_data
+
+    def reset_rotation_angle(self, index):
+        """Reset the angle of a rotation at given index to zero."""
+        import copy
+
+        current_data = copy.deepcopy(
+            getattr(self.server.state, "mpr_rotation_data", {"angles_list": []})
+        )
+        angles_list = current_data["angles_list"]
+
+        if 0 <= index < len(angles_list):
+            angles_list[index]["angles"][0] = 0
+            current_data["angles_list"] = angles_list
+            self.server.state.mpr_rotation_data = current_data
 
     def reset_mpr_rotations(self):
         """Reset all MPR rotations."""
-        self.server.state.mpr_rotation_sequence = []
-        for i in range(self.scene.max_mpr_rotations):
-            setattr(self.server.state, f"mpr_rotation_angle_{i}", 0)
-            setattr(self.server.state, f"mpr_rotation_visible_{i}", True)
-        self.update_mpr_rotation_labels()
-
-    def update_mpr_rotation_labels(self):
-        """Update the rotation axis labels for display."""
-        rotation_sequence = getattr(self.server.state, "mpr_rotation_sequence", [])
-        for i, rotation in enumerate(rotation_sequence):
-            setattr(
-                self.server.state,
-                f"mpr_rotation_axis_{i}",
-                f"{rotation['axis']} ({i + 1})",
-            )
-        # Clear unused labels
-        for i in range(len(rotation_sequence), self.scene.max_mpr_rotations):
-            setattr(self.server.state, f"mpr_rotation_axis_{i}", f"Rotation {i + 1}")
+        self.server.state.mpr_rotation_data = {"angles_list": []}
 
     def finalize_mpr_initialization(self, **kwargs):
         """Set the active volume label after UI is ready to avoid race condition."""
@@ -950,6 +1042,9 @@ class Logic:
             self.sync_active_volume(self._pending_active_volume)
             delattr(self, "_pending_active_volume")
 
+        # Apply loaded rotation data to MPR views
+        self.update_mpr_rotation()
+
     @asynchronous.task
     async def close_application(self):
         """Close the application by stopping the server."""

cardio/orientation.py

@@ -1,17 +1,22 @@
-from enum import Enum
+import enum
 
 import itk
 import numpy as np
 
 
 # DICOM LPS canonical orientation vector mappings
-class EulerAxis(Enum):
+class EulerAxis(enum.StrEnum):
     X = "X"
     Y = "Y"
     Z = "Z"
 
 
-class AngleUnits(Enum):
+class IndexOrder(enum.StrEnum):
+    ITK = "itk"  # X=Left, Y=Posterior, Z=Superior
+    ROMA = "roma"  # X=Superior, Y=Posterior, Z=Left
+
+
+class AngleUnits(enum.StrEnum):
     DEGREES = "degrees"
     RADIANS = "radians"
 

cardio/rotation.py

@@ -0,0 +1,146 @@
+# System
+import datetime as dt
+import pathlib as pl
+import typing as ty
+
+# Third Party
+import numpy as np
+import pydantic as pc
+import tomlkit as tk
+
+# Internal
+from .orientation import AngleUnits, IndexOrder
+
+
+class RotationStep(pc.BaseModel):
+    """Single rotation step.
+
+    Both angles and axes are stored in the current convention/units.
+    - Angles: stored in units specified by parent metadata.angle_units
+    - Axes: stored in convention specified by parent metadata.index_order
+    """
+
+    axes: ty.Literal["X", "Y", "Z"]
+    angle: float = 0.0
+    visible: bool = True
+    name: str = ""
+    name_editable: bool = True
+    deletable: bool = True
+
+    @pc.model_validator(mode="before")
+    @classmethod
+    def handle_legacy_format(cls, data):
+        """Handle legacy 'angles' list format and 'axis' field."""
+        if isinstance(data, dict):
+            if "angles" in data and "angle" not in data:
+                angles = data["angles"]
+                if isinstance(angles, list) and len(angles) > 0:
+                    data["angle"] = angles[0]
+                else:
+                    data["angle"] = angles
+            if "axis" in data and "axes" not in data:
+                data["axes"] = data["axis"]
+        return data
+
+
+class RotationMetadata(pc.BaseModel):
+    """Metadata for TOML files."""
+
+    coordinate_system: ty.Literal["LPS"] = "LPS"
+    index_order: IndexOrder = IndexOrder.ITK
+    angle_units: AngleUnits = AngleUnits.RADIANS
+    timestamp: str = pc.Field(default_factory=lambda: dt.datetime.now().isoformat())
+    volume_label: str = ""
+
+
+class RotationSequence(pc.BaseModel):
+    """Complete rotation sequence.
+
+    Both angles and axes are always stored in the current convention/units:
+    - Angles: stored in units specified by metadata.angle_units
+    - Axes: stored in convention specified by metadata.index_order
+
+    When convention/units change in the UI, all existing rotations are converted.
+    """
+
+    model_config = pc.ConfigDict(frozen=False)
+
+    metadata: RotationMetadata = pc.Field(default_factory=RotationMetadata)
+    angles_list: list[RotationStep] = pc.Field(default_factory=list)
+    mpr_origin: list[float] = pc.Field(
+        default_factory=lambda: [0.0, 0.0, 0.0],
+        description="MPR origin position [x, y, z] in LPS coordinates",
+    )
+
+    @pc.field_validator("mpr_origin")
+    @classmethod
+    def validate_mpr_origin(cls, v):
+        """Ensure mpr_origin is a 3-element list of floats."""
+        if not isinstance(v, list) or len(v) != 3:
+            raise ValueError("mpr_origin must be a 3-element list [x, y, z]")
+        return [float(x) for x in v]
+
+    @pc.field_validator("angles_list", mode="before")
+    @classmethod
+    def convert_legacy_list(cls, v):
+        """Convert legacy list of dicts to list of RotationStep."""
+        if isinstance(v, list) and len(v) > 0 and isinstance(v[0], dict):
+            return [RotationStep(**item) for item in v]
+        return v
+
+    def to_dict_for_ui(self) -> dict:
+        """Convert to UI format.
+
+        Angles are passed through in their current units (metadata.angle_units).
+        UI expects 'angles' as a list for backward compatibility.
+        """
+        return {
+            "angles_list": [
+                {
+                    "axes": step.axes,
+                    "angles": [step.angle],
+                    "visible": step.visible,
+                    "name": step.name,
+                    "name_editable": step.name_editable,
+                    "deletable": step.deletable,
+                }
+                for step in self.angles_list
+            ],
+            "mpr_origin": self.mpr_origin,
+        }
+
+    @classmethod
+    def from_ui_dict(cls, data: dict, volume_label: str = "") -> "RotationSequence":
+        """Create from UI format.
+
+        Angles from UI are stored as-is (in current UI units).
+        Caller should set metadata.angle_units to match the UI's current units.
+        """
+        angles_list = [RotationStep(**step) for step in data.get("angles_list", [])]
+        metadata = RotationMetadata(volume_label=volume_label)
+        mpr_origin = data.get("mpr_origin", [0.0, 0.0, 0.0])
+        return cls(metadata=metadata, angles_list=angles_list, mpr_origin=mpr_origin)
+
+    def to_toml(self) -> str:
+        """Serialize to TOML using stored serialization preferences."""
+        data = self.model_dump(mode="json")
+        return tk.dumps(data)
+
+    @classmethod
+    def from_toml(cls, toml_content: str) -> "RotationSequence":
+        """Deserialize from TOML (no conversions - loads as-is)."""
+        doc = tk.loads(toml_content)
+        data = dict(doc)
+        return cls(**data)
+
+    @classmethod
+    def from_file(cls, path: pl.Path) -> "RotationSequence":
+        """Load from TOML file."""
+        with open(path, "r") as f:
+            return cls.from_toml(f.read())
+
+    def to_file(self, path: pl.Path):
+        """Save to TOML file using stored serialization preferences."""
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w") as f:
+            f.write(self.to_toml())

cardio/scene.py

@@ -8,9 +8,10 @@ import pydantic_settings as ps
 import vtk
 
 from .mesh import Mesh
+from .orientation import AngleUnits, IndexOrder
+from .rotation import RotationSequence
 from .segmentation import Segmentation
 from .types import RGBColor
-from .utils import AngleUnit
 from .volume import Volume
 
 MeshListAdapter = pc.TypeAdapter(list[Mesh])
@@ -124,23 +125,23 @@ class Scene(ps.BaseSettings):
     mpr_window_level_preset: int = pc.Field(
         default=7, description="Window/level preset key for MPR views"
     )
-    mpr_rotation_sequence: list = pc.Field(
-        default_factory=list,
-        description="Dynamic rotation sequence for MPR views - list of rotation steps",
+    mpr_rotation_sequence: RotationSequence = pc.Field(
+        default_factory=RotationSequence,
+        description="Dynamic rotation sequence for MPR views",
+    )
+    mpr_rotation_file: pl.Path | None = pc.Field(
+        default=None,
+        description="Path to TOML file containing rotation configuration to load",
     )
     max_mpr_rotations: int = pc.Field(
         default=20,
         description="Maximum number of MPR rotations supported",
     )
-    angle_units: AngleUnit = pc.Field(
-        default=AngleUnit.DEGREES,
-        description="Units for angle measurements in rotation serialization",
-    )
     coordinate_system: str = pc.Field(
-        default="LAS", description="Coordinate system orientation (e.g., LAS, RAS, LPS)"
+        default="LPS", description="Coordinate system orientation (e.g., LPS, RAS, LAS)"
     )
     mpr_crosshairs_enabled: bool = pc.Field(
-        default=False, description="Show crosshair lines indicating slice intersections"
+        default=True, description="Show crosshair lines indicating slice intersections"
     )
     mpr_crosshair_colors: dict = pc.Field(
         default_factory=lambda: {
@@ -176,6 +177,26 @@ class Scene(ps.BaseSettings):
             return SegmentationListAdapter.validate_json(v)
         return v
 
+    @pc.model_validator(mode="after")
+    def load_rotation_file(self):
+        """Load rotation sequence from TOML file if specified."""
+        if self.mpr_rotation_file is not None and self.mpr_rotation_file.exists():
+            self.mpr_rotation_sequence = RotationSequence.from_file(
+                self.mpr_rotation_file
+            )
+            if (
+                not self.active_volume_label
+                and self.mpr_rotation_sequence.metadata.volume_label
+            ):
+                self.active_volume_label = (
+                    self.mpr_rotation_sequence.metadata.volume_label
+                )
+
+            if self.mpr_rotation_sequence.mpr_origin:
+                self.mpr_origin = list(self.mpr_rotation_sequence.mpr_origin)
+
+        return self
+
     # VTK objects as private attributes
     _renderer: vtk.vtkRenderer = pc.PrivateAttr(default_factory=vtk.vtkRenderer)
     _renderWindow: vtk.vtkRenderWindow = pc.PrivateAttr(

cardio/ui.py

@@ -3,11 +3,12 @@ import time
 
 import numpy as np
 from trame.ui.vuetify3 import SinglePageWithDrawerLayout
+from trame.widgets import client
 from trame.widgets import html
 from trame.widgets import vtk as vtk_widgets
 from trame.widgets import vuetify3 as vuetify
 
-from .orientation import EulerAxis, euler_angle_to_rotation_matrix
+from .orientation import AngleUnits, EulerAxis, euler_angle_to_rotation_matrix
 from .scene import Scene
 from .volume_property_presets import list_volume_property_presets
 from .window_level import presets
@@ -151,16 +152,21 @@ class UI:
             return np.array([0.0, 0.0, 1.0])
 
         # Build cumulative rotation from visible rotations
-        rotation_sequence = getattr(self.server.state, "mpr_rotation_sequence", [])
+        rotation_data = getattr(
+            self.server.state, "mpr_rotation_data", {"angles_list": []}
+        )
+        angles_list = rotation_data.get("angles_list", [])
         cumulative_rotation = np.eye(3)
 
-        for i in range(len(rotation_sequence)):
-            is_visible = getattr(self.server.state, f"mpr_rotation_visible_{i}", True)
-            if is_visible:
-                angle = getattr(self.server.state, f"mpr_rotation_angle_{i}", 0)
-                rotation = rotation_sequence[i]
+        # Get current angle units
+        angle_units_str = getattr(self.server.state, "angle_units", "degrees")
+        angle_units = AngleUnits(angle_units_str)
+
+        for rotation in angles_list:
+            if rotation.get("visible", True):
+                angle = rotation.get("angles", [0])[0]
                 rotation_matrix = euler_angle_to_rotation_matrix(
-                    EulerAxis(rotation["axis"]), angle
+                    EulerAxis(rotation["axes"]), angle, angle_units
                 )
                 cumulative_rotation = cumulative_rotation @ rotation_matrix
 
@@ -462,7 +468,7 @@ class UI:
                 # Volume selection dropdown
                 if self.scene.volumes:
                     vuetify.VSelect(
-                        v_if="!maximized_view || maximized_view === 'volume'",
+                        v_if="(!maximized_view || maximized_view === 'volume') && volume_items.length >= 2",
                         v_model=("active_volume_label", ""),
                         items=("volume_items", []),
                         item_title="text",
@@ -472,57 +478,6 @@ class UI:
                         hide_details=True,
                     )
 
-                    # Window/Level controls for MPR
-                    vuetify.VListSubheader(
-                        "Window/Level", v_if="!maximized_view && active_volume_label"
-                    )
-
-                    vuetify.VSelect(
-                        v_if="!maximized_view && active_volume_label",
-                        v_model=("mpr_window_level_preset", 7),
-                        items=("mpr_presets", []),
-                        item_title="text",
-                        item_value="value",
-                        label="Preset",
-                        dense=True,
-                        hide_details=True,
-                    )
-
-                    vuetify.VSlider(
-                        v_if="!maximized_view && active_volume_label",
-                        v_model="mpr_window",
-                        min=1.0,
-                        max=2000.0,
-                        step=1.0,
-                        hint="Window",
-                        persistent_hint=True,
-                        dense=True,
-                        hide_details=False,
-                        thumb_label=True,
-                    )
-
-                    vuetify.VSlider(
-                        v_if="!maximized_view && active_volume_label",
-                        v_model="mpr_level",
-                        min=-1000.0,
-                        max=1000.0,
-                        step=1.0,
-                        hint="Level",
-                        persistent_hint=True,
-                        dense=True,
-                        hide_details=False,
-                        thumb_label=True,
-                    )
-
-                    vuetify.VCheckbox(
-                        v_if="!maximized_view && active_volume_label",
-                        v_model=("mpr_crosshairs_enabled", True),
-                        label="Show Crosshairs",
-                        dense=True,
-                        hide_details=True,
-                        classes="mt-2",
-                    )
-
                     # MPR Rotation controls
                     vuetify.VListSubheader(
                         "Rotations", v_if="!maximized_view && active_volume_label"
@@ -564,8 +519,8 @@ class UI:
 
                     # Reset rotations button
                     vuetify.VBtn(
-                        "Reset",
-                        v_if="!maximized_view && active_volume_label && mpr_rotation_sequence && mpr_rotation_sequence.length > 0",
+                        "Remove All Rotations",
+                        v_if="!maximized_view && active_volume_label && mpr_rotation_data.angles_list && mpr_rotation_data.angles_list.length > 0",
                         click=self.server.controller.reset_rotations,
                         small=True,
                         dense=True,
@@ -576,48 +531,105 @@ class UI:
                         prepend_icon="mdi-refresh",
                     )
 
-                    # Individual rotation sliders
-                    for i in range(self.scene.max_mpr_rotations):
-                        with vuetify.VRow(
-                            v_if=f"!maximized_view && active_volume_label && mpr_rotation_sequence && mpr_rotation_sequence.length > {i}",
-                            no_gutters=True,
-                            classes="align-center mb-1",
-                        ):
-                            with vuetify.VCol(cols="8"):
-                                vuetify.VSlider(
-                                    v_model=(f"mpr_rotation_angle_{i}", 0),
-                                    min=-180,
-                                    max=180,
-                                    step=1,
-                                    hint=(
-                                        f"mpr_rotation_axis_{i}",
-                                        f"Rotation {i + 1}",
-                                    ),
-                                    persistent_hint=True,
-                                    dense=True,
-                                    hide_details=False,
-                                    thumb_label=True,
-                                )
-                            with vuetify.VCol(cols="2"):
-                                vuetify.VCheckbox(
-                                    v_model=(f"mpr_rotation_visible_{i}", True),
-                                    true_icon="mdi-eye",
-                                    false_icon="mdi-eye-off",
-                                    hide_details=True,
-                                    dense=True,
-                                    title="Toggle this rotation and all subsequent ones",
-                                )
-                            with vuetify.VCol(cols="2"):
-                                vuetify.VBtn(
-                                    icon="mdi-delete",
-                                    click=ft.partial(
-                                        self.server.controller.remove_rotation_event, i
-                                    ),
-                                    small=True,
-                                    dense=True,
-                                    color="error",
-                                    title="Remove this rotation and all subsequent ones",
-                                )
+                    # Individual rotation sliders with DeepReactive
+                    with client.DeepReactive("mpr_rotation_data"):
+                        for i in range(self.scene.max_mpr_rotations):
+                            with vuetify.VContainer(
+                                v_if=f"!maximized_view && active_volume_label && mpr_rotation_data.angles_list && mpr_rotation_data.angles_list.length > {i}",
+                                fluid=True,
+                                classes="pa-0 mb-2",
+                            ):
+                                with vuetify.VRow(no_gutters=True):
+                                    with vuetify.VCol(cols="12"):
+                                        vuetify.VTextField(
+                                            v_model=(
+                                                f"mpr_rotation_data.angles_list[{i}].name",
+                                            ),
+                                            placeholder="Name",
+                                            dense=True,
+                                            hide_details=True,
+                                            readonly=(
+                                                f"!mpr_rotation_data.angles_list[{i}].name_editable",
+                                            ),
+                                            __events=["keydown", "keyup", "keypress"],
+                                            keydown="$event.stopPropagation(); $event.stopImmediatePropagation();",
+                                            keyup="$event.stopPropagation(); $event.stopImmediatePropagation();",
+                                            keypress="$event.stopPropagation(); $event.stopImmediatePropagation();",
+                                        )
+                                with vuetify.VRow(no_gutters=True):
+                                    with vuetify.VCol(cols="12"):
+                                        vuetify.VSlider(
+                                            v_model=(
+                                                f"mpr_rotation_data.angles_list[{i}].angles[0]",
+                                            ),
+                                            min=(
+                                                "angle_units === 'radians' ? -Math.PI : -180",
+                                            ),
+                                            max=(
+                                                "angle_units === 'radians' ? Math.PI : 180",
+                                            ),
+                                            step=(
+                                                "angle_units === 'radians' ? 0.01 : 1",
+                                            ),
+                                            dense=True,
+                                            hide_details=True,
+                                            thumb_label=True,
+                                        )
+                                with vuetify.VRow(
+                                    no_gutters=True, classes="align-center"
+                                ):
+                                    vuetify.VSpacer()
+                                    with vuetify.VCol(cols="4"):
+                                        vuetify.VSelect(
+                                            v_model=(
+                                                f"mpr_rotation_data.angles_list[{i}].axes",
+                                            ),
+                                            items=(["X", "Y", "Z"],),
+                                            dense=True,
+                                            hide_details=True,
+                                            label="Axis",
+                                        )
+                                    vuetify.VSpacer()
+                                    with vuetify.VCol(cols="auto"):
+                                        vuetify.VCheckbox(
+                                            v_model=(
+                                                f"mpr_rotation_data.angles_list[{i}].visible",
+                                            ),
+                                            true_icon="mdi-eye",
+                                            false_icon="mdi-eye-off",
+                                            hide_details=True,
+                                            dense=True,
+                                            title="Toggle this rotation",
+                                        )
+                                    vuetify.VSpacer()
+                                    with vuetify.VCol(cols="auto"):
+                                        vuetify.VBtn(
+                                            icon="mdi-restore",
+                                            click=ft.partial(
+                                                self.server.controller.reset_rotation_angle,
+                                                i,
+                                            ),
+                                            small=True,
+                                            dense=True,
+                                            title="Reset angle to zero",
+                                        )
+                                    vuetify.VSpacer()
+                                    with vuetify.VCol(cols="auto"):
+                                        vuetify.VBtn(
+                                            icon="mdi-delete",
+                                            click=ft.partial(
+                                                self.server.controller.remove_rotation_event,
+                                                i,
+                                            ),
+                                            small=True,
+                                            dense=True,
+                                            color="error",
+                                            title="Remove this rotation",
+                                            disabled=(
+                                                f"!mpr_rotation_data.angles_list[{i}].deletable",
+                                            ),
+                                        )
+                                    vuetify.VSpacer()
 
                     # Angle units selector
                     with vuetify.VRow(
@@ -629,7 +641,7 @@ class UI:
                             vuetify.VLabel("Units:")
                         with vuetify.VCol(cols="8"):
                             vuetify.VSelect(
-                                v_model=("angle_units", "degrees"),
+                                v_model=("angle_units", "radians"),
                                 items=("angle_units_items", []),
                                 item_title="text",
                                 item_value="value",
@@ -638,10 +650,29 @@ class UI:
                                 outlined=True,
                             )
 
+                    # Axis convention selector
+                    with vuetify.VRow(
+                        v_if="!maximized_view && active_volume_label",
+                        no_gutters=True,
+                        classes="align-center mb-2",
+                    ):
+                        with vuetify.VCol(cols="4"):
+                            vuetify.VLabel("Convention:")
+                        with vuetify.VCol(cols="8"):
+                            vuetify.VSelect(
+                                v_model=("index_order", "itk"),
+                                items=("index_order_items", []),
+                                item_title="text",
+                                item_value="value",
+                                dense=True,
+                                hide_details=True,
+                                outlined=True,
+                            )
+
                     # Save rotations button
                     vuetify.VBtn(
                         "Save Rotations",
-                        v_if="!maximized_view && active_volume_label && mpr_rotation_sequence && mpr_rotation_sequence.length > 0",
+                        v_if="!maximized_view && active_volume_label && mpr_rotation_data.angles_list && mpr_rotation_data.angles_list.length > 0",
                         click=self.server.controller.save_rotation_angles,
                         small=True,
                         dense=True,

cardio/utils.py

@@ -10,13 +10,6 @@ class InterpolatorType(enum.Enum):
     NEAREST = "nearest"
 
 
-class AngleUnit(enum.Enum):
-    """Units for angle measurements."""
-
-    DEGREES = "degrees"
-    RADIANS = "radians"
-
-
 def calculate_combined_bounds(actors):
     """Calculate combined bounds encompassing all VTK actors.
 

cardio/volume.py

@@ -206,17 +206,17 @@ class Volume(Object):
                 )
             elif view_name == "sagittal":
                 view_crosshairs["line1"]["actor"].GetProperty().SetColor(
-                    *colors.get("axial", (0, 0, 1))
+                    *colors.get("coronal", (0, 1, 0))
                 )
                 view_crosshairs["line2"]["actor"].GetProperty().SetColor(
-                    *colors.get("coronal", (0, 1, 0))
+                    *colors.get("axial", (0, 0, 1))
                 )
             else:  # coronal
                 view_crosshairs["line1"]["actor"].GetProperty().SetColor(
-                    *colors.get("axial", (0, 0, 1))
+                    *colors.get("sagittal", (1, 0, 0))
                 )
                 view_crosshairs["line2"]["actor"].GetProperty().SetColor(
-                    *colors.get("sagittal", (1, 0, 0))
+                    *colors.get("axial", (0, 0, 1))
                 )
 
             crosshairs[view_name] = view_crosshairs
@@ -299,15 +299,20 @@ class Volume(Object):
         return bounds
 
     def _build_cumulative_rotation(
-        self, rotation_sequence: list, rotation_angles: dict
+        self, rotation_sequence: list, rotation_angles: dict, angle_units=None
     ) -> np.ndarray:
         """Build cumulative rotation matrix from sequence of rotations."""
+        from .orientation import AngleUnits
+
+        if angle_units is None:
+            angle_units = AngleUnits.DEGREES
+
         cumulative_rotation = np.eye(3)
         if rotation_sequence and rotation_angles:
             for i, rotation in enumerate(rotation_sequence):
                 angle = rotation_angles.get(i, 0)
                 rotation_matrix = euler_angle_to_rotation_matrix(
-                    EulerAxis(rotation["axis"]), angle
+                    EulerAxis(rotation["axis"]), angle, angle_units
                 )
                 cumulative_rotation = cumulative_rotation @ rotation_matrix
         return cumulative_rotation
@@ -317,6 +322,7 @@ class Volume(Object):
         view_name: str,
         rotation_sequence: list = None,
         rotation_angles: dict = None,
+        angle_units=None,
     ) -> np.ndarray:
         """Get the current normal vector for a view after rotation.
 
@@ -324,6 +330,7 @@ class Volume(Object):
             view_name: One of "axial", "sagittal", "coronal"
             rotation_sequence: List of rotation definitions
             rotation_angles: Dict mapping rotation index to angle
+            angle_units: AngleUnits enum (degrees or radians)
 
         Returns:
             3D unit vector representing the scroll direction for this view
@@ -338,7 +345,7 @@ class Volume(Object):
             return np.array([0.0, 0.0, 1.0])
 
         cumulative_rotation = self._build_cumulative_rotation(
-            rotation_sequence, rotation_angles
+            rotation_sequence, rotation_angles, angle_units
         )
         return cumulative_rotation @ base_normals[view_name]
 
@@ -348,6 +355,7 @@ class Volume(Object):
         origin: list,
         rotation_sequence: list = None,
         rotation_angles: dict = None,
+        angle_units=None,
     ):
         """Update slice positions for MPR views with optional rotation.
 
@@ -356,7 +364,12 @@ class Volume(Object):
             origin: [x, y, z] position in LPS coordinates (shared by all views)
             rotation_sequence: List of rotation definitions
             rotation_angles: Dict mapping rotation index to angle
+            angle_units: AngleUnits enum (degrees or radians), defaults to DEGREES
         """
+        from .orientation import AngleUnits
+
+        if angle_units is None:
+            angle_units = AngleUnits.DEGREES
         if frame not in self._mpr_actors:
             return
 
@@ -367,7 +380,7 @@ class Volume(Object):
 
         # Build cumulative rotation matrix
         cumulative_rotation = self._build_cumulative_rotation(
-            rotation_sequence, rotation_angles
+            rotation_sequence, rotation_angles, angle_units
         )
 
         # Apply rotation to base transforms

{cardio-2025.12.0.dist-info → cardio-2026.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cardio
-Version: 2025.12.0
+Version: 2026.1.2
 Summary: A simple web-based viewer for 3D and 4D ('cine') medical imaging data.
 Keywords: Medical,Imaging,3D,4D,Visualization
 Author: Davis Marc Vigneault
@@ -60,8 +60,8 @@ Description-Content-Type: text/markdown
 built primarily on [trame](https://github.com/kitware/trame),
 [vtk](https://github.com/kitware/vtk), and
 [itk](https://github.com/insightsoftwareconsortium/itk).  `cardio` can render sequences
-of mesh files (e.g., `\*.obj` files), segmentation files (e.g., `\*nii.gz` files with
-discrete labels) and volume renderings of grayscale images (e.g., `\*.nii.gz` files with
+of mesh files (e.g., `*.obj` files), segmentation files (e.g., `*.nii.gz` files with
+discrete labels) and volume renderings of grayscale images (e.g., `*.nii.gz` files with
 continuous values).  `cardio` is launched from the commandline and may be configured via
 commandline arguments, a static TOML configuration file, or a combination of the two.
 
@@ -75,7 +75,7 @@ $ uv init
 $ uv add cardio
 $ . ./.venv/bin/activate
 (project) cardio --version
-cardio 2025.12.0
+cardio 2026.1.2
 ```
 
 ### Developing

{cardio-2025.12.0.dist-info → cardio-2026.1.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-cardio/__init__.py,sha256=laKThzytBHNMY_Z5Qy9-jF25NpfSyfDM9VGrG4bhJ14,602
+cardio/__init__.py,sha256=1g0tFk2oSQTiQO_WcuDGxiGlutHUn7H4yLY3iMyFIm8,601
 cardio/app.py,sha256=h-Xh57Txw3Hom-fDv08YxjXzovuIxY8_5qPy6MJThZs,1354
 cardio/assets/bone.toml,sha256=vv8uVYSHIoKuHkNCoBOkGe2_qoEbXMvQO6ypm3mMOtA,675
 cardio/assets/vascular_closed.toml,sha256=XtaZS_Zd6NSAtY3ZlUfiog3T86u9Ii0oSutU2wBQy78,1267
@@ -6,24 +6,25 @@ cardio/assets/vascular_open.toml,sha256=1M3sV1IGt3zh_3vviysKEk9quKfjF9xUBcIq3kxV
 cardio/assets/xray.toml,sha256=siPem0OZ2OkWH0e5pizftpItJKGJgxKJ_S2K0316ubQ,693
 cardio/blend_transfer_functions.py,sha256=fkLDYGMj_QXYs0vmXYT_B1tgTfl3YICLYimtWlxrmbQ,2958
 cardio/color_transfer_function.py,sha256=uTyPdwxi0HjR4wm418cQN9-q9SspkkeqvLNqXaF3zzg,792
-cardio/logic.py,sha256=e7OaroXgpq6oE3Zfa2afusVsEzopkpL4YdEGPuFINzc,39885
+cardio/logic.py,sha256=XR7e5sb8vm7t3himwxOBR3OBP2QZxadb2hoGhqSTwiw,42877
 cardio/mesh.py,sha256=wYdU0BU84eXrrHp0U0VLwYW7ZpRJ6GbT5Kl_-K6CBzY,9356
 cardio/object.py,sha256=98A32VpFR4UtVqW8dZsRJR13VVyUoJJ20uoOZBgN4js,6168
-cardio/orientation.py,sha256=GRm6Ix3hzMXybgKgpJip0Mlodqn_LCV9VaGFjTAmS-A,6122
+cardio/orientation.py,sha256=xsWAFPwf3-toT4XFYyGiZJkcGFQ2uz3eLxpC1_i6yZ8,6266
 cardio/piecewise_function.py,sha256=X-_C-BVStufmFjfF8IbkqKk9Xw_jh00JUmjC22ZqeqQ,764
 cardio/property_config.py,sha256=YrWIyCoSAfJPigkhriIQybQpJantGnXjT4nJfrtIJco,1689
-cardio/scene.py,sha256=H_GxJ6Dq2QVx7RJYwwvleLL5M_egTzFd0bJ95TqtrhI,14530
+cardio/rotation.py,sha256=IoIoyhAdtBB90myY2GezXMjPbQ-JLMRTgQCpFSVZKBg,5096
+cardio/scene.py,sha256=FrUQIJrBR_jPrW7utOI3uDbaUxjmZEapzVTEVIgEWaA,15365
 cardio/screenshot.py,sha256=l8bLgxnU5O0FlnmsyVAzKwM9Y0401IzcdnDP0WqFSTY,640
 cardio/segmentation.py,sha256=KT1ClgultXyGpZDdpYxor38GflY7uCgRzfA8JEGQVaU,6642
 cardio/transfer_function_pair.py,sha256=_J0qXA0InUPpvfWPcW492KGSYAqeb12htCzKBSpWHwo,780
 cardio/types.py,sha256=jxSZjvxEJ03OThfupT2CG9UHsFklwbWeFrUozNXro2I,333
-cardio/ui.py,sha256=KwRGb_vDZ6pi8TQ82Ios7zcG9xmvd2hzCv45h0voNMM,50109
-cardio/utils.py,sha256=tFUQ4FxfidTH6GjEIKQwguqhO9T_wJ2Vk0IhbEfxRGA,1616
-cardio/volume.py,sha256=wKvEhjCGhnn8Se-VVNyurspfH9IgAvqp7Br_j0wUdDM,14536
+cardio/ui.py,sha256=esmJzoJE-lKoWHYWg1Zbq_Z1ydIt4ggHXf1i14J0PrM,53181
+cardio/utils.py,sha256=ao4a7_vMjGBxTOMhZ7r0D0W4ujiwKPS0i8Xfmn3Gv9k,1497
+cardio/volume.py,sha256=sdQ7gtX4jQDD9U8U95xD9LIV_1hpykj8NTCo1_aIKVM,15035
 cardio/volume_property.py,sha256=-EUMV9sWCaetgGjnqIWxPp39qrxEZKTNDJ5GHUgLMlk,1619
 cardio/volume_property_presets.py,sha256=4-hjo-dukm5sMMmWidbWnVXq0IN4sWpBnDITY9MqUFg,1625
 cardio/window_level.py,sha256=XMkwLAHcmsEYcI0SoHySQZvptq4VwX2gj--ps3hV8AQ,784
-cardio-2025.12.0.dist-info/WHEEL,sha256=4n27za1eEkOnA7dNjN6C5-O2rUiw6iapszm14Uj-Qmk,79
-cardio-2025.12.0.dist-info/entry_points.txt,sha256=xRd1otqKtW9xmidJ4CFRX1V9KWmsBbtxrgMtDColq3w,40
-cardio-2025.12.0.dist-info/METADATA,sha256=y1706xsek2kYRBsXskEqYxAHdBl5ovdWOIkXULc572o,3522
-cardio-2025.12.0.dist-info/RECORD,,
+cardio-2026.1.2.dist-info/WHEEL,sha256=4n27za1eEkOnA7dNjN6C5-O2rUiw6iapszm14Uj-Qmk,79
+cardio-2026.1.2.dist-info/entry_points.txt,sha256=xRd1otqKtW9xmidJ4CFRX1V9KWmsBbtxrgMtDColq3w,40
+cardio-2026.1.2.dist-info/METADATA,sha256=STZ2oobYKN12HQD_jH_w0HANJ_b4L-PM9bB41eIJZ0Q,3518
+cardio-2026.1.2.dist-info/RECORD,,