itkImageRegistrationFilter.h

Go to the documentation of this file.

/*=============================================================================

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

=============================================================================*/

#ifndef itkImageRegistrationFilter_h
#define itkImageRegistrationFilter_h


#include <itkImageToImageFilter.h>

#include <itkCastImageFilter.h>
#include <itkResampleImageFilter.h>
#include <itkSingleResolutionImageRegistrationMethod.h>
#include <itkMultiResolutionImageRegistrationWrapper.h>
#include <itkImageRegistrationFactory.h>
#include <itkAbsImageFilter.h>

namespace itk
{
template <typename TInputImageType, typename TOutputImageType, unsigned int Dimension, class TScalarType, typename TDeformationScalar, typename TPyramidFilter = RecursiveMultiResolutionPyramidImageFilter< TInputImageType, TInputImageType > >
class ITK_EXPORT ImageRegistrationFilter : public ImageToImageFilter< TInputImageType, TOutputImageType > 
{
  public:

    typedef ImageRegistrationFilter                                        Self;
    typedef ImageToImageFilter< TInputImageType, TOutputImageType >        Superclass;
    typedef SmartPointer<Self>                                             Pointer;
    typedef SmartPointer<const Self>                                       ConstPointer;

    itkNewMacro(Self);

    itkTypeMacro(ImageRegistrationFilter, ImageToImageFilter);

    typedef typename TInputImageType::PixelType                            InputPixelType;    
    typedef typename TInputImageType::Pointer                              InputImagePointer;
    typedef typename TInputImageType::ConstPointer                         InputImageConstPointer;

    typedef itk::MultiResolutionImageRegistrationWrapper<TInputImageType, TPyramidFilter>  MultiResolutionRegistrationType;
    typedef typename MultiResolutionRegistrationType::Pointer              MultiResolutionRegistrationPointer;
    typedef typename MultiResolutionRegistrationType::SingleResType        SingleResType;
    typedef typename SingleResType::TransformType                          TransformType;
    typedef itk::ImageRegistrationFactory<TInputImageType, Dimension, 
                                                           TScalarType>    ImageRegistrationFactoryType;
    typedef typename ImageRegistrationFactoryType::Pointer                 ImageRegistrationFactoryPointer;
    
    typedef itk::InterpolateImageFunction< TInputImageType, TScalarType >  InterpolatorType;
    typedef typename InterpolatorType::Pointer                             InterpolatorPointer;
    typedef itk::ResampleImageFilter<TInputImageType, TInputImageType >    ResampleFilterType;
    typedef typename ResampleFilterType::Pointer                           ResampleFilterPointer;
    typedef itk::AbsImageFilter<TInputImageType, TInputImageType >         AbsImageFilterType;
    typedef itk::CastImageFilter<TInputImageType, TOutputImageType >       CastToOutputFilterType;
    typedef typename CastToOutputFilterType::Pointer                       CastToOutputFilterPointer;
    
    typedef itk::FluidDeformableTransform<TInputImageType, TScalarType, Dimension, TDeformationScalar > FluidDeformableTransformType;
    
    itkSetObjectMacro( MultiResolutionRegistrationMethod, MultiResolutionRegistrationType );
    itkGetObjectMacro( MultiResolutionRegistrationMethod, MultiResolutionRegistrationType );

    itkSetObjectMacro( Interpolator, InterpolatorType );
    itkGetObjectMacro( Interpolator, InterpolatorType );

    void SetFixedImage(InputImagePointer fixedImage) { this->SetInput(0, fixedImage); }

    void SetMovingImage(InputImagePointer  movingImage) { this->m_MovingImage =  movingImage; }

    void SetFixedMask(InputImagePointer fixedMask) {this->SetInput(1, fixedMask); }

    void SetMovingMask(InputImagePointer movingMask) { this->m_MovingMask = movingMask; }

    itkSetMacro(DoReslicing, bool);
    itkGetMacro(DoReslicing, bool);
    
    itkSetMacro(IsOutputAbsIntensity, bool); 
    itkGetMacro(IsOutputAbsIntensity, bool); 
    
    itkSetMacro(IsotropicVoxelSize, double); 
    itkGetMacro(IsotropicVoxelSize, double); 
    
    itkSetMacro(ResampleImageInterpolation, InterpolationTypeEnum); 
    itkGetMacro(ResampleImageInterpolation, InterpolationTypeEnum); 
    
    itkSetMacro(ResampleMaskInterpolation, InterpolationTypeEnum); 
    itkGetMacro(ResampleMaskInterpolation, InterpolationTypeEnum); 
    
    itkSetMacro(ResampledMovingImagePadValue, InputPixelType);
    itkGetMacro(ResampledMovingImagePadValue, InputPixelType);

    itkSetMacro(ResampledFixedImagePadValue, InputPixelType);
    itkGetMacro(ResampledFixedImagePadValue, InputPixelType);

    InputImagePointer ResampleToVoxelSize(const TInputImageType* image, const InputPixelType defaultPixelValue, InterpolationTypeEnum interpolation, typename TInputImageType::SpacingType voxelSize); 

  protected:

    ImageRegistrationFilter();
    virtual ~ImageRegistrationFilter() {};
    void PrintSelf(std::ostream& os, Indent indent) const;

    void GenerateData();

    virtual void Initialize();
    
    ImageRegistrationFactoryPointer m_ImageRegistrationFactory;

    CastToOutputFilterPointer m_FinalCaster;

    ResampleFilterPointer m_FinalResampler;

    InterpolatorPointer m_Interpolator;
    
    MultiResolutionRegistrationPointer m_MultiResolutionRegistrationMethod;
    
    typename AbsImageFilterType::Pointer m_AbsImageFilter; 
    
    typename TInputImageType::ConstPointer m_ResampledFixedImage; 
    
    typename TInputImageType::ConstPointer m_ResampledMovingImage; 
    
    typename TInputImageType::ConstPointer m_ResampledFixedMask; 
    
    typename TInputImageType::ConstPointer m_ResampledMovingMask; 
    
    InterpolationTypeEnum m_ResampleImageInterpolation;
        
    InterpolationTypeEnum m_ResampleMaskInterpolation;
    
  private:
    
    ImageRegistrationFilter(const Self&); // purposefully not implemented
    void operator=(const Self&);          // purposefully not implemented
    
    InputImagePointer m_MovingImage; 
    
    InputImagePointer m_MovingMask; 

    InputPixelType m_ResampledMovingImagePadValue;
    
    InputPixelType m_ResampledFixedImagePadValue;
    
    bool m_DoReslicing;
    
    bool m_IsOutputAbsIntensity; 
    
    double m_IsotropicVoxelSize; 
    
};
  
} // end namespace itk


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

#endif