Scalismo

You can compose two transformations $t_O$ and $t_I$ to create a CompositeTransformation representing $t_O(t_I(x))$.

• Use CompositeTransformation(t1, t2) for standard composition.
• Use CompositeDifferentiableTransformation(t1, t2) if the resulting transformation must be differentiable with respect to position.

To compose multiple spaces, use ProductTransformationSpace or ProductTransformationSpaceWithDifferentiableTransforms. This allows you to generate a single composite transformation from a single concatenated parameter vector.

// Basic composition
val rotationThenTranslation = CompositeTransformation(translation, rotation)

// Composition that preserves position differentiability
val rotationThenTranslationDifferentiable = CompositeDifferentiableTransformation(translation, rotation)

// Composing spaces
val compositeSpace = ProductTransformationSpace(TranslationSpace3D, RotationSpace3D(Point3D(0, 0, 0)))
val ct : CompositeTransformation[_3D, Translation, Rotation] = compositeSpace.transformationForParameters(DenseVector(0.0, 0.0, 0.0, 0.0, 0.0, 0.0))

To move between discrete and continuous representations:

Continuous Representation (Interpolation)

Use the .interpolate method on a discrete image and provide an interpolator (e.g., BSplineImageInterpolator3D). This returns a Field defined on all points within the image's bounding box.

Discrete Representation (Discretization)

To convert a continuous Field back into a discrete image, use the .discretize method. You must provide a new DiscreteImageDomain and an outsideValue to be assigned to points that fall outside the continuous field's domain.

// 1. Interpolate: Discrete -> Continuous
val continuousImage: Field[_3D, Short] = image.interpolate(BSplineImageInterpolator3D(degree = 3))

// 2. Discretize: Continuous -> Discrete
val newDomain = DiscreteImageDomain3D(image.domain.boundingBox, size = IntVector(32, 32, 32))
val resampledImage: DiscreteImage[_3D, Short] = continuousImage.discretize(newDomain, outsideValue = 0.toShort)

The StructuredPoints[D] class defines a set of points in $D$ dimensions aligned on a regular grid. The grid is defined by an origin, a spacing (distance between points in mm), and a size (number of points in each direction). This is useful for representing discrete image domains or regular sampling grids.

Key capabilities include:

• Mapping between grid indices (IntVector[D]) and physical coordinates (Point[D]).
• Mapping between a unique PointId and physical coordinates.
• Finding the closest grid point to an arbitrary physical point.
• Determining if a physical point belongs to the grid.
• Calculating the boundingBox of the grid.

// Example of the conceptual interface
val points: StructuredPoints[_2D] = StructuredPoints(origin, spacing, size)
val physicalPt = points.indexToPoint(IntVector(10, 20))
val closest = points.findClosestPoint(someArbitraryPoint)
val id = points.pointId(physicalPt)

A Transformation[D] is a function that maps points from a domain $D \subset \mathbb{R}^d$ to other points in $\mathbb{R}^d$. You can create a transformation by specifying a function f : Point[D] => Point[D] and its domain. If no domain is specified, the transformation is assumed to be defined on the entire EuclideanSpace.

ParametricTransformations are a subclass of transformations defined by a finite set of parameters (e.g., a translation vector or Euler angles).

import scalismo.common._
import scalismo.geometry._
import scalismo.transformations._

// Creating a transformation with an explicit domain
val domain : Domain[_3D] = EuclideanSpace[_3D]
val myTransform = Transformation3D(domain, p => p + EuclideanVector3D(1, 0, 0))

// Creating a parametric transformation (Translation)
val translation = Translation3D(EuclideanVector3D(1, 3, 0.5))

// Creating a parametric transformation (Rotation with center)
val rotation = Rotation3D(0, 0.1, 0.3, Point3D(0, 0, 0))

All ParametricTransformations are differentiable with respect to their parameters. Additionally, transformations can be made invertible or differentiable with respect to their position in space by implementing specific traits:

• Invertibility: Implement CanInvert[D, T] to access the .inverse method.
• Position Differentiation: Implement CanDifferentiateWRTPosition[D] to access the .derivativeWRTPosition method (which returns a function from a Point to a SquareMatrix).

// Inverting a transformation
val tInvertible : Transformation[_3D] with CanInvert[_3D, Transformation] = Translation3D(EuclideanVector3D(1, 0, 0))
val tinv : Translation[_3D] = tInvertible.inverse

// Getting the derivative with respect to position
val tDifferentiable : Transformation[_3D] with CanDifferentiateWRTPosition[_3D] = Translation3D(EuclideanVector3D(1, 0, 0))
val tDerivative : Point[_3D] => SquareMatrix[_3D] = tDifferentiable.derivativeWRTPosition