Main Page   Namespace List   Class Hierarchy   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

MESH_TemplateMesh.h

Go to the documentation of this file.
00001 
00002 //                            SFTemplateMesh.h                                //
00004 
00005 #ifndef TEMPLATEMESH_H
00006 #define TEMPLATEMESH_H
00007 
00008 #include "MESH_X3DMeshNode.h"
00009 #include "MESH_SFTemplateVertex.h"
00010 #include "MESH_TemplateVertexSet.h"
00011 #include "MESH_SFTemplateDirectEdge.h"
00012 #include "MESH_SFTemplateIndirectEdge.h"
00013 #include "MESH_SFTemplateFace.h"
00014 
00015 #include <iostream>
00016 #include <typeinfo>
00017 
00018 namespace X3DTK {
00019 namespace MESH {
00020 
00024 
00025 template<class MData, class VData, class EData, class FData>
00026 class TemplateMesh : public X3DMeshNode
00027 {
00028 public:
00030   typedef SFTemplateVertex<VData, EData, FData> SFVertex;
00032   typedef MFTemplateVertex<VData, EData, FData> MFVertex;
00034   typedef SFTemplateEdge<EData, FData, VData> SFEdge;
00036   typedef MFTemplateEdge<EData, FData, VData> MFEdge;
00038   typedef SFTemplateFace<FData, VData, EData> SFFace;
00040   typedef MFTemplateFace<FData, VData, EData> MFFace;
00041   
00043   TemplateMesh()
00044   : X3DMeshNode()
00045   {
00046     defineTypeName(typeid(*this).name());
00047   };
00049   virtual SFNode clone() const
00050   {
00051     return new TemplateMesh(*this);  
00052   };
00053   
00055   virtual ~TemplateMesh() 
00056   {
00057     removeParentFromChild(this, vertexSet);   
00058   
00059     // delete edges
00060     for (typename MFEdge::iterator it = _edges.begin(); it != _edges.end(); ++it)
00061     {
00062       delete (*it)->_symetric;
00063       delete (*it)->_edgeContent;
00064       delete (*it);    
00065     } 
00066      
00067     // delete faces
00068     for (typename MFFace::iterator it = _faces.begin(); it != _faces.end(); ++it)
00069       delete (*it); 
00070   };
00071    
00073   void setVertexSet(TemplateVertexSet<VData, EData, FData> *vertexSet)
00074   {
00075     removeParentFromChild(this, this->vertexSet);  
00076     this->vertexSet = vertexSet;
00077     addParentToChild(this, this->vertexSet);  
00078   };
00080   virtual MFAbstractNode getChildrenList() const
00081   {
00082     MFAbstractNode childrenList;
00083     if (vertexSet != 0)
00084       childrenList.push_back(vertexSet);
00085     
00086     return childrenList;   
00087   };
00088   
00091   bool addChild(const SFAbstractNode &N)
00092   {
00093     if (dynamic_cast<TemplateVertexSet<VData, EData, FData> *>(N) != 0)
00094     {
00095       if (vertexSet != 0)
00096         return false;
00097       
00098       setVertexSet(static_cast<TemplateVertexSet<VData, EData, FData> *>(N));
00099       return true;
00100     }
00101     if (N != 0)
00102       cx3d << "MESH::TemplateMesh::addChild: a node of type " << N->getTypeName() << " cannot be a child!" << std::endl;
00103     else
00104       cx3d << "MESH::TemplateMesh::addChild: cannot add a NULL node!" << std::endl;
00105    
00106     return false;
00107   };
00110   bool setChild(const SFAbstractNode &N)
00111   {
00112     if (dynamic_cast<TemplateVertexSet<VData, EData, FData> *>(N) != 0)
00113     {
00114       setVertexSet(static_cast<TemplateVertexSet<VData, EData, FData> *>(N));
00115       return true;
00116     }
00117     if (N != 0)
00118       cx3d << "MESH::TemplateMesh::setChild: a node of type " << N->getTypeName() << " cannot be a child!" << std::endl;
00119     else
00120       cx3d << "MESH::TemplateMesh::setChild: cannot add a NULL node!" << std::endl;
00121     
00122     return false;
00123   };
00124   
00126   bool removeChild(const SFAbstractNode &N)
00127   {
00128     if (vertexSet == N)
00129     {
00130       setVertexSet(0);
00131       return true;
00132     }
00133     
00134     return false;
00135   };    
00136   
00138   SFEdge *getEdge(SFVertex *from, SFVertex *to)
00139   {
00140     if ((from == 0) || (to == 0))
00141       return 0;
00142     
00143     MFEdge from_edges = from->getEdges();
00144     
00145     for (typename MFEdge::const_iterator it = from_edges.begin(); it != from_edges.end(); ++it)
00146     {
00147       if ((*it)->getToVertex() == to) 
00148         return (*it);
00149     }
00150         
00151     return 0;
00152   };
00153   
00155   const MFVertex &getVertices() const 
00156   {
00157     if (vertexSet != 0)
00158       return static_cast<TemplateVertexSet<VData, EData, FData> *>(vertexSet)->getVertices();
00159     
00160     cx3d << "MESH::TemplateMesh::getVertices: cannot return vertices because VertexSet is NULL!" << std::endl;  
00161     static MFVertex mv;
00162     return mv;
00163   };
00164     
00166   inline const MFEdge &getEdges() const {return _edges;};
00168   inline const MFFace &getFaces() const {return _faces;};
00170   inline MData &data() {return _data;};
00172   inline const MData &data() const {return _data;};
00173   
00175   SFFace *createFace(const MFInt32 &coordIndex, bool ccw = true) 
00176   {
00177     return createFace(_faces.size(), coordIndex, ccw);
00178   };
00179     
00181   SFFace *createFace(SFInt32 i, const MFInt32 &coordIndex, bool ccw = true) 
00182   {
00183     // Creating the Face.
00184     if (static_cast<unsigned int>(i) >= _faces.size())
00185       _faces.resize(i + 1, 0);
00186     else
00187     {
00188       if (_faces[i] != 0)  
00189       {
00190         cx3d << "TemplateMesh::createFace: cannot create a Face at index " << i << ", a Face already exists!" << std::endl;
00191         return 0;
00192       }
00193     }
00194       
00195     SFFace *F = new SFFace(i);
00196     _faces[i] = F;
00197     
00198     if (ccw)
00199     {
00200       // Creating the Edges.
00201       MFInt32::const_iterator itCoordIndex = coordIndex.begin();
00202       SFVertex *A, *B;
00203       SFEdge *E;
00204     
00205       const MFVertex &mv = getVertices();
00206       SFVertex *start = mv[*itCoordIndex]; // to test...
00207     
00208       A = start;
00209       ++itCoordIndex;
00210     
00211       while (itCoordIndex != coordIndex.end())
00212       {
00213         //B = getVertices[*itCoordIndex];
00214         B = mv[*itCoordIndex];
00215         ++itCoordIndex;
00216       
00217         E = getEdge(A, B);
00218         if (E == 0)
00219           E = createEdge(A, B);
00220         
00221         E->addLeftFace(F);    
00222         E->getFromVertex()->addFace(F);    
00223         F->addEdge(E);
00224       
00225         A = B;
00226       }
00227       B  = start;
00228       E = getEdge(A, B);
00229       if (E == 0)
00230         E = createEdge(A, B);
00231     
00232       E->addLeftFace(F);    
00233       E->getFromVertex()->addFace(F);
00234       F->addEdge(E);
00235     }
00236     else
00237     {
00238       // Creating the Edges.
00239       MFInt32::const_reverse_iterator itCoordIndex = coordIndex.rbegin();
00240       SFVertex *A, *B;
00241       SFEdge *E;
00242     
00243       const MFVertex &mv = getVertices();
00244       SFVertex *start = mv[*itCoordIndex]; // to test...
00245     
00246       A = start;
00247       ++itCoordIndex;
00248     
00249       while (itCoordIndex != coordIndex.rend())
00250       {
00251         //B = getVertices[*itCoordIndex];
00252         B = mv[*itCoordIndex];
00253         ++itCoordIndex;
00254       
00255         E = getEdge(A, B);
00256         if (E == 0)
00257           E = createEdge(A, B);
00258         
00259         E->addLeftFace(F);    
00260         E->getFromVertex()->addFace(F);    
00261         F->addEdge(E);
00262       
00263         A = B;
00264       }
00265       B = start;
00266       E = getEdge(A, B);
00267       if (E == 0)
00268         E = createEdge(A, B);
00269     
00270       E->addLeftFace(F);    
00271       E->getFromVertex()->addFace(F);
00272       F->addEdge(E);
00273     }
00274             
00275     return F;
00276   };
00277   
00278 protected:
00280   TemplateMesh(const TemplateMesh &N)
00281   : X3DMeshNode(N), _edges(N._edges), _faces(N._faces), _data(N._data)
00282   {
00283     addChild(N.vertexSet);
00284   };
00285   
00286 private:
00287   MFEdge _edges;
00288   MFFace _faces;
00289   MData _data;
00290   
00292   SFEdge *createEdge(SFVertex *from, SFVertex *to) 
00293   {
00294     if ((from == 0) || (to == 0))
00295       return 0;
00296    
00297     SFTemplateEdgeContent<EData, FData, VData> *content = new SFTemplateEdgeContent<EData, FData, VData>(from, to);
00298     SFEdge *E1 = new SFTemplateDirectEdge<EData, FData, VData>(content);
00299     SFEdge *E2 = new SFTemplateIndirectEdge<EData, FData, VData>(content);
00300     
00301     E1->setSymetric(E2);
00302     E2->setSymetric(E1);
00303        
00304     _edges.push_back(E1);
00305     
00306     // updating content of A and B.
00307     // to complete... to respect order of edges.
00308     from->addEdge(E1);
00309     to->addEdge(E2);
00310     
00311     return E1;
00312   };
00313 };
00314 
00315 }
00316 }
00317 
00318 #endif

Generated on Thu Dec 4 13:25:47 2003 for X3DToolKit by doxygen1.2.18