Label Image Operations

def label_statistics_image_filter(input, label_image):
    """
    Compute statistics for each label region.
    
    Parameters:
    - input: itk.Image - Intensity image
    - label_image: itk.Image - Label image
    
    Returns:
    Filter with computed statistics
    """

class LabelStatisticsImageFilter:
    """
    Compute intensity statistics for labeled regions.
    
    Template parameters:
    - input_image_type: Input intensity image type
    - label_image_type: Label image type
    """
    
    def SetInput(self, image):
        """Set the intensity image."""
    
    def SetLabelInput(self, label_image):
        """Set the label image."""
    
    def Update(self):
        """Compute statistics."""
    
    def GetNumberOfLabels(self):
        """Get number of labels found."""
    
    def GetMean(self, label):
        """Get mean intensity for label."""
    
    def GetSigma(self, label):
        """Get standard deviation for label."""
    
    def GetMinimum(self, label):
        """Get minimum intensity for label."""
    
    def GetMaximum(self, label):
        """Get maximum intensity for label."""
    
    def GetSum(self, label):
        """Get sum of intensities for label."""
    
    def GetCount(self, label):
        """Get number of pixels for label."""
    
    def GetRegion(self, label):
        """Get bounding box region for label."""

def relabel_component_image_filter(input, minimum_object_size=0, sort_by_object_size=True):
    """
    Relabel connected components, optionally by size.
    
    Parameters:
    - input: itk.Image - Label image
    - minimum_object_size: int - Remove objects smaller than this
    - sort_by_object_size: bool - Sort labels by size (largest=1)
    
    Returns:
    itk.Image - Relabeled image
    """

class RelabelComponentImageFilter:
    """Relabel components, optionally sorted by size."""
    
    def SetMinimumObjectSize(self, size):
        """Set minimum object size."""
    
    def SetSortByObjectSize(self, sort):
        """Enable/disable sorting by size."""
    
    def GetNumberOfObjects(self):
        """Get the number of objects after filtering."""
    
    def GetSizeOfObjectsInPixels(self):
        """Get sizes of all objects."""

def change_label_image_filter(input, change_map):
    """
    Change specific label values.
    
    Parameters:
    - input: itk.Image - Label image
    - change_map: dict - Mapping from old to new labels
    
    Returns:
    itk.Image - Relabeled image
    """

class ChangeLabelImageFilter:
    """Change specific label values."""
    
    def SetChangeMap(self, old_label, new_label):
        """Map old_label to new_label."""

class LabelMap:
    """
    Efficient label map data structure.
    
    Template parameter:
    - label_object_type: Type of label object
    """
    
    def GetNumberOfLabelObjects(self):
        """Get number of label objects."""
    
    def GetLabelObject(self, label):
        """Get label object by label value."""
    
    def GetNthLabelObject(self, n):
        """Get nth label object."""

class BinaryImageToLabelMapFilter:
    """Convert binary image to label map."""

class LabelImageToLabelMapFilter:
    """Convert label image to label map."""

class LabelMapToLabelImageFilter:
    """Convert label map back to label image."""

class ShapeLabelMapFilter:
    """
    Compute shape attributes for label objects.
    
    Attributes computed:
    - Size (number of pixels)
    - Physical size
    - Centroid
    - Bounding box
    - Perimeter
    - Roundness
    - Elongation
    - And more...
    """

class StatisticsLabelMapFilter:
    """Compute intensity statistics for label objects."""

class LabelMapMaskImageFilter:
    """Mask image using label map."""

class LabelMapOverlayImageFilter:
    """Overlay label map on image with colors."""

def connected_component_image_filter(input, fully_connected=False):
    """
    Label connected components in binary image.
    
    Parameters:
    - input: itk.Image - Binary image
    - fully_connected: bool - Use full connectivity
    
    Returns:
    itk.Image - Labeled image
    """

class ConnectedComponentImageFilter:
    """Label connected components."""
    
    def SetFullyConnected(self, fully_connected):
        """Set connectivity (4 vs 8 in 2D, 6 vs 26 in 3D)."""

class ScalarConnectedComponentImageFilter:
    """Label components in scalar image."""

class VectorConnectedComponentImageFilter:
    """Label components in vector image."""

import itk

# Load intensity and label images
intensity = itk.imread('intensity.png', itk.F)
labels = itk.imread('labels.png', itk.UL)

# Compute statistics
IntensityType = itk.Image[itk.F, 2]
LabelType = itk.Image[itk.UL, 2]
stats = itk.LabelStatisticsImageFilter[IntensityType, LabelType].New()
stats.SetInput(intensity)
stats.SetLabelInput(labels)
stats.Update()

# Get statistics for each label
num_labels = stats.GetNumberOfLabels()
for i in range(num_labels):
    label = stats.GetNthLabel(i)
    mean = stats.GetMean(label)
    sigma = stats.GetSigma(label)
    count = stats.GetCount(label)
    print(f"Label {label}: mean={mean:.2f}, std={sigma:.2f}, pixels={count}")

import itk

# Load label image
labels = itk.imread('labels.png', itk.UL)

# Relabel components by size (largest=1)
relabeled = itk.relabel_component_image_filter(
    labels,
    minimum_object_size=100,  # Remove small objects
    sort_by_object_size=True   # Sort by size
)

itk.imwrite(relabeled, 'relabeled.png')

import itk

# Load binary image
binary = itk.imread('binary.png', itk.UC)

# Label connected components
labeled = itk.connected_component_image_filter(binary, fully_connected=False)

# Relabel by size
sorted_labels = itk.relabel_component_image_filter(labeled, sort_by_object_size=True)

itk.imwrite(sorted_labels, 'components.png')

import itk

# Convert binary image to label map
binary = itk.imread('binary.png', itk.UC)

BinaryType = itk.Image[itk.UC, 2]
converter = itk.BinaryImageToLabelMapFilter[BinaryType].New()
converter.SetInput(binary)
converter.Update()
label_map = converter.GetOutput()

# Compute shape attributes
shape_filter = itk.ShapeLabelMapFilter[type(label_map)].New()
shape_filter.SetInput(label_map)
shape_filter.Update()

# Access shape attributes
num_objects = label_map.GetNumberOfLabelObjects()
for i in range(num_objects):
    obj = label_map.GetNthLabelObject(i)
    centroid = obj.GetCentroid()
    size = obj.GetNumberOfPixels()
    print(f"Object {i}: centroid={centroid}, size={size}")