itkRegistrationForceFilter.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 itkRegistrationForceFilter_h
#define itkRegistrationForceFilter_h
#include <itkHistogramSimilarityMeasure.h>
#include <itkImageToImageFilter.h>
#include <itkVector.h>
#include <itkImage.h>
#include <itkDisplacementFieldJacobianDeterminantFilter.h>

namespace itk {
template< class TFixedImage, class TMovingImage, class TScalarType>
class ITK_EXPORT RegistrationForceFilter :
  public ImageToImageFilter<TFixedImage, 
                            Image<  
                              Vector< TScalarType, TFixedImage::ImageDimension>, 
                              TFixedImage::ImageDimension> >
{
public:

  typedef RegistrationForceFilter                                                       Self;
  typedef ImageToImageFilter<TFixedImage, 
                             Image<  
                               Vector< TScalarType, TFixedImage::ImageDimension>, 
                               TFixedImage::ImageDimension> > Superclass;
  typedef SmartPointer<Self>                                                            Pointer;
  typedef SmartPointer<const Self>                                                      ConstPointer;
  
  itkTypeMacro(RegistrationForceFilter, ImageToImageFilter);

  itkStaticConstMacro(Dimension, unsigned int, TFixedImage::ImageDimension);

  typedef TScalarType                                                                 OutputDataType;
  typedef Vector< OutputDataType, itkGetStaticConstMacro(Dimension) >                 OutputPixelType;
  typedef Image< OutputPixelType, itkGetStaticConstMacro(Dimension) >                 OutputImageType;
  typedef typename Superclass::InputImageType                                         InputImageType;
  typedef typename InputImageType::PixelType                                          InputImagePixelType;
  typedef typename Superclass::InputImageRegionType                                   RegionType;
  typedef TScalarType                                                                 MeasureType;
  
  typedef HistogramSimilarityMeasure<TFixedImage, TMovingImage>                       MetricType;
  typedef typename MetricType::Pointer                                                MetricPointer;
  typedef typename MetricType::HistogramType                                          HistogramType;
  typedef typename MetricType::HistogramPointer                                       HistogramPointer;
  typedef typename MetricType::HistogramSizeType                                      HistogramSizeType;
  typedef typename MetricType::HistogramMeasurementVectorType                         HistogramMeasurementVectorType;
  typedef typename MetricType::HistogramFrequencyType                                 HistogramFrequencyType;
  typedef typename MetricType::HistogramIteratorType                                  HistogramIteratorType;
  
  typedef SpatialObject< Dimension >                                                  FixedImageMaskType; 
  
  //typedef Image<Vector<TScalarType, TFixedImage::ImageDimension>, TFixedImage::ImageDimension>  DeformationFieldType; 
  //typedef DisplacementFieldJacobianDeterminantFilter<DeformationFieldType, TScalarType> JacobianDeterminantFilterType;
  typedef Image<double, TFixedImage::ImageDimension> JacobianImageType; 
  
  virtual void SetFixedImage(const InputImageType *image) { this->SetNthInput(0, image); }

  virtual void SetTransformedMovingImage(const InputImageType *image) { this->SetNthInput(1, image); }

  virtual void SetUnTransformedMovingImage(const InputImageType *image) { this->SetNthInput(2, image); }

  virtual void SetNthInput(unsigned int idx, const InputImageType *);
  
  itkSetObjectMacro( Metric, MetricType );
  itkGetObjectMacro( Metric, MetricType );

  itkSetMacro( ScaleToSizeOfVoxelAxis, bool );
  itkGetMacro( ScaleToSizeOfVoxelAxis, bool );

  itkSetMacro( FixedUpperPixelValue, InputImagePixelType);
  itkGetMacro( FixedUpperPixelValue, InputImagePixelType);

  itkSetMacro( FixedLowerPixelValue, InputImagePixelType);
  itkGetMacro( FixedLowerPixelValue, InputImagePixelType);

  itkSetMacro( MovingUpperPixelValue, InputImagePixelType);
  itkGetMacro( MovingUpperPixelValue, InputImagePixelType);

  itkSetMacro( MovingLowerPixelValue, InputImagePixelType);
  itkGetMacro( MovingLowerPixelValue, InputImagePixelType);
  
  itkSetMacro(IsSymmetric, bool); 
  itkGetMacro(IsSymmetric, bool); 

  virtual void SetFixedImageMask(const FixedImageMaskType* fixedImageMask) { this->m_FixedImageMask = fixedImageMask; } 
  
  void WriteForceImage(std::string filename);
  
  virtual void SetFixedImageTransformJacobian(typename JacobianImageType::Pointer jacobian)
  {
    this->m_FixedImageTransformJacobian = jacobian; 
  }
      
  virtual void SetMovingImageTransformJacobian(typename JacobianImageType::Pointer jacobian)
  {
    this->m_MovingImageTransformJacobian = jacobian; 
  }
  
protected:
  RegistrationForceFilter();
  ~RegistrationForceFilter() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

  // Check before we start.
  virtual void BeforeThreadedGenerateData();
  
  // (mainly for debugging purposes).
  virtual void AfterThreadedGenerateData();
  
  MetricPointer m_Metric;  

  bool m_ScaleToSizeOfVoxelAxis;

  InputImagePixelType m_FixedUpperPixelValue;
  
  InputImagePixelType m_FixedLowerPixelValue;

  InputImagePixelType m_MovingUpperPixelValue;
  
  InputImagePixelType m_MovingLowerPixelValue;

  const FixedImageMaskType* m_FixedImageMask; 
  
  bool m_IsSymmetric; 
  
  typename JacobianImageType::Pointer m_FixedImageTransformJacobian; 
  
  typename JacobianImageType::Pointer m_MovingImageTransformJacobian; 

private:
  
  RegistrationForceFilter(const Self&); 
  void operator=(const Self&); 
  
};

}

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

#endif