tessl/pypi-simpleitk

SimpleITK is a simplified interface to the Insight Toolkit (ITK) for image registration and segmentation

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Miscellaneous Filters

Name: tessl/pypi-simpleitk
Author: tessl

Additional specialized filters including histogram matching, image comparison, hash computation, multi-resolution pyramids, voting filters, and utility operations.

Capabilities

Histogram Matching

class HistogramMatchingImageFilter:
    """Match histogram of image to reference."""

    def SetNumberOfHistogramLevels(self, levels: int) -> None:
        """Set histogram bin resolution."""

    def SetNumberOfMatchPoints(self, points: int) -> None:
        """Set number of histogram match points."""

    def SetThresholdAtMeanIntensity(self, threshold: bool) -> None:
        """Threshold at mean intensity."""

    def Execute(self, image, referenceImage):
        """
        Match histogram.

        Args:
            image: Image to transform
            referenceImage: Reference for target histogram

        Returns:
            Histogram-matched image
        """

def HistogramMatching(image, referenceImage, numberOfHistogramLevels: int = 256,
                       numberOfMatchPoints: int = 1, thresholdAtMeanIntensity: bool = True):
    """Procedural: histogram matching."""

class AdaptiveHistogramEqualizationImageFilter:
    """Adaptive histogram equalization (CLAHE)."""

    def SetRadius(self, radius: int | tuple[int, ...]) -> None:
        """Set neighborhood radius."""

    def SetAlpha(self, alpha: float) -> None:
        """Set blending parameter (0=none, 1=full)."""

    def SetBeta(self, beta: float) -> None:
        """Set slope control parameter."""

    def Execute(self, image):
        """
        Adaptive histogram equalization.

        Returns:
            Equalized image
        """

def AdaptiveHistogramEqualization(image, radius: int | tuple[int, ...] = 5,
                                   alpha: float = 0.3, beta: float = 0.3):
    """Procedural: adaptive histogram equalization."""

Image Comparison

class SimilarityIndexImageFilter:
    """Compute similarity metrics between images."""

    def Execute(self, image1, image2):
        """
        Compute similarity.

        Args:
            image1: First image
            image2: Second image
        """

    def GetSimilarityIndex(self) -> float:
        """Get similarity index (overlap coefficient)."""

    def GetNumberOfPixelsInImage1(self) -> int:
        """Get pixels in first image."""

    def GetNumberOfPixelsInImage2(self) -> int:
        """Get pixels in second image."""

class CheckerBoardImageFilter:
    """Create checkerboard pattern from two images."""

    def SetCheckerPattern(self, pattern: tuple[int, ...]) -> None:
        """
        Set checkerboard pattern.

        Args:
            pattern: Size of checker squares in each dimension
        """

    def Execute(self, image1, image2):
        """
        Create checkerboard.

        Returns:
            Checkerboard image alternating between inputs
        """

def CheckerBoard(image1, image2, checkerPattern: tuple[int, ...]):
    """Procedural: create checkerboard."""

Hash Computation

class HashImageFilter:
    """Compute hash of image for verification."""

    def SetHashFunction(self, hashFunction: int) -> None:
        """Set hash function (SHA1, MD5, etc.)."""

    def Execute(self, image):
        """Compute hash."""

    def GetHashValue(self) -> str:
        """
        Get computed hash string.

        Returns:
            Hash as hex string
        """

def Hash(image, hashFunction: int = 0):
    """Procedural: compute hash (returns filter for hash access)."""

Multi-Resolution Pyramids

class RecursiveMultiResolutionPyramidImageFilter:
    """Generate multi-resolution pyramid using recursive smoothing."""

    def SetNumberOfLevels(self, levels: int) -> None:
        """Set number of pyramid levels."""

    def SetShrinkFactors(self, factors: tuple[int, ...]) -> None:
        """Set shrink factors per level."""

    def Execute(self, image):
        """
        Generate pyramid.

        Returns:
            List of images at different resolutions
        """

def RecursiveMultiResolutionPyramid(image, numberOfLevels: int = 2,
                                     shrinkFactors: tuple[int, ...] = None):
    """Procedural: generate pyramid."""

Image Sources

class GaussianImageSource:
    """Generate Gaussian image."""

    def SetSize(self, size: tuple[int, ...]) -> None:
        """Set output size."""

    def SetSigma(self, sigma: float | tuple[float, ...]) -> None:
        """Set Gaussian sigma."""

    def SetMean(self, mean: tuple[float, ...]) -> None:
        """Set Gaussian center."""

    def SetScale(self, scale: float) -> None:
        """Set amplitude scale."""

    def SetNormalized(self, normalized: bool) -> None:
        """Normalize to unit sum."""

    def Execute(self):
        """Returns: Gaussian image"""

class GaborImageSource:
    """Generate Gabor filter image."""

    def SetSize(self, size: tuple[int, ...]) -> None:
        """Set output size."""

    def SetSigma(self, sigma: float | tuple[float, ...]) -> None:
        """Set Gaussian envelope sigma."""

    def SetFrequency(self, frequency: float) -> None:
        """Set frequency."""

    def Execute(self):
        """Returns: Gabor filter image"""

class GridImageSource:
    """Generate grid pattern image."""

    def SetSize(self, size: tuple[int, ...]) -> None:
        """Set output size."""

    def SetSigma(self, sigma: float | tuple[float, ...]) -> None:
        """Set line thickness (Gaussian sigma)."""

    def SetGridSpacing(self, spacing: tuple[float, ...]) -> None:
        """Set grid spacing."""

    def SetGridOffset(self, offset: tuple[float, ...]) -> None:
        """Set grid offset."""

    def SetScale(self, scale: float) -> None:
        """Set line intensity."""

    def Execute(self):
        """Returns: grid image"""

class PhysicalPointImageSource:
    """Generate image with physical point coordinates."""

    def SetSize(self, size: tuple[int, ...]) -> None:
        """Set output size."""

    def SetOrigin(self, origin: tuple[float, ...]) -> None:
        """Set origin."""

    def SetSpacing(self, spacing: tuple[float, ...]) -> None:
        """Set spacing."""

    def SetDirection(self, direction: tuple[float, ...]) -> None:
        """Set direction."""

    def Execute(self):
        """Returns: vector image with physical coordinates at each pixel"""

Texture and Clustering

class ScalarImageKmeansImageFilter:
    """K-means clustering on scalar image."""

    def SetClassWithInitialMean(self, classIndex: int, mean: float) -> None:
        """Set initial mean for class."""

    def AddClassWithInitialMean(self, mean: float) -> None:
        """Add class with initial mean."""

    def Execute(self, image):
        """
        K-means clustering.

        Returns:
            Label image with cluster assignments
        """

    def GetFinalMeans(self) -> tuple[float, ...]:
        """Get final cluster means."""

ProcessObject Methods

class ProcessObject:
    """
    Base class for all filters (inherited by all filter classes).

    Provides common functionality for progress monitoring, threading,
    and observer pattern.
    """

    def GetName(self) -> str:
        """Get filter name."""

    def GetNumberOfThreads(self) -> int:
        """Get number of threads for execution."""

    def SetNumberOfThreads(self, threads: int) -> None:
        """
        Set number of threads.

        Args:
            threads: Number of threads (0 = default/auto)
        """

    def GetProgress(self) -> float:
        """
        Get execution progress.

        Returns:
            Progress in [0, 1]
        """

    def AddCommand(self, event: int, callback) -> None:
        """
        Add observer callback.

        Args:
            event: Event type (sitkProgressEvent, sitkIterationEvent, etc.)
            callback: Callback function
        """

    def RemoveAllCommands(self) -> None:
        """Remove all observer callbacks."""

    def Abort(self) -> None:
        """Abort filter execution."""

    def GetGlobalDefaultNumberOfThreads() -> int:
        """Get global default thread count."""

    def SetGlobalDefaultNumberOfThreads(threads: int) -> None:
        """Set global default thread count."""

Event Types

sitkAnyEvent = 0
sitkAbortEvent = 1
sitkDeleteEvent = 2
sitkEndEvent = 3
sitkIterationEvent = 4
sitkProgressEvent = 5
sitkStartEvent = 6
sitkUserEvent = 7
sitkMultiResolutionIterationEvent = 9

Common Patterns

Progress Monitoring

import SimpleITK as sitk

def progress_callback():
    progress = filter.GetProgress()
    print(f"Progress: {progress * 100:.1f}%")

# Create filter
filter = sitk.DiscreteGaussianImageFilter()
filter.SetVariance(2.0)

# Add progress callback
filter.AddCommand(sitk.sitkProgressEvent, progress_callback)

# Execute with progress updates
result = filter.Execute(image)

Multi-Threading Control

import SimpleITK as sitk

# Set global default threads
sitk.ProcessObject.SetGlobalDefaultNumberOfThreads(4)

# Or set per filter
filter = sitk.DiscreteGaussianImageFilter()
filter.SetNumberOfThreads(8)
result = filter.Execute(image)

Histogram Matching for Intensity Normalization

import SimpleITK as sitk

# Match histogram of image to reference
normalized = sitk.HistogramMatching(
    image,
    reference_image,
    numberOfHistogramLevels=1024,
    numberOfMatchPoints=10
)

Checkerboard Comparison

import SimpleITK as sitk

# Create checkerboard for visual comparison
checker = sitk.CheckerBoard(
    fixed_image,
    moving_image,
    checkerPattern=(10, 10, 10)
)

K-Means Segmentation

import SimpleITK as sitk

# K-means clustering
kmeans = sitk.ScalarImageKmeansImageFilter()
kmeans.AddClassWithInitialMean(100)
kmeans.AddClassWithInitialMean(200)
kmeans.AddClassWithInitialMean(300)

segmented = kmeans.Execute(image)
final_means = kmeans.GetFinalMeans()
print(f"Final cluster means: {final_means}")

Image Hash for Verification

import SimpleITK as sitk

# Compute hash for verification
hash_filter = sitk.HashImageFilter()
hash_filter.Execute(image)
image_hash = hash_filter.GetHashValue()

print(f"Image hash: {image_hash}")

# Verify images are identical
hash_filter2 = sitk.HashImageFilter()
hash_filter2.Execute(image2)
image_hash2 = hash_filter2.GetHashValue()

if image_hash == image_hash2:
    print("Images are identical")

Generate Test Images

import SimpleITK as sitk

# Gaussian blob
gaussian = sitk.GaussianImageSource()
gaussian.SetSize([128, 128, 64])
gaussian.SetSigma([10.0, 10.0, 5.0])
gaussian.SetMean([64.0, 64.0, 32.0])
blob = gaussian.Execute()

# Grid pattern
grid = sitk.GridImageSource()
grid.SetSize([256, 256])
grid.SetSigma([0.5, 0.5])
grid.SetGridSpacing([20.0, 20.0])
grid_image = grid.Execute()

Install with Tessl CLI

npx tessl i tessl/pypi-simpleitk

tessl/pypi-simpleitk

miscellaneous.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/reference/filters/

Miscellaneous Filters

Capabilities

Histogram Matching

Image Comparison

Hash Computation

Multi-Resolution Pyramids

Image Sources

Texture and Clustering

ProcessObject Methods

Event Types

Common Patterns

Progress Monitoring

Multi-Threading Control

Histogram Matching for Intensity Normalization

Checkerboard Comparison

K-Means Segmentation

Image Hash for Verification

Generate Test Images

miscellaneous.mddocs/reference/filters/