Image Registration

Rigid and non-rigid registration of images. More...

Collaboration diagram for Image Registration:

Detailed Description

Rigid and non-rigid registration of images.

Simplified sequence diagram of the ImageRegistration algorithm.

Abstract Image Registration

The AbstractImageRegistration class is the most common interface for all registration types. It consists only of the two images that should be registered and a view common methods that need to be implemented. The registration is expected to always modify the transformation/deformation of the second image. The reference method returns the image that will be iterated during the registration, which will be either image1 or image2. The reset method should restore the transformation to the state it was when the registration was created. If the registration uses a non-linear transformation isDeformable should return true.

The ImFusion SDK comes with a range of predefined AbstractImageRegistration implementations which will either modify the matrix or the deformation of a ShaderImageSet. These class can also be used as base for sophisticated registration, e.g. one could derive a LinearImageRegistration and add additional regularization to the evaluate method.

Parametric Image Registration

The registration algorithms in this category use a discrete set of parameters for the transformation and derive from ParametricImageRegistration. For example a rigid transformation is represented by a translation vector and three rotation angles. The ParametricImageRegistration base class extends the AbstractImageRegistration interface with the basic components of such a registration: an optimizer and a similarity measure. Derived classes only need to implement the evaluate method which receives the parameters of the optimization and returns the energy for these parameters.

The following diagram shows how the different components of the ParametricImageRegistration work together to find the optimal transformation.

When compute is called the ParametricImageRegistration base class will instance the SimilarityMeasureImpl and the Optimizer. Subsequently it will execute the optimizer. The number of parameters is determined by the dimension of the optimizer.

The optimizer uses the derived class as a cost function for its optimization and will call the evaluate method repeatedly. The evaluate method in the derived class will reinterpret the parameters to fit the transformation model and apply the new transformation to image2. For example a rigid registration would receive 6 double values which are interpreted as a 3 component translation and a 3 component rotation, converted to a 4x4 matrix and subsequently set as the matrix of image2.

Beside setting the new transformation requested by the optimizer, the evaluate method is also expected to return a value estimating the similarity between the two images with the new transformation. This value is computed by a SimilarityMeasureImpl, which is a abstract interface to different kind of measures (see similarity). Each similarity measure requires an ImageTransformer to convert from coordinates in one image to coordinates in the other image. A default transformer is already created in compute and can be used by derived classes.

Summarized, the evaluate method assembles the parameters, applies the parameters to the image and returns a new similarity value for the new transformation. Once the optimizer has found the optimal solution, it will call evaluate a last time with the optimal parameters, i.e. the last applied transformation will be the final registration result. The evaluate method of a rigid linear registration, for example, would be similar to the following code:

double evaluate(int n, const double* x, double* /*dx*/)
{
    // assemble the rigid matrix from the parameters
    mat4 transformation = Pose::eulerToMat(x);
    // apply the new transformation to the image
    m_image2->setMatrix(transformation);
    // return the new similarity
    return m_sm->compute(m_transformer);
}

Currently there are three implementations of ParametricImageRegistration: LinearImageRegistration for rigid or affine transformations, FFDImageRegistration for non-linear deformable registration using Free-Form Deformations (FFD) and TPSImageRegistration for non-linear deformable registration using Thin-Plate splines (TPS).

Demons Image Registration

The DemonsImageRegistration class provides a dense deformable registration.

(Semi-Automatic) Image Registration

The previous registration algorithms only provide the most basic features for the registration and do not perform any automatic processing on the images. The ImageRegistration algorithm on the other hand is a high-level abstraction for these registration algorithms. It wraps a AbstractImageRegistration and allows the user to switch between different registration algorithms without closing and re-opening the algorithm. The more technical aspects are hidden and the algorithm tries to initialize all parameters with optimal default values depending on the image size, modality and so on. Additionally several means of pre-processing can be selected such as downsampling or gradient magnitude filtering as required by LC2. These pre-processing steps and the associated datasets are handled internally by the algorithm and the transformations will always be applied on the original datasets as well. The ImageRegistration class contains a factory that allows registering new AbstractImageRegistration implementations during runtime.

Classes
class	AbstractImageRegistration
	The AbstractImageRegistration class is an interface for all image-based registrations. More...
class	FFDImageRegistration
	Registers two images with a non-linear deformation based on FFDs. More...
class	GatedLinear4DImageRegistration
	Registers two volume clips using a rigid/affine transformation, including a gating phase offset between the two. More...
class	ImageRegistration
	High-level interface for image registration. More...
class	ImageSequenceRegistration
	Registers a SharedImageSet of multiple images. More...
class	LinearGridRegistration
	Registers a set of images arranged in a 2D grid. More...
class	LinearImageRegistration
	Registers two images using a rigid/affine transformation. More...
class	ParametricDeformableRegistration
	Registers two images with a non-linear deformation based on TPSs. More...
class	ParametricImageRegistration
	Base class for parametric image registration algorithms. More...
class	PolyRigidDeformationAlgorithm
	Set up a poly-rigid deformation on a volume and multiple labels. More...
class	PolyRigidImageRegistration
	Registers two images with a non-linear poly-rigid deformation. More...
class	RegistrationInitAlgorithm
	Initialize the registration of two volumes by moving the second one. More...
class	RegistrationResultsAlgorithm
	Store registration results for data combinations. More...
class	RegistrationResultsController
	GUI controller managing registration results. More...