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

cardio/__init__.py

@@ -1,15 +1,16 @@
+from . import window_level
 from .logic import Logic
 from .mesh import Mesh
 from .object import Object
 from .scene import Scene
 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
+from .volume_property_presets import (
+    list_volume_property_presets,
+    load_volume_property_preset,
+)
 
 __all__ = [
     "Object",
@@ -20,8 +21,9 @@ __all__ = [
     "Screenshot",
     "UI",
     "Logic",
-    "load_preset",
-    "list_available_presets",
+    "load_volume_property_preset",
+    "list_volume_property_presets",
+    "window_level",
 ]
 
-__version__ = "2025.8.1"
+__version__ = "2025.10.0"

cardio/app.py

@@ -2,49 +2,42 @@
 
 # Third Party
 import pydantic_settings as ps
-import tomlkit as tk
 import trame as tm
+import trame.decorators
 
+# Internal
 from . import __version__
 from .logic import Logic
-
-# Internal
 from .scene import Scene
 from .ui import UI
 
 
-class CardioApp(tm.app.TrameApp):
-    def __init__(self, name=None):
-        super().__init__(server=name, client_type="vue2")
+@tm.decorators.TrameApp()
+class CardioApp:
+    def __init__(self, server=None):
+        self.server = tm.app.get_server(server, client_type="vue3")
 
-        # 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
         )
 
-        # 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)
 
-        # Set the CLI source and config file on the Scene class temporarily
         Scene._cli_source = cli_settings
         Scene._config_file = config_file
 
         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"):

cardio/blend_transfer_functions.py

@@ -0,0 +1,84 @@
+# System
+import numpy as np
+
+# Third Party
+import vtk
+
+
+def blend_transfer_functions(tfs, scalar_range=(-2000, 2000), num_samples=512):
+    """
+    Blend multiple transfer functions using volume rendering emission-absorption model.
+
+    Based on the volume rendering equation from:
+    - Levoy, M. "Display of Surfaces from Volume Data" IEEE Computer Graphics and Applications, 1988
+    - Kajiya, J.T. & Von Herzen, B.P. "Ray tracing volume densities" ACM SIGGRAPH Computer Graphics, 1984
+    - Engel, K. et al. "Real-time Volume Graphics" A K Peters, 2006, Chapter 2
+
+    The volume rendering integral: I = ∫ C(s) * μ(s) * T(s) ds
+    where C(s) = emission color, μ(s) = opacity, T(s) = transmission
+
+    For discrete transfer functions, this becomes:
+    - Total emission = Σ(color_i * opacity_i)
+    - Total absorption = Σ(opacity_i)
+    - Final color = total_emission / total_absorption
+    """
+    if len(tfs) == 1:
+        return tfs[0]
+
+    sample_points = np.linspace(
+        start=scalar_range[0],
+        stop=scalar_range[1],
+        num=num_samples,
+    )
+
+    # Initialize arrays to store blended values
+    blended_opacity = []
+    blended_color = []
+
+    for scalar_val in sample_points:
+        # Accumulate emission and absorption for volume rendering
+        total_emission = [0.0, 0.0, 0.0]
+        total_absorption = 0.0
+
+        for otf, ctf in tfs:
+            # Get opacity and color for this scalar value
+            layer_opacity = otf.GetValue(scalar_val)
+            layer_color = [0.0, 0.0, 0.0]
+            ctf.GetColor(scalar_val, layer_color)
+
+            # Volume rendering accumulation:
+            # Emission = color * opacity (additive)
+            # Absorption = opacity (multiplicative through transmission)
+            for i in range(3):
+                total_emission[i] += layer_color[i] * layer_opacity
+
+            total_absorption += layer_opacity
+
+        # Clamp values to reasonable ranges
+        total_absorption = min(total_absorption, 1.0)
+        for i in range(3):
+            total_emission[i] = min(total_emission[i], 1.0)
+
+        # For the final color, normalize emission by absorption if absorption > 0
+        if total_absorption > 0.001:  # Avoid division by zero
+            final_color = [total_emission[i] / total_absorption for i in range(3)]
+        else:
+            final_color = [0.0, 0.0, 0.0]
+
+        # Clamp final colors
+        final_color = [min(c, 1.0) for c in final_color]
+
+        blended_opacity.append(total_absorption)
+        blended_color.append(final_color)
+
+    # Create new VTK transfer functions with blended values
+    blended_otf = vtk.vtkPiecewiseFunction()
+    blended_ctf = vtk.vtkColorTransferFunction()
+
+    for i, scalar_val in enumerate(sample_points):
+        blended_otf.AddPoint(scalar_val, blended_opacity[i])
+        blended_ctf.AddRGBPoint(
+            scalar_val, blended_color[i][0], blended_color[i][1], blended_color[i][2]
+        )
+
+    return blended_otf, blended_ctf

cardio/color_transfer_function.py

@@ -0,0 +1,29 @@
+# Third Party
+import pydantic as pc
+import vtk
+
+# Internal
+from .types import RGBColor
+
+
+class ColorTransferFunctionPoint(pc.BaseModel):
+    """A single point in a color transfer function."""
+
+    x: float = pc.Field(description="Scalar value")
+    color: RGBColor
+
+
+class ColorTransferFunctionConfig(pc.BaseModel):
+    """Configuration for a VTK color transfer function."""
+
+    points: list[ColorTransferFunctionPoint] = pc.Field(
+        min_length=1, description="Points defining the color transfer function"
+    )
+
+    @property
+    def vtk_function(self) -> vtk.vtkColorTransferFunction:
+        """Create VTK color transfer function from this configuration."""
+        ctf = vtk.vtkColorTransferFunction()
+        for point in self.points:
+            ctf.AddRGBPoint(point.x, *point.color)
+        return ctf