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

cardio/object.py

@@ -3,7 +3,6 @@ import functools
 import logging
 import pathlib as pl
 import re
-import string
 
 # Third Party
 import pydantic as pc
@@ -22,13 +21,15 @@ class Object(pc.BaseModel):
     pattern: str | None = pc.Field(
         default=None, description="Filename pattern with ${frame} placeholder"
     )
+    frame_start: pc.NonNegativeInt = 0
+    frame_interval: pc.PositiveInt = 1
     file_paths: list[str] | None = pc.Field(
         default=None, description="Static list of file paths relative to directory"
     )
     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
@@ -54,10 +55,10 @@ class Object(pc.BaseModel):
         if not isinstance(v, str):
             raise ValueError("pattern must be a string")
 
-        if not re.match(r"^[a-zA-Z0-9_\-.${}]+$", v):
+        if not re.match(r"^[a-zA-Z0-9_\-.${}:]+$", v):
             raise ValueError("Pattern contains unsafe characters")
 
-        if "${frame}" not in v and "$frame" not in v:
+        if "frame" not in v:
             raise ValueError("Pattern must contain $frame placeholder")
 
         return v
@@ -69,12 +70,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}")
 
@@ -83,8 +79,8 @@ class Object(pc.BaseModel):
     def path_for_frame(self, frame: int) -> pl.Path:
         if self.pattern is None:
             raise ValueError("Cannot use path_for_frame with static file_paths")
-        template = string.Template(self.pattern)
-        filename = template.safe_substitute(frame=frame)
+        filename = self.pattern.format(frame=frame)
+        print(filename)
         return self.directory / filename
 
     @functools.cached_property
@@ -94,13 +90,13 @@ class Object(pc.BaseModel):
             return [self.directory / path for path in self.file_paths]
 
         paths = []
-        frame = 0
+        frame = self.frame_start
         while True:
             path = self.path_for_frame(frame)
             if not path.is_file():
                 break
             paths.append(path)
-            frame += 1
+            frame += self.frame_interval
         return paths
 
     @property

cardio/orientation.py

@@ -0,0 +1,215 @@
+# System
+from enum import Enum
+
+# Third Party
+import numpy as np
+import itk
+
+
+# DICOM LPS canonical orientation vector mappings
+class EulerAxis(Enum):
+    X = "X"
+    Y = "Y"
+    Z = "Z"
+
+
+class AngleUnits(Enum):
+    DEGREES = "degrees"
+    RADIANS = "radians"
+
+
+AXCODE_VECTORS = {
+    "L": (1, 0, 0),
+    "R": (-1, 0, 0),
+    "P": (0, 1, 0),
+    "A": (0, -1, 0),
+    "S": (0, 0, 1),
+    "I": (0, 0, -1),
+}
+
+
+def is_valid_axcode(axcode: str) -> bool:
+    """Validate medical imaging axcode string.
+
+    Valid axcode must have exactly 3 uppercase characters with:
+    - One of L or R (Left/Right)
+    - One of A or P (Anterior/Posterior)
+    - One of S or I (Superior/Inferior)
+    - No repeated characters
+    """
+    if len(axcode) != 3:
+        return False
+
+    if len(set(axcode)) != 3:
+        return False
+
+    has_lr = any(c in axcode for c in "LR")
+    has_ap = any(c in axcode for c in "AP")
+    has_si = any(c in axcode for c in "SI")
+
+    valid_chars = set("LRAPSI")
+    has_only_valid = all(c in valid_chars for c in axcode)
+
+    return has_lr and has_ap and has_si and has_only_valid
+
+
+def is_righthanded_axcode(axcode: str) -> bool:
+    """Check if axcode represents a right-handed coordinate system.
+
+    Right-handed when cross product of first two axes equals third axis.
+    Uses DICOM LPS canonical orientation.
+    """
+    if not is_valid_axcode(axcode):
+        raise ValueError(f"Invalid axcode: {axcode}")
+
+    v1 = np.array(AXCODE_VECTORS[axcode[0]])
+    v2 = np.array(AXCODE_VECTORS[axcode[1]])
+    v3 = np.array(AXCODE_VECTORS[axcode[2]])
+
+    cross = np.cross(v1, v2)
+
+    return np.array_equal(cross, v3)
+
+
+def axcode_transform_matrix(from_axcode: str, to_axcode: str) -> np.ndarray:
+    """Calculate transformation matrix between two coordinate spaces.
+
+    Returns matrix T such that: new_coords = T @ old_coords
+    Uses DICOM LPS canonical orientation for vector mappings.
+    """
+    if not is_valid_axcode(from_axcode):
+        raise ValueError(f"Invalid source axcode: {from_axcode}")
+    if not is_valid_axcode(to_axcode):
+        raise ValueError(f"Invalid target axcode: {to_axcode}")
+
+    # Create basis matrices (each column is a basis vector)
+    from_basis = np.array([AXCODE_VECTORS[c] for c in from_axcode]).T
+    to_basis = np.array([AXCODE_VECTORS[c] for c in to_axcode]).T
+
+    # Transformation matrix: T = to_basis @ from_basis^(-1)
+    return to_basis @ np.linalg.inv(from_basis)
+
+
+def euler_angle_to_rotation_matrix(
+    axis: EulerAxis, angle: float, units: AngleUnits = AngleUnits.DEGREES
+) -> np.ndarray:
+    """Create rotation matrix for given axis and angle.
+
+    Args:
+        axis: Rotation axis (X, Y, or Z)
+        angle: Rotation angle
+        units: Angle units (degrees or radians)
+
+    Returns:
+        3x3 rotation matrix
+    """
+    match units:
+        case AngleUnits.DEGREES:
+            angle_rad = np.radians(angle)
+        case AngleUnits.RADIANS:
+            angle_rad = angle
+
+    cos_a, sin_a = np.cos(angle_rad), np.sin(angle_rad)
+
+    match axis:
+        case EulerAxis.X:
+            return np.array([[1, 0, 0], [0, cos_a, -sin_a], [0, sin_a, cos_a]])
+        case EulerAxis.Y:
+            return np.array([[cos_a, 0, sin_a], [0, 1, 0], [-sin_a, 0, cos_a]])
+        case EulerAxis.Z:
+            return np.array([[cos_a, -sin_a, 0], [sin_a, cos_a, 0], [0, 0, 1]])
+
+
+def is_axis_aligned(image) -> bool:
+    """Check if ITK image orientation is axis-aligned.
+
+    An axis-aligned image has a direction matrix where:
+    - Each column has exactly one non-zero entry
+    - Non-zero entries are ±1
+
+    Args:
+        image: ITK image object
+
+    Returns:
+        True if image is axis-aligned, False otherwise
+    """
+    direction = itk.array_from_matrix(image.GetDirection())
+
+    # Check each column has exactly one non-zero entry
+    for col in range(direction.shape[1]):
+        non_zero_count = np.count_nonzero(direction[:, col])
+        if non_zero_count != 1:
+            return False
+
+    # Check non-zero entries are ±1
+    non_zero_values = direction[direction != 0]
+    if not np.allclose(np.abs(non_zero_values), 1.0):
+        return False
+
+    return True
+
+
+def reset_direction(image):
+    """Reset image direction to identity matrix, preserving physical extent."""
+    assert is_axis_aligned(image), "Input image must be axis-aligned"
+
+    origin = np.array(image.GetOrigin())
+    spacing = np.array(image.GetSpacing())
+    direction = itk.array_from_matrix(image.GetDirection())
+    size = np.array(image.GetLargestPossibleRegion().GetSize())
+    pixel_array = itk.array_from_image(image)
+
+    permutation = []
+    flips = []
+
+    for col in range(3):
+        row = np.nonzero(direction[:, col])[0][0]
+        permutation.append(row)
+        flips.append(direction[row, col] < 0)
+
+    array_permutation = [2 - p for p in reversed(permutation)]
+    pixel_array = np.transpose(pixel_array, array_permutation)
+
+    for i, should_flip in enumerate(reversed(flips)):
+        if should_flip:
+            pixel_array = np.flip(pixel_array, axis=i)
+
+    new_spacing = spacing[permutation]
+
+    adjusted_origin = origin.copy()
+    for i, should_flip in enumerate(flips):
+        if should_flip:
+            image_axis = permutation[i]
+            extent_vector = (
+                direction[:, image_axis] * (size[image_axis] - 1) * spacing[image_axis]
+            )
+            adjusted_origin += extent_vector
+
+    new_origin = adjusted_origin[permutation]
+
+    output = itk.image_from_array(pixel_array)
+    output.SetOrigin(new_origin)
+    output.SetSpacing(new_spacing)
+
+    return output
+
+
+def create_vtk_reslice_matrix(transform_3x3, origin):
+    """Create 4x4 VTK reslice matrix from 3x3 transform and origin.
+
+    Args:
+        transform_3x3: 3x3 coordinate transformation matrix
+        origin: 3-element origin position
+
+    Returns:
+        vtk.vtkMatrix4x4 for use with VTK reslice operations
+    """
+    import vtk
+
+    matrix = vtk.vtkMatrix4x4()
+    for i in range(3):
+        for j in range(3):
+            matrix.SetElement(i, j, transform_3x3[i, j])
+        matrix.SetElement(i, 3, origin[i])
+    matrix.SetElement(3, 3, 1.0)
+    return matrix

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

cardio/scene.py

@@ -1,54 +1,52 @@
 # System
 import logging
 import pathlib as pl
-
-# Type adapters for list types to improve CLI integration
-from typing import Annotated
+import typing as ty
 
 # Third Party
 import numpy as np
 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 .utils import AngleUnit
 from .volume import Volume
 
-MeshListAdapter = TypeAdapter(list[Mesh])
-VolumeListAdapter = TypeAdapter(list[Volume])
-SegmentationListAdapter = TypeAdapter(list[Segmentation])
+MeshListAdapter = pc.TypeAdapter(list[Mesh])
+VolumeListAdapter = pc.TypeAdapter(list[Volume])
+SegmentationListAdapter = pc.TypeAdapter(list[Segmentation])
 
 # Create annotated types for better CLI integration
-MeshList = Annotated[
+MeshList = ty.Annotated[
     list[Mesh],
-    Field(
+    pc.Field(
         description='List of mesh objects. CLI usage: --meshes \'[{"label":"mesh1","directory":"./data/mesh1"}]\''
     ),
 ]
-VolumeList = Annotated[
+VolumeList = ty.Annotated[
     list[Volume],
-    Field(
+    pc.Field(
         description='Volume objects. CLI: --volumes \'[{"label":"vol1","directory":"./data/vol1"}]\''
     ),
 ]
-SegmentationList = Annotated[
+SegmentationList = ty.Annotated[
     list[Segmentation],
-    Field(
+    pc.Field(
         description='Segmentation objects. CLI: --segmentations \'[{"label":"seg1","directory":"./data/seg1"}]\''
     ),
 ]
 
 
 class Background(pc.BaseModel):
-    light: RGBColor = Field(
+    light: RGBColor = pc.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(
+    dark: RGBColor = pc.Field(
         default=(0.0, 0.0, 0.0),
         description="Background color in dark mode.  CLI usage: --background.dark '[0.1,0.1,0.2]'",
     )
@@ -92,33 +90,83 @@ class Scene(ps.BaseSettings):
 
     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")
+    serialization_directory: pl.Path = pc.Field(
+        default=pl.Path("./data"),
+        description="Base directory for all serialized data (screenshots, exports, etc.)",
+    )
+    timestamp_format: str = pc.Field(
+        default="%Y-%m-%d-%H-%M-%S",
+        description="Timestamp format for serialized data subdirectories",
+    )
     rotation_factor: float = 3.0
-    background: Background = Field(
+    background: Background = pc.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)
+    meshes: MeshList = pc.Field(default_factory=list)
+    volumes: VolumeList = pc.Field(default_factory=list)
+    segmentations: SegmentationList = pc.Field(default_factory=list)
+    mpr_enabled: bool = pc.Field(
+        default=False,
+        description="Enable multi-planar reconstruction (MPR) mode with quad-view layout",
+    )
+    active_volume_label: str = pc.Field(
+        default="",
+        description="Label of the volume to use for multi-planar reconstruction",
+    )
+    axial_slice: float = pc.Field(
+        default=0.0,
+        description="Axial slice position in physical coordinates (LAS Z axis)",
+    )
+    sagittal_slice: float = pc.Field(
+        default=0.0,
+        description="Sagittal slice position in physical coordinates (LAS X axis)",
+    )
+    coronal_slice: float = pc.Field(
+        default=0.0,
+        description="Coronal slice position in physical coordinates (LAS Y axis)",
+    )
+    mpr_window: float = pc.Field(
+        default=800.0, description="Window width for MPR image display"
+    )
+    mpr_level: float = pc.Field(
+        default=200.0, description="Window level for MPR image display"
+    )
+    mpr_window_level_preset: int = pc.Field(
+        default=7, description="Window/level preset key for MPR views"
+    )
+    mpr_rotation_sequence: list = pc.Field(
+        default_factory=list,
+        description="Dynamic rotation sequence for MPR views - list of rotation steps",
+    )
+    max_mpr_rotations: int = pc.Field(
+        default=20,
+        description="Maximum number of MPR rotations supported",
+    )
+    angle_units: AngleUnit = pc.Field(
+        default=AngleUnit.DEGREES,
+        description="Units for angle measurements in rotation serialization",
+    )
+    coordinate_system: str = pc.Field(
+        default="LAS", description="Coordinate system orientation (e.g., LAS, RAS, LPS)"
+    )
 
     # Field validators for JSON string inputs
-    @field_validator("meshes", mode="before")
+    @pc.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")
+    @pc.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")
+    @pc.field_validator("segmentations", mode="before")
     @classmethod
     def validate_segmentations(cls, v):
         if isinstance(v, str):
@@ -126,14 +174,19 @@ class Scene(ps.BaseSettings):
         return v
 
     # VTK objects as private attributes
-    _renderer: vtk.vtkRenderer = PrivateAttr(default_factory=vtk.vtkRenderer)
-    _renderWindow: vtk.vtkRenderWindow = PrivateAttr(
+    _renderer: vtk.vtkRenderer = pc.PrivateAttr(default_factory=vtk.vtkRenderer)
+    _renderWindow: vtk.vtkRenderWindow = pc.PrivateAttr(
         default_factory=vtk.vtkRenderWindow
     )
-    _renderWindowInteractor: vtk.vtkRenderWindowInteractor = PrivateAttr(
+    _renderWindowInteractor: vtk.vtkRenderWindowInteractor = pc.PrivateAttr(
         default_factory=vtk.vtkRenderWindowInteractor
     )
 
+    # MPR render windows
+    _axial_renderWindow: vtk.vtkRenderWindow = pc.PrivateAttr(default=None)
+    _coronal_renderWindow: vtk.vtkRenderWindow = pc.PrivateAttr(default=None)
+    _sagittal_renderWindow: vtk.vtkRenderWindow = pc.PrivateAttr(default=None)
+
     @property
     def renderer(self) -> vtk.vtkRenderer:
         return self._renderer
@@ -146,8 +199,26 @@ class Scene(ps.BaseSettings):
     def renderWindowInteractor(self) -> vtk.vtkRenderWindowInteractor:
         return self._renderWindowInteractor
 
-    @model_validator(mode="after")
+    @property
+    def axial_renderWindow(self) -> vtk.vtkRenderWindow:
+        return self._axial_renderWindow
+
+    @property
+    def coronal_renderWindow(self) -> vtk.vtkRenderWindow:
+        return self._coronal_renderWindow
+
+    @property
+    def sagittal_renderWindow(self) -> vtk.vtkRenderWindow:
+        return self._sagittal_renderWindow
+
+    @pc.model_validator(mode="after")
     def setup_scene(self):
+        # Validate unique labels
+        self._validate_unique_labels()
+
+        # Validate active volume label
+        self._validate_active_volume_label()
+
         # Configure VTK objects
         self._renderer.SetBackground(
             *self.background.light,
@@ -173,6 +244,54 @@ class Scene(ps.BaseSettings):
 
         return self
 
+    def _validate_unique_labels(self):
+        mesh_labels = [mesh.label for mesh in self.meshes]
+        volume_labels = [volume.label for volume in self.volumes]
+        segmentation_labels = [seg.label for seg in self.segmentations]
+
+        if len(mesh_labels) != len(set(mesh_labels)):
+            duplicates = [
+                label for label in set(mesh_labels) if mesh_labels.count(label) > 1
+            ]
+            raise ValueError(f"Duplicate mesh labels found: {duplicates}")
+
+        if len(volume_labels) != len(set(volume_labels)):
+            duplicates = [
+                label for label in set(volume_labels) if volume_labels.count(label) > 1
+            ]
+            raise ValueError(f"Duplicate volume labels found: {duplicates}")
+
+        if len(segmentation_labels) != len(set(segmentation_labels)):
+            duplicates = [
+                label
+                for label in set(segmentation_labels)
+                if segmentation_labels.count(label) > 1
+            ]
+            raise ValueError(f"Duplicate segmentation labels found: {duplicates}")
+
+    def _validate_active_volume_label(self):
+        """Validate that active_volume_label refers to an existing volume."""
+        if self.active_volume_label and self.volumes:
+            volume_labels = [volume.label for volume in self.volumes]
+            if self.active_volume_label not in volume_labels:
+                raise ValueError(
+                    f"Active volume label '{self.active_volume_label}' not found in available volumes: {volume_labels}"
+                )
+        elif self.active_volume_label and not self.volumes:
+            raise ValueError(
+                "Active volume label specified but no volumes are available"
+            )
+
+    @property
+    def screenshot_directory(self) -> pl.Path:
+        """Computed property that returns the screenshots subdirectory."""
+        return self.serialization_directory / "screenshots"
+
+    @property
+    def rotations_directory(self) -> pl.Path:
+        """Computed property that returns the rotations subdirectory."""
+        return self.serialization_directory / "rotations"
+
     @property
     def nframes(self) -> int:
         ns = []
@@ -209,6 +328,49 @@ class Scene(ps.BaseSettings):
         self.show_frame(self.current_frame)
         self.renderer.ResetCamera()
 
+        # Set default camera elevation to -90 degrees
+        camera = self.renderer.GetActiveCamera()
+        camera.Elevation(-90)
+
+    def setup_mpr_render_windows(self):
+        """Initialize MPR render windows when MPR mode is enabled."""
+        if self._axial_renderWindow is None:
+            # Create axial render window
+            self._axial_renderWindow = vtk.vtkRenderWindow()
+            axial_renderer = vtk.vtkRenderer()
+            axial_renderer.SetBackground(0.0, 0.0, 0.0)  # Black background
+            self._axial_renderWindow.AddRenderer(axial_renderer)
+            self._axial_renderWindow.SetOffScreenRendering(True)
+
+            # Create and set interactor for axial
+            axial_interactor = vtk.vtkRenderWindowInteractor()
+            axial_interactor.SetInteractorStyle(vtk.vtkInteractorStyle())
+            self._axial_renderWindow.SetInteractor(axial_interactor)
+
+            # Create coronal render window
+            self._coronal_renderWindow = vtk.vtkRenderWindow()
+            coronal_renderer = vtk.vtkRenderer()
+            coronal_renderer.SetBackground(0.0, 0.0, 0.0)  # Black background
+            self._coronal_renderWindow.AddRenderer(coronal_renderer)
+            self._coronal_renderWindow.SetOffScreenRendering(True)
+
+            # Create and set interactor for coronal
+            coronal_interactor = vtk.vtkRenderWindowInteractor()
+            coronal_interactor.SetInteractorStyle(vtk.vtkInteractorStyle())
+            self._coronal_renderWindow.SetInteractor(coronal_interactor)
+
+            # Create sagittal render window
+            self._sagittal_renderWindow = vtk.vtkRenderWindow()
+            sagittal_renderer = vtk.vtkRenderer()
+            sagittal_renderer.SetBackground(0.0, 0.0, 0.0)  # Black background
+            self._sagittal_renderWindow.AddRenderer(sagittal_renderer)
+            self._sagittal_renderWindow.SetOffScreenRendering(True)
+
+            # Create and set interactor for sagittal
+            sagittal_interactor = vtk.vtkRenderWindowInteractor()
+            sagittal_interactor.SetInteractorStyle(vtk.vtkInteractorStyle())
+            self._sagittal_renderWindow.SetInteractor(sagittal_interactor)
+
     def hide_all_frames(self):
         for a in self.renderer.GetActors():
             a.SetVisibility(False)

cardio/segmentation.py

@@ -8,9 +8,11 @@ import pydantic as pc
 import vtk
 
 # Internal
+from .orientation import (
+    reset_direction,
+)
 from .object import Object
 from .property_config import vtkPropertyConfig
-from .utils import InterpolatorType, reset_direction
 
 
 class Segmentation(Object):
@@ -35,7 +37,7 @@ class Segmentation(Object):
 
             # Read and process segmentation image
             image = itk.imread(path)
-            image = reset_direction(image, InterpolatorType.NEAREST)
+            image = reset_direction(image)
             vtk_image = itk.vtk_image_from_image(image)
 
             # Create SurfaceNets3D filter

cardio/transfer_function_pair.py

@@ -0,0 +1,25 @@
+# Third Party
+import pydantic as pc
+import vtk
+
+# Internal
+from .color_transfer_function import ColorTransferFunctionConfig
+from .piecewise_function import PiecewiseFunctionConfig
+
+
+class TransferFunctionPairConfig(pc.BaseModel):
+    """Configuration for a pair of opacity and color transfer functions."""
+
+    opacity: PiecewiseFunctionConfig = pc.Field(
+        description="Opacity transfer function configuration"
+    )
+    color: ColorTransferFunctionConfig = pc.Field(
+        description="Color transfer function configuration"
+    )
+
+    @property
+    def vtk_functions(
+        self,
+    ) -> tuple[vtk.vtkPiecewiseFunction, vtk.vtkColorTransferFunction]:
+        """Create VTK transfer functions from this pair configuration."""
+        return self.opacity.vtk_function, self.color.vtk_function