itkPoint.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkPoint.h,v $
  Language:  C++
  Date:      $Date: 2010-03-24 21:51:55 $
  Version:   $Revision: 1.70 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkPoint_h
#define __itkPoint_h

#include "itkFixedArray.h"

#include "itkNumericTraits.h"
#include "itkVector.h"

#include <vnl/vnl_vector_ref.h>

namespace itk
{
template<class 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< class TPointValueType >
  Point(const Point< TPointValueType, NPointDimension>& r): BaseArray(r) {}
  Point(const ValueType r[PointDimension]): BaseArray(r) {}  
    
  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 < PointDimension && same; i++)
      { same = ((*this)[i] == pt[i]); }
    return same;
    }

  bool
  operator!=(const Self &pt) const
    {
    bool same=true;
    for (unsigned int i=0; i < PointDimension && same; i++)
      { same = ((*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( void );

  vnl_vector<TCoordRep> GetVnlVector( void ) const;

  vnl_vector_ref<TCoordRep> Get_vnl_vector( void );

  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 >::Zero;
    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 = vcl_sqrt(
      static_cast<double>( this->SquaredEuclideanDistanceTo( pa ) ) );
    return static_cast<RealType>( distance );
    }

};

template< class T, unsigned int NPointDimension >  
ITK_EXPORT std::ostream& operator<<(std::ostream& os, 
                                    const Point<T,NPointDimension> & v); 

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

template< class TPointContainer, class TWeightContainer >
ITK_EXPORT 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

// Define instantiation macro for this template.
#define ITK_TEMPLATE_Point(_, EXPORT, x, y) namespace itk { \
  _(2(class EXPORT Point< ITK_TEMPLATE_2 x >)) \
  _(1(EXPORT std::ostream& operator<<(std::ostream&, \
                                      const Point< ITK_TEMPLATE_2 x >&))) \
  _(1(EXPORT std::istream& operator>>(std::istream&, \
                                      Point< ITK_TEMPLATE_2 x >&))) \
  namespace Templates { typedef Point< ITK_TEMPLATE_2 x > Point##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkPoint+-.h"
#endif

#if ITK_TEMPLATE_TXX
# include "itkPoint.txx"
#endif

#endif