itkCombinationImageToImageMetric.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#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;
 
  typedef typename Superclass::ThreaderType   ThreaderType;
  typedef typename Superclass::ThreadInfoType ThreadInfoType;
 
  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 SetMetricRelativeWeight( double weight, unsigned int pos );
 
  double GetMetricRelativeWeight( unsigned int pos ) const;
 
  itkSetMacro( UseRelativeWeights, bool );
  itkGetMacro( UseRelativeWeights, bool );
 
  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;
 
  double GetMetricDerivativeMagnitude( unsigned int pos ) const;
 
  double GetMetricComputationTime( unsigned int pos ) const;
 
  void SetTransform( TransformType * _arg ) override;
 
  virtual void SetTransform( TransformType * _arg, unsigned int pos );
 
  virtual const TransformType * GetTransform( unsigned int pos ) const;
 
  const TransformType * GetTransform( void ) const override
  {
    return this->GetTransform( 0 );
  }
 
 
  void SetInterpolator( InterpolatorType * _arg ) override;
 
  virtual void SetInterpolator( InterpolatorType * _arg, unsigned int pos );
 
  virtual const InterpolatorType * GetInterpolator( unsigned int pos ) const;
 
  const InterpolatorType * GetInterpolator( void ) const override
  {
    return this->GetInterpolator( 0 );
  }
 
 
  void SetFixedImage( const FixedImageType * _arg ) override;
 
  virtual void SetFixedImage( const FixedImageType * _arg, unsigned int pos );
 
  virtual const FixedImageType * GetFixedImage( unsigned int pos ) const;
 
  const FixedImageType * GetFixedImage( void ) const override
  {
    return this->GetFixedImage( 0 );
  }
 
 
  void SetFixedImageMask( FixedImageMaskType * _arg ) override;
 
  virtual void SetFixedImageMask( FixedImageMaskType * _arg, unsigned int pos );
 
  virtual const FixedImageMaskType * GetFixedImageMask( unsigned int pos ) const;
 
  const FixedImageMaskType * GetFixedImageMask( void ) const override
  {
    return this->GetFixedImageMask( 0 );
  }
 
 
  void SetFixedImageRegion( const FixedImageRegionType _arg ) override;
 
  virtual void SetFixedImageRegion( const FixedImageRegionType _arg, unsigned int pos );
 
  virtual const FixedImageRegionType & GetFixedImageRegion( unsigned int pos ) const;
 
  const FixedImageRegionType & GetFixedImageRegion( void ) const override
  {
    return this->GetFixedImageRegion( 0 );
  }
 
 
  void SetMovingImage( const MovingImageType * _arg ) override;
 
  virtual void SetMovingImage( const MovingImageType * _arg, unsigned int pos );
 
  virtual const MovingImageType * GetMovingImage( unsigned int pos ) const;
 
  const MovingImageType * GetMovingImage( void ) const override
  {
    return this->GetMovingImage( 0 );
  }
 
 
  void SetMovingImageMask( MovingImageMaskType * _arg ) override;
 
  virtual void SetMovingImageMask( MovingImageMaskType * _arg, unsigned int pos );
 
  virtual const MovingImageMaskType * GetMovingImageMask( unsigned int pos ) const;
 
  const MovingImageMaskType * GetMovingImageMask( void ) const override
  {
    return this->GetMovingImageMask( 0 );
  }
 
 
  const SizeValueType & GetNumberOfPixelsCounted( void ) const override;
 
  void Initialize( void ) override;
 
  MeasureType GetValue( const ParametersType & parameters ) const override;
 
  void GetDerivative(
    const ParametersType & parameters,
    DerivativeType & derivative ) const override;
 
  void GetValueAndDerivative(
    const ParametersType & parameters,
    MeasureType & value,
    DerivativeType & derivative ) const override;
 
  void GetSelfHessian(
    const TransformParametersType & parameters,
    HessianType & H ) const override;
 
  ModifiedTimeType GetMTime() const override;
 
protected:
 
  CombinationImageToImageMetric();
  ~CombinationImageToImageMetric() override {}
  void PrintSelf( std::ostream & os, Indent indent ) const override;
 
  unsigned int                                   m_NumberOfMetrics;
  std::vector< SingleValuedCostFunctionPointer > m_Metrics;
  std::vector< double >                          m_MetricWeights;
  std::vector< double >                          m_MetricRelativeWeights;
  bool                                           m_UseRelativeWeights;
  std::vector< bool >                            m_UseMetric;
  mutable std::vector< MeasureType >             m_MetricValues;
  mutable std::vector< DerivativeType >          m_MetricDerivatives;
  mutable std::vector< double >                  m_MetricDerivativesMagnitude;
  mutable std::vector< double >                  m_MetricComputationTime;
 
  FixedImageRegionType m_NullFixedImageRegion;
  DerivativeType       m_NullDerivative;
 
private:
 
  CombinationImageToImageMetric( const Self & ); // purposely not implemented
  void operator=( const Self & );                // purposely not implemented
 
  void InitializeThreadingParameters( void ) const override;
 
  double GetFinalMetricWeight( unsigned int pos ) const;
 
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkCombinationImageToImageMetric.hxx"
#endif
 
#endif // end #ifndef __itkCombinationImageToImageMetric_h