Quick Start Guide

pip install SimpleITK

import SimpleITK as sitk

# Read image
image = sitk.ReadImage('input.png')

# Get properties
print(f"Size: {image.GetSize()}")
print(f"Pixel Type: {image.GetPixelIDTypeAsString()}")
print(f"Spacing: {image.GetSpacing()}")

# Write image
sitk.WriteImage(image, 'output.png')

# Gaussian smoothing
smoothed = sitk.SmoothingRecursiveGaussian(image, sigma=[2.0, 2.0])

# Median filtering
denoised = sitk.Median(image, radius=[2, 2])

# Edge detection
edges = sitk.CannyEdgeDetection(image, lowerThreshold=10, upperThreshold=50)

# Binary threshold
binary = sitk.BinaryThreshold(
    image,
    lowerThreshold=100,
    upperThreshold=255,
    insideValue=1,
    outsideValue=0
)

# Automatic Otsu threshold
otsu = sitk.OtsuThreshold(image)

import SimpleITK as sitk
import numpy as np

# SimpleITK to NumPy (deep copy)
image = sitk.ReadImage('input.nii.gz')
array = sitk.GetArrayFromImage(image)
print(f"Array shape: {array.shape}")  # Note: reversed dimensions

# Process with NumPy
processed = array * 2.0
processed = np.clip(processed, 0, 255)

# NumPy to SimpleITK
result = sitk.GetImageFromArray(processed)
result.CopyInformation(image)  # IMPORTANT: Preserve metadata

# Write result
sitk.WriteImage(result, 'output.nii.gz')

# Read-only view (no copy)
array_view = sitk.GetArrayViewFromImage(image)

# Compute statistics efficiently
mean = array_view.mean()
std = array_view.std()

# WARNING: Image must remain alive while using view

import SimpleITK as sitk

# Read images
fixed = sitk.ReadImage('fixed.nii')
moving = sitk.ReadImage('moving.nii')

# Initialize transform
initial_transform = sitk.CenteredTransformInitializer(
    fixed,
    moving,
    sitk.Euler3DTransform(),
    sitk.CenteredTransformInitializerFilter.GEOMETRY
)

# Configure registration
registration = sitk.ImageRegistrationMethod()
registration.SetMetricAsMattesMutualInformation(numberOfHistogramBins=50)
registration.SetOptimizerAsGradientDescent(
    learningRate=1.0,
    numberOfIterations=100
)
registration.SetInterpolator(sitk.sitkLinear)
registration.SetInitialTransform(initial_transform)

# Execute registration
final_transform = registration.Execute(fixed, moving)

# Apply transform
resampled = sitk.Resample(moving, fixed, final_transform)
sitk.WriteImage(resampled, 'registered.nii')

# Define seed points
seeds = [(128, 128, 64)]

# Connected threshold segmentation
segmentation = sitk.ConnectedThreshold(
    image,
    seedList=seeds,
    lower=100,
    upper=200
)

# Confidence connected (automatic threshold)
confidence_seg = sitk.ConfidenceConnected(
    image,
    seedList=seeds,
    numberOfIterations=5,
    multiplier=2.5
)

# Clean up segmentation
cleaned = sitk.BinaryMorphologicalOpening(
    segmentation,
    kernelRadius=[2, 2, 2],
    kernelType=sitk.sitkBall
)

# Fill holes
filled = sitk.BinaryMorphologicalClosing(
    cleaned,
    kernelRadius=[2, 2, 2],
    kernelType=sitk.sitkBall
)

# Label connected components
labeled = sitk.ConnectedComponent(filled)

# Filter by size
labeled = sitk.RelabelComponent(labeled, minimumObjectSize=100)

import SimpleITK as sitk
import os

# Get DICOM series
dicom_dir = 'dicom_directory/'
series_ids = sitk.ImageSeriesReader.GetGDCMSeriesIDs(dicom_dir)

if series_ids:
    # Read first series
    series_files = sitk.ImageSeriesReader.GetGDCMSeriesFileNames(
        dicom_dir,
        series_ids[0]
    )
    
    reader = sitk.ImageSeriesReader()
    reader.SetFileNames(series_files)
    volume = reader.Execute()
    
    print(f"Volume size: {volume.GetSize()}")

# Write 3D volume as 2D slices
depth = volume.GetDepth()
writer = sitk.ImageSeriesWriter()
writer.SetFileNames([f'slice_{i:04d}.png' for i in range(depth)])
writer.Execute(volume)

def preprocess_medical_image(input_path, output_path):
    """Standard preprocessing for medical images."""
    # Read
    image = sitk.ReadImage(input_path)
    
    # Denoise
    image = sitk.CurvatureAnisotropicDiffusion(
        image,
        timeStep=0.0625,
        conductanceParameter=3.0,
        numberOfIterations=5
    )
    
    # Normalize intensity
    image = sitk.RescaleIntensity(image, outputMinimum=0, outputMaximum=1000)
    
    # Resample to isotropic spacing
    original_spacing = image.GetSpacing()
    original_size = image.GetSize()
    
    iso_spacing = [min(original_spacing)] * 3
    new_size = [
        int(original_size[i] * original_spacing[i] / iso_spacing[i])
        for i in range(3)
    ]
    
    image = sitk.Resample(
        image,
        size=new_size,
        transform=sitk.Transform(),
        interpolator=sitk.sitkLinear,
        outputOrigin=image.GetOrigin(),
        outputSpacing=iso_spacing,
        outputDirection=image.GetDirection()
    )
    
    # Write
    sitk.WriteImage(image, output_path)
    return image

def normalize_intensity(image):
    """Normalize image to zero mean, unit variance."""
    # Compute statistics
    stats = sitk.StatisticsImageFilter()
    stats.Execute(image)
    
    mean = stats.GetMean()
    std = stats.GetSigma()
    
    # Normalize
    normalized = sitk.ShiftScale(image, shift=-mean, scale=1.0/std)
    return normalized

import SimpleITK as sitk

try:
    image = sitk.ReadImage('input.nii.gz')
    
    # Check image properties
    if image.GetDimension() != 3:
        raise ValueError("Expected 3D image")
    
    # Process
    result = sitk.SmoothingRecursiveGaussian(image, sigma=[1.0, 1.0, 1.0])
    
    sitk.WriteImage(result, 'output.nii.gz')
    
except RuntimeError as e:
    print(f"SimpleITK error: {e}")
except ValueError as e:
    print(f"Validation error: {e}")

# Set global thread count
sitk.ProcessObject.SetGlobalDefaultNumberOfThreads(8)

# Or per-filter
filter = sitk.DiscreteGaussianImageFilter()
filter.SetNumberOfThreads(4)
result = filter.Execute(image)

def show_progress():
    progress = filter.GetProgress()
    print(f"\rProgress: {progress*100:.1f}%", end='')

filter = sitk.DiscreteGaussianImageFilter()
filter.AddCommand(sitk.sitkProgressEvent, show_progress)
result = filter.Execute(large_image)
print()  # New line after progress