itkObjectToObjectMetric.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 itkObjectToObjectMetric_h
#define itkObjectToObjectMetric_h
 
 
#include "itkObjectToObjectMetricBase.h"
 
#include "itkDisplacementFieldTransform.h"
#include "itkImage.h"
#include "itkObject.h"
#include "itkPointSet.h"
#include "itkTransform.h"
 
namespace itk
{

template <unsigned int TFixedDimension,
          unsigned int TMovingDimension,
          typename TVirtualImage = Image<double, TFixedDimension>,
          typename TParametersValueType = double>
class ITK_TEMPLATE_EXPORT ObjectToObjectMetric : public ObjectToObjectMetricBaseTemplate<TParametersValueType>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ObjectToObjectMetric);

  using Self = ObjectToObjectMetric;
  using Superclass = ObjectToObjectMetricBaseTemplate<TParametersValueType>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkOverrideGetNameOfClassMacro(ObjectToObjectMetric);

  using CoordinateRepresentationType = TParametersValueType;

  using InternalComputationValueType = TParametersValueType;

  using typename Superclass::MeasureType;

  using ObjectType = typename Superclass::Object;

  using typename Superclass::DerivativeType;
  using typename Superclass::DerivativeValueType;

  using typename Superclass::ParametersType;
  using typename Superclass::NumberOfParametersType;
 
  using typename Superclass::GradientSourceEnum;

  using DimensionType = SizeValueType;

  static constexpr DimensionType FixedDimension = TFixedDimension;
  static constexpr DimensionType MovingDimension = TMovingDimension;
  static constexpr DimensionType VirtualDimension = TVirtualImage::ImageDimension;

  using VirtualImageType = TVirtualImage;
  using VirtualImagePointer = typename VirtualImageType::Pointer;
  using VirtualImageConstPointer = typename VirtualImageType::ConstPointer;
  using VirtualPixelType = typename VirtualImageType::PixelType;
  using VirtualRegionType = typename VirtualImageType::RegionType;
  using VirtualSizeType = typename VirtualRegionType::SizeType;
  using VirtualSpacingType = typename VirtualImageType::SpacingType;
  using VirtualOriginType = typename VirtualImageType::PointType;
  using VirtualPointType = typename VirtualImageType::PointType;
  using VirtualDirectionType = typename VirtualImageType::DirectionType;
  using VirtualRadiusType = typename VirtualImageType::SizeType;
  using VirtualIndexType = typename VirtualImageType::IndexType;

  using VirtualPointSetType = PointSet<VirtualPixelType, Self::VirtualDimension>;
  using VirtualPointSetPointer = typename VirtualPointSetType::Pointer;

  using MovingTransformType = Transform<TParametersValueType, TVirtualImage::ImageDimension, TMovingDimension>;
  using FixedTransformType = Transform<TParametersValueType, TVirtualImage::ImageDimension, TFixedDimension>;
 
  using FixedTransformPointer = typename FixedTransformType::Pointer;
  using FixedInputPointType = typename FixedTransformType::InputPointType;
  using FixedOutputPointType = typename FixedTransformType::OutputPointType;
  using FixedTransformParametersType = typename FixedTransformType::ParametersType;
 
  using MovingTransformPointer = typename MovingTransformType::Pointer;
  using MovingInputPointType = typename MovingTransformType::InputPointType;
  using MovingOutputPointType = typename MovingTransformType::OutputPointType;
  using MovingTransformParametersType = typename MovingTransformType::ParametersType;

  using JacobianType = typename FixedTransformType::JacobianType;
  using FixedTransformJacobianType = typename FixedTransformType::JacobianType;
  using MovingTransformJacobianType = typename MovingTransformType::JacobianType;

  using MovingDisplacementFieldTransformType =
    DisplacementFieldTransform<CoordinateRepresentationType, Self::MovingDimension>;
 
  void
  Initialize() override;
 
  NumberOfParametersType
  GetNumberOfParameters() const override;
  NumberOfParametersType
  GetNumberOfLocalParameters() const override;
  void
  SetParameters(ParametersType & params) override;
  const ParametersType &
  GetParameters() const override;
  bool
  HasLocalSupport() const override;
  void
  UpdateTransformParameters(const DerivativeType & derivative, TParametersValueType factor) override;

  itkSetObjectMacro(FixedTransform, FixedTransformType);

  itkGetModifiableObjectMacro(FixedTransform, FixedTransformType);

  itkSetObjectMacro(MovingTransform, MovingTransformType);

  itkGetModifiableObjectMacro(MovingTransform, MovingTransformType);

  void
  SetTransform(MovingTransformType * transform);

  const MovingTransformType *
  GetTransform();

  itkGetConstMacro(NumberOfValidPoints, SizeValueType);

  void
  SetVirtualDomain(const VirtualSpacingType &   spacing,
                   const VirtualOriginType &    origin,
                   const VirtualDirectionType & direction,
                   const VirtualRegionType &    region);

  void
  SetVirtualDomainFromImage(const VirtualImageType * virtualImage);

  virtual bool
  SupportsArbitraryVirtualDomainSamples() const = 0;

  virtual const TimeStamp &
  GetVirtualDomainTimeStamp() const;

  VirtualSpacingType
  GetVirtualSpacing() const;

  VirtualOriginType
  GetVirtualOrigin() const;

  VirtualDirectionType
  GetVirtualDirection() const;

  const VirtualRegionType &
  GetVirtualRegion() const;
 
  itkGetModifiableObjectMacro(VirtualImage, VirtualImageType);

  OffsetValueType
  ComputeParameterOffsetFromVirtualIndex(const VirtualIndexType &       index,
                                         const NumberOfParametersType & numberOfLocalParameters) const;

  OffsetValueType
  ComputeParameterOffsetFromVirtualPoint(const VirtualPointType &       point,
                                         const NumberOfParametersType & numberOfLocalParameters) const;

  bool
  IsInsideVirtualDomain(const VirtualPointType & point) const;
  bool
  IsInsideVirtualDomain(const VirtualIndexType & index) const;
 
  using MetricCategoryType = typename Superclass::MetricCategoryEnum;

  MetricCategoryType
  GetMetricCategory() const override
  {
    return MetricCategoryType::OBJECT_METRIC;
  }
 
protected:
  ObjectToObjectMetric();
  ~ObjectToObjectMetric() override = default;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override;

  virtual void
  VerifyDisplacementFieldSizeAndPhysicalSpace();
 
  bool
  TransformPhysicalPointToVirtualIndex(const VirtualPointType &, VirtualIndexType &) const;
  void
  TransformVirtualIndexToPhysicalPoint(const VirtualIndexType &, VirtualPointType &) const;

  const MovingDisplacementFieldTransformType *
  GetMovingDisplacementFieldTransform() const;

  bool
  VerifyNumberOfValidPoints(MeasureType & value, DerivativeType & derivative) const;

  FixedTransformPointer  m_FixedTransform{};
  MovingTransformPointer m_MovingTransform{};
 
  VirtualImagePointer m_VirtualImage{};

  bool m_UserHasSetVirtualDomain{};

  mutable SizeValueType m_NumberOfValidPoints{ 0 };
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkObjectToObjectMetric.hxx"
#endif
 
#endif