/Users/mourrain/Devel/mmx/shape/include/shape/point.hpp

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * point
 * 2010-08-17
 * Bernard Mourrain & Julien Wintz
 *****************************************************************************
 *               Copyright (C) 2006 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/

# ifndef shape_point_hpp
# define shape_point_hpp

# include <math.h>
# include <realroot/Seq.hpp>
# include <shape/shape.hpp>

# define TMPL_DEF template<class C, class V=REF_OF(C), int N=3>
# define TMPL  template<class C, class V, int N>
# define TMPL1 template<class K>
# define SELF   point<C,V,N>
# define Viewer viewer<axel,W>
# define Ostream std::ostream

# undef Scalar


namespace mmx {
namespace shape {


TMPL_DEF struct point;

//--------------------------------------------------------------------
struct point_def {}; 
template<>   struct use<point_def>
{
  //  typedef typename use<scalar_def,K>::Scalar Scalar;
  typedef point<double> Point;

  template<class SEQ,class POINT>
  static inline void point_insertor(SEQ& vertices, POINT* p) {
    vertices <<p;
  }

  template<class OSTREAM,class POINT>
  static inline void print_with_color(OSTREAM& out, const POINT& p) {
    out<<p.x()<<" "<<p.y()<<" "<<p.z()<<" 255 75 75";
  }
};

TMPL
class point : public SHAPE_OF(V)
{
public:
  typedef C   Scalar;
  typedef typename SHAPE_OF(V) Shape;

  point(void) ;
  point(Scalar x, Scalar y, Scalar z= 0) ;
  point(const SELF & p) ;
  
  inline Scalar  x(void) const { return m_x ; }
  inline Scalar& x(void)       { return m_x ; }
  inline Scalar  y(void) const { return m_y ; }
  inline Scalar& y(void)       { return m_y ; }
  inline Scalar  z(void) const { return m_z ; }
  inline Scalar& z(void)       { return m_z ; }

  Scalar   operator [] (const int & i) const ;
  Scalar & operator [] (const int & i) ;

  inline void setx(Scalar x) { this->m_x = x ; }
  inline void sety(Scalar y) { this->m_y = y ; }
  inline void setz(Scalar z) { this->m_z = z ; }

  bool     operator == (const point & other) const ;
  bool     operator != (const point & other) const ;
  SELF &  operator  = (const point & other) ;


private:
  Scalar m_x ;
  Scalar m_y ;
  Scalar m_z ;
};

TMPL
SELF::point(void) : Shape()
{
  this->m_x = (Scalar)0 ;
  this->m_y = (Scalar)0 ;
  this->m_z = (Scalar)0 ;
}

TMPL
SELF::point(Scalar x, Scalar y, Scalar z) : Shape()
{
  this->m_x = x ;
  this->m_y = y ;
  this->m_z = z ;
}
TMPL
SELF::point(const SELF & other) : Shape()
{
  this->m_x = other.x() ;
  this->m_y = other.y() ;
  this->m_z = other.z() ;
}

TMPL
SELF & SELF::operator = (const SELF & other) 
{
  if(this == &other)
    return *this ;
  
  this->m_x = other.x() ;
  this->m_y = other.y() ;
  this->m_z = other.z() ;
  
  return * this ;
}

TMPL bool 
SELF::operator == (const SELF & other) const {
  return ((m_x == other.x()) && (m_y == other.y()) && (m_z == other.z())) ;
}

TMPL bool 
SELF::operator != (const SELF & other) const {
  return ((m_x != other.x()) || (m_y != other.y()) || (m_z != other.z())) ;
}

TMPL typename SELF::Scalar & SELF::operator [] (const int & i) {
  switch(i) {
  case 0:
    return m_x ; 
    break ;
  case 1:
    return m_y ;
        break ;
  case 2:
    return m_z ;
    break ;
  default:
        break ;
  }
  
  return *(new Scalar(0)) ;
}

TMPL typename SELF::Scalar
SELF::operator [] (const int & i) const {
  switch(i) {
  case 0:
    return m_x ; 
    break ;
  case 1:
    return m_y ;
        break ;
  case 2:
    return m_z ;
    break ;
    default:
      break ;
  }
  
  return (Scalar)0 ;
}

TMPL inline typename SELF::Scalar read (const SELF& v, unsigned i) {
 return v[i]; 
}

TMPL inline typename SELF::Scalar distance (const SELF& p1, const SELF& p2) {
  typename SELF::Scalar d=0;
  d += (p1.x()-p2.x())*(p1.x()-p2.x());
  d += (p1.y()-p2.y())*(p1.y()-p2.y());
  d += (p1.z()-p2.z())*(p1.z()-p2.z());
  return std::sqrt(d);
}

//--------------------------------------------------------------------
TMPL Ostream&
operator<<(Ostream& os, const SELF& p) {
  os <<p.x()<<(char *)" "<<p.y()<<(char *)" "<<p.z();
  return os;
}
//--------------------------------------------------------------------
template<class O, class W> struct viewer; struct axel;
template<class W, class C, class V, int N>
Viewer&
operator<<(Viewer& os, const SELF& p) {
  os<<"<point color=\""<<(int)(255*os.color.r)<<" "<<(int)(255*os.color.g)<<" "<<(int)(255*os.color.b)<<"\">"
    <<p.x()<<" "<<p.y()<<" "<<p.z()
    <<"</point>\n";
  return os;
}
//--------------------------------------------------------------------

} ; // namespace mmx
} ; // namespace shape
//====================================================================
# undef TMPL_DEF
# undef TMPL
# undef TMPL1
# undef SELF
# undef Scalar
# undef Viewer
# undef Ostream
# endif // shape_point_hpp