Doxygen52/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

 *

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


  itkTypeMacro(PointSetToPointSetMetricv4, PointSetToPointSetMetricWithIndexv4);


  using MeasureType = typename Superclass::MeasureType;


  using ParametersType = typename Superclass::ParametersType;

  using ParametersValueType = typename Superclass::ParametersValueType;

  using NumberOfParametersType = typename Superclass::NumberOfParametersType;


  using DerivativeType = typename Superclass::DerivativeType;


  using FixedTransformType = typename Superclass::FixedTransformType;

  using FixedTransformPointer = typename Superclass::FixedTransformPointer;

  using FixedInputPointType = typename Superclass::FixedInputPointType;

  using FixedOutputPointType = typename Superclass::FixedOutputPointType;

  using FixedTransformParametersType = typename Superclass::FixedTransformParametersType;


  using MovingTransformType = typename Superclass::MovingTransformType;

  using MovingTransformPointer = typename Superclass::MovingTransformPointer;

  using MovingInputPointType = typename Superclass::MovingInputPointType;

  using MovingOutputPointType = typename Superclass::MovingOutputPointType;

  using MovingTransformParametersType = typename Superclass::MovingTransformParametersType;


  using JacobianType = typename Superclass::JacobianType;

  using FixedTransformJacobianType = typename Superclass::FixedTransformJacobianType;

  using MovingTransformJacobianType = typename Superclass::MovingTransformJacobianType;


  using DisplacementFieldTransformType = typename Superclass::MovingDisplacementFieldTransformType;


  using DimensionType = 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 PointType = typename Superclass::PointType;

  using PixelType = typename Superclass::PixelType;

  using CoordRepType = typename PointType::CoordRepType;

  using PointsContainer = FixedPointsContainer;

  using PointsConstIterator = typename PointsContainer::ConstIterator;

  using PointIdentifier = typename Superclass::PointIdentifier;


  using PointsLocatorType = typename Superclass::PointsLocatorType;

  using NeighborsIdentifierType = typename PointsLocatorType::NeighborsIdentifierType;


  using FixedTransformedPointSetType = typename Superclass::FixedTransformedPointSetType;

  using MovingTransformedPointSetType = typename Superclass::MovingTransformedPointSetType;


  using DerivativeValueType = typename Superclass::DerivativeValueType;

  using LocalDerivativeType = typename Superclass::LocalDerivativeType;


  using VirtualImageType = typename Superclass::VirtualImageType;

  using VirtualImagePointer = typename Superclass::VirtualImagePointer;

  using VirtualPixelType = typename Superclass::VirtualPixelType;

  using VirtualRegionType = typename Superclass::VirtualRegionType;

  using VirtualSizeType = typename Superclass::VirtualSizeType;

  using VirtualSpacingType = typename Superclass::VirtualSpacingType;

  using VirtualOriginType = typename Superclass::VirtualPointType;

  using VirtualPointType = typename Superclass::VirtualPointType;

  using VirtualDirectionType = typename Superclass::VirtualDirectionType;

  using VirtualRadiusType = typename Superclass::VirtualSizeType;

  using VirtualIndexType = typename Superclass::VirtualIndexType;

  using VirtualPointSetType = typename Superclass::VirtualPointSetType;

  using VirtualPointSetPointer = 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