itkPoint.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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) {}

  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 weightA,  double weightB);

  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 > & v);

template< typename T, unsigned int NPointDimension >
std::istream & operator>>(std::istream & is,
                                     Point< T, NPointDimension > & v);

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