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

cardio/__init__.py

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

cardio/app.py

@@ -1,11 +1,9 @@
 #!/usr/bin/env python
 
-# Third Party
 import pydantic_settings as ps
 import trame as tm
 import trame.decorators
 
-# Internal
 from . import __version__
 from .logic import Logic
 from .scene import Scene

cardio/blend_transfer_functions.py

@@ -1,7 +1,4 @@
-# System
 import numpy as np
-
-# Third Party
 import vtk
 
 

cardio/color_transfer_function.py

@@ -1,8 +1,6 @@
-# Third Party
 import pydantic as pc
 import vtk
 
-# Internal
 from .types import RGBColor
 
 

cardio/logic.py

@@ -8,6 +8,26 @@ from .screenshot import Screenshot
 
 
 class Logic:
+    def _get_visible_rotation_data(self):
+        """Get rotation sequence and angles for visible rotations only."""
+        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 = {}
+
+        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):
         self.server = server
         self.scene = scene
@@ -27,34 +47,31 @@ class Logic:
             {"text": "Radians", "value": "radians"},
         ]
 
-        # Initialize slice bounds (will be updated when active volume changes)
-        self.server.state.axial_slice_bounds = [0.0, 100.0]
-        self.server.state.sagittal_slice_bounds = [0.0, 100.0]
-        self.server.state.coronal_slice_bounds = [0.0, 100.0]
+        # 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
 
         self.server.state.change("frame")(self.update_frame)
         self.server.state.change("playing")(self.play)
         self.server.state.change("theme_mode")(self.sync_background_color)
-        self.server.state.change("mpr_enabled")(self.sync_mpr_mode)
         self.server.state.change("active_volume_label")(self.sync_active_volume)
-        self.server.state.change("axial_slice", "sagittal_slice", "coronal_slice")(
-            self.update_slice_positions
+        self.server.state.change("mpr_origin")(self.update_slice_positions)
+        self.server.state.change("mpr_crosshairs_enabled")(
+            self.sync_crosshairs_visibility
         )
         self.server.state.change("mpr_window", "mpr_level")(
             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:
@@ -140,25 +157,40 @@ class Logic:
         self.server.controller.save_rotation_angles = self.save_rotation_angles
         self.server.controller.reset_all = self.reset_all
         self.server.controller.close_application = self.close_application
+        self.server.controller.finalize_mpr_initialization = (
+            self.finalize_mpr_initialization
+        )
 
         # MPR rotation controllers
         self.server.controller.add_x_rotation = lambda: self.add_mpr_rotation("X")
         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
         self.server.state.mpr_enabled = self.scene.mpr_enabled
-        self.server.state.active_volume_label = self.scene.active_volume_label
-        self.server.state.axial_slice = self.scene.axial_slice
-        self.server.state.sagittal_slice = self.scene.sagittal_slice
-        self.server.state.coronal_slice = self.scene.coronal_slice
+        # Initialize active_volume_label to empty string (actual value set after UI ready)
+        self.server.state.active_volume_label = ""
+        # Store the actual volume label to set later, avoiding race condition
+        self._pending_active_volume = (
+            self.scene.volumes[0].label
+            if self.scene.volumes and not self.scene.active_volume_label
+            else self.scene.active_volume_label
+        )
+        self.server.state.mpr_origin = list(self.scene.mpr_origin)
         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:
@@ -171,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
@@ -236,6 +262,10 @@ class Logic:
         # Get or create MPR actors for the new frame
         mpr_actors = active_volume.get_mpr_actors_for_frame(frame)
 
+        # Get crosshair visibility state
+        crosshairs_visible = getattr(self.server.state, "mpr_crosshairs_enabled", True)
+        crosshairs = active_volume.crosshair_actors
+
         # Update each MPR renderer with the new frame's actors
         if self.scene.axial_renderWindow:
             axial_renderer = (
@@ -245,8 +275,11 @@ class Logic:
                 axial_renderer.RemoveAllViewProps()
                 axial_renderer.AddActor(mpr_actors["axial"]["actor"])
                 mpr_actors["axial"]["actor"].SetVisibility(True)
-                # Apply current slice position and window/level
-                self._apply_current_mpr_settings(active_volume, frame)
+                # Re-add crosshairs
+                if crosshairs and "axial" in crosshairs:
+                    for line_data in crosshairs["axial"].values():
+                        axial_renderer.AddActor2D(line_data["actor"])
+                        line_data["actor"].SetVisibility(crosshairs_visible)
                 axial_renderer.ResetCamera()
 
         if self.scene.coronal_renderWindow:
@@ -257,6 +290,11 @@ class Logic:
                 coronal_renderer.RemoveAllViewProps()
                 coronal_renderer.AddActor(mpr_actors["coronal"]["actor"])
                 mpr_actors["coronal"]["actor"].SetVisibility(True)
+                # Re-add crosshairs
+                if crosshairs and "coronal" in crosshairs:
+                    for line_data in crosshairs["coronal"].values():
+                        coronal_renderer.AddActor2D(line_data["actor"])
+                        line_data["actor"].SetVisibility(crosshairs_visible)
                 coronal_renderer.ResetCamera()
 
         if self.scene.sagittal_renderWindow:
@@ -267,30 +305,28 @@ class Logic:
                 sagittal_renderer.RemoveAllViewProps()
                 sagittal_renderer.AddActor(mpr_actors["sagittal"]["actor"])
                 mpr_actors["sagittal"]["actor"].SetVisibility(True)
+                # Re-add crosshairs
+                if crosshairs and "sagittal" in crosshairs:
+                    for line_data in crosshairs["sagittal"].values():
+                        sagittal_renderer.AddActor2D(line_data["actor"])
+                        line_data["actor"].SetVisibility(crosshairs_visible)
                 sagittal_renderer.ResetCamera()
 
+        # Apply current slice position and window/level to all views
+        self._apply_current_mpr_settings(active_volume, frame)
+
     def _apply_current_mpr_settings(self, active_volume, frame):
         """Apply current slice positions and window/level to MPR actors."""
         # Apply slice positions
-        axial_slice = getattr(self.server.state, "axial_slice", 0.5)
-        sagittal_slice = getattr(self.server.state, "sagittal_slice", 0.5)
-        coronal_slice = getattr(self.server.state, "coronal_slice", 0.5)
-
-        # Get rotation data
-        rotation_sequence = getattr(self.server.state, "mpr_rotation_sequence", [])
-        rotation_angles = {}
-        for i in range(len(rotation_sequence)):
-            rotation_angles[i] = getattr(
-                self.server.state, f"mpr_rotation_angle_{i}", 0
-            )
+        origin = getattr(self.server.state, "mpr_origin", [0.0, 0.0, 0.0])
+        rotation_sequence, rotation_angles = self._get_visible_rotation_data()
 
         active_volume.update_slice_positions(
             frame,
-            axial_slice,
-            sagittal_slice,
-            coronal_slice,
+            origin,
             rotation_sequence,
             rotation_angles,
+            self.scene.angle_units,
         )
 
         # Apply window/level
@@ -462,62 +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
-
-        # Slice positions section
-        slice_positions = tk.table()
-        slice_positions["axial"] = getattr(self.server.state, "axial_slice", 0.5)
-        slice_positions["sagittal"] = getattr(self.server.state, "sagittal_slice", 0.5)
-        slice_positions["coronal"] = getattr(self.server.state, "coronal_slice", 0.5)
-        doc["slice_positions"] = slice_positions
-
-        # 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
@@ -544,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."""
@@ -633,32 +684,32 @@ class Logic:
         if not active_volume:
             return
 
-        # Update slice bounds based on active volume
+        # Initialize origin to volume center (in LPS coordinates)
         try:
-            bounds = active_volume.get_physical_bounds()
-            self.server.state.axial_slice_bounds = [bounds[4], bounds[5]]  # Z bounds
-            self.server.state.sagittal_slice_bounds = [bounds[0], bounds[1]]  # X bounds
-            self.server.state.coronal_slice_bounds = [bounds[2], bounds[3]]  # Y bounds
-
-            # Initialize slice positions to volume center if they are currently 0.0 (scene defaults)
-            if self.server.state.axial_slice == 0.0:
-                self.server.state.axial_slice = (bounds[4] + bounds[5]) / 2  # Z center
-            if self.server.state.sagittal_slice == 0.0:
-                self.server.state.sagittal_slice = (
-                    bounds[0] + bounds[1]
-                ) / 2  # X center
-            if self.server.state.coronal_slice == 0.0:
-                self.server.state.coronal_slice = (
-                    bounds[2] + bounds[3]
-                ) / 2  # Y center
+            current_frame = getattr(self.server.state, "frame", 0)
+            volume_actor = active_volume.actors[current_frame]
+            image_data = volume_actor.GetMapper().GetInput()
+            center = image_data.GetCenter()
+
+            # Set origin to volume center if it's at default [0,0,0]
+            current_origin = getattr(self.server.state, "mpr_origin", [0.0, 0.0, 0.0])
+            if current_origin == [0.0, 0.0, 0.0]:
+                self.server.state.mpr_origin = list(center)
         except (RuntimeError, IndexError) as e:
-            print(f"Error: Cannot get bounds for volume '{active_volume_label}': {e}")
+            print(f"Error: Cannot get center for volume '{active_volume_label}': {e}")
             return
 
         # Create MPR actors for current frame
         current_frame = getattr(self.server.state, "frame", 0)
         mpr_actors = active_volume.get_mpr_actors_for_frame(current_frame)
 
+        # Create crosshair actors
+        crosshairs = active_volume.create_crosshair_actors(
+            colors=self.scene.mpr_crosshair_colors,
+            line_width=self.scene.mpr_crosshair_width,
+        )
+        crosshairs_visible = getattr(self.server.state, "mpr_crosshairs_enabled", True)
+
         # Add MPR actors to their respective renderers
         if self.scene.axial_renderWindow:
             axial_renderer = (
@@ -668,6 +719,10 @@ class Logic:
                 axial_renderer.RemoveAllViewProps()  # Clear existing actors
                 axial_renderer.AddActor(mpr_actors["axial"]["actor"])
                 mpr_actors["axial"]["actor"].SetVisibility(True)
+                # Add 2D crosshair overlay actors
+                for line_data in crosshairs["axial"].values():
+                    axial_renderer.AddActor2D(line_data["actor"])
+                    line_data["actor"].SetVisibility(crosshairs_visible)
                 axial_renderer.ResetCamera()
 
         if self.scene.coronal_renderWindow:
@@ -678,6 +733,10 @@ class Logic:
                 coronal_renderer.RemoveAllViewProps()
                 coronal_renderer.AddActor(mpr_actors["coronal"]["actor"])
                 mpr_actors["coronal"]["actor"].SetVisibility(True)
+                # Add 2D crosshair overlay actors
+                for line_data in crosshairs["coronal"].values():
+                    coronal_renderer.AddActor2D(line_data["actor"])
+                    line_data["actor"].SetVisibility(crosshairs_visible)
                 coronal_renderer.ResetCamera()
 
         if self.scene.sagittal_renderWindow:
@@ -688,6 +747,10 @@ class Logic:
                 sagittal_renderer.RemoveAllViewProps()
                 sagittal_renderer.AddActor(mpr_actors["sagittal"]["actor"])
                 mpr_actors["sagittal"]["actor"].SetVisibility(True)
+                # Add 2D crosshair overlay actors
+                for line_data in crosshairs["sagittal"].values():
+                    sagittal_renderer.AddActor2D(line_data["actor"])
+                    line_data["actor"].SetVisibility(crosshairs_visible)
                 sagittal_renderer.ResetCamera()
 
         # Apply current window/level settings to the MPR actors
@@ -718,28 +781,19 @@ class Logic:
         if not active_volume:
             return
 
-        # Get current slice positions
-        axial_slice = getattr(self.server.state, "axial_slice", 0.5)
-        sagittal_slice = getattr(self.server.state, "sagittal_slice", 0.5)
-        coronal_slice = getattr(self.server.state, "coronal_slice", 0.5)
+        # Get current origin and frame
+        origin = getattr(self.server.state, "mpr_origin", [0.0, 0.0, 0.0])
         current_frame = getattr(self.server.state, "frame", 0)
 
-        # Get rotation data
-        rotation_sequence = getattr(self.server.state, "mpr_rotation_sequence", [])
-        rotation_angles = {}
-        for i in range(len(rotation_sequence)):
-            rotation_angles[i] = getattr(
-                self.server.state, f"mpr_rotation_angle_{i}", 0
-            )
+        rotation_sequence, rotation_angles = self._get_visible_rotation_data()
 
         # Update slice positions with rotation
         active_volume.update_slice_positions(
             current_frame,
-            axial_slice,
-            sagittal_slice,
-            coronal_slice,
+            origin,
             rotation_sequence,
             rotation_angles,
+            self.scene.angle_units,
         )
 
         # Update all views
@@ -826,81 +880,109 @@ class Logic:
         if not active_volume:
             return
 
-        # Get current slice positions
-        axial_slice = getattr(self.server.state, "axial_slice", 0.5)
-        sagittal_slice = getattr(self.server.state, "sagittal_slice", 0.5)
-        coronal_slice = getattr(self.server.state, "coronal_slice", 0.5)
+        # Get current origin and frame
+        origin = getattr(self.server.state, "mpr_origin", [0.0, 0.0, 0.0])
         current_frame = getattr(self.server.state, "frame", 0)
 
-        # Get rotation data - include all visible rotations
-        rotation_sequence = getattr(self.server.state, "mpr_rotation_sequence", [])
-        rotation_angles = {}
-
-        # Include all visible rotations regardless of position
-        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
-                )
+        rotation_sequence, rotation_angles = self._get_visible_rotation_data()
 
         # Update slice positions with rotation
         active_volume.update_slice_positions(
             current_frame,
-            axial_slice,
-            sagittal_slice,
-            coronal_slice,
+            origin,
             rotation_sequence,
             rotation_angles,
+            self.scene.angle_units,
         )
 
         # Update all views
         self.server.controller.view_update()
 
+    def sync_crosshairs_visibility(self, **kwargs):
+        """Toggle crosshair visibility on all MPR views."""
+        if not getattr(self.server.state, "mpr_enabled", False):
+            return
+
+        active_volume_label = getattr(self.server.state, "active_volume_label", "")
+        if not active_volume_label:
+            return
+
+        # Find the active volume
+        active_volume = None
+        for volume in self.scene.volumes:
+            if volume.label == active_volume_label:
+                active_volume = volume
+                break
+
+        if not active_volume:
+            return
+
+        visible = getattr(self.server.state, "mpr_crosshairs_enabled", True)
+        active_volume.set_crosshairs_visible(visible)
+        self.server.controller.view_update()
+
     def add_mpr_rotation(self, axis):
         """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."""
+        if hasattr(self, "_pending_active_volume") and self._pending_active_volume:
+            self.server.state.active_volume_label = self._pending_active_volume
+            # Manually trigger sync_active_volume since state change may not fire during on_server_ready
+            self.sync_active_volume(self._pending_active_volume)
+            delattr(self, "_pending_active_volume")
 
     @asynchronous.task
     async def close_application(self):