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 TCoordRep, unsigned int VPointDimension = 3>
class ITK_TEMPLATE_EXPORT Point : public FixedArray<TCoordRep, VPointDimension>
{
public:
 
  using Self = Point;
  using Superclass = FixedArray<TCoordRep, VPointDimension>;
 
  using ValueType = TCoordRep;
  using CoordRepType = TCoordRep;
 
  using RealType = typename NumericTraits<ValueType>::RealType;
 
  static constexpr unsigned int PointDimension = VPointDimension;
 
  using BaseArray = FixedArray<TCoordRep, 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<TCoordRep>
  GetVnlVector();
 
  vnl_vector<TCoordRep>
  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 TCoordRepB>
  void
  CastFrom(const Point<TCoordRepB, VPointDimension> & pa)
  {
    for (unsigned int i = 0; i < VPointDimension; ++i)
    {
      (*this)[i] = static_cast<TCoordRep>(pa[i]);
    }
  }
  template <typename TCoordRepB>
  RealType
  SquaredEuclideanDistanceTo(const Point<TCoordRepB, 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 TCoordRepB>
  RealType
  EuclideanDistanceTo(const Point<TCoordRepB, 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 TCoordRep, unsigned int VPointDimension>
inline void
swap(Point<TCoordRep, VPointDimension> & a, Point<TCoordRep, VPointDimension> & b)
{
  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