itkPDEDeformableRegistrationFilter.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 __itkPDEDeformableRegistrationFilter_h
#define __itkPDEDeformableRegistrationFilter_h

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

namespace itk
{
template< class TFixedImage, class TMovingImage, class TDisplacementField >
class ITK_EXPORT PDEDeformableRegistrationFilter:
  public DenseFiniteDifferenceImageFilter< TDisplacementField, TDisplacementField >
{
public:

  typedef PDEDeformableRegistrationFilter                                          Self;
  typedef DenseFiniteDifferenceImageFilter< TDisplacementField, TDisplacementField > Superclass;
  typedef SmartPointer< Self >                                                     Pointer;
  typedef SmartPointer< const Self >                                               ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(PDEDeformableRegistrationFilter,
               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 TDisplacementField                      DisplacementFieldType;
  typedef typename DisplacementFieldType::Pointer DisplacementFieldPointer;

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

  typedef typename Superclass::OutputImageType OutputImageType;

  typedef typename Superclass::FiniteDifferenceFunctionType
  FiniteDifferenceFunctionType;

  typedef PDEDeformableRegistrationFunction< FixedImageType, MovingImageType,
                                             DisplacementFieldType >  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 SetInitialDisplacementField(const DisplacementFieldType *ptr)
  { this->SetInput(ptr); }

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

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

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

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

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

#ifdef ITKV3_COMPATIBILITY
  virtual void SetSmoothDeformationField(bool val)
  {
    SetSmoothDisplacementField(val);
  }
  virtual bool GetSmoothDeformationField()
  {
    return this->GetSmoothDisplacementField();
  }
  virtual void SmoothDeformationFieldOn()
  {
    this->SmoothDisplacementFieldOn();
  }
  virtual void SmoothDeformationFieldOff()
  {
    this->SmoothDisplacementFieldOff();
  }
#endif

  typedef FixedArray< double, ImageDimension > StandardDeviationsType;

  itkSetMacro(StandardDeviations, StandardDeviationsType);
  virtual void SetStandardDeviations(double value);

  itkGetConstReferenceMacro(StandardDeviations, StandardDeviationsType);

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

  itkSetMacro(UpdateFieldStandardDeviations, StandardDeviationsType);
  virtual void SetUpdateFieldStandardDeviations(double value);

  itkGetConstReferenceMacro(UpdateFieldStandardDeviations, StandardDeviationsType);

  virtual void StopRegistration()
  { m_StopRegistrationFlag = true; }

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

  itkSetMacro(MaximumKernelWidth, unsigned int);
  itkGetConstMacro(MaximumKernelWidth, unsigned int);
protected:
  PDEDeformableRegistrationFilter();
  ~PDEDeformableRegistrationFilter() {}
  void PrintSelf(std::ostream & os, Indent indent) const;

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

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

  virtual void CopyInputToOutput();

  virtual void InitializeIteration();

  virtual void SmoothDisplacementField();
#ifdef ITKV3_COMPATIBILITY
  virtual void SmoothDeformationField()
  {
    this->SmoothDisplacementField();
  }
#endif

  virtual void SmoothUpdateField();

  virtual void PostProcessOutput();

  virtual void Initialize();

  virtual void GenerateOutputInformation();

  virtual void GenerateInputRequestedRegion();

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

  StandardDeviationsType m_StandardDeviations;
  StandardDeviationsType m_UpdateFieldStandardDeviations;

  bool m_SmoothDisplacementField;
  bool m_SmoothUpdateField;

  DisplacementFieldPointer m_TempField;
private:

  double m_MaximumError;

  unsigned int m_MaximumKernelWidth;

  bool m_StopRegistrationFlag;
};
} // end namespace itk

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

#endif