itkMaskedImageRegistrationMethod.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 itkMaskedImageRegistrationMethod_h
#define itkMaskedImageRegistrationMethod_h


#include "itkSingleResolutionImageRegistrationMethod.h"
#include <itkImageMaskSpatialObject.h>
#include <itkBinaryThresholdImageFilter.h>
#include <itkBinaryCrossStructuringElement.h>
#include <itkBinaryDilateImageFilter.h>
#include <itkCastImageFilter.h>
#include <itkSmoothingRecursiveGaussianImageFilter.h>
#include <itkBoundaryValueRescaleIntensityImageFilter.h>
#include <itkMultiplyImageFilter.h>

namespace itk
{

template <typename TInputImageType>
class ITK_EXPORT MaskedImageRegistrationMethod 
: public SingleResolutionImageRegistrationMethod<TInputImageType, TInputImageType> 
{
public:

  typedef MaskedImageRegistrationMethod                                             Self;
  typedef SingleResolutionImageRegistrationMethod<TInputImageType, TInputImageType> Superclass;
  typedef SmartPointer<Self>                                                        Pointer;
  typedef SmartPointer<const Self>                                                  ConstPointer;
  
  itkNewMacro(Self);
  
  itkTypeMacro(MaskedImageRegistrationMethod, SingleResolutionImageRegistrationMethod);

  typedef          TInputImageType                                                  InputImageType;
  typedef typename InputImageType::PixelType                                        InputImagePixelType;
  typedef typename InputImageType::Pointer                                          InputImagePointer;
  typedef typename InputImageType::ConstPointer                                     InputImageConstPointer;
  typedef typename InputImageType::RegionType                                       InputImageRegionType;
  typedef typename InputImageType::SizeType                                         InputImageSizeType;
  typedef typename InputImageType::IndexType                                        InputImageIndexType;
  typedef typename InputImageType::SpacingType                                      InputImageSpacingType;
  typedef typename InputImageType::PointType                                        InputImageOriginType;
  typedef typename InputImageType::DirectionType                                    InputImageDirectionType;

  void SetFixedMask( const InputImageType * fixedMask );
  itkGetConstObjectMacro( FixedMask, InputImageType ); 

  void SetMovingMask( const InputImageType * movingMask );
  itkGetConstObjectMacro( MovingMask, InputImageType );

  typedef BoundaryValueRescaleIntensityImageFilter<InputImageType>                  RescaleFilterType;
  typedef typename RescaleFilterType::Pointer                                       RescaleFilterPointer;
  
  typedef SmoothingRecursiveGaussianImageFilter<InputImageType, InputImageType >    SmoothingFilterType;
  typedef typename SmoothingFilterType::Pointer                                     SmoothingFilterPointer;
  
  typedef BinaryThresholdImageFilter<InputImageType, InputImageType>                ThresholdFilterType;
  typedef typename ThresholdFilterType::Pointer                                     ThresholdFilterPointer;
  
  typedef BinaryCrossStructuringElement<InputImagePixelType, 
                                        InputImageType::ImageDimension>             StructuringType;
  typedef BinaryDilateImageFilter<InputImageType, 
                                  InputImageType, 
                                  StructuringType>                                  DilateMaskFilterType;
  typedef typename DilateMaskFilterType::Pointer                                    DilateMaskFilterPointer;

  typedef MultiplyImageFilter<InputImageType, InputImageType>                       MultiplyFilterType;
  typedef typename MultiplyFilterType::Pointer                                      MultiplyFilterPointer;
  
  typedef unsigned char                                                             MaskPixelType;
  typedef Image<MaskPixelType, InputImageType::ImageDimension>                      MaskImageType;
  typedef CastImageFilter<InputImageType, MaskImageType >                           CastToMaskImageTypeFilterType;
  typedef typename CastToMaskImageTypeFilterType::Pointer                           CastToMaskImageTypeFilterPointer;
  typedef ImageMaskSpatialObject< InputImageType::ImageDimension >                  MaskFilterType;
  typedef typename MaskFilterType::Pointer                                          MaskFilterPointer;
  typedef typename Superclass::TransformType                                        TransformType;
  itkSetMacro( UseFixedMask, bool );
  itkGetConstMacro( UseFixedMask, bool );

  itkSetMacro( UseMovingMask, bool );
  itkGetConstMacro( UseMovingMask, bool );

  itkSetMacro( NumberOfDilations, unsigned int );
  itkGetMacro( NumberOfDilations, unsigned int );
  
  itkSetMacro( MaskImageDirectly, bool );
  itkGetMacro( MaskImageDirectly, bool );
  
  itkSetMacro( RescaleFixedImage, bool );
  itkGetConstMacro( RescaleFixedImage, bool );

  itkSetMacro( RescaleFixedMinimum, InputImagePixelType );
  itkGetConstMacro( RescaleFixedMinimum, InputImagePixelType );

  itkSetMacro( RescaleFixedMaximum, InputImagePixelType );
  itkGetConstMacro( RescaleFixedMaximum, InputImagePixelType );

  itkSetMacro( RescaleFixedBoundaryValue, InputImagePixelType );
  itkGetConstMacro( RescaleFixedBoundaryValue, InputImagePixelType );

  itkSetMacro( RescaleFixedLowerThreshold, InputImagePixelType );
  itkGetConstMacro( RescaleFixedLowerThreshold, InputImagePixelType );

  itkSetMacro( RescaleFixedUpperThreshold, InputImagePixelType );
  itkGetConstMacro( RescaleFixedUpperThreshold, InputImagePixelType );

  itkSetMacro( RescaleMovingImage, bool );
  itkGetConstMacro( RescaleMovingImage, bool );

  itkSetMacro( RescaleMovingMinimum, InputImagePixelType );
  itkGetConstMacro( RescaleMovingMinimum, InputImagePixelType );

  itkSetMacro( RescaleMovingMaximum, InputImagePixelType );
  itkGetConstMacro( RescaleMovingMaximum, InputImagePixelType );

  itkSetMacro( RescaleMovingBoundaryValue, InputImagePixelType );
  itkGetConstMacro( RescaleMovingBoundaryValue, InputImagePixelType );

  itkSetMacro( RescaleMovingLowerThreshold, InputImagePixelType );
  itkGetConstMacro( RescaleMovingLowerThreshold, InputImagePixelType );

  itkSetMacro( RescaleMovingUpperThreshold, InputImagePixelType );
  itkGetConstMacro( RescaleMovingUpperThreshold, InputImagePixelType );

  itkSetMacro( ThresholdFixedMask, bool );
  itkGetConstMacro( ThresholdFixedMask, bool );

  itkSetMacro( FixedMaskMinimum, InputImagePixelType );
  itkGetConstMacro( FixedMaskMinimum, InputImagePixelType );

  itkSetMacro( FixedMaskMaximum, InputImagePixelType );
  itkGetConstMacro( FixedMaskMaximum, InputImagePixelType );

  itkSetMacro( ThresholdMovingMask, bool );
  itkGetConstMacro( ThresholdMovingMask, bool );

  itkSetMacro( MovingMaskMinimum, InputImagePixelType );
  itkGetConstMacro( MovingMaskMinimum, InputImagePixelType );

  itkSetMacro( MovingMaskMaximum, InputImagePixelType );
  itkGetConstMacro( MovingMaskMaximum, InputImagePixelType );

  itkSetMacro( Sigma, float);
  itkGetMacro( Sigma, float);
  
  InputImageType* GetFixedImageCopy();

  InputImageType* GetMovingImageCopy();
  
protected:

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

  virtual void Initialize() throw (ExceptionObject);

  void CopyImage(const InputImageType* source, InputImageType* target);
  
private:
  
  MaskedImageRegistrationMethod(const Self&); // purposely not implemented
  void operator=(const Self&);                // purposely not implemented
  
  InputImageConstPointer                m_FixedMask;
  InputImageConstPointer                m_MovingMask;

  bool                                  m_UseFixedMask;
  bool                                  m_UseMovingMask;
  bool                                  m_MaskImageDirectly;
  bool                                  m_RescaleFixedImage;
  bool                                  m_RescaleMovingImage;
  bool                                  m_ThresholdFixedMask;
  bool                                  m_ThresholdMovingMask;  
  unsigned int                          m_NumberOfDilations;

  InputImagePixelType                   m_RescaleFixedMinimum;
  InputImagePixelType                   m_RescaleFixedMaximum;
  InputImagePixelType                   m_RescaleFixedBoundaryValue;
  InputImagePixelType                   m_RescaleFixedLowerThreshold;
  InputImagePixelType                   m_RescaleFixedUpperThreshold;
  InputImagePixelType                   m_RescaleMovingMinimum;
  InputImagePixelType                   m_RescaleMovingMaximum;
  InputImagePixelType                   m_RescaleMovingBoundaryValue;
  InputImagePixelType                   m_RescaleMovingLowerThreshold;
  InputImagePixelType                   m_RescaleMovingUpperThreshold;

  RescaleFilterPointer                  m_FixedRescaler;
  RescaleFilterPointer                  m_MovingRescaler;

  float                                 m_Sigma;
  SmoothingFilterPointer                m_FixedSmoother;
  SmoothingFilterPointer                m_MovingSmoother;
  
  InputImagePixelType                   m_FixedMaskMinimum;
  InputImagePixelType                   m_FixedMaskMaximum;
  InputImagePixelType                   m_MovingMaskMinimum;
  InputImagePixelType                   m_MovingMaskMaximum;
  ThresholdFilterPointer                m_FixedMaskThresholder;
  ThresholdFilterPointer                m_MovingMaskThresholder;
  
  DilateMaskFilterPointer               m_FixedMaskDilater;
  DilateMaskFilterPointer               m_MovingMaskDilater;
  
  MultiplyFilterPointer                 m_FixedImageMuliplier;
  MultiplyFilterPointer                 m_MovingImageMultiplier;
  
  CastToMaskImageTypeFilterPointer      m_FixedMaskCaster;
  CastToMaskImageTypeFilterPointer      m_MovingMaskCaster;

  MaskFilterPointer                     m_FixedMasker;
  MaskFilterPointer                     m_MovingMasker;
  
  InputImagePointer                     m_FixedImageCopy;
  InputImagePointer                     m_MovingImageCopy;

};


} // end namespace itk

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

#endif