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

cardio/logic.py

@@ -12,9 +12,49 @@ 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
+        ]
+
+        # Initialize angle units items for dropdown
+        self.server.state.angle_units_items = [
+            {"text": "Degrees", "value": "degrees"},
+            {"text": "Radians", "value": "radians"},
+        ]
+
+        # Initialize slice bounds (will be updated when active volume changes)
+        self.server.state.axial_slice_bounds = [0.0, 100.0]
+        self.server.state.sagittal_slice_bounds = [0.0, 100.0]
+        self.server.state.coronal_slice_bounds = [0.0, 100.0]
+
         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)
+        self.server.state.change("angle_units")(self.sync_angle_units)
+
+        # Add handlers for individual rotation angles and visibility
+        for i in range(self.scene.max_mpr_rotations):
+            self.server.state.change(f"mpr_rotation_angle_{i}")(
+                self.update_mpr_rotation
+            )
+            self.server.state.change(f"mpr_rotation_visible_{i}")(
+                self.update_mpr_rotation
+            )
 
         # Initialize visibility state variables
         for m in self.scene.meshes:
@@ -97,7 +137,54 @@ class Logic:
         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.save_rotation_angles = self.save_rotation_angles
         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
+        self.server.state.angle_units = self.scene.angle_units.value
+
+        # Initialize MPR presets data
+        try:
+            from .window_level import presets
+
+            self.server.state.mpr_presets = [
+                {"text": "Select W/L...", "value": None}
+            ] + [{"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
+        for i in range(self.scene.max_mpr_rotations):
+            setattr(self.server.state, f"mpr_rotation_angle_{i}", 0)
+            setattr(self.server.state, f"mpr_rotation_axis_{i}", f"Rotation {i + 1}")
+            setattr(self.server.state, f"mpr_rotation_visible_{i}", True)
+
+        # 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 +209,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 +333,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:
@@ -261,7 +435,7 @@ class Logic:
 
     @asynchronous.task
     async def screenshot(self):
-        dr = dt.datetime.now().strftime(self.scene.screenshot_subdirectory_format)
+        dr = dt.datetime.now().strftime(self.scene.timestamp_format)
         dr = self.scene.screenshot_directory / dr
         dr.mkdir(parents=True, exist_ok=True)
 
@@ -286,6 +460,65 @@ class Logic:
                         1 / self.server.state.bpm * 60 / self.scene.nframes
                     )
 
+    @asynchronous.task
+    async def save_rotation_angles(self):
+        """Save current rotation angles to a TOML file."""
+        import tomlkit as tk
+
+        # Get current timestamp
+        timestamp = dt.datetime.now()
+        timestamp_str = timestamp.strftime(self.scene.timestamp_format)
+        iso_timestamp = timestamp.isoformat()
+
+        # Get active volume label
+        active_volume_label = getattr(self.server.state, "active_volume_label", "")
+        if not active_volume_label:
+            print("Warning: No active volume selected for rotation saving")
+            return
+
+        # Create directory structure
+        save_dir = self.scene.rotations_directory / active_volume_label
+        save_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create TOML structure
+        doc = tk.document()
+
+        # Metadata section
+        metadata = tk.table()
+        metadata["coordinate_system"] = self.scene.coordinate_system
+        metadata["units"] = self.scene.angle_units.value
+        metadata["timestamp"] = iso_timestamp
+        metadata["volume_label"] = active_volume_label
+        doc["metadata"] = metadata
+
+        # Slice positions section
+        slice_positions = tk.table()
+        slice_positions["axial"] = getattr(self.server.state, "axial_slice", 0.5)
+        slice_positions["sagittal"] = getattr(self.server.state, "sagittal_slice", 0.5)
+        slice_positions["coronal"] = getattr(self.server.state, "coronal_slice", 0.5)
+        doc["slice_positions"] = slice_positions
+
+        # Rotations section (array of tables)
+        rotation_sequence = getattr(self.server.state, "mpr_rotation_sequence", [])
+        rotations_array = tk.aot()
+
+        for i, rotation_def in enumerate(rotation_sequence):
+            rotation = tk.table()
+            rotation["axis"] = rotation_def["axis"]
+            angle = getattr(self.server.state, f"mpr_rotation_angle_{i}", 0)
+            rotation["angle"] = float(angle)
+            rotation["visible"] = getattr(
+                self.server.state, f"mpr_rotation_visible_{i}", True
+            )
+            rotations_array.append(rotation)
+
+        doc["rotations"] = rotations_array
+
+        # Save to file
+        output_path = save_dir / f"{timestamp_str}.toml"
+        with open(output_path, "w") as f:
+            f.write(tk.dumps(doc))
+
     def reset_all(self):
         self.server.state.frame = 0
         self.server.state.playing = False
@@ -295,9 +528,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,
@@ -309,6 +542,16 @@ class Logic:
             )
         self.server.controller.view_update()
 
+    def sync_angle_units(self, angle_units, **kwargs):
+        """Sync angle units selection - updates the scene configuration."""
+        from .utils import AngleUnit
+
+        # Update the scene's angle_units field based on UI selection
+        if angle_units == "degrees":
+            self.scene.angle_units = AngleUnit.DEGREES
+        elif angle_units == "radians":
+            self.scene.angle_units = AngleUnit.RADIANS
+
     def _initialize_clipping_state(self):
         """Initialize clipping state variables for all objects."""
         # Initialize mesh clipping state
@@ -363,3 +606,303 @@ 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
+
+        # Update slice bounds based on active volume
+        try:
+            bounds = active_volume.get_physical_bounds()
+            self.server.state.axial_slice_bounds = [bounds[4], bounds[5]]  # Z bounds
+            self.server.state.sagittal_slice_bounds = [bounds[0], bounds[1]]  # X bounds
+            self.server.state.coronal_slice_bounds = [bounds[2], bounds[3]]  # Y bounds
+
+            # Initialize slice positions to volume center if they are currently 0.0 (scene defaults)
+            if self.server.state.axial_slice == 0.0:
+                self.server.state.axial_slice = (bounds[4] + bounds[5]) / 2  # Z center
+            if self.server.state.sagittal_slice == 0.0:
+                self.server.state.sagittal_slice = (
+                    bounds[0] + bounds[1]
+                ) / 2  # X center
+            if self.server.state.coronal_slice == 0.0:
+                self.server.state.coronal_slice = (
+                    bounds[2] + bounds[3]
+                ) / 2  # Y center
+        except (RuntimeError, IndexError) as e:
+            print(f"Error: Cannot get bounds for volume '{active_volume_label}': {e}")
+            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)
+
+        # Check if this change is from manual adjustment (not from preset)
+        # by checking if we're not in the middle of a preset update
+        if not getattr(self, "_updating_from_preset", False):
+            # Reset preset selection when manually adjusting window/level
+            current_preset = getattr(self.server.state, "mpr_window_level_preset", None)
+            if current_preset is not None:
+                self.server.state.mpr_window_level_preset = None
+
+        # 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
+
+        # Handle None value (Select W/L... option) - do nothing
+        if mpr_window_level_preset is None:
+            return
+
+        if mpr_window_level_preset in presets:
+            preset = presets[mpr_window_level_preset]
+
+            # Set flag to indicate we're updating from preset
+            self._updating_from_preset = True
+            try:
+                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()
+            finally:
+                # Always clear the flag
+                self._updating_from_preset = False
+
+    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 - include all visible rotations
+        rotation_sequence = getattr(self.server.state, "mpr_rotation_sequence", [])
+        rotation_angles = {}
+
+        # Include all visible rotations regardless of position
+        for i in range(len(rotation_sequence)):
+            is_visible = getattr(self.server.state, f"mpr_rotation_visible_{i}", True)
+            if is_visible:
+                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, self.scene.max_mpr_rotations):
+                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(self.scene.max_mpr_rotations):
+            setattr(self.server.state, f"mpr_rotation_angle_{i}", 0)
+            setattr(self.server.state, f"mpr_rotation_visible_{i}", True)
+        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), self.scene.max_mpr_rotations):
+            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

@@ -3,7 +3,6 @@ import enum
 import logging
 
 # Third Party
-import numpy as np
 import pydantic as pc
 import vtk
 
@@ -167,9 +166,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):