include/shape/subdivision.hpp

Go to the documentation of this file.

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

# ifndef shape_subdivision_surface_hpp_H
# define shape_subdivision_surface_hpp_H

# include <shape/graphic.hpp>
# include <shape/vertex.hpp>
# include <shape/edge.hpp>
# include <shape/face.hpp>
# include <shape/kdtree.hpp>
# include <shape/list.hpp>
# include <shape/topology.hpp>
# include <shape/bcell.hpp>
# include <shape/kdtree_cell.hpp>
# include <algorithm>

# define TMPL  template<class C,class V,class Cell>
# define TMPL1 template<class K>
# define SELF  subdivision<C,V,Cell>

namespace mmx {
namespace shape {

TMPL class subdivision;

template <class C> class surface ;
template <class CELL> class node;
template <class CELL> class kdtree;

//--------------------------------------------------------------------
struct subdivision_def {};

template<class C> struct use<subdivision_def, C, default_env>
        :public use<topology_def>
{
    typedef bcell<double> Cell;

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

    template<class Self, class CELL>
    static bool is_regular(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;
        // std::cout<<"Regular "<<cl->size()<<" "<< out->m_leaves.size()<<std::endl;
        //    return true;
    }

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

//    template<class CI, class CO>  static int
//    subdivide_cell(CI* cl, CO*& left, CO*& right) {
//        typedef typename CO::CellBase CellBase;
//        int v; double s;
//        cl->split_position(v,s);
//        cl->subdivide((CellBase*&)left,(CellBase*&)right,v,s);
//        return v;
//    }

    template<class Out, class CELL, class Node>  static unsigned
    subdivide_node(Out* self, CELL* cl, Node * node) {
        typedef typename CELL::CellBase CellBase;
        CELL * left=0, * right=0;
        int v; double s;
        cl->split_position(v,s);
        cl->subdivide((CellBase*&)left,(CellBase*&)right,v,s);
//        int v=subdivide_cell(cl,left,right);
        node->m_left = new Node(node, left,  Node::LEFT , v) ; self->m_nodes << node->m_left ;
        node->m_right= new Node(node, right, Node::RIGHT, v) ; self->m_nodes << node->m_right;
        self->m_map[node->m_left->get_cell()]  = node->m_left;
        self->m_map[node->m_right->get_cell()] = node->m_right;
        return v ;
    }
};

//--------------------------------------------------------------------  
template<class C, class V, class Cell=cell<C,V> >
class subdivision {
public:

    typedef C                                  Scalar;
    typedef typename Cell::BoundingBox         BoundingBox;

    typedef node<Cell*>                        Node;
    typedef Cell                               Input;
    typedef kdtree_cell<Cell>                  Output;

    subdivision(double e1= 0.1, double e2=0.001);

    ~subdivision(void) ;

    //  Node* root() {return m_output->m_tree.root();}

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

    Output* get_output (void)     { return m_output; }

    void    set_precision (double);
    void    set_smoothness(double);

    double  get_precision (void) const { return m_minprec ; }
    double  get_smoothness(void) const { return m_maxprec ; }

    void run(void);

    /* Remove all vertices, edges and faces from the subdivision. */
    virtual void clear();

    //private:
    double              m_maxprec ;
    double              m_minprec ;

private:
    Cell*               m_input;
    Output*             m_output;
};
//--------------------------------------------------------------------
TMPL SELF::subdivision(double e1, double e2): m_maxprec(e1), m_minprec(e2)
{ 
    m_output = new Output;
}
//--------------------------------------------------------------------
TMPL SELF::~subdivision(void) {
    delete m_output;
}
//--------------------------------------------------------------------
TMPL void SELF::set_input(Cell* c0)
{ 
    Node* root = this->get_output()->root();
    root->set_cell(c0);
    m_output->m_nodes.push_back(root) ;
}
//--------------------------------------------------------------------
TMPL void SELF::set_smoothness(double eps) {
    m_maxprec = eps;
}
//--------------------------------------------------------------------
TMPL void SELF::set_precision(double eps) {
    m_minprec = eps;
}
//--------------------------------------------------------------------
TMPL void SELF::clear() {

}
//--------------------------------------------------------------------
TMPL void SELF::run() {

    typedef use<subdivision_def,C,V> USE;

    double maxsz = this->get_smoothness()*this->get_output()->root()->get_cell()->size();
    double minsz = this->get_precision()*this->get_output()->root()->get_cell()->size();

    std::cout<<"Size :"<< maxsz<< " "<<minsz<<std::endl;

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

        if( USE::is_not_out(this,cl)) {
            if(cl->size() > maxsz)
            {
                USE::subdivide_node(this->get_output(), cl, node) ;
            }
            else if(USE::is_regular(this,cl))
            {
                USE::process_regular(this->get_output(),cl) ;
            }
            else if(cl->size() > minsz )
            {
                USE::subdivide_node(this->get_output(), cl, node) ;
            }
            else {
                std::cout<<"Singular cell"<<std::endl;
                USE::process_singular(this->get_output(), cl);
            }
        }
        this->get_output()->m_nodes.pop_front() ;
    }
}


//====================================================================
} ; // namespace shape
} ; // namespace mmx
//====================================================================
# undef TMPL1
# undef TMPL
# undef SELF 
# endif

---