itkImageRegistrationFactory.h

Go to the documentation of this file.

/*=============================================================================

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

=============================================================================*/

#ifndef itkImageRegistrationFactory_h
#define itkImageRegistrationFactory_h

#include <itkProcessObject.h>
#include <itkConstantBoundaryCondition.h>
#include <itkWindowedSincInterpolateImageFunction.h>

// Interpolators.
#include <itkInterpolateImageFunction.h>
#include <itkLinearInterpolateImageFunction.h>
#include <itkNearestNeighborInterpolateImageFunction.h>
#include <itkBSplineInterpolateImageFunction.h>

// Similarity Measures
#include <itkSimilarityMeasure.h>
#include <itkMSDImageToImageMetric.h>
#include <itkNCCImageToImageMetric.h>
#include <itkSSDImageToImageMetric.h>
#include <itkSADImageToImageMetric.h>
#include <itkRIUImageToImageMetric.h>
#include <itkPIUImageToImageMetric.h>
#include <itkJEImageToImageMetric.h>
#include <itkMIImageToImageMetric.h>
#include <itkNMIImageToImageMetric.h>
#include <itkCRImageToImageMetric.h>

// Transformations
#include <itkTransform.h>
#include <itkPerspectiveProjectionTransform.h>
#include <itkEulerAffineTransform.h>
#include <itkUCLBSplineTransform.h>
#include <itkFluidDeformableTransform.h>
#include <itkAffineTransform.h>
#include <itkPCADeformationModelTransform.h>
#include <itkTranslationPCADeformationModelTransform.h>

// Optimizers
#include <itkSingleValuedNonLinearOptimizer.h>
#include <itkGradientDescentOptimizer.h>
#include <itkUCLSimplexOptimizer.h>
#include <itkUCLRegularStepGradientDescentOptimizer.h>
#include <itkConjugateGradientOptimizer.h>
#include <itkPowellOptimizer.h>
#include <itkUCLRegularStepOptimizer.h>
#include <itkUCLPowellOptimizer.h>

// Commands
#include <itkIterationUpdateCommand.h>
#include <itkVnlIterationUpdateCommand.h>

// Registration methods.
#include <itkSingleResolutionImageRegistrationMethod.h>
#include <itkMaskedImageRegistrationMethod.h>
#include <itkTranslationThenRotationImageRegistrationMethod.h>
#include <itkTranslateRotateScaleImageRegistrationMethod.h>
#include <itkRigidPlusScaleImageRegistrationMethod.h>
#include <itkBlockMatchingMethod.h>

// Multi-resolution methods
#include <itkMultiResolutionImageRegistrationWrapper.h>

namespace itk
{

enum 
InterpolationTypeEnum
{
  UNKNOWN_INTERP,
  NEAREST,
  LINEAR,
  BSPLINE,
  SINC 
};

enum 
MetricTypeEnum
{
  UNKNOWN_METRIC,
  SSD,            // Sum of Squared Differences
  MSD,            // Mean of Squared Differences
  SAD,            // Sum of Absolute Differences
  NCC,            // Normalized Cross Correlation
  RIU,            // Woods Ratio Image Uniformity
  PIU,            // Woods Partitioned Image Uniformity
  JE,             // Joint Entropy
  MI,             // Mutual information
  NMI,            // Normalized Mutual Information
  CR              // Correlation Ratio
};

enum
TransformTypeEnum
{
  UNKNOWN_TRANSFORM,
  TRANSLATION,    // Mainly for testing.
  RIGID,          // Rigid, so rotations and translations, 3DOF in 2D and 6DOF in 3D.
  RIGID_SCALE,    // Rigid plus scale, 5DOF in 2D, 9DOF in 3D.
  AFFINE          // Affine. 7DOF in 2D, 12DOF in 3D.
};

enum
OptimizerTypeEnum
{
  UNKNOWN_OPTIMIZER,
  SIMPLEX,                    // For when you dont trust, or don't have derivative.
  GRADIENT_DESCENT,           // Standard gradient descent.
  REGSTEP_GRADIENT_DESCENT,   // Regular step size gradient descent.
  CONJUGATE_GRADIENT_DESCENT, // Conjugate gradients.
  POWELL,                     // also, doesnt require derivative.
  SIMPLE_REGSTEP,             // Simple multi-regular step in each direction.
  UCLPOWELL
};

enum
SingleResRegistrationMethodTypeEnum
{
  UNKNOWN_METHOD,
  SINGLE_RES_MASKED,             // The 'default' method, simply optimises transform wrt metric.
  SINGLE_RES_TRANS_ROTATE,       // Switching method, just does rigid, but alternates translation and rotation
  SINGLE_RES_TRANS_ROTATE_SCALE, // Switching method, separately does translation, rotation and scale
  SINGLE_RES_RIGID_SCALE,        // Switching method, alternates rigid, and then scale.
  SINGLE_RES_BLOCK_MATCH
};

enum
MultiResRegistrationMethodTypeEnum
{
  UNKNOWN_MULTI,
  MULTI_RES_NORMAL
};
template <typename TInputImageType, unsigned int Dimension, class TScalarType>
class ITK_EXPORT ImageRegistrationFactory : public Object 
{
public:
  
  typedef ImageRegistrationFactory  Self;
  typedef Object                    Superclass;
  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkNewMacro(Self);
  
  itkTypeMacro(ImageRegistrationFactory, Object);

  typedef typename TInputImageType::PixelType                                       InputPixelType;
  
  typedef itk::IterationUpdateCommand                                               IterationUpdateCommandType;
  typedef itk::VnlIterationUpdateCommand                                            VnlIterationUpdateCommandType;

  typedef itk::InterpolateImageFunction< TInputImageType, TScalarType>                InterpolatorType;
  typedef itk::NearestNeighborInterpolateImageFunction< TInputImageType, TScalarType> NearestNeighbourInterpolatorType;
  typedef itk::LinearInterpolateImageFunction< TInputImageType, TScalarType >         LinearInterpolatorType;
  typedef itk::BSplineInterpolateImageFunction< TInputImageType, TScalarType >        BSplineInterpolatorType;

  typedef itk::ConstantBoundaryCondition< TInputImageType >                         BoundaryConditionType;
  const static unsigned int                                                         WindowRadius = 5;
  typedef itk::Function::WelchWindowFunction<WindowRadius>  WindowFunctionType;
  typedef itk::WindowedSincInterpolateImageFunction<
                                          TInputImageType,
                                          WindowRadius,
                                          WindowFunctionType,
                                          BoundaryConditionType,
                                          TScalarType  >                            SincInterpolatorType;
                                          
  typedef itk::SimilarityMeasure<TInputImageType, TInputImageType>                  MetricType;
  typedef itk::SSDImageToImageMetric<TInputImageType, TInputImageType >             SSDMetricType;
  typedef itk::MSDImageToImageMetric<TInputImageType, TInputImageType >             MSDMetricType;
  typedef itk::NCCImageToImageMetric<TInputImageType, TInputImageType >             NCCMetricType;  
  typedef itk::SADImageToImageMetric<TInputImageType, TInputImageType >             SADMetricType;    
  typedef itk::RIUImageToImageMetric<TInputImageType, TInputImageType >             RIUMetricType;  
  typedef itk::PIUImageToImageMetric<TInputImageType, TInputImageType >             PIUMetricType;
  typedef itk::JEImageToImageMetric<TInputImageType, TInputImageType >              JEMetricType;
  typedef itk::MIImageToImageMetric<TInputImageType, TInputImageType >              MIMetricType;
  typedef itk::NMIImageToImageMetric<TInputImageType, TInputImageType >             NMIMetricType;
  typedef itk::CRImageToImageMetric<TInputImageType, TInputImageType >              CRMetricType;

  typedef itk::Transform< TScalarType, Dimension, Dimension >                           TransformType;
  typedef itk::PerspectiveProjectionTransform<TScalarType>                              PerspectiveProjectionTransformType;
  typedef itk::EulerAffineTransform<TScalarType, Dimension, Dimension>                  EulerAffineTransformType;
  typedef itk::UCLBSplineTransform<TInputImageType, TScalarType, Dimension, float>      BSplineDeformableTransformType; 
  typedef itk::FluidDeformableTransform<TInputImageType, TScalarType, Dimension, float> FluidDeformableTransformType;
  typedef itk::AffineTransform<TScalarType, Dimension>                                  ITKAffineTransformType;
  typedef itk::PCADeformationModelTransform<TScalarType, Dimension>                     PCADeformationModelTransformType;
  typedef itk::TranslationPCADeformationModelTransform<TScalarType, Dimension>          TranslationPCADeformationModelTransformType;

  typedef itk::SingleValuedNonLinearOptimizer                           OptimizerType;
  typedef itk::UCLSimplexOptimizer                                      SimplexType;
  typedef SimplexType*                                                  SimplexPointer;
  typedef itk::GradientDescentOptimizer                                 GradientDescentType;
  typedef GradientDescentType*                                          GradientDescentPointer;
  typedef itk::UCLRegularStepGradientDescentOptimizer                   RegularStepGradientDescentType;
  typedef RegularStepGradientDescentType*                               RegularStepGradientDescentPointer;
  typedef itk::ConjugateGradientOptimizer                               ConjugateGradientType;
  typedef ConjugateGradientType*                                        ConjugateGradientPointer;
  typedef itk::PowellOptimizer                                          PowellOptimizerType;
  typedef PowellOptimizerType*                                          PowellOptimizerPointer;
  typedef itk::UCLRegularStepOptimizer                                  UCLRegularStepOptimizerType;
  typedef UCLRegularStepOptimizerType*                                  UCLRegularStepOptimizerTypePointer;
  typedef itk::UCLPowellOptimizer                                       UCLPowellOptimizerType;
  typedef UCLPowellOptimizerType*                                          UCLPowellOptimizerPointer;
  
  typedef itk::MaskedImageRegistrationMethod<TInputImageType>                  SingleResRegistrationType;
  typedef itk::TranslationThenRotationImageRegistrationMethod<TInputImageType> TranslationThenRotationRegistrationType;
  typedef itk::TranslateRotateScaleImageRegistrationMethod<TInputImageType>    TranslateRotateScaleRegistrationType;
  typedef itk::RigidPlusScaleImageRegistrationMethod<TInputImageType>          RigidPlusScaleRegistrationType;
  typedef itk::BlockMatchingMethod<TInputImageType, TScalarType>               BlockMatchingRegistrationType;

  typedef itk::MultiResolutionImageRegistrationWrapper
                                                      <TInputImageType> MultiResRegistrationType;
  
  virtual typename SingleResRegistrationType::Pointer CreateSingleResRegistration(SingleResRegistrationMethodTypeEnum type);

  virtual typename MultiResRegistrationType::Pointer CreateMultiResRegistration(MultiResRegistrationMethodTypeEnum type);

  virtual typename InterpolatorType::Pointer CreateInterpolator(InterpolationTypeEnum type);

  virtual typename MetricType::Pointer CreateMetric(MetricTypeEnum type);
        
  virtual typename TransformType::Pointer CreateTransform(TransformTypeEnum type);
  
  virtual typename TransformType::Pointer CreateTransform(std::string transfomFilename); 

  virtual typename OptimizerType::Pointer CreateOptimizer(OptimizerTypeEnum optimizerType);
  
  virtual typename IterationUpdateCommandType::Pointer CreateIterationUpdateCommand(OptimizerTypeEnum optimizerType);
  
protected:

  ImageRegistrationFactory();
  virtual ~ImageRegistrationFactory() {};
  void PrintSelf(std::ostream& os, Indent indent) const override;

private:
  ImageRegistrationFactory(const Self&); // purposefully not implemented
  void operator=(const Self&);           // purposefully not implemented
        
};
  
} // end namespace


#ifndef ITK_MANUAL_INSTANTIATION
#include "itkImageRegistrationFactory.txx"
#endif

#endif