[Insight-developers] Registration classes

[Luis Ibanez]

Hi,

We checked in some classes that could support a full
hierarchy for registration. They are described in 
"RegisrationArchitecture.doc" in the repository's 
Document directory.

The basic class is called:

      RegistrationMethod

It is intended to support registration of any kind
of objects, no only images.

It groups the basic elements of a registration
problem:

 - a RegistrationMetric to evaluate the match between 
   the objects to be registered (target and reference)

 - a RegistrationTransformation that defines how the 
   reference object will be mapped on top of the target

-  a RegistrationMapper that having access to the 
   transformation will pass information back and forth 
   between the reference and target space. Eventually 
   doing some interpolation on the way.
   
-  an RegistrationOptimizer that search for the optimum
   transformation.
 

The Optimizer is expected to be only a light wrapper of an
already existing optimization class. The first candidates
to wrap are the vxl algorithms:

   vnl_nonlinear_minimizer (the generic api)
   vnl_conjugate_gradient
   vnl_levenberg_marquardt
   vnl_amoeba
   
and then, some genetic (or evolutionary) algorithms.


The optimizer's search space is the one defined by the
transformation parameters. That allows to separate the 
implementation of the transformation from its definition.
For example a 2D rigid transformation can be implemented
as a 3x3 matrix in homogeneous coordinates, but it is 
defined by just three numbers (parameters) that represent:
( rotation, translation x, translation y).


The Metric will evaluate how much the transformed reference 
match the target objet. Possible Metrics to implement are:

   Intensity Correlation (for images)
   Intensity based Mutual Information
   Intensity Squared differences (for images)
   Sum of squared distances (for point sets)
   

On the same spirit, the RegistrationTransformation will be
a light wrap for geometric transformations, like the already
existing itkAffineTransform. It just add some mechanism to
standarize the passing of parameters to the optimization
method. Some transformations to consider are:

   Rigid 
   Similarity 
   Affine
   Thin Plate Spline (defined by landmarks)
   Flow 


The basic objects can be used to derive from them, or can 
just be used as examples of what elements the type should
have.


Some examples of how this code will look like when used
in a real registration problem are in the Testing directory,
they compile on Linux and VC++. (There are actualy not 
doing any thing different than checking that all the types
are coherent).  They are:

      itkRegistrationImageToImageAffine.cxx
      itkRegistrationModelToImage.cxx
      itkRegistrationPoints3D2DAffine.cxx
      itkRegistrationProcrustes.cxx


-----


Thanks


Luis


-- 
-----------------------------------------------------------
Luis Ibanez
Research Assistant Professor - Division of NeuroSurgery
University of North Carolina at Chapel Hill
Chapel Hill, NC, 27599   http://www.cs.un.edu/~ibanez
------------------------------------------------------------