SALOME - SMESH
SMESH_MeshEditor.hxx
Go to the documentation of this file.
1 // Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
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.
10 //
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.
15 //
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
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22 // SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
23 // File : SMESH_MeshEditor.hxx
24 // Created : Mon Apr 12 14:56:19 2004
25 // Author : Edward AGAPOV (eap)
26 // Module : SMESH
27 //
28 #ifndef SMESH_MeshEditor_HeaderFile
29 #define SMESH_MeshEditor_HeaderFile
30 
31 #include "Standard_Version.hxx"
32 
33 #include "SMESH_SMESH.hxx"
34 
35 #include "SMDS_MeshElement.hxx"
36 #include "SMESH_Controls.hxx"
37 #include "SMESH_Mesh.hxx"
39 #include "SMESH_SequenceOfNode.hxx"
40 
41 #include <TColStd_HSequenceOfReal.hxx>
42 #include <gp_Dir.hxx>
43 
44 #include <list>
45 #include <map>
46 #include <set>
47 
48 class SMDS_MeshFace;
49 class SMDS_MeshNode;
50 class gp_Ax1;
51 class gp_Vec;
52 class gp_Pnt;
54 
55 
56 typedef std::map<const SMDS_MeshElement*,
57  std::list<const SMDS_MeshElement*> > TElemOfElemListMap;
58 typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*> TNodeNodeMap;
59 
61 typedef std::set< const SMDS_MeshElement*, TIDCompare > TIDSortedElemSet;
62 
63 typedef pair< const SMDS_MeshNode*, const SMDS_MeshNode* > NLink;
64 
65 
66 //=======================================================================
70 //=======================================================================
72 {
73  virtual const SMDS_MeshNode* FindClosestTo( const gp_Pnt& pnt ) = 0;
74  virtual void MoveNode( const SMDS_MeshNode* node, const gp_Pnt& toPnt ) = 0;
75 };
76 
77 //=======================================================================
83 //=======================================================================
84 
86 {
87  virtual void FindElementsByPoint(const gp_Pnt& point,
89  std::vector< const SMDS_MeshElement* >& foundElems)=0;
90 };
91 
92 //=======================================================================
96 //=======================================================================
97 
98 struct SMESH_TLink: public NLink
99 {
100  SMESH_TLink(const SMDS_MeshNode* n1, const SMDS_MeshNode* n2 ):NLink( n1, n2 )
101  { if ( n1->GetID() < n2->GetID() ) std::swap( first, second ); }
102  SMESH_TLink(const NLink& link ):NLink( link )
103  { if ( first->GetID() < second->GetID() ) std::swap( first, second ); }
104  const SMDS_MeshNode* node1() const { return first; }
105  const SMDS_MeshNode* node2() const { return second; }
106 };
107 
108 //=======================================================================
112 //=======================================================================
114 public:
116  myPnt.SetCoord(99., 99., 99.);
117  myTgt.SetCoord(1.,0.,0.);
118  myAngle=0.;
119  myPrm=0.;
120  }
121  void SetPnt(const gp_Pnt& aP3D){
122  myPnt=aP3D;
123  }
124  void SetTangent(const gp_Dir& aTgt){
125  myTgt=aTgt;
126  }
127  void SetAngle(const double& aBeta){
128  myAngle=aBeta;
129  }
130  void SetParameter(const double& aPrm){
131  myPrm=aPrm;
132  }
133  const gp_Pnt& Pnt()const{
134  return myPnt;
135  }
136  const gp_Dir& Tangent()const{
137  return myTgt;
138  }
139  double Angle()const{
140  return myAngle;
141  }
142  double Parameter()const{
143  return myPrm;
144  }
145 
146 protected:
147  gp_Pnt myPnt;
148  gp_Dir myTgt;
149  double myAngle;
150  double myPrm;
151 };
152 
153 
154 // ============================================================
158 // ============================================================
159 
161 
162 public:
163 
164  SMESH_MeshEditor( SMESH_Mesh* theMesh );
165 
169  SMDS_MeshElement* AddElement(const std::vector<const SMDS_MeshNode*> & nodes,
170  const SMDSAbs_ElementType type,
171  const bool isPoly,
172  const int ID = 0);
176  SMDS_MeshElement* AddElement(const std::vector<int> & nodeIDs,
177  const SMDSAbs_ElementType type,
178  const bool isPoly,
179  const int ID = 0);
180 
181  bool Remove (const std::list< int >& theElemIDs, const bool isNodes);
182  // Remove a node or an element.
183  // Modify a compute state of sub-meshes which become empty
184 
185  bool InverseDiag (const SMDS_MeshElement * theTria1,
186  const SMDS_MeshElement * theTria2 );
187  // Replace two neighbour triangles with ones built on the same 4 nodes
188  // but having other common link.
189  // Return False if args are improper
190 
191  bool InverseDiag (const SMDS_MeshNode * theNode1,
192  const SMDS_MeshNode * theNode2 );
193  // Replace two neighbour triangles sharing theNode1-theNode2 link
194  // with ones built on the same 4 nodes but having other common link.
195  // Return false if proper faces not found
196 
197  bool DeleteDiag (const SMDS_MeshNode * theNode1,
198  const SMDS_MeshNode * theNode2 );
199  // Replace two neighbour triangles sharing theNode1-theNode2 link
200  // with a quadrangle built on the same 4 nodes.
201  // Return false if proper faces not found
202 
203  bool Reorient (const SMDS_MeshElement * theElement);
204  // Reverse theElement orientation
205 
206 
215  bool TriToQuad (TIDSortedElemSet & theElems,
217  const double theMaxAngle);
218 
225  bool QuadToTri (TIDSortedElemSet & theElems,
227 
234  bool QuadToTri (TIDSortedElemSet & theElems,
235  const bool the13Diag);
236 
243  int BestSplit (const SMDS_MeshElement* theQuad,
245 
246 
247  enum SmoothMethod { LAPLACIAN = 0, CENTROIDAL };
248 
249  void Smooth (TIDSortedElemSet & theElements,
250  std::set<const SMDS_MeshNode*> & theFixedNodes,
251  const SmoothMethod theSmoothMethod,
252  const int theNbIterations,
253  double theTgtAspectRatio = 1.0,
254  const bool the2D = true);
255  // Smooth theElements using theSmoothMethod during theNbIterations
256  // or until a worst element has aspect ratio <= theTgtAspectRatio.
257  // Aspect Ratio varies in range [1.0, inf].
258  // If theElements is empty, the whole mesh is smoothed.
259  // theFixedNodes contains additionally fixed nodes. Nodes built
260  // on edges and boundary nodes are always fixed.
261  // If the2D, smoothing is performed using UV parameters of nodes
262  // on geometrical faces
263 
264  typedef std::auto_ptr< std::list<int> > PGroupIDs;
265 
266  PGroupIDs RotationSweep (TIDSortedElemSet & theElements,
267  const gp_Ax1& theAxis,
268  const double theAngle,
269  const int theNbSteps,
270  const double theToler,
271  const bool theMakeGroups,
272  const bool theMakeWalls=true);
273  // Generate new elements by rotation of theElements around theAxis
274  // by theAngle by theNbSteps
275 
282  EXTRUSION_FLAG_BOUNDARY = 0x01,
283  EXTRUSION_FLAG_SEW = 0x02
284  };
285 
289  struct ExtrusParam {
290  gp_Dir myDir; // direction of extrusion
291  Handle(TColStd_HSequenceOfReal) mySteps; // magnitudes for each step
292  SMESH_SequenceOfNode myNodes; // nodes for using in sewing
293  };
294 
299  const SMDS_MeshNode* CreateNode(const double x,
300  const double y,
301  const double z,
302  const double tolnode,
303  SMESH_SequenceOfNode& aNodes);
304 
317  PGroupIDs ExtrusionSweep (TIDSortedElemSet & theElems,
318  const gp_Vec& theStep,
319  const int theNbSteps,
320  TElemOfElemListMap& newElemsMap,
321  const bool theMakeGroups,
322  const int theFlags = EXTRUSION_FLAG_BOUNDARY,
323  const double theTolerance = 1.e-6);
324 
335  PGroupIDs ExtrusionSweep (TIDSortedElemSet & theElems,
336  ExtrusParam& theParams,
337  TElemOfElemListMap& newElemsMap,
338  const bool theMakeGroups,
339  const int theFlags,
340  const double theTolerance);
341 
342 
343  // Generate new elements by extrusion of theElements
344  // by theStep by theNbSteps
345 
353  EXTR_CANT_GET_TANGENT
354  };
355 
356  Extrusion_Error ExtrusionAlongTrack (TIDSortedElemSet & theElements,
357  SMESH_subMesh* theTrackPattern,
358  const SMDS_MeshNode* theNodeStart,
359  const bool theHasAngles,
360  std::list<double>& theAngles,
361  const bool theLinearVariation,
362  const bool theHasRefPoint,
363  const gp_Pnt& theRefPoint,
364  const bool theMakeGroups);
365  Extrusion_Error ExtrusionAlongTrack (TIDSortedElemSet & theElements,
366  SMESH_Mesh* theTrackPattern,
367  const SMDS_MeshNode* theNodeStart,
368  const bool theHasAngles,
369  std::list<double>& theAngles,
370  const bool theLinearVariation,
371  const bool theHasRefPoint,
372  const gp_Pnt& theRefPoint,
373  const bool theMakeGroups);
374  // Generate new elements by extrusion of theElements along path given by theTrackPattern,
375  // theHasAngles are the rotation angles, base point can be given by theRefPoint
376 
377  PGroupIDs Transform (TIDSortedElemSet & theElements,
378  const gp_Trsf& theTrsf,
379  const bool theCopy,
380  const bool theMakeGroups,
381  SMESH_Mesh* theTargetMesh=0);
382  // Move or copy theElements applying theTrsf to their nodes
383 
384 
385  typedef std::list< std::list< const SMDS_MeshNode* > > TListOfListOfNodes;
386 
387  void FindCoincidentNodes (std::set<const SMDS_MeshNode*> & theNodes,
388  const double theTolerance,
389  TListOfListOfNodes & theGroupsOfNodes);
390  // Return list of group of nodes close to each other within theTolerance.
391  // Search among theNodes or in the whole mesh if theNodes is empty.
392 
396  SMESH_NodeSearcher* GetNodeSearcher();
397 
401  SMESH_ElementSearcher* GetElementSearcher();
405  static bool isOut( const SMDS_MeshElement* element, const gp_Pnt& point, double tol );
406 
407 
408  int SimplifyFace (const std::vector<const SMDS_MeshNode *> faceNodes,
409  std::vector<const SMDS_MeshNode *>& poly_nodes,
410  std::vector<int>& quantities) const;
411  // Split face, defined by <faceNodes>, into several faces by repeating nodes.
412  // Is used by MergeNodes()
413 
414  void MergeNodes (TListOfListOfNodes & theNodeGroups);
415  // In each group, the cdr of nodes are substituted by the first one
416  // in all elements.
417 
418  typedef std::list< std::list< int > > TListOfListOfElementsID;
419 
420  void FindEqualElements(std::set<const SMDS_MeshElement*> & theElements,
421  TListOfListOfElementsID & theGroupsOfElementsID);
422  // Return list of group of elements build on the same nodes.
423  // Search among theElements or in the whole mesh if theElements is empty.
424 
425  void MergeElements(TListOfListOfElementsID & theGroupsOfElementsID);
426  // In each group remove all but first of elements.
427 
428  void MergeEqualElements();
429  // Remove all but one of elements built on the same nodes.
430  // Return nb of successfully merged groups.
431 
432  static bool CheckFreeBorderNodes(const SMDS_MeshNode* theNode1,
433  const SMDS_MeshNode* theNode2,
434  const SMDS_MeshNode* theNode3 = 0);
435  // Return true if the three nodes are on a free border
436 
437  static bool FindFreeBorder (const SMDS_MeshNode* theFirstNode,
438  const SMDS_MeshNode* theSecondNode,
439  const SMDS_MeshNode* theLastNode,
440  std::list< const SMDS_MeshNode* > & theNodes,
441  std::list< const SMDS_MeshElement* >& theFaces);
442  // Return nodes and faces of a free border if found
443 
444  enum Sew_Error {
446  // for SewFreeBorder()
452  // for SewSideElements()
457  SEW_INTERNAL_ERROR
458  };
459 
460 
461  Sew_Error SewFreeBorder (const SMDS_MeshNode* theBorderFirstNode,
462  const SMDS_MeshNode* theBorderSecondNode,
463  const SMDS_MeshNode* theBorderLastNode,
464  const SMDS_MeshNode* theSide2FirstNode,
465  const SMDS_MeshNode* theSide2SecondNode,
466  const SMDS_MeshNode* theSide2ThirdNode = 0,
467  const bool theSide2IsFreeBorder = true,
468  const bool toCreatePolygons = false,
469  const bool toCreatePolyedrs = false);
470  // Sew the free border to the side2 by replacing nodes in
471  // elements on the free border with nodes of the elements
472  // of the side 2. If nb of links in the free border and
473  // between theSide2FirstNode and theSide2LastNode are different,
474  // additional nodes are inserted on a link provided that no
475  // volume elements share the splitted link.
476  // The side 2 is a free border if theSide2IsFreeBorder == true.
477  // Sewing is peformed between the given first, second and last
478  // nodes on the sides.
479  // theBorderFirstNode is merged with theSide2FirstNode.
480  // if (!theSide2IsFreeBorder) then theSide2SecondNode gives
481  // the last node on the side 2, which will be merged with
482  // theBorderLastNode.
483  // if (theSide2IsFreeBorder) then theSide2SecondNode will
484  // be merged with theBorderSecondNode.
485  // if (theSide2IsFreeBorder && theSide2ThirdNode == 0) then
486  // the 2 free borders are sewn link by link and no additional
487  // nodes are inserted.
488  // Return false, if sewing failed.
489 
490  Sew_Error SewSideElements (TIDSortedElemSet& theSide1,
491  TIDSortedElemSet& theSide2,
492  const SMDS_MeshNode* theFirstNode1ToMerge,
493  const SMDS_MeshNode* theFirstNode2ToMerge,
494  const SMDS_MeshNode* theSecondNode1ToMerge,
495  const SMDS_MeshNode* theSecondNode2ToMerge);
496  // Sew two sides of a mesh. Nodes belonging to theSide1 are
497  // merged with nodes of elements of theSide2.
498  // Number of elements in theSide1 and in theSide2 must be
499  // equal and they should have similar node connectivity.
500  // The nodes to merge should belong to side s borders and
501  // the first node should be linked to the second.
502 
503  void InsertNodesIntoLink(const SMDS_MeshElement* theFace,
504  const SMDS_MeshNode* theBetweenNode1,
505  const SMDS_MeshNode* theBetweenNode2,
506  std::list<const SMDS_MeshNode*>& theNodesToInsert,
507  const bool toCreatePoly = false);
508  // insert theNodesToInsert into theFace between theBetweenNode1 and theBetweenNode2.
509  // If toCreatePoly is true, replace theFace by polygon, else split theFace.
510 
511  void UpdateVolumes (const SMDS_MeshNode* theBetweenNode1,
512  const SMDS_MeshNode* theBetweenNode2,
513  std::list<const SMDS_MeshNode*>& theNodesToInsert);
514  // insert theNodesToInsert into all volumes, containing link
515  // theBetweenNode1 - theBetweenNode2, between theBetweenNode1 and theBetweenNode2.
516 
517  void ConvertToQuadratic(const bool theForce3d);
518  //converts all mesh to quadratic one, deletes old elements, replacing
519  //them with quadratic ones with the same id.
520 
521  bool ConvertFromQuadratic();
522  //converts all mesh from quadratic to ordinary ones, deletes old quadratic elements, replacing
523  //them with ordinary mesh elements with the same id.
524 
525 
526 // static int SortQuadNodes (const SMDS_Mesh * theMesh,
527 // int theNodeIds[] );
528 // // Set 4 nodes of a quadrangle face in a good order.
529 // // Swap 1<->2 or 2<->3 nodes and correspondingly return
530 // // 1 or 2 else 0.
531 //
532 // static bool SortHexaNodes (const SMDS_Mesh * theMesh,
533 // int theNodeIds[] );
534 // // Set 8 nodes of a hexahedron in a good order.
535 // // Return success status
536 
537  static void AddToSameGroups (const SMDS_MeshElement* elemToAdd,
538  const SMDS_MeshElement* elemInGroups,
539  SMESHDS_Mesh * aMesh);
540  // Add elemToAdd to the all groups the elemInGroups belongs to
541 
542  static void RemoveElemFromGroups (const SMDS_MeshElement* element,
543  SMESHDS_Mesh * aMesh);
544  // remove element from the all groups
545 
546  static void ReplaceElemInGroups (const SMDS_MeshElement* elemToRm,
547  const SMDS_MeshElement* elemToAdd,
548  SMESHDS_Mesh * aMesh);
549  // replace elemToRm by elemToAdd in the all groups
550 
554  static void GetLinkedNodes( const SMDS_MeshNode* node,
555  TIDSortedElemSet & linkedNodes,
557 
558  static const SMDS_MeshElement*
559  FindFaceInSet(const SMDS_MeshNode* n1,
560  const SMDS_MeshNode* n2,
561  const TIDSortedElemSet& elemSet,
562  const TIDSortedElemSet& avoidSet);
563  // Return a face having linked nodes n1 and n2 and which is
564  // - not in avoidSet,
565  // - in elemSet provided that !elemSet.empty()
566 
578  static Sew_Error FindMatchingNodes(std::set<const SMDS_MeshElement*>& theSide1,
579  std::set<const SMDS_MeshElement*>& theSide2,
580  const SMDS_MeshNode* theFirstNode1,
581  const SMDS_MeshNode* theFirstNode2,
582  const SMDS_MeshNode* theSecondNode1,
583  const SMDS_MeshNode* theSecondNode2,
584  TNodeNodeMap & nReplaceMap);
585 
592  static bool IsMedium(const SMDS_MeshNode* node,
593  const SMDSAbs_ElementType typeToCheck = SMDSAbs_All);
594 
595  int FindShape (const SMDS_MeshElement * theElem);
596  // Return an index of the shape theElem is on
597  // or zero if a shape not found
598 
599  SMESH_Mesh * GetMesh() { return myMesh; }
600 
601  SMESHDS_Mesh * GetMeshDS() { return myMesh->GetMeshDS(); }
602 
603  const SMESH_SequenceOfElemPtr& GetLastCreatedNodes() const { return myLastCreatedNodes; }
604 
605  const SMESH_SequenceOfElemPtr& GetLastCreatedElems() const { return myLastCreatedElems; }
606 
607  bool DoubleNodes( const std::list< int >& theListOfNodes,
608  const std::list< int >& theListOfModifiedElems );
609 
610  bool DoubleNodes( const TIDSortedElemSet& theElems,
611  const TIDSortedElemSet& theNodesNot,
612  const TIDSortedElemSet& theAffectedElems );
613 
614  bool DoubleNodesInRegion( const TIDSortedElemSet& theElems,
615  const TIDSortedElemSet& theNodesNot,
616  const TopoDS_Shape& theShape );
617 
623  bool Make2DMeshFrom3D();
624 
625 private:
626 
631  int convertElemToQuadratic(SMESHDS_SubMesh * theSm,
632  SMESH_MesherHelper& theHelper,
633  const bool theForce3d);
634 
639  int removeQuadElem( SMESHDS_SubMesh * theSm,
640  SMDS_ElemIteratorPtr theItr,
641  const int theShapeID);
648  PGroupIDs generateGroups(const SMESH_SequenceOfElemPtr& nodeGens,
649  const SMESH_SequenceOfElemPtr& elemGens,
650  const std::string& postfix,
651  SMESH_Mesh* targetMesh=0);
652 
653 
654  typedef std::map<const SMDS_MeshNode*, std::list<const SMDS_MeshNode*> > TNodeOfNodeListMap;
655  typedef TNodeOfNodeListMap::iterator TNodeOfNodeListMapItr;
656  typedef std::vector<TNodeOfNodeListMapItr> TVecOfNnlmiMap;
657  typedef std::map<const SMDS_MeshElement*, TVecOfNnlmiMap > TElemOfVecOfNnlmiMap;
658 
667  void sweepElement(const SMDS_MeshElement* elem,
668  const std::vector<TNodeOfNodeListMapItr> & newNodesItVec,
669  std::list<const SMDS_MeshElement*>& newElems,
670  const int nbSteps,
671  SMESH_SequenceOfElemPtr& srcElements);
672 
682  void makeWalls (TNodeOfNodeListMap & mapNewNodes,
683  TElemOfElemListMap & newElemsMap,
684  TElemOfVecOfNnlmiMap & elemNewNodesMap,
685  TIDSortedElemSet& elemSet,
686  const int nbSteps,
687  SMESH_SequenceOfElemPtr& srcElements);
688 
692  Extrusion_Error MakeEdgePathPoints(std::list<double>& aPrms,
693  const TopoDS_Edge& aTrackEdge,
694  bool FirstIsStart,
695  list<SMESH_MeshEditor_PathPoint>& LPP);
696  Extrusion_Error MakeExtrElements(TIDSortedElemSet& theElements,
697  list<SMESH_MeshEditor_PathPoint>& fullList,
698  const bool theHasAngles,
699  list<double>& theAngles,
700  const bool theLinearVariation,
701  const bool theHasRefPoint,
702  const gp_Pnt& theRefPoint,
703  const bool theMakeGroups);
704  void LinearAngleVariation(const int NbSteps,
705  list<double>& theAngles);
706 
707  bool doubleNodes( SMESHDS_Mesh* theMeshDS,
708  const TIDSortedElemSet& theElems,
709  const TIDSortedElemSet& theNodesNot,
710  std::map< const SMDS_MeshNode*,
711  const SMDS_MeshNode* >& theNodeNodeMap,
712  const bool theIsDoubleElem );
713 
714 private:
715 
717 
722 
727 
728 };
729 
730 #endif
const SMESH_SequenceOfElemPtr & GetLastCreatedElems() const
void SetTangent(const gp_Dir &aTgt)
std::vector< TNodeOfNodeListMapItr > TVecOfNnlmiMap
Return elements of given type where the given point is IN or ON.
boost::shared_ptr< NumericalFunctor > NumericalFunctorPtr
const gp_Pnt & Pnt() const
std::map< const SMDS_MeshNode *, std::list< const SMDS_MeshNode * > > TNodeOfNodeListMap
boost::shared_ptr< SMDS_Iterator< const SMDS_MeshElement * > > SMDS_ElemIteratorPtr
const SMESH_SequenceOfElemPtr & GetLastCreatedNodes() const
virtual const SMDS_MeshNode * FindClosestTo(const gp_Pnt &pnt)=0
SMESH_SequenceOfElemPtr myLastCreatedNodes
void SetParameter(const double &aPrm)
SMESH_SequenceOfElemPtr myLastCreatedElems
Editor of a mesh.
SMDSAbs_ElementType
Type (node, edge, face or volume) of elements.
NCollection_Sequence< SMDS_MeshElementPtr > SMESH_SequenceOfElemPtr
int GetID() const
void SetAngle(const double &aBeta)
pair< const SMDS_MeshNode *, const SMDS_MeshNode *> NLink
std::auto_ptr< std::list< int > > PGroupIDs
const gp_Dir & Tangent() const
void SetPnt(const gp_Pnt &aP3D)
std::set< const SMDS_MeshElement *, TIDCompare > TIDSortedElemSet
SMESH_Mesh * GetMesh()
std::list< std::list< int > > TListOfListOfElementsID
std::map< const SMDS_MeshNode *, const SMDS_MeshNode * > TNodeNodeMap
Set of elements sorted by ID, to be used to assure predictability of edition.
Base class for elements.
#define SMESH_EXPORT
Definition: SMESH_SMESH.hxx:36
virtual void FindElementsByPoint(const gp_Pnt &point, SMDSAbs_ElementType type, std::vector< const SMDS_MeshElement * > &foundElems)=0
NCollection_Sequence< SMDS_MeshNodePtr > SMESH_SequenceOfNode
Searcher for the node closest to point.
std::map< const SMDS_MeshElement *, TVecOfNnlmiMap > TElemOfVecOfNnlmiMap
virtual void MoveNode(const SMDS_MeshNode *node, const gp_Pnt &toPnt)=0
std::list< std::list< const SMDS_MeshNode *> > TListOfListOfNodes
TNodeOfNodeListMap::iterator TNodeOfNodeListMapItr
std::map< const SMDS_MeshElement *, std::list< const SMDS_MeshElement * > > TElemOfElemListMap
SMESHDS_Mesh * GetMeshDS()