itkLogDomainDeformableRegistrationFilter.h

Go to the documentation of this file.

#ifndef __itkLogDomainDeformableRegistrationFilter_h
#define __itkLogDomainDeformableRegistrationFilter_h

#include "itkDenseFiniteDifferenceImageFilter.h"
#include "itkExponentialDeformationFieldImageFilter2.h"
#include "itkPDEDeformableRegistrationFunction.h"

namespace itk
{
template< class TFixedImage, class TMovingImage, class TField >
class ITK_EXPORT LogDomainDeformableRegistrationFilter:
  public DenseFiniteDifferenceImageFilter< TField, TField >
{
public:
  typedef LogDomainDeformableRegistrationFilter              Self;
  typedef DenseFiniteDifferenceImageFilter< TField, TField > Superclass;
  typedef SmartPointer< Self >                               Pointer;
  typedef SmartPointer< const Self >                         ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(LogDomainDeformableRegistrationFilter,
               DenseFiniteDifferenceImageFilter);

  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 TField                              VelocityFieldType;
  typedef typename VelocityFieldType::Pointer VelocityFieldPointer;

  typedef TField                                 DeformationFieldType;
  typedef typename DeformationFieldType::Pointer DeformationFieldPointer;

  typedef typename Superclass::OutputImageType OutputImageType;

  typedef typename Superclass::FiniteDifferenceFunctionType
  FiniteDifferenceFunctionType;

  typedef PDEDeformableRegistrationFunction< FixedImageType, MovingImageType,
                                             DeformationFieldType >
  PDEDeformableRegistrationFunctionType;

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

  void SetFixedImage(const FixedImageType *ptr);

  const FixedImageType * GetFixedImage(void) const;

  void SetMovingImage(const MovingImageType *ptr);

  const MovingImageType * GetMovingImage(void) const;

  void SetInitialVelocityField(VelocityFieldType *ptr)
  { this->SetInput(ptr); }

  VelocityFieldType * GetVelocityField() { return this->GetOutput(); }

  DeformationFieldPointer GetDeformationField();

  DeformationFieldPointer GetInverseDeformationField();

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

  itkSetMacro(SmoothVelocityField, bool);
  itkGetConstMacro(SmoothVelocityField, bool);
  itkBooleanMacro(SmoothVelocityField);

  itkSetVectorMacro(StandardDeviations, double, ImageDimension);
  virtual void SetStandardDeviations(double value);

  const double * GetStandardDeviations(void) const
  { return static_cast< const double * >( m_StandardDeviations ); }

  itkSetMacro(SmoothUpdateField, bool);
  itkGetConstMacro(SmoothUpdateField, bool);
  itkBooleanMacro(SmoothUpdateField);

  itkSetVectorMacro(UpdateFieldStandardDeviations, double, ImageDimension);
  virtual void SetUpdateFieldStandardDeviations(double value);

  const double * GetUpdateFieldStandardDeviations(void) const
  { return static_cast< const double * >( m_UpdateFieldStandardDeviations ); }

  virtual void StopRegistration()
  {
    m_StopRegistrationFlag = true;
  }

  itkSetMacro(MaximumError, double);
  itkGetConstMacro(MaximumError, double);

  itkSetMacro(MaximumKernelWidth, unsigned int);
  itkGetConstMacro(MaximumKernelWidth, unsigned int);

  virtual double GetMetric() const { return 0; }
protected:
  LogDomainDeformableRegistrationFilter();
  ~LogDomainDeformableRegistrationFilter() {}
  void PrintSelf(std::ostream & os, Indent indent) const;

  typedef ExponentialDeformationFieldImageFilter2<
    VelocityFieldType, DeformationFieldType >      FieldExponentiatorType;

  typedef typename FieldExponentiatorType::Pointer FieldExponentiatorPointer;

  itkSetObjectMacro(Exponentiator, FieldExponentiatorType);
  itkGetObjectMacro(Exponentiator, FieldExponentiatorType);

  virtual bool Halt()
  {
    if ( m_StopRegistrationFlag )
      {
      return true;
      }

    return this->Superclass::Halt();
  }

  virtual void CopyInputToOutput();

  virtual void InitializeIteration();

  virtual void SmoothVelocityField();

  virtual void SmoothUpdateField();

  virtual void SmoothGivenField(VelocityFieldType *field, const double StandardDeviations[ImageDimension]);

  virtual void PostProcessOutput();

  virtual void Initialize();

  virtual void GenerateOutputInformation();

  virtual void GenerateInputRequestedRegion();

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

  // implemented

  double m_StandardDeviations[ImageDimension];
  double m_UpdateFieldStandardDeviations[ImageDimension];

  bool m_SmoothVelocityField;
  bool m_SmoothUpdateField;

  VelocityFieldPointer m_TempField;

  double m_MaximumError;

  unsigned int m_MaximumKernelWidth;

  bool m_StopRegistrationFlag;

  FieldExponentiatorPointer m_Exponentiator;
  FieldExponentiatorPointer m_InverseExponentiator;
};
} // end namespace itk

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

#endif