Heavy lag when displaying segmentations via Trame + TotalSegmentator

Support
2

Automatically-generated content using jumbojing/slicerClaw. Accuracy of the answer has not been verified and code has not been tested.

Solution

1. Merge Multiple NIfTI Files into Single SegmentationNode

import slicer
import logging
from pathlib import Path

def merge_nifti_files(mask_files, segmentation_name="TotalSegmentation"):
    """Merge multiple NIfTI files into a single SegmentationNode."""
    
    # Create single segmentation node
    seg_node = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLSegmentationNode')
    seg_node.SetName(segmentation_name)
    seg_node.CreateDefaultDisplayNodes()
    
    temp_nodes = []
    
    for mask_path in mask_files:
        if not Path(mask_path).exists():
            continue
        
        # Extract organ name
        organ_name = Path(mask_path).stem.replace('.nii', '')
        
        # Load as labelmap
        label_node = slicer.util.loadLabelVolume(mask_path, {'name': f"temp_{organ_name}"})
        temp_nodes.append(label_node)
        
        # Import to segmentation
        slicer.modules.segmentations.logic().ImportLabelmapToSegmentationNode(
            label_node, seg_node, organ_name
        )
        
        logging.info(f"Added segment: {organ_name}")
    
    # Cleanup temporary nodes
    for node in temp_nodes:
        slicer.mrmlScene.RemoveNode(node)
    
    return seg_node

2. Control CPU/GPU Rendering for Segmentations

def configure_segmentation_rendering(seg_node, use_gpu=False):
    """Configure segmentation rendering method."""
    
    # Get display node
    display_node = seg_node.GetDisplayNode()
    if not display_node:
        display_node = seg_node.CreateDefaultDisplayNodes()
    
    # Set representation (affects performance)
    if use_gpu:
        # GPU-based rendering (faster but requires GPU)
        display_node.SetRepresentation2D("Outline")
        display_node.SetRepresentation3D("Closed surface")
    else:
        # CPU-optimized rendering
        display_node.SetRepresentation2D("Outline")
        display_node.SetRepresentation3D("Closed surface")
        
        # Reduce quality for better performance
        display_node.SetOpacity3D(0.8)
        
        # Disable auto-update for performance
        seg_node.SetDisplayVisibility(False)
        # ... do processing ...
        seg_node.SetDisplayVisibility(True)
    
    return display_node

# Alternative: Use Binary Labelmap representation (CPU-friendly)
def use_labelmap_representation(seg_node):
    """Use binary labelmap representation (CPU-friendly)."""
    segmentation = seg_node.GetSegmentation()
    
    # Use binary labelmap representation instead of closed surface
    # This is more CPU-friendly
    segmentation.SetMasterRepresentationName("Binary labelmap")
    
    # Disable automatic surface creation
    segmentation.SetConversionParameter("Apply to all representations", "0")

3. Optimized Loading in Trame-Slicer

def load_segments_optimized(self, mask_files):
    """Load and merge all segments at once."""
    
    # Merge all NIfTI files into one segmentation node
    merged_seg = merge_nifti_files(mask_files, "TotalSegmentation")
    
    # Configure for CPU rendering
    configure_segmentation_rendering(merged_seg, use_gpu=False)
    
    # Enable surface representation
    seg_wrapper = Segmentation(
        segmentation_node=merged_seg,
        volume_node=self.volume_node,
        editor_logic=self.slicer_app.segmentation_editor.editor_logic
    )
    
    # For CPU optimization, reduce resolution
    display_node = merged_seg.GetDisplayNode()
    if display_node:
        display_node.SetOpacity3D(0.7)
        # Reduce smooth factor for faster rendering
        display_node.SetSurfaceSmoothingFactor(0.5)
    
    return [merged_seg]  # Return single node instead of list

Key Benefits:

  • Reduces display nodes from N to 1
  • Less memory usage (single renderer)
  • Better performance (especially for CPU rendering)
  • Easier management of segment visibility and colors

Performance Tips:

  1. Use Binary labelmap representation for CPU
  2. Reduce SurfaceSmoothingFactor for faster rendering
  3. Set appropriate Opacity3D (0.5-0.8)
  4. Disable auto-updates during batch operations
  5. Use merged segmentation instead of multiple nodes

From GitHub - jumbojing/slicerClaw: A revolutionary, lightning-fast AI assistant natively integrated into 3D Slicer. ยท GitHub

Confidently incorrect posts appearing on forum