itkAdvancedImageToImageMetric.h

Go to the documentation of this file.

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

  This file is part of the elastix software.

  Copyright (c) University Medical Center Utrecht. All rights reserved.
  See src/CopyrightElastix.txt or http://elastix.isi.uu.nl/legal.php for
  details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE. See the above copyright notices for more information.

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

#ifndef __itkAdvancedImageToImageMetric_h
#define __itkAdvancedImageToImageMetric_h

#include "itkImageToImageMetric.h"

#include "itkImageSamplerBase.h"
#include "itkGradientImageFilter.h"
#include "itkBSplineInterpolateImageFunction.h"
#include "itkLimiterFunctionBase.h"
#include "itkFixedArray.h"
#include "itkAdvancedTransform.h"

namespace itk
{

template <class TFixedImage, class TMovingImage>
class AdvancedImageToImageMetric :
  public ImageToImageMetric< TFixedImage, TMovingImage >
{
public:
  typedef AdvancedImageToImageMetric  Self;
  typedef ImageToImageMetric<
    TFixedImage, TMovingImage >           Superclass;
  typedef SmartPointer<Self>              Pointer;
  typedef SmartPointer<const Self>        ConstPointer;

  itkTypeMacro( AdvancedImageToImageMetric, ImageToImageMetric );

  itkStaticConstMacro( MovingImageDimension, unsigned int,
    TMovingImage::ImageDimension );
  itkStaticConstMacro( FixedImageDimension, unsigned int,
    TFixedImage::ImageDimension );

  typedef typename Superclass::CoordinateRepresentationType CoordinateRepresentationType;
  typedef typename Superclass::MovingImageType            MovingImageType;
  typedef typename Superclass::MovingImagePixelType       MovingImagePixelType;
  typedef typename MovingImageType::Pointer               MovingImagePointer;
  typedef typename Superclass::MovingImageConstPointer    MovingImageConstPointer;
  typedef typename Superclass::FixedImageType             FixedImageType;
  typedef typename FixedImageType::Pointer                FixedImagePointer;
  typedef typename Superclass::FixedImageConstPointer     FixedImageConstPointer;
  typedef typename Superclass::FixedImageRegionType       FixedImageRegionType;
  typedef typename Superclass::TransformType              TransformType;
  typedef typename Superclass::TransformPointer           TransformPointer;
  typedef typename Superclass::InputPointType             InputPointType;
  typedef typename Superclass::OutputPointType            OutputPointType;
  typedef typename Superclass::TransformParametersType    TransformParametersType;
  typedef typename Superclass::TransformJacobianType      TransformJacobianType;
  typedef typename Superclass::InterpolatorType           InterpolatorType;
  typedef typename Superclass::InterpolatorPointer        InterpolatorPointer;
  typedef typename Superclass::RealType                   RealType;
  typedef typename Superclass::GradientPixelType          GradientPixelType;
  typedef typename Superclass::GradientImageType          GradientImageType;
  typedef typename Superclass::GradientImagePointer       GradientImagePointer;
  typedef typename Superclass::GradientImageFilterType    GradientImageFilterType;
  typedef typename Superclass::GradientImageFilterPointer GradientImageFilterPointer;
  typedef typename Superclass::FixedImageMaskType         FixedImageMaskType;
  typedef typename Superclass::FixedImageMaskPointer      FixedImageMaskPointer;
  typedef typename Superclass::MovingImageMaskType        MovingImageMaskType;
  typedef typename Superclass::MovingImageMaskPointer     MovingImageMaskPointer;
  typedef typename Superclass::MeasureType                MeasureType;
  typedef typename Superclass::DerivativeType             DerivativeType;
  typedef typename DerivativeType::ValueType              DerivativeValueType;
  typedef typename Superclass::ParametersType             ParametersType;

  typedef typename FixedImageType::PixelType              FixedImagePixelType;
  typedef typename MovingImageType::RegionType            MovingImageRegionType;
  typedef FixedArray< double,
    itkGetStaticConstMacro(MovingImageDimension) >        MovingImageDerivativeScalesType;

  typedef ImageSamplerBase< FixedImageType >              ImageSamplerType;
  typedef typename ImageSamplerType::Pointer              ImageSamplerPointer;
  typedef typename
    ImageSamplerType::OutputVectorContainerType           ImageSampleContainerType;
  typedef typename
    ImageSamplerType::OutputVectorContainerPointer        ImageSampleContainerPointer;

  typedef LimiterFunctionBase<
    RealType, FixedImageDimension>                        FixedImageLimiterType;
  typedef typename FixedImageLimiterType::OutputType      FixedImageLimiterOutputType;
  typedef LimiterFunctionBase<
    RealType, MovingImageDimension>                       MovingImageLimiterType;
  typedef typename MovingImageLimiterType::OutputType     MovingImageLimiterOutputType;

  typedef typename TransformType::ScalarType              ScalarType;
  typedef AdvancedTransform<
    ScalarType,
    FixedImageDimension,
    MovingImageDimension >                                AdvancedTransformType;

  typedef typename DerivativeType::ValueType              HessianValueType;
  typedef Array2D<HessianValueType>                       HessianType;

  virtual void SetTransform( AdvancedTransformType * arg )
  {
    this->Superclass::SetTransform( arg );
    if ( this->m_AdvancedTransform != arg )
    {
      this->m_AdvancedTransform = arg;
      this->Modified();
    }
  }
  const AdvancedTransformType * GetTransform( void ) const
  {
    return this->m_AdvancedTransform.GetPointer();
  }

  itkSetObjectMacro( ImageSampler, ImageSamplerType );
  virtual ImageSamplerType * GetImageSampler( void ) const
  {
    return this->m_ImageSampler.GetPointer();
  };

  itkGetConstMacro( UseImageSampler, bool );

  itkSetMacro( RequiredRatioOfValidSamples, double );
  itkGetConstMacro( RequiredRatioOfValidSamples, double );

  itkSetObjectMacro( MovingImageLimiter, MovingImageLimiterType );
  itkGetConstObjectMacro( MovingImageLimiter, MovingImageLimiterType );
  itkSetObjectMacro( FixedImageLimiter, FixedImageLimiterType );
  itkGetConstObjectMacro( FixedImageLimiter, FixedImageLimiterType );

  itkSetMacro( MovingLimitRangeRatio, double );
  itkGetConstMacro( MovingLimitRangeRatio, double );
  itkSetMacro( FixedLimitRangeRatio, double );
  itkGetConstMacro( FixedLimitRangeRatio, double );

  itkGetConstMacro( UseFixedImageLimiter, bool );
  itkGetConstMacro( UseMovingImageLimiter, bool );

  itkSetMacro( UseMovingImageDerivativeScales, bool );
  itkGetConstMacro( UseMovingImageDerivativeScales, bool );
  itkSetMacro( MovingImageDerivativeScales, MovingImageDerivativeScalesType );
  itkGetConstReferenceMacro( MovingImageDerivativeScales, MovingImageDerivativeScalesType );

  virtual void Initialize( void ) throw ( ExceptionObject );

  virtual void GetSelfHessian( const TransformParametersType & parameters, HessianType & H ) const;

protected:

  AdvancedImageToImageMetric();

  virtual ~AdvancedImageToImageMetric() {};

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

  typedef typename FixedImageType::IndexType                    FixedImageIndexType;
  typedef typename FixedImageIndexType::IndexValueType          FixedImageIndexValueType;
  typedef typename MovingImageType::IndexType                   MovingImageIndexType;
  typedef typename TransformType::InputPointType                FixedImagePointType;
  typedef typename TransformType::OutputPointType               MovingImagePointType;
  typedef typename InterpolatorType::ContinuousIndexType        MovingImageContinuousIndexType;

  typedef BSplineInterpolateImageFunction<
    MovingImageType, CoordinateRepresentationType, double>      BSplineInterpolatorType;
  typedef BSplineInterpolateImageFunction<
    MovingImageType, CoordinateRepresentationType, float>       BSplineInterpolatorFloatType;
  typedef typename BSplineInterpolatorType::CovariantVectorType MovingImageDerivativeType;
  typedef GradientImageFilter<
    MovingImageType, RealType, RealType>                        CentralDifferenceGradientFilterType;

  typedef typename
    AdvancedTransformType::NonZeroJacobianIndicesType           NonZeroJacobianIndicesType;

  mutable ImageSamplerPointer   m_ImageSampler;

  bool m_InterpolatorIsBSpline;
  bool m_InterpolatorIsBSplineFloat;
  typename BSplineInterpolatorType::Pointer             m_BSplineInterpolator;
  typename BSplineInterpolatorFloatType::Pointer             m_BSplineInterpolatorFloat;
  typename CentralDifferenceGradientFilterType::Pointer m_CentralDifferenceGradientFilter;

  bool m_TransformIsAdvanced;
  typename AdvancedTransformType::Pointer           m_AdvancedTransform;

  typename FixedImageLimiterType::Pointer            m_FixedImageLimiter;
  typename MovingImageLimiterType::Pointer           m_MovingImageLimiter;
  FixedImagePixelType                                m_FixedImageTrueMin;
  FixedImagePixelType                                m_FixedImageTrueMax;
  MovingImagePixelType                               m_MovingImageTrueMin;
  MovingImagePixelType                               m_MovingImageTrueMax;
  FixedImageLimiterOutputType                        m_FixedImageMinLimit;
  FixedImageLimiterOutputType                        m_FixedImageMaxLimit;
  MovingImageLimiterOutputType                       m_MovingImageMinLimit;
  MovingImageLimiterOutputType                       m_MovingImageMaxLimit;

  virtual void InitializeImageSampler( void ) throw ( ExceptionObject );

  itkSetMacro( UseImageSampler, bool );

  virtual void CheckNumberOfSamples(
    unsigned long wanted, unsigned long found ) const;

  virtual void CheckForBSplineInterpolator( void );

  virtual bool EvaluateMovingImageValueAndDerivative(
    const MovingImagePointType & mappedPoint,
    RealType & movingImageValue,
    MovingImageDerivativeType * gradient ) const;

  virtual void CheckForAdvancedTransform( void );

  virtual bool TransformPoint(
    const FixedImagePointType & fixedImagePoint,
    MovingImagePointType & mappedPoint ) const;

  virtual bool EvaluateTransformJacobian(
    const FixedImagePointType & fixedImagePoint,
    TransformJacobianType & jacobian,
    NonZeroJacobianIndicesType & nzji ) const;

  virtual bool IsInsideMovingMask( const MovingImagePointType & point ) const;

  virtual void ComputeFixedImageExtrema(
    const FixedImageType * image,
    const FixedImageRegionType & region );

  virtual void ComputeMovingImageExtrema(
    const MovingImageType * image,
    const MovingImageRegionType & region );

  virtual void InitializeLimiters( void );

  itkSetMacro( UseFixedImageLimiter, bool );
  itkSetMacro( UseMovingImageLimiter, bool );

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

  bool    m_UseImageSampler;
  double  m_FixedLimitRangeRatio;
  double  m_MovingLimitRangeRatio;
  bool    m_UseFixedImageLimiter;
  bool    m_UseMovingImageLimiter;
  double  m_RequiredRatioOfValidSamples;
  bool    m_UseMovingImageDerivativeScales;
  MovingImageDerivativeScalesType m_MovingImageDerivativeScales;

}; // end class AdvancedImageToImageMetric

} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkAdvancedImageToImageMetric.hxx"
#endif

#endif // end #ifndef __itkAdvancedImageToImageMetric_h