dualize< C, V, Cell > Struct Template Reference

#include <dualize.hpp>

List of all members.

Classes

Public Types

Public Member Functions

Detailed Description

template<class C, class V = default_env, class Cell = cell<C,V>>
struct mmx::shape::dualize< C, V, Cell >

Definition at line 27 of file dualize.hpp.

Member Typedef Documentation

typedef kdtree_cell<Cell> Input

Definition at line 31 of file dualize.hpp.

typedef node<Cell*> Node

Definition at line 30 of file dualize.hpp.

typedef graph Output

Definition at line 46 of file dualize.hpp.

Constructor & Destructor Documentation

dualize ( void   )  [inline]

Definition at line 70 of file dualize.hpp.

00070                    {
00071     m_output = new Output;
00072 }

dualize ( Input *  in  )  [inline]

Definition at line 74 of file dualize.hpp.

00074                             {
00075     m_input = in;
00076     m_output = new Output;
00077 }

~dualize ( void   )  [inline]

Definition at line 79 of file dualize.hpp.

00079                         {
00080     delete m_output;
00081 }

Member Function Documentation

void clear ( void   )  [inline]

Definition at line 281 of file dualize.hpp.

00281                           {
00282 }

void get_dual_cell ( Node *  n1,
Node *  n2,
Node *  n3,
Node *  n4,
Node *  n5,
Node *  n6,
Node *  n7,
Node *  n8 
) [inline]

Definition at line 183 of file dualize.hpp.

References node< _CELL >::get_cell(), mmx::shape::is_adjacent(), node< _CELL >::is_leaf(), node< _CELL >::left(), and node< _CELL >::right().

00184                                                                       {
00185 
00186     if(!n1->get_cell()->is_active() &&
00187             !n2->get_cell()->is_active() &&
00188             !n3->get_cell()->is_active() &&
00189             !n4->get_cell()->is_active() &&
00190             !n5->get_cell()->is_active() &&
00191             !n6->get_cell()->is_active() &&
00192             !n7->get_cell()->is_active() &&
00193             !n8->get_cell()->is_active()) return;
00194 
00195     // std::cout<<"\nCell ";
00196     // if(!is_adjacent(n1,n2) ||
00197     //    !is_adjacent(n2,n3) ||
00198     //    !is_adjacent(n3,n4) ||
00199     //    !is_adjacent(n4,n1) ||
00200     //    !is_adjacent(n1,n5) ||
00201     //    !is_adjacent(n2,n6) ||
00202     //    !is_adjacent(n3,n7) ||
00203     //    !is_adjacent(n4,n8)
00204     //    ) return;
00205     // else
00206     //   std::cout<<" OK ";
00207 
00208     if(!n1->is_leaf()) {
00209         if (is_adjacent(n1->left(),n2) && is_adjacent(n1->left(),n4) && is_adjacent(n1->left(),n5))
00210             get_dual_cell(n1->left(), n2,n3,n4,n5,n6,n7,n8);
00211         if (is_adjacent(n1->right(),n2) && is_adjacent(n1->right(),n4) && is_adjacent(n1->right(),n5))
00212             get_dual_cell(n1->right(),n2,n3,n4,n5,n6,n7,n8);
00213         return;
00214     }
00215 
00216     if(!n2->is_leaf()) {
00217         if (is_adjacent(n1,n2->left()) && is_adjacent(n2->left(),n3) && is_adjacent(n2->left(),n6))
00218             get_dual_cell(n1,n2->left(), n3,n4,n5,n6,n7,n8);
00219         if (is_adjacent(n1,n2->right()) && is_adjacent(n2->right(),n3) && is_adjacent(n2->right(),n6))
00220             get_dual_cell(n1,n2->right(),n3,n4,n5,n6,n7,n8);
00221         return;
00222     }
00223 
00224     if(!n3->is_leaf()) {
00225         if (is_adjacent(n2,n3->left()) && is_adjacent(n3->left(),n4) && is_adjacent(n3->left(),n7))
00226             get_dual_cell(n1,n2,n3->left(), n4,n5,n6,n7,n8);
00227         if (is_adjacent(n2,n3->right()) && is_adjacent(n3->right(),n4) && is_adjacent(n3->right(),n7))
00228             get_dual_cell(n1,n2,n3->right(),n4,n5,n6,n7,n8);
00229         return;
00230     }
00231 
00232     if(!n4->is_leaf()) {
00233         if (is_adjacent(n3,n4->left()) && is_adjacent(n4->left(),n1) && is_adjacent(n4->left(),n8))
00234             get_dual_cell(n1,n2,n3,n4->left(), n5,n6,n7,n8);
00235         if (is_adjacent(n3,n4->right()) && is_adjacent(n4->right(),n1) && is_adjacent(n4->right(),n8))
00236             get_dual_cell(n1,n2,n3,n4->right(),n5,n6,n7,n8);
00237         return;
00238     }
00239 
00240 
00241     if(!n8->is_leaf()) {
00242         if (is_adjacent(n4,n8->left()) && is_adjacent(n7,n8->left()) && is_adjacent(n8->left(),n5))
00243             get_dual_cell(n1,n2,n3,n4,n5,n6,n7,n8->left() );
00244         if (is_adjacent(n4,n8->right()) && is_adjacent(n7,n8->right()) && is_adjacent(n8->right(),n5))
00245             get_dual_cell(n1,n2,n3,n4,n5,n6,n7,n8->right());
00246         return;
00247     }
00248 
00249     if(!n7->is_leaf()) {
00250         if (is_adjacent(n3,n7->left()) && is_adjacent(n6,n7->left()) && is_adjacent(n7->left(),n8))
00251             get_dual_cell(n1,n2,n3,n4,n5,n6,n7->left(), n8);
00252         if (is_adjacent(n3,n7->right()) && is_adjacent(n6,n7->right()) && is_adjacent(n7->right(),n8))
00253             get_dual_cell(n1,n2,n3,n4,n5,n6,n7->right(),n8);
00254         return;
00255     }
00256 
00257     if(!n6->is_leaf()) {
00258         if (is_adjacent(n2,n6->left()) && is_adjacent(n5,n6->left()) && is_adjacent(n6->left(),n7))
00259             get_dual_cell(n1,n2,n3,n4,n5,n6->left(), n7,n8);
00260         if (is_adjacent(n2,n6->right()) && is_adjacent(n5,n6->right()) && is_adjacent(n6->right(),n7))
00261             get_dual_cell(n1,n2,n3,n4,n5,n6->right(),n7,n8);
00262         return;
00263     }
00264 
00265     if(!n5->is_leaf()) {
00266         if (is_adjacent(n1,n5->left()) && is_adjacent(n5->left(),n6) && is_adjacent(n8,n5->left()))
00267             get_dual_cell(n1,n2,n3,n4,n5->left(), n6,n7,n8);
00268         if (is_adjacent(n1,n5->right()) && is_adjacent(n5->right(),n6) && is_adjacent(n8,n5->right()))
00269             get_dual_cell(n1,n2,n3,n4,n5->right(),n6,n7,n8);
00270         return;
00271     }
00272 
00273     use<dualize_def,C,V >::insert_cell(this, n1,n2,n3,n4, n5,n6,n7,n8);
00274 }

void get_dual_edge ( Node *  n1,
Node *  n2 
) [inline]

Definition at line 96 of file dualize.hpp.

References node< _CELL >::get_cell(), mmx::shape::is_adjacent(), node< _CELL >::is_leaf(), node< _CELL >::left(), and node< _CELL >::right().

00096                                                 {
00097 
00098     if(!is_adjacent(n1,n2)) return;
00099 
00100     if(!n1->get_cell()->is_active() && !n2->get_cell()->is_active()) return;
00101 
00102     if(!n1->is_leaf()) {
00103         if (is_adjacent(n1->left(), n2))  get_dual_edge(n1->left(),  n2);
00104         if (is_adjacent(n1->right(),n2))  get_dual_edge(n1->right(), n2);
00105         //use<dualize_def,C,V>::dual_face(this, n1->right(), n1->left(), n2, n2);
00106         return;
00107     }
00108 
00109     if(!n2->is_leaf()){
00110         if (is_adjacent(n1,n2->left()))   get_dual_edge(n1,n2->left());
00111         if (is_adjacent(n1,n2->right()))  get_dual_edge(n1,n2->right());
00112         //use<dualize_def,C,V>::dual_face(this, n1, n1, n2->left(), n2->right());
00113         return;
00114     }
00115 
00116     use<dualize_def,C,V>::insert_edge(this, n1,n2);
00117 }

void get_dual_face ( Node *  n1,
Node *  n2,
Node *  n3,
Node *  n4 
) [inline]

Definition at line 120 of file dualize.hpp.

References node< _CELL >::get_cell(), mmx::shape::is_adjacent(), node< _CELL >::is_leaf(), node< _CELL >::left(), and node< _CELL >::right().

00120                                                                     {
00121     if(!n1->get_cell()->is_active() &&
00122             !n2->get_cell()->is_active() &&
00123             !n3->get_cell()->is_active() &&
00124             !n4->get_cell()->is_active()) return;
00125 
00126     if(!is_adjacent(n1,n2) ||
00127             !is_adjacent(n2,n3) ||
00128             !is_adjacent(n3,n4) ||
00129             !is_adjacent(n4,n1) ) return;
00130 
00131     if(!n1->is_leaf()) {
00132         if (is_adjacent(n1->left(),n2) && is_adjacent(n1->left(),n4))
00133             get_dual_face(n1->left(),n2,n3,n4);
00134         if (is_adjacent(n1->right(),n2) && is_adjacent(n1->right(),n4))
00135             get_dual_face(n1->right(),n2,n3,n4);
00136 
00137         if (is_adjacent(n1->left() ,n2) && is_adjacent(n1->left() ,n4) &&
00138                 is_adjacent(n1->right(),n2) && is_adjacent(n1->right(),n4) )
00139             use<dualize_def,C,V>::dual_cell(this, n1->left(), n2,n3,n4, n1->right(),n2,n3,n4);
00140         return;
00141     }
00142 
00143     if(!n2->is_leaf()) {
00144         if (is_adjacent(n1,n2->left()) && is_adjacent(n2->left(),n3))
00145             get_dual_face(n1,n2->left(), n3,n4);
00146         if (is_adjacent(n1,n2->right()) && is_adjacent(n2->right(),n3))
00147             get_dual_face(n1,n2->right(),n3,n4);
00148 
00149         if (is_adjacent(n1,n2->left() ) && is_adjacent(n2->left() ,n3) &&
00150                 is_adjacent(n1,n2->right()) && is_adjacent(n2->right(),n3) )
00151             use<dualize_def,C,V>::dual_cell(this, n1,n2->left(), n3,n4, n1,n2->right(),n3,n4);
00152         return;
00153     }
00154 
00155     if(!n3->is_leaf()) {
00156         if (is_adjacent(n2,n3->left()) && is_adjacent(n3->left(),n4))
00157             get_dual_face(n1,n2,n3->left(), n4);
00158         if (is_adjacent(n2,n3->right()) && is_adjacent(n3->right(),n4))
00159             get_dual_face(n1,n2,n3->right(),n4);
00160 
00161         if (is_adjacent(n2,n3->left() ) && is_adjacent(n3->left() ,n4) &&
00162                 is_adjacent(n2,n3->right()) && is_adjacent(n3->right(),n4) )
00163             use<dualize_def,C,V>::dual_cell(this, n1,n2,n3->left(),n4, n1,n2,n3->right(),n4);
00164         return;
00165     }
00166 
00167     if(!n4->is_leaf()) {
00168         if (is_adjacent(n3,n4->left()) && is_adjacent(n4->left(),n1))
00169             get_dual_face(n1,n2,n3,n4->left());
00170         if (is_adjacent(n3,n4->right()) && is_adjacent(n4->right(),n1))
00171             get_dual_face(n1,n2,n3,n4->right());
00172 
00173         if (is_adjacent(n3,n4->left() ) && is_adjacent(n4->left() ,n1) &&
00174                 is_adjacent(n3,n4->right()) && is_adjacent(n4->right(),n1) )
00175             use<dualize_def,C,V>::dual_cell(this, n1,n2,n3, n4->left(), n1,n2,n3, n4->right());
00176         return;
00177     }
00178 
00179     use<dualize_def,C,V>::insert_face(this,n1,n2,n3,n4);
00180     return;
00181 }

void get_dual_vertex ( Node *  n  )  [inline]

Definition at line 83 of file dualize.hpp.

References node< _CELL >::get_cell(), node< _CELL >::is_leaf(), node< _CELL >::left(), and node< _CELL >::right().

Referenced by dualize< C, V, Cell >::run().

00083                                        {
00084     if(!n->get_cell()->is_active()) return;
00085 
00086     if(!n->is_leaf()) {
00087         this->get_dual_vertex(n->left());
00088         this->get_dual_vertex(n->right());
00089         use<dualize_def,C,V>::dual_edge(this, n->left(), n->right());
00090         return;
00091     }
00092     use<dualize_def,C,V>::insert_vertex(this, n);
00093 }

Input* get_input ( void   )  [inline]

Definition at line 53 of file dualize.hpp.

00053 { return m_input; }

Output* get_output ( void   )  [inline]

Definition at line 54 of file dualize.hpp.

00054 { return m_output; }

void run ( void   )  [inline]

Definition at line 277 of file dualize.hpp.

References dualize< C, V, Cell >::get_dual_vertex(), and kdtree_cell< CELL >::root().

00277                     {
00278     this->get_dual_vertex(m_input->root());
00279 }

void set_input ( Input *  i  )  [inline]

Definition at line 52 of file dualize.hpp.

00052 { m_input = i; }

The documentation for this struct was generated from the following file:
Generated on 6 Dec 2012 for shape by  doxygen 1.6.1