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
transforms.mddocs/
Transforms
Geometric transformation classes for image registration, spatial alignment, and coordinate system manipulation. SimpleITK provides a comprehensive set of transformation types from simple rigid transformations to complex deformable transforms, with parameter optimization and inverse computation capabilities.
Capabilities
Base Transform Class
All transforms inherit from the base Transform class which provides common functionality.
class Transform:
def __init__(self, dimension: int = 3, transformType: str = ""):
"""
Initialize transform.
Args:
dimension: Spatial dimension (2 or 3)
transformType: Specific transform type name
"""
def GetParameters(self) -> tuple:
"""Get transform parameters as tuple"""
def SetParameters(self, parameters: tuple):
"""
Set transform parameters.
Args:
parameters: Parameter values as tuple
"""
def GetFixedParameters(self) -> tuple:
"""Get fixed parameters (e.g., center of rotation)"""
def SetFixedParameters(self, parameters: tuple):
"""Set fixed parameters"""
def GetNumberOfParameters(self) -> int:
"""Get number of parameters"""
def GetNumberOfFixedParameters(self) -> int:
"""Get number of fixed parameters"""
def TransformPoint(self, point: tuple) -> tuple:
"""
Transform a single point.
Args:
point: Input point coordinates as tuple
Returns:
Transformed point coordinates
"""
def GetInverse(self) -> Transform:
"""
Get inverse transform.
Returns:
Inverse transform object
Raises:
Exception if transform is not invertible
"""
def SetIdentity(self):
"""Set transform to identity"""
def GetDimension(self) -> int:
"""Get spatial dimension"""
def GetTransformEnum(self) -> int:
"""Get transform type enumeration"""
def GetName(self) -> str:
"""Get transform name"""Translation Transform
Pure translation without rotation or scaling.
class TranslationTransform(Transform):
def __init__(self, dimension: int = 3):
"""
Initialize translation transform.
Args:
dimension: Spatial dimension (2 or 3)
"""
def SetOffset(self, offset: tuple):
"""
Set translation offset.
Args:
offset: Translation vector
"""
def GetOffset(self) -> tuple:
"""Get translation offset"""Rigid Transforms
Rotation and translation without scaling or shearing.
class Euler2DTransform(Transform):
def __init__(self):
"""Initialize 2D rigid transform with rotation and translation"""
def SetAngle(self, angle: float):
"""Set rotation angle in radians"""
def GetAngle(self) -> float:
"""Get rotation angle in radians"""
def SetTranslation(self, translation: tuple):
"""Set translation vector"""
def GetTranslation(self) -> tuple:
"""Get translation vector"""
def SetCenter(self, center: tuple):
"""Set center of rotation"""
def GetCenter(self) -> tuple:
"""Get center of rotation"""
class Euler3DTransform(Transform):
def __init__(self):
"""Initialize 3D rigid transform with rotation and translation"""
def SetRotation(self, angleX: float, angleY: float, angleZ: float):
"""
Set rotation angles around X, Y, Z axes.
Args:
angleX: Rotation around X-axis in radians
angleY: Rotation around Y-axis in radians
angleZ: Rotation around Z-axis in radians
"""
def GetAngleX(self) -> float:
"""Get rotation around X-axis"""
def GetAngleY(self) -> float:
"""Get rotation around Y-axis"""
def GetAngleZ(self) -> float:
"""Get rotation around Z-axis"""
def SetTranslation(self, translation: tuple):
"""Set translation vector"""
def GetTranslation(self) -> tuple:
"""Get translation vector"""
def SetCenter(self, center: tuple):
"""Set center of rotation"""
def GetCenter(self) -> tuple:
"""Get center of rotation"""
class VersorTransform(Transform):
def __init__(self):
"""3D rotation using versor (unit quaternion) representation"""
def SetRotation(self, versor: tuple):
"""
Set rotation using versor (unit quaternion).
Args:
versor: Versor as (x, y, z, w) tuple
"""
def GetVersor(self) -> tuple:
"""Get versor representation"""
def SetCenter(self, center: tuple):
"""Set center of rotation"""
def GetCenter(self) -> tuple:
"""Get center of rotation"""
class VersorRigid3DTransform(Transform):
def __init__(self):
"""3D rigid transform using versor for rotation"""
def SetRotation(self, versor: tuple):
"""Set rotation using versor"""
def GetVersor(self) -> tuple:
"""Get versor representation"""
def SetTranslation(self, translation: tuple):
"""Set translation vector"""
def GetTranslation(self) -> tuple:
"""Get translation vector"""
def SetCenter(self, center: tuple):
"""Set center of rotation"""
def GetCenter(self) -> tuple:
"""Get center of rotation"""Similarity Transforms
Uniform scaling, rotation, and translation.
class Similarity2DTransform(Transform):
def __init__(self):
"""2D similarity transform (rotation, uniform scaling, translation)"""
def SetScale(self, scale: float):
"""Set uniform scaling factor"""
def GetScale(self) -> float:
"""Get scaling factor"""
def SetAngle(self, angle: float):
"""Set rotation angle in radians"""
def GetAngle(self) -> float:
"""Get rotation angle"""
def SetTranslation(self, translation: tuple):
"""Set translation vector"""
def GetTranslation(self) -> tuple:
"""Get translation vector"""
def SetCenter(self, center: tuple):
"""Set center of transformation"""
def GetCenter(self) -> tuple:
"""Get center of transformation"""
class Similarity3DTransform(Transform):
def __init__(self):
"""3D similarity transform"""
def SetScale(self, scale: float):
"""Set uniform scaling factor"""
def GetScale(self) -> float:
"""Get scaling factor"""
def SetRotation(self, versor: tuple):
"""Set rotation using versor"""
def GetVersor(self) -> tuple:
"""Get versor representation"""
def SetTranslation(self, translation: tuple):
"""Set translation vector"""
def GetTranslation(self) -> tuple:
"""Get translation vector"""
def SetCenter(self, center: tuple):
"""Set center of transformation"""
def GetCenter(self) -> tuple:
"""Get center of transformation"""
class ScaleVersor3DTransform(Transform):
def __init__(self):
"""3D transform with non-uniform scaling and versor rotation"""
def SetScale(self, scale: tuple):
"""
Set non-uniform scaling factors.
Args:
scale: Scaling factors for (x, y, z) axes
"""
def GetScale(self) -> tuple:
"""Get scaling factors"""
def SetRotation(self, versor: tuple):
"""Set rotation using versor"""
def GetVersor(self) -> tuple:
"""Get versor representation"""
def SetTranslation(self, translation: tuple):
"""Set translation vector"""
def GetTranslation(self) -> tuple:
"""Get translation vector"""
def SetCenter(self, center: tuple):
"""Set center of transformation"""
def GetCenter(self) -> tuple:
"""Get center of transformation"""Affine Transform
General linear transformation including scaling, shearing, rotation, and translation.
class AffineTransform(Transform):
def __init__(self, dimension: int = 3):
"""
Initialize affine transform.
Args:
dimension: Spatial dimension (2 or 3)
"""
def SetMatrix(self, matrix: tuple):
"""
Set transformation matrix (without translation).
Args:
matrix: Matrix elements as flat tuple (row-major order)
"""
def GetMatrix(self) -> tuple:
"""Get transformation matrix"""
def SetTranslation(self, translation: tuple):
"""Set translation vector"""
def GetTranslation(self) -> tuple:
"""Get translation vector"""
def SetCenter(self, center: tuple):
"""Set center of transformation"""
def GetCenter(self) -> tuple:
"""Get center of transformation"""
def Translate(self, offset: tuple):
"""Apply additional translation"""
def Scale(self, factor: float, pre: bool = False):
"""
Apply uniform scaling.
Args:
factor: Scaling factor
pre: Apply before (True) or after (False) current transform
"""
def Rotate2D(self, angle: float, pre: bool = False):
"""Apply 2D rotation (2D transforms only)"""
def Rotate3D(self, axis: tuple, angle: float, pre: bool = False):
"""Apply 3D rotation around axis (3D transforms only)"""
def Shear(self, axis1: int, axis2: int, coeff: float, pre: bool = False):
"""
Apply shearing transformation.
Args:
axis1: First axis index
axis2: Second axis index
coeff: Shearing coefficient
pre: Apply before (True) or after (False) current transform
"""Scale Transform
Non-uniform scaling transformation.
class ScaleTransform(Transform):
def __init__(self, dimension: int = 3):
"""
Initialize scale transform.
Args:
dimension: Spatial dimension (2 or 3)
"""
def SetScale(self, scale: tuple):
"""
Set scaling factors for each axis.
Args:
scale: Scaling factors as tuple
"""
def GetScale(self) -> tuple:
"""Get scaling factors"""
def SetCenter(self, center: tuple):
"""Set center of scaling"""
def GetCenter(self) -> tuple:
"""Get center of scaling"""Deformable Transforms
Non-linear transformations for complex deformations.
class BSplineTransform(Transform):
def __init__(self, dimension: int = 3, splineOrder: int = 3):
"""
Initialize B-spline deformable transform.
Args:
dimension: Spatial dimension (2 or 3)
splineOrder: B-spline order (typically 3 for cubic)
"""
def SetTransformDomainOrigin(self, origin: tuple):
"""Set origin of transform domain"""
def GetTransformDomainOrigin(self) -> tuple:
"""Get origin of transform domain"""
def SetTransformDomainPhysicalDimensions(self, dimensions: tuple):
"""Set physical size of transform domain"""
def GetTransformDomainPhysicalDimensions(self) -> tuple:
"""Get physical size of transform domain"""
def SetTransformDomainMeshSize(self, meshSize: tuple):
"""
Set mesh size (number of control points - 1).
Args:
meshSize: Mesh size in each dimension
"""
def GetTransformDomainMeshSize(self) -> tuple:
"""Get mesh size"""
def SetTransformDomainDirection(self, direction: tuple):
"""Set direction matrix of transform domain"""
def GetTransformDomainDirection(self) -> tuple:
"""Get direction matrix of transform domain"""
def GetCoefficientImages(self) -> list:
"""
Get coefficient images as list of Image objects.
Returns:
List of coefficient images (one per dimension)
"""
def SetCoefficientImages(self, images: list):
"""
Set coefficient images.
Args:
images: List of coefficient images (one per dimension)
"""
class DisplacementFieldTransform(Transform):
def __init__(self, dimension: int = 3):
"""
Initialize displacement field transform.
Args:
dimension: Spatial dimension (2 or 3)
"""
def SetDisplacementField(self, field: Image):
"""
Set displacement field image.
Args:
field: Vector image containing displacement vectors
"""
def GetDisplacementField(self) -> Image:
"""Get displacement field image"""
def SetInverseDisplacementField(self, field: Image):
"""Set inverse displacement field for inverse transforms"""
def GetInverseDisplacementField(self) -> Image:
"""Get inverse displacement field"""
def SetInterpolator(self, interpolator: int):
"""Set interpolation method for field sampling"""
def GetInterpolator(self) -> int:
"""Get interpolation method"""Transform I/O
Functions for reading and writing transforms to/from files.
def ReadTransform(filename: str) -> Transform:
"""
Read transform from file.
Args:
filename: Path to transform file (.txt, .tfm, .h5, .mat)
Returns:
Transform object
"""
def WriteTransform(transform: Transform, filename: str):
"""
Write transform to file.
Args:
transform: Transform object to write
filename: Output file path
"""Transform Composition
Combine multiple transforms into composite transformations.
class CompositeTransform(Transform):
def __init__(self, dimension: int = 3):
"""
Initialize composite transform.
Args:
dimension: Spatial dimension
"""
def AddTransform(self, transform: Transform):
"""
Add transform to composition.
Args:
transform: Transform to add (applied last)
"""
def GetNumberOfTransforms(self) -> int:
"""Get number of transforms in composition"""
def GetNthTransform(self, n: int) -> Transform:
"""
Get nth transform in composition.
Args:
n: Transform index (0-based)
Returns:
Transform at index n
"""
def RemoveTransform(self):
"""Remove last transform from composition"""
def ClearTransformQueue(self):
"""Remove all transforms from composition"""
def FlattenTransformQueue(self) -> Transform:
"""
Flatten composition into equivalent single transform if possible.
Returns:
Flattened transform or composite if flattening not possible
"""Usage Examples
Basic Transform Operations
import SimpleITK as sitk
# Create 3D translation
translation = sitk.TranslationTransform(3)
translation.SetOffset([10.0, 5.0, -2.0])
# Transform a point
point = [100.0, 150.0, 75.0]
transformed_point = translation.TransformPoint(point)
print(f"Original: {point}")
print(f"Transformed: {transformed_point}")
# Get inverse transform
inverse_translation = translation.GetInverse()
back_to_original = inverse_translation.TransformPoint(transformed_point)
print(f"Back to original: {back_to_original}")Rigid Transform Setup
import SimpleITK as sitk
import math
# Create 3D rigid transform
rigid = sitk.Euler3DTransform()
# Set center of rotation to image center
image_center = [128.0, 128.0, 64.0]
rigid.SetCenter(image_center)
# Set rotation (45 degrees around Z-axis)
rigid.SetRotation(0.0, 0.0, math.pi/4)
# Set translation
rigid.SetTranslation([10.0, -5.0, 0.0])
print(f"Parameters: {rigid.GetParameters()}")
print(f"Fixed parameters: {rigid.GetFixedParameters()}")Affine Transform with Operations
import SimpleITK as sitk
import math
# Create 2D affine transform
affine = sitk.AffineTransform(2)
# Set center
affine.SetCenter([128.0, 128.0])
# Apply transformations in sequence
affine.Scale(1.2) # Scale by 20%
affine.Rotate2D(math.pi/6) # Rotate 30 degrees
affine.Translate([10.0, -5.0]) # Translate
# Check final parameters
print(f"Matrix: {affine.GetMatrix()}")
print(f"Translation: {affine.GetTranslation()}")B-spline Deformable Transform
import SimpleITK as sitk
# Read reference image to define transform domain
reference_image = sitk.ReadImage('reference.nii')
# Create B-spline transform
bspline = sitk.BSplineTransform(3, 3) # 3D, cubic B-splines
# Set transform domain from reference image
bspline.SetTransformDomainOrigin(reference_image.GetOrigin())
bspline.SetTransformDomainPhysicalDimensions(
[reference_image.GetSize()[i] * reference_image.GetSpacing()[i]
for i in range(3)]
)
bspline.SetTransformDomainDirection(reference_image.GetDirection())
# Set mesh size (controls resolution of deformation)
mesh_size = [8, 8, 8] # 9x9x9 control points
bspline.SetTransformDomainMeshSize(mesh_size)
# Initialize with small random deformations
import random
num_params = bspline.GetNumberOfParameters()
params = [random.uniform(-2.0, 2.0) for _ in range(num_params)]
bspline.SetParameters(params)
print(f"B-spline parameters: {num_params}")
print(f"Mesh size: {bspline.GetTransformDomainMeshSize()}")Transform Composition
import SimpleITK as sitk
# Create individual transforms
translation = sitk.TranslationTransform(3)
translation.SetOffset([10.0, 0.0, 0.0])
rotation = sitk.Euler3DTransform()
rotation.SetCenter([128.0, 128.0, 64.0])
rotation.SetRotation(0.0, 0.0, 0.5) # Rotate around Z
scaling = sitk.ScaleTransform(3)
scaling.SetScale([1.2, 1.2, 1.0])
scaling.SetCenter([128.0, 128.0, 64.0])
# Compose transforms (applied in reverse order)
composite = sitk.CompositeTransform(3)
composite.AddTransform(translation) # Applied first
composite.AddTransform(rotation) # Applied second
composite.AddTransform(scaling) # Applied third
# Test composition
point = [100.0, 100.0, 50.0]
result = composite.TransformPoint(point)
print(f"Composite result: {result}")
# Alternative: apply individually to verify
temp1 = translation.TransformPoint(point)
temp2 = rotation.TransformPoint(temp1)
temp3 = scaling.TransformPoint(temp2)
print(f"Manual composition: {temp3}")Transform File I/O
import SimpleITK as sitk
# Create and configure transform
transform = sitk.Similarity3DTransform()
transform.SetScale(1.1)
transform.SetCenter([128.0, 128.0, 64.0])
transform.SetRotation([0.1, 0.0, 0.0, 0.995]) # Small rotation
transform.SetTranslation([5.0, -2.0, 1.0])
# Write transform to file
sitk.WriteTransform(transform, 'my_transform.tfm')
# Read transform back
loaded_transform = sitk.ReadTransform('my_transform.tfm')
# Verify they're equivalent
test_point = [100.0, 150.0, 75.0]
original_result = transform.TransformPoint(test_point)
loaded_result = loaded_transform.TransformPoint(test_point)
print(f"Original: {original_result}")
print(f"Loaded: {loaded_result}")
print(f"Difference: {[abs(a-b) for a,b in zip(original_result, loaded_result)]}")Install with Tessl CLI
npx tessl i tessl/cmake-simpleitk@1.2.2