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

cardio/__init__.py

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

cardio/logic.py

@@ -9,7 +9,13 @@ from .screenshot import Screenshot
 
 class Logic:
     def _get_visible_rotation_data(self):
-        """Get rotation sequence and angles for visible rotations only."""
+        """Get rotation sequence and angles for visible rotations only.
+
+        Returns data in ITK convention, as required by VTK.
+        Converts from current convention if necessary.
+        """
+        from .orientation import IndexOrder
+
         rotation_data = getattr(
             self.server.state, "mpr_rotation_data", {"angles_list": []}
         )
@@ -26,6 +32,17 @@ class Logic:
                 rotation_angles[visible_index] = rotation["angles"][0]
                 visible_index += 1
 
+        # CRITICAL: VTK always needs rotations in ITK convention
+        # Convert from current convention to ITK if necessary
+        current_convention = self.scene.mpr_rotation_sequence.metadata.index_order
+        if current_convention == IndexOrder.ROMA:
+            # Convert ROMA to ITK: X→Z, Y→Y, Z→X, angle→-angle
+            rotation_sequence = [
+                {"axis": {"X": "Z", "Y": "Y", "Z": "X"}[rot["axis"]]}
+                for rot in rotation_sequence
+            ]
+            rotation_angles = {idx: -angle for idx, angle in rotation_angles.items()}
+
         return rotation_sequence, rotation_angles
 
     def __init__(self, server, scene: Scene):
@@ -48,7 +65,7 @@ class Logic:
         ]
 
         # Initialize axis convention items for dropdown
-        self.server.state.axis_convention_items = [
+        self.server.state.index_order_items = [
             {"text": "ITK (X=L, Y=P, Z=S)", "value": "itk"},
             {"text": "Roma (X=S, Y=P, Z=L)", "value": "roma"},
         ]
@@ -71,7 +88,7 @@ class Logic:
         self.server.state.change("mpr_window_level_preset")(self.update_mpr_preset)
         self.server.state.change("mpr_rotation_data")(self.update_mpr_rotation)
         self.server.state.change("angle_units")(self.sync_angle_units)
-        self.server.state.change("axis_convention")(self.sync_axis_convention)
+        self.server.state.change("index_order")(self.sync_index_order)
 
         # Initialize visibility state variables
         for m in self.scene.meshes:
@@ -189,8 +206,12 @@ class Logic:
             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
+        self.server.state.angle_units = (
+            self.scene.mpr_rotation_sequence.metadata.angle_units.value
+        )
+        self.server.state.index_order = (
+            self.scene.mpr_rotation_sequence.metadata.index_order.value
+        )
 
         # Initialize MPR presets data
         try:
@@ -317,16 +338,24 @@ class Logic:
 
     def _apply_current_mpr_settings(self, active_volume, frame):
         """Apply current slice positions and window/level to MPR actors."""
+        from .orientation import IndexOrder
+
         # Apply slice positions
         origin = getattr(self.server.state, "mpr_origin", [0.0, 0.0, 0.0])
         rotation_sequence, rotation_angles = self._get_visible_rotation_data()
 
+        # VTK needs origin in ITK convention - convert if necessary
+        current_convention = self.scene.mpr_rotation_sequence.metadata.index_order
+        if current_convention == IndexOrder.ROMA:
+            # Convert Roma to ITK: swap X and Z
+            origin = [origin[2], origin[1], origin[0]]
+
         active_volume.update_slice_positions(
             frame,
             origin,
             rotation_sequence,
             rotation_angles,
-            self.scene.angle_units,
+            self.scene.mpr_rotation_sequence.metadata.angle_units,
         )
 
         # Apply window/level
@@ -517,16 +546,21 @@ class Logic:
         )
         rotation_seq = RotationSequence.from_ui_dict(rotation_data, active_volume_label)
 
+        mpr_origin = getattr(self.server.state, "mpr_origin", [0.0, 0.0, 0.0])
+        rotation_seq.mpr_origin = list(mpr_origin)
+
         rotation_seq.metadata.timestamp = timestamp.isoformat()
         rotation_seq.metadata.volume_label = active_volume_label
         rotation_seq.metadata.coordinate_system = self.scene.coordinate_system
+        rotation_seq.metadata.index_order = (
+            self.scene.mpr_rotation_sequence.metadata.index_order
+        )
+        rotation_seq.metadata.angle_units = (
+            self.scene.mpr_rotation_sequence.metadata.angle_units
+        )
 
         output_path = save_dir / f"{timestamp_str}.toml"
-        rotation_seq.to_file(
-            output_path,
-            target_convention=self.scene.axis_convention,
-            target_units=self.scene.angle_units,
-        )
+        rotation_seq.to_file(output_path)
 
     def reset_all(self):
         self.server.state.frame = 0
@@ -560,9 +594,9 @@ class Logic:
         from .orientation import AngleUnits
 
         # Get current units before changing
-        old_units = self.scene.angle_units
+        old_units = self.scene.mpr_rotation_sequence.metadata.angle_units
 
-        # Update the scene's angle_units field based on UI selection
+        # Update based on UI selection
         new_units = None
         if angle_units == "degrees":
             new_units = AngleUnits.DEGREES
@@ -592,16 +626,53 @@ class Logic:
 
             self.server.state.mpr_rotation_data = updated_data
 
-        self.scene.angle_units = new_units
+        self.scene.mpr_rotation_sequence.metadata.angle_units = new_units
+
+    def sync_index_order(self, index_order, **kwargs):
+        """Sync index order selection - converts existing rotations and updates scene."""
+        import copy
 
-    def sync_axis_convention(self, axis_convention, **kwargs):
-        """Sync axis convention selection - updates the scene configuration."""
-        from .orientation import AxisConvention
+        from .orientation import IndexOrder
 
-        if axis_convention == "itk":
-            self.scene.axis_convention = AxisConvention.ITK
-        elif axis_convention == "roma":
-            self.scene.axis_convention = AxisConvention.ROMA
+        old_convention = self.scene.mpr_rotation_sequence.metadata.index_order
+
+        # Convert string input to enum
+        if isinstance(index_order, str):
+            match index_order.lower():
+                case "itk":
+                    new_convention = IndexOrder.ITK
+                case "roma":
+                    new_convention = IndexOrder.ROMA
+                case _:
+                    raise ValueError(f"Unrecognized index order: {index_order}")
+        else:
+            new_convention = index_order
+
+        if old_convention == new_convention:
+            return
+
+        rotation_data = getattr(
+            self.server.state, "mpr_rotation_data", {"angles_list": []}
+        )
+        if rotation_data.get("angles_list"):
+            updated_data = copy.deepcopy(rotation_data)
+
+            for rotation in updated_data["angles_list"]:
+                current_axis = rotation.get("axes")
+                current_angle = rotation.get("angles", [0])[0]
+
+                # Conversion is the same for both ITK<->ROMA directions
+                rotation["axes"] = {"X": "Z", "Y": "Y", "Z": "X"}[current_axis]
+                rotation["angles"][0] = -current_angle
+
+            self.server.state.mpr_rotation_data = updated_data
+
+        # Transform mpr_origin: swap X and Z (indices 0 and 2)
+        mpr_origin = getattr(self.server.state, "mpr_origin", None)
+        if mpr_origin is not None and len(mpr_origin) == 3:
+            self.server.state.mpr_origin = [mpr_origin[2], mpr_origin[1], mpr_origin[0]]
+
+        self.scene.mpr_rotation_sequence.metadata.index_order = new_convention
 
     def _initialize_clipping_state(self):
         """Initialize clipping state variables for all objects."""
@@ -686,6 +757,8 @@ class Logic:
 
         # Initialize origin to volume center (in LPS coordinates)
         try:
+            from .orientation import IndexOrder
+
             current_frame = getattr(self.server.state, "frame", 0)
             volume_actor = active_volume.actors[current_frame]
             image_data = volume_actor.GetMapper().GetInput()
@@ -694,7 +767,16 @@ class Logic:
             # 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)
+                # VTK returns center in ITK convention (X=L, Y=P, Z=S)
+                # Transform to current convention if needed
+                center_list = list(center)
+                if (
+                    self.scene.mpr_rotation_sequence.metadata.index_order
+                    == IndexOrder.ROMA
+                ):
+                    # Convert ITK -> Roma: swap X and Z
+                    center_list = [center_list[2], center_list[1], center_list[0]]
+                self.server.state.mpr_origin = center_list
         except (RuntimeError, IndexError) as e:
             print(f"Error: Cannot get center for volume '{active_volume_label}': {e}")
             return
@@ -763,6 +845,7 @@ class Logic:
 
     def update_slice_positions(self, **kwargs):
         """Update MPR slice positions when sliders change."""
+        from .orientation import IndexOrder
 
         if not getattr(self.server.state, "mpr_enabled", False):
             return
@@ -787,13 +870,19 @@ class Logic:
 
         rotation_sequence, rotation_angles = self._get_visible_rotation_data()
 
+        # VTK needs origin in ITK convention - convert if necessary
+        current_convention = self.scene.mpr_rotation_sequence.metadata.index_order
+        if current_convention == IndexOrder.ROMA:
+            # Convert Roma to ITK: swap X and Z
+            origin = [origin[2], origin[1], origin[0]]
+
         # Update slice positions with rotation
         active_volume.update_slice_positions(
             current_frame,
             origin,
             rotation_sequence,
             rotation_angles,
-            self.scene.angle_units,
+            self.scene.mpr_rotation_sequence.metadata.angle_units,
         )
 
         # Update all views
@@ -863,6 +952,8 @@ class Logic:
 
     def update_mpr_rotation(self, **kwargs):
         """Update MPR views when rotation changes."""
+        from .orientation import IndexOrder
+
         if not getattr(self.server.state, "mpr_enabled", False):
             return
 
@@ -886,13 +977,19 @@ class Logic:
 
         rotation_sequence, rotation_angles = self._get_visible_rotation_data()
 
+        # VTK needs origin in ITK convention - convert if necessary
+        current_convention = self.scene.mpr_rotation_sequence.metadata.index_order
+        if current_convention == IndexOrder.ROMA:
+            # Convert Roma to ITK: swap X and Z
+            origin = [origin[2], origin[1], origin[0]]
+
         # Update slice positions with rotation
         active_volume.update_slice_positions(
             current_frame,
             origin,
             rotation_sequence,
             rotation_angles,
-            self.scene.angle_units,
+            self.scene.mpr_rotation_sequence.metadata.angle_units,
         )
 
         # Update all views
@@ -984,6 +1081,9 @@ class Logic:
             self.sync_active_volume(self._pending_active_volume)
             delattr(self, "_pending_active_volume")
 
+        # Apply loaded rotation data to MPR views
+        self.update_mpr_rotation()
+
     @asynchronous.task
     async def close_application(self):
         """Close the application by stopping the server."""

cardio/orientation.py

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

cardio/rotation.py

@@ -9,11 +9,16 @@ import pydantic as pc
 import tomlkit as tk
 
 # Internal
-from .orientation import AngleUnits, AxisConvention
+from .orientation import AngleUnits, IndexOrder
 
 
 class RotationStep(pc.BaseModel):
-    """Single rotation step (stored in ITK convention, radians)."""
+    """Single rotation step.
+
+    Both angles and axes are stored in the current convention/units.
+    - Angles: stored in units specified by parent metadata.angle_units
+    - Axes: stored in convention specified by parent metadata.index_order
+    """
 
     axes: ty.Literal["X", "Y", "Z"]
     angle: float = 0.0
@@ -37,59 +42,44 @@ class RotationStep(pc.BaseModel):
                 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
+    index_order: IndexOrder = IndexOrder.ITK
+    angle_units: AngleUnits = AngleUnits.RADIANS
     timestamp: str = pc.Field(default_factory=lambda: dt.datetime.now().isoformat())
     volume_label: str = ""
 
 
 class RotationSequence(pc.BaseModel):
-    """Complete rotation sequence (stored in ITK convention, radians)."""
+    """Complete rotation sequence.
+
+    All data (angles, axes, and origin) are stored in the current convention/units:
+    - Angles: stored in units specified by metadata.angle_units
+    - Axes: stored in convention specified by metadata.index_order
+    - Origin: stored in axis order specified by metadata.index_order
+
+    When convention/units change in the UI, all existing data is converted.
+    """
 
     model_config = pc.ConfigDict(frozen=False)
 
     metadata: RotationMetadata = pc.Field(default_factory=RotationMetadata)
     angles_list: list[RotationStep] = pc.Field(default_factory=list)
+    mpr_origin: list[float] = pc.Field(
+        default_factory=lambda: [0.0, 0.0, 0.0],
+        description="MPR origin position [x, y, z] in current index_order convention",
+    )
+
+    @pc.field_validator("mpr_origin")
+    @classmethod
+    def validate_mpr_origin(cls, v):
+        """Ensure mpr_origin is a 3-element list of floats."""
+        if not isinstance(v, list) or len(v) != 3:
+            raise ValueError("mpr_origin must be a 3-element list [x, y, z]")
+        return [float(x) for x in v]
 
     @pc.field_validator("angles_list", mode="before")
     @classmethod
@@ -100,9 +90,10 @@ class RotationSequence(pc.BaseModel):
         return v
 
     def to_dict_for_ui(self) -> dict:
-        """Convert to UI format (always ITK/radians internally).
+        """Convert to UI format.
 
-        Note: UI expects 'angles' as a list for backward compatibility.
+        Angles are passed through in their current units (metadata.angle_units).
+        UI expects 'angles' as a list for backward compatibility.
         """
         return {
             "angles_list": [
@@ -115,83 +106,38 @@ class RotationSequence(pc.BaseModel):
                     "deletable": step.deletable,
                 }
                 for step in self.angles_list
-            ]
+            ],
+            "mpr_origin": self.mpr_origin,
         }
 
     @classmethod
     def from_ui_dict(cls, data: dict, volume_label: str = "") -> "RotationSequence":
-        """Create from UI format (assumes ITK/radians)."""
+        """Create from UI format.
+
+        Angles from UI are stored as-is (in current UI units).
+        Caller should set metadata.angle_units to match the UI's current units.
+        """
         angles_list = [RotationStep(**step) for step in data.get("angles_list", [])]
         metadata = RotationMetadata(volume_label=volume_label)
-        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)
+        mpr_origin = data.get("mpr_origin", [0.0, 0.0, 0.0])
+        return cls(metadata=metadata, angles_list=angles_list, mpr_origin=mpr_origin)
+
+    def to_toml(self) -> str:
+        """Serialize to TOML using stored serialization preferences."""
+        from . import __version__
+
+        data = self.model_dump(mode="json")
+        toml_str = tk.dumps(data)
+
+        version_comment = f"# Generated by cardio version {__version__}\n\n"
+        return version_comment + toml_str
 
     @classmethod
     def from_toml(cls, toml_content: str) -> "RotationSequence":
-        """Deserialize from TOML with conversions."""
+        """Deserialize from TOML (no conversions - loads as-is)."""
         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)
+        data = dict(doc)
+        return cls(**data)
 
     @classmethod
     def from_file(cls, path: pl.Path) -> "RotationSequence":
@@ -199,13 +145,8 @@ class RotationSequence(pc.BaseModel):
         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."""
+    def to_file(self, path: pl.Path):
+        """Save to TOML file using stored serialization preferences."""
         path.parent.mkdir(parents=True, exist_ok=True)
         with open(path, "w") as f:
-            f.write(self.to_toml(target_convention, target_units))
+            f.write(self.to_toml())

cardio/scene.py

@@ -8,7 +8,7 @@ import pydantic_settings as ps
 import vtk
 
 from .mesh import Mesh
-from .orientation import AngleUnits, AxisConvention
+from .orientation import AngleUnits, IndexOrder
 from .rotation import RotationSequence
 from .segmentation import Segmentation
 from .types import RGBColor
@@ -137,17 +137,9 @@ class Scene(ps.BaseSettings):
         default=20,
         description="Maximum number of MPR rotations supported",
     )
-    angle_units: AngleUnits = pc.Field(
-        default=AngleUnits.RADIANS,
-        description="Units for angle measurements in rotation serialization",
-    )
     coordinate_system: str = pc.Field(
         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=True, description="Show crosshair lines indicating slice intersections"
     )
@@ -200,6 +192,9 @@ class Scene(ps.BaseSettings):
                     self.mpr_rotation_sequence.metadata.volume_label
                 )
 
+            if self.mpr_rotation_sequence.mpr_origin:
+                self.mpr_origin = list(self.mpr_rotation_sequence.mpr_origin)
+
         return self
 
     # VTK objects as private attributes

cardio/ui.py

@@ -660,8 +660,8 @@ class UI:
                             vuetify.VLabel("Convention:")
                         with vuetify.VCol(cols="8"):
                             vuetify.VSelect(
-                                v_model=("axis_convention", "itk"),
-                                items=("axis_convention_items", []),
+                                v_model=("index_order", "itk"),
+                                items=("index_order_items", []),
                                 item_title="text",
                                 item_value="value",
                                 dense=True,

{cardio-2026.1.0.dist-info → cardio-2026.1.3.dist-info}/METADATA

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

{cardio-2026.1.0.dist-info → cardio-2026.1.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-cardio/__init__.py,sha256=WZ7MfzISF8ryIC9NdIyub4mP6DQBWsMX766IPcWihXg,601
+cardio/__init__.py,sha256=07x-I5z0KKgiJwm-tqtY1qZTh5YKg32IScpzzFVEeno,601
 cardio/app.py,sha256=h-Xh57Txw3Hom-fDv08YxjXzovuIxY8_5qPy6MJThZs,1354
 cardio/assets/bone.toml,sha256=vv8uVYSHIoKuHkNCoBOkGe2_qoEbXMvQO6ypm3mMOtA,675
 cardio/assets/vascular_closed.toml,sha256=XtaZS_Zd6NSAtY3ZlUfiog3T86u9Ii0oSutU2wBQy78,1267
@@ -6,25 +6,25 @@ cardio/assets/vascular_open.toml,sha256=1M3sV1IGt3zh_3vviysKEk9quKfjF9xUBcIq3kxV
 cardio/assets/xray.toml,sha256=siPem0OZ2OkWH0e5pizftpItJKGJgxKJ_S2K0316ubQ,693
 cardio/blend_transfer_functions.py,sha256=fkLDYGMj_QXYs0vmXYT_B1tgTfl3YICLYimtWlxrmbQ,2958
 cardio/color_transfer_function.py,sha256=uTyPdwxi0HjR4wm418cQN9-q9SspkkeqvLNqXaF3zzg,792
-cardio/logic.py,sha256=pjAqiJc_3pfUpB9hXWiSYJTmbG4c1omuUvuT2gshPNo,40431
+cardio/logic.py,sha256=AuKQZ_ACTRrtB4oxPuaKYjajsoA3yoszw7GnZK11UdQ,44721
 cardio/mesh.py,sha256=wYdU0BU84eXrrHp0U0VLwYW7ZpRJ6GbT5Kl_-K6CBzY,9356
 cardio/object.py,sha256=98A32VpFR4UtVqW8dZsRJR13VVyUoJJ20uoOZBgN4js,6168
-cardio/orientation.py,sha256=zOw3R284izAcKXnCCYYFOzOPBqgiE8om8q2JDWTQFoY,6256
+cardio/orientation.py,sha256=xsWAFPwf3-toT4XFYyGiZJkcGFQ2uz3eLxpC1_i6yZ8,6266
 cardio/piecewise_function.py,sha256=X-_C-BVStufmFjfF8IbkqKk9Xw_jh00JUmjC22ZqeqQ,764
 cardio/property_config.py,sha256=YrWIyCoSAfJPigkhriIQybQpJantGnXjT4nJfrtIJco,1689
-cardio/rotation.py,sha256=eUUk74kBpPr-YCZdIAcU5pIX6FKeVGT8dRg2YnaS2yE,7204
-cardio/scene.py,sha256=2oq-zVMSHj9PhNToSMbk8RzJ3jKzo7oaAvDn_U4vcPM,15583
+cardio/rotation.py,sha256=BCh3x347AdnsRMK-6-N9o12jnGiwg7vG-DuJirzn468,5341
+cardio/scene.py,sha256=FrUQIJrBR_jPrW7utOI3uDbaUxjmZEapzVTEVIgEWaA,15365
 cardio/screenshot.py,sha256=l8bLgxnU5O0FlnmsyVAzKwM9Y0401IzcdnDP0WqFSTY,640
 cardio/segmentation.py,sha256=KT1ClgultXyGpZDdpYxor38GflY7uCgRzfA8JEGQVaU,6642
 cardio/transfer_function_pair.py,sha256=_J0qXA0InUPpvfWPcW492KGSYAqeb12htCzKBSpWHwo,780
 cardio/types.py,sha256=jxSZjvxEJ03OThfupT2CG9UHsFklwbWeFrUozNXro2I,333
-cardio/ui.py,sha256=uYyO1-Lysi5guFDv4k3HSGJ12Ro27B1yxkmS_PFbd-M,53189
+cardio/ui.py,sha256=esmJzoJE-lKoWHYWg1Zbq_Z1ydIt4ggHXf1i14J0PrM,53181
 cardio/utils.py,sha256=ao4a7_vMjGBxTOMhZ7r0D0W4ujiwKPS0i8Xfmn3Gv9k,1497
 cardio/volume.py,sha256=sdQ7gtX4jQDD9U8U95xD9LIV_1hpykj8NTCo1_aIKVM,15035
 cardio/volume_property.py,sha256=-EUMV9sWCaetgGjnqIWxPp39qrxEZKTNDJ5GHUgLMlk,1619
 cardio/volume_property_presets.py,sha256=4-hjo-dukm5sMMmWidbWnVXq0IN4sWpBnDITY9MqUFg,1625
 cardio/window_level.py,sha256=XMkwLAHcmsEYcI0SoHySQZvptq4VwX2gj--ps3hV8AQ,784
-cardio-2026.1.0.dist-info/WHEEL,sha256=4n27za1eEkOnA7dNjN6C5-O2rUiw6iapszm14Uj-Qmk,79
-cardio-2026.1.0.dist-info/entry_points.txt,sha256=xRd1otqKtW9xmidJ4CFRX1V9KWmsBbtxrgMtDColq3w,40
-cardio-2026.1.0.dist-info/METADATA,sha256=xulm4Dgn_80ZFMHSKEBtxnoEfYKFFf3Pfb3aNM1fgzw,3520
-cardio-2026.1.0.dist-info/RECORD,,
+cardio-2026.1.3.dist-info/WHEEL,sha256=4n27za1eEkOnA7dNjN6C5-O2rUiw6iapszm14Uj-Qmk,79
+cardio-2026.1.3.dist-info/entry_points.txt,sha256=xRd1otqKtW9xmidJ4CFRX1V9KWmsBbtxrgMtDColq3w,40
+cardio-2026.1.3.dist-info/METADATA,sha256=BE_DMgEZ959_kbfIfIMTbDs-hIhjep_SGFSmoeMm3Ag,3518
+cardio-2026.1.3.dist-info/RECORD,,