itkSimilarityMeasure.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 itkSimilarityMeasure_h
#define itkSimilarityMeasure_h

#include <itkUCLBaseTransform.h>
#include "itkImageToImageMetricWithConstraint.h"
#include <itkCovariantVector.h>
#include <itkPoint.h>
#include <itkImageFileWriter.h>
#include <itkSignedMaurerDistanceMapImageFilter.h>
#include <itkLinearInterpolateImageFunction.h>
#include <itkEulerAffineTransform.h>
#include <itkImageMaskSpatialObject.h>

namespace itk
{
template < typename TFixedImage, typename TMovingImage > 
class ITK_EXPORT SimilarityMeasure : 
    public ImageToImageMetricWithConstraint< TFixedImage, TMovingImage>
{
public:

  typedef SimilarityMeasure                                               Self;
  typedef ImageToImageMetricWithConstraint<TFixedImage, TMovingImage >    Superclass;
  typedef SmartPointer<Self>                                              Pointer;
  typedef SmartPointer<const Self>                                        ConstPointer;

  itkTypeMacro(SimilarityMeasure, ImageToImageMetricWithConstraint);

  typedef typename Superclass::TransformType                TransformType;
  typedef typename itk::UCLBaseTransform<double, 
                    TFixedImage::ImageDimension,
                    TMovingImage::ImageDimension>           UCLBaseTransformType;  
  typedef typename Superclass::TransformPointer             TransformPointer;
  typedef typename Superclass::TransformParametersType      TransformParametersType;
  typedef typename Superclass::TransformJacobianType        TransformJacobianType;
  typedef typename Superclass::InputPointType               InputPointType;
  typedef typename Superclass::OutputPointType              OutputPointType;
  typedef typename Superclass::MeasureType                  MeasureType;
  typedef typename Superclass::DerivativeType               DerivativeType;
  typedef typename Superclass::FixedImageType               FixedImageType;
  typedef typename FixedImageType::SizeType                 FixedImageSizeType;
  typedef typename Superclass::FixedImageType::PixelType    FixedImagePixelType;
  typedef typename Superclass::MovingImageType              MovingImageType;
  typedef typename MovingImageType::SizeType                MovingImageSizeType;
  typedef typename Superclass::MovingImageType::PixelType   MovingImagePixelType;
  typedef typename Superclass::FixedImageConstPointer       FixedImageConstPointer;
  typedef typename Superclass::MovingImageConstPointer      MovingImageConstPointer;
  typedef ImageFileWriter<TFixedImage>                      ImageFileWriterType;
  typedef typename Superclass::InterpolatorType             InterpolatorType;
  typedef Image<char, TFixedImage::ImageDimension>          MidwayImageType; 
  typedef Image<float, TFixedImage::ImageDimension>         FloatImageType; 
  typedef Image<unsigned char, TFixedImage::ImageDimension> UnsignedCharImageType; 
  typedef SignedMaurerDistanceMapImageFilter<UnsignedCharImageType, FloatImageType> FixedDistanceMapImageFilterType;
  typedef SignedMaurerDistanceMapImageFilter<UnsignedCharImageType, FloatImageType> MovingDistanceMapImageFilterType;
  typedef LinearInterpolateImageFunction<FloatImageType, double>                    DistanceMapLinearInterpolatorType;
  typedef itk::EulerAffineTransform<double, TFixedImage::ImageDimension, TMovingImage::ImageDimension> AffineTransformType; 
  typedef const ImageMaskSpatialObject<TFixedImage::ImageDimension> FixedMaskType; 
  typedef const ImageMaskSpatialObject<TMovingImage::ImageDimension> MovingMaskType; 
  
  static const int SYMMETRIC_METRIC_AVERAGE; 
  static const int SYMMETRIC_METRIC_MID_WAY; 
  static const int SYMMETRIC_METRIC_BOTH_FIXED_AND_MOVING_TRANSFORM; 
  
  void Initialize() throw (ExceptionObject);

  void InitializeIntensityBounds() throw (ExceptionObject);
  
  void SetIntensityBounds( const FixedImagePixelType fixedLower, 
                           const FixedImagePixelType fixedUpper,
                           const MovingImagePixelType movingLower,
                           const MovingImagePixelType movingUpper);

  itkGetConstMacro( FixedLowerBound, FixedImagePixelType );
  
  itkGetConstMacro( FixedUpperBound, FixedImagePixelType );

  itkGetConstMacro( MovingLowerBound, MovingImagePixelType );

  itkGetConstMacro( MovingUpperBound, MovingImagePixelType );

  itkGetMacro( NumberOfFixedSamples, long int);

  itkGetMacro( NumberOfMovingSamples, long int);

  itkSetMacro( TwoSidedMetric, bool );
  itkGetMacro( TwoSidedMetric, bool );
  
  itkSetMacro( WriteFixedImage, bool );
  itkGetMacro( WriteFixedImage, bool );

  itkSetMacro( FixedImageFileName, std::string );
  itkGetMacro( FixedImageFileName, std::string );

  itkSetMacro( FixedImageFileExt, std::string );
  itkGetMacro( FixedImageFileExt, std::string );

  itkSetMacro( WriteTransformedMovingImage, bool );
  itkGetMacro( WriteTransformedMovingImage, bool );

  itkSetMacro( TransformedMovingImageFileName, std::string );
  itkGetMacro( TransformedMovingImageFileName, std::string );

  itkSetMacro( TransformedMovingImageFileExt, std::string );
  itkGetMacro( TransformedMovingImageFileExt, std::string );
  
  itkSetMacro(DirectVoxelComparison, bool);
  itkGetMacro(DirectVoxelComparison, bool);
  
  itkSetMacro(SymmetricMetric, int);
  itkGetMacro(SymmetricMetric, int);
  
  itkSetMacro(IsUpdateMatrix, bool); 
  itkGetMacro(IsUpdateMatrix, bool); 
  
  itkSetMacro(TransformedMovingImagePadValue, MovingImagePixelType); 
  itkGetMacro(TransformedMovingImagePadValue, MovingImagePixelType); 
  
  itkSetMacro(UseWeighting, bool); 
  itkGetMacro(UseWeighting, bool); 
  
  itkSetMacro(WeightingDistanceThreshold, double); 
  itkGetMacro(WeightingDistanceThreshold, double); 
  
  itkSetObjectMacro(FixedImageInterpolator, InterpolatorType); 
  itkSetObjectMacro(MovingImageInterpolator, InterpolatorType); 
  itkGetObjectMacro(FixedImageInterpolator, InterpolatorType); 
  itkGetObjectMacro(MovingImageInterpolator, InterpolatorType); 
  
  itkSetObjectMacro(FixedImageTransform, TransformType); 
  itkGetObjectMacro(FixedImageTransform, TransformType); 
  
  itkSetMacro(InitialiseIntensityBoundsUsingMask, bool); 
  itkGetMacro(InitialiseIntensityBoundsUsingMask, bool); 
  
  itkSetMacro(IsResampleWholeImage, bool); 
  itkGetMacro(IsResampleWholeImage, bool); 
  
  virtual bool ShouldBeMaximized() { return false; }
  
  virtual const TFixedImage* GetTransformedMovingImage() const { return this->m_TransformedMovingImage.GetPointer(); }

  virtual const TFixedImage* GetTransformedFixedImage() const { return this->m_TransformedFixedImage.GetPointer(); }
  
  double GetMeasureOfParameterChange(TransformParametersType lastP, TransformParametersType p); 
  
protected:
  
  SimilarityMeasure();
  virtual ~SimilarityMeasure() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

  virtual MeasureType GetSimilarity( const TransformParametersType & parameters ) const;

  virtual void ResetCostFunction() = 0;
  
  virtual void AggregateCostFunctionPair(FixedImagePixelType fixedValue, MovingImagePixelType movingValue) = 0;
  
  virtual void AggregateCostFunctionPairWithWeighting(FixedImagePixelType fixedValue, MovingImagePixelType movingValue, double weight) {       itkExceptionMacro(<<"AggregateCostFunctionPairWithWeighting not implemented.");
 }
  
  virtual MeasureType FinalizeCostFunction() = 0;

  typename TFixedImage::Pointer m_TransformedMovingImage;
  
  typename TFixedImage::Pointer m_TransformedFixedImage;
  
  typename InterpolatorType::Pointer m_FixedImageInterpolator; 
  typename InterpolatorType::Pointer m_MovingImageInterpolator; 

  FixedImagePixelType m_FixedLowerBound;
  
  FixedImagePixelType m_FixedUpperBound;
  
  MovingImagePixelType m_MovingLowerBound;
  
  MovingImagePixelType m_MovingUpperBound;
  
  bool m_UseWeighting; 
  
  double m_WeightingDistanceThreshold; 
  
  typename MidwayImageType::Pointer m_MidwayImage; 
  
  typename FixedDistanceMapImageFilterType::Pointer m_FixedDistanceMap; 
  
  typename MovingDistanceMapImageFilterType::Pointer m_MovingDistanceMap; 
  
  typename DistanceMapLinearInterpolatorType::Pointer m_FixedDistanceMapInterpolator; 
  
  typename DistanceMapLinearInterpolatorType::Pointer m_MovingDistanceMapInterpolator; 
  
  typename TransformType::Pointer m_FixedImageTransform; 
  
  bool m_InitialiseIntensityBoundsUsingMask; 
  
  bool m_IsResampleWholeImage; 

  void WriteImage(const TFixedImage* image, std::string filename) const;
  
  virtual MeasureType GetSymmetricSimilarity(const TransformParametersType & parameters); 
  
  virtual MeasureType GetSymmetricSimilarityAtHalfway(const TransformParametersType & parameters); 
  
  virtual MeasureType GetSimilarityUsingFixedAndMovingImageTransforms(const TransformParametersType& parameters); 
  
  virtual void InitializeSymmetricMetric();
  
  virtual void InitializeDistanceWeightings();

private:
  
  SimilarityMeasure(const Self&); // purposefully not implemented
  void operator=(const Self&);    // purposefully not implemented

  bool m_BoundsSetByUser;

  mutable long int m_NumberOfFixedSamples; 

  mutable long int m_NumberOfMovingSamples;

  mutable int m_IterationNumber;
  
  bool m_WriteFixedImage;
  
  bool m_WriteTransformedMovingImage;

  std::string m_FixedImageFileName;

  std::string m_FixedImageFileExt;

  std::string m_TransformedMovingImageFileName;

  std::string m_TransformedMovingImageFileExt;

  bool m_TwoSidedMetric;

  bool m_DirectVoxelComparison;
  
  int m_SymmetricMetric; 
  
  bool m_IsUpdateMatrix; 
  
  MovingImagePixelType m_TransformedMovingImagePadValue;
  
};

} // end namespace itk

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

#endif