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, int N= 3, class V=default_env>
# define TMPL  template<class C, int N, class V>
# define TMPL1 template<class K>
# define SELF   point<C,N,V>
# define Viewer viewer<axel,W>
# define Ostream std::ostream

# undef Scalar

namespace mmx {
namespace shape {

TMPL_DEF class point; // TMPL_DEF struct point;

//--------------------------------------------------------------------
struct point_def {}; 
template<class C>   struct use<point_def,C>
{
  //  typedef typename use<scalar_def,K>::Scalar Scalar;
  typedef point<C> 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=0, 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) ;

  // Linear Algebra operations
  point operator+(const point &v)const; //Addition
  point operator-(const point &v)const; //Substraction
  point operator*(const Scalar&k)const; //Multiplication by Scalar
  point operator/(const Scalar&k)const
  { return *this*( Scalar(1)/k); };     //Division by Scalar
  point operator*(const point &v)const; //Coordinate-wise Product

  point operator+=(const point &v)const //Addition
  {return *this+v; };
  point operator-=(const point &v)const //Substraction
  {return *this-v; };
  point operator*=(const Scalar&k)const //Multiplication by Scalar
  {return *this*k; };
  point operator*=(const point &v)const //Coordinate-wise Product
  {return *this*v; };

  point  operator-()const;              //Negative of a point
  point  cross(const point &v) const;   //Cross Product
  Scalar dot(point v2)const;            //Dot Product
  Scalar dist2(point v2)const;          //Distance Product
  Scalar norm() const;                  //L2 Norm

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
SELF SELF::operator +(const SELF &v)const  //Addition
{
        SELF res;
        res.x() = m_x + v.x();
        res.y() = m_y + v.y();
        res.z() = m_z + v.z();
        return res;
}

TMPL
SELF SELF::operator -(const SELF &v)const  //Subtraction
{
        SELF res;
        res.x() = m_x - v.x();
        res.y() = m_y - v.y();
        res.z() = m_z - v.z();
        return res;
}

TMPL
SELF SELF::operator *(const Scalar &k)const  //Multiplication By Scalar
{
        SELF res;
        res.x() = k * m_x;
        res.y() = k * m_y;
        res.z() = k * m_z;
        return res;
}

TMPL
SELF operator *(typename SELF::Scalar k,const SELF &v) //Left multiplication By Scalar
{
        return v * k;
}

TMPL
SELF SELF::operator -()const   //Negative Of a point
{
        SELF res;
        res.x() = -m_x;
        res.y() = -m_y;
        res.z() = -m_z;
        return res;
}

TMPL
SELF SELF::operator *(const SELF &v)const // Coordinate-wise Product
{
        SELF res;
        res.x() = m_x * v.x();
        res.y() = m_y * v.y();
        res.z() = m_z * v.z();
        return res;
}


TMPL
SELF SELF::cross(const SELF &v)const //Cross Product
{
        SELF res;
        res.x() = (m_y * v.z()) - (m_z * v.y());
        res.y() = (m_z * v.x()) - (m_x * v.z());
        res.z() = (m_x * v.y()) - (m_y * v.x());
        return res;
}

TMPL
SELF cross(const SELF v1, const SELF v2) //Cross Product of 2 points
{
  return v1.cross(v2);
}

TMPL
typename SELF::Scalar SELF::dot(const SELF v2) const //Dot product
{
  return (m_x * v2.x())+(m_y * v2.y())+(m_z * v2.z());
}

TMPL
typename SELF::Scalar SELF::dist2(const SELF v2) const //Dot product
{
  return (m_x - v2.x())*(m_x - v2.x())
    +(m_y - v2.y())*(m_y - v2.y())
    +(m_z - v2.z())*(m_z - v2.z());
}
TMPL
typename SELF::Scalar dot(const SELF v1, const SELF v2) //Dot product of 2 points
{
  return v1.dot(v2);
}

TMPL
typename SELF::Scalar SELF::norm() const   //Norm
{
  return std::sqrt( this->dot(*this) );
}

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;
}
//--------------------------------------------------------------------
TMPL void
print (Ostream& os, const SELF& p) {
  os <<(char *)"("<<p.x()<<(char *)","<<p.y()<<(char *)","<<p.z()<<(char *)")";
}
//--------------------------------------------------------------------
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

---