cardio 2025.8.1__py3-none-any.whl → 2025.9.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,8 @@ __all__ = [
     "Screenshot",
     "UI",
     "Logic",
-    "load_preset",
-    "list_available_presets",
+    "load_volume_property_preset",
+    "list_volume_property_presets",
 ]
 
-__version__ = "2025.8.1"
+__version__ = "2025.9.0"

cardio/app.py

@@ -15,7 +15,7 @@ from .ui import UI
 
 class CardioApp(tm.app.TrameApp):
     def __init__(self, name=None):
-        super().__init__(server=name, client_type="vue2")
+        super().__init__(server=name, client_type="vue3")
 
         # Add config file argument to Trame's parser
         self.server.cli.add_argument(

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

cardio/logic.py

@@ -12,9 +12,34 @@ class Logic:
         self.server = server
         self.scene = scene
 
+        # Initialize mpr_presets early to avoid undefined errors
+        self.server.state.mpr_presets = []
+
+        # Initialize volume items for MPR dropdown
+        self.server.state.volume_items = [
+            {"text": volume.label, "value": volume.label}
+            for volume in self.scene.volumes
+        ]
+
         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)
+        self.server.state.change("theme_mode")(self.sync_background_color)
+        self.server.state.change("mpr_enabled")(self.sync_mpr_mode)
+        self.server.state.change("active_volume_label")(self.sync_active_volume)
+        self.server.state.change("axial_slice", "sagittal_slice", "coronal_slice")(
+            self.update_slice_positions
+        )
+        self.server.state.change("mpr_window", "mpr_level")(
+            self.update_mpr_window_level
+        )
+        self.server.state.change("mpr_window_level_preset")(self.update_mpr_preset)
+        self.server.state.change("mpr_rotation_sequence")(self.update_mpr_rotation)
+
+        # Add handlers for individual rotation angles
+        for i in range(20):
+            self.server.state.change(f"mpr_rotation_angle_{i}")(
+                self.update_mpr_rotation
+            )
 
         # Initialize visibility state variables
         for m in self.scene.meshes:
@@ -98,6 +123,50 @@ class Logic:
         self.server.controller.decrement_frame = self.decrement_frame
         self.server.controller.screenshot = self.screenshot
         self.server.controller.reset_all = self.reset_all
+        self.server.controller.close_application = self.close_application
+
+        # MPR rotation controllers
+        self.server.controller.add_x_rotation = lambda: self.add_mpr_rotation("X")
+        self.server.controller.add_y_rotation = lambda: self.add_mpr_rotation("Y")
+        self.server.controller.add_z_rotation = lambda: self.add_mpr_rotation("Z")
+        self.server.controller.remove_rotation_event = self.remove_mpr_rotation
+        self.server.controller.reset_rotations = self.reset_mpr_rotations
+
+        # Initialize MPR state
+        self.server.state.mpr_enabled = self.scene.mpr_enabled
+        self.server.state.active_volume_label = self.scene.active_volume_label
+        self.server.state.axial_slice = self.scene.axial_slice
+        self.server.state.sagittal_slice = self.scene.sagittal_slice
+        self.server.state.coronal_slice = self.scene.coronal_slice
+        self.server.state.mpr_window = self.scene.mpr_window
+        self.server.state.mpr_level = self.scene.mpr_level
+        self.server.state.mpr_window_level_preset = self.scene.mpr_window_level_preset
+        self.server.state.mpr_rotation_sequence = self.scene.mpr_rotation_sequence
+
+        # Initialize MPR presets data
+        try:
+            from .window_level import presets
+
+            self.server.state.mpr_presets = [
+                {"text": preset.name, "value": key} for key, preset in presets.items()
+            ]
+        except Exception as e:
+            print(f"Error initializing MPR presets: {e}")
+            self.server.state.mpr_presets = []
+
+        # Initialize rotation angle states (up to 20 rotations like app.py)
+        for i in range(20):
+            setattr(self.server.state, f"mpr_rotation_angle_{i}", 0)
+            setattr(self.server.state, f"mpr_rotation_axis_{i}", f"Rotation {i + 1}")
+
+        # Apply initial preset to ensure window/level values are set correctly
+        # Only update state values, don't call update methods yet since MPR may not be enabled
+        from .window_level import presets
+
+        if self.scene.mpr_window_level_preset in presets:
+            preset = presets[self.scene.mpr_window_level_preset]
+            self.server.state.mpr_window = preset.window
+            self.server.state.mpr_level = preset.level
 
         # Initialize clipping state variables
         self._initialize_clipping_state()
@@ -122,8 +191,95 @@ class Logic:
                 actor = segmentation.actors[frame % len(segmentation.actors)]
                 actor.SetVisibility(True)
 
+        # Update MPR views if MPR is enabled
+        self.update_mpr_frame(frame)
+
         self.server.controller.view_update()
 
+    def update_mpr_frame(self, frame):
+        """Update MPR views to show the specified frame."""
+        if not getattr(self.server.state, "mpr_enabled", False):
+            return
+
+        active_volume_label = getattr(self.server.state, "active_volume_label", "")
+        if not active_volume_label:
+            return
+
+        # Find the active volume
+        active_volume = None
+        for volume in self.scene.volumes:
+            if volume.label == active_volume_label:
+                active_volume = volume
+                break
+
+        if not active_volume:
+            return
+
+        # Get or create MPR actors for the new frame
+        mpr_actors = active_volume.get_mpr_actors_for_frame(frame)
+
+        # Update each MPR renderer with the new frame's actors
+        if self.scene.axial_renderWindow:
+            axial_renderer = (
+                self.scene.axial_renderWindow.GetRenderers().GetFirstRenderer()
+            )
+            if axial_renderer:
+                axial_renderer.RemoveAllViewProps()
+                axial_renderer.AddActor(mpr_actors["axial"]["actor"])
+                mpr_actors["axial"]["actor"].SetVisibility(True)
+                # Apply current slice position and window/level
+                self._apply_current_mpr_settings(active_volume, frame)
+                axial_renderer.ResetCamera()
+
+        if self.scene.coronal_renderWindow:
+            coronal_renderer = (
+                self.scene.coronal_renderWindow.GetRenderers().GetFirstRenderer()
+            )
+            if coronal_renderer:
+                coronal_renderer.RemoveAllViewProps()
+                coronal_renderer.AddActor(mpr_actors["coronal"]["actor"])
+                mpr_actors["coronal"]["actor"].SetVisibility(True)
+                coronal_renderer.ResetCamera()
+
+        if self.scene.sagittal_renderWindow:
+            sagittal_renderer = (
+                self.scene.sagittal_renderWindow.GetRenderers().GetFirstRenderer()
+            )
+            if sagittal_renderer:
+                sagittal_renderer.RemoveAllViewProps()
+                sagittal_renderer.AddActor(mpr_actors["sagittal"]["actor"])
+                mpr_actors["sagittal"]["actor"].SetVisibility(True)
+                sagittal_renderer.ResetCamera()
+
+    def _apply_current_mpr_settings(self, active_volume, frame):
+        """Apply current slice positions and window/level to MPR actors."""
+        # Apply slice positions
+        axial_slice = getattr(self.server.state, "axial_slice", 0.5)
+        sagittal_slice = getattr(self.server.state, "sagittal_slice", 0.5)
+        coronal_slice = getattr(self.server.state, "coronal_slice", 0.5)
+
+        # Get rotation data
+        rotation_sequence = getattr(self.server.state, "mpr_rotation_sequence", [])
+        rotation_angles = {}
+        for i in range(len(rotation_sequence)):
+            rotation_angles[i] = getattr(
+                self.server.state, f"mpr_rotation_angle_{i}", 0
+            )
+
+        active_volume.update_slice_positions(
+            frame,
+            axial_slice,
+            sagittal_slice,
+            coronal_slice,
+            rotation_sequence,
+            rotation_angles,
+        )
+
+        # Apply window/level
+        window = getattr(self.server.state, "mpr_window", 400.0)
+        level = getattr(self.server.state, "mpr_level", 40.0)
+        active_volume.update_mpr_window_level(frame, window, level)
+
     @asynchronous.task
     async def play(self, playing, **kwargs):
         if not (self.server.state.incrementing or self.server.state.rotating):
@@ -159,11 +315,11 @@ class Logic:
 
     def sync_volume_presets(self, **kwargs):
         """Update volume transfer function presets based on UI selection."""
-        from .transfer_functions import load_preset
+        from .volume_property_presets import load_volume_property_preset
 
         for v in self.scene.volumes:
             preset_name = self.server.state[f"volume_preset_{v.label}"]
-            preset = load_preset(preset_name)
+            preset = load_volume_property_preset(preset_name)
 
             # Apply preset to all actors
             for actor in v.actors:
@@ -295,9 +451,9 @@ class Logic:
         self.server.state.bpr = 5
         self.server.controller.view_update()
 
-    def sync_background_color(self, dark_mode, **kwargs):
+    def sync_background_color(self, theme_mode, **kwargs):
         """Sync VTK renderer background with dark mode."""
-        if dark_mode:
+        if theme_mode == "dark":
             # Dark mode: use dark background from config
             self.scene.renderer.SetBackground(
                 *self.scene.background.dark,
@@ -363,3 +519,257 @@ class Logic:
                 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]])
+
+    def sync_mpr_mode(self, mpr_enabled, **kwargs):
+        """Handle MPR mode toggle."""
+        if (
+            mpr_enabled
+            and self.scene.volumes
+            and not self.server.state.active_volume_label
+        ):
+            # Auto-select first volume when MPR is enabled and no volume is selected
+            self.server.state.active_volume_label = self.scene.volumes[0].label
+
+    def sync_active_volume(self, active_volume_label, **kwargs):
+        """Handle active volume selection for MPR."""
+
+        if not active_volume_label or not self.server.state.mpr_enabled:
+            return
+
+        # Find the selected volume
+        active_volume = None
+        for volume in self.scene.volumes:
+            if volume.label == active_volume_label:
+                active_volume = volume
+                break
+
+        if not active_volume:
+            return
+
+        # Create MPR actors for current frame
+        current_frame = getattr(self.server.state, "frame", 0)
+        mpr_actors = active_volume.get_mpr_actors_for_frame(current_frame)
+
+        # Add MPR actors to their respective renderers
+        if self.scene.axial_renderWindow:
+            axial_renderer = (
+                self.scene.axial_renderWindow.GetRenderers().GetFirstRenderer()
+            )
+            if axial_renderer:
+                axial_renderer.RemoveAllViewProps()  # Clear existing actors
+                axial_renderer.AddActor(mpr_actors["axial"]["actor"])
+                mpr_actors["axial"]["actor"].SetVisibility(True)
+                axial_renderer.ResetCamera()
+
+        if self.scene.coronal_renderWindow:
+            coronal_renderer = (
+                self.scene.coronal_renderWindow.GetRenderers().GetFirstRenderer()
+            )
+            if coronal_renderer:
+                coronal_renderer.RemoveAllViewProps()
+                coronal_renderer.AddActor(mpr_actors["coronal"]["actor"])
+                mpr_actors["coronal"]["actor"].SetVisibility(True)
+                coronal_renderer.ResetCamera()
+
+        if self.scene.sagittal_renderWindow:
+            sagittal_renderer = (
+                self.scene.sagittal_renderWindow.GetRenderers().GetFirstRenderer()
+            )
+            if sagittal_renderer:
+                sagittal_renderer.RemoveAllViewProps()
+                sagittal_renderer.AddActor(mpr_actors["sagittal"]["actor"])
+                mpr_actors["sagittal"]["actor"].SetVisibility(True)
+                sagittal_renderer.ResetCamera()
+
+        # Apply current window/level settings to the MPR actors
+        window = getattr(self.server.state, "mpr_window", 800.0)
+        level = getattr(self.server.state, "mpr_level", 200.0)
+        active_volume.update_mpr_window_level(current_frame, window, level)
+
+        # Update all views
+        self.server.controller.view_update()
+
+    def update_slice_positions(self, **kwargs):
+        """Update MPR slice positions when sliders change."""
+
+        if not getattr(self.server.state, "mpr_enabled", False):
+            return
+
+        active_volume_label = getattr(self.server.state, "active_volume_label", "")
+        if not active_volume_label:
+            return
+
+        # Find the active volume
+        active_volume = None
+        for volume in self.scene.volumes:
+            if volume.label == active_volume_label:
+                active_volume = volume
+                break
+
+        if not active_volume:
+            return
+
+        # Get current slice positions
+        axial_slice = getattr(self.server.state, "axial_slice", 0.5)
+        sagittal_slice = getattr(self.server.state, "sagittal_slice", 0.5)
+        coronal_slice = getattr(self.server.state, "coronal_slice", 0.5)
+        current_frame = getattr(self.server.state, "frame", 0)
+
+        # Get rotation data
+        rotation_sequence = getattr(self.server.state, "mpr_rotation_sequence", [])
+        rotation_angles = {}
+        for i in range(len(rotation_sequence)):
+            rotation_angles[i] = getattr(
+                self.server.state, f"mpr_rotation_angle_{i}", 0
+            )
+
+        # Update slice positions with rotation
+        active_volume.update_slice_positions(
+            current_frame,
+            axial_slice,
+            sagittal_slice,
+            coronal_slice,
+            rotation_sequence,
+            rotation_angles,
+        )
+
+        # Update all views
+        self.server.controller.view_update()
+
+    def update_mpr_window_level(self, **kwargs):
+        """Update MPR window/level when sliders change."""
+
+        if not getattr(self.server.state, "mpr_enabled", False):
+            return
+
+        active_volume_label = getattr(self.server.state, "active_volume_label", "")
+        if not active_volume_label:
+            return
+
+        # Find the active volume
+        active_volume = None
+        for volume in self.scene.volumes:
+            if volume.label == active_volume_label:
+                active_volume = volume
+                break
+
+        if not active_volume:
+            return
+
+        # Get current window/level values
+        window = getattr(self.server.state, "mpr_window", 400.0)
+        level = getattr(self.server.state, "mpr_level", 40.0)
+        current_frame = getattr(self.server.state, "frame", 0)
+
+        # Update window/level for MPR actors
+        active_volume.update_mpr_window_level(current_frame, window, level)
+
+        # Update all views
+        self.server.controller.view_update()
+
+    def update_mpr_preset(self, mpr_window_level_preset, **kwargs):
+        """Update MPR window/level when preset changes."""
+        from .window_level import presets
+
+        if mpr_window_level_preset in presets:
+            preset = presets[mpr_window_level_preset]
+            self.server.state.mpr_window = preset.window
+            self.server.state.mpr_level = preset.level
+
+            # Update the actual MPR views with new window/level
+            self.update_mpr_window_level()
+
+    def update_mpr_rotation(self, **kwargs):
+        """Update MPR views when rotation changes."""
+        if not getattr(self.server.state, "mpr_enabled", False):
+            return
+
+        active_volume_label = getattr(self.server.state, "active_volume_label", "")
+        if not active_volume_label:
+            return
+
+        # Find the active volume
+        active_volume = None
+        for volume in self.scene.volumes:
+            if volume.label == active_volume_label:
+                active_volume = volume
+                break
+
+        if not active_volume:
+            return
+
+        # Get current slice positions
+        axial_slice = getattr(self.server.state, "axial_slice", 0.5)
+        sagittal_slice = getattr(self.server.state, "sagittal_slice", 0.5)
+        coronal_slice = getattr(self.server.state, "coronal_slice", 0.5)
+        current_frame = getattr(self.server.state, "frame", 0)
+
+        # Get rotation data
+        rotation_sequence = getattr(self.server.state, "mpr_rotation_sequence", [])
+        rotation_angles = {}
+        for i in range(len(rotation_sequence)):
+            rotation_angles[i] = getattr(
+                self.server.state, f"mpr_rotation_angle_{i}", 0
+            )
+
+        # Update slice positions with rotation
+        active_volume.update_slice_positions(
+            current_frame,
+            axial_slice,
+            sagittal_slice,
+            coronal_slice,
+            rotation_sequence,
+            rotation_angles,
+        )
+
+        # Update all views
+        self.server.controller.view_update()
+
+    def add_mpr_rotation(self, axis):
+        """Add a new rotation to the MPR rotation sequence."""
+        import copy
+
+        current_sequence = copy.deepcopy(
+            getattr(self.server.state, "mpr_rotation_sequence", [])
+        )
+        current_sequence.append({"axis": axis, "angle": 0})
+        self.server.state.mpr_rotation_sequence = current_sequence
+        self.update_mpr_rotation_labels()
+
+    def remove_mpr_rotation(self, index):
+        """Remove a rotation at given index and all subsequent rotations."""
+        sequence = list(getattr(self.server.state, "mpr_rotation_sequence", []))
+        if 0 <= index < len(sequence):
+            sequence = sequence[:index]
+            self.server.state.mpr_rotation_sequence = sequence
+
+            # Reset angle states for all removed rotations
+            for i in range(index, 20):
+                setattr(self.server.state, f"mpr_rotation_angle_{i}", 0)
+
+            self.update_mpr_rotation_labels()
+
+    def reset_mpr_rotations(self):
+        """Reset all MPR rotations."""
+        self.server.state.mpr_rotation_sequence = []
+        for i in range(20):
+            setattr(self.server.state, f"mpr_rotation_angle_{i}", 0)
+        self.update_mpr_rotation_labels()
+
+    def update_mpr_rotation_labels(self):
+        """Update the rotation axis labels for display."""
+        rotation_sequence = getattr(self.server.state, "mpr_rotation_sequence", [])
+        for i, rotation in enumerate(rotation_sequence):
+            setattr(
+                self.server.state,
+                f"mpr_rotation_axis_{i}",
+                f"{rotation['axis']} ({i + 1})",
+            )
+        # Clear unused labels
+        for i in range(len(rotation_sequence), 20):
+            setattr(self.server.state, f"mpr_rotation_axis_{i}", f"Rotation {i + 1}")
+
+    @asynchronous.task
+    async def close_application(self):
+        """Close the application by stopping the server."""
+        await self.server.stop()

cardio/mesh.py

@@ -167,9 +167,9 @@ class Mesh(Object):
 
     def color_transfer_function(self):
         ctf = vtk.vtkColorTransferFunction()
-        ctf.AddRGBPoint(0.7, 0.0, 0.0, 1.0)
+        ctf.AddRGBPoint(self.ctf_min, 0.0, 0.0, 1.0)
         ctf.AddRGBPoint(1.0, 1.0, 0.0, 0.0)
-        ctf.AddRGBPoint(1.3, 1.0, 1.0, 0.0)
+        ctf.AddRGBPoint(self.ctf_max, 1.0, 1.0, 0.0)
         return ctf
 
     def setup_scalar_coloring(self, mapper):

cardio/object.py

@@ -28,7 +28,7 @@ class Object(pc.BaseModel):
     visible: bool = pc.Field(
         default=True, description="Whether object is initially visible"
     )
-    clipping_enabled: bool = pc.Field(default=False)
+    clipping_enabled: bool = pc.Field(default=True)
 
     @pc.field_validator("label")
     @classmethod
@@ -69,12 +69,7 @@ class Object(pc.BaseModel):
         if self.pattern is not None and self.file_paths is not None:
             logging.info("Both pattern and file_paths specified; using file_paths.")
 
-        # Validate all paths for traversal attacks and file existence
         for path in self.path_list:
-            if not path.resolve().is_relative_to(self.directory.resolve()):
-                raise ValueError(
-                    f"Path {path} would access files outside base directory"
-                )
             if not path.is_file():
                 raise ValueError(f"File does not exist: {path}")
 

cardio/piecewise_function.py

@@ -0,0 +1,29 @@
+# Third Party
+import pydantic as pc
+import vtk
+
+# Internal
+from .types import ScalarComponent
+
+
+class PiecewiseFunctionPoint(pc.BaseModel):
+    """A single point in a piecewise function."""
+
+    x: float = pc.Field(description="Scalar value")
+    y: ScalarComponent
+
+
+class PiecewiseFunctionConfig(pc.BaseModel):
+    """Configuration for a VTK piecewise function (opacity)."""
+
+    points: list[PiecewiseFunctionPoint] = pc.Field(
+        min_length=1, description="Points defining the piecewise function"
+    )
+
+    @property
+    def vtk_function(self) -> vtk.vtkPiecewiseFunction:
+        """Create VTK piecewise function from this configuration."""
+        otf = vtk.vtkPiecewiseFunction()
+        for point in self.points:
+            otf.AddPoint(point.x, point.y)
+        return otf