itkPoint.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkPoint.h,v $
  Language:  C++
  Date:      $Date: 2005/05/28 19:56:27 $
  Version:   $Revision: 1.62 $

  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 "itkVector.h"
#include "vnl/vnl_vector_ref.h"
#include "itkIndent.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() {}

  Point(const Self& 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 ValueType difference = (*this)[i] - component;
      sum += difference * difference;
      }
  return sum;
  }



  template < typename TCoordRepB >
  RealType EuclideanDistanceTo( const Point<TCoordRepB,NPointDimension> & pa ) const
  {
  const double distance = 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 );
};

#ifdef ITK_EXPLICIT_INSTANTIATION
   extern template class Point<float         ,2>;
   extern template class Point<double        ,2>;
   extern template class Point<float         ,3>;
   extern template class Point<double        ,3>;
#endif

}  // end namespace itk

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


#endif 

---