include/shape/mesher3d_algebraic_curve.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_algebraic_curve_hpp
# define shape_mesher3d_algebraic_curve_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/algebraic_surface.hpp>
//# include <shape/bcell.hpp>
# include <shape/bcell3d_algebraic_curve.hpp>
//# include <shape/bcell3d_algebraic_surface.hpp>
//# include <shape/bcell3d_list.hpp>
//# include <shape/tpl3d.hpp>
//# include <algorithm>
//# include <shape/with_vertex.hpp>

# undef mesher3d_algebraic_curve

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

# define AlgebraicCurve         algebraic_curve<C,V>
# define AlgebraicSurface       algebraic_surface<C,V>
# define Cell3dAlgebraicCurve   bcell3d_algebraic_curve<C,V>
# define Cell3dAlgebraicSurface bcell3d_algebraic_surface<C,V>
# define Cell3dParametricCurve  bcell3d_parametric_curve<C,V>
# define Cell3dList             bcell3d_list<C,V>
# define SELF                   mesher3d_algebraic_curve<C,V> 

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

struct mesher3d_algebraic_curve_def {};

template<class C, class V>
struct use<mesher3d_algebraic_curve_def,C, V>
        : public use<vertex_def,C,V>
        , public use<bcell3d_def,C,V>
        , public use<surface_def,C,V>
{ 
    //typedef typename use<tpl3d_def,V>::Point Point;
    typedef mesher3d_algebraic_curve<C, V> Topology3d;

};

//--------------------------------------------------------------------
TMPL class bcell_list ;
TMPL1 class surface ;
template <class CELL> class node;
template <class CELL> class kdtree;

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

    typedef node<Cell *>     Node;
    typedef kdtree<Cell *>   Kdtree;
    //  typedef topology<C,V>                   Topology;
    typedef typename Cell::BoundingBox BoundingBox;

    mesher3d_algebraic_curve(const BoundingBox & bx)
        : m_maxprec(0.1), m_minprec(0.01), m_bbx(bx)
    {
        m_tree = new Kdtree;
    }

    ~mesher3d_algebraic_curve(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 * bcell);
    virtual void insert_singular(Point*); ;
    virtual void insert_singular(BoundingBox* bx);

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

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


    bool post_process(Cell * bcell);
    bool sing_process(Cell * bcell);
    bool subdivide   (Cell * bcell, 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 bcell3d_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_algebraic_curve_def,C,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;

    Graphic* res = new Graphic (tp.nbv(), tp.nbe(), 0);

    int c=0;
    foreach(Point* p, tp.vertices()) {
        res->vertices[3*c]  =p->x();
        res->vertices[3*c+1]=p->y();
        res->vertices[3*c+2]=p->z();
        c++;
    }

    if( tp.nbe()>0){
        int c=0;
        foreach(Edge* e, tp.edges()) {
            if(e->source()->index()<0) std::cerr<<"Pb in as_graphic"<<std::endl;
            res->edges[2*c]   = e->source()->index();
            if(e->destination()->index()<0) std::cerr<<"Pb in as_graphic"<<std::endl;
            res->edges[2*c+1] = e->destination()->index();
            c++;
        }
        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

---