itkPoint.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 itkPoint_h
#define itkPoint_h
 
 
#include "itkNumericTraits.h"
#include "itkVector.h"
 
#include "vnl/vnl_vector_ref.h"
#include "itkMath.h"
 
namespace itk
{
template <typename TCoordinate, unsigned int VPointDimension = 3>
class ITK_TEMPLATE_EXPORT Point : public FixedArray<TCoordinate, VPointDimension>
{
public:
  using Self = Point;
  using Superclass = FixedArray<TCoordinate, VPointDimension>;

  using ValueType = TCoordinate;
  using CoordinateType = TCoordinate;
#ifndef ITK_FUTURE_LEGACY_REMOVE
  using CoordRepType ITK_FUTURE_DEPRECATED(
    "ITK 6 discourages using `CoordRepType`. Please use `CoordinateType` instead!") = CoordinateType;
#endif
 
  using RealType = typename NumericTraits<ValueType>::RealType;

  static constexpr unsigned int PointDimension = VPointDimension;

  using BaseArray = FixedArray<TCoordinate, VPointDimension>;
  using Iterator = typename BaseArray::Iterator;
  using ConstIterator = typename BaseArray::ConstIterator;

  static unsigned int
  GetPointDimension()
  {
    return VPointDimension;
  }

  using VectorType = Vector<ValueType, VPointDimension>;

  Point() = default;

  template <typename TPointValueType>
  Point(const Point<TPointValueType, VPointDimension> & r)
    : BaseArray(r)
  {}

  template <typename TPointValueType>
  Point(const TPointValueType r[VPointDimension])
    : BaseArray(r)
  {}
  Point(const ValueType r[VPointDimension])
    : BaseArray(r)
  {}

#if defined(ITK_LEGACY_REMOVE)
  Point(std::nullptr_t) = delete;

  template <typename TPointValueType>
  explicit Point(const TPointValueType & v)
    : BaseArray(v)
  {}
  explicit Point(const ValueType & v)
    : BaseArray(v)
  {}
#else

  template <typename TPointValueType>
  Point(const TPointValueType & v)
    : BaseArray(v)
  {}
 
  Point(const ValueType & v)
    : BaseArray(v)
  {}
#endif

  explicit Point(const std::array<ValueType, VPointDimension> & stdArray)
    : BaseArray(stdArray)
  {}

  Point &
  operator=(const ValueType r[VPointDimension]);

  bool
  operator==(const Self & pt) const
  {
    return this->BaseArray::operator==(pt);
  }
 
  ITK_UNEQUAL_OPERATOR_MEMBER_FUNCTION(Self);

  const Self &
  operator+=(const VectorType & vec);

  const Self &
  operator-=(const VectorType & vec);

  VectorType
  operator-(const Self & pnt) const;

  Self
  operator+(const VectorType & vec) const;

  Self
  operator-(const VectorType & vec) const;

  VectorType
  GetVectorFromOrigin() const;

  vnl_vector_ref<TCoordinate>
  GetVnlVector();

  vnl_vector<TCoordinate>
  GetVnlVector() const;

  void
  SetToMidPoint(const Self &, const Self &);

  void
  SetToBarycentricCombination(const Self & A, const Self & B, double alpha);

  void
  SetToBarycentricCombination(const Self & A, const Self & B, const Self & C, double weightForA, double weightForB);

  void
  SetToBarycentricCombination(const Self * P, const double * weights, unsigned int N);

  template <typename TCoordinateB>
  void
  CastFrom(const Point<TCoordinateB, VPointDimension> & pa)
  {
    for (unsigned int i = 0; i < VPointDimension; ++i)
    {
      (*this)[i] = static_cast<TCoordinate>(pa[i]);
    }
  }

 
  template <typename TCoordinateB>
  RealType
  SquaredEuclideanDistanceTo(const Point<TCoordinateB, VPointDimension> & pa) const
  {
    RealType sum{};
 
    for (unsigned int i = 0; i < VPointDimension; ++i)
    {
      const auto     component = static_cast<RealType>(pa[i]);
      const RealType difference = static_cast<RealType>((*this)[i]) - component;
      sum += difference * difference;
    }
    return sum;
  }

  template <typename TCoordinateB>
  RealType
  EuclideanDistanceTo(const Point<TCoordinateB, VPointDimension> & pa) const
  {
    const double distance = std::sqrt(static_cast<double>(this->SquaredEuclideanDistanceTo(pa)));
 
    return static_cast<RealType>(distance);
  }
};
 
template <typename T, unsigned int VPointDimension>
std::ostream &
operator<<(std::ostream & os, const Point<T, VPointDimension> & vct);
 
template <typename T, unsigned int VPointDimension>
std::istream &
operator>>(std::istream & is, Point<T, VPointDimension> & vct);

template <typename TPointContainer, typename TWeightContainer>
class ITK_TEMPLATE_EXPORT BarycentricCombination
{
public:
  using PointContainerType = TPointContainer;
  using PointContainerPointer = typename PointContainerType::Pointer;
  using PointType = typename PointContainerType::Element;
  using WeightContainerType = TWeightContainer;
 
  static PointType
  Evaluate(const PointContainerPointer & points, const WeightContainerType & weights);
};
 
 
template <typename TCoordinate, unsigned int VPointDimension>
inline void
swap(Point<TCoordinate, VPointDimension> & a, Point<TCoordinate, VPointDimension> & b) noexcept
{
  a.swap(b);
}
 

template <typename TValue, typename... TVariadic>
auto
MakePoint(const TValue firstValue, const TVariadic... otherValues)
{
  static_assert(std::conjunction_v<std::is_same<TVariadic, TValue>...>,
                "The other values should have the same type as the first value.");
 
  constexpr unsigned int              dimension{ 1 + sizeof...(TVariadic) };
  const std::array<TValue, dimension> stdArray{ { firstValue, otherValues... } };
  return Point<TValue, dimension>{ stdArray };
}
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkPoint.hxx"
#endif
 
#endif