include/shape/dualize.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_dualize_hpp
# define shape_dualize_hpp

# include <shape/list.hpp>
# include <shape/kdtree_cell.hpp>
# include <shape/dualize.hpp>

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

template<class C,class V=default_env, class Cell=cell<C,V> >
struct dualize: public PROCESS_OF(V)
{

    typedef node<Cell*>                  Node;
    typedef kdtree_cell<Cell>            Input;
 //   typedef typename use<dualize_def,C,V>::template graph<Cell>  Output;

    struct graph {

        typedef Cell          value_type;
        typedef node<Cell*>   Node;

    public:
        Seq<Cell*>      m_vertices;
        Seq<Cell*>      m_edges;
        Seq<Cell*>      m_faces;
        Seq<Cell*>      m_cells;
    };

    typedef graph  Output;

    dualize(void);
    dualize(Input*);
    ~dualize(void) ;

    void    set_input  (Input* i) { m_input = i; }
    Input*  get_input  (void)     { return m_input; }
    Output* get_output (void)     { return m_output; }

    void run();

    void get_dual_vertex(Node*);
    void get_dual_edge  (Node*, Node*);
    void get_dual_face  (Node*, Node*, Node*, Node*);
    void get_dual_cell  (Node*, Node*, Node*, Node*, Node*, Node*, Node*, Node*);

    void clear(void);

    private:
    Input*       m_input;
    Output*      m_output;
};
//--------------------------------------------------------------------
TMPL SELF::dualize() {
    m_output = new Output;
}
//--------------------------------------------------------------------
TMPL SELF::dualize(Input* in) {
    m_input = in;
    m_output = new Output;
}
//--------------------------------------------------------------------
TMPL SELF::~dualize(void) {
    delete m_output;
}
//--------------------------------------------------------------------
TMPL void SELF::get_dual_vertex(Node* n) {
    if(!n->get_cell()->is_active()) return;

    if(!n->is_leaf()) {
        this->get_dual_vertex(n->left());
        this->get_dual_vertex(n->right());
        use<dualize_def,C,V>::dual_edge(this, n->left(), n->right());
        return;
    }
    use<dualize_def,C,V>::insert_vertex(this, n);
}

//--------------------------------------------------------------------
TMPL void SELF::get_dual_edge(Node* n1, Node* n2) {

    if(!is_adjacent(n1,n2)) return;

    if(!n1->get_cell()->is_active() && !n2->get_cell()->is_active()) return;

    if(!n1->is_leaf()) {
        if (is_adjacent(n1->left(), n2))  get_dual_edge(n1->left(),  n2);
        if (is_adjacent(n1->right(),n2))  get_dual_edge(n1->right(), n2);
        //use<dualize_def,C,V>::dual_face(this, n1->right(), n1->left(), n2, n2);
        return;
    }

    if(!n2->is_leaf()){
        if (is_adjacent(n1,n2->left()))   get_dual_edge(n1,n2->left());
        if (is_adjacent(n1,n2->right()))  get_dual_edge(n1,n2->right());
        //use<dualize_def,C,V>::dual_face(this, n1, n1, n2->left(), n2->right());
        return;
    }

    use<dualize_def,C,V>::insert_edge(this, n1,n2);
}

//--------------------------------------------------------------------
TMPL void SELF::get_dual_face(Node* n1, Node* n2, Node* n3, Node* n4) {
    if(!n1->get_cell()->is_active() &&
            !n2->get_cell()->is_active() &&
            !n3->get_cell()->is_active() &&
            !n4->get_cell()->is_active()) return;

    if(!is_adjacent(n1,n2) ||
            !is_adjacent(n2,n3) ||
            !is_adjacent(n3,n4) ||
            !is_adjacent(n4,n1) ) return;

    if(!n1->is_leaf()) {
        if (is_adjacent(n1->left(),n2) && is_adjacent(n1->left(),n4))
            get_dual_face(n1->left(),n2,n3,n4);
        if (is_adjacent(n1->right(),n2) && is_adjacent(n1->right(),n4))
            get_dual_face(n1->right(),n2,n3,n4);

        if (is_adjacent(n1->left() ,n2) && is_adjacent(n1->left() ,n4) &&
                is_adjacent(n1->right(),n2) && is_adjacent(n1->right(),n4) )
            use<dualize_def,C,V>::dual_cell(this, n1->left(), n2,n3,n4, n1->right(),n2,n3,n4);
        return;
    }

    if(!n2->is_leaf()) {
        if (is_adjacent(n1,n2->left()) && is_adjacent(n2->left(),n3))
            get_dual_face(n1,n2->left(), n3,n4);
        if (is_adjacent(n1,n2->right()) && is_adjacent(n2->right(),n3))
            get_dual_face(n1,n2->right(),n3,n4);

        if (is_adjacent(n1,n2->left() ) && is_adjacent(n2->left() ,n3) &&
                is_adjacent(n1,n2->right()) && is_adjacent(n2->right(),n3) )
            use<dualize_def,C,V>::dual_cell(this, n1,n2->left(), n3,n4, n1,n2->right(),n3,n4);
        return;
    }

    if(!n3->is_leaf()) {
        if (is_adjacent(n2,n3->left()) && is_adjacent(n3->left(),n4))
            get_dual_face(n1,n2,n3->left(), n4);
        if (is_adjacent(n2,n3->right()) && is_adjacent(n3->right(),n4))
            get_dual_face(n1,n2,n3->right(),n4);

        if (is_adjacent(n2,n3->left() ) && is_adjacent(n3->left() ,n4) &&
                is_adjacent(n2,n3->right()) && is_adjacent(n3->right(),n4) )
            use<dualize_def,C,V>::dual_cell(this, n1,n2,n3->left(),n4, n1,n2,n3->right(),n4);
        return;
    }

    if(!n4->is_leaf()) {
        if (is_adjacent(n3,n4->left()) && is_adjacent(n4->left(),n1))
            get_dual_face(n1,n2,n3,n4->left());
        if (is_adjacent(n3,n4->right()) && is_adjacent(n4->right(),n1))
            get_dual_face(n1,n2,n3,n4->right());

        if (is_adjacent(n3,n4->left() ) && is_adjacent(n4->left() ,n1) &&
                is_adjacent(n3,n4->right()) && is_adjacent(n4->right(),n1) )
            use<dualize_def,C,V>::dual_cell(this, n1,n2,n3, n4->left(), n1,n2,n3, n4->right());
        return;
    }

    use<dualize_def,C,V>::insert_face(this,n1,n2,n3,n4);
    return;
}
//----------------------------------------------------------------------
TMPL void SELF::get_dual_cell(Node* n1, Node* n2, Node* n3, Node* n4,
                              Node* n5, Node* n6, Node* n7, Node* n8) {

    if(!n1->get_cell()->is_active() &&
            !n2->get_cell()->is_active() &&
            !n3->get_cell()->is_active() &&
            !n4->get_cell()->is_active() &&
            !n5->get_cell()->is_active() &&
            !n6->get_cell()->is_active() &&
            !n7->get_cell()->is_active() &&
            !n8->get_cell()->is_active()) return;

    // std::cout<<"\nCell ";
    // if(!is_adjacent(n1,n2) ||
    //    !is_adjacent(n2,n3) ||
    //    !is_adjacent(n3,n4) ||
    //    !is_adjacent(n4,n1) ||
    //    !is_adjacent(n1,n5) ||
    //    !is_adjacent(n2,n6) ||
    //    !is_adjacent(n3,n7) ||
    //    !is_adjacent(n4,n8)
    //    ) return;
    // else
    //   std::cout<<" OK ";

    if(!n1->is_leaf()) {
        if (is_adjacent(n1->left(),n2) && is_adjacent(n1->left(),n4) && is_adjacent(n1->left(),n5))
            get_dual_cell(n1->left(), n2,n3,n4,n5,n6,n7,n8);
        if (is_adjacent(n1->right(),n2) && is_adjacent(n1->right(),n4) && is_adjacent(n1->right(),n5))
            get_dual_cell(n1->right(),n2,n3,n4,n5,n6,n7,n8);
        return;
    }

    if(!n2->is_leaf()) {
        if (is_adjacent(n1,n2->left()) && is_adjacent(n2->left(),n3) && is_adjacent(n2->left(),n6))
            get_dual_cell(n1,n2->left(), n3,n4,n5,n6,n7,n8);
        if (is_adjacent(n1,n2->right()) && is_adjacent(n2->right(),n3) && is_adjacent(n2->right(),n6))
            get_dual_cell(n1,n2->right(),n3,n4,n5,n6,n7,n8);
        return;
    }

    if(!n3->is_leaf()) {
        if (is_adjacent(n2,n3->left()) && is_adjacent(n3->left(),n4) && is_adjacent(n3->left(),n7))
            get_dual_cell(n1,n2,n3->left(), n4,n5,n6,n7,n8);
        if (is_adjacent(n2,n3->right()) && is_adjacent(n3->right(),n4) && is_adjacent(n3->right(),n7))
            get_dual_cell(n1,n2,n3->right(),n4,n5,n6,n7,n8);
        return;
    }

    if(!n4->is_leaf()) {
        if (is_adjacent(n3,n4->left()) && is_adjacent(n4->left(),n1) && is_adjacent(n4->left(),n8))
            get_dual_cell(n1,n2,n3,n4->left(), n5,n6,n7,n8);
        if (is_adjacent(n3,n4->right()) && is_adjacent(n4->right(),n1) && is_adjacent(n4->right(),n8))
            get_dual_cell(n1,n2,n3,n4->right(),n5,n6,n7,n8);
        return;
    }


    if(!n8->is_leaf()) {
        if (is_adjacent(n4,n8->left()) && is_adjacent(n7,n8->left()) && is_adjacent(n8->left(),n5))
            get_dual_cell(n1,n2,n3,n4,n5,n6,n7,n8->left() );
        if (is_adjacent(n4,n8->right()) && is_adjacent(n7,n8->right()) && is_adjacent(n8->right(),n5))
            get_dual_cell(n1,n2,n3,n4,n5,n6,n7,n8->right());
        return;
    }

    if(!n7->is_leaf()) {
        if (is_adjacent(n3,n7->left()) && is_adjacent(n6,n7->left()) && is_adjacent(n7->left(),n8))
            get_dual_cell(n1,n2,n3,n4,n5,n6,n7->left(), n8);
        if (is_adjacent(n3,n7->right()) && is_adjacent(n6,n7->right()) && is_adjacent(n7->right(),n8))
            get_dual_cell(n1,n2,n3,n4,n5,n6,n7->right(),n8);
        return;
    }

    if(!n6->is_leaf()) {
        if (is_adjacent(n2,n6->left()) && is_adjacent(n5,n6->left()) && is_adjacent(n6->left(),n7))
            get_dual_cell(n1,n2,n3,n4,n5,n6->left(), n7,n8);
        if (is_adjacent(n2,n6->right()) && is_adjacent(n5,n6->right()) && is_adjacent(n6->right(),n7))
            get_dual_cell(n1,n2,n3,n4,n5,n6->right(),n7,n8);
        return;
    }

    if(!n5->is_leaf()) {
        if (is_adjacent(n1,n5->left()) && is_adjacent(n5->left(),n6) && is_adjacent(n8,n5->left()))
            get_dual_cell(n1,n2,n3,n4,n5->left(), n6,n7,n8);
        if (is_adjacent(n1,n5->right()) && is_adjacent(n5->right(),n6) && is_adjacent(n8,n5->right()))
            get_dual_cell(n1,n2,n3,n4,n5->right(),n6,n7,n8);
        return;
    }

    use<dualize_def,C,V >::insert_cell(this, n1,n2,n3,n4, n5,n6,n7,n8);
}

//--------------------------------------------------------------------
TMPL void SELF::run() {
    this->get_dual_vertex(m_input->root());
}
//--------------------------------------------------------------------
TMPL void SELF::clear(void) {
}

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

---