include/shape/isosurface.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_isosurface_hpp
# define shape_isosurface_hpp

# include <shape/subdivision.hpp>
# include <shape/topology3d.hpp>
# include <shape/dualize3d.hpp>
# include <shape/polygonizer.hpp>

# define TMPL   template<class C,class V,class Cell>
# define SELF   isosurface<C,V,Cell>
//====================================================================
namespace mmx { namespace shape {
//====================================================================
struct isovalue_env {};

template<class C> struct use<subdivision_def,C,isovalue_env>
{
    template<class Self, class CELL>
    static bool is_not_out(Self* self, CELL* cl) {
        double m = cl ->lower_bound(),
                M = cl ->upper_bound();
        return (m <=this->m_max && M >= this-> m_min);
    }

    template<class Self, class CELL>
    static bool is_in(Self* self, CELL* cl) {
        return cl->is_regular();
    }


    template<class Out, class CELL>  static void
    process_regular(Out* out, CELL* cl) {
        // put in the leaves and will be treated at the end
        out->m_leaves <<cl;
    }

    template<class Out, class CELL>  static void
    process_singular(Out* out, CELL* cl) {
        //    return true;
    }

};

//--------------------------------------------------------------------
template<class C,class V=isosurface_env, class Cell=cell3d<C,V> >
struct isosurface : public PROCESS_OF(V)
{
    typedef Cell                        Input;
    typedef tpl3d<C,V>                  Output;
    typedef typename Output::Point      Point;
    typedef typename Output::Edge       Edge;
    typedef typename Output::Face       Face;
    typedef typename Cell::BoundingBox  BoundingBox;

    isosurface(double m=0, double M=1, double e1= 0.1, double e2=0.01);
    ~isosurface(void) ;

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

    Output* get_output (void)    { return m_output; }

    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    run(void);
    void    clear(void);

    private:
    double          m_smooth ;
    double          m_prec ;

    double          m_min, m_max;
    Cell*           m_input;
    Output*         m_output;

};
//--------------------------------------------------------------------
TMPL SELF::isosurface(double m, double M, double e1, double e2):
    m_min(m), m_max(M), m_smooth(e1), m_prec(e2)
{
    m_output = new Output;
}

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

    typedef subdivision<C,V,Cell> Subdivisor;
    Subdivisor* sbd = new Subdivisor(m_smooth,m_prec);
    sbd->set_input(this->input());
    sbd->run();

    std::cout<< ">> leaves    = "<< sbd->get_output()->m_leaves.size()<<"\n";

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

    std::cout<< "\nCells      = "<< sbd->get_output()->m_leaves.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";
    std::cout<< "Dual cells = "<< dl->get_output()->m_cells.size()/8<<"\n";

    typedef polygonizer<C,V,Seq<Cell*> > Polygonizer;
    Polygonizer* plg = new Polygonizer;
    plg->set_input(&dl->get_output()->m_cells);
    plg->set_output(this->get_output());
    plg->run(m_n,m_min,m_max);

}

//--------------------------------------------------------------------
TMPL void SELF::clear(void) {
    this->output()->clear();
}
//--------------------------------------------------------------------

//====================================================================
} ; // namespace shape
              } ; // namespace mmx
//====================================================================
# undef TMPL
# undef Shape
# undef Viewer
# undef Graphic
# undef SELF 
# endif

---