include/shape/mesher2d_dual.hpp

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * 2011-04-26
 * Bernard Mourrain
 *****************************************************************************
 *               Copyright (C) 2011 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/
# ifndef shape_mesher2d_dual_hpp
# define shape_mesher2d_dual_hpp

# include <shape/subdivision.hpp>
# include <shape/cell2d.hpp>
# include <shape/tpl3d.hpp>
# include <shape/dualize2d.hpp>
# include <shape/polygonizer2d.hpp>

# undef  Cell
# define TMPL   template<class Cell, class V> 
# define TMPL1  template<class V>
# define Viewer viewer<W>
# define SELF   mesher2d_dual<Cell,V> 
//====================================================================
namespace mmx { namespace shape {
//====================================================================
struct mesher2d_dual_def {};

template<> struct use<mesher2d_dual_def, default_env>
{
    template<class Topo, class Cell> static
    void polygonise(Topo* t, Cell* c) { c->polygonise(t); }
};
//--------------------------------------------------------------------

template<class Cell, class V=default_env >
struct mesher2d_dual : public PROCESS_OF(V)
{
  //    typedef typename Cell::Scalar       C;
    typedef double C;
    typedef Cell                        Shape;
    typedef subdivision<C,V,Cell> Subdivisor;
    typedef Cell                        Input;
    typedef mesh3d<C,V>                  Output;
    typedef typename Output::Point      Point;
    typedef typename Output::Edge       Edge;
    typedef typename Output::Face       Face;
    typedef typename Cell::BoundingBox  BoundingBox;

    mesher2d_dual(double e1= 0.1, double e2=0.01);
    ~mesher2d_dual(void) ;

    void set_input (Cell* cl) { m_input= cl; }

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

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

    Input*  input  (void)     { return m_input; }
    Output* output (void)     { return m_output; }

    void run(void);
    void clear(void);

    private:
    double          m_smooth ;
    double          m_prec ;

    Cell*           m_input;
    Output*         m_output;

};
//--------------------------------------------------------------------
TMPL SELF::mesher2d_dual(double e1, double e2): m_smooth(e1), m_prec(e2)
{
    m_output = new Output;
}

TMPL SELF::~mesher2d_dual(void) {
    delete m_output;
}
//--------------------------------------------------------------------
TMPL void SELF::run(void) {

    Subdivisor* sbd = new Subdivisor(m_smooth,m_prec);
    sbd->set_input(this->input());
    sbd->run();

    typedef dualize<C,default_2d,Cell>  Dualize;
    Dualize* dl = new Dualize(sbd->get_output());
    dl->run();

    std::cout<< "\nCells      = "<< sbd->get_output()->m_leaves.size()<<"\n";
    std::cout<< "Cells      = "<< dl->get_output()->m_vertices.size()<<"\n";
    std::cout<< "Dual edges = "<< dl->get_output()->m_edges.size()/2<<"\n";
    std::cout<< "Dual faces = "<< dl->get_output()->m_faces.size()/4<<"\n";

    typedef polygonizer<C,default_2d,typename Dualize::Output> Polygonizer;
    Polygonizer* plg = new Polygonizer(dl->get_output(), m_output);
    plg->run();

}

//--------------------------------------------------------------------
TMPL void SELF::clear(void) {
    this->get_output()->clear();
}
//====================================================================
} ; // namespace shape
} ; // namespace mmx
//====================================================================
# undef TMPL
# undef TMPL1
# undef Shape
# undef Viewer
# undef Graphic
# undef SELF 
# endif

---