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
 *
 *         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 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 NPointDimension = 3>
class ITK_TEMPLATE_EXPORT Point : public FixedArray<TCoordRep, NPointDimension>
{
public:
 
  using Self = Point;
  using Superclass = FixedArray<TCoordRep, NPointDimension>;
 
  using ValueType = TCoordRep;
  using CoordRepType = TCoordRep;
 
  using RealType = typename NumericTraits<ValueType>::RealType;
 
  static constexpr unsigned int PointDimension = NPointDimension;
 
  using BaseArray = FixedArray<TCoordRep, NPointDimension>;
  using Iterator = typename BaseArray::Iterator;
  using ConstIterator = typename BaseArray::ConstIterator;
 
  static unsigned int
  GetPointDimension()
  {
    return NPointDimension;
  }
 
  using VectorType = Vector<ValueType, NPointDimension>;
 
  Point() = default;
  Point(const Point &) = default;
  Point(Point &&) = default;
  Point &
  operator=(const Point &) = default;
  Point &
  operator=(Point &&) = default;
  ~Point() = default;
 
  template <typename TPointValueType>
  Point(const Point<TPointValueType, NPointDimension> & r)
    : BaseArray(r)
  {}
 
  template <typename TPointValueType>
  Point(const TPointValueType r[NPointDimension])
    : BaseArray(r)
  {}
  Point(const ValueType r[NPointDimension])
    : BaseArray(r)
  {}
 
  template <typename TPointValueType>
  Point(const TPointValueType & v)
    : BaseArray(v)
  {}
  Point(const ValueType & v)
    : BaseArray(v)
  {}
 
  explicit Point(const std::array<ValueType, NPointDimension> & stdArray)
    : BaseArray(stdArray)
  {}
 
  Point &
  operator=(const ValueType r[NPointDimension]);
 
  bool
  operator==(const Self & pt) const
  {
    bool same = true;
 
    for (unsigned int i = 0; i < NPointDimension && same; ++i)
    {
      same = (Math::ExactlyEquals((*this)[i], pt[i]));
    }
    return same;
  }
 
  bool
  operator!=(const Self & pt) const
  {
    bool same = true;
 
    for (unsigned int i = 0; i < NPointDimension && same; ++i)
    {
      same = (Math::ExactlyEquals((*this)[i], pt[i]));
    }
    return !same;
  }
 
  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, NPointDimension> & pa)
  {
    for (unsigned int i = 0; i < NPointDimension; i++)
    {
      (*this)[i] = static_cast<TCoordRep>(pa[i]);
    }
  }
 
  template <typename TCoordRepB>
  RealType
  SquaredEuclideanDistanceTo(const Point<TCoordRepB, NPointDimension> & pa) const
  {
    RealType sum = NumericTraits<RealType>::ZeroValue();
 
    for (unsigned int i = 0; i < NPointDimension; 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, NPointDimension> & pa) const
  {
    const double distance = std::sqrt(static_cast<double>(this->SquaredEuclideanDistanceTo(pa)));
 
    return static_cast<RealType>(distance);
  }
};
 
template <typename T, unsigned int NPointDimension>
std::ostream &
operator<<(std::ostream & os, const Point<T, NPointDimension> & vct);
 
template <typename T, unsigned int NPointDimension>
std::istream &
operator>>(std::istream & is, Point<T, NPointDimension> & 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;
 
  BarycentricCombination() = default;
  ~BarycentricCombination() = default;
 
  static PointType
  Evaluate(const PointContainerPointer & points, const WeightContainerType & weights);
};
 
 
template <typename TCoordRep, unsigned int NPointDimension>
inline void
swap(Point<TCoordRep, NPointDimension> & a, Point<TCoordRep, NPointDimension> & b)
{
  a.swap(b);
}
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkPoint.hxx"
#endif
 
#endif