itkVariationalRegistrationMultiResolutionFilter.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 itkVariationalRegistrationMultiResolutionFilter_h
#define itkVariationalRegistrationMultiResolutionFilter_h

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

namespace itk
{
template< typename TFixedImage, typename TMovingImage, typename TDisplacementField, typename  TRealType = float>
class VariationalRegistrationMultiResolutionFilter :
    public ImageToImageFilter< TDisplacementField, TDisplacementField >
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(VariationalRegistrationMultiResolutionFilter);

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

  itkNewMacro(Self);

  itkTypeMacro( VariationalRegistrationMultiResolutionFilter, 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 MaskImagePixelType = unsigned char;
  using MaskImageType = Image< MaskImagePixelType, ImageDimension >;
  using MaskImagePointer = typename MaskImageType::Pointer;
  using MaskImageConstPointer = typename MaskImageType::ConstPointer;

  using FloatImageType = Image< TRealType, itkGetStaticConstMacro(ImageDimension) >;

  using RegistrationType = VariationalRegistrationFilter< FixedImageType, MovingImageType, DisplacementFieldType >;
  using RegistrationPointer = typename RegistrationType::Pointer;

  using DefaultRegistrationType = VariationalRegistrationFilter< FixedImageType, MovingImageType, DisplacementFieldType >;

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

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

  using MaskImagePyramidType = MultiResolutionPyramidImageFilter< FloatImageType, FloatImageType >;
  using MaskImagePyramidPointer = typename MaskImagePyramidType::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(void) const;

  virtual void SetMovingImage( const MovingImageType * ptr );

  const MovingImageType * GetMovingImage(void) const;

  void SetMaskImage( const MaskImageType * ptr );

  const MaskImageType * GetMaskImage(void) const;

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

  const DisplacementFieldType * GetInitialField(void)
      { return this->GetInput(); }

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

  itkGetModifiableObjectMacro( DisplacementField, DisplacementFieldType );

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

  itkSetObjectMacro( RegistrationFilter, RegistrationType );

  itkGetConstObjectMacro( RegistrationFilter, RegistrationType );

  itkSetObjectMacro( FixedImagePyramid, FixedImagePyramidType );

  itkGetConstObjectMacro( FixedImagePyramid, FixedImagePyramidType );

  itkSetObjectMacro( MovingImagePyramid, MovingImagePyramidType );

  itkGetConstObjectMacro( MovingImagePyramid, MovingImagePyramidType );

  itkSetObjectMacro( MaskImagePyramid, MaskImagePyramidType );

  itkGetConstObjectMacro( MaskImagePyramid, MaskImagePyramidType );

  virtual void SetNumberOfLevels( unsigned int num );

  itkGetConstReferenceMacro( NumberOfLevels, unsigned int );

  itkGetConstReferenceMacro( ElapsedLevels, unsigned int );

  itkSetMacro( NumberOfIterations, NumberOfIterationsType );

  itkSetVectorMacro( NumberOfIterations, unsigned int, m_NumberOfLevels );

  itkGetConstReferenceMacro( NumberOfIterations, NumberOfIterationsType );

  itkSetObjectMacro( FieldExpander, FieldExpanderType );

  itkGetConstObjectMacro( FieldExpander, FieldExpanderType );

  virtual void StopRegistration();

protected:
  VariationalRegistrationMultiResolutionFilter();
  ~VariationalRegistrationMultiResolutionFilter() override {}

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

private:
  RegistrationPointer        m_RegistrationFilter;
  FixedImagePyramidPointer   m_FixedImagePyramid;
  MovingImagePyramidPointer  m_MovingImagePyramid;
  MaskImagePyramidPointer    m_MaskImagePyramid;
  FieldExpanderPointer       m_FieldExpander;
  DisplacementFieldPointer   m_DisplacementField;

  unsigned int               m_NumberOfLevels;
  unsigned int               m_ElapsedLevels;
  NumberOfIterationsType     m_NumberOfIterations;

  bool                       m_StopRegistrationFlag;
};

} // end namespace itk

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


#endif