1 // SMESH SMDS : implementaion of Salome mesh data structure
3 // Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
22 #include "utilities.h"
23 #include "SMDS_Mesh.hxx"
24 #include "SMDS_VolumeOfNodes.hxx"
25 #include "SMDS_VolumeOfFaces.hxx"
26 #include "SMDS_FaceOfNodes.hxx"
27 #include "SMDS_Tria3OfNodes.hxx"
28 #include "SMDS_HexahedronOfNodes.hxx"
29 #include "SMDS_FaceOfEdges.hxx"
31 ///////////////////////////////////////////////////////////////////////////////
32 /// Create a new mesh object
33 ///////////////////////////////////////////////////////////////////////////////
34 SMDS_Mesh::SMDS_Mesh()
35 :myNodeIDFactory(new SMDS_MeshElementIDFactory()),
36 myElementIDFactory(new SMDS_MeshElementIDFactory()),
37 myHasConstructionEdges(false), myHasConstructionFaces(false),
38 myHasInverseElements(true)
42 ///////////////////////////////////////////////////////////////////////////////
43 /// Create a new child mesh
44 /// Note that the tree structure of SMDS_Mesh seems to be unused in this version
45 /// (2003-09-08) of SMESH
46 ///////////////////////////////////////////////////////////////////////////////
47 SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent)
48 :myParent(parent), myNodeIDFactory(parent->myNodeIDFactory),
49 myElementIDFactory(parent->myElementIDFactory),
50 myHasConstructionEdges(false), myHasConstructionFaces(false),
51 myHasInverseElements(true)
55 ///////////////////////////////////////////////////////////////////////////////
56 ///Create a submesh and add it to the current mesh
57 ///////////////////////////////////////////////////////////////////////////////
59 SMDS_Mesh *SMDS_Mesh::AddSubMesh()
61 SMDS_Mesh *submesh = new SMDS_Mesh(this);
62 myChildren.insert(myChildren.end(), submesh);
66 ///////////////////////////////////////////////////////////////////////////////
67 ///create a MeshNode and add it to the current Mesh
68 ///An ID is automatically assigned to the node.
69 ///@return : The created node
70 ///////////////////////////////////////////////////////////////////////////////
72 SMDS_MeshNode * SMDS_Mesh::AddNode(double x, double y, double z)
74 return AddNodeWithID(x,y,z,myNodeIDFactory->GetFreeID());
77 ///////////////////////////////////////////////////////////////////////////////
78 ///create a MeshNode and add it to the current Mesh
79 ///@param ID : The ID of the MeshNode to create
80 ///@return : The created node or NULL if a node with this ID already exists
81 ///////////////////////////////////////////////////////////////////////////////
82 SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID)
84 // find the MeshNode corresponding to ID
85 const SMDS_MeshElement *node = myNodeIDFactory->MeshElement(ID);
89 SMDS_MeshNode * node=new SMDS_MeshNode(x, y, z);
91 myNodeIDFactory->BindID(ID,node);
98 ///////////////////////////////////////////////////////////////////////////////
99 /// create a MeshEdge and add it to the current Mesh
100 /// @return : The created MeshEdge
101 ///////////////////////////////////////////////////////////////////////////////
103 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID)
105 SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
106 SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
107 if((node1==NULL)||(node2==NULL)) return NULL;
108 return AddEdgeWithID(node1, node2, ID);
111 ///////////////////////////////////////////////////////////////////////////////
112 /// create a MeshEdge and add it to the current Mesh
113 /// @return : The created MeshEdge
114 ///////////////////////////////////////////////////////////////////////////////
116 SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode * node1,
117 const SMDS_MeshNode * node2)
119 return AddEdgeWithID(node1, node2, myElementIDFactory->GetFreeID());
122 ///////////////////////////////////////////////////////////////////////////////
123 /// Create a new edge and at it to the mesh
124 /// @param idnode1 ID of the first node
125 /// @param idnode2 ID of the second node
126 /// @param ID ID of the edge to create
127 /// @return The created edge or NULL if an edge with this ID already exists or
128 /// if input nodes are not found.
129 ///////////////////////////////////////////////////////////////////////////////
131 SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
132 const SMDS_MeshNode * n2, int ID)
134 SMDS_MeshNode *node1,*node2;
135 node1=const_cast<SMDS_MeshNode*>(n1);
136 node2=const_cast<SMDS_MeshNode*>(n2);
138 SMDS_MeshEdge * edge=new SMDS_MeshEdge(node1,node2);
139 if(myElementIDFactory->BindID(ID, edge))
141 node1->AddInverseElement(edge);
142 node2->AddInverseElement(edge);
143 myEdges.insert(edge);
153 ///////////////////////////////////////////////////////////////////////////////
154 /// Add a triangle defined by its nodes. An ID is automatically affected to the
156 ///////////////////////////////////////////////////////////////////////////////
158 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
159 const SMDS_MeshNode * n2,
160 const SMDS_MeshNode * n3)
162 return AddFaceWithID(n1,n2,n3, myElementIDFactory->GetFreeID());
165 ///////////////////////////////////////////////////////////////////////////////
166 /// Add a quadrangle defined by its nodes IDs
167 ///////////////////////////////////////////////////////////////////////////////
169 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, int ID)
171 SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
172 SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
173 SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
174 if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL;
175 return AddFaceWithID(node1, node2, node3, ID);
178 ///////////////////////////////////////////////////////////////////////////////
179 /// Add a quadrangle defined by its nodes
180 ///////////////////////////////////////////////////////////////////////////////
182 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(
183 const SMDS_MeshNode * n1,
184 const SMDS_MeshNode * n2,
185 const SMDS_MeshNode * n3, int ID)
187 SMDS_MeshNode *node1, *node2, *node3;
188 node1=const_cast<SMDS_MeshNode*>(n1),
189 node2=const_cast<SMDS_MeshNode*>(n2),
190 node3=const_cast<SMDS_MeshNode*>(n3);
191 SMDS_MeshFace * face=createTriangle(node1, node2, node3);
193 if(myElementIDFactory->BindID(ID, face))
195 node1->AddInverseElement(face);
196 node2->AddInverseElement(face);
197 node3->AddInverseElement(face);
207 ///////////////////////////////////////////////////////////////////////////////
208 /// Add a triangle defined by its nodes. An ID is automatically affected to the
210 ///////////////////////////////////////////////////////////////////////////////
212 SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
213 const SMDS_MeshNode * n2,
214 const SMDS_MeshNode * n3,
215 const SMDS_MeshNode * n4)
217 return AddFaceWithID(n1,n2,n3, myElementIDFactory->GetFreeID());
220 ///////////////////////////////////////////////////////////////////////////////
221 /// Add a quadrangle defined by its nodes IDs
222 ///////////////////////////////////////////////////////////////////////////////
224 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3,
227 SMDS_MeshNode *node1, *node2, *node3, *node4;
228 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
229 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
230 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
231 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
232 if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL;
233 return AddFaceWithID(node1, node2, node3, node4, ID);
236 ///////////////////////////////////////////////////////////////////////////////
237 /// Add a quadrangle defined by its nodes
238 ///////////////////////////////////////////////////////////////////////////////
240 SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
241 const SMDS_MeshNode * n2, const SMDS_MeshNode * n3,
242 const SMDS_MeshNode * n4, int ID)
244 SMDS_MeshNode *node1, *node2, *node3, *node4;
245 node1=const_cast<SMDS_MeshNode*>(n1),
246 node2=const_cast<SMDS_MeshNode*>(n2),
247 node3=const_cast<SMDS_MeshNode*>(n3);
248 node4=const_cast<SMDS_MeshNode*>(n4);
249 SMDS_MeshFace * face=createQuadrangle(node1, node2, node3, node4);
251 if(myElementIDFactory->BindID(ID, face))
253 node1->AddInverseElement(face);
254 node2->AddInverseElement(face);
255 node3->AddInverseElement(face);
256 node4->AddInverseElement(face);
266 ///////////////////////////////////////////////////////////////////////////////
267 ///Create a new tetrahedron and add it to the mesh.
268 ///@return The created tetrahedron
269 ///////////////////////////////////////////////////////////////////////////////
271 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
272 const SMDS_MeshNode * n2, const SMDS_MeshNode * n3,
273 const SMDS_MeshNode * n4)
275 int ID = myElementIDFactory->GetFreeID();
276 SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, ID);
277 if(v==NULL) myElementIDFactory->ReleaseID(ID);
281 ///////////////////////////////////////////////////////////////////////////////
282 ///Create a new tetrahedron and add it to the mesh.
283 ///@param ID The ID of the new volume
284 ///@return The created tetrahedron or NULL if an edge with this ID already exists
285 ///or if input nodes are not found.
286 ///////////////////////////////////////////////////////////////////////////////
288 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2,
289 int idnode3, int idnode4, int ID)
291 SMDS_MeshNode *node1, *node2, *node3, *node4;
292 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
293 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
294 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
295 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
296 if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)) return NULL;
297 return AddVolumeWithID(node1, node2, node3, node4, ID);
300 ///////////////////////////////////////////////////////////////////////////////
301 ///Create a new tetrahedron and add it to the mesh.
302 ///@param ID The ID of the new volume
303 ///@return The created tetrahedron
304 ///////////////////////////////////////////////////////////////////////////////
306 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(
307 const SMDS_MeshNode * n1,
308 const SMDS_MeshNode * n2,
309 const SMDS_MeshNode * n3,
310 const SMDS_MeshNode * n4, int ID)
312 SMDS_MeshNode *node1, *node2, *node3, *node4;
313 node1=const_cast<SMDS_MeshNode*>(n1),
314 node2=const_cast<SMDS_MeshNode*>(n2),
315 node3=const_cast<SMDS_MeshNode*>(n3);
316 node4=const_cast<SMDS_MeshNode*>(n4);
317 SMDS_MeshVolume* volume;
318 if(hasConstructionFaces())
320 SMDS_MeshFace * f1=createTriangle(node1,node2,node3);
321 SMDS_MeshFace * f2=createTriangle(node1,node2,node4);
322 SMDS_MeshFace * f3=createTriangle(node1,node3,node4);
323 SMDS_MeshFace * f4=createTriangle(node2,node3,node4);
324 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4);
325 myVolumes.insert(volume);
327 else if(hasConstructionEdges())
329 MESSAGE("Error : Not implemented");
334 volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4);
335 myVolumes.insert(volume);
338 if(myElementIDFactory->BindID(ID, volume))
340 node1->AddInverseElement(volume);
341 node2->AddInverseElement(volume);
342 node3->AddInverseElement(volume);
343 node4->AddInverseElement(volume);
348 RemoveVolume(volume);
353 ///////////////////////////////////////////////////////////////////////////////
354 ///Create a new pyramid and add it to the mesh.
355 ///Nodes 1,2,3 and 4 define the base of the pyramid
356 ///@return The created pyramid
357 ///////////////////////////////////////////////////////////////////////////////
359 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
360 const SMDS_MeshNode * n2, const SMDS_MeshNode * n3,
361 const SMDS_MeshNode * n4, const SMDS_MeshNode * n5)
363 int ID = myElementIDFactory->GetFreeID();
364 SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, n5, ID);
365 if(v==NULL) myElementIDFactory->ReleaseID(ID);
369 ///////////////////////////////////////////////////////////////////////////////
370 ///Create a new pyramid and add it to the mesh.
371 ///Nodes 1,2,3 and 4 define the base of the pyramid
372 ///@param ID The ID of the new volume
373 ///@return The created pyramid or NULL if a pyramid with this ID already exists
374 ///or if input nodes are not found.
375 ///////////////////////////////////////////////////////////////////////////////
377 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2,
378 int idnode3, int idnode4, int idnode5, int ID)
380 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5;
381 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
382 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
383 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
384 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
385 node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
386 if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)||
389 return AddVolumeWithID(node1, node2, node3, node4, node5, ID);
392 ///////////////////////////////////////////////////////////////////////////////
393 ///Create a new pyramid and add it to the mesh.
394 ///Nodes 1,2,3 and 4 define the base of the pyramid
395 ///@param ID The ID of the new volume
396 ///@return The created pyramid
397 ///////////////////////////////////////////////////////////////////////////////
399 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(
400 const SMDS_MeshNode * n1,
401 const SMDS_MeshNode * n2,
402 const SMDS_MeshNode * n3,
403 const SMDS_MeshNode * n4,
404 const SMDS_MeshNode * n5, int ID)
406 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5;
407 node1=const_cast<SMDS_MeshNode*>(n1),
408 node2=const_cast<SMDS_MeshNode*>(n2),
409 node3=const_cast<SMDS_MeshNode*>(n3);
410 node4=const_cast<SMDS_MeshNode*>(n4);
411 node5=const_cast<SMDS_MeshNode*>(n5);
412 SMDS_MeshVolume* volume;
413 if(hasConstructionFaces())
415 SMDS_MeshFace * f1=createQuadrangle(node1,node2,node3,node4);
416 SMDS_MeshFace * f2=createTriangle(node1,node2,node5);
417 SMDS_MeshFace * f3=createTriangle(node2,node3,node5);
418 SMDS_MeshFace * f4=createTriangle(node3,node4,node5);
419 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4);
420 myVolumes.insert(volume);
422 else if(hasConstructionEdges())
424 MESSAGE("Error : Not implemented");
429 volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4,node5);
430 myVolumes.insert(volume);
433 if(myElementIDFactory->BindID(ID, volume))
435 node1->AddInverseElement(volume);
436 node2->AddInverseElement(volume);
437 node3->AddInverseElement(volume);
438 node4->AddInverseElement(volume);
439 node5->AddInverseElement(volume);
444 RemoveVolume(volume);
449 ///////////////////////////////////////////////////////////////////////////////
450 ///Create a new prism and add it to the mesh.
451 ///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle.
452 ///@return The created prism
453 ///////////////////////////////////////////////////////////////////////////////
455 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
456 const SMDS_MeshNode * n2, const SMDS_MeshNode * n3,
457 const SMDS_MeshNode * n4, const SMDS_MeshNode * n5,
458 const SMDS_MeshNode * n6)
460 int ID = myElementIDFactory->GetFreeID();
461 SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
462 if(v==NULL) myElementIDFactory->ReleaseID(ID);
466 ///////////////////////////////////////////////////////////////////////////////
467 ///Create a new prism and add it to the mesh.
468 ///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle.
469 ///@param ID The ID of the new volume
470 ///@return The created prism or NULL if a prism with this ID already exists
471 ///or if input nodes are not found.
472 ///////////////////////////////////////////////////////////////////////////////
474 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2,
475 int idnode3, int idnode4, int idnode5, int idnode6, int ID)
477 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6;
478 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
479 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
480 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
481 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
482 node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
483 node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6);
484 if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)||
485 (node5==NULL)||(node6=NULL))
487 return AddVolumeWithID(node1, node2, node3, node4, node5, node6, ID);
490 ///////////////////////////////////////////////////////////////////////////////
491 ///Create a new prism and add it to the mesh.
492 ///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle.
493 ///@param ID The ID of the new volume
494 ///@return The created prism
495 ///////////////////////////////////////////////////////////////////////////////
497 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(
498 const SMDS_MeshNode * n1,
499 const SMDS_MeshNode * n2,
500 const SMDS_MeshNode * n3,
501 const SMDS_MeshNode * n4,
502 const SMDS_MeshNode * n5,
503 const SMDS_MeshNode * n6, int ID)
505 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6;
506 node1=const_cast<SMDS_MeshNode*>(n1),
507 node2=const_cast<SMDS_MeshNode*>(n2),
508 node3=const_cast<SMDS_MeshNode*>(n3);
509 node4=const_cast<SMDS_MeshNode*>(n4);
510 node5=const_cast<SMDS_MeshNode*>(n5);
511 node6=const_cast<SMDS_MeshNode*>(n6);
512 SMDS_MeshVolume* volume;
513 if(hasConstructionFaces())
515 SMDS_MeshFace * f1=createTriangle(node1,node2,node3);
516 SMDS_MeshFace * f2=createTriangle(node4,node5,node6);
517 SMDS_MeshFace * f3=createQuadrangle(node1,node4,node5,node2);
518 SMDS_MeshFace * f4=createQuadrangle(node2,node5,node6,node3);
519 SMDS_MeshFace * f5=createQuadrangle(node3,node6,node4,node1);
520 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5);
521 myVolumes.insert(volume);
523 else if(hasConstructionEdges())
525 MESSAGE("Error : Not implemented");
530 volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4,node5,node6);
531 myVolumes.insert(volume);
534 if(myElementIDFactory->BindID(ID, volume))
536 node1->AddInverseElement(volume);
537 node2->AddInverseElement(volume);
538 node3->AddInverseElement(volume);
539 node4->AddInverseElement(volume);
540 node5->AddInverseElement(volume);
541 node6->AddInverseElement(volume);
546 RemoveVolume(volume);
551 ///////////////////////////////////////////////////////////////////////////////
552 ///Create a new hexahedron and add it to the mesh.
553 ///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges.
554 ///@return The created hexahedron
555 ///////////////////////////////////////////////////////////////////////////////
557 SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
558 const SMDS_MeshNode * n2, const SMDS_MeshNode * n3,
559 const SMDS_MeshNode * n4, const SMDS_MeshNode * n5,
560 const SMDS_MeshNode * n6, const SMDS_MeshNode * n7,
561 const SMDS_MeshNode * n8)
563 int ID = myElementIDFactory->GetFreeID();
564 SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID);
565 if(v==NULL) myElementIDFactory->ReleaseID(ID);
569 ///////////////////////////////////////////////////////////////////////////////
570 ///Create a new hexahedron and add it to the mesh.
571 ///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges.
572 ///@param ID The ID of the new volume
573 ///@return The created hexahedron or NULL if an hexahedron with this ID already
574 ///exists or if input nodes are not found.
575 ///////////////////////////////////////////////////////////////////////////////
577 SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2,
578 int idnode3, int idnode4, int idnode5, int idnode6, int idnode7,
581 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8;
582 node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
583 node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
584 node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3);
585 node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4);
586 node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5);
587 node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6);
588 node7 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode7);
589 node8 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode8);
590 if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)||
591 (node5==NULL)||(node6=NULL)||(node7==NULL)||(node8=NULL))
593 return AddVolumeWithID(node1, node2, node3, node4, node5, node6, node7,
597 ///////////////////////////////////////////////////////////////////////////////
598 ///Create a new hexahedron and add it to the mesh.
599 ///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges.
600 ///@param ID The ID of the new volume
601 ///@return The created prism or NULL if an hexadron with this ID already exists
602 ///or if input nodes are not found.
603 ///////////////////////////////////////////////////////////////////////////////
605 SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(
606 const SMDS_MeshNode * n1,
607 const SMDS_MeshNode * n2,
608 const SMDS_MeshNode * n3,
609 const SMDS_MeshNode * n4,
610 const SMDS_MeshNode * n5,
611 const SMDS_MeshNode * n6,
612 const SMDS_MeshNode * n7,
613 const SMDS_MeshNode * n8, int ID)
615 SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8;
616 node1=const_cast<SMDS_MeshNode*>(n1),
617 node2=const_cast<SMDS_MeshNode*>(n2),
618 node3=const_cast<SMDS_MeshNode*>(n3);
619 node4=const_cast<SMDS_MeshNode*>(n4);
620 node5=const_cast<SMDS_MeshNode*>(n5);
621 node6=const_cast<SMDS_MeshNode*>(n6);
622 node7=const_cast<SMDS_MeshNode*>(n7);
623 node8=const_cast<SMDS_MeshNode*>(n8);
624 SMDS_MeshVolume* volume;
625 if(hasConstructionFaces())
627 SMDS_MeshFace * f1=FindFaceOrCreate(node1,node2,node3,node4);
628 SMDS_MeshFace * f2=FindFaceOrCreate(node5,node6,node7,node8);
629 SMDS_MeshFace * f3=FindFaceOrCreate(node1,node4,node8,node5);
630 SMDS_MeshFace * f4=FindFaceOrCreate(node1,node2,node6,node5);
631 SMDS_MeshFace * f5=FindFaceOrCreate(node2,node3,node7,node6);
632 SMDS_MeshFace * f6=FindFaceOrCreate(node3,node4,node8,node7);
633 volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5,f6);
634 myVolumes.insert(volume);
636 else if(hasConstructionEdges())
638 MESSAGE("Error : Not implemented");
643 volume=new SMDS_HexahedronOfNodes(node1,node2,node3,node4,node5,node6,
645 myVolumes.insert(volume);
648 if(myElementIDFactory->BindID(ID, volume))
650 node1->AddInverseElement(volume);
651 node2->AddInverseElement(volume);
652 node3->AddInverseElement(volume);
653 node4->AddInverseElement(volume);
654 node5->AddInverseElement(volume);
655 node6->AddInverseElement(volume);
656 node7->AddInverseElement(volume);
657 node8->AddInverseElement(volume);
662 RemoveVolume(volume);
667 ///////////////////////////////////////////////////////////////////////////////
668 /// Return the node whose ID is 'ID'.
669 ///////////////////////////////////////////////////////////////////////////////
670 const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const
672 return (const SMDS_MeshNode *)myNodeIDFactory->MeshElement(ID);
675 ///////////////////////////////////////////////////////////////////////////////
676 ///Create a triangle and add it to the current mesh. This methode do not bind a
677 ///ID to the create triangle.
678 ///////////////////////////////////////////////////////////////////////////////
679 SMDS_MeshFace * SMDS_Mesh::createTriangle(SMDS_MeshNode * node1,
680 SMDS_MeshNode * node2, SMDS_MeshNode * node3)
682 if(hasConstructionEdges())
684 SMDS_MeshEdge *edge1, *edge2, *edge3;
685 edge1=FindEdgeOrCreate(node1,node2);
686 edge2=FindEdgeOrCreate(node2,node3);
687 edge3=FindEdgeOrCreate(node3,node1);
689 SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3);
690 myFaces.insert(face);
695 SMDS_MeshFace * face = new SMDS_Tria3OfNodes(node1,node2,node3);
696 myFaces.insert(face);
701 ///////////////////////////////////////////////////////////////////////////////
702 ///Create a quadrangle and add it to the current mesh. This methode do not bind
703 ///a ID to the create triangle.
704 ///////////////////////////////////////////////////////////////////////////////
705 SMDS_MeshFace * SMDS_Mesh::createQuadrangle(SMDS_MeshNode * node1,
706 SMDS_MeshNode * node2, SMDS_MeshNode * node3, SMDS_MeshNode * node4)
708 if(hasConstructionEdges())
710 SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4;
711 edge1=FindEdgeOrCreate(node1,node2);
712 edge2=FindEdgeOrCreate(node2,node3);
713 edge3=FindEdgeOrCreate(node3,node4);
714 edge4=FindEdgeOrCreate(node4,node1);
716 SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3,edge4);
717 myFaces.insert(face);
722 SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3,node4);
723 myFaces.insert(face);
728 ///////////////////////////////////////////////////////////////////////////////
729 /// Remove a node and all the elements which own this node
730 ///////////////////////////////////////////////////////////////////////////////
732 void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
734 SMDS_Iterator<const SMDS_MeshElement *> * it=
735 node->GetInverseElementIterator();
736 while(it->more()) RemoveElement(it->next(),true);
737 myNodeIDFactory->ReleaseID(node->GetID());
738 myNodes.erase(const_cast<SMDS_MeshNode*>(node));
741 ///////////////////////////////////////////////////////////////////////////////
742 /// Remove an edge and all the elements which own this edge
743 ///////////////////////////////////////////////////////////////////////////////
745 void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
747 /** @todo to be fix */
748 myEdges.erase(const_cast<SMDS_MeshEdge*>(edge));
749 //removeElementDependencies(edge);
753 ///////////////////////////////////////////////////////////////////////////////
754 /// Remove an face and all the elements which own this face
755 ///////////////////////////////////////////////////////////////////////////////
757 void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
759 /** @todo to be fix */
760 myFaces.erase(const_cast<SMDS_MeshFace*>(face));
761 //removeElementDependencies(face);
765 ///////////////////////////////////////////////////////////////////////////////
767 ///////////////////////////////////////////////////////////////////////////////
769 void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume)
771 /** @todo to be fix */
772 myVolumes.erase(const_cast<SMDS_MeshVolume*>(volume));
773 //removeElementDependencies(volume);
777 ///////////////////////////////////////////////////////////////////////////////
778 /// Remove no longer used sub element of an element. Unbind the element ID
779 ///////////////////////////////////////////////////////////////////////////////
781 void SMDS_Mesh::removeElementDependencies(SMDS_MeshElement * element)
783 /** @todo to be fix */
784 myElementIDFactory->ReleaseID(element->GetID());
785 SMDS_Iterator<const SMDS_MeshElement*> * it=element->nodesIterator();
788 SMDS_MeshNode * node=static_cast<SMDS_MeshNode*>(
789 const_cast<SMDS_MeshElement*>(it->next()));
790 node->RemoveInverseElement(element);
791 if(node->emptyInverseElements()) RemoveNode(node);
795 //=======================================================================
796 //function : RemoveElement
798 //=======================================================================
800 void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
801 const bool removenodes)
803 /** @todo to be fix */
804 switch(elem->GetType())
807 RemoveNode((const SMDS_MeshNode*)elem);
810 RemoveEdge((const SMDS_MeshEdge*)elem);
813 RemoveFace((const SMDS_MeshFace*)elem);
816 RemoveVolume((const SMDS_MeshVolume*)elem);
819 MESSAGE("remove function : unknown type");
823 SMDS_Iterator<const SMDS_MeshNode*> * it=elem->nodesIterator();
826 const SMDS_MeshNode * node=it->next();
831 //=======================================================================
832 //function : RemoveFromParent
834 //=======================================================================
836 bool SMDS_Mesh::RemoveFromParent()
838 if (myParent==NULL) return false;
839 else return (myParent->RemoveSubMesh(this));
842 //=======================================================================
843 //function : RemoveSubMesh
845 //=======================================================================
847 bool SMDS_Mesh::RemoveSubMesh(const SMDS_Mesh * aMesh)
851 list<SMDS_Mesh *>::iterator itmsh=myChildren.begin();
852 for (; itmsh!=myChildren.end() && !found; itmsh++)
854 SMDS_Mesh * submesh = *itmsh;
855 if (submesh == aMesh)
858 myChildren.erase(itmsh);
866 //=======================================================================
867 //function : FindEdge
869 //=======================================================================
871 const SMDS_MeshEdge* SMDS_Mesh::FindEdge(int idnode1, int idnode2) const
873 const SMDS_MeshNode * node1=FindNode(idnode1);
874 const SMDS_MeshNode * node2=FindNode(idnode2);
875 if((node1==NULL)||(node2==NULL)) return NULL;
876 return FindEdge(node1,node2);
879 ///////////////////////////////////////////////////////////////////////////////
881 ///////////////////////////////////////////////////////////////////////////////
882 //#include "Profiler.h"
883 const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1,
884 const SMDS_MeshNode * node2) const
886 const SMDS_MeshEdge * toReturn=NULL;
889 SMDS_Iterator<const SMDS_MeshElement *>* it1=node1->edgesIterator();
894 const SMDS_MeshEdge * e=static_cast<const SMDS_MeshEdge *>
896 SMDS_Iterator<const SMDS_MeshElement *>* it2=e->nodesIterator();
899 if(it2->next()->GetID()==node2->GetID())
913 SMDS_MeshEdge* SMDS_Mesh::FindEdgeOrCreate(const SMDS_MeshNode * node1,
914 const SMDS_MeshNode * node2)
916 SMDS_MeshEdge * toReturn=NULL;
917 toReturn=const_cast<SMDS_MeshEdge*>(FindEdge(node1,node2));
920 toReturn=new SMDS_MeshEdge(const_cast<SMDS_MeshNode*>(node1),
921 const_cast<SMDS_MeshNode*>(node2));
922 myEdges.insert(toReturn);
927 //=======================================================================
928 //function : FindFace
930 //=======================================================================
932 const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2,
935 const SMDS_MeshNode * node1=FindNode(idnode1);
936 const SMDS_MeshNode * node2=FindNode(idnode2);
937 const SMDS_MeshNode * node3=FindNode(idnode3);
938 const SMDS_MeshFace * face;
939 const SMDS_MeshElement * node;
940 bool node2found, node3found;
941 if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL;
943 SMDS_Iterator<const SMDS_MeshElement *>* it1=node1->facesIterator();
946 face=static_cast<const SMDS_MeshFace*>(it1->next());
947 if(face->NbNodes()!=3) continue;
948 SMDS_Iterator<const SMDS_MeshElement *>* it2=face->nodesIterator();
954 if(node->GetID()==idnode2) node2found=true;
955 if(node->GetID()==idnode3) node3found=true;
958 if(node2found&&node3found)
968 //=======================================================================
969 //function : FindFace
971 //=======================================================================
973 const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2, int idnode3,
976 const SMDS_MeshNode * node1=FindNode(idnode1);
977 const SMDS_MeshNode * node2=FindNode(idnode2);
978 const SMDS_MeshNode * node3=FindNode(idnode3);
979 const SMDS_MeshNode * node4=FindNode(idnode4);
980 if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)) return NULL;
981 return FindFace(node1, node2, node3, node4);
984 const SMDS_MeshFace* SMDS_Mesh::FindFace(
985 const SMDS_MeshNode *node1,
986 const SMDS_MeshNode *node2,
987 const SMDS_MeshNode *node3,
988 const SMDS_MeshNode *node4) const
990 const SMDS_MeshFace * face;
991 const SMDS_MeshElement * node;
992 bool node2found, node3found, node4found;
993 SMDS_Iterator<const SMDS_MeshElement *>* it1=node1->facesIterator();
996 face=static_cast<const SMDS_MeshFace *>(it1->next());
997 if(face->NbNodes()!=4) continue;
998 SMDS_Iterator<const SMDS_MeshElement *>* it2=face->nodesIterator();
1005 if(node->GetID()==node2->GetID()) node2found=true;
1006 if(node->GetID()==node3->GetID()) node3found=true;
1007 if(node->GetID()==node4->GetID()) node4found=true;
1010 if(node2found&&node3found&&node4found)
1020 SMDS_MeshFace* SMDS_Mesh::FindFaceOrCreate(
1021 const SMDS_MeshNode *node1,
1022 const SMDS_MeshNode *node2,
1023 const SMDS_MeshNode *node3,
1024 const SMDS_MeshNode *node4)
1026 SMDS_MeshFace * toReturn=NULL;
1027 toReturn=const_cast<SMDS_MeshFace*>(FindFace(node1,node2,node3,node4));
1030 toReturn=createQuadrangle(
1031 const_cast<SMDS_MeshNode *>(node1),
1032 const_cast<SMDS_MeshNode *>(node2),
1033 const_cast<SMDS_MeshNode *>(node3),
1034 const_cast<SMDS_MeshNode *>(node4)
1040 //=======================================================================
1041 //function : FindElement
1043 //=======================================================================
1045 const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const
1047 return myElementIDFactory->MeshElement(IDelem);
1050 //=======================================================================
1051 //function : DumpNodes
1053 //=======================================================================
1055 void SMDS_Mesh::DumpNodes() const
1057 MESSAGE("dump nodes of mesh : ");
1058 SMDS_Iterator<const SMDS_MeshNode *> * itnode=nodesIterator();
1059 while(itnode->more()) MESSAGE(itnode->next());
1063 //=======================================================================
1064 //function : DumpEdges
1066 //=======================================================================
1068 void SMDS_Mesh::DumpEdges() const
1070 MESSAGE("dump edges of mesh : ");
1071 SMDS_Iterator<const SMDS_MeshEdge *> * itedge=edgesIterator();
1072 while(itedge->more()) MESSAGE(itedge->next());
1076 //=======================================================================
1077 //function : DumpFaces
1079 //=======================================================================
1081 void SMDS_Mesh::DumpFaces() const
1083 MESSAGE("dump faces of mesh : ");
1084 SMDS_Iterator<const SMDS_MeshFace *> * itface=facesIterator();
1085 while(itface->more()) MESSAGE(itface->next());
1089 //=======================================================================
1090 //function : DumpVolumes
1092 //=======================================================================
1094 void SMDS_Mesh::DumpVolumes() const
1096 MESSAGE("dump volumes of mesh : ");
1097 SMDS_Iterator<const SMDS_MeshVolume *> * itvol=volumesIterator();
1098 while(itvol->more()) MESSAGE(itvol->next());
1102 //=======================================================================
1103 //function : DebugStats
1105 //=======================================================================
1107 void SMDS_Mesh::DebugStats() const
1109 MESSAGE("Debug stats of mesh : ");
1111 MESSAGE("===== NODES ====="<<NbNodes());
1112 MESSAGE("===== EDGES ====="<<NbEdges());
1113 MESSAGE("===== FACES ====="<<NbFaces());
1114 MESSAGE("===== VOLUMES ====="<<NbVolumes());
1116 MESSAGE("End Debug stats of mesh ");
1120 SMDS_Iterator<const SMDS_MeshNode *> * itnode=nodesIterator();
1121 int sizeofnodes = 0;
1122 int sizeoffaces = 0;
1124 while(itnode->more())
1126 const SMDS_MeshNode *node = itnode->next();
1128 sizeofnodes += sizeof(*node);
1130 SMDS_Iterator<const SMDS_MeshElement *> * it=
1131 node->GetInverseElementIterator();
1134 const SMDS_MeshElement *me = it->next();
1135 sizeofnodes += sizeof(me);
1141 SMDS_Iterator<const SMDS_MeshFace*>* itface=facesIterator();
1143 while(itface->more())
1145 const SMDS_MeshElement *face = itface->next();
1146 sizeoffaces += sizeof(*face);
1149 MESSAGE("total size of node elements = " << sizeofnodes);;
1150 MESSAGE("total size of face elements = " << sizeoffaces);;
1156 ///////////////////////////////////////////////////////////////////////////////
1157 /// Return the number of nodes
1158 ///////////////////////////////////////////////////////////////////////////////
1159 int SMDS_Mesh::NbNodes() const
1161 return myNodes.size();
1164 ///////////////////////////////////////////////////////////////////////////////
1165 /// Return the number of edges (including construction edges)
1166 ///////////////////////////////////////////////////////////////////////////////
1167 int SMDS_Mesh::NbEdges() const
1169 return myEdges.size();
1172 ///////////////////////////////////////////////////////////////////////////////
1173 /// Return the number of faces (including construction faces)
1174 ///////////////////////////////////////////////////////////////////////////////
1175 int SMDS_Mesh::NbFaces() const
1177 return myFaces.size();
1180 ///////////////////////////////////////////////////////////////////////////////
1181 /// Return the number of volumes
1182 ///////////////////////////////////////////////////////////////////////////////
1183 int SMDS_Mesh::NbVolumes() const
1185 return myVolumes.size();
1188 ///////////////////////////////////////////////////////////////////////////////
1189 /// Return the number of child mesh of this mesh.
1190 /// Note that the tree structure of SMDS_Mesh seems to be unused in this version
1191 /// (2003-09-08) of SMESH
1192 ///////////////////////////////////////////////////////////////////////////////
1193 int SMDS_Mesh::NbSubMesh() const
1195 return myChildren.size();
1198 ///////////////////////////////////////////////////////////////////////////////
1199 /// Destroy the mesh and all its elements
1200 /// All pointer on elements owned by this mesh become illegals.
1201 ///////////////////////////////////////////////////////////////////////////////
1202 SMDS_Mesh::~SMDS_Mesh()
1206 delete myNodeIDFactory;
1207 delete myElementIDFactory;
1210 list<SMDS_Mesh*>::iterator itc=myChildren.begin();
1211 while(itc!=myChildren.end())
1217 SMDS_Iterator<const SMDS_MeshNode*> * itn=nodesIterator();
1224 set<SMDS_MeshEdge*>::iterator ite=myEdges.begin();
1225 while(ite!=myEdges.end())
1231 set<SMDS_MeshFace*>::iterator itf=myFaces.begin();
1232 while(itf!=myFaces.end())
1238 set<SMDS_MeshVolume*>::iterator itv=myVolumes.begin();
1239 while(itv!=myVolumes.end())
1247 ///////////////////////////////////////////////////////////////////////////////
1248 /// Return true if this mesh create faces with edges.
1249 /// A false returned value mean that faces are created with nodes. A concequence
1250 /// is, iteration on edges (SMDS_Element::edgesIterator) will be unavailable.
1251 ///////////////////////////////////////////////////////////////////////////////
1252 bool SMDS_Mesh::hasConstructionEdges()
1254 return myHasConstructionEdges;
1257 ///////////////////////////////////////////////////////////////////////////////
1258 /// Return true if this mesh create volumes with faces
1259 /// A false returned value mean that volumes are created with nodes or edges.
1260 /// (see hasConstructionEdges)
1261 /// A concequence is, iteration on faces (SMDS_Element::facesIterator) will be
1263 ///////////////////////////////////////////////////////////////////////////////
1264 bool SMDS_Mesh::hasConstructionFaces()
1266 return myHasConstructionFaces;
1269 ///////////////////////////////////////////////////////////////////////////////
1270 /// Return true if nodes are linked to the finit elements, they are belonging to.
1271 /// Currently, It always return true.
1272 ///////////////////////////////////////////////////////////////////////////////
1273 bool SMDS_Mesh::hasInverseElements()
1275 return myHasInverseElements;
1278 ///////////////////////////////////////////////////////////////////////////////
1279 /// Make this mesh creating construction edges (see hasConstructionEdges)
1280 /// @param b true to have construction edges, else false.
1281 ///////////////////////////////////////////////////////////////////////////////
1282 void SMDS_Mesh::setConstructionEdges(bool b)
1284 myHasConstructionEdges=b;
1287 ///////////////////////////////////////////////////////////////////////////////
1288 /// Make this mesh creating construction faces (see hasConstructionFaces)
1289 /// @param b true to have construction faces, else false.
1290 ///////////////////////////////////////////////////////////////////////////////
1291 void SMDS_Mesh::setConstructionFaces(bool b)
1293 myHasConstructionFaces=b;
1296 ///////////////////////////////////////////////////////////////////////////////
1297 /// Make this mesh creating link from nodes to elements (see hasInverseElements)
1298 /// @param b true to link nodes to elements, else false.
1299 ///////////////////////////////////////////////////////////////////////////////
1300 void SMDS_Mesh::setInverseElements(bool b)
1302 if(!b) MESSAGE("Error : inverseElement=false not implemented");
1303 myHasInverseElements=b;
1306 ///////////////////////////////////////////////////////////////////////////////
1307 /// Return an iterator on nodes of the current mesh. Once used this iterator
1308 /// must be free by the caller
1309 ///////////////////////////////////////////////////////////////////////////////
1310 SMDS_Iterator<const SMDS_MeshNode *> * SMDS_Mesh::nodesIterator() const
1312 class MyIterator:public SMDS_Iterator<const SMDS_MeshNode*>
1314 const SetOfNodes& mySet;
1315 SetOfNodes::iterator myIterator;
1317 MyIterator(const SetOfNodes& s):mySet(s)
1319 myIterator=mySet.begin();
1324 return myIterator!=mySet.end();
1327 const SMDS_MeshNode* next()
1329 const SMDS_MeshNode* current=*myIterator;
1334 return new MyIterator(myNodes);
1337 ///////////////////////////////////////////////////////////////////////////////
1338 ///Return an iterator on volumes of the current mesh. Once used this iterator
1339 ///must be free by the caller
1340 ///////////////////////////////////////////////////////////////////////////////
1341 SMDS_Iterator<const SMDS_MeshEdge *> * SMDS_Mesh::edgesIterator() const
1343 class MyIterator:public SMDS_Iterator<const SMDS_MeshEdge*>
1345 const SetOfEdges& mySet;
1346 const SMDS_MeshEdge * myEdge;
1347 SetOfEdges::iterator myIterator;
1349 MyIterator(const SetOfEdges& s):mySet(s)
1351 myIterator=mySet.begin();
1356 while((myIterator!=mySet.end()))
1358 if((*myIterator)->GetID()!=-1)
1365 const SMDS_MeshEdge* next()
1367 const SMDS_MeshEdge* current=*myIterator;
1372 return new MyIterator(myEdges);
1375 ///////////////////////////////////////////////////////////////////////////////
1376 ///Return an iterator on faces of the current mesh. Once used this iterator
1377 ///must be free by the caller
1378 ///////////////////////////////////////////////////////////////////////////////
1379 SMDS_Iterator<const SMDS_MeshFace *> * SMDS_Mesh::facesIterator() const
1381 class MyIterator:public SMDS_Iterator<const SMDS_MeshFace*>
1383 const SetOfFaces& mySet;
1384 set<SMDS_MeshFace*>::iterator myIterator;
1386 MyIterator(const SetOfFaces& s):mySet(s)
1388 myIterator=mySet.begin();
1393 while((myIterator!=mySet.end()))
1395 if((*myIterator)->GetID()!=-1)
1402 const SMDS_MeshFace* next()
1404 const SMDS_MeshFace* current=*myIterator;
1409 return new MyIterator(myFaces);
1412 ///////////////////////////////////////////////////////////////////////////////
1413 ///Return an iterator on volumes of the current mesh. Once used this iterator
1414 ///must be free by the caller
1415 ///////////////////////////////////////////////////////////////////////////////
1416 SMDS_Iterator<const SMDS_MeshVolume *> * SMDS_Mesh::volumesIterator() const
1418 class MyIterator:public SMDS_Iterator<const SMDS_MeshVolume*>
1420 const SetOfVolumes& mySet;
1421 SetOfVolumes::iterator myIterator;
1423 MyIterator(const SetOfVolumes& s):mySet(s)
1425 myIterator=mySet.begin();
1430 return myIterator!=mySet.end();
1433 const SMDS_MeshVolume* next()
1435 const SMDS_MeshVolume* current=*myIterator;
1440 return new MyIterator(myVolumes);