From: jrt Date: Wed, 3 Sep 2003 17:30:36 +0000 (+0000) Subject: New DS implementation X-Git-Tag: V1_2_2~38 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=484fe83a97f643207334576fbe08d4a90d67fd37;p=modules%2Fsmesh.git New DS implementation --- diff --git a/src/SMDS/SMDS_Mesh.cxx b/src/SMDS/SMDS_Mesh.cxx index 9ba956012..a67282810 100644 --- a/src/SMDS/SMDS_Mesh.cxx +++ b/src/SMDS/SMDS_Mesh.cxx @@ -18,460 +18,337 @@ // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // // See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org -// -// -// -// File : SMDS_Mesh.cxx -// Author : Jean-Michel BOULCOURT -// Module : SMESH - -using namespace std; -#include "SMDS_Mesh.ixx" -#include "SMDS_MapIteratorOfExtendedOrientedMap.hxx" -#include "SMDS_ListOfMeshElement.hxx" -#include "SMDS_ListIteratorOfListOfMeshElement.hxx" -#include "SMDS_MeshNode.hxx" -#include "SMDS_MeshEdge.hxx" -#include "SMDS_MeshFace.hxx" -#include "SMDS_MeshTriangle.hxx" -#include "SMDS_MeshQuadrangle.hxx" -#include "SMDS_MeshVolume.hxx" -#include "SMDS_MeshTetrahedron.hxx" -#include "SMDS_MeshPyramid.hxx" -#include "SMDS_MeshPrism.hxx" -#include "SMDS_MeshHexahedron.hxx" -#include "SMDS_ListOfMesh.hxx" -#include "SMDS_ListIteratorOfListOfMesh.hxx" - - -#include -#include #include "utilities.h" +#include "SMDS_Mesh.hxx" +#include "SMDS_VolumeOfNodes.hxx" +#include "SMDS_VolumeOfFaces.hxx" +#include "SMDS_FaceOfNodes.hxx" +#include "SMDS_FaceOfEdges.hxx" - -//======================================================================= -//function : SMDS_Mesh -//purpose : creation of a new mesh object -//======================================================================= - -SMDS_Mesh::SMDS_Mesh(const Standard_Integer nbnodes, - const Standard_Integer nbedges, - const Standard_Integer nbfaces, - const Standard_Integer nbvolumes) - :myNodes(nbnodes),myEdges(nbedges),myFaces(nbfaces),myVolumes(nbvolumes), - myNodeIDFactory(new SMDS_MeshNodeIDFactory()), - myElementIDFactory(new SMDS_MeshElementIDFactory()),myHasInverse(Standard_False) +/////////////////////////////////////////////////////////////////////////////// +/// Create a new mesh object +/////////////////////////////////////////////////////////////////////////////// +SMDS_Mesh::SMDS_Mesh() + :myNodeIDFactory(new SMDS_MeshElementIDFactory()), + myElementIDFactory(new SMDS_MeshElementIDFactory()), + myHasConstructionEdges(false), myHasConstructionFaces(false), + myHasInverseElements(true) { } -//======================================================================= -//function : SMDS_Mesh -//purpose : -//======================================================================= - -SMDS_Mesh::SMDS_Mesh(const Handle(SMDS_Mesh)& parent, - const Standard_Integer nbnodes) - :myNodes(nbnodes),myParent(parent),myNodeIDFactory(parent->myNodeIDFactory), - myElementIDFactory(parent->myElementIDFactory), - myHasInverse(Standard_False) +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent) + :myParent(parent), myNodeIDFactory(parent->myNodeIDFactory), + myElementIDFactory(parent->myElementIDFactory), + myHasConstructionEdges(false), myHasConstructionFaces(false), + myHasInverseElements(true) { } -//======================================================================= -//function : AddSubMesh -//purpose : create an submesh -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +///Create a submesh and add it to the current mesh +/////////////////////////////////////////////////////////////////////////////// -Handle(SMDS_Mesh) SMDS_Mesh::AddSubMesh() +SMDS_Mesh *SMDS_Mesh::AddSubMesh() { - Handle(SMDS_Mesh) submesh = new SMDS_Mesh(this); - if (!submesh.IsNull()) { - myChildren.Append(submesh); - } - - return submesh; + SMDS_Mesh *submesh = new SMDS_Mesh(this); + myChildren.insert(myChildren.end(), submesh); + return submesh; } +/////////////////////////////////////////////////////////////////////////////// +///create a MeshNode and add it to the current Mesh +///@return : The created node +/////////////////////////////////////////////////////////////////////////////// -//======================================================================= -//function : AddNode -//purpose : create a MeshNode and returns an ID -//======================================================================= - -Standard_Integer SMDS_Mesh::AddNode(const Standard_Real x, - const Standard_Real y, - const Standard_Real z) +SMDS_MeshNode * SMDS_Mesh::AddNode(double x, double y, double z) { - Standard_Integer ID = myNodeIDFactory->GetFreeID(); - - Handle(SMDS_MeshElement) node = new SMDS_MeshNode(ID,x,y,z); - AddNode(node); - - return ID; + return AddNodeWithID(x,y,z,myNodeIDFactory->GetFreeID()); } -//======================================================================= -//function : AddNode -//purpose : create a MeshNode. Returns False if the ID already exists -//======================================================================= - -Standard_Boolean SMDS_Mesh::AddNodeWithID(const Standard_Real x, - const Standard_Real y, - const Standard_Real z, - const Standard_Integer ID) +/////////////////////////////////////////////////////////////////////////////// +///create a MeshNode and add it to the current Mesh +///@param ID : The ID of the MeshNode to create +///@return : The created node or NULL if a node with this ID already exists +/////////////////////////////////////////////////////////////////////////////// +SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID) { + // find the MeshNode corresponding to ID + const SMDS_MeshElement *node = myNodeIDFactory->MeshElement(ID); - // find the MeshNode corresponding to ID - Handle(SMDS_MeshElement) node; - node = GetNode(ID); - - if (node.IsNull()) { - node = new SMDS_MeshNode(ID,x,y,z); - AddNode(node); - return Standard_True; - } else - return Standard_False; - -} - -//======================================================================= -//function : AddNode -//purpose : add an existing node in the mesh (useful for submesh) -//======================================================================= - -Standard_Boolean SMDS_Mesh::AddNode(const Standard_Integer ID) -{ - // find the MeshNode corresponding to ID - Handle(SMDS_MeshElement) node; - - node = GetNode(ID); - - if (!node.IsNull()) { - myNodes.Add(node); - return Standard_True;; - } else - return Standard_False; -} - -//======================================================================= -//function : AddNode -//purpose : -//======================================================================= - -Standard_Boolean SMDS_Mesh::AddNode(const Handle(SMDS_MeshElement)& node) -{ - - if (!node.IsNull()) { - myNodes.Add(node); - if (!myParent.IsNull()) { - myParent->AddNode(node); - } - return Standard_True; - } else - return Standard_False; -} - - -//======================================================================= -//function : AddEdge -//purpose : -//======================================================================= - -Standard_Integer SMDS_Mesh::AddEdge(const Standard_Integer idnode1, - const Standard_Integer idnode2) -{ - Standard_Integer ID = myElementIDFactory->GetFreeID(); - - if (AddEdgeWithID(idnode1,idnode2,ID)) - return ID; - else - return 0; - + if (node == NULL) + { + SMDS_MeshNode * node=new SMDS_MeshNode(x, y, z); + myNodes.insert(node); + myNodeIDFactory->BindID(ID,node); + return node; + } + else + return NULL; +} + +/////////////////////////////////////////////////////////////////////////////// +///create a MeshEdge and add it to the current Mesh +///@return : The created MeshEdge +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshEdge* SMDS_Mesh::AddEdge(int idnode1, int idnode2) +{ + return AddEdgeWithID(idnode1, idnode2, myElementIDFactory->GetFreeID()); +} + +/////////////////////////////////////////////////////////////////////////////// +///Create a new edge and at it to the mesh +///@param idnode1 ID of the first node +///@param idnode2 ID of the second node +///@param ID ID of the edge to create +///@return The created edge or NULL if an edge with this ID already exists or +///if input nodes are not found. +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID) +{ + SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + if((node1==NULL)||(node2==NULL)) return NULL; + SMDS_MeshEdge * edge=new SMDS_MeshEdge(node1, node2); + if(myElementIDFactory->BindID(ID, edge)) + { + node1->AddInverseElement(edge); + node2->AddInverseElement(edge); + myEdges.insert(edge); + return edge; + } + else + { + delete edge; + return NULL; + } } -//======================================================================= -//function : AddEdge -//purpose : -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +/// Add a triangle defined by its nodes IDs +/////////////////////////////////////////////////////////////////////////////// -Standard_Boolean SMDS_Mesh::AddEdgeWithID(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer ID) +SMDS_MeshFace* SMDS_Mesh::AddFace(int idnode1, int idnode2, int idnode3) { - Handle(SMDS_MeshElement) edge,elem; - Standard_Boolean successAdd = Standard_False; - - // find the MeshNode corresponding to idnode1 - if (AddNode(idnode1)) { - // find the MeshNode corresponding to idnode2 - if (AddNode(idnode2)) { - elem = CreateEdge(ID,idnode1,idnode2); - edge = FindEdge(elem); - if (edge.IsNull()) { - edge = elem; - myEdges.Add(edge); - } - successAdd = myElementIDFactory->BindID(ID,edge); - } - } - - return successAdd; - + return AddFaceWithID(idnode1,idnode2,idnode3, + myElementIDFactory->GetFreeID()); } -//======================================================================= -//function : AddFace -//purpose : -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +/// Add a quandrangle defined by its nodes IDs +/////////////////////////////////////////////////////////////////////////////// -Standard_Integer SMDS_Mesh::AddFace(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3) +SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, int ID) { - Standard_Integer ID = myElementIDFactory->GetFreeID(); - - if (AddFaceWithID(idnode1,idnode2,idnode3,ID)) - return ID; - else - return 0; + SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); -} - -//======================================================================= -//function : AddFace -//purpose : -//======================================================================= + if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL; + SMDS_MeshFace * face=createTriangle(node1,node2,node3); -Standard_Boolean SMDS_Mesh::AddFaceWithID(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer ID) -{ - Handle(SMDS_MeshElement) face,elem; - Standard_Boolean successAdd = Standard_False; - - // find the MeshNode corresponding to idnode1 - if (AddNode(idnode1)) { - // find the MeshNode corresponding to idnode2 - if (AddNode(idnode2)) { - // find the MeshNode corresponding to idnode3 - if (AddNode(idnode3)) { - elem = CreateFace(ID,idnode1,idnode2,idnode3); - face = FindFace(elem); - if (face.IsNull()) { - face = elem; - myFaces.Add(face); + if(myElementIDFactory->BindID(ID, face)) + { + node1->AddInverseElement(face); + node2->AddInverseElement(face); + node3->AddInverseElement(face); + return face; + } + else + { + RemoveFace(face); + return NULL; } - successAdd = myElementIDFactory->BindID(ID,face); - } - } - } - - return successAdd; - } - //======================================================================= //function : AddFace -//purpose : +//purpose : //======================================================================= -Standard_Integer SMDS_Mesh::AddFace(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4) +SMDS_MeshFace* SMDS_Mesh::AddFace(int idnode1, + int idnode2, int idnode3, int idnode4) { - Standard_Integer ID = myElementIDFactory->GetFreeID(); - - if (AddFaceWithID(idnode1,idnode2,idnode3,idnode4,ID)) - return ID; - else - return 0; - + int ID=myElementIDFactory->GetFreeID(); + SMDS_MeshFace* f= AddFaceWithID(idnode1, idnode2, idnode3, idnode4, ID); + if(f==NULL) myElementIDFactory->ReleaseID(ID); } - //======================================================================= //function : AddFace -//purpose : -//======================================================================= - -Standard_Boolean SMDS_Mesh::AddFaceWithID(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4, - const Standard_Integer ID) -{ - Handle(SMDS_MeshElement) face,elem; - Standard_Boolean successAdd = Standard_False; - - // find the MeshNode corresponding to idnode1 - if (AddNode(idnode1)) { - // find the MeshNode corresponding to idnode2 - if (AddNode(idnode2)) { - // find the MeshNode corresponding to idnode3 - if (AddNode(idnode3)) { - // find the MeshNode corresponding to idnode4 - if (AddNode(idnode4)) { - elem = CreateFace(ID,idnode1,idnode2,idnode3,idnode4); - face = FindFace(elem); - if (face.IsNull()) { - face = elem; - myFaces.Add(face); - } - successAdd = myElementIDFactory->BindID(ID,face); +//purpose : +//======================================================================= + +SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, + int idnode2, int idnode3, int idnode4, int ID) +{ + SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); + SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); + + if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)) return NULL; + SMDS_MeshFace * face=createQuadrangle(node1,node2,node3,node4); + + if(myElementIDFactory->BindID(ID, face)) + { + node1->AddInverseElement(face); + node2->AddInverseElement(face); + node3->AddInverseElement(face); + node4->AddInverseElement(face); + return face; + } + else + { + RemoveFace(face); + return NULL; } - } - } - } - - return successAdd; - } - - //======================================================================= //function : AddVolume //purpose : Tetrahedra //======================================================================= -Standard_Integer SMDS_Mesh::AddVolume(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4) +SMDS_MeshVolume * SMDS_Mesh::AddVolume(int idnode1, int idnode2, int idnode3, + int idnode4) { - Standard_Integer ID = myElementIDFactory->GetFreeID(); - - if (AddVolumeWithID(idnode1,idnode2,idnode3,idnode4,ID)) - return ID; - else - return 0; - + int ID = myElementIDFactory->GetFreeID(); + SMDS_MeshVolume * v= + AddVolumeWithID(idnode1, idnode2, idnode3, idnode4, ID); + if(v==NULL) myElementIDFactory->ReleaseID(ID); } -//======================================================================= -//function : AddVolume -//purpose : Tetrahedra -//======================================================================= -Standard_Boolean SMDS_Mesh::AddVolumeWithID(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4, - const Standard_Integer ID) -{ - Handle(SMDS_MeshElement) volume,elem; - Standard_Boolean successAdd = Standard_False; - - // find the MeshNode corresponding to idnode1 - if (AddNode(idnode1)) { - // find the MeshNode corresponding to idnode2 - if (AddNode(idnode2)) { - // find the MeshNode corresponding to idnode3 - if (AddNode(idnode3)) { - // find the MeshNode corresponding to idnode4 - if (AddNode(idnode4)) { - elem = CreateVolume(ID,idnode1,idnode2,idnode3,idnode4); - volume = FindVolume(elem); - if (volume.IsNull()) { - volume = elem; - myVolumes.Add(volume); - } - successAdd = myElementIDFactory->BindID(ID,volume); - } - } - } - } +/////////////////////////////////////////////////////////////////////////////// +///Create a new tetrahedron and add it to the mesh. +///@return The created tetrahedron or NULL if an edge with this ID already exists +///or if input nodes are not found. +/////////////////////////////////////////////////////////////////////////////// - return successAdd; - -} - -//======================================================================= -//function : AddVolume -//purpose : Pyramid -//======================================================================= - -Standard_Integer SMDS_Mesh::AddVolume(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4, - const Standard_Integer idnode5) +SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, + int idnode3, int idnode4, int ID) { - Standard_Integer ID = myElementIDFactory->GetFreeID(); - - if (AddVolumeWithID(idnode1,idnode2,idnode3,idnode4,idnode5,ID)) - return ID; - else - return 0; + SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); + SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); -} - -//======================================================================= -//function : AddVolume -//purpose : Pyramid -//======================================================================= + if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)) return NULL; + + SMDS_MeshVolume* volume; + if(hasConstructionFaces()) + { + SMDS_MeshFace * f1=createTriangle(node1,node2,node3); + SMDS_MeshFace * f2=createTriangle(node1,node2,node4); + SMDS_MeshFace * f3=createTriangle(node1,node3,node4); + SMDS_MeshFace * f4=createTriangle(node2,node3,node4); + SMDS_MeshVolume* volume= + new SMDS_VolumeOfFaces(f1,f2,f3,f4); + myVolumes.insert(volume); + } + else if(hasConstructionEdges()) + { + /** @todo */ + } + else + { + /** @todo */ + } -Standard_Boolean SMDS_Mesh::AddVolumeWithID(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4, - const Standard_Integer idnode5, - const Standard_Integer ID) -{ - Handle(SMDS_MeshElement) volume,elem; - Standard_Boolean successAdd = Standard_False; - - // find the MeshNode corresponding to idnode1 - if (AddNode(idnode1)) { - // find the MeshNode corresponding to idnode2 - if (AddNode(idnode2)) { - // find the MeshNode corresponding to idnode3 - if (AddNode(idnode3)) { - // find the MeshNode corresponding to idnode4 - if (AddNode(idnode4)) { - // find the MeshNode corresponding to idnode5 - if (AddNode(idnode5)) { - elem = CreateVolume(ID,idnode1,idnode2,idnode3,idnode4,idnode5); - volume = FindVolume(elem); - if (volume.IsNull()) { - volume = elem; - myVolumes.Add(volume); - } - successAdd = myElementIDFactory->BindID(ID,volume); - } + if(myElementIDFactory->BindID(ID, volume)) + { + node1->AddInverseElement(volume); + node2->AddInverseElement(volume); + node3->AddInverseElement(volume); + node4->AddInverseElement(volume); + return volume; + } + else + { + RemoveVolume(volume); + return NULL; } - } - } - } +} - return successAdd; +/////////////////////////////////////////////////////////////////////////////// +/// Add a pyramid to the mesh. node 1,2,3 and 4 define the base of the pyramid +/////////////////////////////////////////////////////////////////////////////// +SMDS_MeshVolume * SMDS_Mesh::AddVolume(int idnode1, + int idnode2, int idnode3, int idnode4, int idnode5) +{ + int ID = myElementIDFactory->GetFreeID(); + SMDS_MeshVolume * v= + AddVolumeWithID(idnode1, idnode2, idnode3, idnode4, idnode5, ID); + if(v==NULL) myElementIDFactory->ReleaseID(ID); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Add a pyramid to the mesh. node 1,2,3 and 4 define the base of the pyramid +/////////////////////////////////////////////////////////////////////////////// +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, + int idnode3, int idnode4, int idnode5, int ID) +{ + SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); + SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); + SMDS_MeshNode * node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5); + + if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)||(node5==NULL)) + return NULL; + + SMDS_MeshVolume* volume; + if(hasConstructionFaces()) + { + SMDS_MeshFace * f1=createQuadrangle(node1,node2,node3,node4); + SMDS_MeshFace * f2=createTriangle(node1,node2,node5); + SMDS_MeshFace * f3=createTriangle(node2,node3,node5); + SMDS_MeshFace * f4=createTriangle(node3,node4,node5); + SMDS_MeshFace * f5=createTriangle(node4,node1,node4); + SMDS_MeshVolume* volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5); + myVolumes.insert(volume); + } + else if(hasConstructionEdges()) + { + /** @todo */ + } + else + { + /** @todo */ + } + if(myElementIDFactory->BindID(ID, volume)) + { + node1->AddInverseElement(volume); + node2->AddInverseElement(volume); + node3->AddInverseElement(volume); + node4->AddInverseElement(volume); + node5->AddInverseElement(volume); + return volume; + } + else + { + RemoveVolume(volume); + return NULL; + } } -//======================================================================= -//function : AddVolume -//purpose : Prism -//======================================================================= - -Standard_Integer SMDS_Mesh::AddVolume(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4, - const Standard_Integer idnode5, - const Standard_Integer idnode6) +/////////////////////////////////////////////////////////////////////////////// +/// Add a prism. Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle. +/////////////////////////////////////////////////////////////////////////////// +SMDS_MeshVolume* SMDS_Mesh::AddVolume(int idnode1, int idnode2, int idnode3, + int idnode4, int idnode5, int idnode6) { - Standard_Integer ID = myElementIDFactory->GetFreeID(); - - if (AddVolumeWithID(idnode1,idnode2,idnode3,idnode4, - idnode5,idnode6,ID)) - return ID; - else - return 0; - + int ID = myElementIDFactory->GetFreeID(); + SMDS_MeshVolume * v= + AddVolumeWithID(idnode1, idnode2, idnode3, idnode4, idnode5, idnode6, + ID); + if(v==NULL) myElementIDFactory->ReleaseID(ID); } //======================================================================= @@ -479,69 +356,56 @@ Standard_Integer SMDS_Mesh::AddVolume(const Standard_Integer idnode1, //purpose : Prism //======================================================================= -Standard_Boolean SMDS_Mesh::AddVolumeWithID(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4, - const Standard_Integer idnode5, - const Standard_Integer idnode6, - const Standard_Integer ID) -{ - Handle(SMDS_MeshElement) volume,elem; - Standard_Boolean successAdd = Standard_False; - - // find the MeshNode corresponding to idnode1 - if (AddNode(idnode1)) { - // find the MeshNode corresponding to idnode2 - if (AddNode(idnode2)) { - // find the MeshNode corresponding to idnode3 - if (AddNode(idnode3)) { - // find the MeshNode corresponding to idnode4 - if (AddNode(idnode4)) { - // find the MeshNode corresponding to idnode5 - if (AddNode(idnode5)) { - // find the MeshNode corresponding to idnode6 - if (AddNode(idnode6)) { - elem = CreateVolume(ID,idnode1,idnode2,idnode3,idnode4,idnode5,idnode6); - volume = FindVolume(elem); - if (volume.IsNull()) { - volume = elem; - myVolumes.Add(volume); - } - successAdd = myElementIDFactory->BindID(ID,volume); - } - } +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, int idnode3, + int idnode4, int idnode5, int idnode6, int ID) +{ + SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); + SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); + SMDS_MeshNode * node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5); + SMDS_MeshNode * node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6); + + if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)||(node5==NULL)|| + (node6==NULL)) return NULL; + + SMDS_MeshVolume* volume; + if(hasConstructionFaces()) + + { + SMDS_MeshFace * f1=createTriangle(node1,node2,node3); + SMDS_MeshFace * f2=createTriangle(node4,node5,node6); + SMDS_MeshFace * f3=createQuadrangle(node1,node4,node5,node2); + SMDS_MeshFace * f4=createQuadrangle(node2,node5,node6,node3); + SMDS_MeshFace * f5=createQuadrangle(node3,node6,node4,node1); + + SMDS_MeshVolume* volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5); + myVolumes.insert(volume); + } + else if(hasConstructionEdges()) + { + /** @todo */ + } + else + { + /** @todo */ } - } - } - } - - return successAdd; - -} - -//======================================================================= -//function : AddVolume -//purpose : Hexahedra -//======================================================================= - -Standard_Integer SMDS_Mesh::AddVolume(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4, - const Standard_Integer idnode5, - const Standard_Integer idnode6, - const Standard_Integer idnode7, - const Standard_Integer idnode8) -{ - Standard_Integer ID = myElementIDFactory->GetFreeID(); - - if (AddVolumeWithID(idnode1,idnode2,idnode3,idnode4, - idnode5,idnode6,idnode7,idnode8,ID)) - return ID; - else - return 0; + if(myElementIDFactory->BindID(ID, volume)) + { + node1->AddInverseElement(volume); + node2->AddInverseElement(volume); + node3->AddInverseElement(volume); + node4->AddInverseElement(volume); + node5->AddInverseElement(volume); + node6->AddInverseElement(volume); + return volume; + } + else + { + RemoveVolume(volume); + return NULL; + } } //======================================================================= @@ -549,708 +413,513 @@ Standard_Integer SMDS_Mesh::AddVolume(const Standard_Integer idnode1, //purpose : Hexahedra //======================================================================= -Standard_Boolean SMDS_Mesh::AddVolumeWithID(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4, - const Standard_Integer idnode5, - const Standard_Integer idnode6, - const Standard_Integer idnode7, - const Standard_Integer idnode8, - const Standard_Integer ID) -{ - Handle(SMDS_MeshElement) volume,elem; - Standard_Boolean successAdd = Standard_False; - - // find the MeshNode corresponding to idnode1 - if (AddNode(idnode1)) { - // find the MeshNode corresponding to idnode2 - if (AddNode(idnode2)) { - // find the MeshNode corresponding to idnode3 - if (AddNode(idnode3)) { - // find the MeshNode corresponding to idnode4 - if (AddNode(idnode4)) { - // find the MeshNode corresponding to idnode5 - if (AddNode(idnode5)) { - // find the MeshNode corresponding to idnode6 - if (AddNode(idnode6)) { - // find the MeshNode corresponding to idnode7 - if (AddNode(idnode7)) { - // find the MeshNode corresponding to idnode8 - if (AddNode(idnode8)) { - elem = CreateVolume(ID,idnode1,idnode2,idnode3,idnode4,idnode5, - idnode6,idnode7,idnode8); - volume = FindVolume(elem); - if (volume.IsNull()) { - volume = elem; - myVolumes.Add(volume); - } - successAdd = myElementIDFactory->BindID(ID,volume); - } - } - } - } +SMDS_MeshVolume* SMDS_Mesh::AddVolume(int idnode1, int idnode2, int idnode3, + int idnode4, int idnode5, int idnode6, int idnode7, int idnode8) +{ + int ID = myElementIDFactory->GetFreeID(); + SMDS_MeshVolume * v= + AddVolumeWithID(idnode1, idnode2, idnode3, idnode4, idnode5, idnode6, + idnode7, idnode8, ID); + if(v==NULL) myElementIDFactory->ReleaseID(ID); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Add an hexahedron to the mesh. node 1,2,3,4 and 5,6,7,8 are quadrangle and +/// 5,1 and 7,3 are an edges. +/////////////////////////////////////////////////////////////////////////////// +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, int idnode3, + int idnode4, int idnode5, int idnode6, int idnode7, int idnode8, int ID) +{ + SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); + SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); + SMDS_MeshNode * node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5); + SMDS_MeshNode * node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6); + SMDS_MeshNode * node7 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode7); + SMDS_MeshNode * node8 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode8); + + if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)||(node5==NULL)|| + (node6==NULL)||(node7==NULL)||(node8==NULL)) return NULL; + + SMDS_MeshVolume* volume; + if(hasConstructionFaces()) + { + SMDS_MeshFace * f1=FindFaceOrCreate(node1,node2,node3,node4); + SMDS_MeshFace * f2=FindFaceOrCreate(node5,node6,node7,node8); + SMDS_MeshFace * f3=FindFaceOrCreate(node1,node4,node8,node5); + SMDS_MeshFace * f4=FindFaceOrCreate(node1,node2,node6,node5); + SMDS_MeshFace * f5=FindFaceOrCreate(node2,node3,node7,node6); + SMDS_MeshFace * f6=FindFaceOrCreate(node3,node4,node8,node7); + volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5,f6); + myVolumes.insert(volume); + } + else if(hasConstructionEdges()) + { + MESSAGE("Error : Not Implemented"); + } + else + { + volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4,node5,node6,node7,node8); + myVolumes.insert(volume); } - } - } - } - - return successAdd; - -} - - -//======================================================================= -//function : GetNode -//purpose : returns the MeshNode corresponding to the ID -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::GetNode(const Standard_Integer idnode) const -{ - - Handle(SMDS_MeshElement) node; - - Handle(SMDS_MeshElement) elem = FindNode(idnode); - if (!elem.IsNull()) { // found one correspondance - node = elem; - } else { - if (!myParent.IsNull()) - node = myParent->GetNode(idnode); - } - - return node; -} - -//======================================================================= -//function : FindNode -//purpose : -//======================================================================= -Handle(SMDS_MeshElement) SMDS_Mesh::FindNode(const Standard_Integer ID) const -{ - Handle(SMDS_MeshElement) elem; - if (myNodes.ContainsID(ID)) - elem = myNodes.FindID(ID); - return elem; + if(myElementIDFactory->BindID(ID, volume)) + { + //MESSAGE("SMDS_Mesh::AddVolumeWithID: update inverse elements"); + node1->AddInverseElement(volume); + node2->AddInverseElement(volume); + node3->AddInverseElement(volume); + node4->AddInverseElement(volume); + node5->AddInverseElement(volume); + node6->AddInverseElement(volume); + node7->AddInverseElement(volume); + node8->AddInverseElement(volume); + return volume; + } + else + { + RemoveVolume(volume); + return NULL; + } } //======================================================================= //function : FindNode -//purpose : +//purpose : //======================================================================= -Handle(SMDS_MeshElement) SMDS_Mesh::FindNode(const Handle(SMDS_MeshElement)& node) const +const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const { - Handle(SMDS_MeshElement) elem; - if (myNodes.Contains(node)) - elem = myNodes.Find(node); - - return elem; + return (const SMDS_MeshNode *)myNodeIDFactory->MeshElement(ID); } -//======================================================================= -//function : CreateEdge -//purpose : -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::CreateEdge(const Standard_Integer ID, - const Standard_Integer idnode1, - const Standard_Integer idnode2) const +/////////////////////////////////////////////////////////////////////////////// +///Create a triangle and add it to the current mesh. This methode do not bind a +///ID to the create triangle. +/////////////////////////////////////////////////////////////////////////////// +SMDS_MeshFace * SMDS_Mesh::createTriangle(SMDS_MeshNode * node1, + SMDS_MeshNode * node2, SMDS_MeshNode * node3) { - Handle(SMDS_MeshEdge) edge = new SMDS_MeshEdge(ID,idnode1,idnode2); - return edge; -} - - -//======================================================================= -//function : CreateFace -//purpose : -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::CreateFace(const Standard_Integer ID, - const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3) const -{ - Handle(SMDS_MeshFace) face = new SMDS_MeshTriangle(ID,idnode1,idnode2,idnode3); - return face; -} - - -//======================================================================= -//function : CreateFace -//purpose : -//======================================================================= + if(hasConstructionEdges()) + { + SMDS_MeshEdge *edge1, *edge2, *edge3; + edge1=FindEdgeOrCreate(node1,node2); + edge2=FindEdgeOrCreate(node2,node3); + edge3=FindEdgeOrCreate(node3,node1); -Handle(SMDS_MeshElement) SMDS_Mesh::CreateFace(const Standard_Integer ID, - const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4) const -{ - Handle(SMDS_MeshFace) face = new SMDS_MeshQuadrangle(ID,idnode1,idnode2,idnode3,idnode4); - return face; -} - -//======================================================================= -//function : CreateVolume -//purpose : -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::CreateVolume(const Standard_Integer ID, - const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4) const -{ - Handle(SMDS_MeshVolume) volume = new SMDS_MeshTetrahedron(ID,idnode1,idnode2,idnode3,idnode4); - return volume; -} - -//======================================================================= -//function : CreateVolume -//purpose : -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::CreateVolume(const Standard_Integer ID, - const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4, - const Standard_Integer idnode5) const -{ - Handle(SMDS_MeshVolume) volume = new SMDS_MeshPyramid(ID,idnode1,idnode2,idnode3,idnode4,idnode5); - return volume; -} - -//======================================================================= -//function : CreateVolume -//purpose : -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::CreateVolume(const Standard_Integer ID, - const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4, - const Standard_Integer idnode5, - const Standard_Integer idnode6) const -{ - Handle(SMDS_MeshVolume) volume = new SMDS_MeshPrism(ID,idnode1,idnode2,idnode3,idnode4,idnode5,idnode6); - return volume; -} - -//======================================================================= -//function : CreateVolume -//purpose : -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::CreateVolume(const Standard_Integer ID, - const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4, - const Standard_Integer idnode5, - const Standard_Integer idnode6, - const Standard_Integer idnode7, - const Standard_Integer idnode8) const -{ - Handle(SMDS_MeshVolume) volume = new SMDS_MeshHexahedron(ID,idnode1,idnode2,idnode3,idnode4, - idnode5,idnode6,idnode7,idnode8); - return volume; -} - -//======================================================================= -//function : Contains -//purpose : -//======================================================================= - -Standard_Boolean SMDS_Mesh::Contains(const Handle(SMDS_MeshElement)& elem) const -{ - Standard_Boolean isinmesh = Standard_False; - if (myNodes.Contains(elem)) - isinmesh = Standard_True; - else if (myEdges.Contains(elem)) - isinmesh = Standard_True; - else if (myFaces.Contains(elem)) - isinmesh = Standard_True; - else if (myVolumes.Contains(elem)) - isinmesh = Standard_True; - - return isinmesh; -} - -//======================================================================= -//function : FindEdge -//purpose : -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::FindEdge(const Handle(SMDS_MeshElement)& edge) const -{ - Handle(SMDS_MeshElement) elem; - if (myEdges.Contains(edge)) - elem = myEdges.Find(edge); - - return elem; -} - -//======================================================================= -//function : FindFace -//purpose : -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::FindFace(const Handle(SMDS_MeshElement)& face) const -{ - Handle(SMDS_MeshElement) elem; - if (myFaces.Contains(face)) - elem = myFaces.Find(face); - - return elem; -} - - -//======================================================================= -//function : FindVolume -//purpose : -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::FindVolume(const Handle(SMDS_MeshElement)& volume) const -{ - Handle(SMDS_MeshElement) elem; - if (myVolumes.Contains(volume)) - elem = myVolumes.Find(volume); - - return elem; + SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3); + myFaces.insert(face); + return face; + } + else + { + SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3); + myFaces.insert(face); + return face; + } } - -//======================================================================= -//function : FreeNode -//purpose : -//======================================================================= - -void SMDS_Mesh::FreeNode(const Handle(SMDS_MeshElement)& node) -{ - myNodes.Remove(node); - - SMDS_ListIteratorOfListOfMesh itmsh(myChildren); - for (;itmsh.More(); itmsh.Next()) { - const Handle(SMDS_Mesh)& submesh = itmsh.Value(); - submesh->RemoveNode(node->GetID()); - } +/////////////////////////////////////////////////////////////////////////////// +///Create a quadrangle and add it to the current mesh. This methode do not bind +///a ID to the create triangle. +/////////////////////////////////////////////////////////////////////////////// +SMDS_MeshFace * SMDS_Mesh::createQuadrangle(SMDS_MeshNode * node1, + SMDS_MeshNode * node2, SMDS_MeshNode * node3, SMDS_MeshNode * node4) +{ + if(hasConstructionEdges()) + { + SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4; + edge1=FindEdgeOrCreate(node1,node2); + edge2=FindEdgeOrCreate(node2,node3); + edge3=FindEdgeOrCreate(node3,node4); + edge4=FindEdgeOrCreate(node4,node1); + + SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3,edge4); + myFaces.insert(face); + return face; + } + else + { + SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3,node4); + myFaces.insert(face); + return face; + } } - - //======================================================================= //function : RemoveNode -//purpose : +//purpose : //======================================================================= -void SMDS_Mesh::RemoveNode(const Standard_Integer IDnode) +void SMDS_Mesh::RemoveNode(int IDnode) { - // find the MeshNode corresponding to IDnode - Handle(SMDS_MeshElement) node = FindNode(IDnode); - if (RemoveNode(node)) { - if (myParent.IsNull()) { // if no parent we can release the ID - myNodeIDFactory->ReleaseID(IDnode); - } - } - + RemoveNode(FindNode(IDnode)); } //======================================================================= //function : RemoveNode -//purpose : +//purpose : //======================================================================= -Standard_Boolean SMDS_Mesh::RemoveNode(const Handle(SMDS_MeshElement)& node) +bool SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node) { - Standard_Boolean successRemove = Standard_False; - - if (!node.IsNull()) { - if (myHasInverse && myNodes.Contains(node)) { - SMDS_MapOfMeshOrientedElement map(1); - BuildMapNodeAncestors(node,map); - RemoveAncestors(node,map); - } - - FreeNode(node); - successRemove = Standard_True; - } - - return successRemove; + SMDS_Iterator * it= + node->GetInverseElementIterator(); + while(it->more()) RemoveElement(it->next(),true); + myNodeIDFactory->ReleaseID(node->GetID()); + myNodes.erase(const_cast(node)); } //======================================================================= //function : RemoveEdge -//purpose : +//purpose : //======================================================================= -void SMDS_Mesh::RemoveEdge(const Standard_Integer idnode1, const Standard_Integer idnode2) +void SMDS_Mesh::RemoveEdge(int idnode1, int idnode2) { - Handle(SMDS_MeshElement) edge = FindEdge(idnode1,idnode2); - RemoveEdge(edge); + RemoveEdge(FindEdge(idnode1, idnode2)); } //======================================================================= //function : RemoveEdge -//purpose : +//purpose : //======================================================================= -void SMDS_Mesh::RemoveEdge(const Handle(SMDS_MeshElement)& edge) +void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge) { - - if (!edge.IsNull()) { - myEdges.Remove(edge); - - myElementIDFactory->ReleaseID(edge->GetID()); - } + /** @todo to be fix */ + myEdges.erase(const_cast(edge)); + //removeElementDependencies(edge); + delete edge; } - //======================================================================= //function : RemoveFace -//purpose : +//purpose : //======================================================================= -void SMDS_Mesh::RemoveFace(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3) +void SMDS_Mesh::RemoveFace(int idnode1, int idnode2, int idnode3) { - Handle(SMDS_MeshElement) face = FindFace(idnode1,idnode2,idnode3); - RemoveFace(face); + RemoveFace(FindFace(idnode1, idnode2, idnode3)); } //======================================================================= //function : RemoveFace -//purpose : +//purpose : //======================================================================= -void SMDS_Mesh::RemoveFace(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4) +void SMDS_Mesh::RemoveFace(int idnode1, int idnode2, int idnode3, int idnode4) { - Handle(SMDS_MeshElement) face = FindFace(idnode1,idnode2,idnode3,idnode4); - RemoveFace(face); + RemoveFace(FindFace(idnode1, idnode2, idnode3, idnode4)); } - //======================================================================= //function : RemoveFace -//purpose : +//purpose : //======================================================================= -void SMDS_Mesh::RemoveFace(const Handle(SMDS_MeshElement)& face) +void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face) { - if (!face.IsNull()) { - myFaces.Remove(face); - myElementIDFactory->ReleaseID(face->GetID()); - } + /** @todo to be fix */ + myFaces.erase(const_cast(face)); + //removeElementDependencies(face); + delete face; } //======================================================================= //function : RemoveVolume -//purpose : -//======================================================================= - -void SMDS_Mesh::RemoveVolume(const Handle(SMDS_MeshElement)& volume) -{ - if (myVolumes.Contains(volume)) { - myVolumes.Remove(volume); - myElementIDFactory->ReleaseID(volume->GetID()); - } +//purpose : +//======================================================================= + +void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume) +{ + /** @todo to be fix */ + myVolumes.erase(const_cast(volume)); + //removeElementDependencies(volume); + delete volume; +} +/////////////////////////////////////////////////////////////////////////////// +/// Remove no longer used sub element of an element. Unbind the element ID +/////////////////////////////////////////////////////////////////////////////// +void SMDS_Mesh::removeElementDependencies(SMDS_MeshElement * element) +{ + /** @todo to be fix */ + myElementIDFactory->ReleaseID(element->GetID()); + SMDS_Iterator * it=element->nodesIterator(); + while(it->more()) + { + SMDS_MeshNode * node=static_cast( + const_cast(it->next())); + node->RemoveInverseElement(element); + if(node->emptyInverseElements()) RemoveNode(node); + } } - //======================================================================= //function : RemoveElement -//purpose : +//purpose : //======================================================================= -void SMDS_Mesh::RemoveElement(const Standard_Integer IDelem,const Standard_Boolean removenodes) +void SMDS_Mesh::RemoveElement(int IDelem, const bool removenodes) { - Handle(SMDS_MeshElement) elem = myElementIDFactory->MeshElement(IDelem); - RemoveElement(elem,removenodes); - - - + RemoveElement(myElementIDFactory->MeshElement(IDelem), removenodes); } //======================================================================= //function : RemoveElement -//purpose : -//======================================================================= +//purpose : +//======================================================================= + +void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, + const bool removenodes) +{ + /** @todo to be fix */ + switch(elem->GetType()) + { + case SMDSAbs_Node: + RemoveNode((const SMDS_MeshNode*)elem); + return; + case SMDSAbs_Edge: + RemoveEdge((const SMDS_MeshEdge*)elem); + break; + case SMDSAbs_Face: + RemoveFace((const SMDS_MeshFace*)elem); + break; + case SMDSAbs_Volume: + RemoveVolume((const SMDS_MeshVolume*)elem); + break; + default : + MESSAGE("remove function : unknown type"); + return; + } +/* + SMDS_Iterator * it=elem->nodesIterator(); + while(it->more()) + { + const SMDS_MeshNode * node=it->next(); + + }*/ +} -void SMDS_Mesh::RemoveElement(const Handle(SMDS_MeshElement)& elem,const Standard_Boolean removenodes) -{ - if ( elem->IsKind(STANDARD_TYPE(SMDS_MeshEdge)) ) { - RemoveEdge(elem); - } else if ( elem->IsKind(STANDARD_TYPE(SMDS_MeshNode))) { - RemoveNode(elem); - return; - } else if ( elem->IsKind(STANDARD_TYPE(SMDS_MeshFace))) { - RemoveFace(elem); - } else if ( elem->IsKind(STANDARD_TYPE(SMDS_MeshVolume))) { - RemoveVolume(elem); - } else { - MESSAGE( "remove function : unknown type" ); - return; - } - - Standard_Integer nbcnx = elem->NbNodes(); - Standard_Integer i; - for (i=1; i <= nbcnx; ++i) { - RemoveInverseElement(GetNode(i,elem),elem); - - } - - if (removenodes) { - for (i=1; i <= nbcnx; ++i) { - if (GetNode(i,elem)->InverseElements().IsEmpty()) - FreeNode(GetNode(i,elem)); - } - } - -} - //======================================================================= //function : RemoveFromParent -//purpose : +//purpose : //======================================================================= -Standard_Boolean SMDS_Mesh::RemoveFromParent() +bool SMDS_Mesh::RemoveFromParent() { - if (myParent.IsNull()) - return Standard_False; - - return (myParent->RemoveSubMesh(this)); - + if (myParent==NULL) return false; + else return (myParent->RemoveSubMesh(this)); } //======================================================================= //function : RemoveSubMesh -//purpose : +//purpose : //======================================================================= -Standard_Boolean SMDS_Mesh::RemoveSubMesh(const Handle(SMDS_Mesh)& aMesh) +bool SMDS_Mesh::RemoveSubMesh(const SMDS_Mesh * aMesh) { - Standard_Boolean found = Standard_False; - - SMDS_ListIteratorOfListOfMesh itmsh(myChildren); - for (;itmsh.More() && !found; itmsh.Next()) { - Handle(SMDS_Mesh) submesh; - submesh = itmsh.Value(); - if (submesh == aMesh) { - found = Standard_True; - myChildren.Remove(itmsh); - } - } + bool found = false; - return found; -} - -//======================================================================= -//function : RemoveInverseElement -//purpose : -//======================================================================= - -void SMDS_Mesh::RemoveInverseElement(const Handle(SMDS_MeshElement)& elem, - const Handle(SMDS_MeshElement)& parent) const -{ - if (!myHasInverse) - return; - - Handle(SMDS_MeshNode)& node = *((Handle(SMDS_MeshNode)*)&elem); - node->RemoveInverseElement(parent); -} - -//======================================================================= -//function : RemoveAncestors -//purpose : -//======================================================================= - -void SMDS_Mesh::RemoveAncestors(const Handle(SMDS_MeshElement)& elem, - const SMDS_MapOfMeshOrientedElement& map) -{ - - if (!myHasInverse) - return; - - SMDS_MapIteratorOfExtendedOrientedMap itAnc(map); - - for (;itAnc.More();itAnc.Next()) { - const Handle(SMDS_MeshElement)& ME = itAnc.Key(); - Standard_Integer nbcnx = ME->NbNodes(); - - for (Standard_Integer i=1; i <= nbcnx; ++i) { - RemoveInverseElement(GetNode(i,ME),ME); - } - } - - SMDS_MapIteratorOfExtendedOrientedMap itAnc2(map); - - for (;itAnc2.More();itAnc2.Next()) { - const Handle(SMDS_MeshElement)& ME = itAnc2.Key(); - RemoveElement(ME); - } -} - -//======================================================================= -//function : BuildMapNodeAncestors -//purpose : -//======================================================================= - -void SMDS_Mesh::BuildMapNodeAncestors(const Handle(SMDS_MeshElement)& ME, - SMDS_MapOfMeshOrientedElement& map) const -{ - - if (!myHasInverse) - return; - - Standard_Integer nbcnx = ME->NbNodes(); - - for (Standard_Integer i=1; i <= nbcnx; ++i) { - const SMDS_ListOfMeshElement& lstInvElements = GetNode(i,ME)->InverseElements(); - - SMDS_ListIteratorOfListOfMeshElement it(lstInvElements); - for (;it.More();it.Next()) { - const Handle(SMDS_MeshElement)& meParent = it.Value(); - if (Contains(meParent)) - map.Add(meParent); - } - - } - -} - - -//======================================================================= -//function : BuildMapEdgeAncestors -//purpose : -//======================================================================= - -void SMDS_Mesh::BuildMapEdgeAncestors(const Handle(SMDS_MeshElement)& ME, - SMDS_MapOfMeshOrientedElement& map) const -{ - - if (!myHasInverse) - return; - - Standard_Integer nbcnx = ME->NbNodes(); - - for (Standard_Integer i=1; i <= nbcnx; ++i) { - const SMDS_ListOfMeshElement& lstInvElements = GetNode(i,ME)->InverseElements(); - - SMDS_ListIteratorOfListOfMeshElement it(lstInvElements); - for (;it.More();it.Next()) { - const Handle(SMDS_MeshElement)& meParent = it.Value(); - if ( !meParent->IsKind(STANDARD_TYPE(SMDS_MeshEdge)) && Contains(meParent)) - map.Add(meParent); - } - - } + list::iterator itmsh=myChildren.begin(); + for (; itmsh!=myChildren.end() && !found; itmsh++) + { + SMDS_Mesh * submesh = *itmsh; + if (submesh == aMesh) + { + found = true; + myChildren.erase(itmsh); + } + } + return found; } //======================================================================= -//function : BuildMapFaceAncestors -//purpose : -//======================================================================= - -void SMDS_Mesh::BuildMapFaceAncestors(const Handle(SMDS_MeshElement)& ME, - SMDS_MapOfMeshOrientedElement& map) const -{ - - if (!myHasInverse) - return; - - Standard_Integer nbcnx = ME->NbNodes(); - - for (Standard_Integer i=1; i <= nbcnx; ++i) { - const SMDS_ListOfMeshElement& lstInvElements = GetNode(i,ME)->InverseElements(); - - SMDS_ListIteratorOfListOfMeshElement it(lstInvElements); - for (;it.More();it.Next()) { - const Handle(SMDS_MeshElement)& meParent = it.Value(); - if ( !meParent->IsKind(STANDARD_TYPE(SMDS_MeshEdge)) - && ( !meParent->IsKind(STANDARD_TYPE(SMDS_MeshFace))) && Contains(meParent) ) - map.Add(meParent); - } - - } - +//function : FindEdge +//purpose : +//======================================================================= + +const SMDS_MeshEdge* SMDS_Mesh::FindEdge(int idnode1, int idnode2) const +{ + const SMDS_MeshNode * node1=FindNode(idnode1); + const SMDS_MeshNode * node2=FindNode(idnode2); + if((node1==NULL)||(node2==NULL)) return NULL; + return FindEdge(node1,node2); +} + +/////////////////////////////////////////////////////////////////////////////// +/// +/////////////////////////////////////////////////////////////////////////////// +//#include "Profiler.h" +const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1, + const SMDS_MeshNode * node2) const +{ + const SMDS_MeshEdge * toReturn=NULL; + //PROFILER_Init(); + //PROFILER_Set(); + SMDS_Iterator* it1=node1->edgesIterator(); + //PROFILER_Get(0); + //PROFILER_Set(); + while(it1->more()) + { + const SMDS_MeshEdge * e=static_cast + (it1->next()); + SMDS_Iterator* it2=e->nodesIterator(); + while(it2->more()) + { + if(it2->next()->GetID()==node2->GetID()) + { + toReturn=e; + break; + } + } + delete it2; + } + //PROFILER_Get(1); + delete it1; + return toReturn; } -//======================================================================= -//function : FindEdge -//purpose : -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::FindEdge(const Standard_Integer idnode1, - const Standard_Integer idnode2 ) const +SMDS_MeshEdge* SMDS_Mesh::FindEdgeOrCreate(const SMDS_MeshNode * node1, + const SMDS_MeshNode * node2) { - Handle(SMDS_MeshEdge) edge = new SMDS_MeshEdge(0,idnode1,idnode2); - return FindEdge(edge); + SMDS_MeshEdge * toReturn=NULL; + toReturn=const_cast(FindEdge(node1,node2)); + if(toReturn==NULL) + { + toReturn=new SMDS_MeshEdge(const_cast(node1), + const_cast(node2)); + myEdges.insert(toReturn); + } + return toReturn; } //======================================================================= //function : FindFace -//purpose : -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::FindFace(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3 ) const -{ - Handle(SMDS_MeshFace) face = new SMDS_MeshTriangle(0,idnode1,idnode2,idnode3); - return FindFace(face); +//purpose : +//======================================================================= + +const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2, + int idnode3) const +{ + const SMDS_MeshNode * node1=FindNode(idnode1); + const SMDS_MeshNode * node2=FindNode(idnode2); + const SMDS_MeshNode * node3=FindNode(idnode3); + const SMDS_MeshFace * face; + const SMDS_MeshElement * node; + bool node2found, node3found; + if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL; + + SMDS_Iterator* it1=node1->facesIterator(); + while(it1->more()) + { + face=static_cast(it1->next()); + if(face->NbNodes()!=3) continue; + SMDS_Iterator* it2=face->nodesIterator(); + node2found=false; + node3found=false; + while(it2->more()) + { + node=it2->next(); + if(node->GetID()==idnode2) node2found=true; + if(node->GetID()==idnode3) node3found=true; + } + delete it2; + if(node2found&&node3found) + { + delete it1; + return face; + } + } + delete it1; + return NULL; } //======================================================================= //function : FindFace -//purpose : -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::FindFace(const Standard_Integer idnode1, - const Standard_Integer idnode2, - const Standard_Integer idnode3, - const Standard_Integer idnode4 ) const -{ - Handle(SMDS_MeshFace) face = new SMDS_MeshQuadrangle(0,idnode1,idnode2,idnode3,idnode4); - return FindFace(face); +//purpose : +//======================================================================= + +const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2, int idnode3, + int idnode4) const +{ + const SMDS_MeshNode * node1=FindNode(idnode1); + const SMDS_MeshNode * node2=FindNode(idnode2); + const SMDS_MeshNode * node3=FindNode(idnode3); + const SMDS_MeshNode * node4=FindNode(idnode4); + if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)) return NULL; + return FindFace(node1, node2, node3, node4); +} + +const SMDS_MeshFace* SMDS_Mesh::FindFace( + const SMDS_MeshNode *node1, + const SMDS_MeshNode *node2, + const SMDS_MeshNode *node3, + const SMDS_MeshNode *node4) const +{ + const SMDS_MeshFace * face; + const SMDS_MeshElement * node; + bool node2found, node3found, node4found; + SMDS_Iterator* it1=node1->facesIterator(); + while(it1->more()) + { + face=static_cast(it1->next()); + if(face->NbNodes()!=4) continue; + SMDS_Iterator* it2=face->nodesIterator(); + node2found=false; + node3found=false; + node4found=false; + while(it2->more()) + { + node=it2->next(); + if(node->GetID()==node2->GetID()) node2found=true; + if(node->GetID()==node3->GetID()) node3found=true; + if(node->GetID()==node4->GetID()) node4found=true; + } + delete it2; + if(node2found&&node3found&&node4found) + { + delete it1; + return face; + } + } + delete it1; + return NULL; } -//======================================================================= -//function : FindElement -//purpose : -//======================================================================= - -Handle(SMDS_MeshElement) SMDS_Mesh::FindElement(const Standard_Integer IDelem) const +SMDS_MeshFace* SMDS_Mesh::FindFaceOrCreate( + const SMDS_MeshNode *node1, + const SMDS_MeshNode *node2, + const SMDS_MeshNode *node3, + const SMDS_MeshNode *node4) { - return myElementIDFactory->MeshElement(IDelem); + SMDS_MeshFace * toReturn=NULL; + toReturn=const_cast(FindFace(node1,node2,node3,node4)); + if(toReturn==NULL) + { + toReturn=createQuadrangle( + const_cast(node1), + const_cast(node2), + const_cast(node3), + const_cast(node4) + ); + } + return toReturn; } //======================================================================= -//function : GetNode -//purpose : +//function : FindElement +//purpose : //======================================================================= -Handle(SMDS_MeshNode) SMDS_Mesh::GetNode(const Standard_Integer rank, - const Handle(SMDS_MeshElement)& ME) const - +const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const { - const Standard_Integer idnode = ME->GetConnection(rank); // take care, no control of bounds - - Handle(SMDS_MeshElement) elem = FindNode(idnode); - Handle(SMDS_MeshNode)& node = *((Handle(SMDS_MeshNode)*)&elem); - return node; - + return myElementIDFactory->MeshElement(IDelem); } - //======================================================================= //function : DumpNodes //purpose : @@ -1258,20 +927,12 @@ Handle(SMDS_MeshNode) SMDS_Mesh::GetNode(const Standard_Integer rank, void SMDS_Mesh::DumpNodes() const { - MESSAGE( "dump nodes of mesh : " ); - - SMDS_MapIteratorOfExtendedOrientedMap itnode(myNodes); - - for (;itnode.More();itnode.Next()) { - const Handle(SMDS_MeshElement)& node = itnode.Key(); - MESSAGE( node); - - } - + MESSAGE("dump nodes of mesh : "); + SMDS_Iterator * itnode=nodesIterator(); + while(itnode->more()) MESSAGE(itnode->next()); + delete itnode; } - - //======================================================================= //function : DumpEdges //purpose : @@ -1279,18 +940,12 @@ void SMDS_Mesh::DumpNodes() const void SMDS_Mesh::DumpEdges() const { - MESSAGE( "dump edges of mesh : " ); - - SMDS_MapIteratorOfExtendedOrientedMap itedge(myEdges); - - for (;itedge.More();itedge.Next()) { - const Handle(SMDS_MeshElement)& edge = itedge.Key(); - MESSAGE( edge); - } + MESSAGE("dump edges of mesh : "); + SMDS_Iterator * itedge=edgesIterator(); + while(itedge->more()) MESSAGE(itedge->next()); + delete itedge; } - - //======================================================================= //function : DumpFaces //purpose : @@ -1298,17 +953,12 @@ void SMDS_Mesh::DumpEdges() const void SMDS_Mesh::DumpFaces() const { - MESSAGE( "dump faces of mesh : " ); - - SMDS_MapIteratorOfExtendedOrientedMap itface(myFaces); - - for (;itface.More();itface.Next()) { - const Handle(SMDS_MeshElement)& face = itface.Key(); - MESSAGE( face); - } + MESSAGE("dump faces of mesh : "); + SMDS_Iterator * itface=facesIterator(); + while(itface->more()) MESSAGE(itface->next()); + delete itface; } - //======================================================================= //function : DumpVolumes //purpose : @@ -1316,18 +966,12 @@ void SMDS_Mesh::DumpFaces() const void SMDS_Mesh::DumpVolumes() const { - MESSAGE( "dump volumes of mesh : " ); - - SMDS_MapIteratorOfExtendedOrientedMap itvol(myVolumes); - - for (;itvol.More();itvol.Next()) { - const Handle(SMDS_MeshElement)& volume = itvol.Key(); - MESSAGE( volume); - } + MESSAGE("dump volumes of mesh : "); + SMDS_Iterator * itvol=volumesIterator(); + while(itvol->more()) MESSAGE(itvol->next()); + delete itvol; } - - //======================================================================= //function : DebugStats //purpose : @@ -1335,159 +979,288 @@ void SMDS_Mesh::DumpVolumes() const void SMDS_Mesh::DebugStats() const { - //VRV: T2.4 impossible to use Logger server - MESSAGE( "Debug stats of mesh : " ); - - MESSAGE( "===== NODES =====" ); - myNodes.Statistics(cout); - - MESSAGE( "===== EDGES =====" ); - myEdges.Statistics(cout); - - MESSAGE( "===== FACES =====" ); - myFaces.Statistics(cout); - - MESSAGE( "===== VOLUMES =====" ); - myVolumes.Statistics(cout); - //VRV: T2.4 impossible to use Logger server - - MESSAGE( "End Debug stats of mesh " ); + MESSAGE("Debug stats of mesh : "); + + MESSAGE("===== NODES ====="< * itnode=nodesIterator(); + int sizeofnodes = 0; + int sizeoffaces = 0; + + while(itnode->more()) + { + const SMDS_MeshNode *node = itnode->next(); + + sizeofnodes += sizeof(*node); + + SMDS_Iterator * it= + node->GetInverseElementIterator(); + while(it->more()) + { + const SMDS_MeshElement *me = it->next(); + sizeofnodes += sizeof(me); + } + delete it; - //#ifdef DEB - SMDS_MapIteratorOfExtendedOrientedMap itnode(myNodes); - Standard_Integer sizeofnodes = 0; - Standard_Integer sizeoffaces = 0; + } + delete itnode; + SMDS_Iterator* itface=facesIterator(); + + while(itface->more()) + { + const SMDS_MeshElement *face = itface->next(); + sizeoffaces += sizeof(*face); + } + MESSAGE("total size of node elements = " << sizeofnodes);; + MESSAGE("total size of face elements = " << sizeoffaces);; - for (;itnode.More();itnode.Next()) { - const Handle(SMDS_MeshElement)& node = itnode.Key(); - - Standard_Transient *p = node->This(); - sizeofnodes += sizeof( *((SMDS_MeshNode *)p) ); + //#endif - SMDS_ListIteratorOfListOfMeshElement it(node->InverseElements()); - for (;it.More();it.Next()) { - const Handle(SMDS_MeshElement)& me = it.Value(); - sizeofnodes += sizeof(me); - } - - } +} - SMDS_MapIteratorOfExtendedOrientedMap itface(myFaces); +int SMDS_Mesh::NbNodes() const +{ + myNodes.size(); +} - for (;itface.More();itface.Next()) { - const Handle(SMDS_MeshElement)& face = itface.Key(); - - Standard_Transient *p = face->This(); - sizeoffaces += sizeof( *((SMDS_MeshFace *)p) ); - - } - MESSAGE( "total size of node elements = " << sizeofnodes );; - MESSAGE( "total size of face elements = " << sizeoffaces );; +int SMDS_Mesh::NbEdges() const +{ + return myEdges.size(); +} - //#endif +int SMDS_Mesh::NbFaces() const +{ + return myFaces.size(); +} +int SMDS_Mesh::NbVolumes() const +{ + return myVolumes.size(); } -//======================================================================= -//function : RebuildAllInverseConnections -//purpose : -//======================================================================= +int SMDS_Mesh::NbSubMesh() const +{ + return myChildren.size(); +} -void SMDS_Mesh::RebuildAllInverseConnections() +SMDS_Mesh::~SMDS_Mesh() { - if (!myParent.IsNull()) - myParent->RebuildAllInverseConnections(); + if(myParent==NULL) + { + delete myNodeIDFactory; + delete myElementIDFactory; + } - else { - // Clear all inverseconnections from nodes - SMDS_MapIteratorOfExtendedOrientedMap itnode(myNodes); - - for (;itnode.More();itnode.Next()) { - const Handle(SMDS_MeshElement)& elem = itnode.Key(); - elem->ClearInverseElements(); - } - + list::iterator itc=myChildren.begin(); + while(itc!=myChildren.end()) + { + delete *itc; + itc++; + } + + SMDS_Iterator * itn=nodesIterator(); + while(itn->more()) + { + delete itn->next(); + } + delete itn; + + set::iterator ite=myEdges.begin(); + while(ite!=myEdges.end()) + { + delete *ite; + ite++; + } - RebuildInverseConnections(); + set::iterator itf=myFaces.begin(); + while(itf!=myFaces.end()) + { + delete *itf; + itf++; + } - SMDS_ListIteratorOfListOfMesh itmsh(myChildren); - for (;itmsh.More(); itmsh.Next()) { - Handle(SMDS_Mesh) submesh; - submesh = itmsh.Value(); - - submesh->RebuildInverseConnections(); + set::iterator itv=myVolumes.begin(); + while(itv!=myVolumes.end()) + { + delete *itv; + itv++; + } - } - } } -//======================================================================= -//function : RebuildInverseConnections -//purpose : -//======================================================================= +bool SMDS_Mesh::hasConstructionEdges() +{ + return myHasConstructionEdges; +} -void SMDS_Mesh::RebuildInverseConnections() +bool SMDS_Mesh::hasConstructionFaces() { - // rebuld inverse connections to volumes - SMDS_MapIteratorOfExtendedOrientedMap itvol(myVolumes); + return myHasConstructionFaces; +} - for (;itvol.More();itvol.Next()) { - const Handle(SMDS_MeshElement)& vol = itvol.Key(); +bool SMDS_Mesh::hasInverseElements() +{ + return myHasInverseElements; +} - Standard_Integer nbcnx = vol->NbNodes(); - for (Standard_Integer inode=1; inode<=nbcnx; ++inode) { - Standard_Integer idnode = vol->GetConnection(inode); - Handle(SMDS_MeshElement) node = FindNode(idnode); - if (!node.IsNull()) - node->AddInverseElement(vol); - } - - } +void SMDS_Mesh::setConstructionEdges(bool b) +{ + myHasConstructionEdges=b; +} - // rebuld inverse connections to faces - SMDS_MapIteratorOfExtendedOrientedMap itface(myFaces); +void SMDS_Mesh::setConstructionFaces(bool b) +{ + myHasConstructionFaces=b; +} - for (;itface.More();itface.Next()) { - const Handle(SMDS_MeshElement)& face = itface.Key(); +void SMDS_Mesh::setInverseElements(bool b) +{ + if(!b) MESSAGE("Error : inverseElement=false not implemented"); + myHasInverseElements=b; +} - Standard_Integer nbcnx = face->NbNodes(); - for (Standard_Integer inode=1; inode<=nbcnx; ++inode) { - Standard_Integer idnode = face->GetConnection(inode); - Handle(SMDS_MeshElement) node = FindNode(idnode); - if (!node.IsNull()) - node->AddInverseElement(face); - } - - } +/////////////////////////////////////////////////////////////////////////////// +///Return an iterator on nodes of the current mesh. Once used this iterator +///must be free by the caller +/////////////////////////////////////////////////////////////////////////////// +SMDS_Iterator * SMDS_Mesh::nodesIterator() const +{ + class MyIterator:public SMDS_Iterator + { + const SetOfNodes& mySet; + SetOfNodes::iterator myIterator; + public: + MyIterator(const SetOfNodes& s):mySet(s) + { + myIterator=mySet.begin(); + } - // rebuld inverse connections to edges - SMDS_MapIteratorOfExtendedOrientedMap itedge(myEdges); + bool more() + { + myIterator!=mySet.end(); + } - for (;itedge.More();itedge.Next()) { - const Handle(SMDS_MeshElement)& edge = itedge.Key(); + const SMDS_MeshNode* next() + { + const SMDS_MeshNode* current=*myIterator; + myIterator++; + return current; + } + }; + return new MyIterator(myNodes); +} + +/////////////////////////////////////////////////////////////////////////////// +///Return an iterator on volumes of the current mesh. Once used this iterator +///must be free by the caller +/////////////////////////////////////////////////////////////////////////////// +SMDS_Iterator * SMDS_Mesh::edgesIterator() const +{ + class MyIterator:public SMDS_Iterator + { + const SetOfEdges& mySet; + const SMDS_MeshEdge * myEdge; + SetOfEdges::iterator myIterator; + public: + MyIterator(const SetOfEdges& s):mySet(s) + { + myIterator=mySet.begin(); + } - Standard_Integer nbcnx = edge->NbNodes(); - for (Standard_Integer inode=1; inode<=nbcnx; ++inode) { - Standard_Integer idnode = edge->GetConnection(inode); - Handle(SMDS_MeshElement) node = FindNode(idnode); - if (!node.IsNull()) - node->AddInverseElement(edge); - } - - } + bool more() + { + while((myIterator!=mySet.end())) + { + if((*myIterator)->GetID()!=-1) + return true; + myIterator++; + } + return false; + } - myHasInverse = Standard_True; -} + const SMDS_MeshEdge* next() + { + const SMDS_MeshEdge* current=*myIterator; + myIterator++; + return current; + } + }; + return new MyIterator(myEdges); +} + +/////////////////////////////////////////////////////////////////////////////// +///Return an iterator on faces of the current mesh. Once used this iterator +///must be free by the caller +/////////////////////////////////////////////////////////////////////////////// +SMDS_Iterator * SMDS_Mesh::facesIterator() const +{ + class MyIterator:public SMDS_Iterator + { + const SetOfFaces& mySet; + set::iterator myIterator; + public: + MyIterator(const SetOfFaces& s):mySet(s) + { + myIterator=mySet.begin(); + } + bool more() + { + while((myIterator!=mySet.end())) + { + if((*myIterator)->GetID()!=-1) + return true; + myIterator++; + } + return false; + } -//======================================================================= -//function : SubMeshIterator -//purpose : returns the ith SubMesh -//======================================================================= + const SMDS_MeshFace* next() + { + const SMDS_MeshFace* current=*myIterator; + myIterator++; + return current; + } + }; + return new MyIterator(myFaces); +} + +/////////////////////////////////////////////////////////////////////////////// +///Return an iterator on volumes of the current mesh. Once used this iterator +///must be free by the caller +/////////////////////////////////////////////////////////////////////////////// +SMDS_Iterator * SMDS_Mesh::volumesIterator() const +{ + class MyIterator:public SMDS_Iterator + { + const SetOfVolumes& mySet; + SetOfVolumes::iterator myIterator; + public: + MyIterator(const SetOfVolumes& s):mySet(s) + { + myIterator=mySet.begin(); + } -void SMDS_Mesh::SubMeshIterator(SMDS_ListIteratorOfListOfMesh& itmsh) const -{ - itmsh.Initialize(myChildren); + bool more() + { + myIterator!=mySet.end(); + } + + const SMDS_MeshVolume* next() + { + const SMDS_MeshVolume* current=*myIterator; + myIterator++; + return current; + } + }; + return new MyIterator(myVolumes); } diff --git a/src/SMDS/SMDS_Mesh.hxx b/src/SMDS/SMDS_Mesh.hxx index d847620fc..946d9b0e4 100644 --- a/src/SMDS/SMDS_Mesh.hxx +++ b/src/SMDS/SMDS_Mesh.hxx @@ -27,209 +27,145 @@ #ifndef _SMDS_Mesh_HeaderFile #define _SMDS_Mesh_HeaderFile -#ifndef _Standard_HeaderFile -#include -#endif -#ifndef _Handle_SMDS_Mesh_HeaderFile -#include "Handle_SMDS_Mesh.hxx" -#endif - -#ifndef _SMDS_MapOfMeshOrientedElement_HeaderFile -#include "SMDS_MapOfMeshOrientedElement.hxx" -#endif -#ifndef _Handle_SMDS_Mesh_HeaderFile -#include "Handle_SMDS_Mesh.hxx" -#endif -#ifndef _SMDS_ListOfMesh_HeaderFile -#include "SMDS_ListOfMesh.hxx" -#endif -#ifndef _Handle_SMDS_MeshNodeIDFactory_HeaderFile -#include "Handle_SMDS_MeshNodeIDFactory.hxx" -#endif -#ifndef _Handle_SMDS_MeshElementIDFactory_HeaderFile -#include "Handle_SMDS_MeshElementIDFactory.hxx" -#endif -#ifndef _Standard_Boolean_HeaderFile -#include "Standard_Boolean.hxx" -#endif -#ifndef _SMDS_MeshObject_HeaderFile -#include "SMDS_MeshObject.hxx" -#endif -#ifndef _Standard_Integer_HeaderFile -#include -#endif -#ifndef _Standard_Real_HeaderFile -#include -#endif -#ifndef _Handle_SMDS_MeshElement_HeaderFile -#include "Handle_SMDS_MeshElement.hxx" -#endif -#ifndef _Handle_SMDS_MeshNode_HeaderFile -#include "Handle_SMDS_MeshNode.hxx" -#endif -class SMDS_MeshNodeIDFactory; -class SMDS_MeshElementIDFactory; -class Standard_NoSuchObject; -class SMDS_MeshVolumesIterator; -class SMDS_MeshFacesIterator; -class SMDS_MeshEdgesIterator; -class SMDS_MeshNodesIterator; -class SMDS_MeshElement; -class SMDS_MeshNode; -class SMDS_ListIteratorOfListOfMesh; -class SMDS_MapOfMeshOrientedElement; - - -class SMDS_Mesh : public SMDS_MeshObject { - -public: - - inline void* operator new(size_t,void* anAddress) - { - return anAddress; - } - inline void* operator new(size_t size) - { - return Standard::Allocate(size); - } - inline void operator delete(void *anAddress) - { - if (anAddress) Standard::Free((Standard_Address&)anAddress); - } -// inline void operator delete(void *anAddress, size_t size) -// { -// if (anAddress) Standard::Free((Standard_Address&)anAddress,size); -// } - // Methods PUBLIC - // -Standard_EXPORT SMDS_Mesh(const Standard_Integer nbnodes = 10,const Standard_Integer nbedges = 10,const Standard_Integer nbfaces = 10,const Standard_Integer nbvolumes = 10); -Standard_EXPORT Handle_SMDS_Mesh AddSubMesh() ; -Standard_EXPORT virtual Standard_Integer AddNode(const Standard_Real x,const Standard_Real y,const Standard_Real z) ; -Standard_EXPORT virtual Standard_Boolean AddNodeWithID(const Standard_Real x,const Standard_Real y,const Standard_Real z,const Standard_Integer ID) ; -Standard_EXPORT virtual Standard_Boolean AddNode(const Standard_Integer ID) ; -Standard_EXPORT virtual Standard_Integer AddEdge(const Standard_Integer idnode1,const Standard_Integer idnode2) ; -Standard_EXPORT virtual Standard_Boolean AddEdgeWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer ID) ; -Standard_EXPORT virtual Standard_Integer AddFace(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) ; -Standard_EXPORT virtual Standard_Boolean AddFaceWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer ID) ; -Standard_EXPORT virtual Standard_Integer AddFace(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ; -Standard_EXPORT virtual Standard_Boolean AddFaceWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer ID) ; -Standard_EXPORT virtual Standard_Integer AddVolume(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ; -Standard_EXPORT virtual Standard_Boolean AddVolumeWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer ID) ; -Standard_EXPORT virtual Standard_Integer AddVolume(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5) ; -Standard_EXPORT virtual Standard_Boolean AddVolumeWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer ID) ; -Standard_EXPORT virtual Standard_Integer AddVolume(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer idnode6) ; -Standard_EXPORT virtual Standard_Boolean AddVolumeWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer idnode6,const Standard_Integer ID) ; -Standard_EXPORT virtual Standard_Integer AddVolume(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer idnode6,const Standard_Integer idnode7,const Standard_Integer idnode8) ; -Standard_EXPORT virtual Standard_Boolean AddVolumeWithID(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer idnode6,const Standard_Integer idnode7,const Standard_Integer idnode8,const Standard_Integer ID) ; -Standard_EXPORT Handle_SMDS_MeshElement AddVolume(const Handle(SMDS_MeshElement)& node1,const Handle(SMDS_MeshElement)& node2,const Handle(SMDS_MeshElement)& node3,const Handle(SMDS_MeshElement)& node4) ; -Standard_EXPORT Handle_SMDS_MeshElement AddVolume(const Handle(SMDS_MeshElement)& node1,const Handle(SMDS_MeshElement)& node2,const Handle(SMDS_MeshElement)& node3,const Handle(SMDS_MeshElement)& node4,const Handle(SMDS_MeshElement)& node5) ; -Standard_EXPORT Handle_SMDS_MeshElement AddVolume(const Handle(SMDS_MeshElement)& node1,const Handle(SMDS_MeshElement)& node2,const Handle(SMDS_MeshElement)& node3,const Handle(SMDS_MeshElement)& node4,const Handle(SMDS_MeshElement)& node5,const Handle(SMDS_MeshElement)& node6) ; -Standard_EXPORT Handle_SMDS_MeshElement AddVolume(const Handle(SMDS_MeshElement)& node1,const Handle(SMDS_MeshElement)& node2,const Handle(SMDS_MeshElement)& node3,const Handle(SMDS_MeshElement)& node4,const Handle(SMDS_MeshElement)& node5,const Handle(SMDS_MeshElement)& node6,const Handle(SMDS_MeshElement)& node7,const Handle(SMDS_MeshElement)& node8) ; -Standard_EXPORT virtual void RemoveNode(const Standard_Integer IDnode) ; -Standard_EXPORT virtual void RemoveEdge(const Standard_Integer idnode1,const Standard_Integer idnode2) ; -Standard_EXPORT virtual void RemoveFace(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) ; -Standard_EXPORT virtual void RemoveFace(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ; -Standard_EXPORT virtual void RemoveElement(const Standard_Integer IDelem,const Standard_Boolean removenodes = Standard_False) ; -Standard_EXPORT void RemoveElement(const Handle(SMDS_MeshElement)& elem,const Standard_Boolean removenodes = Standard_False) ; -Standard_EXPORT virtual Standard_Boolean RemoveFromParent() ; -Standard_EXPORT virtual Standard_Boolean RemoveSubMesh(const Handle(SMDS_Mesh)& aMesh) ; -Standard_EXPORT Handle_SMDS_MeshNode GetNode(const Standard_Integer rank,const Handle(SMDS_MeshElement)& ME) const; -Standard_EXPORT Handle_SMDS_MeshElement FindNode(const Standard_Integer idnode) const; -Standard_EXPORT Handle_SMDS_MeshElement FindEdge(const Standard_Integer idnode1,const Standard_Integer idnode2) const; -Standard_EXPORT Handle_SMDS_MeshElement FindFace(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) const; -Standard_EXPORT Handle_SMDS_MeshElement FindFace(const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) const; -Standard_EXPORT Handle_SMDS_MeshElement FindElement(const Standard_Integer IDelem) const; -Standard_EXPORT Standard_Boolean Contains(const Handle(SMDS_MeshElement)& elem) const; -Standard_EXPORT void RebuildAllInverseConnections() ; -Standard_EXPORT void SubMeshIterator(SMDS_ListIteratorOfListOfMesh& itmsh) const; -Standard_EXPORT inline Standard_Integer NbNodes() const; -Standard_EXPORT inline Standard_Integer NbEdges() const; -Standard_EXPORT inline Standard_Integer NbFaces() const; -Standard_EXPORT inline Standard_Integer NbVolumes() const; -Standard_EXPORT inline Standard_Integer NbSubMesh() const; -Standard_EXPORT void DumpNodes() const; -Standard_EXPORT void DumpEdges() const; -Standard_EXPORT void DumpFaces() const; -Standard_EXPORT void DumpVolumes() const; -Standard_EXPORT void DebugStats() const; -Standard_EXPORT Handle_SMDS_MeshElement CreateEdge(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2) const; -Standard_EXPORT Handle_SMDS_MeshElement CreateFace(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) const; -Standard_EXPORT Handle_SMDS_MeshElement CreateFace(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) const; -Standard_EXPORT Handle_SMDS_MeshElement CreateVolume(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) const; -Standard_EXPORT Handle_SMDS_MeshElement CreateVolume(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5) const; -Standard_EXPORT Handle_SMDS_MeshElement CreateVolume(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer idnode6) const; -Standard_EXPORT Handle_SMDS_MeshElement CreateVolume(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4,const Standard_Integer idnode5,const Standard_Integer idnode6,const Standard_Integer idnode7,const Standard_Integer idnode8) const; -Standard_EXPORT ~SMDS_Mesh(); - - -friend class SMDS_MeshVolumesIterator; -friend class SMDS_MeshFacesIterator; -friend class SMDS_MeshEdgesIterator; -friend class SMDS_MeshNodesIterator; - - - // Type management - // - Standard_EXPORT friend Handle_Standard_Type& SMDS_Mesh_Type_(); - Standard_EXPORT const Handle(Standard_Type)& DynamicType() const; - Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const; - -protected: - - // Methods PROTECTED - // -Standard_EXPORT Handle_SMDS_MeshElement FindNode(const Handle(SMDS_MeshElement)& node) const; -Standard_EXPORT Handle_SMDS_MeshElement FindEdge(const Handle(SMDS_MeshElement)& edge) const; -Standard_EXPORT Handle_SMDS_MeshElement FindFace(const Handle(SMDS_MeshElement)& face) const; -Standard_EXPORT Handle_SMDS_MeshElement FindVolume(const Handle(SMDS_MeshElement)& volume) const; -Standard_EXPORT void RemoveInverseElement(const Handle(SMDS_MeshElement)& node,const Handle(SMDS_MeshElement)& parent) const; -Standard_EXPORT Standard_Boolean RemoveNode(const Handle(SMDS_MeshElement)& node) ; -Standard_EXPORT void RemoveEdge(const Handle(SMDS_MeshElement)& edge) ; -Standard_EXPORT void RemoveFace(const Handle(SMDS_MeshElement)& face) ; -Standard_EXPORT void RemoveVolume(const Handle(SMDS_MeshElement)& volume) ; -Standard_EXPORT Handle_SMDS_MeshElement GetNode(const Standard_Integer ID) const; -Standard_EXPORT void RemoveAncestors(const Handle(SMDS_MeshElement)& ME,const SMDS_MapOfMeshOrientedElement& map) ; - - - // Fields PROTECTED - // - - -private: - - // Methods PRIVATE - // -Standard_EXPORT SMDS_Mesh(const Handle(SMDS_Mesh)& parent,const Standard_Integer nbnodes = 10); -Standard_EXPORT Standard_Boolean AddNode(const Handle(SMDS_MeshElement)& node) ; -Standard_EXPORT void FreeNode(const Handle(SMDS_MeshElement)& node) ; -Standard_EXPORT void BuildMapNodeAncestors(const Handle(SMDS_MeshElement)& ME,SMDS_MapOfMeshOrientedElement& map) const; -Standard_EXPORT void BuildMapEdgeAncestors(const Handle(SMDS_MeshElement)& ME,SMDS_MapOfMeshOrientedElement& map) const; -Standard_EXPORT void BuildMapFaceAncestors(const Handle(SMDS_MeshElement)& ME,SMDS_MapOfMeshOrientedElement& map) const; -Standard_EXPORT void RebuildInverseConnections() ; - - - // Fields PRIVATE - // -SMDS_MapOfMeshOrientedElement myNodes; -SMDS_MapOfMeshOrientedElement myEdges; -SMDS_MapOfMeshOrientedElement myFaces; -SMDS_MapOfMeshOrientedElement myVolumes; -Handle_SMDS_Mesh myParent; -SMDS_ListOfMesh myChildren; -Handle_SMDS_MeshNodeIDFactory myNodeIDFactory; -Handle_SMDS_MeshElementIDFactory myElementIDFactory; -Standard_Boolean myHasInverse; - - +#include "SMDS_MeshNode.hxx" +#include "SMDS_MeshEdge.hxx" +#include "SMDS_MeshFace.hxx" +#include "SMDS_MeshVolume.hxx" +#include "SMDS_MeshElementIDFactory.hxx" +#include "SMDS_Iterator.hxx" + +#include +#include + +class SMDSControl_BoundaryEdges; + +class SMDS_Mesh:public SMDS_MeshObject +{ + + public: + + SMDS_Mesh(); + + SMDS_Iterator * nodesIterator() const; + SMDS_Iterator * edgesIterator() const; + SMDS_Iterator * facesIterator() const; + SMDS_Iterator * volumesIterator() const; + + SMDS_Mesh *AddSubMesh(); + virtual SMDS_MeshNode* AddNode(double x, double y, double z); + virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID); + + virtual SMDS_MeshEdge* AddEdge(int idnode1, int idnode2); + virtual SMDS_MeshEdge* AddEdgeWithID(int idnode1, int idnode2, int ID); + virtual SMDS_MeshFace* AddFace(int idnode1, int idnode2, int idnode3); + virtual SMDS_MeshFace* AddFaceWithID(int idnode1, int idnode2, int idnode3, + int ID); + virtual SMDS_MeshFace* AddFace(int idnode1, int idnode2, int idnode3, + int idnode4); + virtual SMDS_MeshFace* AddFaceWithID(int idnode1, int idnode2, int idnode3, + int idnode4, int ID); + virtual SMDS_MeshVolume* AddVolume(int idnode1, int idnode2, int idnode3, + int idnode4); + virtual SMDS_MeshVolume* AddVolumeWithID(int idnode1, int idnode2, + int idnode3, int idnode4, int ID); + virtual SMDS_MeshVolume* AddVolume(int idnode1, int idnode2, int idnode3, + int idnode4, int idnode5); + virtual SMDS_MeshVolume* AddVolumeWithID(int idnode1, int idnode2, int idnode3, + int idnode4, int idnode5, int ID); + virtual SMDS_MeshVolume* AddVolume(int idnode1, int idnode2, int idnode3, + int idnode4, int idnode5, int idnode6); + virtual SMDS_MeshVolume* AddVolumeWithID(int idnode1, int idnode2, + int idnode3, int idnode4, int idnode5, int idnode6, int ID); + virtual SMDS_MeshVolume* AddVolume(int idnode1, int idnode2, int idnode3, + int idnode4, int idnode5, int idnode6, int idnode7, int idnode8); + virtual SMDS_MeshVolume* AddVolumeWithID(int idnode1, int idnode2, int idnode3, + int idnode4, int idnode5, int idnode6, int idnode7, int idnode8, + int ID); + virtual void RemoveNode(int IDnode); + virtual void RemoveEdge(int idnode1, int idnode2); + virtual void RemoveFace(int idnode1, int idnode2, int idnode3); + virtual void RemoveFace(int idnode1, int idnode2, int idnode3, int idnode4); + virtual void RemoveElement(int IDelem, const bool removenodes = false); + void RemoveElement(const SMDS_MeshElement * elem, const bool removenodes = + false); + bool RemoveNode(const SMDS_MeshNode * node); //Remove a node and elements which need this node + void RemoveEdge(const SMDS_MeshEdge * edge); + void RemoveFace(const SMDS_MeshFace * face); + void RemoveVolume(const SMDS_MeshVolume * volume); + + virtual bool RemoveFromParent(); + virtual bool RemoveSubMesh(const SMDS_Mesh * aMesh); + + const SMDS_MeshNode *FindNode(int idnode) const; + const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2) const; + const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3) const; + const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4) const; + const SMDS_MeshElement *FindElement(int IDelem) const; + + int NbNodes() const; + int NbEdges() const; + int NbFaces() const; + int NbVolumes() const; + int NbSubMesh() const; + void DumpNodes() const; + void DumpEdges() const; + void DumpFaces() const; + void DumpVolumes() const; + void DebugStats() const; + SMDS_Mesh *boundaryFaces(); + SMDS_Mesh *boundaryEdges(); + ~SMDS_Mesh(); + bool hasConstructionEdges(); + bool hasConstructionFaces(); + bool hasInverseElements(); + void setConstructionEdges(bool); + void setConstructionFaces(bool); + void setInverseElements(bool); + + private: + SMDS_Mesh(SMDS_Mesh * parent); + SMDS_MeshFace * createTriangle(SMDS_MeshNode * node1, + SMDS_MeshNode * node2, SMDS_MeshNode * node3); + SMDS_MeshFace * createQuadrangle(SMDS_MeshNode * node1, + SMDS_MeshNode * node2, SMDS_MeshNode * node3, SMDS_MeshNode * node4); + void removeElementDependencies(SMDS_MeshElement * element); + const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2) const; + SMDS_MeshEdge* FindEdgeOrCreate(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2); + SMDS_MeshFace* FindFaceOrCreate( + const SMDS_MeshNode *n1, + const SMDS_MeshNode *n2, + const SMDS_MeshNode *n3); + const SMDS_MeshFace* FindFace( + const SMDS_MeshNode *n1, + const SMDS_MeshNode *n2, + const SMDS_MeshNode *n3, + const SMDS_MeshNode *n4) const; + SMDS_MeshFace* FindFaceOrCreate( + const SMDS_MeshNode *n1, + const SMDS_MeshNode *n2, + const SMDS_MeshNode *n3, + const SMDS_MeshNode *n4); + + // Fields PRIVATE + typedef set SetOfNodes; + typedef set SetOfEdges; + typedef set SetOfFaces; + typedef set SetOfVolumes; + + SetOfNodes myNodes; + SetOfEdges myEdges; + SetOfFaces myFaces; + SetOfVolumes myVolumes; + SMDS_Mesh *myParent; + list myChildren; + SMDS_MeshElementIDFactory *myNodeIDFactory; + SMDS_MeshElementIDFactory *myElementIDFactory; + + bool myHasConstructionEdges; + bool myHasConstructionFaces; + bool myHasInverseElements; }; - -#include "SMDS_Mesh.lxx" - - - -// other inline functions and methods (like "C++: function call" methods) -// - - #endif diff --git a/src/SMDS/SMDS_MeshEdge.cxx b/src/SMDS/SMDS_MeshEdge.cxx index c6d6b7879..3f7994c1f 100644 --- a/src/SMDS/SMDS_MeshEdge.cxx +++ b/src/SMDS/SMDS_MeshEdge.cxx @@ -25,50 +25,103 @@ // Author : Jean-Michel BOULCOURT // Module : SMESH -using namespace std; -#include "SMDS_MeshEdge.ixx" + +#include "SMDS_MeshEdge.hxx" +#include "SMDS_IteratorOfElements.hxx" +#include "SMDS_MeshNode.hxx" +#include //======================================================================= //function : SMDS_MeshEdge //purpose : //======================================================================= -SMDS_MeshEdge::SMDS_MeshEdge(const Standard_Integer ID, - const Standard_Integer idnode1, - const Standard_Integer idnode2) : -SMDS_MeshElement(ID,2,SMDSAbs_Edge) -{ - SetConnections(idnode1,idnode2); - ComputeKey(); +SMDS_MeshEdge::SMDS_MeshEdge(SMDS_MeshNode * node1, SMDS_MeshNode * node2) +{ + myNodes[0]=node1; + myNodes[1]=node2; } //======================================================================= -//function : SetConnections +//function : Print //purpose : //======================================================================= -void SMDS_MeshEdge::SetConnections(const Standard_Integer idnode1, - const Standard_Integer idnode2) + +void SMDS_MeshEdge::Print(ostream & OS) const { - Standard_Integer idmin = (idnode1 < idnode2? idnode1 : idnode2); - - myNodes[0] = idmin; - if (idmin == idnode1) { - myNodes[1] = idnode2; - } else { - myNodes[1] = idnode1; - } + OS << "edge <" << GetID() << "> : (" << myNodes[0] << " , " << myNodes[1] << + ") " << endl; } -//======================================================================= -//function : Print -//purpose : -//======================================================================= +int SMDS_MeshEdge::NbNodes() const +{ + return 2; +} -void SMDS_MeshEdge::Print(Standard_OStream& OS) const +int SMDS_MeshEdge::NbEdges() const { - OS << "edge <" << myID <<"> : (" << myNodes[0] << " , " << myNodes[1] << ") " << endl; + return 1; } +SMDSAbs_ElementType SMDS_MeshEdge::GetType() const +{ + return SMDSAbs_Edge; +} + +SMDS_Iterator * SMDS_MeshEdge:: + elementsIterator(SMDSAbs_ElementType type) const +{ + class MyNodeIterator:public SMDS_Iterator + { + SMDS_MeshNode *const* myNodes; + int myIndex; + public: + MyNodeIterator(SMDS_MeshNode * const* nodes):myNodes(nodes),myIndex(0) + {} + + bool more() + { + return myIndex<2; + } + + const SMDS_MeshElement* next() + { + myIndex++; + return myNodes[myIndex-1]; + } + }; + switch(type) + { + case SMDSAbs_Edge:return SMDS_MeshElement::elementsIterator(SMDSAbs_Edge); + case SMDSAbs_Node:return new MyNodeIterator(myNodes); + default: return new SMDS_IteratorOfElements(this,type, nodesIterator()); + } +} + +bool operator<(const SMDS_MeshEdge & e1, const SMDS_MeshEdge & e2) +{ + int id11=e1.myNodes[0]->GetID(); + int id21=e2.myNodes[0]->GetID(); + int id12=e1.myNodes[1]->GetID(); + int id22=e2.myNodes[1]->GetID(); + int tmp; + if(id11>=id12) + { + tmp=id11; + id11=id12; + id12=tmp; + } + if(id21>=id22) + { + tmp=id21; + id21=id22; + id22=tmp; + } + + if(id11 -#endif -#ifndef _Handle_SMDS_MeshEdge_HeaderFile -#include "Handle_SMDS_MeshEdge.hxx" -#endif - -#ifndef _Standard_Integer_HeaderFile -#include -#endif -#ifndef _SMDS_MeshElement_HeaderFile #include "SMDS_MeshElement.hxx" -#endif -#ifndef _Standard_Address_HeaderFile -#include -#endif -#ifndef _Standard_OStream_HeaderFile -#include -#endif - - -class SMDS_MeshEdge : public SMDS_MeshElement { - -public: - - inline void* operator new(size_t,void* anAddress) - { - return anAddress; - } - inline void* operator new(size_t size) - { - return Standard::Allocate(size); - } - inline void operator delete(void *anAddress) - { - if (anAddress) Standard::Free((Standard_Address&)anAddress); - } -// inline void operator delete(void *anAddress, size_t size) -// { -// if (anAddress) Standard::Free((Standard_Address&)anAddress,size); -// } - // Methods PUBLIC - // -Standard_EXPORT SMDS_MeshEdge(const Standard_Integer ID,const Standard_Integer idnode1,const Standard_Integer idnode2); -Standard_EXPORT inline void ComputeKey() ; -Standard_EXPORT inline Standard_Integer GetKey() const; -Standard_EXPORT inline Standard_Address GetConnections() const; -Standard_EXPORT inline Standard_Integer GetConnection(const Standard_Integer rank) const; -Standard_EXPORT void Print(Standard_OStream& OS) const; -Standard_EXPORT ~SMDS_MeshEdge(); - - - - - // Type management - // - Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshEdge_Type_(); - Standard_EXPORT const Handle(Standard_Type)& DynamicType() const; - Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const; +#include -protected: +class SMDS_MeshEdge:public SMDS_MeshElement +{ - // Methods PROTECTED - // + public: + SMDS_MeshEdge(SMDS_MeshNode * node1, SMDS_MeshNode * node2); + void Print(ostream & OS) const; + SMDSAbs_ElementType GetType() const; + int NbNodes() const; + int NbEdges() const; + friend bool operator<(const SMDS_MeshEdge& e1, const SMDS_MeshEdge& e2); + protected: + SMDS_Iterator * + elementsIterator(SMDSAbs_ElementType type) const; - // Fields PROTECTED - // - - -private: - - // Methods PRIVATE - // -Standard_EXPORT void SetConnections(const Standard_Integer idnode1,const Standard_Integer idnode2) ; - - - // Fields PRIVATE - // -Standard_Integer myKey; -Standard_Integer myNodes[2]; - + private: + SMDS_MeshNode* myNodes[2]; }; - - -#include "SMDS_MeshEdge.lxx" - - - -// other inline functions and methods (like "C++: function call" methods) -// - - #endif diff --git a/src/SMDS/SMDS_MeshElement.cxx b/src/SMDS/SMDS_MeshElement.cxx index 10432de1d..827737228 100644 --- a/src/SMDS/SMDS_MeshElement.cxx +++ b/src/SMDS/SMDS_MeshElement.cxx @@ -18,181 +18,172 @@ // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // // See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org -// -// -// -// File : SMDS_MeshElement.cxx -// Author : Jean-Michel BOULCOURT -// Module : SMESH - -using namespace std; -#include "SMDS_MeshElement.ixx" -//======================================================================= -//function : SMDS_MeshElement -//purpose : -//======================================================================= +#include "SMDS_MeshElement.hxx" +#include "SMDS_MeshNode.hxx" +#include "SMDS_MeshEdge.hxx" +#include "SMDS_MeshFace.hxx" +#include "SMDS_MeshVolume.hxx" +#include "utilities.h" -SMDS_MeshElement::SMDS_MeshElement(const Standard_Integer ID, const Standard_Integer nb,const SMDSAbs_ElementType Type) - :myID(ID),myNbNodes(nb),myType(Type) +SMDS_MeshElement::SMDS_MeshElement(int ID):myID(ID) { } -//======================================================================= -//function : GetConnections -//purpose : -//======================================================================= - -Standard_Address SMDS_MeshElement::GetConnections() const +void SMDS_MeshElement::Print(ostream & OS) const { - return (Standard_Address)&myID; + OS << "dump of mesh element" << endl; } - -//======================================================================= -//function : GetConnection -//purpose : -//======================================================================= - -Standard_Integer SMDS_MeshElement::GetConnection(const Standard_Integer rank) const +ostream & operator <<(ostream & OS, const SMDS_MeshElement * ME) { - return myID; + ME->Print(OS); + return OS; } - -//======================================================================= -//function : InverseElements -//purpose : -//======================================================================= - -const SMDS_ListOfMeshElement& SMDS_MeshElement::InverseElements() const +/////////////////////////////////////////////////////////////////////////////// +/// Create an iterator which iterate on nodes owned by the element. +/// This method call elementsIterator(). +/////////////////////////////////////////////////////////////////////////////// +SMDS_Iterator * SMDS_MeshElement::nodesIterator() const { - static SMDS_ListOfMeshElement empty; - return empty; + return elementsIterator(SMDSAbs_Node); } -//======================================================================= -//function : ClearInverseElements -//purpose : -//======================================================================= - -void SMDS_MeshElement::ClearInverseElements() +/////////////////////////////////////////////////////////////////////////////// +/// Create an iterator which iterate on edges linked with or owned by the element. +/// This method call elementsIterator(). +/////////////////////////////////////////////////////////////////////////////// +SMDS_Iterator * SMDS_MeshElement::edgesIterator() const { + return elementsIterator(SMDSAbs_Edge); } -//======================================================================= -//function : AddInverseElement -//purpose : -//======================================================================= - -void SMDS_MeshElement::AddInverseElement(const Handle(SMDS_MeshElement)& elem) +/////////////////////////////////////////////////////////////////////////////// +/// Create an iterator which iterate on faces linked with or owned by the element. +/// This method call elementsIterator(). +/////////////////////////////////////////////////////////////////////////////// +SMDS_Iterator * SMDS_MeshElement::facesIterator() const { + return elementsIterator(SMDSAbs_Face); } -//======================================================================= -//function : NbEdges -//purpose : -//======================================================================= - -Standard_Integer SMDS_MeshElement::NbEdges() const +/////////////////////////////////////////////////////////////////////////////// +///Return The number of nodes owned by the current element +/////////////////////////////////////////////////////////////////////////////// +int SMDS_MeshElement::NbNodes() const { - return 0; + int nbnodes=0; + SMDS_Iterator * it=nodesIterator(); + while(it->more()) + { + it->next(); + nbnodes++; + } + delete it; + return nbnodes; } -//======================================================================= -//function : NbFaces -//purpose : -//======================================================================= - -Standard_Integer SMDS_MeshElement::NbFaces() const +/////////////////////////////////////////////////////////////////////////////// +///Return the number of edges owned by or linked with the current element +/////////////////////////////////////////////////////////////////////////////// +int SMDS_MeshElement::NbEdges() const { - return 0; + int nbedges=0; + SMDS_Iterator * it=edgesIterator(); + while(it->more()) + { + it->next(); + nbedges++; + } + delete it; + return nbedges; } - -//======================================================================= -//function : GetEdgeDefinedByNodes -//purpose : -//======================================================================= - -void SMDS_MeshElement::GetEdgeDefinedByNodes(const Standard_Integer rank, - Standard_Integer& idnode1, - Standard_Integer& idnode2) const +/////////////////////////////////////////////////////////////////////////////// +///Return the number of faces owned by or linked with the current element +/////////////////////////////////////////////////////////////////////////////// +int SMDS_MeshElement::NbFaces() const { - idnode1 = 0; - idnode2 = 0; + int nbfaces=0; + SMDS_Iterator * it=facesIterator(); + while(it->more()) + { + it->next(); + nbfaces++; + } + delete it; + return nbfaces; } -//======================================================================= -//function : GetFaceDefinedByNodes -//purpose : -//======================================================================= - -void SMDS_MeshElement::GetFaceDefinedByNodes(const Standard_Integer rank, - const Standard_Address idnode, - Standard_Integer& nb) const +/////////////////////////////////////////////////////////////////////////////// +///Create and iterator which iterate on elements linked with the current element. +///The iterator must be free by the caller (call delete myIterator). +///@param type The of elements on which you want to iterate +///@return An iterator, that you must free when you no longer need it +/////////////////////////////////////////////////////////////////////////////// +SMDS_Iterator * SMDS_MeshElement:: + elementsIterator(SMDSAbs_ElementType type) const { - nb = 0; + class MyIterator:public SMDS_Iterator + { + const SMDS_MeshElement * myElement; + bool myMore; + public: + MyIterator(const SMDS_MeshElement * element): + myElement(element),myMore(true) + { + } + + bool more() + { + return myMore; + } + + const SMDS_MeshElement* next() + { + myMore=false; + return myElement; + } + }; + + if(type==GetType()) return new MyIterator(this); + else + { + MESSAGE("Iterator not implemented"); + return NULL; + } } -//======================================================================= -//function : SetNormal -//purpose : -//======================================================================= - -void SMDS_MeshElement::SetNormal(const Standard_Integer rank, - const Standard_Real vx, - const Standard_Real vy, - const Standard_Real vz) - -{ - if (myNormals.IsNull()) { - myNormals = new TColgp_HArray1OfDir(1,NbNodes()); - } - myNormals->SetValue(rank, gp_Dir(vx,vy,vz)); -} - -//======================================================================= -//function : SetNormal -//purpose : -//======================================================================= - -void SMDS_MeshElement::SetNormal(const Standard_Integer rank, - const gp_Vec& V) +/////////////////////////////////////////////////////////////////////////////// +///Return the ID of the element +/////////////////////////////////////////////////////////////////////////////// +int SMDS_MeshElement::GetID() const { - if (myNormals.IsNull()) { - myNormals = new TColgp_HArray1OfDir(1,NbNodes()); - } - myNormals->SetValue(rank, gp_Dir(V)); + return myID; } -//======================================================================= -//function : GetNormal -//purpose : -//======================================================================= - -gp_Dir SMDS_MeshElement::GetNormal(const Standard_Integer rank) -{ - if (myNormals.IsNull()) { - myNormals = new TColgp_HArray1OfDir(1,NbNodes()); - } - return myNormals->Value(rank); -} - -//======================================================================= -//function : Print -//purpose : -//======================================================================= - -void SMDS_MeshElement::Print(Standard_OStream& OS) const -{ - OS << "dump of mesh element" << endl; -} - - -Standard_OStream& operator << (Standard_OStream& OS - ,const Handle(SMDS_MeshElement)& ME) +bool operator<(const SMDS_MeshElement& e1, const SMDS_MeshElement& e2) { - ME->Print(OS); - return OS; + if(e1.GetType()!=e2.GetType()) return false; + switch(e1.GetType()) + { + case SMDSAbs_Node: + return static_cast(e1) < + static_cast(e2); + + case SMDSAbs_Edge: + return static_cast(e1) < + static_cast(e2); + + case SMDSAbs_Face: + return static_cast(e1) < + static_cast(e2); + + case SMDSAbs_Volume: + return static_cast(e1) < + static_cast(e2); + + default : MESSAGE("Internal Error"); + } } diff --git a/src/SMDS/SMDS_MeshElement.hxx b/src/SMDS/SMDS_MeshElement.hxx index 0bd0d407d..d35e151bd 100644 --- a/src/SMDS/SMDS_MeshElement.hxx +++ b/src/SMDS/SMDS_MeshElement.hxx @@ -26,134 +26,49 @@ #ifndef _SMDS_MeshElement_HeaderFile #define _SMDS_MeshElement_HeaderFile - -#ifndef _Standard_HeaderFile -#include -#endif -#ifndef _Handle_SMDS_MeshElement_HeaderFile -#include "Handle_SMDS_MeshElement.hxx" -#endif - -#ifndef _Standard_Integer_HeaderFile -#include -#endif -#ifndef _SMDSAbs_ElementType_HeaderFile + #include "SMDSAbs_ElementType.hxx" -#endif -#ifndef _Handle_TColgp_HArray1OfDir_HeaderFile -#include "Handle_TColgp_HArray1OfDir.hxx" -#endif -#ifndef _SMDS_MeshObject_HeaderFile #include "SMDS_MeshObject.hxx" -#endif -#ifndef _Standard_Boolean_HeaderFile -#include -#endif -#ifndef _Standard_Address_HeaderFile -#include -#endif -#ifndef _Standard_Real_HeaderFile -#include -#endif -#ifndef _Standard_OStream_HeaderFile -#include -#endif -class TColgp_HArray1OfDir; -class Standard_OutOfRange; -class SMDS_ListOfMeshElement; -class gp_Vec; -class gp_Dir; - - -class SMDS_MeshElement : public SMDS_MeshObject { - -public: - - inline void* operator new(size_t,void* anAddress) - { - return anAddress; - } - inline void* operator new(size_t size) - { - return Standard::Allocate(size); - } - inline void operator delete(void *anAddress) - { - if (anAddress) Standard::Free((Standard_Address&)anAddress); - } -// inline void operator delete(void *anAddress, size_t size) -// { -// if (anAddress) Standard::Free((Standard_Address&)anAddress,size); -// } - // Methods PUBLIC - // -Standard_EXPORT inline Standard_Integer HashCode(const Standard_Integer Upper) const; -Standard_EXPORT inline Standard_Boolean IsSame(const Handle(SMDS_MeshElement)& other) const; -Standard_EXPORT inline Standard_Boolean IsEqual(const Handle(SMDS_MeshElement)& other) const; -Standard_EXPORT inline Standard_Boolean IsNodeInElement(const Standard_Integer idnode) const; -Standard_EXPORT virtual void GetEdgeDefinedByNodes(const Standard_Integer rank,Standard_Integer& idnode1,Standard_Integer& idnode2) const; -Standard_EXPORT virtual void GetFaceDefinedByNodes(const Standard_Integer rank,const Standard_Address idnode,Standard_Integer& nb) const; -Standard_EXPORT virtual Standard_Integer GetConnection(const Standard_Integer rank) const; -Standard_EXPORT virtual void AddInverseElement(const Handle(SMDS_MeshElement)& ME) ; -Standard_EXPORT virtual const SMDS_ListOfMeshElement& InverseElements() const; -Standard_EXPORT virtual void ClearInverseElements() ; -Standard_EXPORT inline Standard_Integer NbNodes() const; -Standard_EXPORT virtual Standard_Integer NbEdges() const; -Standard_EXPORT virtual Standard_Integer NbFaces() const; -Standard_EXPORT inline Standard_Integer GetID() const; -Standard_EXPORT virtual Standard_Integer GetKey() const = 0; -Standard_EXPORT virtual void SetNormal(const Standard_Integer rank,const Standard_Real vx,const Standard_Real vy,const Standard_Real vz) ; -Standard_EXPORT virtual void SetNormal(const Standard_Integer rank,const gp_Vec& v) ; -Standard_EXPORT virtual gp_Dir GetNormal(const Standard_Integer rank) ; -Standard_EXPORT virtual void Print(Standard_OStream& OS) const; -friend Standard_EXPORT Standard_OStream& operator << (Standard_OStream& OS, const Handle(SMDS_MeshElement)& ); -Standard_EXPORT inline SMDSAbs_ElementType GetType() const; -Standard_EXPORT ~SMDS_MeshElement(); - - - - - // Type management - // - Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshElement_Type_(); - Standard_EXPORT const Handle(Standard_Type)& DynamicType() const; - Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const; - -protected: - - // Methods PROTECTED - // -Standard_EXPORT SMDS_MeshElement(const Standard_Integer ID,const Standard_Integer NbConnections,const SMDSAbs_ElementType Type); -Standard_EXPORT virtual Standard_Address GetConnections() const; - - - // Fields PROTECTED - // -Standard_Integer myID; -Standard_Integer myNbNodes; -Handle_TColgp_HArray1OfDir myNormals; - - -private: - - // Methods PRIVATE - // - - - // Fields PRIVATE - // -SMDSAbs_ElementType myType; - - +#include "SMDS_Iterator.hxx" +#include "SMDS_MeshElementIDFactory.hxx" + +#include +#include + +using namespace std; +class SMDS_MeshNode; +class SMDS_MeshEdge; +class SMDS_MeshFace; + +/////////////////////////////////////////////////////////////////////////////// +/// Base class for elements +/////////////////////////////////////////////////////////////////////////////// +class SMDS_MeshElement:public SMDS_MeshObject +{ + + public: + SMDS_Iterator * nodesIterator() const; + SMDS_Iterator * edgesIterator() const; + SMDS_Iterator * facesIterator() const; + virtual SMDS_Iterator * + elementsIterator(SMDSAbs_ElementType type) const; + + virtual int NbNodes() const; + virtual int NbEdges() const; + virtual int NbFaces() const; + int GetID() const; + + ///Return the type of the current element + virtual SMDSAbs_ElementType GetType() const = 0; + friend ostream & operator <<(ostream & OS, const SMDS_MeshElement *); + friend bool SMDS_MeshElementIDFactory::BindID(int ID,SMDS_MeshElement*elem); + + protected: + SMDS_MeshElement(int ID=-1); + virtual void Print(ostream & OS) const; + + private: + int myID; }; - -#include "SMDS_MeshElement.lxx" - - - -// other inline functions and methods (like "C++: function call" methods) -// - - #endif diff --git a/src/SMDS/SMDS_MeshFace.cxx b/src/SMDS/SMDS_MeshFace.cxx index 7441cc551..b7014293a 100644 --- a/src/SMDS/SMDS_MeshFace.cxx +++ b/src/SMDS/SMDS_MeshFace.cxx @@ -18,49 +18,10 @@ // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // // See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org -// -// -// -// File : SMDS_MeshFace.cxx -// Author : Jean-Michel BOULCOURT -// Module : SMESH - -using namespace std; -#include "SMDS_MeshFace.ixx" - - -//======================================================================= -//function : SMDS_MeshFace -//purpose : -//======================================================================= - -SMDS_MeshFace::SMDS_MeshFace(const Standard_Integer ID, const Standard_Integer nb) -:SMDS_MeshElement(ID,nb,SMDSAbs_Face) -{ -} - - -//======================================================================= -//function : NbEdges -//purpose : -//======================================================================= - -Standard_Integer SMDS_MeshFace::NbEdges() const -{ - return myNbNodes; -} -//======================================================================= -//function : Print -//purpose : -//======================================================================= +#include "SMDS_MeshFace.hxx" -void SMDS_MeshFace::Print(Standard_OStream& OS) const +SMDSAbs_ElementType SMDS_MeshFace::GetType() const { - OS << "face <" << myID <<" > : "; - for (Standard_Integer i=1; i -#endif -#ifndef _Handle_SMDS_MeshFace_HeaderFile -#include "Handle_SMDS_MeshFace.hxx" -#endif - -#ifndef _Standard_Integer_HeaderFile -#include -#endif -#ifndef _SMDS_MeshElement_HeaderFile #include "SMDS_MeshElement.hxx" -#endif -#ifndef _Standard_OStream_HeaderFile -#include -#endif - - -class SMDS_MeshFace : public SMDS_MeshElement { - -public: - - inline void* operator new(size_t,void* anAddress) - { - return anAddress; - } - inline void* operator new(size_t size) - { - return Standard::Allocate(size); - } - inline void operator delete(void *anAddress) - { - if (anAddress) Standard::Free((Standard_Address&)anAddress); - } -// inline void operator delete(void *anAddress, size_t size) -// { -// if (anAddress) Standard::Free((Standard_Address&)anAddress,size); -// } - // Methods PUBLIC - // -Standard_EXPORT virtual void ComputeKey() = 0; -Standard_EXPORT inline Standard_Integer GetKey() const; -Standard_EXPORT virtual Standard_Integer NbEdges() const; -Standard_EXPORT virtual void Print(Standard_OStream& OS) const; -Standard_EXPORT ~SMDS_MeshFace(); - - - - - // Type management - // - Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshFace_Type_(); - Standard_EXPORT const Handle(Standard_Type)& DynamicType() const; - Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const; - -protected: - - // Methods PROTECTED - // -Standard_EXPORT SMDS_MeshFace(const Standard_Integer ID,const Standard_Integer NbConnections); - - - // Fields PROTECTED - // -Standard_Integer myKey; - - -private: - - // Methods PRIVATE - // - - - // Fields PRIVATE - // - +class SMDS_MeshFace:public SMDS_MeshElement +{ + public: + SMDSAbs_ElementType GetType() const; }; - -#include "SMDS_MeshFace.lxx" - - - -// other inline functions and methods (like "C++: function call" methods) -// - - #endif diff --git a/src/SMDS/SMDS_MeshNode.cxx b/src/SMDS/SMDS_MeshNode.cxx index 6a9556031..271d53fe0 100644 --- a/src/SMDS/SMDS_MeshNode.cxx +++ b/src/SMDS/SMDS_MeshNode.cxx @@ -18,78 +18,52 @@ // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // // See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org -// -// -// -// File : SMDS_MeshNode.cxx -// Author : Jean-Michel BOULCOURT -// Module : SMESH -using namespace std; -#include "SMDS_MeshNode.ixx" -#include "SMDS_ListIteratorOfListOfMeshElement.hxx" -#include "SMDS_SpacePosition.hxx" -static Handle(SMDS_Position)& StaticInstancePosition() -{ - static Handle(SMDS_SpacePosition) staticpos; - if (staticpos.IsNull()) - staticpos = new SMDS_SpacePosition(); - - return staticpos; -} +#include "SMDS_MeshNode.hxx" +#include "SMDS_SpacePosition.hxx" +#include "SMDS_IteratorOfElements.hxx" //======================================================================= //function : SMDS_MeshNode //purpose : //======================================================================= -SMDS_MeshNode::SMDS_MeshNode(const Standard_Integer ID, - const Standard_Real x, const Standard_Real y, const Standard_Real z) : - SMDS_MeshElement(ID,1,SMDSAbs_Node),myPnt(x,y,z),myPosition(StaticInstancePosition()) +SMDS_MeshNode::SMDS_MeshNode(double x, double y, double z): + myX(x), myY(y), myZ(z), + myPosition(SMDS_SpacePosition::originSpacePosition()) { } - //======================================================================= //function : RemoveInverseElement //purpose : //======================================================================= -void SMDS_MeshNode::RemoveInverseElement(const Handle(SMDS_MeshElement)& parent) +void SMDS_MeshNode::RemoveInverseElement(const SMDS_MeshElement * parent) { - - SMDS_ListIteratorOfListOfMeshElement itLstInvCnx(myInverseElements); - - for (;itLstInvCnx.More();itLstInvCnx.Next()) { - Handle(SMDS_MeshElement)& ME = itLstInvCnx.Value(); - if (ME->IsSame(parent)) - myInverseElements.Remove(itLstInvCnx); - if (!itLstInvCnx.More()) - break; - } + myInverseElements.erase(parent); } - //======================================================================= //function : Print //purpose : //======================================================================= -void SMDS_MeshNode::Print(Standard_OStream& OS) const +void SMDS_MeshNode::Print(ostream & OS) const { - OS << "Node <" << myID << "> : X = " << myPnt.X() << " Y = " << myPnt.Y() << " Z = " << myPnt.Z() << endl; + OS << "Node <" << GetID() << "> : X = " << myX << " Y = " + << myY << " Z = " << myZ << endl; } - //======================================================================= //function : SetPosition //purpose : //======================================================================= -void SMDS_MeshNode::SetPosition(const Handle(SMDS_Position)& aPos) +void SMDS_MeshNode::SetPosition(SMDS_Position * aPos) { - myPosition = aPos; + myPosition = aPos; } //======================================================================= @@ -97,8 +71,164 @@ void SMDS_MeshNode::SetPosition(const Handle(SMDS_Position)& aPos) //purpose : //======================================================================= -Handle(SMDS_Position) SMDS_MeshNode::GetPosition() const +SMDS_Position *SMDS_MeshNode::GetPosition() +{ + return myPosition; +} + +const SMDS_Position *SMDS_MeshNode::GetPosition() const +{ + return myPosition; +} +/** +*/ +SMDS_Iterator * SMDS_MeshNode:: + GetInverseElementIterator() const +{ + class SMDS_InverseElementIterator:public SMDS_Iterator + { + const set& mySet; + set::iterator myIterator; + public: + SMDS_InverseElementIterator(const set& s):mySet(s) + { + myIterator=mySet.begin(); + } + + bool more() + { + myIterator!=mySet.end(); + } + + const SMDS_MeshElement* next() + { + const SMDS_MeshElement* current=*myIterator; + myIterator++; + return current; + } + }; + return new SMDS_InverseElementIterator(myInverseElements); +} + +SMDS_Iterator * SMDS_MeshNode:: + elementsIterator(SMDSAbs_ElementType type) const +{ + // Same as GetInverseElementIterator but the create iterator only return + // wanted type elements. + class MyIterator:public SMDS_Iterator + { + set mySet; + set::iterator myIterator; + public: + MyIterator(SMDSAbs_ElementType type, + const set& s) + { + const SMDS_MeshElement * e; + bool toInsert; + set::iterator it=s.begin(); + while(it!=s.end()) + { + e=*it; + switch(type) + { + case SMDSAbs_Edge: toInsert=true; break; + case SMDSAbs_Face: toInsert=(e->GetType()!=SMDSAbs_Edge); break; + case SMDSAbs_Volume: toInsert=(e->GetType()==SMDSAbs_Volume); break; + } + if(toInsert) mySet.insert(e); + it++; + } + myIterator=mySet.begin(); + } + + bool more() + { + myIterator!=mySet.end(); + } + + const SMDS_MeshElement* next() + { + const SMDS_MeshElement* current=*myIterator; + myIterator++; + return current; + } + }; + + if(type==SMDSAbs_Node) + return SMDS_MeshElement::elementsIterator(SMDSAbs_Node); + else + return new SMDS_IteratorOfElements(this,type, + new MyIterator(type, myInverseElements)); +} + +int SMDS_MeshNode::NbNodes() const +{ + return 1; +} + +double SMDS_MeshNode::X() const +{ + return myX; +} + +double SMDS_MeshNode::Y() const +{ + return myY; +} + +double SMDS_MeshNode::Z() const +{ + return myZ; +} + +void SMDS_MeshNode::setXYZ(double x, double y, double z) +{ + myX=x; + myY=y; + myZ=z; +} + +SMDSAbs_ElementType SMDS_MeshNode::GetType() const +{ + return SMDSAbs_Node; +} + +//======================================================================= +//function : AddInverseElement +//purpose : +//======================================================================= +void SMDS_MeshNode::AddInverseElement(const SMDS_MeshElement* ME) +{ + myInverseElements.insert(ME); +} + +//======================================================================= +//function : ClearInverseElements +//purpose : +//======================================================================= +void SMDS_MeshNode::ClearInverseElements() +{ + myInverseElements.clear(); +} + +bool SMDS_MeshNode::emptyInverseElements() +{ + return myInverseElements.empty(); +} + +/////////////////////////////////////////////////////////////////////////////// +/// To be used with STL set +/////////////////////////////////////////////////////////////////////////////// +bool operator<(const SMDS_MeshNode& e1, const SMDS_MeshNode& e2) { - return myPosition; + return e1.GetID() -#endif -#ifndef _Handle_SMDS_MeshNode_HeaderFile -#include "Handle_SMDS_MeshNode.hxx" -#endif - -#ifndef _gp_Pnt_HeaderFile -#include -#endif -#ifndef _SMDS_ListOfMeshElement_HeaderFile -#include "SMDS_ListOfMeshElement.hxx" -#endif -#ifndef _Handle_SMDS_Position_HeaderFile -#include "Handle_SMDS_Position.hxx" -#endif -#ifndef _SMDS_MeshElement_HeaderFile #include "SMDS_MeshElement.hxx" -#endif -#ifndef _Standard_Integer_HeaderFile -#include -#endif -#ifndef _Standard_Real_HeaderFile -#include -#endif -#ifndef _Standard_OStream_HeaderFile -#include -#endif -#ifndef _Handle_SMDS_MeshElement_HeaderFile -#include "Handle_SMDS_MeshElement.hxx" -#endif -class SMDS_Position; -class gp_Pnt; -class SMDS_MeshElement; -class SMDS_ListOfMeshElement; - - -class SMDS_MeshNode : public SMDS_MeshElement { - -public: - - inline void* operator new(size_t,void* anAddress) - { - return anAddress; - } - inline void* operator new(size_t size) - { - return Standard::Allocate(size); - } - inline void operator delete(void *anAddress) - { - if (anAddress) Standard::Free((Standard_Address&)anAddress); - } -// inline void operator delete(void *anAddress, size_t size) -// { -// if (anAddress) Standard::Free((Standard_Address&)anAddress,size); -// } - // Methods PUBLIC - // -Standard_EXPORT SMDS_MeshNode(const Standard_Integer ID,const Standard_Real x,const Standard_Real y,const Standard_Real z); -Standard_EXPORT void Print(Standard_OStream& OS) const; -Standard_EXPORT inline Standard_Integer GetKey() const; -Standard_EXPORT inline Standard_Real X() const; -Standard_EXPORT inline Standard_Real Y() const; -Standard_EXPORT inline Standard_Real Z() const; -Standard_EXPORT inline gp_Pnt Pnt() const; -Standard_EXPORT inline void SetPnt(const gp_Pnt& P) ; -Standard_EXPORT inline void AddInverseElement(const Handle(SMDS_MeshElement)& ME) ; -Standard_EXPORT void RemoveInverseElement(const Handle(SMDS_MeshElement)& parent) ; -Standard_EXPORT inline const SMDS_ListOfMeshElement& InverseElements() const; -Standard_EXPORT inline void ClearInverseElements() ; -Standard_EXPORT void SetPosition(const Handle(SMDS_Position)& aPos) ; -Standard_EXPORT Handle_SMDS_Position GetPosition() const; -Standard_EXPORT ~SMDS_MeshNode(); - - - - - // Type management - // - Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshNode_Type_(); - Standard_EXPORT const Handle(Standard_Type)& DynamicType() const; - Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const; - -protected: - - // Methods PROTECTED - // - - - // Fields PROTECTED - // - - -private: - - // Methods PRIVATE - // - - - // Fields PRIVATE - // -gp_Pnt myPnt; -SMDS_ListOfMeshElement myInverseElements; -Handle_SMDS_Position myPosition; - - +#include "SMDS_Position.hxx" + +#include +using namespace std; + +class SMDS_MeshNode:public SMDS_MeshElement +{ + + public: + SMDS_MeshNode(double x, double y, double z); + void Print(ostream & OS) const; + double X() const; + double Y() const; + double Z() const; + void AddInverseElement(const SMDS_MeshElement * ME); + void RemoveInverseElement(const SMDS_MeshElement * parent); + void ClearInverseElements(); + bool emptyInverseElements(); + SMDS_Iterator * GetInverseElementIterator() const; + void SetPosition(SMDS_Position * aPos); + SMDS_Position *GetPosition(); + const SMDS_Position *GetPosition() const; + SMDSAbs_ElementType GetType() const; + int NbNodes() const; + void setXYZ(double x, double y, double z); + friend bool operator<(const SMDS_MeshNode& e1, const SMDS_MeshNode& e2); + + protected: + SMDS_Iterator * + elementsIterator(SMDSAbs_ElementType type) const; + + private: + double myX, myY, myZ; + SMDS_Position *myPosition; + set myInverseElements; }; - -#include "SMDS_MeshNode.lxx" - - - -// other inline functions and methods (like "C++: function call" methods) -// - - #endif diff --git a/src/SMDS/SMDS_MeshVolume.cxx b/src/SMDS/SMDS_MeshVolume.cxx index 20e40f3b6..561f0dccb 100644 --- a/src/SMDS/SMDS_MeshVolume.cxx +++ b/src/SMDS/SMDS_MeshVolume.cxx @@ -25,31 +25,14 @@ // Author : Jean-Michel BOULCOURT // Module : SMESH -using namespace std; -#include "SMDS_MeshVolume.ixx" -#include - -//======================================================================= -//function : SMDS_MeshVolume -//purpose : -//======================================================================= - -SMDS_MeshVolume::SMDS_MeshVolume(const Standard_Integer ID, const Standard_Integer nb) -:SMDS_MeshElement(ID,nb,SMDSAbs_Volume) -{ -} - +#include "SMDS_MeshVolume.hxx" //======================================================================= //function : Print //purpose : //======================================================================= -void SMDS_MeshVolume::Print(Standard_OStream& OS) const +SMDSAbs_ElementType SMDS_MeshVolume::GetType() const { - OS << "volume <" << myID <<"> : " ; - for (Standard_Integer i=1; i -#endif -#ifndef _Handle_SMDS_MeshVolume_HeaderFile -#include "Handle_SMDS_MeshVolume.hxx" -#endif - -#ifndef _Standard_Integer_HeaderFile -#include -#endif -#ifndef _SMDS_MeshElement_HeaderFile #include "SMDS_MeshElement.hxx" -#endif -#ifndef _Standard_OStream_HeaderFile -#include -#endif -class Standard_ConstructionError; - - -class SMDS_MeshVolume : public SMDS_MeshElement { - -public: - - inline void* operator new(size_t,void* anAddress) - { - return anAddress; - } - inline void* operator new(size_t size) - { - return Standard::Allocate(size); - } - inline void operator delete(void *anAddress) - { - if (anAddress) Standard::Free((Standard_Address&)anAddress); - } -// inline void operator delete(void *anAddress, size_t size) -// { -// if (anAddress) Standard::Free((Standard_Address&)anAddress,size); -// } - // Methods PUBLIC - // -Standard_EXPORT virtual void ComputeKey() = 0; -Standard_EXPORT inline Standard_Integer GetKey() const; -Standard_EXPORT virtual void Print(Standard_OStream& OS) const; -Standard_EXPORT ~SMDS_MeshVolume(); - - - - - // Type management - // - Standard_EXPORT friend Handle_Standard_Type& SMDS_MeshVolume_Type_(); - Standard_EXPORT const Handle(Standard_Type)& DynamicType() const; - Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const; - -protected: - - // Methods PROTECTED - // -Standard_EXPORT SMDS_MeshVolume(const Standard_Integer ID,const Standard_Integer NbConnections); - - - // Fields PROTECTED - // -Standard_Integer myKey; - - -private: - - // Methods PRIVATE - // - - - // Fields PRIVATE - // - +class SMDS_MeshVolume:public SMDS_MeshElement +{ + + public: + SMDSAbs_ElementType GetType() const; }; - - -#include "SMDS_MeshVolume.lxx" - - - -// other inline functions and methods (like "C++: function call" methods) -// - - #endif