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

cardio/ui.py

@@ -1,9 +1,14 @@
 import functools as ft
+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 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
@@ -37,10 +42,46 @@ class UI:
 
         match event["type"]:
             case "KeyPress":
-                if event["key"].isdigit():
-                    key_num = int(event["key"])
+                key = event["key"]
+                current_time = time.time() * 1000
+
+                if key in self.last_keypress_time:
+                    time_since_last = current_time - self.last_keypress_time[key]
+                    if time_since_last < self.keypress_debounce_ms:
+                        return
+
+                self.last_keypress_time[key] = current_time
+
+                if key.isdigit():
+                    key_num = int(key)
                     if key_num in presets.keys():
                         self.server.state.mpr_window_level_preset = key_num
+                elif key == "l":
+                    current = getattr(self.server.state, "mpr_crosshairs_enabled", True)
+                    self.server.state.mpr_crosshairs_enabled = not current
+                elif key == "h":
+                    current = getattr(self.server.state, "help_overlay_visible", False)
+                    self.server.state.help_overlay_visible = not current
+                elif key == "v":
+                    current = getattr(self.server.state, "maximized_view", "")
+                    self.server.state.maximized_view = (
+                        "" if current == "volume" else "volume"
+                    )
+                elif key == "a":
+                    current = getattr(self.server.state, "maximized_view", "")
+                    self.server.state.maximized_view = (
+                        "" if current == "axial" else "axial"
+                    )
+                elif key == "c":
+                    current = getattr(self.server.state, "maximized_view", "")
+                    self.server.state.maximized_view = (
+                        "" if current == "coronal" else "coronal"
+                    )
+                elif key == "s":
+                    current = getattr(self.server.state, "maximized_view", "")
+                    self.server.state.maximized_view = (
+                        "" if current == "sagittal" else "sagittal"
+                    )
 
             case "LeftButtonPress":
                 self.left_dragging = True
@@ -99,32 +140,57 @@ class UI:
                 event["position"]["y"],
             ]
 
-    def _handle_slice_scroll(self, view_name, base_slice_delta):
-        """Handle slice scrolling for a specific view."""
-        match view_name:
-            case "axial":
-                current_slice = getattr(self.server.state, "axial_slice", 0.0)
-                bounds = getattr(self.server.state, "axial_slice_bounds", [0.0, 100.0])
-                slice_attr = "axial_slice"
-            case "sagittal":
-                current_slice = getattr(self.server.state, "sagittal_slice", 0.0)
-                bounds = getattr(
-                    self.server.state, "sagittal_slice_bounds", [0.0, 100.0]
-                )
-                slice_attr = "sagittal_slice"
-            case "coronal":
-                current_slice = getattr(self.server.state, "coronal_slice", 0.0)
-                bounds = getattr(
-                    self.server.state, "coronal_slice_bounds", [0.0, 100.0]
+    def _get_scroll_vector(self, view_name):
+        """Get the current normal vector for a view after rotation."""
+        base_normals = {
+            "axial": np.array([0.0, 0.0, 1.0]),
+            "sagittal": np.array([1.0, 0.0, 0.0]),
+            "coronal": np.array([0.0, 1.0, 0.0]),
+        }
+
+        if view_name not in base_normals:
+            return np.array([0.0, 0.0, 1.0])
+
+        # Build cumulative rotation from visible rotations
+        rotation_data = getattr(
+            self.server.state, "mpr_rotation_data", {"angles_list": []}
+        )
+        angles_list = rotation_data.get("angles_list", [])
+        cumulative_rotation = np.eye(3)
+
+        # 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["axes"]), angle, angle_units
                 )
-                slice_attr = "coronal_slice"
-            case _:
-                return
+                cumulative_rotation = cumulative_rotation @ rotation_matrix
+
+        return cumulative_rotation @ base_normals[view_name]
+
+    def _handle_slice_scroll(self, view_name, base_slice_delta):
+        """Handle slice scrolling for a specific view using rotated scroll vectors."""
+        if view_name not in {"axial", "sagittal", "coronal"}:
+            return
 
-        min_bound, max_bound = min(bounds), max(bounds)
-        slice_delta = base_slice_delta if bounds[1] > bounds[0] else -base_slice_delta
-        new_slice = max(min_bound, min(max_bound, current_slice + slice_delta))
-        setattr(self.server.state, slice_attr, new_slice)
+        # Get current origin
+        origin = getattr(self.server.state, "mpr_origin", [0.0, 0.0, 0.0])
+
+        # Get scroll vector for this view (considering rotation)
+        scroll_vector = self._get_scroll_vector(view_name)
+
+        # Update origin along the rotated scroll direction
+        new_origin = [
+            origin[0] + base_slice_delta * scroll_vector[0],
+            origin[1] + base_slice_delta * scroll_vector[1],
+            origin[2] + base_slice_delta * scroll_vector[2],
+        ]
+
+        self.server.state.mpr_origin = new_origin
 
     def __init__(self, server, scene: Scene):
         self.server = server
@@ -135,6 +201,10 @@ class UI:
         self.window_sensitivity = 5.0
         self.level_sensitivity = 2.0
         self.slice_sensitivity = 1.0
+        self.last_keypress_time = {}
+        self.keypress_debounce_ms = 100
+        self.server.state.help_overlay_visible = False
+        self.server.state.maximized_view = ""
 
         self.setup()
 
@@ -181,9 +251,9 @@ class UI:
                 )
 
             with layout.content:
-                # Single VR view (default mode)
+                # Single VR view (volume maximized)
                 with vuetify.VContainer(
-                    v_if="!mpr_enabled",
+                    v_if="maximized_view === 'volume'",
                     fluid=True,
                     classes="pa-0 fill-height",
                 ):
@@ -197,9 +267,9 @@ class UI:
                     self.server.controller.view_reset_camera = view.reset_camera
                     self.server.controller.on_server_ready.add(view.update)
 
-                # Quad-view layout (MPR mode) - directly in content like app.py
+                # Quad-view layout (MPR mode - default)
                 with vuetify.VContainer(
-                    v_if="mpr_enabled",
+                    v_if="!maximized_view",
                     fluid=True,
                     classes="pa-0",
                     style="height: calc(100vh - 85px);",
@@ -263,6 +333,10 @@ class UI:
                     self.server.controller.on_server_ready.add(
                         self._update_all_mpr_views
                     )
+                    # Finalize MPR initialization after UI is ready to avoid race condition
+                    self.server.controller.on_server_ready.add(
+                        self.server.controller.finalize_mpr_initialization
+                    )
 
                     # Store individual view update functions
                     self.server.controller.axial_update = axial_view.update
@@ -270,121 +344,148 @@ class UI:
                     self.server.controller.sagittal_update = sagittal_view.update
                     self.server.controller.volume_update = volume_view.update
 
-            with layout.drawer:
-                # MPR Mode Toggle (only show when volumes are present)
-                if self.scene.volumes:
-                    vuetify.VListSubheader("View Mode")
-                    vuetify.VCheckbox(
-                        v_model=("mpr_enabled", False),
-                        label="Multi-Planar Reconstruction (MPR)",
-                        title="Toggle between single 3D view and quad-view with slice planes",
-                        dense=True,
-                        hide_details=True,
+                # Maximized axial view
+                with vuetify.VContainer(
+                    v_if="maximized_view === 'axial'",
+                    fluid=True,
+                    classes="pa-0 fill-height",
+                ):
+                    axial_maximized_view = vtk_widgets.VtkRemoteView(
+                        self.scene.axial_renderWindow,
+                        interactor_events=("event_types", self.handled_events),
+                        **self.event_listeners_for_view("axial"),
+                        interactive_ratio=1,
                     )
 
-                    # Volume selection dropdown (only show when MPR is enabled)
-                    vuetify.VSelect(
-                        v_if="mpr_enabled",
-                        v_model=("active_volume_label", ""),
-                        items=("volume_items", []),
-                        item_title="text",
-                        item_value="value",
-                        title="Select which volume to use for MPR",
-                        dense=True,
-                        hide_details=True,
+                # Maximized coronal view
+                with vuetify.VContainer(
+                    v_if="maximized_view === 'coronal'",
+                    fluid=True,
+                    classes="pa-0 fill-height",
+                ):
+                    coronal_maximized_view = vtk_widgets.VtkRemoteView(
+                        self.scene.coronal_renderWindow,
+                        interactor_events=("event_types", self.handled_events),
+                        **self.event_listeners_for_view("coronal"),
+                        interactive_ratio=1,
                     )
 
-                    # Window/Level controls for MPR
-                    vuetify.VListSubheader(
-                        "Window/Level", v_if="mpr_enabled && active_volume_label"
+                # Maximized sagittal view
+                with vuetify.VContainer(
+                    v_if="maximized_view === 'sagittal'",
+                    fluid=True,
+                    classes="pa-0 fill-height",
+                ):
+                    sagittal_maximized_view = vtk_widgets.VtkRemoteView(
+                        self.scene.sagittal_renderWindow,
+                        interactor_events=("event_types", self.handled_events),
+                        **self.event_listeners_for_view("sagittal"),
+                        interactive_ratio=1,
                     )
 
+                with vuetify.VDialog(
+                    v_model=("help_overlay_visible", False),
+                    max_width="700px",
+                    scrim="rgba(0, 0, 0, 0.7)",
+                ):
+                    with vuetify.VCard(
+                        classes="pa-6",
+                        style="background: rgba(33, 33, 33, 0.95);",
+                    ):
+                        vuetify.VCardTitle(
+                            "Keyboard Shortcuts & Controls", classes="text-h5 mb-4"
+                        )
+
+                        with vuetify.VCardText():
+                            html.H3("Keyboard Shortcuts", classes="text-h6 mb-3")
+                            with vuetify.VTable(density="compact", classes="mb-4"):
+                                with html.Thead():
+                                    with html.Tr():
+                                        html.Th("Key")
+                                        html.Th("Action")
+                                with html.Tbody():
+                                    with html.Tr():
+                                        html.Td("h")
+                                        html.Td("Toggle this help window")
+                                    with html.Tr():
+                                        html.Td("v")
+                                        html.Td("Toggle 3D volume view")
+                                    with html.Tr():
+                                        html.Td("a")
+                                        html.Td("Toggle axial view")
+                                    with html.Tr():
+                                        html.Td("c")
+                                        html.Td("Toggle coronal view")
+                                    with html.Tr():
+                                        html.Td("s")
+                                        html.Td("Toggle sagittal view")
+                                    with html.Tr():
+                                        html.Td("l")
+                                        html.Td("Toggle crosshairs")
+
+                            html.H3("Window/Level Presets", classes="text-h6 mb-3")
+                            with vuetify.VTable(density="compact", classes="mb-4"):
+                                with html.Thead():
+                                    with html.Tr():
+                                        html.Th("Key")
+                                        html.Th("Preset")
+                                        html.Th("Window")
+                                        html.Th("Level")
+                                with html.Tbody():
+                                    for key, preset in presets.items():
+                                        with html.Tr():
+                                            html.Td(str(key))
+                                            html.Td(preset.name)
+                                            html.Td(str(preset.window))
+                                            html.Td(str(preset.level))
+
+                            html.H3("Mouse Controls (MPR Mode)", classes="text-h6 mb-3")
+                            with vuetify.VTable(density="compact"):
+                                with html.Thead():
+                                    with html.Tr():
+                                        html.Th("Action")
+                                        html.Th("Effect")
+                                with html.Tbody():
+                                    with html.Tr():
+                                        html.Td("Left Drag ←/→")
+                                        html.Td("Narrow/widen window")
+                                    with html.Tr():
+                                        html.Td("Left Drag ↑/↓")
+                                        html.Td("Increase/decrease level")
+                                    with html.Tr():
+                                        html.Td("Right Drag ↑/↓")
+                                        html.Td("Scroll through slices")
+
+                        with vuetify.VCardActions():
+                            vuetify.VSpacer()
+                            vuetify.VBtn(
+                                "Close",
+                                click="help_overlay_visible = false",
+                                variant="text",
+                            )
+
+            with layout.drawer:
+                # Volume selection dropdown
+                if self.scene.volumes:
                     vuetify.VSelect(
-                        v_if="mpr_enabled && active_volume_label",
-                        v_model=("mpr_window_level_preset", 7),
-                        items=("mpr_presets", []),
+                        v_if="(!maximized_view || maximized_view === 'volume') && volume_items.length >= 2",
+                        v_model=("active_volume_label", ""),
+                        items=("volume_items", []),
                         item_title="text",
                         item_value="value",
-                        label="Preset",
+                        title="Select which volume to use for MPR",
                         dense=True,
                         hide_details=True,
                     )
 
-                    vuetify.VSlider(
-                        v_if="mpr_enabled && 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="mpr_enabled && 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,
-                    )
-
-                    # Slice position controls (only show when MPR is enabled and volume is selected)
-                    vuetify.VListSubheader(
-                        "Slice Positions", v_if="mpr_enabled && active_volume_label"
-                    )
-
-                    vuetify.VSlider(
-                        v_if="mpr_enabled && active_volume_label",
-                        v_model=("axial_slice", 0.0),
-                        min=("axial_slice_bounds[0]", 0.0),
-                        max=("axial_slice_bounds[1]", 100.0),
-                        hint="A (I ↔ S)",
-                        persistent_hint=True,
-                        dense=True,
-                        hide_details=False,
-                        thumb_label=True,
-                    )
-
-                    vuetify.VSlider(
-                        v_if="mpr_enabled && active_volume_label",
-                        v_model=("sagittal_slice", 0.0),
-                        min=("sagittal_slice_bounds[0]", 0.0),
-                        max=("sagittal_slice_bounds[1]", 100.0),
-                        hint="S (R ↔ L)",
-                        persistent_hint=True,
-                        dense=True,
-                        hide_details=False,
-                        thumb_label=True,
-                    )
-
-                    vuetify.VSlider(
-                        v_if="mpr_enabled && active_volume_label",
-                        v_model=("coronal_slice", 0.0),
-                        min=("coronal_slice_bounds[0]", 0.0),
-                        max=("coronal_slice_bounds[1]", 100.0),
-                        hint="C (P ↔ A)",
-                        persistent_hint=True,
-                        dense=True,
-                        hide_details=False,
-                        thumb_label=True,
-                    )
-
                     # MPR Rotation controls
                     vuetify.VListSubheader(
-                        "Rotations", v_if="mpr_enabled && active_volume_label"
+                        "Rotations", v_if="!maximized_view && active_volume_label"
                     )
 
                     # Rotation buttons
                     with vuetify.VRow(
-                        v_if="mpr_enabled && active_volume_label",
+                        v_if="!maximized_view && active_volume_label",
                         no_gutters=True,
                         classes="mb-2",
                     ):
@@ -418,8 +519,8 @@ class UI:
 
                     # Reset rotations button
                     vuetify.VBtn(
-                        "Reset",
-                        v_if="mpr_enabled && 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,
@@ -430,52 +531,109 @@ class UI:
                         prepend_icon="mdi-refresh",
                     )
 
-                    # Individual rotation sliders
-                    for i in range(self.scene.max_mpr_rotations):
-                        with vuetify.VRow(
-                            v_if=f"mpr_enabled && 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(
-                        v_if="mpr_enabled && active_volume_label",
+                        v_if="!maximized_view && active_volume_label",
                         no_gutters=True,
                         classes="align-center mb-2 mt-2",
                     ):
@@ -483,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",
@@ -492,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="mpr_enabled && 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.