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

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * TopologyCurve
 * 2008-05-16
 * Julien Wintz & Bernard Mourrain
 *****************************************************************************
 *               Copyright (C) 2006 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/

# ifndef shape_mesher3d_curve_algebraic_hpp
# define shape_mesher3d_curve_algebraic_hpp

# include <shape/vertex.hpp>
# include <shape/edge.hpp>
# include <shape/face.hpp>
# include <shape/kdtree.hpp>
# include <shape/list.hpp>
# include <shape/graphic.hpp>
//# include <shape/algebraic_curve.hpp>
# include <shape/surface_algebraic.hpp>
//# include <shape/cell.hpp>
# include <shape/cell3d_algebraic_curve.hpp>
//# include <shape/cell3d_surface_algebraic.hpp>
//# include <shape/cell3d_list.hpp>
//# include <shape/tpl3d.hpp>
//# include <algorithm>
//# include <shape/with_vertex.hpp>

# undef mesher3d_curve_algebraic

# define TMPL template<class C, class V>
# define TMPL1 template<class V>

# define AlgebraicCurve         algebraic_curve<C,V>
# define AlgebraicSurface       surface_algebraic<C,V>
# define Cell3dAlgebraicCurve   cell3d_algebraic_curve<C,V>
# define Cell3dAlgebraicSurface cell3d_surface_algebraic<C,V>
# define Cell3dParametricCurve  cell3d_parametric_curve<C,V>
# define Cell3dList             cell3d_list<C,V>
# define SELF                   mesher3d_curve_algebraic<C,V> 

//====================================================================
namespace mmx { namespace shape {
//====================================================================
TMPL struct mesher3d_curve_algebraic;

struct mesher3d_curve_algebraic_def {};

template<class V>
struct use<mesher3d_curve_algebraic_def,V>
  : public use<vertex_def,V> 
  , public use<cell3d_def,V> 
  , public use<surface_def,V>
{ 
  //typedef typename use<tpl3d_def,V>::Point Point;
  typedef mesher3d_curve_algebraic<typename use<scalar_def,V>::Scalar,V> Topology3d; 

};

//--------------------------------------------------------------------
TMPL class cell_list ;
TMPL1 class surface ;
template <class Object, class CELL> class node;
template <class Object, class CELL> class kdtree;

//====================================================================
template<class C,class V=default_env>
class mesher3d_curve_algebraic : public SHAPE_OF(V) {
public:
  typedef typename SHAPE_OF(V)        Shape;
  typedef vertex<C,V>                 Point;  
  typedef edge<C,V, Point>            Edge;
  typedef face<C,V, Point>            Face;
  typedef cell<C,V>                   CellBase;
  typedef cell3d_algebraic_curve<C,V> Cell;
  typedef surface<V>                  Surface;

  typedef node<Surface *, Cell *>     Node;
  typedef kdtree<Surface *, Cell *>   Kdtree;
  //  typedef topology<C,V>                   Topology;
  typedef typename Cell::BoundingBox BoundingBox;
  
  mesher3d_curve_algebraic(const BoundingBox & bx)
    : m_maxprec(0.1), m_minprec(0.01), m_bbx(bx)  
  {
    m_tree = new Kdtree;
  }

  ~mesher3d_curve_algebraic(void) {
    delete m_tree ;
  }

  void set_precision (double eps) { m_minprec = eps; }
  void set_smoothness(double eps) { m_maxprec = eps; }

  void push_back(Shape * s)  { m_objects.push_back(s); }
  void operator<<(Shape * s) { m_objects.push_back(s); }
  unsigned count(void)       { return m_objects.size(); }

  int nbv() const { return m_vertices.size();}
  int nbe() const { return m_edges.size();}
  int nbf() const { return m_faces.size();}

  inline Seq<Point *>&       vertices(void)     { return m_vertices ; }
  inline const Seq<Point *>& vertices(void)const{ return m_vertices ; }
  inline Seq<Edge *>&        edges(void)        { return m_edges ; }
  inline const Seq<Edge *>&  edges(void) const  { return m_edges ; }
  inline Seq<Face *>&        faces(void)        { return m_faces ; }
  inline const Seq<Face *>&  faces(void) const  { return m_faces ; }
  
  virtual Point* vertices(int i)     { return m_vertices[i] ; }
  virtual Face*  faces(int i)        { return m_faces[i] ; }
  
  void run(void) ;

  virtual void insert(Point*);
  virtual void insert(Edge *);
  virtual void insert(Face *);
  virtual void insert(BoundingBox*, bool);

  virtual void clear();

          bool insert_regular (Cell * cell);
  virtual void insert_singular(Point*); ;
  virtual void insert_singular(BoundingBox* bx);

  const Kdtree* tree(void) const                 { return m_tree; }

  //  protected:
  bool is_regular  (Cell * cell);


  bool post_process(Cell * cell);
  bool sing_process(Cell * cell);
  bool subdivide   (Cell * cell, Node * node) ;

  int stopFlag;

private:
  Kdtree*             m_tree ;
  std::list<Node *>   m_nodes ;

  Seq<BoundingBox*>   m_specials;
  Seq<Point *>        m_vertices ;
  Seq<Edge  *>        m_edges ;
  Seq<Face  *>        m_faces ;

  double              m_maxprec ;
  double              m_minprec ;
  
  BoundingBox         m_bbx;
  Seq<Shape*>         m_objects;

};
//--------------------------------------------------------------------
TMPL void SELF::insert(BoundingBox *bx, bool cross=false) {
  Point 
    *p0= new Point(bx->xmin(),bx->ymin(),bx->zmin()),
    *p1= new Point(bx->xmin(),bx->ymax(),bx->zmin()),
    *p2= new Point(bx->xmax(),bx->ymax(),bx->zmin()),
    *p3= new Point(bx->xmax(),bx->ymin(),bx->zmin());
  
  this->insert(p0);this->insert(p1); this->insert(new Edge(p0,p1));
  this->insert(p1);this->insert(p2); this->insert(new Edge(p1,p2));
  this->insert(p2);this->insert(p3); this->insert(new Edge(p2,p3));
  this->insert(p3);this->insert(p0); this->insert(new Edge(p3,p0));
      
  Point 
    *q0= new Point(bx->xmin(),bx->ymin(),bx->zmax()),
    *q1= new Point(bx->xmin(),bx->ymax(),bx->zmax()),
    *q2= new Point(bx->xmax(),bx->ymax(),bx->zmax()),
    *q3= new Point(bx->xmax(),bx->ymin(),bx->zmax());
  
  this->insert(q0);this->insert(q1); this->insert(new Edge(q0,q1));
  this->insert(q1);this->insert(q2); this->insert(new Edge(q1,q2));
  this->insert(q2);this->insert(q3); this->insert(new Edge(q2,q3));
  this->insert(q3);this->insert(q0); this->insert(new Edge(q3,q0));
  
  this->insert(p0);this->insert(q0);this->insert(new Edge(p0,q0));
  this->insert(p1);this->insert(q1);this->insert(new Edge(p1,q1));
  this->insert(p2);this->insert(q2);this->insert(new Edge(p2,q2));
  this->insert(p3);this->insert(q3);this->insert(new Edge(p3,q3));

  if(cross) {
    Point 
      *r0= new Point(bx->xmin(),bx->ymin(),bx->zmax()),
      *r1= new Point(bx->xmin(),bx->ymax(),bx->zmax()),
      *r2= new Point(bx->xmax(),bx->ymax(),bx->zmax()),
      *r3= new Point(bx->xmax(),bx->ymin(),bx->zmax());

    this->insert(r0);this->insert(r2);this->insert(new Edge(r0,r2));
    this->insert(r1);this->insert(r3);this->insert(new Edge(r1,r3));
  }
}
//======================================================================
TMPL void 
SELF::run(void) {
  //no singularities are detected in the topology of the space algebraic curve. stopFlag is set to false(0)
  stopFlag=0;
  Node* root = m_tree->root();

  if(this->m_objects.size()==0) return;

  AlgebraicCurve* ic = dynamic_cast<AlgebraicCurve *>(*(this->m_objects.begin()));
  Cell* cl = new Cell3dAlgebraicCurve(ic, this->m_bbx);

//   foreach(Shape* s, m_objects) 
//     cl->push_back(SurfaceCellFactory::instance()->create(s,m_bbx)) ;
  
  root->set_cell(cl);
  m_nodes.push_back(root) ;
     
  double maxsz = this->m_maxprec*m_tree->root()->get_cell()->size();
  double minsz = this->m_minprec*m_tree->root()->get_cell()->size();

  while(!m_nodes.empty()) {
    Node* node = m_nodes.front() ;
    Cell* cl = node->get_cell() ;

    if(cl->is_active()) {
      if(cl->size() > maxsz) 
        { 
          this->subdivide(cl, node) ;
        } 
      else if(this->is_regular(cl)) 
        { 
          this->insert_regular(cl) ;
        } 
      else if(cl->size() > minsz ) 
        { 
          this->subdivide(cl, node) ;
        } 
      else { 
                  this->sing_process(cl);
                  //singularities are detected in the topology of the space algebraic curve. stopFlag is set to true(1)
                  stopFlag=1;
      }
    }
    m_nodes.pop_front() ;
  }
}

TMPL bool 
SELF::is_regular(Cell* cl) {
  return cl->is_regular();
}

TMPL bool 
SELF::insert_regular(Cell* cl) {
  return cl->inserted_regular_in(this);
}

TMPL bool 
SELF::post_process(Cell* cl) {
  return true;
}

TMPL bool 
SELF::sing_process(Cell* cl) {
  //the method insert_singular(Topology* t) from cell3d_algebraic_curve.hpp is used here!!
  return cl->inserted_singular_in(this) ;
}

TMPL bool 
SELF::subdivide(Cell* cl, Node * node) {

  int v = 0;
  Cell * left, * right;
  v = cl->subdivide(left, right) ;
  node->m_left = new Node(node, left,  Node::LEFT , v) ; m_nodes << node->m_left ;
  node->m_right= new Node(node, right, Node::RIGHT, v) ; m_nodes << node->m_right;

  return true ;
}

TMPL void 
SELF::insert(Point * p) {
  use<mesher3d_curve_algebraic_def,V>::point_insertor(this->m_vertices, p); 
}

TMPL void 
SELF::insert(Edge* e) {
  //  std::cout<<m_edges.size()<<"| "<<e->source()->index()<<" "<<e->destination()->index()<<std::endl;
  this->m_edges<<e;
}

TMPL void 
SELF::insert(Face * f) {
  this->m_faces<<f;
}

TMPL void 
SELF::insert_singular(BoundingBox * bx) {
        std::cout<<"Begin insert_singular"<<endl;
        this->m_specials<<bx;
        std::cout<<"End insert_singular"<<endl;
}

TMPL void 
SELF::insert_singular(Point * ) {
  std::cout<<"Begin insert_singular Uff"<<endl;
  //  m_specials<<p;
}

TMPL void
SELF::clear() {
        // Should we clean up these points?
        this->m_faces.resize( 0 );
        this->m_edges.resize( 0 );
        this->m_vertices.resize( 0 );
}
//--------------------------------------------------------------------
TMPL
graphic<C,V>* as_graphic(const SELF& tp) {

  typedef typename SELF::Point  Point; 
  typedef typename SELF::Edge   Edge;
  typedef graphic<C,V>          Graphic;

  int nbi=0;
  
  if( tp.nbe()>0){
    nbi=2*tp.nbe();
    int c=0;
    Graphic* res = new Graphic( Graphic::E_LINE, nbi, nbi);
    foreach(Edge* e, tp.edges()) { 
      res->vertices[3*c]  =e->source()->x();
      res->vertices[3*c+1]=e->source()->y();
      res->vertices[3*c+2]=e->source()->z();
      c++;
      res->vertices[3*c]  =e->destination()->x();
      res->vertices[3*c+1]=e->destination()->y();
      res->vertices[3*c+2]=e->destination()->z();
      c++;
      res->indices[c-2]=c-1;
      res->indices[c-1]=c-2;
    }
    return res;
  }
  return NULL;
}

//====================================================================
} ; // namespace shape
} ; // namespace mmx
# undef TMPL
# undef TMPL1
# undef AlgebraicCurve 
# undef AlgebraicSurface
# undef Cell
# undef Cell3dAlgebraicCurve
# undef Cell3dAlgebraicSurface
# undef Cell3dParametricCurve
# undef Cell3dList
# undef Cell3dFactory
# undef SELF 
# undef Shape
# endif