include/shape/mesher2d.hpp

Go to the documentation of this file.

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

# include <shape/vertex.hpp>
# include <shape/bcell.hpp>
# include <shape/kdtree.hpp>
# include <shape/graph.hpp>
# include <shape/list.hpp>
# include <shape/curve.hpp>
# include <shape/algebraic_curve.hpp>
# include <shape/bcell2d_factory.hpp>
# include <shape/topology.hpp>
# include <shape/tpl3d.hpp>

# include <stack>
# define  STACK std::stack<Cell2d*>
# define Cell2dFactory bcell2d_factory<C,V>


# define TMPL template<class C, class V>
# define TMPL1 template<class V>
# define REF REF_OF(V)

//# define Shape SHAPE_OF(V)
# define AlgebraicCurve algebraic_curve<C,V>
//# define SemiAlgebraicCurve semialgebraic_curve<C,REF>
//# define ParametricCurve parametric_curve<C,REF>
//# define VoronoiSite2d voronoi_site2d<C,REF>
# define Cell2dAlgebraicCurve bcell2d_algebraic_curve<C,REF>
//# define Cell2dParametricCurve bcell2d_parametric_curve<C,REF>
//# define Cell2dSemiAlgebraicCurve bcell2d_semialgebraic_curve<C,REF>
//# define Cell2dVoronoiSite bcell2d_voronoi_site2d<C,REF>
//# define Cell2dVoronoiDiagram bcell2d_voronoi_diagram<C,REF>
//# define Cell2dList bcell2d_list<C,REF>
//# define Cell2dInter bcell2d_intersection<C,REF>
# define SELF   mesher2d<C,V>
# define Viewer viewer<axel,V>
# undef Cell

//====================================================================
namespace mmx {  namespace shape {
//====================================================================

TMPL1 class curve ;
TMPL class bcell2d_parametric_curve ;
TMPL class bcell2d_algebraic_curve;
TMPL class bcell2d_list;

template<class C, class V=default_env>
class mesher2d //: public topology<C,V>
{
public:
    typedef typename SHAPE_OF(V)     Shape;
    typedef topology<C,V> Topology;
    typedef typename topology<C,V>::Point       Point;
    typedef typename topology<C,V>::Edge        Edge;
    typedef typename topology<C,V>::Face        Face;
    typedef typename topology<C,V>::BoundingBox BoundingBox;
    typedef bcell<C,V>                          Cell;
    typedef bcell2d<C,REF>                      Cell2d;
    typedef curve<REF>                          Curve;
    typedef tpl3d<C,V>                          Output;
    typedef node<Cell*>                         Node;
    typedef kdtree<Cell*>                       Kdtree;


public:
             mesher2d(void); //(const BoundingBox& bx);
    virtual ~mesher2d(void) ;

    void   set_smoothness(double e) { m_smooth = e; }
    void   set_precision (double e) { m_prec   = e; }

    double get_smoothness(void) { return m_smooth; }
    double get_precision (void) { return m_prec;   }


    void  set_input_bbox(const BoundingBox& bx);
    void  add_input(Shape* s);

    Cell* get_input_cell();

    Output* get_output()  {return m_output;}

    void run(void) ;

//    virtual void insert(Point*);
//    virtual void insert(Edge *);
//    virtual void insert_edge(Point * p1, Point * p2);

    virtual void insert_singular(Point*);

protected:
    bool is_regular (Cell * bcell) ;
    bool insert_regular(Cell * bcell) ;
    bool insert_singular(Cell * bcell) ;
    bool   subdivide(Cell * bcell, Node * node) ;

    std::list<Node *> m_nodes ;

private:
    Kdtree         *  m_tree ;

    static bool active_cell(gNode<Cell2d*>* v)
    {
        return (v->get_aux()>0 );
    }

    static void ccw_walk(gNode<Cell2d*>* v)
    {
        //
    }

public:

    Graph<Point*>       m_graph;  // topological graph
    Graph<Cell2d*>      m_leaves; // active leaves graph
    Graph<Cell2d*>      b_leaves; // border leaves CCW loop

//    int nbv() const { return this->get_output()->m_vertices.size(); }
//    int nbe() const { return this->get_output()->m_edges.size(); }

//    Seq<Point*>  vertices(void)  const { return this->get_output()->m_vertices ; }
//    Point*       vertices(int i) const { return this->get_output()->m_vertices[i] ; }
//    Seq<Edge*>   edges(void)  const { return this->get_output()->m_edges ; }
//    Edge*        edges(int i) const { return this->get_output()->m_edges[i] ; }

    Seq<Point*>         m_specials;

//    Seq<Point*>         m_vertices;
//    Seq<Edge *>         m_edges;
//    Seq<Face *>         m_faces;

private:
    double       m_smooth ;
    double       m_prec ;

    Seq<Shape*>  m_input_objects;
    BoundingBox  m_input_bbx;

    Output*      m_output;
};

//--------------------------------------------------------------------
TMPL 
SELF::mesher2d (void): m_smooth(0.1), m_prec(0.01) {
    m_tree = new Kdtree ;
    m_input_bbx = BoundingBox(0, 1, 0, 1);
    m_output = new Output;
}

TMPL
SELF::~mesher2d(void) {
    delete m_tree ;
}

TMPL void
SELF::set_input_bbox(const BoundingBox& box) {
    m_input_bbx=box;
    m_input_bbx.set_zmin(0);
    m_input_bbx.set_zmax(0);
}

TMPL void
SELF::add_input(Shape * object) {
    this->m_input_objects.push_back(object);
}


TMPL bcell<C,V>*
SELF::get_input_cell() {
    if(this->m_input_objects.size() == 1)
        return Cell2dFactory::instance()->create(this->m_input_objects[0],this->m_input_bbx);
    else
        return Cell2dFactory::instance()->create(this->m_input_objects,this->m_input_bbx);
}
TMPL void 
SELF::run() {

    Node* root = m_tree->root() ;

    //std::cout<<"Running, objs="<<this->m_input_objects.size() << std::endl;

    Cell* cl = this->get_input_cell();
    //  Cell2dFactory::instance()->create(this->m_objects,this->m_bbx);

    root->set_cell( (Cell*)cl ) ;
    this->m_nodes.push_back(root) ;

    //std::cout<<"RUNing "<< cl <<std::endl;

    // double maxsz = this->m_maxprec*m_tree->root()->get_cell()->size();
    // double minsz = this->m_minprec*m_tree->root()->get_cell()->size();
    double maxsz = this->get_smoothness();
    double minsz = this->get_precision();

    while(!m_nodes.empty()  ) {   //
        Node * node = m_nodes.front() ;
        Cell   * cl = node->get_cell() ;
        Cell2d * cl2= dynamic_cast<Cell2d*>(cl);

        //std::cout<<"node "<<cl->size()<<std::endl;

        if(cl->is_active()) {

            //std::cout<<"active.. "<<std::endl;

            if(cl->size() > maxsz)
            {
                //std::cout<<"subdivide "<<cl->size()<<std::endl;
                this->subdivide(cl, node) ;
            }
            else if(this->is_regular(cl) )// && cl->is_intersected())
            {
                //std::cout<<"ins regular "<<std::endl;
                this->get_output()->insert_regular(cl) ;
                //std::cout<<"ok "<<std::endl;
                cl2->m_gnode=
                        this->m_leaves.push_vertex(cl2);
                if (  cl2->is_border() )
                    this->b_leaves.push_vertex(cl2);
            }
            else if(cl->size() > minsz)
            {
                //std::cout<<"subdivide "<<cl->size()<<std::endl;
                this->subdivide(cl, node) ;
            }
            else
            {
                this->insert_singular(cl) ;
                cl2->m_gnode=
                        this->m_leaves.push_vertex(cl2);
                if (  cl2->is_border() )
                    this->b_leaves.push_vertex(cl2);
            }
        }
        else    //inactive leaf -- end if
        {
            // cl2->m_gnode=
            // this->m_leaves.push_vertex(cl2);
            if (  cl2->is_border() )
                this->b_leaves.push_vertex(cl2);
        }
        this->m_nodes.pop_front() ;
    }

    /* add edges */
    Seq<Cell2d*> nlist;

    //std::cout<<"border " << std::endl;
    // Border graph
    this->b_leaves.dfs(nlist);
    foreach(Cell2d* cl2, nlist)
    {
        if (cl2->s_neighbors.size()==0)
            foreach(Cell2d* nb, cl2->e_neighbors )
                if (nlist.member(nb) && nb->s_neighbors.size()==0)
                    this->b_leaves.push_edge( cl2,nb ) ;
        if (cl2->e_neighbors.size()==0)
            foreach(Cell2d* nb, cl2->n_neighbors )
                if (nlist.member(nb) && nb->e_neighbors.size()==0)
                    this->b_leaves.push_edge( cl2,nb ) ;
        if (cl2->n_neighbors.size()==0)
            foreach(Cell2d* nb, cl2->w_neighbors )
                if (nlist.member(nb)&& nb->n_neighbors.size()==0)
                    this->b_leaves.push_edge( cl2,nb ) ;
        if (cl2->w_neighbors.size()==0)
            foreach(Cell2d* nb, cl2->s_neighbors )
                if (nlist.member(nb)&& nb->w_neighbors.size()==0)
                    this->b_leaves.push_edge( cl2,nb ) ;
    }
    nlist.clear();
}


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

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

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

TMPL void 
SELF::insert_singular(Point * p) {
    m_specials<<p;
}

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) {
//    if(p->index()<0) {
//        p->set_index(this->get_output()->m_vertices.size());
//        this->get_output()->m_vertices << p;
//        this->m_graph.push_vertex(p);
//    }
//}

//TMPL void SELF::insert(Edge  * e) {
//    this->get_output()->m_edges    << e;
//    this->m_graph.push_uedge(e->source(), e->destination() );
//}

//TMPL void SELF::insert_edge(Point * p1,Point * p2){
//    this->get_output()->m_edges << new Edge(p1,p2);
//    this->m_graph.push_uedge(p1,p2);
//}

//--------------------------------------------------------------------
//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.get_output()->vertices()) {
//        res->vertices[c]  =p->x();
//        res->vertices[c+1]=p->y();
//        res->vertices[c+2]=p->z();
//        c+=3;
//    }

//    //foreach(Point* p, tp->m_specials) out<<(*p)<<"\n";

//    c=0;
//    foreach(Edge* e, tp->get_output()->edges()) {
//        res->edges[c]   = e->source()->index();
//        res->edges[c+1] = e->destination()->index();
//        c+=2;
//    }

//    return res;
//}
//====================================================================
} // namespace shape
} // namespace mmx
//====================================================================
# undef TMPL
# undef TMPL1
# undef AlgebraicCurve
# undef SemiAlgebraicCurve
# undef Cell
# undef Cell2dAlgebraicCurve
# undef Cell2dParametricCurve
# undef Cell2dSemiAlgebraicCurve
# undef Cell2dList
# undef Cell2dInter
# undef Cell2dFactory
# undef Curve
# undef SELF 
# undef Shape
# undef STACK
# undef Viewer
//# undef VoronoiSite2d
# undef ParametricCurve
//# undef Cell2dVoronoiDiagram
# undef Cell2dAlgebraicCurve
#endif

---