itkMultiResolutionImageRegistrationWrapper.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 itkMultiResolutionImageRegistrationWrapper_h
#define itkMultiResolutionImageRegistrationWrapper_h

#include <itkProcessObject.h>
#include <itkNumericTraits.h>
#include <itkDataObjectDecorator.h>
#include <itkImageToImageMetric.h>
#include <itkSingleValuedNonLinearOptimizer.h>
#include <itkRecursiveMultiResolutionPyramidImageFilter.h>
#include "itkMaskedImageRegistrationMethod.h"
#include <itkBinaryThresholdImageFilter.h>

namespace itk
{

template <typename TInputImageType, class TPyramidFilter = RecursiveMultiResolutionPyramidImageFilter< TInputImageType, TInputImageType > >
class ITK_EXPORT MultiResolutionImageRegistrationWrapper : public ProcessObject 
{
public:
  typedef MultiResolutionImageRegistrationWrapper  Self;
  typedef ProcessObject                            Superclass;
  typedef SmartPointer<Self>                       Pointer;
  typedef SmartPointer<const Self>                 ConstPointer;

  itkNewMacro(Self);
  
  itkTypeMacro(MultiResolutionImageRegistrationWrapper, ProcessObject);

  typedef MaskedImageRegistrationMethod<TInputImageType>                            SingleResType;
  typedef typename SingleResType::Pointer                                           SingleResPointer;

  typedef          TInputImageType                                                  InputImageType;
  typedef typename InputImageType::PixelType                                        InputImagePixelType;
  typedef typename InputImageType::Pointer                                          InputImagePointer;
  typedef typename InputImageType::ConstPointer                                     InputImageConstPointer;
  typedef typename InputImageType::RegionType                                       InputImageRegionType;

  typedef ImageToImageMetric< InputImageType, InputImageType >                      MetricType;
  typedef typename MetricType::Pointer                                              MetricPointer;

  typedef typename MetricType::TransformType                                        TransformType;
  typedef typename TransformType::Pointer                                           TransformPointer;

  typedef  DataObjectDecorator< TransformType >                                     TransformOutputType;
  typedef typename TransformOutputType::Pointer                                     TransformOutputPointer;
  typedef typename TransformOutputType::ConstPointer                                TransformOutputConstPointer;
  
  typedef typename MetricType::InterpolatorType                                     InterpolatorType;
  typedef typename InterpolatorType::Pointer                                        InterpolatorPointer;

  typedef SingleValuedNonLinearOptimizer                                            OptimizerType;

  typedef BinaryThresholdImageFilter<InputImageType, InputImageType>                ThresholdFilterType;
  typedef typename ThresholdFilterType::Pointer                                     ThresholdFilterPointer;

  typedef TPyramidFilter                                                               ImagePyramidType;
  typedef typename ImagePyramidType::Pointer                                           ImagePyramidPointer;
  typedef typename ImagePyramidType::ScheduleType                                      ImagePyramidScheduleType;
  
  typedef  typename MetricType::TransformParametersType ParametersType;

  typedef typename DataObject::Pointer DataObjectPointer;

  typedef typename ImagePyramidType::ScheduleType                                      ScheduleType;

  virtual void StartRegistration();

  virtual void StopRegistration();

  itkSetObjectMacro( SingleResMethod, SingleResType );
  itkGetObjectMacro( SingleResMethod, SingleResType );
  
  itkSetConstObjectMacro( FixedImage, InputImageType );
  itkGetConstObjectMacro( FixedImage, InputImageType ); 

  itkSetConstObjectMacro( FixedMask, InputImageType );
  itkGetConstObjectMacro( FixedMask, InputImageType ); 

  itkSetConstObjectMacro( MovingImage, InputImageType );
  itkGetConstObjectMacro( MovingImage, InputImageType );

  itkSetConstObjectMacro( MovingMask, InputImageType );
  itkGetConstObjectMacro( MovingMask, InputImageType );

  itkSetMacro( NumberOfLevels, unsigned int );
  itkGetMacro( NumberOfLevels, unsigned int );

  itkSetMacro ( StartLevel, unsigned int);
  itkGetMacro ( StartLevel, unsigned int);

  itkSetMacro ( StopLevel, unsigned int);
  itkGetMacro ( StopLevel, unsigned int);

  itkGetMacro( CurrentLevel, unsigned int );

  //itkSetMacro( InitialTransformParameters, ParametersType );
  //itkGetConstReferenceMacro( InitialTransformParameters, ParametersType );
  virtual void SetInitialTransformParameters(const ParametersType& parameters) 
  { 
    this->m_InitialTransformParametersOfNextLevel = parameters; 
  }
  virtual const ParametersType& GetInitialTransformParameters() const 
  {
    return this->m_InitialTransformParametersOfNextLevel; 
  }

  itkSetMacro( InitialTransformParametersOfNextLevel, ParametersType );
  itkGetConstReferenceMacro( InitialTransformParametersOfNextLevel, ParametersType );

  //itkGetConstReferenceMacro( LastTransformParameters, ParametersType );  
  virtual const ParametersType& GetLastTransformParameters() const
  {
    return this->m_SingleResMethod->GetLastTransformParameters(); 
  }

  const TransformOutputType * GetOutput() const;

  virtual DataObjectPointer MakeOutput(unsigned int idx);

  unsigned long GetMTime() const override;  
  
  ScheduleType* GetSchedule() { return m_Schedule;}
  void SetSchedule(ScheduleType* schedule) 
    { 
      this->m_Schedule = schedule;
      this->m_UserSpecifiedSchedule = true;
    } 

  itkSetMacro ( MaskBeforePyramid, bool);
  itkGetMacro ( MaskBeforePyramid, bool);
  
  itkSetMacro (UseOriginalImageAtFinalLevel, bool); 
  itkGetMacro (UseOriginalImageAtFinalLevel, bool); 

  itkSetMacro (IsAutoAdjustMovingSamping, bool);
  itkGetMacro (IsAutoAdjustMovingSamping, bool);

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

  void  GenerateData () override;

  virtual void PreparePyramids();
  
  virtual void Initialize() throw (ExceptionObject);

  virtual void BeforeSingleResolutionRegistration() {};

  virtual void AfterSingleResolutionRegistration() {};

  unsigned int                        m_NumberOfLevels;
  unsigned int                        m_StartLevel;  
  unsigned int                        m_StopLevel;
  unsigned int                        m_CurrentLevel;
  ParametersType                      m_InitialTransformParametersOfNextLevel;
  SingleResPointer                    m_SingleResMethod;
  
  bool                                m_UseOriginalImageAtFinalLevel; 
  bool                                m_UserSpecifiedSchedule;

  InputImageConstPointer              m_FixedImage;
  InputImageConstPointer              m_FixedMask;
  InputImageConstPointer              m_MovingImage;
  InputImageConstPointer              m_MovingMask;

  ImagePyramidPointer                 m_FixedImagePyramid;
  ImagePyramidPointer                 m_FixedMaskPyramid;  
  ImagePyramidPointer                 m_MovingImagePyramid;
  ImagePyramidPointer                 m_MovingMaskPyramid;
  
  ThresholdFilterPointer              m_FixedMaskThresholder;
  ThresholdFilterPointer              m_MovingMaskThresholder;
  
  bool                                m_Stop;
  
  ScheduleType*                       m_Schedule;
  
  bool                                m_MaskBeforePyramid;

  // Automatically adjust the sampling in moving image
  // depending on the resolution.
  bool                                m_IsAutoAdjustMovingSamping;
  
private:
  MultiResolutionImageRegistrationWrapper(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

};


} // end namespace itk


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

#endif