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"

namespace itk
{
template< typename TCoordRep, unsigned int NPointDimension = 3 >
class Point:public FixedArray< TCoordRep, NPointDimension >
{
public:
  typedef Point                                    Self;
  typedef FixedArray< TCoordRep, NPointDimension > Superclass;

  typedef TCoordRep ValueType;
  typedef TCoordRep CoordRepType;

  typedef typename NumericTraits< ValueType >::RealType RealType;

  itkStaticConstMacro(PointDimension, unsigned int, NPointDimension);

  typedef FixedArray< TCoordRep, NPointDimension > BaseArray;
  typedef typename BaseArray::Iterator             Iterator;
  typedef typename BaseArray::ConstIterator        ConstIterator;

  static unsigned int GetPointDimension()
  { return NPointDimension; }

  typedef Vector< ValueType, NPointDimension > VectorType;

  Point() {}

  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 Self & r);

  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 = ( ( *this )[i] == pt[i] ); }
    return same;
  }

  bool
  operator!=(const Self & pt) const
  {
    bool same = true;

CLANG_PRAGMA_PUSH
CLANG_SUPPRESS_Wfloat_equal
    for ( unsigned int i = 0; i < NPointDimension && same; ++i )
          { same = ( ( *this )[i] == pt[i] ); }
CLANG_PRAGMA_POP
    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;

  itkLegacyMacro(vnl_vector_ref< TCoordRep > Get_vnl_vector(void));

  itkLegacyMacro(vnl_vector< TCoordRep > Get_vnl_vector(void) 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 RealType 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 BarycentricCombination
{
public:
  typedef TPointContainer                      PointContainerType;
  typedef typename PointContainerType::Pointer PointContainerPointer;
  typedef typename PointContainerType::Element PointType;
  typedef TWeightContainer                     WeightContainerType;

  BarycentricCombination() {}
  ~BarycentricCombination() {}

  static PointType Evaluate(
    const PointContainerPointer & points,
    const WeightContainerType & weights);
};
}  // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkPoint.hxx"
#endif

#endif