Doxygen/html/itkPointSetToPointSetMetricv4_8h_source.html

/*=========================================================================

 *

 *  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 itkPointSetToPointSetMetricv4_h

#define itkPointSetToPointSetMetricv4_h


#include "itkPointSetToPointSetMetricWithIndexv4.h"


namespace itk

{

template <typename TFixedPointSet,

          typename TMovingPointSet = TFixedPointSet,

          class TInternalComputationValueType = double>

class ITK_TEMPLATE_EXPORT PointSetToPointSetMetricv4

  : public PointSetToPointSetMetricWithIndexv4<TFixedPointSet, TMovingPointSet, TInternalComputationValueType>

{

public:

  ITK_DISALLOW_COPY_AND_MOVE(PointSetToPointSetMetricv4);


  using Self = PointSetToPointSetMetricv4;

  using Superclass =

    PointSetToPointSetMetricWithIndexv4<TFixedPointSet, TMovingPointSet, TInternalComputationValueType>;

  using Pointer = SmartPointer<Self>;

  using ConstPointer = SmartPointer<const Self>;


  itkOverrideGetNameOfClassMacro(PointSetToPointSetMetricv4);


  using typename Superclass::MeasureType;


  using typename Superclass::ParametersType;

  using typename Superclass::ParametersValueType;

  using typename Superclass::NumberOfParametersType;


  using typename Superclass::DerivativeType;


  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 DisplacementFieldTransformType = typename Superclass::MovingDisplacementFieldTransformType;


  using typename Superclass::DimensionType;


  using FixedPointSetType = TFixedPointSet;

  using FixedPointType = typename TFixedPointSet::PointType;

  using FixedPixelType = typename TFixedPointSet::PixelType;

  using FixedPointsContainer = typename TFixedPointSet::PointsContainer;


  static constexpr DimensionType FixedPointDimension = Superclass::FixedPointDimension;


  using MovingPointSetType = TMovingPointSet;

  using MovingPointType = typename TMovingPointSet::PointType;

  using MovingPixelType = typename TMovingPointSet::PixelType;

  using MovingPointsContainer = typename TMovingPointSet::PointsContainer;


  static constexpr DimensionType MovingPointDimension = Superclass::MovingPointDimension;


  static constexpr DimensionType PointDimension = Superclass::PointDimension;


  using typename Superclass::PointType;

  using typename Superclass::PixelType;

  using CoordRepType = typename PointType::CoordRepType;

  using PointsContainer = FixedPointsContainer;

  using PointsConstIterator = typename PointsContainer::ConstIterator;

  using typename Superclass::PointIdentifier;


  using typename Superclass::PointsLocatorType;

  using NeighborsIdentifierType = typename PointsLocatorType::NeighborsIdentifierType;


  using typename Superclass::FixedTransformedPointSetType;

  using typename Superclass::MovingTransformedPointSetType;


  using typename Superclass::DerivativeValueType;

  using typename Superclass::LocalDerivativeType;


  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;


  virtual MeasureType

  GetLocalNeighborhoodValue(const PointType &, const PixelType & pixel) const = 0;


  virtual LocalDerivativeType

  GetLocalNeighborhoodDerivative(const PointType &, const PixelType & pixel) const;


  virtual void

  GetLocalNeighborhoodValueAndDerivative(const PointType &,

                                         MeasureType &,

                                         LocalDerivativeType &,

                                         const PixelType & pixel) const = 0;


protected:

  PointSetToPointSetMetricv4() = default;

  ~PointSetToPointSetMetricv4() override = default;


private:

  MeasureType

  GetLocalNeighborhoodValueWithIndex(const PointIdentifier &,

                                     const PointType & point,

                                     const PixelType & pixel) const override

  {

    return this->GetLocalNeighborhoodValue(point, pixel);

  }


  LocalDerivativeType

  GetLocalNeighborhoodDerivativeWithIndex(const PointIdentifier &,

                                          const PointType & point,

                                          const PixelType & pixel) const override

  {

    return this->GetLocalNeighborhoodDerivative(point, pixel);

  }


  void

  GetLocalNeighborhoodValueAndDerivativeWithIndex(const PointIdentifier &,

                                                  const PointType &     point,

                                                  MeasureType &         measure,

                                                  LocalDerivativeType & derivative,

                                                  const PixelType &     pixel) const override

  {

    this->GetLocalNeighborhoodValueAndDerivative(point, measure, derivative, pixel);

  }

};

} // end namespace itk


#ifndef ITK_MANUAL_INSTANTIATION

#  include "itkPointSetToPointSetMetricv4.hxx"

#endif


#endif