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< class TFixedImage, class TMovingImage, class TDisplacementField, class  TRealType = float>
class VariationalRegistrationMultiResolutionFilter :
    public ImageToImageFilter< TDisplacementField, TDisplacementField >
{
public:
  typedef VariationalRegistrationMultiResolutionFilter Self;
  typedef ImageToImageFilter< TDisplacementField, TDisplacementField >
                                                       Superclass;
  typedef SmartPointer< Self >                         Pointer;
  typedef SmartPointer< const Self >                   ConstPointer;

  itkNewMacro(Self);

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

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

  typedef unsigned char                               MaskImagePixelType;
  typedef Image< MaskImagePixelType, ImageDimension > MaskImageType;
  typedef typename MaskImageType::Pointer             MaskImagePointer;
  typedef typename MaskImageType::ConstPointer        MaskImageConstPointer;

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

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

  typedef VariationalRegistrationFilter< FixedImageType, MovingImageType, DisplacementFieldType >
                                                      DefaultRegistrationType;

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

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

  typedef MultiResolutionPyramidImageFilter< FloatImageType, FloatImageType >
                                                      MaskImagePyramidType;
  typedef typename MaskImagePyramidType::Pointer      MaskImagePyramidPointer;

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

  typedef Array< unsigned int >                       NumberOfIterationsType;

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

  virtual std::vector< SmartPointer<DataObject> >::size_type GetNumberOfValidRequiredInputs() const ITK_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() {}

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

  virtual void GenerateData() ITK_OVERRIDE;

  virtual void GenerateInputRequestedRegion() ITK_OVERRIDE;

  virtual void GenerateOutputInformation() ITK_OVERRIDE;

  virtual void EnlargeOutputRequestedRegion( DataObject *ptr ) ITK_OVERRIDE;

  virtual bool Halt();

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

  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