tessl/cmake-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

I/O Operations

Name: tessl/cmake-simpleitk
Author: tessl

Comprehensive input/output functionality for reading and writing images in various formats including DICOM, NIfTI, PNG, JPEG, TIFF, and many scientific formats. SimpleITK provides both procedural functions for simple operations and class-based interfaces for advanced control over the I/O process.

Capabilities

Procedural I/O Functions

Simple functions for common read/write operations with automatic format detection.

def ReadImage(filename: str, pixelType: int = None) -> Image:
    """
    Read image from file with automatic format detection.
    
    Args:
        filename: Path to image file
        pixelType: Optional pixel type to cast to (e.g., sitk.sitkFloat32)
        
    Returns:
        SimpleITK Image object
        
    Supported formats: DICOM, NIfTI, Analyze, MetaImage, PNG, JPEG, 
                      TIFF, BMP, LSM, Bio-Rad, Stimulate, VTK, Nrrd
    """

def WriteImage(image: Image, filename: str, useCompression: bool = False):
    """
    Write image to file with automatic format detection based on extension.
    
    Args:
        image: SimpleITK Image to write
        filename: Output file path
        useCompression: Enable compression if supported by format
    """

def Show(image: Image, title: str = "", debugOn: bool = False):
    """
    Display image using external viewer (ImageJ/Fiji by default).
    
    Args:
        image: Image to display
        title: Window title
        debugOn: Enable debug output
    """

ImageFileReader Class

Advanced image reading with metadata access and format control.

class ImageFileReader:
    def __init__(self): 
        """Initialize image file reader"""
    
    def SetFileName(self, filename: str):
        """Set input filename"""
    
    def GetFileName(self) -> str:
        """Get input filename"""
    
    def Execute(self) -> Image:
        """Read image file and return Image object"""
    
    def ReadImageInformation(self):
        """
        Read only metadata without loading pixel data.
        Call this before accessing image information methods.
        """
    
    # Image information methods (valid after ReadImageInformation or Execute)
    def GetSize(self) -> tuple:
        """Get image dimensions"""
    
    def GetOrigin(self) -> tuple:
        """Get image origin"""
    
    def GetSpacing(self) -> tuple:
        """Get pixel spacing"""
    
    def GetDirection(self) -> tuple:
        """Get direction matrix"""
    
    def GetNumberOfComponents(self) -> int:
        """Get number of components per pixel"""
    
    def GetPixelID(self) -> int:
        """Get pixel type identifier"""
    
    def GetPixelIDValue(self) -> int:
        """Get pixel type value"""
    
    def GetDimension(self) -> int:
        """Get number of dimensions"""
    
    def GetMetaDataKeys(self) -> list:
        """Get list of metadata keys"""
    
    def GetMetaData(self, key: str) -> str:
        """Get metadata value for key"""
    
    def HasMetaDataKey(self, key: str) -> bool:
        """Check if metadata key exists"""
    
    # ImageIO control
    def SetImageIO(self, imageio: str):
        """
        Override automatic ImageIO selection.
        
        Args:
            imageio: ImageIO name (e.g., 'GDCMImageIO', 'NiftiImageIO')
        """
    
    def GetImageIO(self) -> str:
        """Get name of ImageIO being used"""
    
    def GetRegisteredImageIOs(self) -> list:
        """Get list of available ImageIO names"""

ImageFileWriter Class

Advanced image writing with compression and format control.

class ImageFileWriter:
    def __init__(self):
        """Initialize image file writer"""
    
    def SetFileName(self, filename: str):
        """Set output filename"""
    
    def GetFileName(self) -> str:
        """Get output filename"""
    
    def Execute(self, image: Image):
        """Write image to file"""
    
    def SetUseCompression(self, compress: bool):
        """Enable or disable compression"""
    
    def GetUseCompression(self) -> bool:
        """Get compression setting"""
    
    def SetCompressionLevel(self, level: int):
        """
        Set compression level (format dependent).
        
        Args:
            level: Compression level (typically 0-9)
        """
    
    def GetCompressionLevel(self) -> int:
        """Get compression level"""
    
    def SetImageIO(self, imageio: str):
        """Override automatic ImageIO selection"""
    
    def GetImageIO(self) -> str:
        """Get name of ImageIO being used"""
    
    def GetRegisteredImageIOs(self) -> list:
        """Get list of available ImageIO names"""

ImageSeriesReader Class

Read image series (e.g., DICOM series, multi-file datasets).

class ImageSeriesReader:
    def __init__(self):
        """Initialize image series reader"""
    
    def SetFileNames(self, filenames: list):
        """
        Set list of filenames to read as series.
        
        Args:
            filenames: List of file paths in correct order
        """
    
    def GetFileNames(self) -> list:
        """Get list of filenames"""
    
    def Execute(self) -> Image:
        """Read series as single 3D image"""
    
    def SetMetaDataDictionaryArrayUpdate(self, update: bool):
        """Enable metadata dictionary updates"""
    
    def GetMetaDataDictionaryArrayUpdate(self) -> bool:
        """Get metadata dictionary update setting"""
    
    def SetImageIO(self, imageio: str):
        """Set ImageIO for series reading"""
    
    def GetImageIO(self) -> str:
        """Get ImageIO name"""
    
    # DICOM-specific methods
    def GetGDCMSeriesFileNames(self, directory: str, seriesID: str = "") -> list:
        """
        Get DICOM series filenames from directory.
        
        Args:
            directory: Directory containing DICOM files
            seriesID: Specific series ID to read (empty for first series)
            
        Returns:
            List of filenames in correct order
        """
    
    def GetGDCMSeriesIDs(self, directory: str) -> list:
        """
        Get list of DICOM series IDs in directory.
        
        Args:
            directory: Directory containing DICOM files
            
        Returns:
            List of series IDs
        """

ImageSeriesWriter Class

Write image series to multiple files.

class ImageSeriesWriter:
    def __init__(self):
        """Initialize image series writer"""
    
    def SetFileNames(self, filenames: list):
        """
        Set output filenames for series.
        
        Args:
            filenames: List of output file paths
        """
    
    def GetFileNames(self) -> list:
        """Get output filenames"""
    
    def Execute(self, image: Image):
        """
        Write 3D image as series of 2D images.
        
        Args:
            image: 3D image to write as series
        """
    
    def SetUseCompression(self, compress: bool):
        """Enable compression"""
    
    def GetUseCompression(self) -> bool:
        """Get compression setting"""
    
    def SetImageIO(self, imageio: str):
        """Set ImageIO for series writing"""
    
    def GetImageIO(self) -> str:
        """Get ImageIO name"""

Image Viewer

Display images using external viewers.

class ImageViewer:
    def __init__(self):
        """Initialize image viewer"""
    
    def SetTitle(self, title: str):
        """Set viewer window title"""
    
    def GetTitle(self) -> str:
        """Get viewer window title"""
    
    def SetApplication(self, app: str, args: str = ""):
        """
        Set external viewer application.
        
        Args:
            app: Path to viewer executable
            args: Command line arguments
        """
    
    def GetApplication(self) -> tuple:
        """Get viewer application and arguments"""
    
    def Execute(self, image: Image):
        """Display image using configured viewer"""
    
    # Global viewer settings
    def SetGlobalDefaultDebug(debug: bool):
        """Set global debug mode for viewer"""
    
    def GetGlobalDefaultDebug() -> bool:
        """Get global debug mode setting"""
    
    def SetGlobalDefaultDebugOn():
        """Enable global debug mode"""
    
    def SetGlobalDefaultDebugOff():
        """Disable global debug mode"""

Supported File Formats

SimpleITK supports numerous medical and scientific image formats through the ITK ImageIO framework:

# Medical formats
DICOM_FORMATS = [".dcm", ".dicom", ".ima"]
NIFTI_FORMATS = [".nii", ".nii.gz", ".hdr", ".img"]
ANALYZE_FORMATS = [".hdr", ".img"]
MINC_FORMATS = [".mnc", ".mnc2"]

# Scientific formats  
META_FORMATS = [".mhd", ".mha"]
NRRD_FORMATS = [".nrrd", ".nhdr"]
VTK_FORMATS = [".vtk"]
GIPL_FORMATS = [".gipl"]

# Standard image formats
RASTER_FORMATS = [".png", ".jpg", ".jpeg", ".tiff", ".tif", ".bmp"]
HDR_FORMATS = [".hdr", ".pic"]

# Microscopy formats
LSM_FORMATS = [".lsm"]
BIO_RAD_FORMATS = [".pic"]
STIMULATE_FORMATS = [".spr"]

Usage Examples

Basic File Operations

import SimpleITK as sitk

# Simple read/write
image = sitk.ReadImage('input.dcm')
sitk.WriteImage(image, 'output.png')

# Read with specific pixel type
float_image = sitk.ReadImage('input.dcm', sitk.sitkFloat32)

# Write with compression
sitk.WriteImage(image, 'output.nii.gz', True)

Advanced Reading with Metadata

import SimpleITK as sitk

# Create reader
reader = sitk.ImageFileReader()
reader.SetFileName('medical_image.dcm')

# Read only metadata first
reader.ReadImageInformation()

# Check image properties before loading
print(f"Image size: {reader.GetSize()}")
print(f"Pixel type: {reader.GetPixelID()}")
print(f"Spacing: {reader.GetSpacing()}")

# Check for specific metadata
if reader.HasMetaDataKey('0010|0010'):  # Patient Name
    patient = reader.GetMetaData('0010|0010')
    print(f"Patient: {patient}")

# Now read the actual image
image = reader.Execute()

DICOM Series Reading

import SimpleITK as sitk
import os

# Directory containing DICOM files
dicom_dir = "/path/to/dicom/series"

# Create series reader
series_reader = sitk.ImageSeriesReader()

# Get series IDs in directory
series_ids = series_reader.GetGDCMSeriesIDs(dicom_dir)
print(f"Found {len(series_ids)} series")

# Read first series
if series_ids:
    series_id = series_ids[0]
    dicom_files = series_reader.GetGDCMSeriesFileNames(dicom_dir, series_id)
    print(f"Series contains {len(dicom_files)} files")
    
    series_reader.SetFileNames(dicom_files)
    image = series_reader.Execute()
    
    print(f"3D image size: {image.GetSize()}")

Writing Image Series

import SimpleITK as sitk

# Read 3D image
image_3d = sitk.ReadImage('volume.nii')

# Create output filenames
num_slices = image_3d.GetSize()[2]
filenames = [f'slice_{i:03d}.png' for i in range(num_slices)]

# Write as series
series_writer = sitk.ImageSeriesWriter()
series_writer.SetFileNames(filenames)
series_writer.Execute(image_3d)

Custom Viewer Setup

import SimpleITK as sitk

# Set custom viewer (ImageJ/Fiji)
viewer = sitk.ImageViewer()
viewer.SetApplication('/path/to/ImageJ', '-eval "run(\\"Enhance Contrast\\", \\"saturated=0.35\\")"')

# Display image
image = sitk.ReadImage('data.dcm')
viewer.SetTitle('Medical Image')
viewer.Execute(image)

# Or use simple Show function
sitk.Show(image, 'Quick View', debugOn=True)

Format-Specific Options

import SimpleITK as sitk

# Force specific ImageIO
reader = sitk.ImageFileReader()
reader.SetFileName('ambiguous_file')
reader.SetImageIO('GDCMImageIO')  # Force DICOM reading
image = reader.Execute()

# Check available ImageIOs
available_ios = reader.GetRegisteredImageIOs()
print(f"Available ImageIOs: {available_ios}")

# Write with specific format options
writer = sitk.ImageFileWriter()
writer.SetFileName('output.tiff')
writer.SetUseCompression(True)
writer.SetCompressionLevel(6)  # Medium compression
writer.Execute(image)

Install with Tessl CLI