itkMultiResolutionPDEDeformableRegistration.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMultiResolutionPDEDeformableRegistration.h,v $
  Language:  C++
  Date:      $Date: 2009-01-26 21:45:51 $
  Version:   $Revision: 1.33 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkMultiResolutionPDEDeformableRegistration_h
#define __itkMultiResolutionPDEDeformableRegistration_h

#include "itkImage.h"
#include "itkImageToImageFilter.h"
#include "itkPDEDeformableRegistrationFilter.h"
#include "itkDemonsRegistrationFilter.h"
#include "itkMultiResolutionPyramidImageFilter.h"
#include "itkVectorResampleImageFilter.h"

#include <vector>

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

  typedef MultiResolutionPDEDeformableRegistration Self;
  typedef ImageToImageFilter<TDeformationField, TDeformationField>
                                                   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 TDeformationField                      DeformationFieldType;
  typedef typename DeformationFieldType::Pointer DeformationFieldPointer;

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

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

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

  typedef DemonsRegistrationFilter<
    FloatImageType, FloatImageType, DeformationFieldType > DefaultRegistrationType;

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

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

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

  virtual void SetFixedImage( const FixedImageType * ptr );

  const FixedImageType * GetFixedImage(void) const;

  virtual void SetMovingImage( const MovingImageType * ptr );

  const MovingImageType * GetMovingImage(void) const;

  virtual void SetInitialDeformationField( DeformationFieldType * ptr )
    {
    this->m_InitialDeformationField=ptr;
    }

  virtual void SetArbitraryInitialDeformationField( DeformationFieldType * ptr )
    {
    this->SetInput( ptr ); 
    }

  const DeformationFieldType * GetDeformationField(void)
  { return this->GetOutput(); }

  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 );

  itkSetVectorMacro( NumberOfIterations, unsigned int, m_NumberOfLevels );

  itkSetObjectMacro( FieldExpander, FieldExpanderType );

  itkGetObjectMacro( FieldExpander, FieldExpanderType );

  virtual const unsigned int * GetNumberOfIterations() const
  { return &(m_NumberOfIterations[0]); }

  virtual void StopRegistration();

protected:
  MultiResolutionPDEDeformableRegistration();
  ~MultiResolutionPDEDeformableRegistration() {}
  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();

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;
  DeformationFieldPointer    m_InitialDeformationField;

  unsigned int               m_NumberOfLevels;
  unsigned int               m_CurrentLevel;
  std::vector<unsigned int>  m_NumberOfIterations;

  bool                      m_StopRegistrationFlag;

};


} // end namespace itk

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


#endif