X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH%2FSMESH_Pattern.hxx;h=67c9093ea5c89eb1d71dee95604ea8719f30f22e;hp=670578ce459d1e04bfb6eab8028309fb57c9d848;hb=3da8fefe9c957f4538e9eacf013ce678df4d6c91;hpb=e465982eeb48dded773c5e18053a8da7fcf15222 diff --git a/src/SMESH/SMESH_Pattern.hxx b/src/SMESH/SMESH_Pattern.hxx index 670578ce4..67c9093ea 100644 --- a/src/SMESH/SMESH_Pattern.hxx +++ b/src/SMESH/SMESH_Pattern.hxx @@ -1,36 +1,41 @@ -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// // File : SMESH_Pattern.hxx // Created : Mon Aug 2 10:30:00 2004 // Author : Edward AGAPOV (eap) - +// #ifndef SMESH_Pattern_HeaderFile #define SMESH_Pattern_HeaderFile +#include "SMESH_SMESH.hxx" + #include #include #include #include #include -#include +#include #include #include #include @@ -41,8 +46,8 @@ class SMDS_MeshFace; class SMDS_MeshVolume; class SMDS_MeshNode; class SMESH_Mesh; +class SMESHDS_SubMesh; class TopoDS_Shell; -class TopoDS_Vertex; class TopoDS_Face; class TopoDS_Edge; @@ -52,7 +57,7 @@ class TopoDS_Edge; // of 6 faces. // -class SMESH_Pattern { +class SMESH_EXPORT SMESH_Pattern { public: SMESH_Pattern (); @@ -65,7 +70,8 @@ class SMESH_Pattern { bool Load (SMESH_Mesh* theMesh, const TopoDS_Face& theFace, - bool theProject); + bool theProject = false, + TopoDS_Vertex the1stVertex=TopoDS_Vertex()); // Create a pattern from the mesh built on . // ==true makes override nodes positions // on computed by mesher @@ -100,9 +106,19 @@ class SMESH_Pattern { // the loaded pattern to . The first key-point // will be mapped into -th node - bool Apply (std::set theFaces, - const int theNodeIndexOnKeyPoint1, - const bool theReverse); + bool Apply (SMESH_Mesh* theMesh, + const SMDS_MeshFace* theFace, + const TopoDS_Shape& theSurface, + const int theNodeIndexOnKeyPoint1, + const bool theReverse); + // Compute nodes coordinates applying + // the loaded pattern to . The first key-point + // will be mapped into -th node + + bool Apply (SMESH_Mesh* theMesh, + std::set& theFaces, + const int theNodeIndexOnKeyPoint1, + const bool theReverse); // Compute nodes coordinates applying // the loaded pattern to . The first key-point // will be mapped into -th node @@ -116,9 +132,9 @@ class SMESH_Pattern { // (0,0,1) key-point will be mapped into -th // node. - bool Apply (std::set theVolumes, - const int theNode000Index, - const int theNode001Index); + bool Apply (std::set& theVolumes, + const int theNode000Index, + const int theNode001Index); // Compute nodes coordinates applying // the loaded pattern to . The (0,0,0) key-point // will be mapped into -th node. The @@ -128,12 +144,15 @@ class SMESH_Pattern { bool GetMappedPoints ( std::list & thePoints ) const; // Return nodes coordinates computed by Apply() method - bool MakeMesh(SMESH_Mesh* theMesh); + bool MakeMesh(SMESH_Mesh* theMesh, + const bool toCreatePolygons = false, + const bool toCreatePolyedrs = false); // Create nodes and elements in using nodes // coordinates computed by either of Apply...() methods - + // ---------- // Inquiries + // ---------- enum ErrorCode { ERR_OK, @@ -154,6 +173,7 @@ class SMESH_Pattern { // Load(face) ERR_LOADF_NARROW_FACE, // too narrow face ERR_LOADF_CLOSED_FACE, // closed face + ERR_LOADF_CANT_PROJECT, // impossible to project nodes // Load(volume) ERR_LOADV_BAD_SHAPE, // volume is not a brick of 6 faces ERR_LOADV_COMPUTE_PARAMS, // cant compute point parameters @@ -171,7 +191,9 @@ class SMESH_Pattern { // Apply(mesh_face) ERR_APPLF_BAD_FACE_GEOM, // bad face geometry // MakeMesh - ERR_MAKEM_NOT_COMPUTED // mapping failed + ERR_MAKEM_NOT_COMPUTED, // mapping failed + //Unexpected error + ERR_UNEXPECTED // Unexpected of the pattern mapping alorithm }; ErrorCode GetErrorCode() const { return myErrorCode; } @@ -197,8 +219,18 @@ class SMESH_Pattern { void DumpPoints() const; // Debug + // ----------------------------- + // Utilities for advanced usage + // ----------------------------- - private: + TopoDS_Shape GetSubShape( const int i ) const { + if ( i < 1 || i > myShapeIDMap.Extent() ) return TopoDS_Shape(); + return myShapeIDMap( i ); + } + // Return a shape from myShapeIDMap where shapes are indexed so that first go + // ordered vertices, then ordered edge, then faces and maybe a shell + +private: // private methods struct TPoint { @@ -212,58 +244,57 @@ class SMESH_Pattern { }; friend std::ostream & operator <<(std::ostream & OS, const TPoint& p); - bool setErrorCode( const ErrorCode theErrorCode ) - { myErrorCode = theErrorCode; return myErrorCode == ERR_OK; } + bool setErrorCode( const ErrorCode theErrorCode ); // set ErrorCode and return true if it is Ok bool setShapeToMesh(const TopoDS_Shape& theShape); // Set a shape to be meshed. Return True if meshing is possible - list< TPoint* > & getShapePoints(const TopoDS_Shape& theShape); + std::list< TPoint* > & getShapePoints(const TopoDS_Shape& theShape); // Return list of points located on theShape. // A list of edge-points include vertex-points (for 2D pattern only). // A list of face-points doesnt include edge-points. // A list of volume-points doesnt include face-points. - list< TPoint* > & getShapePoints(const int theShapeID); + std::list< TPoint* > & getShapePoints(const int theShapeID); // Return list of points located on the shape bool findBoundaryPoints(); // If loaded from file, find points to map on edges and faces and // compute their parameters - void arrangeBoundaries (list< list< TPoint* > >& boundaryPoints); + void arrangeBoundaries (std::list< std::list< TPoint* > >& boundaryPoints); // if there are several wires, arrange boundaryPoints so that // the outer wire goes first and fix inner wires orientation; // update myKeyPointIDs to correspond to the order of key-points // in boundaries; sort internal boundaries by the nb of key-points - void computeUVOnEdge( const TopoDS_Edge& theEdge, const list< TPoint* > & ePoints ); + void computeUVOnEdge( const TopoDS_Edge& theEdge, const std::list< TPoint* > & ePoints ); // compute coordinates of points on theEdge - bool compUVByIsoIntersection (const list< list< TPoint* > >& boundaryPoints, + bool compUVByIsoIntersection (const std::list< std::list< TPoint* > >& boundaryPoints, const gp_XY& theInitUV, gp_XY& theUV, bool & theIsDeformed); // compute UV by intersection of iso-lines found by points on edges - bool compUVByElasticIsolines(const list< list< TPoint* > >& boundaryPoints, - const list< TPoint* >& pointsToCompute); + bool compUVByElasticIsolines(const std::list< std::list< TPoint* > >& boundaryPoints, + const std::list< TPoint* >& pointsToCompute); // compute UV as nodes of iso-poly-lines consisting of // segments keeping relative size as in the pattern - double setFirstEdge (list< TopoDS_Edge > & theWire, int theFirstEdgeID); + double setFirstEdge (std::list< TopoDS_Edge > & theWire, int theFirstEdgeID); // choose the best first edge of theWire; return the summary distance // between point UV computed by isolines intersection and // eventual UV got from edge p-curves - typedef list< list< TopoDS_Edge > > TListOfEdgesList; + typedef std::list< std::list< TopoDS_Edge > > TListOfEdgesList; bool sortSameSizeWires (TListOfEdgesList & theWireList, const TListOfEdgesList::iterator& theFromWire, const TListOfEdgesList::iterator& theToWire, const int theFirstEdgeID, - list< list< TPoint* > >& theEdgesPointsList ); + std::list< std::list< TPoint* > >& theEdgesPointsList ); // sort wires in theWireList from theFromWire until theToWire, // the wires are set in the order to correspond to the order // of boundaries; after sorting, edges in the wires are put @@ -271,41 +302,93 @@ class SMESH_Pattern { // are appended to theEdgesPointsList typedef std::set TNodeSet; - void mergePoints (std::map > >& xyzIndGroups, - std::map< int, std::list< std::list< int >* > >& reverseConnectivity); - // Look for coincident points between myXYZs indexed with - // list of each element of xyzIndGroups. Coincident indices - // are merged in myElemXYZIDs using reverseConnectivity. + + void mergePoints (const bool uniteGroups); + // Merge XYZ on edges and/or faces. + + void makePolyElements(const std::vector< const SMDS_MeshNode* >& theNodes, + const bool toCreatePolygons, + const bool toCreatePolyedrs); + // prepare intermediate data to create Polygons and Polyhedrons + + void createElements(SMESH_Mesh* theMesh, + const std::vector& theNodesVector, + const std::list< std::list< int > > & theElemNodeIDs, + const std::vector& theElements); + // add elements to the mesh + + bool getFacesDefinition(const SMDS_MeshNode** theBndNodes, + const int theNbBndNodes, + const std::vector< const SMDS_MeshNode* >& theNodes, + std::list< int >& theFaceDefs, + std::vector& theQuantity); + // fill faces definition for a volume face defined by theBndNodes + // return true if a face definition changes + + + bool isReversed(const SMDS_MeshNode* theFirstNode, + const std::list< int >& theIdsList) const; + // check xyz ids order in theIdsList taking into account + // theFirstNode on a link + + void clearMesh(SMESH_Mesh* theMesh) const; + // clear mesh elements existing on myShape in theMesh + + bool findExistingNodes( SMESH_Mesh* mesh, + const TopoDS_Shape& S, + const std::list< TPoint* > & points, + std::vector< const SMDS_MeshNode* > & nodes); + // fills nodes vector with nodes existing on a given shape + + static SMESHDS_SubMesh * getSubmeshWithElements(SMESH_Mesh* theMesh, + const TopoDS_Shape& theShape); + // return submesh containing elements bound to theShape in theMesh private: // fields - bool myIs2D; - std::vector< TPoint > myPoints; - std::list< int > myKeyPointIDs; - std::list< std::list< int > > myElemPointIDs; + typedef std::list< int > TElemDef; // element definition is its nodes ids - ErrorCode myErrorCode; - bool myIsComputed; - bool myIsBoundaryPointsFound; + bool myIs2D; + std::vector< TPoint > myPoints; + std::list< int > myKeyPointIDs; + std::list< TElemDef > myElemPointIDs; - TopoDS_Shape myShape; + ErrorCode myErrorCode; + bool myIsComputed; + bool myIsBoundaryPointsFound; + + TopoDS_Shape myShape; // all functions assure that shapes are indexed so that first go // ordered vertices, then ordered edge, then faces and maybe a shell - TopTools_IndexedMapOfOrientedShape myShapeIDMap; - //TopTools_IndexedMapOfShape myShapeIDMap; - std::map< int, list< TPoint* > > myShapeIDToPointsMap; + TopTools_IndexedMapOfOrientedShape myShapeIDMap; + std::map< int, std::list< TPoint*> > myShapeIDToPointsMap; // for the 2d case: // nb of key-points in each of pattern boundaries - std::list< int > myNbKeyPntInBoundary; + std::list< int > myNbKeyPntInBoundary; + // to compute while applying to mesh elements, not to shapes - std::vector myXYZ; - std::list< std::list< int > > myElemXYZIDs; - std::map< int, const SMDS_MeshNode*> myXYZIdToNodeMap; // map id to node of a refined element - std::vector myElements; // refined elements - std::vector myOrderedNodes; + + std::vector myXYZ; // XYZ of nodes to create + std::list< TElemDef > myElemXYZIDs; // new elements definitions + std::map< int, const SMDS_MeshNode*> myXYZIdToNodeMap; // map XYZ id to node of a refined element + std::vector myElements; // refined elements + std::vector myOrderedNodes; + + // elements to replace with polygon or polyhedron + std::vector myPolyElems; + // definitions of new poly elements + std::list< TElemDef > myPolyElemXYZIDs; + std::list< std::vector > myPolyhedronQuantities; + + // map a boundary to XYZs on it; + // a boundary (edge or face) is defined as a set of its nodes, + // XYZs on a boundary are indices of myXYZ s + std::map > > myIdsOnBoundary; + // map XYZ id to element it is in + std::map< int, std::list< TElemDef* > > myReverseConnectivity; };