itkCombinationImageToImageMetric.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 __itkCombinationImageToImageMetric_h
#define __itkCombinationImageToImageMetric_h

#include "itkAdvancedImageToImageMetric.h"
#include "itkSingleValuedPointSetToPointSetMetric.h"

namespace itk
{

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

  itkTypeMacro( CombinationImageToImageMetric, AdvancedImageToImageMetric );

  itkNewMacro( Self );

  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 Superclass::MovingImagePointer         MovingImagePointer;
  typedef typename Superclass::MovingImageConstPointer    MovingImageConstPointer;
  typedef typename Superclass::FixedImageType             FixedImageType;
  //typedef typename Superclass::FixedImagePointer          FixedImagePointer;
  typedef typename Superclass::FixedImageConstPointer     FixedImageConstPointer;
  typedef typename Superclass::FixedImageRegionType       FixedImageRegionType;
  typedef typename Superclass::AdvancedTransformType      TransformType;
  typedef typename TransformType::Pointer                 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 Superclass::DerivativeValueType        DerivativeValueType;
  typedef typename Superclass::ParametersType             ParametersType;

  typedef typename Superclass::HessianValueType           HessianValueType;
  typedef typename Superclass::HessianType                HessianType;


  typedef Superclass                                      ImageMetricType;
  typedef typename ImageMetricType::Pointer               ImageMetricPointer;
  typedef SingleValuedCostFunction                        SingleValuedCostFunctionType;
  typedef typename SingleValuedCostFunctionType::Pointer  SingleValuedCostFunctionPointer;

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

  typedef PointSet< CoordinateRepresentationType,
    TFixedImage::ImageDimension,
    DefaultStaticMeshTraits<
      CoordinateRepresentationType,
      TFixedImage::ImageDimension,
      TFixedImage::ImageDimension,
      CoordinateRepresentationType, CoordinateRepresentationType,
      CoordinateRepresentationType > >                    FixedPointSetType;
  typedef PointSet< CoordinateRepresentationType,
    TMovingImage::ImageDimension,
    DefaultStaticMeshTraits<
      CoordinateRepresentationType,
      TMovingImage::ImageDimension,
      TMovingImage::ImageDimension,
      CoordinateRepresentationType, CoordinateRepresentationType,
      CoordinateRepresentationType > >                    MovingPointSetType;
  typedef SingleValuedPointSetToPointSetMetric<
    FixedPointSetType, MovingPointSetType >               PointSetMetricType;

  void SetNumberOfMetrics( unsigned int count );

  itkGetConstMacro( NumberOfMetrics, unsigned int );

  void SetMetric( SingleValuedCostFunctionType * metric, unsigned int pos );

  SingleValuedCostFunctionType * GetMetric( unsigned int count ) const;

  void SetMetricWeight( double weight, unsigned int pos );

  double GetMetricWeight( unsigned int pos ) const;

  void SetUseMetric( const bool use, const unsigned int pos );

  void SetUseAllMetrics( void );

  bool GetUseMetric( const unsigned int pos ) const;

  MeasureType GetMetricValue( unsigned int pos ) const;

  const DerivativeType & GetMetricDerivative( unsigned int pos ) const;

  virtual void SetTransform( TransformType * _arg );

  virtual void SetTransform( TransformType * _arg, unsigned int pos );

  virtual const TransformType * GetTransform( unsigned int pos ) const;

  virtual const TransformType * GetTransform( void ) const
  {
    return this->GetTransform( 0 );
  };

  virtual void SetInterpolator( InterpolatorType *_arg );

  virtual void SetInterpolator( InterpolatorType * _arg, unsigned int pos );

  virtual const InterpolatorType * GetInterpolator( unsigned int pos ) const;

  virtual const InterpolatorType * GetInterpolator( void ) const
  {
    return this->GetInterpolator(0);
  };

  virtual void SetFixedImage( const FixedImageType *_arg );

  virtual void SetFixedImage( const FixedImageType *_arg, unsigned int pos );

  virtual const FixedImageType * GetFixedImage( unsigned int pos ) const;

  virtual const FixedImageType * GetFixedImage( void ) const
  {
    return this->GetFixedImage(0);
  };

  virtual void SetFixedImageMask( FixedImageMaskType *_arg );

  virtual void SetFixedImageMask( FixedImageMaskType *_arg, unsigned int pos );

  virtual const FixedImageMaskType * GetFixedImageMask( unsigned int pos ) const;

  virtual const FixedImageMaskType * GetFixedImageMask( void ) const
  {
    return this->GetFixedImageMask(0);
  };

  virtual void SetFixedImageRegion( const FixedImageRegionType _arg );

  virtual void SetFixedImageRegion( const FixedImageRegionType _arg, unsigned int pos );

  virtual const FixedImageRegionType & GetFixedImageRegion( unsigned int pos ) const;

  virtual const FixedImageRegionType & GetFixedImageRegion( void ) const
  {
    return this->GetFixedImageRegion(0);
  };

  virtual void SetMovingImage( const MovingImageType *_arg );

  virtual void SetMovingImage( const MovingImageType *_arg, unsigned int pos );

  virtual const MovingImageType * GetMovingImage( unsigned int pos ) const;

  virtual const MovingImageType * GetMovingImage( void ) const
  {
    return this->GetMovingImage(0);
  };

  virtual void SetMovingImageMask( MovingImageMaskType *_arg );

  virtual void SetMovingImageMask( MovingImageMaskType *_arg, unsigned int pos );

  virtual const MovingImageMaskType * GetMovingImageMask( unsigned int pos ) const;

  virtual const MovingImageMaskType * GetMovingImageMask( void ) const
  {
    return this->GetMovingImageMask(0);
  };

  virtual const unsigned long & GetNumberOfPixelsCounted( void ) const;

  virtual void Initialize( void ) throw ( ExceptionObject );

  virtual MeasureType GetValue( const ParametersType & parameters ) const;

  virtual void GetDerivative(
    const ParametersType & parameters,
    DerivativeType & derivative ) const;

  virtual void GetValueAndDerivative(
    const ParametersType & parameters,
    MeasureType & value,
    DerivativeType & derivative ) const;

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

  virtual unsigned long GetMTime() const;

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

  unsigned int                                      m_NumberOfMetrics;
  std::vector< SingleValuedCostFunctionPointer >    m_Metrics;
  std::vector< double >                             m_MetricWeights;
  std::vector< bool >                               m_UseMetric;
  mutable std::vector< MeasureType >                m_MetricValues;
  mutable std::vector< DerivativeType >             m_MetricDerivatives;

  FixedImageRegionType        m_NullFixedImageRegion;
  DerivativeType              m_NullDerivative;

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

}; // end class CombinationImageToImageMetric

} // end namespace itk

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

#endif // end #ifndef __itkCombinationImageToImageMetric_h