/Users/mourrain/Devel/mmx/shape/include/shape/curve_pl.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 & bernard Mourrain
 *****************************************************************************
 *               Copyright (C) 2006 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/

# ifndef shape_curve_pl_hpp
# define shape_curve_pl_hpp

# include <realroot/Seq.hpp>
# include <shape/vertex.hpp>
# include <shape/edge_set.hpp>
# include <shape/curve.hpp>

# define TMPL     template<class C, class V>
# define TMPL1    template<class V>
# define REF     REF_OF(V)
# define SELF  curve_pl<C,V>
# define Viewer viewer<axel,V>

namespace mmx {
namespace shape {


template<class C, class V=default_env>
class curve_pl : public edge_set<C,REF>
{
public:
  typedef curve<V>            Curve;
  typedef edge_set<C,REF>     EdgeSet;
  typedef point<C,REF>        Point;
  typedef bounding_box<C,REF> BoundingBox;
  typedef edge<C,REF>         Edge;

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

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

  void clear(void) ;

  
  Seq<Point *> criticalpoints(void) ;
  Seq<Point *> extremalpoints(void) ;
  Seq<Point *> singularpoints(void) ;

private:
  Seq<Edge>  m_edges ;
} ;

TMPL SELF::curve_pl(void) : Curve(), EdgeSet() {}
TMPL SELF::curve_pl(unsigned np, unsigned ne) : Curve(), EdgeSet(np) {
  m_edges.resize(ne);
}

TMPL SELF::curve_pl(const BoundingBox & box) : Curve(box), EdgeSet() {}

TMPL SELF::~curve_pl(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::clear(void) {
  this->EdgeSet::clear() ;
}

// 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 SELF&
operator<<(SELF& c, const typename SELF::Edge& e) {
  c.m_edges<< e;
  return c;
}
//--------------------------------------------------------------------
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()<<" "
     <<s->nbv()<<" "
     <<s->nbe()<<"\n";
  for(unsigned i=0; i<s->nbe();i++) out<<"2 ";
  out<<"\n";
  for(unsigned i=0; i<s->nbv();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.314 0.979 1 1\n";
  out<<" </vect>\n </curve>\n";
  return out;
}
//====================================================================
} ; // namespace shape
} ; // namespace mmx
//====================================================================
# undef TMPL
# undef TMPL1
# undef SELF
# undef Viewer
# endif // shape_curve_pl_hpp