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

cardio/scene.py

@@ -1,78 +1,213 @@
+# System
 import logging
+import pathlib as pl
 
+# Type adapters for list types to improve CLI integration
+from typing import Annotated
+
+# Third Party
 import numpy as np
-import tomlkit as tk
-
-# noinspection PyUnresolvedReferences
-import vtkmodules.vtkInteractionStyle
-
-# Required for rendering initialization, not necessary for
-# local rendering, but doesn't hurt to include it
-# noinspection PyUnresolvedReferences
-import vtkmodules.vtkRenderingOpenGL2  # noqa
-
-# Required for interactor initialization
-from vtkmodules.vtkInteractionStyle import vtkInteractorStyleSwitch  # noqa
-from vtkmodules.vtkIOGeometry import vtkOBJReader
-from vtkmodules.vtkRenderingCore import (
-    vtkRenderer,
-    vtkRenderWindow,
-    vtkRenderWindowInteractor,
-)
-
-from . import Mesh, Volume
-
-
-class Scene:
-    def __init__(self, cfg_file: str):
-        self.meshes: list[Mesh] = []
-        self.volumes: list[Volume] = []
-        self.nframes: int = None
-        self.renderer: vtkRenderer = vtkRenderer()
-        self.renderWindow: vtkRenderWindow = vtkRenderWindow()
-        self.renderWindowInteractor: vtkRenderWindowInteractor = (
-            vtkRenderWindowInteractor()
+import pydantic as pc
+import pydantic_settings as ps
+import vtk
+from pydantic import Field, PrivateAttr, TypeAdapter, field_validator, model_validator
+
+# Internal
+from .mesh import Mesh
+from .segmentation import Segmentation
+from .types import RGBColor
+from .volume import Volume
+
+MeshListAdapter = TypeAdapter(list[Mesh])
+VolumeListAdapter = TypeAdapter(list[Volume])
+SegmentationListAdapter = TypeAdapter(list[Segmentation])
+
+# Create annotated types for better CLI integration
+MeshList = Annotated[
+    list[Mesh],
+    Field(
+        description='List of mesh objects. CLI usage: --meshes \'[{"label":"mesh1","directory":"./data/mesh1"}]\''
+    ),
+]
+VolumeList = Annotated[
+    list[Volume],
+    Field(
+        description='Volume objects. CLI: --volumes \'[{"label":"vol1","directory":"./data/vol1"}]\''
+    ),
+]
+SegmentationList = Annotated[
+    list[Segmentation],
+    Field(
+        description='Segmentation objects. CLI: --segmentations \'[{"label":"seg1","directory":"./data/seg1"}]\''
+    ),
+]
+
+
+class Background(pc.BaseModel):
+    light: RGBColor = Field(
+        default=(1.0, 1.0, 1.0),
+        description="Background color in light mode.  CLI usage: --background.light '[0.8,0.9,1.0]'",
+    )
+    dark: RGBColor = Field(
+        default=(0.0, 0.0, 0.0),
+        description="Background color in dark mode.  CLI usage: --background.dark '[0.1,0.1,0.2]'",
+    )
+
+
+class Scene(ps.BaseSettings):
+    model_config = ps.SettingsConfigDict(
+        arbitrary_types_allowed=True,
+        populate_by_name=True,
+        cli_parse_args=False,
+        cli_use_class_docstring=True,
+    )
+
+    @classmethod
+    def settings_customise_sources(
+        cls,
+        settings_cls,
+        init_settings,
+        env_settings,
+        dotenv_settings,
+        file_secret_settings,
+    ):
+        # Get the CLI settings source and config file from the class if available
+        cli_source = getattr(cls, "_cli_source", None)
+        config_file = getattr(cls, "_config_file", None)
+
+        sources = [init_settings]
+
+        # Add CLI settings source if available
+        if cli_source is not None:
+            sources.append(cli_source)
+
+        # Add TOML config file source if config file is specified
+        if config_file is not None:
+            sources.append(
+                ps.TomlConfigSettingsSource(settings_cls, toml_file=config_file)
+            )
+
+        sources.extend([env_settings, file_secret_settings])
+        return tuple(sources)
+
+    project_name: str = "Cardio"
+    current_frame: int = 0
+    screenshot_directory: pl.Path = pl.Path("./data/screenshots")
+    screenshot_subdirectory_format: pl.Path = pl.Path("%Y-%m-%d-%H-%M-%S")
+    rotation_factor: float = 3.0
+    background: Background = Field(
+        default_factory=Background,
+        description='Background colors. CLI usage: \'{"light": [0.8, 0.9, 1.0], "dark": [0.1, 0.1, 0.2]}\'',
+    )
+    meshes: MeshList = Field(default_factory=list)
+    volumes: VolumeList = Field(default_factory=list)
+    segmentations: SegmentationList = Field(default_factory=list)
+
+    # Field validators for JSON string inputs
+    @field_validator("meshes", mode="before")
+    @classmethod
+    def validate_meshes(cls, v):
+        if isinstance(v, str):
+            return MeshListAdapter.validate_json(v)
+        return v
+
+    @field_validator("volumes", mode="before")
+    @classmethod
+    def validate_volumes(cls, v):
+        if isinstance(v, str):
+            return VolumeListAdapter.validate_json(v)
+        return v
+
+    @field_validator("segmentations", mode="before")
+    @classmethod
+    def validate_segmentations(cls, v):
+        if isinstance(v, str):
+            return SegmentationListAdapter.validate_json(v)
+        return v
+
+    # VTK objects as private attributes
+    _renderer: vtk.vtkRenderer = PrivateAttr(default_factory=vtk.vtkRenderer)
+    _renderWindow: vtk.vtkRenderWindow = PrivateAttr(
+        default_factory=vtk.vtkRenderWindow
+    )
+    _renderWindowInteractor: vtk.vtkRenderWindowInteractor = PrivateAttr(
+        default_factory=vtk.vtkRenderWindowInteractor
+    )
+
+    @property
+    def renderer(self) -> vtk.vtkRenderer:
+        return self._renderer
+
+    @property
+    def renderWindow(self) -> vtk.vtkRenderWindow:
+        return self._renderWindow
+
+    @property
+    def renderWindowInteractor(self) -> vtk.vtkRenderWindowInteractor:
+        return self._renderWindowInteractor
+
+    @model_validator(mode="after")
+    def setup_scene(self):
+        # Configure VTK objects
+        self._renderer.SetBackground(
+            *self.background.light,
         )
-        self.renderWindowInteractor.GetInteractorStyle().SetCurrentStyleToTrackballCamera()
-
-        with open(cfg_file, mode="rt", encoding="utf-8") as fp:
-            self.cfg = tk.load(fp)
-        for mesh_cfg in self.cfg["meshes"]:
-            self.meshes += [Mesh(mesh_cfg, self.renderer)]
-        for volume_cfg in self.cfg["volumes"]:
-            self.volumes += [Volume(volume_cfg, self.renderer)]
-        self.set_nframes()
-
-        self.project_name = self.cfg["project_name"]
-        self.current_frame = self.cfg["current_frame"] % self.nframes
-        self.screenshot_directory = self.cfg["screenshot_directory"]
-        self.screenshot_subdirectory_format = self.cfg["screenshot_subdirectory_format"]
-        self.rotation_factor = self.cfg["rotation_factor"]
-        self.background_r = self.cfg["background_r"]
-        self.background_g = self.cfg["background_g"]
-        self.background_b = self.cfg["background_b"]
-
-        self.setup_rendering()
+        self._renderWindow.AddRenderer(self._renderer)
+        self._renderWindow.SetOffScreenRendering(True)
+        self._renderWindowInteractor.SetRenderWindow(self._renderWindow)
+        self._renderWindowInteractor.GetInteractorStyle().SetCurrentStyleToTrackballCamera()
+
+        # Configure all objects
         for mesh in self.meshes:
-            mesh.setup_pipeline(self.current_frame)
+            mesh.configure_actors()
         for volume in self.volumes:
-            volume.setup_pipeline(self.current_frame)
+            volume.configure_actors()
+        for segmentation in self.segmentations:
+            segmentation.configure_actors()
+
+        # Set current frame using nframes property
+        self.current_frame = self.current_frame % self.nframes
 
-    def set_nframes(self):
+        # Setup rendering pipeline
+        self.setup_pipeline()
+
+        return self
+
+    @property
+    def nframes(self) -> int:
         ns = []
         ns += [len(m.actors) for m in self.meshes]
         ns += [len(v.actors) for v in self.volumes]
+        ns += [len(s.actors) for s in self.segmentations]
+        if not len(ns) > 0:
+            logging.warning("No objects were found to display.")
+            return 1
+        result = int(max(ns))
         ns = np.array(ns)
-        assert len(ns) > 0
-        assert np.all(ns == ns[0])
-        self.nframes = int(ns[0])
+        if not np.all(ns == ns[0]):
+            logging.warning(f"Unequal number of frames: {ns}.")
+        return result
 
-    def setup_rendering(self):
-        self.renderer.SetBackground(
-            self.background_r, self.background_g, self.background_b
-        )
-        self.renderWindow.AddRenderer(self.renderer)
-        self.renderWindowInteractor.SetRenderWindow(self.renderWindow)
+    def setup_pipeline(self):
+        """Add all actors to the renderer and configure initial visibility."""
+        # Add mesh actors
+        for mesh in self.meshes:
+            for actor in mesh.actors:
+                self.renderer.AddActor(actor)
+
+        # Add volume actors
+        for volume in self.volumes:
+            for actor in volume.actors:
+                self.renderer.AddVolume(actor)
+
+        # Add segmentation actors
+        for segmentation in self.segmentations:
+            for actor in segmentation.actors:
+                self.renderer.AddActor(actor)
+
+        # Show current frame
+        self.show_frame(self.current_frame)
+        self.renderer.ResetCamera()
 
     def hide_all_frames(self):
         for a in self.renderer.GetActors():
@@ -83,7 +218,11 @@ class Scene:
     def show_frame(self, frame: int):
         for mesh in self.meshes:
             if mesh.visible:
-                mesh.actors[frame].SetVisibility(True)
+                mesh.actors[frame % len(mesh.actors)].SetVisibility(True)
         for volume in self.volumes:
             if volume.visible:
-                volume.actors[frame].SetVisibility(True)
+                volume.actors[frame % len(volume.actors)].SetVisibility(True)
+        for segmentation in self.segmentations:
+            if segmentation.visible:
+                actor = segmentation.actors[frame % len(segmentation.actors)]
+                actor.SetVisibility(True)

cardio/screenshot.py

@@ -1,16 +1,15 @@
-from vtkmodules.vtkIOImage import vtkPNGWriter
-from vtkmodules.vtkRenderingCore import vtkRenderWindow, vtkWindowToImageFilter
+import vtk
 
 
 class Screenshot:
-    def __init__(self, renderWindow: vtkRenderWindow):
-        self.windowToImageFilter = vtkWindowToImageFilter()
+    def __init__(self, renderWindow: vtk.vtkRenderWindow):
+        self.windowToImageFilter = vtk.vtkWindowToImageFilter()
         self.windowToImageFilter.SetInput(renderWindow)
         self.windowToImageFilter.SetScale(1)
         self.windowToImageFilter.SetInputBufferTypeToRGBA()
         self.windowToImageFilter.ReadFrontBufferOff()
 
-        self.writer = vtkPNGWriter()
+        self.writer = vtk.vtkPNGWriter()
         self.writer.SetInputConnection(self.windowToImageFilter.GetOutputPort())
 
     def save(self, fileName: str):

cardio/segmentation.py

@@ -0,0 +1,178 @@
+# System
+import logging
+
+# Third Party
+import itk
+import numpy as np
+import pydantic as pc
+import vtk
+
+# Internal
+from .object import Object
+from .property_config import vtkPropertyConfig
+from .utils import InterpolatorType, reset_direction
+
+
+class Segmentation(Object):
+    """Segmentation object with multi-label mesh extraction using SurfaceNets."""
+
+    pattern: str = pc.Field(
+        default="${frame}.nii.gz",
+        description="Filename pattern with $frame placeholder",
+    )
+    _actors: list[vtk.vtkActor] = pc.PrivateAttr(default_factory=list)
+    properties: vtkPropertyConfig = pc.Field(
+        default_factory=vtkPropertyConfig, description="Property configuration"
+    )
+    include_labels: list[int] | None = pc.Field(default=None)
+    label_properties: dict[int, dict] = pc.Field(default_factory=dict)
+
+    @pc.model_validator(mode="after")
+    def initialize_segmentation(self):
+        """Generate VTK actors for all frames using SurfaceNets3D."""
+        for frame, path in enumerate(self.path_list):
+            logging.info(f"{self.label}: Loading segmentation frame {frame}.")
+
+            # Read and process segmentation image
+            image = itk.imread(path)
+            image = reset_direction(image, InterpolatorType.NEAREST)
+            vtk_image = itk.vtk_image_from_image(image)
+
+            # Create SurfaceNets3D filter
+            surface_nets = vtk.vtkSurfaceNets3D()
+            surface_nets.SetInputData(vtk_image)
+
+            # Configure label selection if specified
+            if self.include_labels is not None:
+                surface_nets.SetOutputStyle(surface_nets.OUTPUT_STYLE_SELECTED)
+                surface_nets.InitializeSelectedLabelsList()
+                for label in self.include_labels:
+                    surface_nets.AddSelectedLabel(label)
+
+            # Execute filter
+            surface_nets.Update()
+            mesh = surface_nets.GetOutput()
+
+            # Create scalar array from boundary labels (use higher value)
+            boundary_labels = mesh.GetCellData().GetArray("BoundaryLabels")
+
+            if boundary_labels:
+                # Create scalar array using the maximum of the two boundary labels
+                scalar_array = vtk.vtkIntArray()
+                scalar_array.SetName("Labels")
+                scalar_array.SetNumberOfTuples(boundary_labels.GetNumberOfTuples())
+
+                for i in range(boundary_labels.GetNumberOfTuples()):
+                    label1 = int(boundary_labels.GetComponent(i, 0))
+                    label2 = int(boundary_labels.GetComponent(i, 1))
+                    # Use the higher label value (excluding background=0)
+                    max_label = (
+                        max(label1, label2)
+                        if max(label1, label2) > 0
+                        else min(label1, label2)
+                    )
+                    scalar_array.SetValue(i, max_label)
+
+                mesh.GetCellData().SetScalars(scalar_array)
+
+            # Create single actor with scalar coloring
+            actor = self._create_segmentation_actor(mesh)
+            self._actors.append(actor)
+
+        return self
+
+    @property
+    def actors(self) -> list[vtk.vtkActor]:
+        return self._actors
+
+    def _create_segmentation_actor(self, mesh):
+        """Create a VTK actor with scalar-based coloring for the segmentation mesh."""
+        # Create a mapper with scalar coloring
+        mapper = vtk.vtkPolyDataMapper()
+        mapper.SetInputData(mesh)
+        mapper.SetScalarModeToUseCellData()
+        mapper.ScalarVisibilityOn()
+
+        # Create color transfer function for label-based coloring
+        color_func = vtk.vtkColorTransferFunction()
+
+        # Get the label range from the scalar array
+        scalar_array = mesh.GetCellData().GetArray("Labels")
+        if scalar_array:
+            scalar_range = scalar_array.GetRange()
+            min_label = int(scalar_range[0])
+            max_label = int(scalar_range[1])
+
+            # Set colors for each label
+            for label in range(min_label, max_label + 1):
+                if label == 0:  # Skip background
+                    continue
+
+                if label in self.label_properties:
+                    props = self.label_properties[label]
+                    color_func.AddRGBPoint(
+                        label,
+                        props.get("r", 1.0),
+                        props.get("g", 0.0),
+                        props.get("b", 0.0),
+                    )
+                else:
+                    # Default coloring based on label value
+                    color = self._get_default_color(label)
+                    color_func.AddRGBPoint(label, *color)
+
+            mapper.SetLookupTable(color_func)
+            mapper.SetScalarRange(min_label, max_label)
+
+        # Create actor
+        actor = vtk.vtkActor()
+        actor.SetMapper(mapper)
+
+        return actor
+
+    def _get_default_color(self, label):
+        """Generate a default color for a label."""
+        # Simple color generation based on label value
+        np.random.seed(label)
+        return np.random.rand(3)
+
+    def configure_actors(self):
+        """Configure actor properties without adding to renderer."""
+        for actor in self._actors:
+            actor.SetVisibility(False)
+            # Apply base property configuration if available
+            base_prop = self.properties.vtk_property
+            if base_prop:
+                # Note: For scalar-colored actors, we preserve the color transfer function
+                # by not overriding the mapper's lookup table
+                pass
+
+    def toggle_clipping(self, enabled: bool):
+        """Enable or disable clipping for all segmentation actors."""
+        if not self._actors:
+            return
+
+        if enabled and self.clipping_planes:
+            # Apply clipping to all actors
+            for actor in self._actors:
+                mapper = actor.GetMapper()
+                mapper.SetClippingPlanes(self.clipping_planes)
+        else:
+            # Remove clipping from all actors
+            for actor in self._actors:
+                mapper = actor.GetMapper()
+                mapper.RemoveAllClippingPlanes()
+
+    def update_clipping_bounds(self, bounds):
+        """Update clipping bounds from UI controls."""
+        if not self.clipping_planes:
+            return
+
+        # Update clipping planes with new bounds
+        super()._create_clipping_planes_from_bounds(self.clipping_planes, bounds)
+
+        # Apply to all actors if clipping is enabled
+        if self.clipping_enabled:
+            for actor in self._actors:
+                mapper = actor.GetMapper()
+                mapper.SetClippingPlanes(self.clipping_planes)