cardio 2025.12.0__tar.gz → 2026.1.0__tar.gz

{cardio-2025.12.0 → cardio-2026.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cardio
-Version: 2025.12.0
+Version: 2026.1.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
@@ -75,7 +75,7 @@ $ uv init
 $ uv add cardio
 $ . ./.venv/bin/activate
 (project) cardio --version
-cardio 2025.12.0
+cardio 2026.1.0
 ```
 
 ### Developing

{cardio-2025.12.0 → cardio-2026.1.0}/README.md

@@ -19,7 +19,7 @@ $ uv init
 $ uv add cardio
 $ . ./.venv/bin/activate
 (project) cardio --version
-cardio 2025.12.0
+cardio 2026.1.0
 ```
 
 ### Developing

{cardio-2025.12.0 → cardio-2026.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "cardio"
-version = "2025.12.0"
+version = "2026.1.0"
 authors = [
     {name = "Davis Marc Vigneault", email = "davis.vigneault@gmail.com"}
 ]
@@ -62,7 +62,7 @@ repository = "https://github.com/sudomakeinstall/cardio"
 profile = "black"
 
 [tool.bumpver]
-current_version = "2025.12.0"
+current_version = "2026.1.0"
 version_pattern = "YYYY.MM.INC0"
 commit_message = "ENH: Bump version from {old_version} => {new_version}"
 commit = true

{cardio-2025.12.0 → cardio-2026.1.0}/src/cardio/__init__.py

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

{cardio-2025.12.0 → cardio-2026.1.0}/src/cardio/logic.py

@@ -10,14 +10,22 @@ 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", [])
+        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
+
         return rotation_sequence, rotation_angles
 
     def __init__(self, server, scene: Scene):
@@ -39,6 +47,12 @@ class Logic:
             {"text": "Radians", "value": "radians"},
         ]
 
+        # Initialize axis convention items for dropdown
+        self.server.state.axis_convention_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 +69,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("axis_convention")(self.sync_axis_convention)
 
         # Initialize visibility state variables
         for m in self.scene.meshes:
@@ -160,6 +166,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 +183,14 @@ 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
+
+        # 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.angle_units.value
+        self.server.state.axis_convention = self.scene.axis_convention.value
 
         # Initialize MPR presets data
         try:
@@ -190,12 +203,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 +326,7 @@ class Logic:
             origin,
             rotation_sequence,
             rotation_angles,
+            self.scene.angle_units,
         )
 
         # Apply window/level
@@ -490,63 +498,35 @@ 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
-
-        # 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)
+        rotation_data = getattr(
+            self.server.state, "mpr_rotation_data", {"angles_list": []}
+        )
+        rotation_seq = RotationSequence.from_ui_dict(rotation_data, active_volume_label)
 
-        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
 
-        # 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,
+            target_convention=self.scene.axis_convention,
+            target_units=self.scene.angle_units,
+        )
 
     def reset_all(self):
         self.server.state.frame = 0
@@ -573,13 +553,55 @@ 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
+
+        from .orientation import AngleUnits
+
+        # Get current units before changing
+        old_units = self.scene.angle_units
 
         # Update the scene's angle_units field 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.angle_units = new_units
+
+    def sync_axis_convention(self, axis_convention, **kwargs):
+        """Sync axis convention selection - updates the scene configuration."""
+        from .orientation import AxisConvention
+
+        if axis_convention == "itk":
+            self.scene.axis_convention = AxisConvention.ITK
+        elif axis_convention == "roma":
+            self.scene.axis_convention = AxisConvention.ROMA
 
     def _initialize_clipping_state(self):
         """Initialize clipping state variables for all objects."""
@@ -771,6 +793,7 @@ class Logic:
             origin,
             rotation_sequence,
             rotation_angles,
+            self.scene.angle_units,
         )
 
         # Update all views
@@ -869,6 +892,7 @@ class Logic:
             origin,
             rotation_sequence,
             rotation_angles,
+            self.scene.angle_units,
         )
 
         # Update all views
@@ -901,46 +925,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": []})
+        )
+        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,
+            }
         )
-        current_sequence.append({"axis": axis, "angle": 0})
-        self.server.state.mpr_rotation_sequence = current_sequence
-        self.update_mpr_rotation_labels()
+
+        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."""

{cardio-2025.12.0 → cardio-2026.1.0}/src/cardio/orientation.py

@@ -11,6 +11,11 @@ class EulerAxis(Enum):
     Z = "Z"
 
 
+class AxisConvention(Enum):
+    ITK = "itk"  # X=Left, Y=Posterior, Z=Superior
+    ROMA = "roma"  # X=Superior, Y=Posterior, Z=Left
+
+
 class AngleUnits(Enum):
     DEGREES = "degrees"
     RADIANS = "radians"

cardio-2026.1.0/src/cardio/rotation.py

@@ -0,0 +1,211 @@
+# 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, AxisConvention
+
+
+class RotationStep(pc.BaseModel):
+    """Single rotation step (stored in ITK convention, radians)."""
+
+    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
+
+    def to_convention(
+        self, convention: AxisConvention, units: AngleUnits
+    ) -> tuple[str, float]:
+        """Convert to target convention/units for serialization."""
+        axis = self.axes
+        angle = self.angle
+
+        if convention == AxisConvention.ROMA:
+            axis = {"X": "Z", "Y": "Y", "Z": "X"}[axis]
+            angle = -angle
+
+        if units == AngleUnits.DEGREES:
+            angle = np.degrees(angle)
+
+        return axis, angle
+
+    @classmethod
+    def from_convention(
+        cls,
+        axes: str,
+        angle: float,
+        convention: AxisConvention,
+        units: AngleUnits,
+        **kwargs,
+    ) -> "RotationStep":
+        """Create from target convention/units (for deserialization)."""
+        if units == AngleUnits.DEGREES:
+            angle = np.radians(angle)
+
+        if convention == AxisConvention.ROMA:
+            axes = {"X": "Z", "Y": "Y", "Z": "X"}[axes]
+            angle = -angle
+
+        return cls(axes=axes, angle=angle, **kwargs)
+
+
+class RotationMetadata(pc.BaseModel):
+    """Metadata for TOML files."""
+
+    coordinate_system: ty.Literal["LPS"] = "LPS"
+    axis_convention: AxisConvention = AxisConvention.ITK
+    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 (stored in ITK convention, radians)."""
+
+    model_config = pc.ConfigDict(frozen=False)
+
+    metadata: RotationMetadata = pc.Field(default_factory=RotationMetadata)
+    angles_list: list[RotationStep] = pc.Field(default_factory=list)
+
+    @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 (always ITK/radians internally).
+
+        Note: 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
+            ]
+        }
+
+    @classmethod
+    def from_ui_dict(cls, data: dict, volume_label: str = "") -> "RotationSequence":
+        """Create from UI format (assumes ITK/radians)."""
+        angles_list = [RotationStep(**step) for step in data.get("angles_list", [])]
+        metadata = RotationMetadata(volume_label=volume_label)
+        return cls(metadata=metadata, angles_list=angles_list)
+
+    def to_toml(
+        self, target_convention: AxisConvention, target_units: AngleUnits
+    ) -> str:
+        """Serialize to TOML with conversions."""
+        doc = tk.document()
+
+        metadata_table = tk.table()
+        metadata_table["coordinate_system"] = self.metadata.coordinate_system
+        metadata_table["axis_convention"] = target_convention.value
+        metadata_table["units"] = target_units.value
+        metadata_table["timestamp"] = self.metadata.timestamp
+        metadata_table["volume_label"] = self.metadata.volume_label
+        doc["metadata"] = metadata_table
+
+        rotations_array = tk.aot()
+        for step in self.angles_list:
+            rotation = tk.table()
+            converted_axis, converted_angle = step.to_convention(
+                target_convention, target_units
+            )
+            rotation["axes"] = converted_axis
+            rotation["angle"] = converted_angle
+            rotation["visible"] = step.visible
+            rotation["name"] = step.name
+            rotation["name_editable"] = step.name_editable
+            rotation["deletable"] = step.deletable
+            rotations_array.append(rotation)
+
+        doc["angles_list"] = rotations_array
+
+        return tk.dumps(doc)
+
+    @classmethod
+    def from_toml(cls, toml_content: str) -> "RotationSequence":
+        """Deserialize from TOML with conversions."""
+        doc = tk.loads(toml_content)
+
+        metadata_dict = doc.get("metadata", {})
+        convention = AxisConvention(metadata_dict.get("axis_convention", "itk"))
+        units = AngleUnits(metadata_dict.get("units", "radians"))
+
+        metadata = RotationMetadata(
+            coordinate_system=metadata_dict.get("coordinate_system", "LPS"),
+            axis_convention=convention,
+            units=units,
+            timestamp=metadata_dict.get("timestamp", dt.datetime.now().isoformat()),
+            volume_label=metadata_dict.get("volume_label", ""),
+        )
+
+        angles_list_data = doc.get("angles_list", [])
+        angles_list = []
+        for item in angles_list_data:
+            axes = item.get("axes", "X")
+            angle = item.get("angle", 0.0)
+            step = RotationStep.from_convention(
+                axes=axes,
+                angle=angle,
+                convention=convention,
+                units=units,
+                visible=item.get("visible", True),
+                name=item.get("name", ""),
+                name_editable=item.get("name_editable", True),
+                deletable=item.get("deletable", True),
+            )
+            angles_list.append(step)
+
+        return cls(metadata=metadata, angles_list=angles_list)
+
+    @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,
+        target_convention: AxisConvention,
+        target_units: AngleUnits,
+    ):
+        """Save to TOML file."""
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w") as f:
+            f.write(self.to_toml(target_convention, target_units))

{cardio-2025.12.0 → cardio-2026.1.0}/src/cardio/scene.py

@@ -8,9 +8,10 @@ import pydantic_settings as ps
 import vtk
 
 from .mesh import Mesh
+from .orientation import AngleUnits, AxisConvention
+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,31 @@ 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,
+    angle_units: AngleUnits = pc.Field(
+        default=AngleUnits.RADIANS,
         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)"
+    )
+    axis_convention: AxisConvention = pc.Field(
+        default=AxisConvention.ITK,
+        description="Axis convention for saved rotations (ITK: X=L,Y=P,Z=S; Roma: X=S,Y=P,Z=L)",
     )
     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 +185,23 @@ 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
+                )
+
+        return self
+
     # VTK objects as private attributes
     _renderer: vtk.vtkRenderer = pc.PrivateAttr(default_factory=vtk.vtkRenderer)
     _renderWindow: vtk.vtkRenderWindow = pc.PrivateAttr(

{cardio-2025.12.0 → cardio-2026.1.0}/src/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=("axis_convention", "itk"),
+                                items=("axis_convention_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-2025.12.0 → cardio-2026.1.0}/src/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-2025.12.0 → cardio-2026.1.0}/src/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