cardio 2023.1.2__py3-none-any.whl → 2025.8.1__py3-none-any.whl

cardio/__init__.py

@@ -1,19 +1,27 @@
-from .object import Object
+from .logic import Logic
 from .mesh import Mesh
-from .volume import Volume
+from .object import Object
 from .scene import Scene
-from .logic import Logic
-from .ui import UI
 from .screenshot import Screenshot
+from .segmentation import Segmentation
+from .transfer_functions import (
+    list_available_presets,
+    load_preset,
+)
+from .ui import UI
+from .volume import Volume
 
 __all__ = [
     "Object",
     "Mesh",
     "Volume",
+    "Segmentation",
     "Scene",
     "Screenshot",
     "UI",
     "Logic",
+    "load_preset",
+    "list_available_presets",
 ]
 
-__version__ = "2023.1.2"
+__version__ = "2025.8.1"

cardio/app.py

@@ -1,31 +1,62 @@
 #!/usr/bin/env python
 
-from trame.app import Server, get_server
+# Third Party
+import pydantic_settings as ps
+import tomlkit as tk
+import trame as tm
 
+from . import __version__
 from .logic import Logic
+
+# Internal
 from .scene import Scene
 from .ui import UI
 
 
-def main(server=None, **kwargs):
+class CardioApp(tm.app.TrameApp):
+    def __init__(self, name=None):
+        super().__init__(server=name, client_type="vue2")
+
+        # Add config file argument to Trame's parser
+        self.server.cli.add_argument(
+            "--config", help="TOML configuration file.", dest="cfg_file", required=False
+        )
+
+        # Add version argument
+        self.server.cli.add_argument(
+            "--version", action="version", version=f"cardio {__version__}"
+        )
+
+        # Create CLI settings source with Trame's parser - enable argument parsing
+        cli_settings = ps.CliSettingsSource(
+            Scene, root_parser=self.server.cli, cli_parse_args=True
+        )
 
-    if server is None:
-        server = get_server()
+        # Parse arguments to get config file path (use parse_known_args to avoid conflicts)
+        args, unknown = self.server.cli.parse_known_args()
+        config_file = getattr(args, "cfg_file", None)
 
-    if isinstance(server, str):
-        server = get_server(server)
+        # Set the CLI source and config file on the Scene class temporarily
+        Scene._cli_source = cli_settings
+        Scene._config_file = config_file
 
-    server.cli.add_argument(
-        "--config", help="TOML configutation file.", dest="cfg_file", required=True
-    )
-    args = server.cli.parse_args()
+        try:
+            # Create Scene with CLI and config file support
+            scene = Scene()
+        finally:
+            # Clean up class attributes
+            if hasattr(Scene, "_cli_source"):
+                delattr(Scene, "_cli_source")
+            if hasattr(Scene, "_config_file"):
+                delattr(Scene, "_config_file")
 
-    scene = Scene(args.cfg_file)
+        Logic(self.server, scene)
+        UI(self.server, scene)
 
-    Logic(server, scene)
-    UI(server, scene)
 
-    server.start(open_browser=False)
+def main():
+    app = CardioApp()
+    app.server.start(open_browser=False)
 
 
 if __name__ == "__main__":

cardio/assets/bone.toml

@@ -0,0 +1,42 @@
+name = "Bone"
+description = "Bone"
+
+ambient = 1.0
+diffuse = 1.0
+specular = 0.0
+
+[[transfer_functions]]
+
+[transfer_functions.opacity]
+[[transfer_functions.opacity.points]]
+x = -1024.0
+y = 0.0
+
+[[transfer_functions.opacity.points]]
+x = 54.0
+y = 0.0
+
+[[transfer_functions.opacity.points]]
+x = 536.0
+y = 0.1
+
+[[transfer_functions.opacity.points]]
+x = 3071.0
+y = 0.1
+
+[transfer_functions.color]
+[[transfer_functions.color.points]]
+x = -1024.0
+color = [0.0, 0.0, 0.0]
+
+[[transfer_functions.color.points]]
+x = 54.0
+color = [0.0, 0.0, 0.0]
+
+[[transfer_functions.color.points]]
+x = 536.0
+color = [1.0, 1.0, 1.0]
+
+[[transfer_functions.color.points]]
+x = 3071.0
+color = [1.0, 1.0, 1.0]

cardio/assets/vascular_closed.toml

@@ -0,0 +1,78 @@
+name = "Vascular_Closed"
+description = "Vascular (Closed)"
+
+ambient = 0.7
+diffuse = 0.4
+specular = 1.0
+
+[[transfer_functions]]
+
+[transfer_functions.opacity]
+[[transfer_functions.opacity.points]]
+x = 150
+y = 0.0
+
+[[transfer_functions.opacity.points]]
+x = 650
+y = 1.0
+
+[[transfer_functions.opacity.points]]
+x = 3071
+y = 1.0
+
+[transfer_functions.color]
+[[transfer_functions.color.points]]
+x = 150
+color = [1.0, 1.0, 1.0]
+
+[[transfer_functions.color.points]]
+x = 3071
+color = [1.0, 1.0, 1.0]
+
+[[transfer_functions]]
+
+[transfer_functions.opacity]
+[[transfer_functions.opacity.points]]
+x = -96.5
+y = 0.0
+
+[[transfer_functions.opacity.points]]
+x = 269.0
+y = 0.05
+
+[[transfer_functions.opacity.points]]
+x = 474.5
+y = 0.0
+
+[transfer_functions.color]
+[[transfer_functions.color.points]]
+x = -96.5
+color = [1.0, 1.0, 1.0]
+
+[[transfer_functions.color.points]]
+x = 474.5
+color = [1.0, 1.0, 1.0]
+
+[[transfer_functions]]
+
+[transfer_functions.opacity]
+[[transfer_functions.opacity.points]]
+x = 120
+y = 0.0
+
+[[transfer_functions.opacity.points]]
+x = 258.0
+y = 0.8
+
+[[transfer_functions.opacity.points]]
+x = 320
+y = 0.0
+
+[transfer_functions.color]
+[[transfer_functions.color.points]]
+x = 120
+color = [1.0, 0.0, 0.0]
+
+[[transfer_functions.color.points]]
+x = 320
+color = [1.0, 1.0, 0.0]

cardio/assets/vascular_open.toml

@@ -0,0 +1,54 @@
+name = "Vascular_Open"
+description = "Vascular (Open)"
+
+ambient = 0.7
+diffuse = 0.4
+specular = 1.0
+
+[[transfer_functions]]
+
+[transfer_functions.opacity]
+[[transfer_functions.opacity.points]]
+x = -96.5
+y = 0.0
+
+[[transfer_functions.opacity.points]]
+x = 269.0
+y = 0.05
+
+[[transfer_functions.opacity.points]]
+x = 474.5
+y = 0.0
+
+[transfer_functions.color]
+[[transfer_functions.color.points]]
+x = -96.5
+color = [1.0, 1.0, 1.0]
+
+[[transfer_functions.color.points]]
+x = 474.5
+color = [1.0, 1.0, 1.0]
+
+[[transfer_functions]]
+
+[transfer_functions.opacity]
+[[transfer_functions.opacity.points]]
+x = 117
+y = 0.0
+
+[[transfer_functions.opacity.points]]
+x = 246.0
+y = 0.87
+
+[[transfer_functions.opacity.points]]
+x = 319
+y = 0.0
+
+[transfer_functions.color]
+[[transfer_functions.color.points]]
+x = 117
+color = [1.0, 0.0, 0.0]
+
+[[transfer_functions.color.points]]
+x = 319
+color = [1.0, 1.0, 0.0]

cardio/assets/xray.toml

@@ -0,0 +1,42 @@
+name = "Radiograph"
+description = "Radiograph"
+
+ambient = 1.0
+diffuse = 1.0
+specular = 0.0
+
+[[transfer_functions]]
+
+[transfer_functions.opacity]
+[[transfer_functions.opacity.points]]
+x = -1024.0
+y = 0.0
+
+[[transfer_functions.opacity.points]]
+x = -200.0
+y = 0.0
+
+[[transfer_functions.opacity.points]]
+x = 300.0
+y = 0.01
+
+[[transfer_functions.opacity.points]]
+x = 3071.0
+y = 0.01
+
+[transfer_functions.color]
+[[transfer_functions.color.points]]
+x = -1024.0
+color = [0.0, 0.0, 0.0]
+
+[[transfer_functions.color.points]]
+x = -200.0
+color = [0.0, 0.0, 0.0]
+
+[[transfer_functions.color.points]]
+x = 300.0
+color = [1.0, 1.0, 1.0]
+
+[[transfer_functions.color.points]]
+x = 3071.0
+color = [1.0, 1.0, 1.0]

cardio/logic.py

@@ -1,8 +1,10 @@
 import asyncio
+import datetime as dt
 
 from trame.app import asynchronous
 
-from . import Scene
+from .scene import Scene
+from .screenshot import Screenshot
 
 
 class Logic:
@@ -12,21 +14,114 @@ class Logic:
 
         self.server.state.change("frame")(self.update_frame)
         self.server.state.change("playing")(self.play)
+        self.server.state.change("dark_mode")(self.sync_background_color)
+
+        # Initialize visibility state variables
+        for m in self.scene.meshes:
+            self.server.state[f"mesh_visibility_{m.label}"] = m.visible
+        for v in self.scene.volumes:
+            self.server.state[f"volume_visibility_{v.label}"] = v.visible
+        for s in self.scene.segmentations:
+            self.server.state[f"segmentation_visibility_{s.label}"] = s.visible
+
+        # Initialize preset state variables
+        for v in self.scene.volumes:
+            self.server.state[f"volume_preset_{v.label}"] = v.transfer_function_preset
+
+        # Initialize clipping state variables
+        for m in self.scene.meshes:
+            self.server.state[f"mesh_clipping_{m.label}"] = m.clipping_enabled
+        for v in self.scene.volumes:
+            self.server.state[f"volume_clipping_{v.label}"] = v.clipping_enabled
+        for s in self.scene.segmentations:
+            self.server.state[f"segmentation_clipping_{s.label}"] = s.clipping_enabled
         self.server.state.change(
             *[f"mesh_visibility_{m.label}" for m in self.scene.meshes]
         )(self.sync_mesh_visibility)
         self.server.state.change(
             *[f"volume_visibility_{v.label}" for v in self.scene.volumes]
         )(self.sync_volume_visibility)
+        self.server.state.change(
+            *[f"segmentation_visibility_{s.label}" for s in self.scene.segmentations]
+        )(self.sync_segmentation_visibility)
+        self.server.state.change(
+            *[f"volume_preset_{v.label}" for v in self.scene.volumes]
+        )(self.sync_volume_presets)
+
+        # Set up mesh clipping controls
+        mesh_clipping_controls = []
+        for m in self.scene.meshes:
+            mesh_clipping_controls.extend(
+                [
+                    f"mesh_clipping_{m.label}",
+                    f"clip_x_{m.label}",
+                    f"clip_y_{m.label}",
+                    f"clip_z_{m.label}",
+                ]
+            )
+        if mesh_clipping_controls:
+            self.server.state.change(*mesh_clipping_controls)(self.sync_mesh_clipping)
+
+        # Set up volume clipping controls
+        volume_clipping_controls = []
+        for v in self.scene.volumes:
+            volume_clipping_controls.extend(
+                [
+                    f"volume_clipping_{v.label}",
+                    f"clip_x_{v.label}",
+                    f"clip_y_{v.label}",
+                    f"clip_z_{v.label}",
+                ]
+            )
+        if volume_clipping_controls:
+            self.server.state.change(*volume_clipping_controls)(
+                self.sync_volume_clipping
+            )
+
+        # Set up segmentation clipping controls
+        segmentation_clipping_controls = []
+        for s in self.scene.segmentations:
+            segmentation_clipping_controls.extend(
+                [
+                    f"segmentation_clipping_{s.label}",
+                    f"clip_x_{s.label}",
+                    f"clip_y_{s.label}",
+                    f"clip_z_{s.label}",
+                ]
+            )
+        if segmentation_clipping_controls:
+            self.server.state.change(*segmentation_clipping_controls)(
+                self.sync_segmentation_clipping
+            )
 
         self.server.controller.increment_frame = self.increment_frame
         self.server.controller.decrement_frame = self.decrement_frame
         self.server.controller.screenshot = self.screenshot
         self.server.controller.reset_all = self.reset_all
 
+        # Initialize clipping state variables
+        self._initialize_clipping_state()
+
     def update_frame(self, frame, **kwargs):
         self.scene.hide_all_frames()
-        self.scene.show_frame(frame)
+
+        # Show frame with server state visibility
+        for mesh in self.scene.meshes:
+            visible = self.server.state[f"mesh_visibility_{mesh.label}"]
+            if visible:
+                mesh.actors[frame % len(mesh.actors)].SetVisibility(True)
+
+        for volume in self.scene.volumes:
+            visible = self.server.state[f"volume_visibility_{volume.label}"]
+            if visible:
+                volume.actors[frame % len(volume.actors)].SetVisibility(True)
+
+        for segmentation in self.scene.segmentations:
+            visible = self.server.state[f"segmentation_visibility_{segmentation.label}"]
+            if visible:
+                actor = segmentation.actors[frame % len(segmentation.actors)]
+                actor.SetVisibility(True)
+
         self.server.controller.view_update()
 
     @asynchronous.task
@@ -45,14 +140,113 @@ class Logic:
 
     def sync_mesh_visibility(self, **kwargs):
         for m in self.scene.meshes:
-            m.visible = self.server.state[f"mesh_visibility_{m.label}"]
-            m.actors[self.server.state.frame].SetVisibility(m.visible)
+            visible = self.server.state[f"mesh_visibility_{m.label}"]
+            m.actors[self.server.state.frame % len(m.actors)].SetVisibility(visible)
         self.server.controller.view_update()
 
     def sync_volume_visibility(self, **kwargs):
         for v in self.scene.volumes:
-            v.visible = self.server.state[f"volume_visibility_{v.label}"]
-            v.actors[self.server.state.frame].SetVisibility(v.visible)
+            visible = self.server.state[f"volume_visibility_{v.label}"]
+            v.actors[self.server.state.frame % len(v.actors)].SetVisibility(visible)
+        self.server.controller.view_update()
+
+    def sync_segmentation_visibility(self, **kwargs):
+        for s in self.scene.segmentations:
+            visible = self.server.state[f"segmentation_visibility_{s.label}"]
+            actor = s.actors[self.server.state.frame % len(s.actors)]
+            actor.SetVisibility(visible)
+        self.server.controller.view_update()
+
+    def sync_volume_presets(self, **kwargs):
+        """Update volume transfer function presets based on UI selection."""
+        from .transfer_functions import load_preset
+
+        for v in self.scene.volumes:
+            preset_name = self.server.state[f"volume_preset_{v.label}"]
+            preset = load_preset(preset_name)
+
+            # Apply preset to all actors
+            for actor in v.actors:
+                actor.SetProperty(preset.vtk_property)
+
+        self.server.controller.view_update()
+
+    def sync_mesh_clipping(self, **kwargs):
+        """Update mesh clipping based on UI controls."""
+        for m in self.scene.meshes:
+            # Toggle clipping on/off
+            clipping_enabled = self.server.state[f"mesh_clipping_{m.label}"]
+            m.toggle_clipping(clipping_enabled)
+
+            # Update clipping bounds from sliders
+            if clipping_enabled and hasattr(self.server.state, f"clip_x_{m.label}"):
+                x_bounds = getattr(self.server.state, f"clip_x_{m.label}")
+                y_bounds = getattr(self.server.state, f"clip_y_{m.label}")
+                z_bounds = getattr(self.server.state, f"clip_z_{m.label}")
+
+                bounds = [
+                    x_bounds[0],
+                    x_bounds[1],  # x_min, x_max
+                    y_bounds[0],
+                    y_bounds[1],  # y_min, y_max
+                    z_bounds[0],
+                    z_bounds[1],  # z_min, z_max
+                ]
+
+                m.update_clipping_bounds(bounds)
+
+        self.server.controller.view_update()
+
+    def sync_volume_clipping(self, **kwargs):
+        """Update volume clipping based on UI controls."""
+        for v in self.scene.volumes:
+            # Toggle clipping on/off
+            clipping_enabled = self.server.state[f"volume_clipping_{v.label}"]
+            v.toggle_clipping(clipping_enabled)
+
+            # Update clipping bounds if enabled
+            if clipping_enabled:
+                x_range = self.server.state[f"clip_x_{v.label}"]
+                y_range = self.server.state[f"clip_y_{v.label}"]
+                z_range = self.server.state[f"clip_z_{v.label}"]
+
+                if x_range and y_range and z_range:
+                    bounds = [
+                        x_range[0],
+                        x_range[1],
+                        y_range[0],
+                        y_range[1],
+                        z_range[0],
+                        z_range[1],
+                    ]
+                    v.update_clipping_bounds(bounds)
+
+        self.server.controller.view_update()
+
+    def sync_segmentation_clipping(self, **kwargs):
+        """Update segmentation clipping based on UI controls."""
+        for s in self.scene.segmentations:
+            # Toggle clipping on/off
+            clipping_enabled = self.server.state[f"segmentation_clipping_{s.label}"]
+            s.toggle_clipping(clipping_enabled)
+
+            # Update clipping bounds if enabled
+            if clipping_enabled:
+                x_range = self.server.state[f"clip_x_{s.label}"]
+                y_range = self.server.state[f"clip_y_{s.label}"]
+                z_range = self.server.state[f"clip_z_{s.label}"]
+
+                if x_range and y_range and z_range:
+                    bounds = [
+                        x_range[0],
+                        x_range[1],
+                        y_range[0],
+                        y_range[1],
+                        z_range[0],
+                        z_range[1],
+                    ]
+                    s.update_clipping_bounds(bounds)
+
         self.server.controller.view_update()
 
     def increment_frame(self):
@@ -68,11 +262,11 @@ class Logic:
     @asynchronous.task
     async def screenshot(self):
         dr = dt.datetime.now().strftime(self.scene.screenshot_subdirectory_format)
-        dr = f"{self.scene.screenshot_directory}/{dr}"
-        os.makedirs(dr)
+        dr = self.scene.screenshot_directory / dr
+        dr.mkdir(parents=True, exist_ok=True)
 
         if not (self.server.state.incrementing or self.server.state.rotating):
-            ss = cy.Screenshot(self.scene.renderWindow)
+            ss = Screenshot(self.scene.renderWindow)
             ss.save(f"{dr}/0.png")
         else:
             n = self.scene.nframes
@@ -86,7 +280,7 @@ class Logic:
                     if self.server.state.incrementing:
                         self.increment_frame()
                     self.server.controller.view_update()
-                    ss = cy.Screenshot(self.scene.renderWindow)
+                    ss = Screenshot(self.scene.renderWindow)
                     ss.save(f"{dr}/{i}.png")
                     await asyncio.sleep(
                         1 / self.server.state.bpm * 60 / self.scene.nframes
@@ -100,3 +294,72 @@ class Logic:
         self.server.state.bpm = 60
         self.server.state.bpr = 5
         self.server.controller.view_update()
+
+    def sync_background_color(self, dark_mode, **kwargs):
+        """Sync VTK renderer background with dark mode."""
+        if dark_mode:
+            # Dark mode: use dark background from config
+            self.scene.renderer.SetBackground(
+                *self.scene.background.dark,
+            )
+        else:
+            # Light mode: use light background from config
+            self.scene.renderer.SetBackground(
+                *self.scene.background.light,
+            )
+        self.server.controller.view_update()
+
+    def _initialize_clipping_state(self):
+        """Initialize clipping state variables for all objects."""
+        # Initialize mesh clipping state
+        for m in self.scene.meshes:
+            # Initialize panel state
+            setattr(self.server.state, f"clip_panel_{m.label}", [])
+
+            # Initialize range sliders with mesh bounds if available
+            if m.actors:
+                bounds = m.combined_bounds
+                setattr(self.server.state, f"clip_x_{m.label}", [bounds[0], bounds[1]])
+                setattr(self.server.state, f"clip_y_{m.label}", [bounds[2], bounds[3]])
+                setattr(self.server.state, f"clip_z_{m.label}", [bounds[4], bounds[5]])
+
+        # Initialize volume clipping state
+        for v in self.scene.volumes:
+            preset_key = getattr(v, "transfer_function_preset", "cardiac")
+            setattr(self.server.state, f"volume_preset_{v.label}", preset_key)
+
+            # Initialize preset panel state (collapsed by default)
+            setattr(self.server.state, f"preset_panel_{v.label}", [])
+            if hasattr(v, "clipping_enabled"):
+                # Initialize clipping checkbox state
+                setattr(
+                    self.server.state, f"volume_clipping_{v.label}", v.clipping_enabled
+                )
+
+                # Initialize panel state
+                setattr(self.server.state, f"clip_panel_{v.label}", [])
+
+                # Initialize range sliders with volume bounds if available
+                if v.actors:
+                    bounds = v.combined_bounds
+                    setattr(
+                        self.server.state, f"clip_x_{v.label}", [bounds[0], bounds[1]]
+                    )
+                    setattr(
+                        self.server.state, f"clip_y_{v.label}", [bounds[2], bounds[3]]
+                    )
+                    setattr(
+                        self.server.state, f"clip_z_{v.label}", [bounds[4], bounds[5]]
+                    )
+
+        # Initialize segmentation clipping state
+        for s in self.scene.segmentations:
+            # Initialize panel state
+            setattr(self.server.state, f"clip_panel_{s.label}", [])
+
+            # Initialize range sliders with segmentation bounds if available
+            if s.actors:
+                bounds = s.combined_bounds
+                setattr(self.server.state, f"clip_x_{s.label}", [bounds[0], bounds[1]])
+                setattr(self.server.state, f"clip_y_{s.label}", [bounds[2], bounds[3]])
+                setattr(self.server.state, f"clip_z_{s.label}", [bounds[4], bounds[5]])