itkImageToImageMetricv4.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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 itkImageToImageMetricv4_h
#define itkImageToImageMetricv4_h
 
#include "itkCovariantVector.h"
#include "itkImageFunction.h"
#include "itkObjectToObjectMetric.h"
#include "itkInterpolateImageFunction.h"
#include "itkSpatialObject.h"
#include "itkResampleImageFilter.h"
#include "itkThreadedIndexedContainerPartitioner.h"
#include "itkThreadedImageRegionPartitioner.h"
#include "itkImageToImageFilter.h"
#include "itkImageToImageMetricv4GetValueAndDerivativeThreader.h"
#include "itkPointSet.h"
#include "itkDefaultConvertPixelTraits.h"
#include "itkDefaultImageToImageMetricTraitsv4.h"
 
namespace itk
{
template <typename TFixedImage,
          typename TMovingImage,
          typename TVirtualImage = TFixedImage,
          typename TInternalComputationValueType = double,
          typename TMetricTraits =
            DefaultImageToImageMetricTraitsv4<TFixedImage, TMovingImage, TVirtualImage, TInternalComputationValueType>>
class ITK_TEMPLATE_EXPORT ImageToImageMetricv4
  : public ObjectToObjectMetric<TFixedImage::ImageDimension,
                                TMovingImage::ImageDimension,
                                TVirtualImage,
                                TInternalComputationValueType>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ImageToImageMetricv4);

  using Self = ImageToImageMetricv4;
  using Superclass = ObjectToObjectMetric<TFixedImage::ImageDimension,
                                          TMovingImage::ImageDimension,
                                          TVirtualImage,
                                          TInternalComputationValueType>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkOverrideGetNameOfClassMacro(ImageToImageMetricv4);


  using InternalComputationValueType = TInternalComputationValueType;

  using typename Superclass::CoordinateRepresentationType;

  using typename Superclass::ParametersType;
  using typename Superclass::ParametersValueType;

  using typename Superclass::GradientSourceEnum;

  using typename Superclass::DimensionType;
  using ImageDimensionType = typename Superclass::DimensionType;

  using typename Superclass::FixedTransformType;
  using typename Superclass::FixedTransformPointer;
  using typename Superclass::FixedInputPointType;
  using typename Superclass::FixedOutputPointType;
  using typename Superclass::FixedTransformParametersType;
 
  using typename Superclass::MovingTransformType;
  using typename Superclass::MovingTransformPointer;
  using typename Superclass::MovingInputPointType;
  using typename Superclass::MovingOutputPointType;
  using typename Superclass::MovingTransformParametersType;
 
  using typename Superclass::JacobianType;
  using typename Superclass::FixedTransformJacobianType;
  using typename Superclass::MovingTransformJacobianType;
 
  using ObjectType = typename Superclass::ObjectType;

  using FixedImageType = TFixedImage;
  using FixedImagePixelType = typename FixedImageType::PixelType;
  using FixedPixelType = FixedImagePixelType;
  using FixedImagePointer = typename FixedImageType::Pointer;
  using FixedImageConstPointer = typename FixedImageType::ConstPointer;
  using FixedImagePointType = typename FixedImageType::PointType;
  using FixedImageIndexType = typename FixedImageType::IndexType;
  using MovingImageType = TMovingImage;
  using MovingImagePixelType = typename MovingImageType::PixelType;
  using MovingPixelType = MovingImagePixelType;
  using MovingImagePointer = typename MovingImageType::Pointer;
  using MovingImageConstPointer = typename MovingImageType::ConstPointer;
  using MovingImagePointType = typename MovingImageType::PointType;
  using MovingImageRegionType = typename MovingImageType::RegionType;
  using MovingImageIndexType = typename MovingImageType::IndexType;

  using VirtualImageType = typename Superclass::VirtualImageType;
  using typename Superclass::VirtualImagePointer;
  using typename Superclass::VirtualPixelType;
  using typename Superclass::VirtualRegionType;
  using typename Superclass::VirtualSizeType;
  using typename Superclass::VirtualSpacingType;
  using VirtualOriginType = typename Superclass::VirtualPointType;
  using typename Superclass::VirtualPointType;
  using typename Superclass::VirtualDirectionType;
  using VirtualRadiusType = typename Superclass::VirtualSizeType;
  using typename Superclass::VirtualIndexType;
  using typename Superclass::VirtualPointSetType;
  using typename Superclass::VirtualPointSetPointer;

  using MetricTraits = TMetricTraits;
 
  /* Image dimension accessors */
  static constexpr DimensionType FixedImageDimension = Superclass::FixedDimension;
  static constexpr DimensionType MovingImageDimension = Superclass::MovingDimension;
  static constexpr DimensionType VirtualImageDimension = Superclass::VirtualDimension;

  using FixedImageMaskType = SpatialObject<Self::FixedImageDimension>;
  using FixedImageMaskPointer = typename FixedImageMaskType::Pointer;
  using FixedImageMaskConstPointer = typename FixedImageMaskType::ConstPointer;

  using MovingImageMaskType = SpatialObject<Self::MovingImageDimension>;
  using MovingImageMaskPointer = typename MovingImageMaskType::Pointer;
  using MovingImageMaskConstPointer = typename MovingImageMaskType::ConstPointer;

  using FixedSampledPointSetType = PointSet<typename FixedImageType::PixelType, Self::FixedImageDimension>;
  using FixedSampledPointSetPointer = typename FixedSampledPointSetType::Pointer;
  using FixedSampledPointSetConstPointer = typename FixedSampledPointSetType::ConstPointer;

  using FixedInterpolatorType = InterpolateImageFunction<FixedImageType, CoordinateRepresentationType>;
  using MovingInterpolatorType = InterpolateImageFunction<MovingImageType, CoordinateRepresentationType>;
  using FixedInterpolatorPointer = typename FixedInterpolatorType::Pointer;
  using MovingInterpolatorPointer = typename MovingInterpolatorType::Pointer;

  using FixedImageGradientType = typename MetricTraits::FixedImageGradientType;
  using MovingImageGradientType = typename MetricTraits::MovingImageGradientType;
  using VirtualImageGradientType = typename MetricTraits::VirtualImageGradientType;
 
  using FixedImageComponentGradientType =
    CovariantVector<typename FixedImageGradientType::ValueType, FixedImageDimension>;
 
  using MovingImageComponentGradientType =
    CovariantVector<typename MovingImageGradientType::ValueType, MovingImageDimension>;
 
  using VirtualImageComponentGradientType =
    CovariantVector<typename VirtualImageGradientType::ValueType, VirtualImageDimension>;

  using FixedRealType = typename MetricTraits::FixedRealType;
  using MovingRealType = typename MetricTraits::MovingRealType;
 
  using FixedScalarRealType = typename NumericTraits<FixedRealType>::ScalarRealType;
  using MovingScalarRealType = typename NumericTraits<MovingRealType>::ScalarRealType;
 
  using FixedGradientPixelType = typename MetricTraits::FixedGradientPixelType;
  using MovingGradientPixelType = typename MetricTraits::MovingGradientPixelType;
 
  using FixedImageGradientImageType = typename MetricTraits::FixedImageGradientImageType;
  using MovingImageGradientImageType = typename MetricTraits::MovingImageGradientImageType;
 
  using FixedImageGradientImagePointer = typename FixedImageGradientImageType::Pointer;
  using MovingImageGradientImagePointer = typename MovingImageGradientImageType::Pointer;
 
  using FixedImageGradientFilterType = typename MetricTraits::FixedImageGradientFilterType;
  using MovingImageGradientFilterType = typename MetricTraits::MovingImageGradientFilterType;
 
  using FixedImageGradientFilterPointer = typename FixedImageGradientFilterType::Pointer;
  using MovingImageGradientFilterPointer = typename MovingImageGradientFilterType::Pointer;
 

  using DefaultFixedImageGradientFilter = typename MetricTraits::DefaultFixedImageGradientFilter;
  using DefaultMovingImageGradientFilter = typename MetricTraits::DefaultMovingImageGradientFilter;

  using FixedImageGradientCalculatorType = typename MetricTraits::FixedImageGradientCalculatorType;
  using MovingImageGradientCalculatorType = typename MetricTraits::MovingImageGradientCalculatorType;
 
  using FixedImageGradientCalculatorPointer = typename FixedImageGradientCalculatorType::Pointer;
  using MovingImageGradientCalculatorPointer = typename MovingImageGradientCalculatorType::Pointer;

  using DefaultFixedImageGradientCalculator = typename MetricTraits::DefaultFixedImageGradientCalculator;
  using DefaultMovingImageGradientCalculator = typename MetricTraits::DefaultMovingImageGradientCalculator;

  using typename Superclass::MeasureType;

  using typename Superclass::DerivativeType;
  using DerivativeValueType = typename DerivativeType::ValueType;

  using typename Superclass::NumberOfParametersType;

  void
  SetFixedObject(const ObjectType * object) override
  {
    auto * image = dynamic_cast<FixedImageType *>(const_cast<ObjectType *>(object));
    if (image != nullptr)
    {
      this->SetFixedImage(image);
    }
    else
    {
      itkExceptionStringMacro("Incorrect object type.  Should be an image.");
    }
  }

  void
  SetMovingObject(const ObjectType * object) override
  {
    auto * image = dynamic_cast<MovingImageType *>(const_cast<ObjectType *>(object));
    if (image != nullptr)
    {
      this->SetMovingImage(image);
    }
    else
    {
      itkExceptionStringMacro("Incorrect object type.  Should be an image.");
    }
  }
 
  /* Get/Set the Fixed Image.  */
  itkSetConstObjectMacro(FixedImage, FixedImageType);
  itkGetConstObjectMacro(FixedImage, FixedImageType);

  itkSetConstObjectMacro(MovingImage, MovingImageType);
  itkGetConstObjectMacro(MovingImage, MovingImageType);

  itkSetObjectMacro(FixedInterpolator, FixedInterpolatorType);

  itkGetModifiableObjectMacro(FixedInterpolator, FixedInterpolatorType);

  itkSetObjectMacro(MovingInterpolator, MovingInterpolatorType);

  itkGetModifiableObjectMacro(MovingInterpolator, MovingInterpolatorType);

#ifndef ITK_FUTURE_LEGACY_REMOVE
  virtual void
  SetMovingImageMask(MovingImageMaskType * const arg)
  {
    const auto * const constArg = arg;
    // Call the overload defined by itkSetConstObjectMacro, or an override.
    this->SetMovingImageMask(constArg);
  }
#endif
  itkSetConstObjectMacro(MovingImageMask, MovingImageMaskType);
  itkGetConstObjectMacro(MovingImageMask, MovingImageMaskType);
#ifndef ITK_FUTURE_LEGACY_REMOVE
  virtual void
  SetFixedImageMask(FixedImageMaskType * const arg)
  {
    const auto * const constArg = arg;
    // Call the overload defined by itkSetConstObjectMacro, or an override.
    this->SetFixedImageMask(constArg);
  }
#endif
  itkSetConstObjectMacro(FixedImageMask, FixedImageMaskType);
  itkGetConstObjectMacro(FixedImageMask, FixedImageMaskType);
#ifndef ITK_FUTURE_LEGACY_REMOVE
  virtual void
  SetFixedSampledPointSet(FixedSampledPointSetType * const arg)
  {
    const auto * const constArg = arg;
    // Call the overload defined by itkSetConstObjectMacro, or an override.
    this->SetFixedSampledPointSet(constArg);
  }
#endif
  itkSetConstObjectMacro(FixedSampledPointSet, FixedSampledPointSetType);
  itkGetConstObjectMacro(FixedSampledPointSet, FixedSampledPointSetType);
  itkSetObjectMacro(VirtualSampledPointSet, VirtualPointSetType);
  itkGetConstObjectMacro(VirtualSampledPointSet, VirtualPointSetType);
  itkSetMacro(UseSampledPointSet, bool);
  itkGetConstReferenceMacro(UseSampledPointSet, bool);
  itkBooleanMacro(UseSampledPointSet);
  itkSetMacro(UseVirtualSampledPointSet, bool);
  itkGetConstReferenceMacro(UseVirtualSampledPointSet, bool);
  itkBooleanMacro(UseVirtualSampledPointSet);
#if !defined(ITK_LEGACY_REMOVE)
  itkLegacyMacro(virtual void SetUseFixedSampledPointSet(bool v))
  {
    this->SetUseSampledPointSet(v);
  }
  itkLegacyMacro(virtual bool GetUseFixedSampledPointSet() const)
  {
    return this->GetUseSampledPointSet();
  }
  itkLegacyMacro(virtual void UseFixedSampledPointSetOn())
  {
    return this->UseSampledPointSetOn();
  }
  itkLegacyMacro(virtual void UseFixedSampledPointSetOff())
  {
    return this->UseSampledPointSetOff();
  }
#endif

  itkSetObjectMacro(FixedImageGradientFilter, FixedImageGradientFilterType);
  itkGetModifiableObjectMacro(FixedImageGradientFilter, FixedImageGradientFilterType);
  itkSetObjectMacro(MovingImageGradientFilter, MovingImageGradientFilterType);
  itkGetModifiableObjectMacro(MovingImageGradientFilter, MovingImageGradientFilterType);
  itkSetObjectMacro(FixedImageGradientCalculator, FixedImageGradientCalculatorType);
  itkGetModifiableObjectMacro(FixedImageGradientCalculator, FixedImageGradientCalculatorType);
  itkSetObjectMacro(MovingImageGradientCalculator, MovingImageGradientCalculatorType);
  itkGetModifiableObjectMacro(MovingImageGradientCalculator, MovingImageGradientCalculatorType);
  itkSetMacro(UseFixedImageGradientFilter, bool);
  itkGetConstReferenceMacro(UseFixedImageGradientFilter, bool);
  itkBooleanMacro(UseFixedImageGradientFilter);
  itkSetMacro(UseMovingImageGradientFilter, bool);
  itkGetConstReferenceMacro(UseMovingImageGradientFilter, bool);
  itkBooleanMacro(UseMovingImageGradientFilter);
  virtual ThreadIdType
  GetNumberOfWorkUnitsUsed() const;

  virtual void
  SetMaximumNumberOfWorkUnits(const ThreadIdType number);
  virtual ThreadIdType
  GetMaximumNumberOfWorkUnits() const;
#if !defined(ITK_LEGACY_REMOVE)
  itkLegacyMacro(virtual ThreadIdType GetNumberOfThreadsUsed() const)
  {
    return this->GetNumberOfWorkUnitsUsed();
  }

  itkLegacyMacro(virtual void SetMaximumNumberOfThreads(const ThreadIdType count))
  {
    this->SetMaximumNumberOfWorkUnits(count);
  }
  itkLegacyMacro(virtual ThreadIdType GetMaximumNumberOfThreads() const)
  {
    return this->GetMaximumNumberOfWorkUnits();
  }
#endif // !ITK_LEGACY_REMOVE

  virtual void
  FinalizeThread(const ThreadIdType /*threadId*/)
  { /*Do nothing by default */
  }

  itkGetModifiableObjectMacro(FixedImageGradientImage, FixedImageGradientImageType);

  itkGetModifiableObjectMacro(MovingImageGradientImage, MovingImageGradientImageType);

  SizeValueType
  GetNumberOfDomainPoints() const;

  itkSetMacro(UseFloatingPointCorrection, bool);
  itkGetConstReferenceMacro(UseFloatingPointCorrection, bool);
  itkBooleanMacro(UseFloatingPointCorrection);
  itkSetMacro(FloatingPointCorrectionResolution, DerivativeValueType);
  itkGetConstMacro(FloatingPointCorrectionResolution, DerivativeValueType);
  /* Initialize the metric before calling GetValue or GetDerivative.
   * Derived classes must call this Superclass version if they override
   * this to perform their own initialization.
   * \note This is meant to be called once for a particular metric setup.
   * That is, when used in registration, this method would be called once
   * before entering the registration loop, during which GetValue or
   * GetDerivative will be called repeatedly. It must be called again if
   * metric settings are changed before beginning a new registration. */
  void
  Initialize() override;
 
  MeasureType
  GetValue() const override;
 
  void
  GetDerivative(DerivativeType &) const override;

  void
  GetValueAndDerivative(MeasureType & value, DerivativeType & derivative) const override;

  itkGetConstReferenceMacro(NumberOfSkippedFixedSampledPoints, SizeValueType);
 
  bool
  SupportsArbitraryVirtualDomainSamples() const override
  {
    return true;
  }
 
  using typename Superclass::MetricCategoryType;

  MetricCategoryType
  GetMetricCategory() const override
  {
    return MetricCategoryType::IMAGE_METRIC;
  }
 
protected:
  /* Interpolators for image gradient filters. */
  using FixedImageGradientInterpolatorType =
    LinearInterpolateImageFunction<FixedImageGradientImageType, CoordinateRepresentationType>;
  using MovingImageGradientInterpolatorType =
    LinearInterpolateImageFunction<MovingImageGradientImageType, CoordinateRepresentationType>;
 
  friend class ImageToImageMetricv4GetValueAndDerivativeThreaderBase<
    ThreadedImageRegionPartitioner<VirtualImageDimension>,
    Self>;
  friend class ImageToImageMetricv4GetValueAndDerivativeThreaderBase<ThreadedIndexedContainerPartitioner, Self>;
  friend class ImageToImageMetricv4GetValueAndDerivativeThreader<ThreadedImageRegionPartitioner<VirtualImageDimension>,
                                                                 Self>;
  friend class ImageToImageMetricv4GetValueAndDerivativeThreader<ThreadedIndexedContainerPartitioner, Self>;
 
  /* A DenseGetValueAndDerivativeThreader
   * Derived classes must define this class and assign it in their constructor
   * if threaded processing in GetValueAndDerivative is performed. */
  typename ImageToImageMetricv4GetValueAndDerivativeThreader<ThreadedImageRegionPartitioner<VirtualImageDimension>,
                                                             Self>::Pointer m_DenseGetValueAndDerivativeThreader;
  /* A SparseGetValueAndDerivativeThreader
   * Derived classes must define this class and assign it in their constructor
   * if threaded processing in GetValueAndDerivative is performed. */
  typename ImageToImageMetricv4GetValueAndDerivativeThreader<ThreadedIndexedContainerPartitioner, Self>::Pointer
    m_SparseGetValueAndDerivativeThreader;

  virtual void
  InitializeForIteration() const;

  bool
  TransformAndEvaluateFixedPoint(const VirtualPointType & virtualPoint,
                                 FixedImagePointType &    mappedFixedPoint,
                                 FixedImagePixelType &    mappedFixedPixelValue) const;

  bool
  TransformAndEvaluateMovingPoint(const VirtualPointType & virtualPoint,
                                  MovingImagePointType &   mappedMovingPoint,
                                  MovingImagePixelType &   mappedMovingPixelValue) const;

  virtual void
  ComputeFixedImageGradientAtPoint(const FixedImagePointType & mappedPoint, FixedImageGradientType & gradient) const;

  virtual void
  ComputeMovingImageGradientAtPoint(const MovingImagePointType & mappedPoint, MovingImageGradientType & gradient) const;

  virtual void
  ComputeFixedImageGradientFilterImage();

  virtual void
  ComputeMovingImageGradientFilterImage() const;

  virtual void
  GetValueAndDerivativeExecute() const;

  virtual void
  InitializeDefaultFixedImageGradientFilter();
  virtual void
  InitializeDefaultMovingImageGradientFilter();
  itkGetConstMacro(ComputeDerivative, bool);
 
  FixedImageConstPointer  m_FixedImage{};
  MovingImageConstPointer m_MovingImage{};

  FixedInterpolatorPointer                              m_FixedInterpolator{};
  MovingInterpolatorPointer                             m_MovingInterpolator{};
  typename FixedImageGradientInterpolatorType::Pointer  m_FixedImageGradientInterpolator{};
  typename MovingImageGradientInterpolatorType::Pointer m_MovingImageGradientInterpolator{};

  bool m_UseFixedImageGradientFilter{};
  bool m_UseMovingImageGradientFilter{};

  FixedImageGradientFilterPointer  m_FixedImageGradientFilter{};
  MovingImageGradientFilterPointer m_MovingImageGradientFilter{};

  typename DefaultFixedImageGradientFilter::Pointer  m_DefaultFixedImageGradientFilter{};
  typename DefaultMovingImageGradientFilter::Pointer m_DefaultMovingImageGradientFilter{};

  typename DefaultFixedImageGradientCalculator::Pointer  m_DefaultFixedImageGradientCalculator{};
  typename DefaultMovingImageGradientCalculator::Pointer m_DefaultMovingImageGradientCalculator{};

  mutable FixedImageGradientImagePointer  m_FixedImageGradientImage{};
  mutable MovingImageGradientImagePointer m_MovingImageGradientImage{};

  FixedImageGradientCalculatorPointer  m_FixedImageGradientCalculator{};
  MovingImageGradientCalculatorPointer m_MovingImageGradientCalculator{};

  mutable DerivativeType * m_DerivativeResult{};

  FixedImageMaskConstPointer  m_FixedImageMask{};
  MovingImageMaskConstPointer m_MovingImageMask{};

  FixedSampledPointSetConstPointer m_FixedSampledPointSet{};
  VirtualPointSetPointer           m_VirtualSampledPointSet{};

  bool m_UseSampledPointSet{};

  bool m_UseVirtualSampledPointSet{};
 
  ImageToImageMetricv4();
  ~ImageToImageMetricv4() override = default;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
private:
  void
  MapFixedSampledPointSetToVirtual();

  void
  LocalTransformPoint(const typename FixedTransformType::OutputPointType & virtualPoint,
                      typename FixedTransformType::OutputPointType &       mappedFixedPoint) const
  {
    mappedFixedPoint = this->m_FixedTransform->TransformPoint(virtualPoint);
  }
  // cast the virtual point
  template <typename TVirtualPoint>
  void
  LocalTransformPoint(const TVirtualPoint &                          virtualPoint,
                      typename FixedTransformType::OutputPointType & mappedFixedPoint) const
  {
    typename FixedTransformType::OutputPointType localVirtualPoint;
 
    localVirtualPoint.CastFrom(virtualPoint);
 
    mappedFixedPoint = this->m_FixedTransform->TransformPoint(localVirtualPoint);
  }
  // cast the mapped Fixed Point
  template <typename TFixedImagePoint>
  void
  LocalTransformPoint(const typename FixedTransformType::OutputPointType & virtualPoint,
                      TFixedImagePoint &                                   mappedFixedPoint) const
  {
    typename FixedTransformType::OutputPointType localMappedFixedPoint;
    localMappedFixedPoint.CastFrom(mappedFixedPoint);
    localMappedFixedPoint = this->m_FixedTransform->TransformPoint(virtualPoint);
    mappedFixedPoint.CastFrom(localMappedFixedPoint);
  }
  // cast both mapped and fixed point.
  template <typename TVirtualPoint, typename TFixedImagePoint>
  void
  LocalTransformPoint(const TVirtualPoint & virtualPoint, TFixedImagePoint & mappedFixedPoint) const
  {
    typename FixedTransformType::OutputPointType localVirtualPoint;
    typename FixedTransformType::OutputPointType localMappedFixedPoint;
 
    localVirtualPoint.CastFrom(virtualPoint);
    localMappedFixedPoint.CastFrom(mappedFixedPoint);
 
    localMappedFixedPoint = this->m_FixedTransform->TransformPoint(localVirtualPoint);
    mappedFixedPoint.CastFrom(localMappedFixedPoint);
  }

  mutable bool m_HaveMadeGetValueWarning{};

  SizeValueType m_NumberOfSkippedFixedSampledPoints{};
 
  bool                m_UseFloatingPointCorrection{};
  DerivativeValueType m_FloatingPointCorrectionResolution{};
 
  MetricTraits m_MetricTraits{};

  mutable bool m_ComputeDerivative{};

  using FixedImagePixelValueType = typename PixelTraits<FixedImagePixelType>::ValueType;
  using MovingImagePixelValueType = typename PixelTraits<MovingImagePixelType>::ValueType;
  itkConceptMacro(OnlyDefinedForFloatingPointTypes0, (itk::Concept::IsFloatingPoint<FixedImagePixelValueType>));
  itkConceptMacro(OnlyDefinedForFloatingPointTypes1, (itk::Concept::IsFloatingPoint<MovingImagePixelValueType>));
};
} // namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkImageToImageMetricv4.hxx"
#endif
 
#endif