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 ITK_TEMPLATE_EXPORT CombinationImageToImageMetric : public AdvancedImageToImageMetric<TFixedImage, TMovingImage>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(CombinationImageToImageMetric);
 
  using Self = CombinationImageToImageMetric;
  using Superclass = AdvancedImageToImageMetric<TFixedImage, TMovingImage>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkTypeMacro(CombinationImageToImageMetric, AdvancedImageToImageMetric);
 
  itkNewMacro(Self);
 
  itkStaticConstMacro(MovingImageDimension, unsigned int, TMovingImage::ImageDimension);
  itkStaticConstMacro(FixedImageDimension, unsigned int, TFixedImage::ImageDimension);
 
  using typename Superclass::CoordinateRepresentationType;
  using typename Superclass::MovingImageType;
  using typename Superclass::MovingImagePixelType;
  // using typename Superclass::MovingImagePointer;
  using typename Superclass::MovingImageConstPointer;
  using typename Superclass::FixedImageType;
  // using typename Superclass::FixedImagePointer;
  using typename Superclass::FixedImageConstPointer;
  using typename Superclass::FixedImageRegionType;
  using TransformType = typename Superclass::AdvancedTransformType;
  using TransformPointer = typename TransformType::Pointer;
  using typename Superclass::InputPointType;
  using typename Superclass::OutputPointType;
  using typename Superclass::TransformParametersType;
  using typename Superclass::TransformJacobianType;
  using typename Superclass::InterpolatorType;
  using typename Superclass::InterpolatorPointer;
  using typename Superclass::RealType;
  using typename Superclass::GradientPixelType;
  using typename Superclass::GradientImageType;
  using typename Superclass::GradientImagePointer;
  using typename Superclass::GradientImageFilterType;
  using typename Superclass::GradientImageFilterPointer;
  using typename Superclass::FixedImageMaskType;
  using typename Superclass::FixedImageMaskPointer;
  using typename Superclass::MovingImageMaskType;
  using typename Superclass::MovingImageMaskPointer;
  using typename Superclass::MeasureType;
  using typename Superclass::DerivativeType;
  using typename Superclass::DerivativeValueType;
  using typename Superclass::ParametersType;
 
  using typename Superclass::HessianValueType;
  using typename Superclass::HessianType;
 
  using ImageMetricType = Superclass;
  using ImageMetricPointer = typename ImageMetricType::Pointer;
  using SingleValuedCostFunctionType = SingleValuedCostFunction;
  using SingleValuedCostFunctionPointer = typename SingleValuedCostFunctionType::Pointer;
 
  using FixedImagePixelType = typename FixedImageType::PixelType;
  using MovingImageRegionType = typename MovingImageType::RegionType;
  using MovingImageDerivativeScalesType = FixedArray<double, Self::MovingImageDimension>;
 
  using FixedPointSetType = PointSet<CoordinateRepresentationType,
                                     TFixedImage::ImageDimension,
                                     DefaultStaticMeshTraits<CoordinateRepresentationType,
                                                             TFixedImage::ImageDimension,
                                                             TFixedImage::ImageDimension,
                                                             CoordinateRepresentationType,
                                                             CoordinateRepresentationType,
                                                             CoordinateRepresentationType>>;
  using MovingPointSetType = PointSet<CoordinateRepresentationType,
                                      TMovingImage::ImageDimension,
                                      DefaultStaticMeshTraits<CoordinateRepresentationType,
                                                              TMovingImage::ImageDimension,
                                                              TMovingImage::ImageDimension,
                                                              CoordinateRepresentationType,
                                                              CoordinateRepresentationType,
                                                              CoordinateRepresentationType>>;
  using PointSetMetricType = SingleValuedPointSetToPointSetMetric<FixedPointSetType, MovingPointSetType>;
 
  using typename Superclass::ThreaderType;
  using typename Superclass::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);
  itkGetConstMacro(UseRelativeWeights, bool);
 
  void
  SetUseMetric(const bool use, const unsigned int pos);
 
  void
  SetUseAllMetrics();
 
  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() 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() 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() 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() 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() 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() 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() const override
  {
    return this->GetMovingImageMask(0);
  }
 
 
  const SizeValueType &
  GetNumberOfPixelsCounted() const override;
 
  void
  Initialize() 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 = default;
  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:
  void
  InitializeThreadingParameters() const override;
 
  double
  GetFinalMetricWeight(unsigned int pos) const;
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkCombinationImageToImageMetric.hxx"
#endif
 
#endif // end #ifndef itkCombinationImageToImageMetric_h