itkImageRegistrationMethodv4.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkImageRegistrationMethodv4_h
#define __itkImageRegistrationMethodv4_h

#include "itkProcessObject.h"

#include "itkAffineTransform.h"
#include "itkCompositeTransform.h"
#include "itkDataObjectDecorator.h"
#include "itkObjectToObjectOptimizerBase.h"
#include "itkImageToImageMetricv4.h"
#include "itkInterpolateImageFunction.h"
#include "itkTransform.h"
#include "itkTransformParametersAdaptor.h"

#include <vector>

namespace itk
{

template<typename TFixedImage, typename TMovingImage, typename TTransform =
  AffineTransform<double, GetImageDimension<TFixedImage>::ImageDimension> >
class ITK_EXPORT ImageRegistrationMethodv4
:public ProcessObject
{
public:
  typedef ImageRegistrationMethodv4                 Self;
  typedef ProcessObject                             Superclass;
  typedef SmartPointer<Self>                        Pointer;
  typedef SmartPointer<const Self>                  ConstPointer;

  itkNewMacro( Self );

  itkStaticConstMacro( ImageDimension, unsigned int, TFixedImage::ImageDimension );

  itkTypeMacro( ImageRegistrationMethodv4, ProcessObject );

  typedef TFixedImage                                                 FixedImageType;
  typedef typename FixedImageType::Pointer                            FixedImagePointer;
  typedef TMovingImage                                                MovingImageType;
  typedef typename MovingImageType::Pointer                           MovingImagePointer;

  typedef ImageToImageMetricv4<FixedImageType, MovingImageType>       MetricType;
  typedef typename MetricType::Pointer                                MetricPointer;

  typedef TTransform                                                  TransformType;
  typedef typename TransformType::Pointer                             TransformPointer;
  typedef typename TransformType::ScalarType                          RealType;
  typedef typename TransformType::DerivativeType                      DerivativeType;
  typedef typename DerivativeType::ValueType                          DerivativeValueType;

  typedef CompositeTransform<RealType, ImageDimension>                CompositeTransformType;
  typedef typename CompositeTransformType::Pointer                    CompositeTransformPointer;

  typedef DataObjectDecorator<TransformType>                          TransformOutputType;
  typedef typename TransformOutputType::Pointer                       TransformOutputPointer;

  typedef Array<SizeValueType>                                        ShrinkFactorsArrayType;
  typedef Array<RealType>                                             SmoothingSigmasArrayType;

  typedef InterpolateImageFunction<FixedImageType, RealType>          FixedInterpolatorType;
  typedef typename FixedInterpolatorType::Pointer                     FixedInterpolatorPointer;
  typedef InterpolateImageFunction<MovingImageType, RealType>         MovingInterpolatorType;
  typedef typename MovingInterpolatorType::Pointer                    MovingInterpolatorPointer;

  typedef TransformParametersAdaptor<TransformType>                   TransformParametersAdaptorType;
  typedef typename TransformParametersAdaptorType::Pointer            TransformParametersAdaptorPointer;
  typedef std::vector<TransformParametersAdaptorPointer>              TransformParametersAdaptorsContainerType;

  typedef ObjectToObjectOptimizerBase                                 OptimizerType;
  typedef typename OptimizerType::Pointer                             OptimizerPointer;

  enum MetricSamplingStrategyType { NONE, REGULAR, RANDOM };

  typedef typename MetricType::FixedSampledPointSetType               MetricSamplePointSetType;


  itkSetInputMacro( FixedImage, FixedImageType );
  itkGetInputMacro( FixedImage, FixedImageType );

  itkSetInputMacro( MovingImage, MovingImageType );
  itkGetInputMacro( MovingImage, MovingImageType );

  itkSetObjectMacro( FixedInterpolator, FixedInterpolatorType );
  itkGetConstObjectMacro( FixedInterpolator, FixedInterpolatorType );

  itkSetObjectMacro( MovingInterpolator, MovingInterpolatorType );
  itkGetConstObjectMacro( MovingInterpolator, MovingInterpolatorType );

  itkSetObjectMacro( Metric, MetricType );
  itkGetObjectMacro( Metric, MetricType );

  itkSetMacro( MetricSamplingStrategy, MetricSamplingStrategyType );
  itkGetConstMacro( MetricSamplingStrategy, MetricSamplingStrategyType );

  itkSetClampMacro( MetricSamplingPercentage, RealType, 0.0, 1.0 );
  itkGetConstMacro( MetricSamplingPercentage, RealType );

  itkSetObjectMacro( Transform, TransformType );
  itkGetObjectMacro( Transform, TransformType );

  itkSetObjectMacro( Optimizer, OptimizerType );
  itkGetObjectMacro( Optimizer, OptimizerType );

  itkSetObjectMacro( CompositeTransform, CompositeTransformType );
  itkGetObjectMacro( CompositeTransform, CompositeTransformType );

  void SetTransformParametersAdaptorsPerLevel( TransformParametersAdaptorsContainerType & );
  const TransformParametersAdaptorsContainerType & GetTransformParametersAdaptorsPerLevel() const;

  void SetNumberOfLevels( const SizeValueType );
  itkGetConstMacro( NumberOfLevels, SizeValueType );

  itkSetMacro( ShrinkFactorsPerLevel, ShrinkFactorsArrayType );
  itkGetConstMacro( ShrinkFactorsPerLevel, ShrinkFactorsArrayType );

  itkSetMacro( SmoothingSigmasPerLevel, SmoothingSigmasArrayType );
  itkGetConstMacro( SmoothingSigmasPerLevel, SmoothingSigmasArrayType );

  void StartRegistration() { this->GenerateData(); }

  typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
  using Superclass::MakeOutput;
  virtual DataObjectPointer MakeOutput( DataObjectPointerArraySizeType );

  virtual const TransformOutputType * GetOutput() const;

  itkGetConstMacro( CurrentLevel, SizeValueType );

protected:
  ImageRegistrationMethodv4();
  virtual ~ImageRegistrationMethodv4();
  virtual void PrintSelf( std::ostream & os, Indent indent ) const;

  virtual void  GenerateData();

  virtual void InitializeRegistrationAtEachLevel( const SizeValueType );

  virtual void SetMetricSamplePoints();

  SizeValueType                                                   m_CurrentLevel;
  SizeValueType                                                   m_NumberOfLevels;

  MovingImagePointer                                              m_MovingSmoothImage;
  FixedImagePointer                                               m_FixedSmoothImage;

  FixedInterpolatorPointer                                        m_FixedInterpolator;
  MovingInterpolatorPointer                                       m_MovingInterpolator;

  OptimizerPointer                                                m_Optimizer;

  MetricPointer                                                   m_Metric;
  MetricSamplingStrategyType                                      m_MetricSamplingStrategy;
  RealType                                                        m_MetricSamplingPercentage;

  ShrinkFactorsArrayType                                          m_ShrinkFactorsPerLevel;
  SmoothingSigmasArrayType                                        m_SmoothingSigmasPerLevel;

  TransformParametersAdaptorsContainerType                        m_TransformParametersAdaptorsPerLevel;

  CompositeTransformPointer                                       m_CompositeTransform;

  TransformPointer                                                m_Transform;

private:
  ImageRegistrationMethodv4( const Self & );   //purposely not implemented
  void operator=( const Self & );                  //purposely not implemented
};
} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkImageRegistrationMethodv4.hxx"
#endif

#endif