tessl/pypi-itk

Insight Toolkit for N-dimensional image processing, segmentation, and registration in medical and scientific applications

—

Pending

Overview

Eval results

Files

Region Growing Segmentation

Name: tessl/pypi-itk
Author: tessl

Region growing segmentation methods that start from seed points and grow regions based on intensity or statistical criteria.

Capabilities

Connected Threshold

def connected_threshold_image_filter(input, seed, lower=0, upper=255, replace_value=1):
    """
    Region growing with intensity threshold.
    
    Parameters:
    - input: itk.Image - Input image
    - seed: itk.Index or list - Seed point(s)
    - lower: pixel_type - Lower intensity threshold
    - upper: pixel_type - Upper intensity threshold
    - replace_value: pixel_type - Value for segmented region
    
    Returns:
    itk.Image - Binary segmentation
    """

class ConnectedThresholdImageFilter:
    """
    Segment pixels connected to seeds within intensity range.
    
    Template parameters:
    - input_image_type: Input image type
    - output_image_type: Output image type
    """
    
    def SetSeed(self, seed):
        """
        Set a seed point.
        
        Parameters:
        - seed: itk.Index - Seed point index
        """
    
    def AddSeed(self, seed):
        """Add an additional seed point."""
    
    def ClearSeeds(self):
        """Clear all seed points."""
    
    def SetLower(self, lower):
        """Set lower intensity threshold."""
    
    def SetUpper(self, upper):
        """Set upper intensity threshold."""
    
    def SetReplaceValue(self, value):
        """Set output value for segmented region."""

Confidence Connected

def confidence_connected_image_filter(input, seed, multiplier=2.5, number_of_iterations=5, initial_neighborhood_radius=1, replace_value=1):
    """
    Confidence-based region growing using statistics.
    
    Parameters:
    - input: itk.Image - Input image
    - seed: itk.Index or list - Seed point(s)
    - multiplier: float - Threshold = mean ± multiplier × stddev
    - number_of_iterations: int - Number of growing iterations
    - initial_neighborhood_radius: int - Initial neighborhood for statistics
    - replace_value: pixel_type - Value for segmented region
    
    Returns:
    itk.Image - Binary segmentation
    """

class ConfidenceConnectedImageFilter:
    """
    Segment using statistical confidence intervals.
    
    Template parameters:
    - input_image_type: Input image type
    - output_image_type: Output image type
    """
    
    def SetSeed(self, seed):
        """Set a seed point."""
    
    def AddSeed(self, seed):
        """Add an additional seed point."""
    
    def SetMultiplier(self, multiplier):
        """Set the multiplier for confidence interval."""
    
    def SetNumberOfIterations(self, iterations):
        """Set number of growing iterations."""
    
    def SetInitialNeighborhoodRadius(self, radius):
        """Set initial neighborhood radius for statistics."""
    
    def SetReplaceValue(self, value):
        """Set output value for segmented region."""
    
    def GetMean(self):
        """Get the computed mean intensity."""
    
    def GetVariance(self):
        """Get the computed variance."""

Neighborhood Connected

def neighborhood_connected_image_filter(input, seed, lower=0, upper=255, radius=1, replace_value=1):
    """
    Region growing with neighborhood connectivity.
    
    Parameters:
    - input: itk.Image - Input image
    - seed: itk.Index or list - Seed point(s)
    - lower: pixel_type - Lower intensity threshold
    - upper: pixel_type - Upper intensity threshold
    - radius: int or itk.Size - Neighborhood radius
    - replace_value: pixel_type - Value for segmented region
    
    Returns:
    itk.Image - Binary segmentation
    """

class NeighborhoodConnectedImageFilter:
    """
    Segment using neighborhood connectivity criteria.
    
    Template parameters:
    - input_image_type: Input image type
    - output_image_type: Output image type
    """
    
    def SetSeed(self, seed):
        """Set a seed point."""
    
    def AddSeed(self, seed):
        """Add an additional seed point."""
    
    def SetLower(self, lower):
        """Set lower intensity threshold."""
    
    def SetUpper(self, upper):
        """Set upper intensity threshold."""
    
    def SetRadius(self, radius):
        """Set neighborhood radius."""
    
    def SetReplaceValue(self, value):
        """Set output value for segmented region."""

Isolated Connected

def isolated_connected_image_filter(input, seed1, seed2, lower=0, replace_value=1, isolated_value_tolerance=1.0):
    """
    Region growing that finds threshold isolating two regions.
    
    Parameters:
    - input: itk.Image - Input image
    - seed1: itk.Index - First seed point
    - seed2: itk.Index - Second seed point (to be isolated from first)
    - lower: pixel_type - Lower starting threshold
    - replace_value: pixel_type - Value for segmented region
    - isolated_value_tolerance: float - Tolerance for isolation
    
    Returns:
    itk.Image - Binary segmentation
    """

class IsolatedConnectedImageFilter:
    """
    Find threshold that isolates two seed-based regions.
    
    Template parameters:
    - input_image_type: Input image type
    - output_image_type: Output image type
    """
    
    def SetSeed1(self, seed):
        """Set first seed point."""
    
    def SetSeed2(self, seed):
        """Set second seed point."""
    
    def SetLower(self, lower):
        """Set lower starting threshold."""
    
    def SetUpper(self, upper):
        """Set upper starting threshold."""
    
    def SetIsolatedValueTolerance(self, tolerance):
        """Set tolerance for isolation."""
    
    def SetReplaceValue(self, value):
        """Set output value for segmented region."""
    
    def GetIsolatedValue(self):
        """Get the threshold value that isolates the regions."""

Usage Examples

Basic Connected Threshold

import itk

image = itk.imread('input.png', itk.F)

# Define seed point
seed = itk.Index[2]()
seed[0] = 100
seed[1] = 100

# Segment region
segmented = itk.connected_threshold_image_filter(
    image,
    seed=seed,
    lower=50.0,
    upper=150.0,
    replace_value=255
)

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

Multiple Seeds

import itk

image = itk.imread('input.png', itk.F)

# Create filter
ImageType = itk.Image[itk.F, 2]
OutputType = itk.Image[itk.UC, 2]
filter = itk.ConnectedThresholdImageFilter[ImageType, OutputType].New()
filter.SetInput(image)

# Add multiple seeds
seeds = [(100, 100), (150, 150), (200, 200)]
for x, y in seeds:
    seed = itk.Index[2]()
    seed[0] = x
    seed[1] = y
    filter.AddSeed(seed)

# Set parameters
filter.SetLower(50.0)
filter.SetUpper(150.0)
filter.SetReplaceValue(255)

# Execute
filter.Update()
segmented = filter.GetOutput()
itk.imwrite(segmented, 'multi_seed.png')

Confidence Connected Segmentation

import itk

image = itk.imread('input.png', itk.F)

# Seed point
seed = itk.Index[2]()
seed[0] = 100
seed[1] = 100

# Confidence-based segmentation
segmented = itk.confidence_connected_image_filter(
    image,
    seed=seed,
    multiplier=2.5,  # ± 2.5 std deviations
    number_of_iterations=5,
    initial_neighborhood_radius=2,
    replace_value=255
)

itk.imwrite(segmented, 'confidence.png')

Isolated Connected - Finding Optimal Threshold

import itk

image = itk.imread('input.png', itk.F)

# Two seeds in different regions
seed1 = itk.Index[2]()
seed1[0] = 100
seed1[1] = 100

seed2 = itk.Index[2]()
seed2[0] = 200
seed2[1] = 200

# Find threshold that isolates seed1 from seed2
ImageType = itk.Image[itk.F, 2]
OutputType = itk.Image[itk.UC, 2]
filter = itk.IsolatedConnectedImageFilter[ImageType, OutputType].New()
filter.SetInput(image)
filter.SetSeed1(seed1)
filter.SetSeed2(seed2)
filter.SetLower(0.0)
filter.SetReplaceValue(255)
filter.Update()

segmented = filter.GetOutput()
threshold = filter.GetIsolatedValue()
print(f"Optimal threshold: {threshold}")

itk.imwrite(segmented, 'isolated.png')

Install with Tessl CLI

npx tessl i tessl/pypi-itk