include/shape/point_with_idx.hpp

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * vertex
 * 2010-08-18
 * Bernard Mourrain & Julien Wintz
 *****************************************************************************
 *               Copyright (C) 2006 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/
# ifndef shape_point_with_idx_hpp
# define shape_point_with_idx_hpp

# include <shape/point.hpp>
# define TMPL_DEF template<class C, int N=3, class V=default_env>
# define TMPL  template<class C, int N, class V>
# define SELF point<C,N,with_idx<V> >
# undef Scalar
# undef Point
# define IDX -1
/*********************************************************************/
namespace mmx {
  namespace shape {
//====================================================================
template<class K> struct with_idx: public K {
  //  typedef typename use<point_with_idx_def,K>::Vertex Point;
};
template<class FF, class K> struct use<FF,with_idx<K> > 
  : public use<FF,K> {};

  template<class V> struct use<ref_def,with_idx<V> > {
    typedef with_idx<REF_OF(V)> Ref;
};
//--------------------------------------------------------------------
struct point_with_idx_def {};

template<> struct use<point_with_idx_def>
   : public use<point_def> {

  typedef point<double,3,with_idx<double> > Vertex;

  template<class SEQ, class VERTEX>
  static inline void point_insertor(SEQ& vertices, VERTEX *p) {
    //   std::cout<<p->x()<<" "<<p->y()<<" "<<p->z()<<" "<<p->index()<< " ";
    if(p->index()<0) {
      p->set_index(vertices.size());
      vertices << p; 
    }
    std::cout<<p->index()<<std::endl;
  }

};
//--------------------------------------------------------------------
TMPL
class point<C,N,with_idx<V> > : public point<C,N,V>
{
public:
  typedef C Scalar;
  typedef point<C,N,V> Point;

  point(void) ;
  point(Scalar x, Scalar y, Scalar z, int idx = IDX) ;
  point(const Point & p) ;
  point(const SELF& p) ;
  
  bool     operator == (const SELF & other) const ;
  bool     operator != (const SELF & other) const ;
  SELF & operator  = (const SELF & other) ;

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

  int index() const     {return m_idx;}
  int set_index(int i)  {m_idx=i;return m_idx;}

  int nface() const     {return m_nf;}
private:
  int  m_idx ;
  int  m_nf ;
};

TMPL
SELF::point(void) : Point(), m_idx(IDX), m_nf(IDX)
{
}

TMPL
SELF::point(Scalar x, Scalar y, Scalar z, int idx) :Point(x,y,z), m_idx(IDX), m_nf(idx)
{
}

TMPL
SELF::point(const Point& p) :Point(p), m_idx(IDX), m_nf(p.n_face())
{
}

TMPL
SELF::point(const SELF & other) : Point(other), m_idx(other.index()),  m_nf(other.nface())
{
}

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

TMPL bool 
SELF::operator == (const SELF & other) const {
  return ((this->x() == other.x()) && (this->y() == other.y()) && (this->z() == other.z())) ;
}

TMPL bool 
SELF::operator != (const SELF & other) const {
  return ((this->x() != other.x()) || (this->y() != other.y()) || (this->z() != other.z())) ;
}

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

//====================================================================
  } ; // namespace shape
} ; // namespace mmx
/*********************************************************************/
# undef TMPL_DEF
# undef TMPL
# undef SELF
# undef IDX
# endif // shape_point_with_idx_hpp

---