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< typename TFixedImage, typename TMovingImage, typename TDisplacementField, typename TRealType = float >
class ITK_TEMPLATE_EXPORT MultiResolutionPDEDeformableRegistration:
  public ImageToImageFilter< TDisplacementField, TDisplacementField >
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(MultiResolutionPDEDeformableRegistration);

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

  itkNewMacro(Self);

  itkTypeMacro(MultiResolutionPDEDeformableRegistration,
               ImageToImageFilter);

  using FixedImageType = TFixedImage;
  using FixedImagePointer = typename FixedImageType::Pointer;
  using FixedImageConstPointer = typename FixedImageType::ConstPointer;

  using MovingImageType = TMovingImage;
  using MovingImagePointer = typename MovingImageType::Pointer;
  using MovingImageConstPointer = typename MovingImageType::ConstPointer;

  using DisplacementFieldType = TDisplacementField;
  using DisplacementFieldPointer = typename DisplacementFieldType::Pointer;

  static constexpr unsigned int ImageDimension = FixedImageType::ImageDimension;

  using FloatImageType = Image< TRealType, Self::ImageDimension >;

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

  using DefaultRegistrationType = DemonsRegistrationFilter< FloatImageType, FloatImageType, DisplacementFieldType >;

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

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

  using FieldExpanderType = VectorResampleImageFilter< DisplacementFieldType, DisplacementFieldType >;
  using FieldExpanderPointer = typename FieldExpanderType::Pointer;

  using NumberOfIterationsType = Array< unsigned int >;

  virtual void SetFixedImage(const FixedImageType *ptr);

  const FixedImageType * GetFixedImage() const;

  virtual void SetMovingImage(const MovingImageType *ptr);

  const MovingImageType * GetMovingImage() const;

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

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

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

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

  itkSetObjectMacro(RegistrationFilter, RegistrationType);
  itkGetModifiableObjectMacro(RegistrationFilter, RegistrationType);

  itkSetObjectMacro(FixedImagePyramid, FixedImagePyramidType);
  itkGetModifiableObjectMacro(FixedImagePyramid, FixedImagePyramidType);

  itkSetObjectMacro(MovingImagePyramid, MovingImagePyramidType);
  itkGetModifiableObjectMacro(MovingImagePyramid, MovingImagePyramidType);

  virtual void SetNumberOfLevels(unsigned int num);

  itkGetConstReferenceMacro(NumberOfLevels, unsigned int);

  itkGetConstReferenceMacro(CurrentLevel, unsigned int);

  itkSetObjectMacro(FieldExpander, FieldExpanderType);
  itkGetModifiableObjectMacro(FieldExpander, FieldExpanderType);

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

  itkGetConstReferenceMacro(NumberOfIterations, NumberOfIterationsType);

  virtual void StopRegistration();

protected:
  MultiResolutionPDEDeformableRegistration();
  ~MultiResolutionPDEDeformableRegistration() override = default;

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

  void GenerateData() override;

  void GenerateInputRequestedRegion() override;

  void GenerateOutputInformation() override;

  void EnlargeOutputRequestedRegion(DataObject *ptr) override;

  virtual bool Halt();

  void VerifyInputInformation() ITKv5_CONST override {}

private:
  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