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

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * Curve_piecewise_linear
 * 2008-03-28
 * Julien Wintz
 *****************************************************************************
 *               Copyright (C) 2006 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/

# ifndef shape_edge_set_hpp
# define shape_edge_set_hpp

# include <realroot/Seq.hpp>
# include <shape/point_set.hpp>
# include <shape/edge.hpp>
# include <shape/bounding_box.hpp>
# include <shape/curve.hpp>

# define TMPL      template<class C, class V>
# define TMPL1     template<class V>
# define SELF      edge_set<C,V>
# define REF       REF_OF(V) 
# define Viewer    viewer<axel,V>
//====================================================================
namespace mmx {
  namespace shape {
//====================================================================
    template<class C, class V=default_env>
class edge_set : public curve<REF>, public point_set<C,REF>
{
public:
  typedef curve<REF>          Curve;
  typedef point_set<C,REF>    PointSet;
  typedef point<C,REF>        Point;
  typedef bounding_box<C,REF> BoundingBox;
  typedef edge<C,V>           Edge;

  edge_set(void) ;
  edge_set(unsigned np, unsigned ne=0) ;
  edge_set(const BoundingBox& box) ;
 ~edge_set(void) ;

  bool closed(void) ;
  bool opened(void) ;
  
  void sort(void) ;
  void link(void) ;
  
  void push_edge(Edge* e) ;
  
  void pop(Point * vertex) ;
  void pop(Edge * edge) ;

  void clear(void) ;

  
  inline Seq<Edge*>& edges(void) {
    return m_edges ;
  }

  Seq<Edge*> edges(void) const {
    return m_edges ;
  }

  const Edge& get_edge(unsigned i) const { return *(m_edges[i]) ; }
  Edge&       get_edge(unsigned i)       { return *(m_edges[i]) ; }

  SELF& operator<< (Edge * e) {m_edges.push_back(e); return *this;}

  inline unsigned nbe(void) const {
    return m_edges.size() ;
  }
  Seq<Point *> criticalpoints(void) ;
  Seq<Point *> extremalpoints(void) ;
  Seq<Point *> singularpoints(void) ;

private:
  Seq<Edge*>  m_edges ;
} ;

TMPL SELF::edge_set(void) : PointSet() {}
TMPL SELF::edge_set(unsigned np, unsigned ne) : PointSet(np), m_edges(ne) {}

TMPL SELF::edge_set(const BoundingBox & box) : Curve(box), PointSet() {}

TMPL SELF::~edge_set(void) {}

TMPL bool 
SELF::closed(void) { return false ; }

TMPL bool 
SELF::opened(void) { return false ; }

TMPL void 
SELF::link(void) {
  //  for(unsigned int i = 0 ; i < m_vertices.size()-1 ; i++)
  //    push(new Edge(at(m_vertices, i), at(m_vertices, i+1))) ;
}

TMPL void 
SELF::push_edge(Edge* e) {
  m_edges.push_back(e) ;
}

TMPL void 
SELF::pop(Point * vertex) {
  //    remove(m_vertices, vertex) ;
}

TMPL void 
SELF::pop(Edge * edge) {
  //    remove(m_edges, edge) ;
}

TMPL void 
SELF::clear(void) {
  this->PointSet::clear() ;
  m_edges.resize(0);
}

// Seq<Point *> SELF::criticalPoints(void) 
// {
//     Seq<Point *> l ;
//     // ...
//     return l ;
// }

// Seq<Point *> SELF::extremalPoints(void) 
// {
//     Seq<Point *> l ;
//     // ...
//     return l ;
// }

// Seq<Point *> SELF::singularPoints(void) 
// {
//     Seq<Point *> l ;
//     // ...
//     return l ;
// }
//--------------------------------------------------------------------
    TMPL struct viewer; struct axel;
TMPL Viewer&
operator<<(Viewer& out, const SELF& s) {
  typedef typename SELF::Edge Edge;
  out<<" <curve type=\"mesh\">\n<vect>\nVECT\n";
  out<<s.nbe()<<" "
     <<2*s.nbe()<<" "
     <<s.nbe()<<"\n";
  for(unsigned i=0; i<s.nbe();i++) out<<"2 ";
  out<<"\n";
  for(unsigned i=0; i<2*s.nbe();i++) out<<"1 ";
  out<<"\n";
  foreach(Edge* e, s.edges()) {
    out <<e->source()->x()<<" "
        <<e->source()->y()<<" "
        <<e->source()->z()<<" "
        <<e->destination()->x()<<" "
        <<e->destination()->y()<<" "
        <<e->destination()->z()<<"\n";
  }
  for(unsigned i=0; i<s.nbe();i++) 
    out<< "0.98 0.05 0.05 1\n";
  out<<" </vect>\n </curve>\n";
  return out;
}
//====================================================================
} ; // namespace shape
} ; // namespace mmx
//====================================================================
# undef TMPL
# undef TMPL1
# undef SELF
# undef REF
# endif // shape_edge_set_hpp