1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 // File : SMESH_Pattern.hxx
24 // Created : Mon Aug 2 10:30:00 2004
25 // Author : Edward AGAPOV (eap)
27 #ifndef SMESH_Pattern_HeaderFile
28 #define SMESH_Pattern_HeaderFile
30 #include "SMESH_SMESH.hxx"
38 #include <TopoDS_Vertex.hxx>
39 #include <TopTools_IndexedMapOfOrientedShape.hxx>
44 class SMDS_MeshElement;
46 class SMDS_MeshVolume;
49 class SMESHDS_SubMesh;
55 // Class allowing meshing by mapping of pre-defined patterns: it generates
56 // a 2D mesh on a geometrical face or a 3D mesh inside a geometrical block
60 class SMESH_EXPORT SMESH_Pattern {
68 bool Load (const char* theFileContents);
69 // Load a pattern from <theFileContents>
71 bool Load (SMESH_Mesh* theMesh,
72 const TopoDS_Face& theFace,
73 bool theProject = false,
74 TopoDS_Vertex the1stVertex=TopoDS_Vertex(),
75 bool theKeepNodes = false );
76 // Create a pattern from the mesh built on <theFace>.
77 // <theProject>==true makes override nodes positions
78 // on <theFace> computed by mesher
80 bool Load (SMESH_Mesh* theMesh,
81 const TopoDS_Shell& theBlock,
82 bool theKeepNodes = false);
83 // Create a pattern from the mesh built on <theBlock>
85 bool Save (std::ostream& theFile);
86 // Save the loaded pattern into theFile
88 bool Apply (const TopoDS_Face& theFace,
89 const TopoDS_Vertex& theVertexOnKeyPoint1,
90 const bool theReverse);
91 // Compute nodes coordinates applying
92 // the loaded pattern to <theFace>. The first key-point
93 // will be mapped into <theVertexOnKeyPoint1>, which must
94 // be in the outer wire of theFace
96 bool Apply (const TopoDS_Shell& theBlock,
97 const TopoDS_Vertex& theVertex000,
98 const TopoDS_Vertex& theVertex001);
99 // Compute nodes coordinates applying
100 // the loaded pattern to <theBlock>. The (0,0,0) key-point
101 // will be mapped into <theVertex000>. The
102 // (0,0,1) key-point will be mapped into <theVertex001>.
104 bool Apply (const SMDS_MeshFace* theFace,
105 const int theNodeIndexOnKeyPoint1,
106 const bool theReverse);
107 // Compute nodes coordinates applying
108 // the loaded pattern to <theFace>. The first key-point
109 // will be mapped into <theNodeIndexOnKeyPoint1>-th node
111 bool Apply (SMESH_Mesh* theMesh,
112 const SMDS_MeshFace* theFace,
113 const TopoDS_Shape& theSurface,
114 const int theNodeIndexOnKeyPoint1,
115 const bool theReverse);
116 // Compute nodes coordinates applying
117 // the loaded pattern to <theFace>. The first key-point
118 // will be mapped into <theNodeIndexOnKeyPoint1>-th node
120 bool Apply (SMESH_Mesh* theMesh,
121 std::set<const SMDS_MeshFace*>& theFaces,
122 const int theNodeIndexOnKeyPoint1,
123 const bool theReverse);
124 // Compute nodes coordinates applying
125 // the loaded pattern to <theFaces>. The first key-point
126 // will be mapped into <theNodeIndexOnKeyPoint1>-th node
128 bool Apply (const SMDS_MeshVolume* theVolume,
129 const int theNode000Index,
130 const int theNode001Index);
131 // Compute nodes coordinates applying
132 // the loaded pattern to <theVolume>. The (0,0,0) key-point
133 // will be mapped into <theNode000Index>-th node. The
134 // (0,0,1) key-point will be mapped into <theNode000Index>-th
137 bool Apply (std::set<const SMDS_MeshVolume*>& theVolumes,
138 const int theNode000Index,
139 const int theNode001Index);
140 // Compute nodes coordinates applying
141 // the loaded pattern to <theVolumes>. The (0,0,0) key-point
142 // will be mapped into <theNode000Index>-th node. The
143 // (0,0,1) key-point will be mapped into <theNode000Index>-th
146 bool GetMappedPoints ( std::list<const gp_XYZ *> & thePoints ) const;
147 // Return nodes coordinates computed by Apply() method
149 bool MakeMesh(SMESH_Mesh* theMesh,
150 const bool toCreatePolygons = false,
151 const bool toCreatePolyedrs = false);
152 // Create nodes and elements in <theMesh> using nodes
153 // coordinates computed by either of Apply...() methods
162 ERR_READ_NB_POINTS, // couldn't read nb of points
163 ERR_READ_POINT_COORDS, // invalid nb of point coordinates
164 ERR_READ_TOO_FEW_POINTS, // too few points in a pattern
165 ERR_READ_3D_COORD, // coordinate of 3D point out of [0,1] range
166 ERR_READ_NO_KEYPOINT, // no key-points in 2D pattern
167 ERR_READ_BAD_INDEX, // invalid point index
168 ERR_READ_ELEM_POINTS, // invalid nb of points in element
169 ERR_READ_NO_ELEMS, // no elements in a pattern
170 ERR_READ_BAD_KEY_POINT, // a key-point not on a boundary
172 ERR_SAVE_NOT_LOADED, // pattern was not loaded
174 ERR_LOAD_EMPTY_SUBMESH, // no elements to load
176 ERR_LOADF_NARROW_FACE, // too narrow face
177 ERR_LOADF_CLOSED_FACE, // closed face
178 ERR_LOADF_CANT_PROJECT, // impossible to project nodes
180 ERR_LOADV_BAD_SHAPE, // volume is not a brick of 6 faces
181 ERR_LOADV_COMPUTE_PARAMS, // cant compute point parameters
183 ERR_APPL_NOT_COMPUTED, // mapping failed
184 ERR_APPL_NOT_LOADED, // pattern was not loaded
185 ERR_APPL_BAD_DIMENTION, // wrong shape dimention
186 ERR_APPL_BAD_NB_VERTICES, // keypoints - vertices mismatch
188 ERR_APPLF_BAD_TOPOLOGY, // bad pattern topology
189 ERR_APPLF_BAD_VERTEX, // first vertex not on an outer face boundary
190 ERR_APPLF_INTERNAL_EEROR, // program error
192 ERR_APPLV_BAD_SHAPE, // volume is not a brick of 6 faces
194 ERR_APPLF_BAD_FACE_GEOM, // bad face geometry
196 ERR_MAKEM_NOT_COMPUTED, // mapping failed
198 ERR_UNEXPECTED // Unexpected of the pattern mapping alorithm
201 ErrorCode GetErrorCode() const { return myErrorCode; }
202 // return ErrorCode of the last operation
204 bool IsLoaded() const { return !myPoints.empty() && !myElemPointIDs.empty(); }
205 // Return true if a pattern was successfully loaded
207 bool Is2D() const { return myIs2D; }
208 // Return true if the loaded pattern is a 2D one
210 bool GetPoints ( std::list<const gp_XYZ *> & thePoints ) const;
211 // Return nodes coordinates of the pattern
213 const std::list< int > & GetKeyPointIDs () const { return myKeyPointIDs; }
214 // Return indices of key-points within the sequences returned by
215 // GetPoints() and GetMappedPoints()
217 const std::list< std::list< int > >& GetElementPointIDs (bool applied) const
218 { return myElemXYZIDs.empty() || !applied ? myElemPointIDs : myElemXYZIDs; }
219 // Return nodal connectivity of the elements of the pattern
221 void GetInOutNodes( std::vector< const SMDS_MeshNode* > *& inNodes,
222 std::vector< const SMDS_MeshNode* > *& outNodes )
223 { inNodes = & myInNodes; outNodes = & myOutNodes; }
224 // Return loaded and just created nodes
226 void DumpPoints() const;
229 // -----------------------------
230 // Utilities for advanced usage
231 // -----------------------------
233 TopoDS_Shape GetSubShape( const int i ) const {
234 if ( i < 1 || i > myShapeIDMap.Extent() ) return TopoDS_Shape();
235 return myShapeIDMap( i );
237 // Return a shape from myShapeIDMap where shapes are indexed so that first go
238 // ordered vertices, then ordered edge, then faces and maybe a shell
244 gp_XYZ myInitXYZ; // loaded postion
246 double myInitU; // [0,1]
247 gp_Pnt myXYZ; // position to compute
252 friend std::ostream & operator <<(std::ostream & OS, const TPoint& p);
254 bool setErrorCode( const ErrorCode theErrorCode );
255 // set ErrorCode and return true if it is Ok
257 bool setShapeToMesh(const TopoDS_Shape& theShape);
258 // Set a shape to be meshed. Return True if meshing is possible
260 std::list< TPoint* > & getShapePoints(const TopoDS_Shape& theShape);
261 // Return list of points located on theShape.
262 // A list of edge-points include vertex-points (for 2D pattern only).
263 // A list of face-points doesnt include edge-points.
264 // A list of volume-points doesnt include face-points.
266 std::list< TPoint* > & getShapePoints(const int theShapeID);
267 // Return list of points located on the shape
269 bool findBoundaryPoints();
270 // If loaded from file, find points to map on edges and faces and
271 // compute their parameters
273 void arrangeBoundaries (std::list< std::list< TPoint* > >& boundaryPoints);
274 // if there are several wires, arrange boundaryPoints so that
275 // the outer wire goes first and fix inner wires orientation;
276 // update myKeyPointIDs to correspond to the order of key-points
277 // in boundaries; sort internal boundaries by the nb of key-points
279 void computeUVOnEdge( const TopoDS_Edge& theEdge, const std::list< TPoint* > & ePoints );
280 // compute coordinates of points on theEdge
282 bool compUVByIsoIntersection (const std::list< std::list< TPoint* > >& boundaryPoints,
283 const gp_XY& theInitUV,
285 bool & theIsDeformed);
286 // compute UV by intersection of iso-lines found by points on edges
288 bool compUVByElasticIsolines(const std::list< std::list< TPoint* > >& boundaryPoints,
289 const std::list< TPoint* >& pointsToCompute);
290 // compute UV as nodes of iso-poly-lines consisting of
291 // segments keeping relative size as in the pattern
293 double setFirstEdge (std::list< TopoDS_Edge > & theWire, int theFirstEdgeID);
294 // choose the best first edge of theWire; return the summary distance
295 // between point UV computed by isolines intersection and
296 // eventual UV got from edge p-curves
298 typedef std::list< std::list< TopoDS_Edge > > TListOfEdgesList;
300 bool sortSameSizeWires (TListOfEdgesList & theWireList,
301 const TListOfEdgesList::iterator& theFromWire,
302 const TListOfEdgesList::iterator& theToWire,
303 const int theFirstEdgeID,
304 std::list< std::list< TPoint* > >& theEdgesPointsList );
305 // sort wires in theWireList from theFromWire until theToWire,
306 // the wires are set in the order to correspond to the order
307 // of boundaries; after sorting, edges in the wires are put
308 // in a good order, point UVs on edges are computed and points
309 // are appended to theEdgesPointsList
311 typedef std::set<const SMDS_MeshNode*> TNodeSet;
313 void mergePoints (const bool uniteGroups);
314 // Merge XYZ on edges and/or faces.
316 void makePolyElements(const std::vector< const SMDS_MeshNode* >& theNodes,
317 const bool toCreatePolygons,
318 const bool toCreatePolyedrs);
319 // prepare intermediate data to create Polygons and Polyhedrons
321 void createElements(SMESH_Mesh* theMesh,
322 const std::vector<const SMDS_MeshNode* >& theNodesVector,
323 const std::list< std::list< int > > & theElemNodeIDs,
324 const std::vector<const SMDS_MeshElement*>& theElements);
325 // add elements to the mesh
327 bool getFacesDefinition(const SMDS_MeshNode** theBndNodes,
328 const int theNbBndNodes,
329 const std::vector< const SMDS_MeshNode* >& theNodes,
330 std::list< int >& theFaceDefs,
331 std::vector<int>& theQuantity);
332 // fill faces definition for a volume face defined by theBndNodes
333 // return true if a face definition changes
336 bool isReversed(const SMDS_MeshNode* theFirstNode,
337 const std::list< int >& theIdsList) const;
338 // check xyz ids order in theIdsList taking into account
339 // theFirstNode on a link
341 void clearMesh(SMESH_Mesh* theMesh) const;
342 // clear mesh elements existing on myShape in theMesh
344 bool findExistingNodes( SMESH_Mesh* mesh,
345 const TopoDS_Shape& S,
346 const std::list< TPoint* > & points,
347 std::vector< const SMDS_MeshNode* > & nodes);
348 // fills nodes vector with nodes existing on a given shape
350 static SMESHDS_SubMesh * getSubmeshWithElements(SMESH_Mesh* theMesh,
351 const TopoDS_Shape& theShape);
352 // return submesh containing elements bound to theShape in theMesh
357 typedef std::list< int > TElemDef; // element definition is its nodes ids
360 std::vector< TPoint > myPoints;
361 std::list< int > myKeyPointIDs;
362 std::list< TElemDef > myElemPointIDs;
364 ErrorCode myErrorCode;
366 bool myIsBoundaryPointsFound;
368 TopoDS_Shape myShape;
369 // all functions assure that shapes are indexed so that first go
370 // ordered vertices, then ordered edge, then faces and maybe a shell
371 TopTools_IndexedMapOfOrientedShape myShapeIDMap;
372 std::map< int, std::list< TPoint*> > myShapeIDToPointsMap;
375 // nb of key-points in each of pattern boundaries
376 std::list< int > myNbKeyPntInBoundary;
378 // nodes corresponding to myPoints
379 bool myToKeepNodes; // to keep these data
380 std::vector< const SMDS_MeshNode* > myInNodes; // loaded nodes
381 std::vector< const SMDS_MeshNode* > myOutNodes; // created nodes
383 // to compute while applying to mesh elements, not to shapes
385 std::vector<gp_XYZ> myXYZ; // XYZ of nodes to create
386 std::list< TElemDef > myElemXYZIDs; // new elements definitions
387 std::map< int, const SMDS_MeshNode*> myXYZIdToNodeMap; // map XYZ id to node of a refined element
388 std::vector<const SMDS_MeshElement*> myElements; // refined elements
389 std::vector<const SMDS_MeshNode*> myOrderedNodes;
391 // elements to replace with polygon or polyhedron
392 std::vector<const SMDS_MeshElement*> myPolyElems;
393 // definitions of new poly elements
394 std::list< TElemDef > myPolyElemXYZIDs;
395 std::list< std::vector<int> > myPolyhedronQuantities;
397 // map a boundary to XYZs on it;
398 // a boundary (edge or face) is defined as a set of its nodes,
399 // XYZs on a boundary are indices of myXYZ s
400 std::map<TNodeSet,std::list<std::list<int> > > myIdsOnBoundary;
401 // map XYZ id to element it is in
402 std::map< int, std::list< TElemDef* > > myReverseConnectivity;