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
resampling-geometric.mddocs/reference/filters/
Resampling and Geometric Transforms
Filters for image resampling, cropping, padding, flipping, extraction, and geometric transformations. These filters modify image geometry, resolution, or spatial extent.
Capabilities
Resampling
def Resample(image, *args, referenceImage = None, size = None, **kwargs):
"""
Resample image with transform and/or new geometry.
Three main usage patterns:
1. Resample(image, transform, interpolator, defaultPixelValue, outputPixelType)
2. Resample(image, referenceImage, transform, interpolator, defaultPixelValue)
3. Resample(image, size, transform, interpolator, outputOrigin, outputSpacing,
outputDirection, defaultPixelValue, outputPixelType)
Args:
image: Input image
transform: Geometric transform (default: identity)
interpolator: Interpolation method (default: sitkLinear)
defaultPixelValue: Value for pixels outside input (default: 0)
outputPixelType: Output pixel type (default: same as input)
referenceImage: Reference for output geometry
size: Output size
outputOrigin: Output origin
outputSpacing: Output spacing
outputDirection: Output direction
Returns:
Resampled image
"""
class ResampleImageFilter:
"""Resample image with transform and specified output geometry."""
def SetReferenceImage(self, referenceImage) -> None:
"""Set reference image for output geometry."""
def SetSize(self, size: tuple[int, ...]) -> None:
"""Set output size."""
def SetOutputOrigin(self, origin: tuple[float, ...]) -> None:
"""Set output origin."""
def SetOutputSpacing(self, spacing: tuple[float, ...]) -> None:
"""Set output spacing."""
def SetOutputDirection(self, direction: tuple[float, ...]) -> None:
"""Set output direction."""
def SetTransform(self, transform) -> None:
"""Set geometric transform."""
def SetInterpolator(self, interpolator: int) -> None:
"""Set interpolator (sitkLinear, sitkNearestNeighbor, etc.)."""
def SetDefaultPixelValue(self, value: float) -> None:
"""Set value for pixels outside input."""
def SetOutputPixelType(self, pixelType: int) -> None:
"""Set output pixel type."""
def SetUseNearestNeighborExtrapolator(self, use: bool) -> None:
"""Use nearest neighbor extrapolation outside image."""
def Execute(self, image):
"""Returns: resampled image"""
class ExpandImageFilter:
"""Expand image by interpolation (upsampling)."""
def SetExpandFactors(self, factors: tuple[int, ...]) -> None:
"""Set expansion factors for each dimension."""
def SetInterpolator(self, interpolator: int) -> None:
"""Set interpolator."""
def Execute(self, image):
"""Returns: expanded image"""
def Expand(image, expandFactors: tuple[int, ...], interpolator: int = sitkLinear):
"""Procedural: expand image."""
class ShrinkImageFilter:
"""Shrink image by subsampling (downsampling)."""
def SetShrinkFactors(self, factors: tuple[int, ...]) -> None:
"""Set shrink factors for each dimension."""
def Execute(self, image):
"""Returns: shrunk image (subsampled)"""
def Shrink(image, shrinkFactors: tuple[int, ...]):
"""Procedural: shrink image."""
class BinShrinkImageFilter:
"""Shrink by averaging (bin averaging)."""
def SetShrinkFactors(self, factors: tuple[int, ...]) -> None:
"""Set shrink factors."""
def Execute(self, image):
"""Returns: shrunk image (averaged)"""
def BinShrink(image, shrinkFactors: tuple[int, ...]):
"""Procedural: bin shrink."""Cropping and Extraction
class CropImageFilter:
"""Crop image by removing boundary pixels."""
def SetLowerBoundaryCropSize(self, size: tuple[int, ...]) -> None:
"""Set pixels to crop from lower boundary."""
def SetUpperBoundaryCropSize(self, size: tuple[int, ...]) -> None:
"""Set pixels to crop from upper boundary."""
def Execute(self, image):
"""Returns: cropped image"""
def Crop(image, lowerBoundaryCropSize: tuple[int, ...], upperBoundaryCropSize: tuple[int, ...]):
"""Procedural: crop image."""
class ExtractImageFilter:
"""Extract region of interest with dimension reduction."""
def SetSize(self, size: tuple[int, ...]) -> None:
"""Set extraction size (0 in dimension to collapse)."""
def SetIndex(self, index: tuple[int, ...]) -> None:
"""Set starting index."""
def Execute(self, image):
"""Returns: extracted region (may be lower dimensional)"""
def Extract(image, size: tuple[int, ...], index: tuple[int, ...] = (0, 0, 0)):
"""Procedural: extract region."""
class RegionOfInterestImageFilter:
"""Extract region of interest (same dimensionality)."""
def SetSize(self, size: tuple[int, ...]) -> None:
"""Set ROI size."""
def SetIndex(self, index: tuple[int, ...]) -> None:
"""Set ROI starting index."""
def Execute(self, image):
"""Returns: ROI image"""
def RegionOfInterest(image, size: tuple[int, ...], index: tuple[int, ...]):
"""Procedural: extract ROI."""Padding
class ConstantPadImageFilter:
"""Pad image with constant value."""
def SetPadLowerBound(self, bound: tuple[int, ...]) -> None:
"""Set padding at lower boundary."""
def SetPadUpperBound(self, bound: tuple[int, ...]) -> None:
"""Set padding at upper boundary."""
def SetConstant(self, value: float) -> None:
"""Set constant padding value."""
def Execute(self, image):
"""Returns: padded image"""
def ConstantPad(image, padLowerBound: tuple[int, ...], padUpperBound: tuple[int, ...],
constant: float = 0):
"""Procedural: constant padding."""
class MirrorPadImageFilter:
"""Pad by mirroring image content."""
def SetPadLowerBound(self, bound: tuple[int, ...]) -> None:
"""Set padding at lower boundary."""
def SetPadUpperBound(self, bound: tuple[int, ...]) -> None:
"""Set padding at upper boundary."""
def Execute(self, image):
"""Returns: mirror-padded image"""
class WrapPadImageFilter:
"""Pad by wrapping (periodic boundary)."""
def SetPadLowerBound(self, bound: tuple[int, ...]) -> None:
"""Set lower padding."""
def SetPadUpperBound(self, bound: tuple[int, ...]) -> None:
"""Set upper padding."""
def Execute(self, image):
"""Returns: wrap-padded image"""
class ZeroFluxNeumannPadImageFilter:
"""Pad using zero-flux Neumann boundary (replicate edge)."""
def SetPadLowerBound(self, bound: tuple[int, ...]) -> None:
"""Set lower padding."""
def SetPadUpperBound(self, bound: tuple[int, ...]) -> None:
"""Set upper padding."""
def Execute(self, image):
"""Returns: padded image"""Geometric Operations
class FlipImageFilter:
"""Flip image along specified axes."""
def SetFlipAxes(self, axes: tuple[bool, ...]) -> None:
"""Set which axes to flip (True to flip)."""
def Execute(self, image):
"""Returns: flipped image"""
def Flip(image, flipAxes: tuple[bool, ...]):
"""Procedural: flip image."""
class PermuteAxesImageFilter:
"""Permute image axes."""
def SetOrder(self, order: tuple[int, ...]) -> None:
"""
Set axis permutation order.
Args:
order: New axis order (e.g., (2, 1, 0) reverses axes)
"""
def Execute(self, image):
"""Returns: permuted image"""
def PermuteAxes(image, order: tuple[int, ...]):
"""Procedural: permute axes."""Image Composition
class PasteImageFilter:
"""Paste one image into another."""
def SetSourceSize(self, size: tuple[int, ...]) -> None:
"""Set size of region to paste."""
def SetSourceIndex(self, index: tuple[int, ...]) -> None:
"""Set starting index in source."""
def SetDestinationIndex(self, index: tuple[int, ...]) -> None:
"""Set paste location in destination."""
def Execute(self, destinationImage, sourceImage):
"""
Paste source into destination.
Returns:
Destination image with source pasted
"""
class TileImageFilter:
"""Tile multiple images into grid."""
def SetLayout(self, layout: tuple[int, ...]) -> None:
"""Set grid layout (columns, rows, [slices])."""
def SetDefaultPixelValue(self, value: float) -> None:
"""Set value for empty tiles."""
def Execute(self, *images):
"""
Tile images.
Args:
images: Multiple images to tile
Returns:
Tiled image
"""
class JoinSeriesImageFilter:
"""Join images into series (adds dimension)."""
def SetOrigin(self, origin: float) -> None:
"""Set origin for new dimension."""
def SetSpacing(self, spacing: float) -> None:
"""Set spacing for new dimension."""
def Execute(self, *images):
"""
Join images into series.
Returns:
N+1 dimensional image
"""
def JoinSeries(*images, origin: float = 0, spacing: float = 1):
"""Procedural: join series."""
class ComposeImageFilter:
"""Compose scalar images into vector image."""
def Execute(self, *images):
"""
Compose images.
Args:
images: Multiple scalar images (same size)
Returns:
Vector image with N components
"""
def Compose(*images):
"""Procedural: compose into vector image."""
class VectorIndexSelectionCastImageFilter:
"""Extract component from vector image."""
def SetIndex(self, index: int) -> None:
"""Set component index to extract."""
def SetOutputPixelType(self, pixelType: int) -> None:
"""Set output pixel type."""
def Execute(self, vectorImage):
"""Returns: scalar image with selected component"""
def VectorIndexSelectionCast(vectorImage, index: int, outputPixelType: int = sitkUnknown):
"""Procedural: extract vector component."""Common Patterns
Resample to Isotropic Spacing
import SimpleITK as sitk
# Get current spacing
original_spacing = image.GetSpacing()
original_size = image.GetSize()
# Compute isotropic spacing (use minimum)
iso_spacing = [min(original_spacing)] * 3
# Compute new size
new_size = [
int(original_size[i] * original_spacing[i] / iso_spacing[i])
for i in range(3)
]
# Resample
resampled = sitk.Resample(
image,
size=new_size,
transform=sitk.Transform(),
interpolator=sitk.sitkLinear,
outputOrigin=image.GetOrigin(),
outputSpacing=iso_spacing,
outputDirection=image.GetDirection(),
defaultPixelValue=0,
outputPixelType=image.GetPixelID()
)Extract 2D Slice from 3D Volume
import SimpleITK as sitk
# Extract middle slice (Z dimension)
size = list(image.GetSize())
index = [0, 0, size[2] // 2]
size[2] = 0 # Collapse Z dimension
slice_2d = sitk.Extract(image, size=size, index=index)Crop to Region of Interest
import SimpleITK as sitk
# Define ROI in index space
roi_start = (50, 50, 20)
roi_size = (100, 100, 40)
roi = sitk.RegionOfInterest(image, size=roi_size, index=roi_start)Install with Tessl CLI
npx tessl i tessl/pypi-simpleitk