itkMultiResolutionPDEDeformableRegistration.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 __itkMultiResolutionPDEDeformableRegistration_h
#define __itkMultiResolutionPDEDeformableRegistration_h

#include "itkImage.h"
#include "itkDemonsRegistrationFilter.h"
#include "itkMultiResolutionPyramidImageFilter.h"
#include "itkVectorResampleImageFilter.h"
#include "itkArray.h"

namespace itk
{
template< class TFixedImage, class TMovingImage, class TDisplacementField, class TRealType = float >
class ITK_EXPORT MultiResolutionPDEDeformableRegistration:
  public ImageToImageFilter< TDisplacementField, TDisplacementField >
{
public:

  typedef MultiResolutionPDEDeformableRegistration Self;
  typedef ImageToImageFilter< TDisplacementField, TDisplacementField >
  Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(MultiResolutionPDEDeformableRegistration,
               ImageToImageFilter);

  typedef TFixedImage                           FixedImageType;
  typedef typename FixedImageType::Pointer      FixedImagePointer;
  typedef typename FixedImageType::ConstPointer FixedImageConstPointer;

  typedef TMovingImage                           MovingImageType;
  typedef typename MovingImageType::Pointer      MovingImagePointer;
  typedef typename MovingImageType::ConstPointer MovingImageConstPointer;

  typedef TDisplacementField                      DisplacementFieldType;
  typedef typename DisplacementFieldType::Pointer DisplacementFieldPointer;
#ifdef ITKV3_COMPATIBILITY
  typedef TDisplacementField                      DeformationFieldType;
  typedef typename DeformationFieldType::Pointer  DeformationFieldPointer;
#endif

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

  typedef Image< TRealType, itkGetStaticConstMacro(ImageDimension) > FloatImageType;

  typedef PDEDeformableRegistrationFilter< FloatImageType, FloatImageType, DisplacementFieldType > RegistrationType;
  typedef typename RegistrationType::Pointer                                                      RegistrationPointer;

  typedef DemonsRegistrationFilter< FloatImageType, FloatImageType, DisplacementFieldType > DefaultRegistrationType;

  typedef MultiResolutionPyramidImageFilter< FixedImageType, FloatImageType > FixedImagePyramidType;
  typedef typename FixedImagePyramidType::Pointer                             FixedImagePyramidPointer;

  typedef MultiResolutionPyramidImageFilter< MovingImageType, FloatImageType > MovingImagePyramidType;
  typedef typename MovingImagePyramidType::Pointer                             MovingImagePyramidPointer;

  typedef VectorResampleImageFilter< DisplacementFieldType, DisplacementFieldType > FieldExpanderType;
  typedef typename FieldExpanderType::Pointer                                     FieldExpanderPointer;

  typedef Array< unsigned int > NumberOfIterationsType;

  virtual void SetFixedImage(const FixedImageType *ptr);

  const FixedImageType * GetFixedImage(void) const;

  virtual void SetMovingImage(const MovingImageType *ptr);

  const MovingImageType * GetMovingImage(void) const;

  virtual void SetInitialDisplacementField(DisplacementFieldType *ptr)
  {
    this->m_InitialDisplacementField = ptr;
  }

  virtual void SetArbitraryInitialDisplacementField(DisplacementFieldType *ptr)
  {
    this->SetInput(ptr);
  }

  const DisplacementFieldType * GetDisplacementField(void)
  { return this->GetOutput(); }

#ifdef ITKV3_COMPATIBILITY
  virtual void SetInitialDeformationField(DisplacementFieldType *ptr)
  {
    this->SetInitialDisplacementField(ptr);
  }

  virtual void SetArbitraryInitialDeformationField(DisplacementFieldType *ptr)
  {
    this->SetArbitraryInitialDisplacementField(ptr);
  }

  const DeformationFieldType * GetDeformationField(void)
  {
    return static_cast<DeformationFieldType *> (this->GetDisplacementField());
  }
#endif

  virtual std::vector< SmartPointer< DataObject > >::size_type GetNumberOfValidRequiredInputs() const;

  itkSetObjectMacro(RegistrationFilter, RegistrationType);

  itkGetObjectMacro(RegistrationFilter, RegistrationType);

  itkSetObjectMacro(FixedImagePyramid, FixedImagePyramidType);

  itkGetObjectMacro(FixedImagePyramid, FixedImagePyramidType);

  itkSetObjectMacro(MovingImagePyramid, MovingImagePyramidType);

  itkGetObjectMacro(MovingImagePyramid, MovingImagePyramidType);

  virtual void SetNumberOfLevels(unsigned int num);

  itkGetConstReferenceMacro(NumberOfLevels, unsigned int);

  itkGetConstReferenceMacro(CurrentLevel, unsigned int);

  itkSetObjectMacro(FieldExpander, FieldExpanderType);

  itkGetObjectMacro(FieldExpander, FieldExpanderType);

  itkSetMacro(NumberOfIterations, NumberOfIterationsType);
  itkSetVectorMacro(NumberOfIterations, unsigned int, m_NumberOfLevels);

  itkGetConstReferenceMacro(NumberOfIterations, NumberOfIterationsType);

  virtual void StopRegistration();

protected:
  MultiResolutionPDEDeformableRegistration();
  // ~MultiResolutionPDEDeformableRegistration() {} default implementation ok

  void PrintSelf(std::ostream & os, Indent indent) const;

  virtual void GenerateData();

  virtual void GenerateInputRequestedRegion();

  virtual void GenerateOutputInformation();

  virtual void EnlargeOutputRequestedRegion(DataObject *ptr);

  virtual bool Halt();

  virtual void VerifyInputInformation() {}

private:
  MultiResolutionPDEDeformableRegistration(const Self &); //purposely not
                                                          // implemented
  void operator=(const Self &);                           //purposely not

  // implemented

  RegistrationPointer       m_RegistrationFilter;
  FixedImagePyramidPointer  m_FixedImagePyramid;
  MovingImagePyramidPointer m_MovingImagePyramid;
  FieldExpanderPointer      m_FieldExpander;
  DisplacementFieldPointer  m_InitialDisplacementField;

  unsigned int                m_NumberOfLevels;
  unsigned int                m_CurrentLevel;
  NumberOfIterationsType      m_NumberOfIterations;

  bool m_StopRegistrationFlag;
};
} // end namespace itk

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

#endif