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
smoothing-denoising.mddocs/reference/filters/
Smoothing and Denoising Filters
Filters for noise reduction and image smoothing while preserving important features like edges. Includes Gaussian smoothing, median filtering, bilateral filtering, anisotropic diffusion, and advanced denoising methods.
Capabilities
Gaussian Smoothing
def DiscreteGaussian(image, variance: list[float] = [1, 1, 1],
maximumKernelWidth: int = 32, maximumError: float = 0.01,
useImageSpacing: bool = True):
"""
Discrete Gaussian blur with separable convolution.
Args:
image: Input image
variance: Gaussian variance for each dimension
maximumKernelWidth: Maximum kernel size in pixels
maximumError: Maximum approximation error
useImageSpacing: Account for pixel spacing in physical units
Returns:
Smoothed image
"""
class DiscreteGaussianImageFilter:
"""Discrete Gaussian blur using separable convolution."""
def SetVariance(self, variance: float | tuple[float, ...]) -> None:
"""Set Gaussian variance."""
def SetMaximumKernelWidth(self, width: int) -> None:
"""Set maximum kernel width."""
def SetMaximumError(self, error: float) -> None:
"""Set maximum error tolerance."""
def SetUseImageSpacing(self, useSpacing: bool) -> None:
"""Account for image spacing."""
def Execute(self, image):
"""Returns: smoothed image"""
def SmoothingRecursiveGaussian(image, sigma: list[float] = [1, 1, 1],
normalizeAcrossScale: bool = False):
"""
Gaussian smoothing using recursive filters (efficient for large sigma).
Args:
image: Input image
sigma: Gaussian sigma (standard deviation) for each dimension
normalizeAcrossScale: Normalize for scale-space analysis
Returns:
Smoothed image
"""
class SmoothingRecursiveGaussianImageFilter:
"""Gaussian smoothing using recursive IIR filters."""
def SetSigma(self, sigma: float | tuple[float, ...]) -> None:
"""Set Gaussian sigma (standard deviation)."""
def SetNormalizeAcrossScale(self, normalize: bool) -> None:
"""Enable scale-space normalization."""
def Execute(self, image):
"""Returns: smoothed image"""Median Filtering
class MedianImageFilter:
"""Median filter for noise reduction (edge-preserving)."""
def SetRadius(self, radius: list[int] | tuple[int, ...]) -> None:
"""
Set neighborhood radius.
Args:
radius: Radius in each dimension
"""
def Execute(self, image):
"""Returns: median filtered image"""
def Median(image, radius: list[int] | tuple[int, ...] = 1):
"""Procedural: median filter."""
class RankImageFilter:
"""Rank filter (generalized median)."""
def SetRadius(self, radius: list[int] | tuple[int, ...]) -> None:
"""Set neighborhood radius."""
def SetRank(self, rank: float) -> None:
"""
Set rank (0.0 = minimum, 0.5 = median, 1.0 = maximum).
Args:
rank: Rank value in [0, 1]
"""
def Execute(self, image):
"""Returns: rank filtered image"""
def Rank(image, radius: list[int] | tuple[int, ...] = 1, rank: float = 0.5):
"""Procedural: rank filter."""Bilateral Filtering
class BilateralImageFilter:
"""Edge-preserving bilateral filter."""
def SetDomainSigma(self, sigma: float) -> None:
"""
Set spatial domain sigma (controls spatial smoothing extent).
Args:
sigma: Spatial sigma in physical units
"""
def SetRangeSigma(self, sigma: float) -> None:
"""
Set intensity range sigma (controls edge preservation).
Larger values allow more smoothing across intensity differences.
Args:
sigma: Range sigma
"""
def SetNumberOfRangeGaussianSamples(self, samples: int) -> None:
"""Set number of samples for range Gaussian."""
def Execute(self, image):
"""Returns: bilateral filtered image"""
def Bilateral(image, domainSigma: float = 4.0, rangeSigma: float = 50.0,
numberOfRangeGaussianSamples: int = 100):
"""Procedural: bilateral filter."""Anisotropic Diffusion
class GradientAnisotropicDiffusionImageFilter:
"""Gradient anisotropic diffusion for edge-preserving smoothing."""
def SetTimeStep(self, timeStep: float) -> None:
"""
Set time step for diffusion.
Must satisfy CFL condition. Typically 0.0625 for 3D, 0.125 for 2D.
Args:
timeStep: Time step value
"""
def SetNumberOfIterations(self, iterations: int) -> None:
"""Set number of diffusion iterations."""
def SetConductanceParameter(self, conductance: float) -> None:
"""
Set conductance parameter (edge sensitivity).
Lower values preserve edges more strongly.
Args:
conductance: Conductance value
"""
def Execute(self, image):
"""Returns: diffused image"""
def GradientAnisotropicDiffusion(image, timeStep: float = 0.0625,
conductanceParameter: float = 3.0,
numberOfIterations: int = 5):
"""Procedural: gradient anisotropic diffusion."""
class CurvatureAnisotropicDiffusionImageFilter:
"""Curvature anisotropic diffusion (better edge preservation)."""
def SetTimeStep(self, timeStep: float) -> None:
"""Set time step."""
def SetNumberOfIterations(self, iterations: int) -> None:
"""Set number of iterations."""
def SetConductanceParameter(self, conductance: float) -> None:
"""Set conductance (edge sensitivity)."""
def Execute(self, image):
"""Returns: diffused image"""
def CurvatureAnisotropicDiffusion(image, timeStep: float = 0.0625,
conductanceParameter: float = 3.0,
numberOfIterations: int = 5):
"""Procedural: curvature anisotropic diffusion."""Curvature Flow
class CurvatureFlowImageFilter:
"""Curvature-driven flow for image smoothing."""
def SetTimeStep(self, timeStep: float) -> None:
"""Set time step (must satisfy CFL condition)."""
def SetNumberOfIterations(self, iterations: int) -> None:
"""Set number of iterations."""
def Execute(self, image):
"""Returns: smoothed image"""
def CurvatureFlow(image, timeStep: float = 0.05, numberOfIterations: int = 5):
"""Procedural: curvature flow."""
class MinMaxCurvatureFlowImageFilter:
"""Min-max curvature flow (preserves sharp features)."""
def SetTimeStep(self, timeStep: float) -> None:
"""Set time step."""
def SetNumberOfIterations(self, iterations: int) -> None:
"""Set number of iterations."""
def SetStencilRadius(self, radius: int) -> None:
"""Set stencil radius for curvature computation."""
def Execute(self, image):
"""Returns: smoothed image"""
def MinMaxCurvatureFlow(image, timeStep: float = 0.05,
numberOfIterations: int = 5, stencilRadius: int = 2):
"""Procedural: min-max curvature flow."""Patch-Based Denoising
class PatchBasedDenoisingImageFilter:
"""Non-local means patch-based denoising."""
def SetNoiseModel(self, noiseModel: int) -> None:
"""
Set noise model.
Args:
noiseModel: Noise model type
"""
def SetPatchRadius(self, radius: int) -> None:
"""Set patch radius in pixels."""
def SetNumberOfIterations(self, iterations: int) -> None:
"""Set number of iterations."""
def SetNumberOfSamplePatches(self, samples: int) -> None:
"""Set number of patches to sample."""
def SetSampleVariance(self, variance: float) -> None:
"""Set variance for sampling."""
def Execute(self, image):
"""Returns: denoised image"""Anti-Aliasing
class AntiAliasBinaryImageFilter:
"""Anti-alias binary images for smooth boundaries."""
def SetMaximumRMSError(self, error: float) -> None:
"""Set maximum RMS error tolerance."""
def SetNumberOfIterations(self, iterations: int) -> None:
"""Set maximum number of iterations."""
def Execute(self, image):
"""Returns: anti-aliased binary image"""
def AntiAliasBinary(image, maximumRMSError: float = 0.01,
numberOfIterations: int = 50):
"""Procedural: anti-alias binary image."""Common Patterns
Progressive Denoising
import SimpleITK as sitk
# Light smoothing
image = sitk.SmoothingRecursiveGaussian(noisy_image, sigma=[0.5, 0.5, 0.5])
# Medium smoothing
image = sitk.SmoothingRecursiveGaussian(noisy_image, sigma=[1.0, 1.0, 1.0])
# Strong smoothing
image = sitk.SmoothingRecursiveGaussian(noisy_image, sigma=[2.0, 2.0, 2.0])Edge-Preserving Denoising
import SimpleITK as sitk
# Bilateral filter - preserves edges
denoised = sitk.Bilateral(noisy_image, domainSigma=2.0, rangeSigma=50.0)
# Anisotropic diffusion - preserves edges
denoised = sitk.CurvatureAnisotropicDiffusion(
noisy_image,
timeStep=0.0625,
conductanceParameter=3.0,
numberOfIterations=10
)Choosing Smoothing Method
import SimpleITK as sitk
# Fast, isotropic smoothing: Recursive Gaussian
smooth = sitk.SmoothingRecursiveGaussian(image, sigma=[1.5, 1.5, 1.5])
# Edge-preserving: Bilateral or Anisotropic Diffusion
smooth = sitk.Bilateral(image, domainSigma=3.0, rangeSigma=50.0)
# Salt-and-pepper noise: Median
smooth = sitk.Median(image, radius=[2, 2, 2])Install with Tessl CLI
npx tessl i tessl/pypi-simpleitk