SALOME - SMESH
SMESH_MeshEditor.hxx
Go to the documentation of this file.
00001 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 //  This library is free software; you can redistribute it and/or
00007 //  modify it under the terms of the GNU Lesser General Public
00008 //  License as published by the Free Software Foundation; either
00009 //  version 2.1 of the License.
00010 //
00011 //  This library is distributed in the hope that it will be useful,
00012 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 //  Lesser General Public License for more details.
00015 //
00016 //  You should have received a copy of the GNU Lesser General Public
00017 //  License along with this library; if not, write to the Free Software
00018 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 //  SMESH SMESH_I : idl implementation based on 'SMESH' unit's calsses
00023 // File      : SMESH_MeshEditor.hxx
00024 // Created   : Mon Apr 12 14:56:19 2004
00025 // Author    : Edward AGAPOV (eap)
00026 // Module    : SMESH
00027 //
00028 #ifndef SMESH_MeshEditor_HeaderFile
00029 #define SMESH_MeshEditor_HeaderFile
00030 
00031 #include "SMESH_SMESH.hxx"
00032 
00033 #include "SMDS_MeshElement.hxx"
00034 #include "SMESH_Controls.hxx"
00035 #include "SMESH_Mesh.hxx"
00036 #include "SMESH_SequenceOfElemPtr.hxx"
00037 #include "SMESH_SequenceOfNode.hxx"
00038 
00039 #include <TColStd_HSequenceOfReal.hxx>
00040 #include <gp_Dir.hxx>
00041 
00042 #include <list>
00043 #include <map>
00044 #include <set>
00045 
00046 class SMDS_MeshFace;
00047 class SMDS_MeshNode;
00048 class gp_Ax1;
00049 class gp_Vec;
00050 class gp_Pnt;
00051 class SMESH_MesherHelper;
00052 
00053 
00054 typedef std::map<const SMDS_MeshElement*,
00055                  std::list<const SMDS_MeshElement*> >        TElemOfElemListMap;
00056 typedef std::map<const SMDS_MeshNode*, const SMDS_MeshNode*> TNodeNodeMap;
00057 
00059 typedef std::set< const SMDS_MeshElement*, TIDCompare >      TIDSortedElemSet;
00060 
00061 typedef pair< const SMDS_MeshNode*, const SMDS_MeshNode* >   NLink;
00062 
00063 
00064 //=======================================================================
00068 //=======================================================================
00069 struct SMESH_NodeSearcher
00070 {
00071   virtual const SMDS_MeshNode* FindClosestTo( const gp_Pnt& pnt ) = 0;
00072   virtual void MoveNode( const SMDS_MeshNode* node, const gp_Pnt& toPnt ) = 0;
00073 };
00074 
00075 //=======================================================================
00081 //=======================================================================
00082 
00083 struct SMESH_ElementSearcher
00084 {
00085   virtual void FindElementsByPoint(const gp_Pnt&                           point,
00086                                    SMDSAbs_ElementType                     type,
00087                                    std::vector< const SMDS_MeshElement* >& foundElems)=0;
00088 };
00089 
00090 //=======================================================================
00094 //=======================================================================
00095 
00096 struct SMESH_TLink: public NLink
00097 {
00098   SMESH_TLink(const SMDS_MeshNode* n1, const SMDS_MeshNode* n2 ):NLink( n1, n2 )
00099   { if ( n1->GetID() < n2->GetID() ) std::swap( first, second ); }
00100   SMESH_TLink(const NLink& link ):NLink( link )
00101   { if ( first->GetID() < second->GetID() ) std::swap( first, second ); }
00102   const SMDS_MeshNode* node1() const { return first; }
00103   const SMDS_MeshNode* node2() const { return second; }
00104 };
00105 
00106 //=======================================================================
00110 //=======================================================================
00111 class SMESH_MeshEditor_PathPoint {
00112 public:
00113   SMESH_MeshEditor_PathPoint() {
00114     myPnt.SetCoord(99., 99., 99.);
00115     myTgt.SetCoord(1.,0.,0.);
00116     myAngle=0.;
00117     myPrm=0.;
00118   }
00119   void SetPnt(const gp_Pnt& aP3D){
00120     myPnt=aP3D;
00121   }
00122   void SetTangent(const gp_Dir& aTgt){
00123     myTgt=aTgt;
00124   }
00125   void SetAngle(const double& aBeta){
00126     myAngle=aBeta;
00127   }
00128   void SetParameter(const double& aPrm){
00129     myPrm=aPrm;
00130   }
00131   const gp_Pnt& Pnt()const{
00132     return myPnt;
00133   }
00134   const gp_Dir& Tangent()const{
00135     return myTgt;
00136   }
00137   double Angle()const{
00138     return myAngle;
00139   }
00140   double Parameter()const{
00141     return myPrm;
00142   }
00143 
00144 protected:
00145   gp_Pnt myPnt;
00146   gp_Dir myTgt;
00147   double myAngle;
00148   double myPrm;
00149 };
00150 
00151 
00152 // ============================================================
00156 // ============================================================
00157 
00158 class SMESH_EXPORT SMESH_MeshEditor {
00159 
00160 public:
00161 
00162   SMESH_MeshEditor( SMESH_Mesh* theMesh );
00163 
00167   SMDS_MeshElement* AddElement(const std::vector<const SMDS_MeshNode*> & nodes,
00168                                const SMDSAbs_ElementType                 type,
00169                                const bool                                isPoly,
00170                                const int                                 ID = 0);
00174   SMDS_MeshElement* AddElement(const std::vector<int>  & nodeIDs,
00175                                const SMDSAbs_ElementType type,
00176                                const bool                isPoly,
00177                                const int                 ID = 0);
00178 
00179   bool Remove (const std::list< int >& theElemIDs, const bool isNodes);
00180   // Remove a node or an element.
00181   // Modify a compute state of sub-meshes which become empty
00182 
00183   bool InverseDiag (const SMDS_MeshElement * theTria1,
00184                     const SMDS_MeshElement * theTria2 );
00185   // Replace two neighbour triangles with ones built on the same 4 nodes
00186   // but having other common link.
00187   // Return False if args are improper
00188 
00189   bool InverseDiag (const SMDS_MeshNode * theNode1,
00190                     const SMDS_MeshNode * theNode2 );
00191   // Replace two neighbour triangles sharing theNode1-theNode2 link
00192   // with ones built on the same 4 nodes but having other common link.
00193   // Return false if proper faces not found
00194 
00195   bool DeleteDiag (const SMDS_MeshNode * theNode1,
00196                    const SMDS_MeshNode * theNode2 );
00197   // Replace two neighbour triangles sharing theNode1-theNode2 link
00198   // with a quadrangle built on the same 4 nodes.
00199   // Return false if proper faces not found
00200 
00201   bool Reorient (const SMDS_MeshElement * theElement);
00202   // Reverse theElement orientation
00203 
00204 
00213   bool TriToQuad (TIDSortedElemSet &                   theElems,
00214                   SMESH::Controls::NumericalFunctorPtr theCriterion,
00215                   const double                         theMaxAngle);
00216 
00223   bool QuadToTri (TIDSortedElemSet &                   theElems,
00224                   SMESH::Controls::NumericalFunctorPtr theCriterion);
00225 
00232   bool QuadToTri (TIDSortedElemSet & theElems,
00233                   const bool         the13Diag);
00234 
00241   int BestSplit (const SMDS_MeshElement*              theQuad,
00242                  SMESH::Controls::NumericalFunctorPtr theCriterion);
00243 
00244 
00245   enum SmoothMethod { LAPLACIAN = 0, CENTROIDAL };
00246 
00247   void Smooth (TIDSortedElemSet &               theElements,
00248                std::set<const SMDS_MeshNode*> & theFixedNodes,
00249                const SmoothMethod               theSmoothMethod,
00250                const int                        theNbIterations,
00251                double                           theTgtAspectRatio = 1.0,
00252                const bool                       the2D = true);
00253   // Smooth theElements using theSmoothMethod during theNbIterations
00254   // or until a worst element has aspect ratio <= theTgtAspectRatio.
00255   // Aspect Ratio varies in range [1.0, inf].
00256   // If theElements is empty, the whole mesh is smoothed.
00257   // theFixedNodes contains additionally fixed nodes. Nodes built
00258   // on edges and boundary nodes are always fixed.
00259   // If the2D, smoothing is performed using UV parameters of nodes
00260   // on geometrical faces
00261 
00262   typedef std::auto_ptr< std::list<int> > PGroupIDs;
00263 
00264   PGroupIDs RotationSweep (TIDSortedElemSet & theElements,
00265                            const gp_Ax1&      theAxis,
00266                            const double       theAngle,
00267                            const int          theNbSteps,
00268                            const double       theToler,
00269                            const bool         theMakeGroups,
00270                            const bool         theMakeWalls=true);
00271   // Generate new elements by rotation of theElements around theAxis
00272   // by theAngle by theNbSteps
00273 
00279   enum ExtrusionFlags {
00280     EXTRUSION_FLAG_BOUNDARY = 0x01,
00281     EXTRUSION_FLAG_SEW = 0x02
00282   };
00283   
00287   struct ExtrusParam {
00288     gp_Dir myDir; // direction of extrusion
00289     Handle(TColStd_HSequenceOfReal) mySteps; // magnitudes for each step
00290     SMESH_SequenceOfNode myNodes; // nodes for using in sewing
00291   };
00292 
00297   const SMDS_MeshNode* CreateNode(const double x,
00298                                   const double y,
00299                                   const double z,
00300                                   const double tolnode,
00301                                   SMESH_SequenceOfNode& aNodes);
00302 
00315   PGroupIDs ExtrusionSweep (TIDSortedElemSet &  theElems,
00316                             const gp_Vec&       theStep,
00317                             const int           theNbSteps,
00318                             TElemOfElemListMap& newElemsMap,
00319                             const bool          theMakeGroups,
00320                             const int           theFlags = EXTRUSION_FLAG_BOUNDARY,
00321                             const double        theTolerance = 1.e-6);
00322   
00333   PGroupIDs ExtrusionSweep (TIDSortedElemSet &  theElems,
00334                             ExtrusParam&        theParams,
00335                             TElemOfElemListMap& newElemsMap,
00336                             const bool          theMakeGroups,
00337                             const int           theFlags,
00338                             const double        theTolerance);
00339 
00340 
00341   // Generate new elements by extrusion of theElements 
00342   // by theStep by theNbSteps
00343 
00344   enum Extrusion_Error {
00345     EXTR_OK,
00346     EXTR_NO_ELEMENTS, 
00347     EXTR_PATH_NOT_EDGE,
00348     EXTR_BAD_PATH_SHAPE,
00349     EXTR_BAD_STARTING_NODE,
00350     EXTR_BAD_ANGLES_NUMBER,
00351     EXTR_CANT_GET_TANGENT
00352     };
00353   
00354   Extrusion_Error ExtrusionAlongTrack (TIDSortedElemSet &   theElements,
00355                                        SMESH_subMesh*       theTrackPattern,
00356                                        const SMDS_MeshNode* theNodeStart,
00357                                        const bool           theHasAngles,
00358                                        std::list<double>&   theAngles,
00359                                        const bool           theLinearVariation,
00360                                        const bool           theHasRefPoint,
00361                                        const gp_Pnt&        theRefPoint,
00362                                        const bool           theMakeGroups);
00363   Extrusion_Error ExtrusionAlongTrack (TIDSortedElemSet &   theElements,
00364                                        SMESH_Mesh*          theTrackPattern,
00365                                        const SMDS_MeshNode* theNodeStart,
00366                                        const bool           theHasAngles,
00367                                        std::list<double>&   theAngles,
00368                                        const bool           theLinearVariation,
00369                                        const bool           theHasRefPoint,
00370                                        const gp_Pnt&        theRefPoint,
00371                                        const bool           theMakeGroups);
00372   // Generate new elements by extrusion of theElements along path given by theTrackPattern,
00373   // theHasAngles are the rotation angles, base point can be given by theRefPoint
00374 
00375   PGroupIDs Transform (TIDSortedElemSet & theElements,
00376                        const gp_Trsf&     theTrsf,
00377                        const bool         theCopy,
00378                        const bool         theMakeGroups,
00379                        SMESH_Mesh*        theTargetMesh=0);
00380   // Move or copy theElements applying theTrsf to their nodes
00381 
00382 
00383   typedef std::list< std::list< const SMDS_MeshNode* > > TListOfListOfNodes;
00384 
00385   void FindCoincidentNodes (std::set<const SMDS_MeshNode*> & theNodes,
00386                             const double                     theTolerance,
00387                             TListOfListOfNodes &             theGroupsOfNodes);
00388   // Return list of group of nodes close to each other within theTolerance.
00389   // Search among theNodes or in the whole mesh if theNodes is empty.
00390 
00394   SMESH_NodeSearcher* GetNodeSearcher();
00395 
00399   SMESH_ElementSearcher* GetElementSearcher();
00403   static bool isOut( const SMDS_MeshElement* element, const gp_Pnt& point, double tol );
00404 
00405 
00406   int SimplifyFace (const std::vector<const SMDS_MeshNode *> faceNodes,
00407                     std::vector<const SMDS_MeshNode *>&      poly_nodes,
00408                     std::vector<int>&                        quantities) const;
00409   // Split face, defined by <faceNodes>, into several faces by repeating nodes.
00410   // Is used by MergeNodes()
00411 
00412   void MergeNodes (TListOfListOfNodes & theNodeGroups);
00413   // In each group, the cdr of nodes are substituted by the first one
00414   // in all elements.
00415 
00416   typedef std::list< std::list< int > > TListOfListOfElementsID;
00417 
00418   void FindEqualElements(std::set<const SMDS_MeshElement*> & theElements,
00419                          TListOfListOfElementsID &           theGroupsOfElementsID);
00420   // Return list of group of elements build on the same nodes.
00421   // Search among theElements or in the whole mesh if theElements is empty.
00422 
00423   void MergeElements(TListOfListOfElementsID & theGroupsOfElementsID);
00424   // In each group remove all but first of elements.
00425 
00426   void MergeEqualElements();
00427   // Remove all but one of elements built on the same nodes.
00428   // Return nb of successfully merged groups.
00429 
00430   static bool CheckFreeBorderNodes(const SMDS_MeshNode* theNode1,
00431                                    const SMDS_MeshNode* theNode2,
00432                                    const SMDS_MeshNode* theNode3 = 0);
00433   // Return true if the three nodes are on a free border
00434 
00435   static bool FindFreeBorder (const SMDS_MeshNode*                  theFirstNode,
00436                               const SMDS_MeshNode*                  theSecondNode,
00437                               const SMDS_MeshNode*                  theLastNode,
00438                               std::list< const SMDS_MeshNode* > &   theNodes,
00439                               std::list< const SMDS_MeshElement* >& theFaces);
00440   // Return nodes and faces of a free border if found 
00441 
00442   enum Sew_Error {
00443     SEW_OK,
00444     // for SewFreeBorder()
00445     SEW_BORDER1_NOT_FOUND,
00446     SEW_BORDER2_NOT_FOUND,
00447     SEW_BOTH_BORDERS_NOT_FOUND,
00448     SEW_BAD_SIDE_NODES,
00449     SEW_VOLUMES_TO_SPLIT,
00450     // for SewSideElements()
00451     SEW_DIFF_NB_OF_ELEMENTS,
00452     SEW_TOPO_DIFF_SETS_OF_ELEMENTS,
00453     SEW_BAD_SIDE1_NODES,
00454     SEW_BAD_SIDE2_NODES,
00455     SEW_INTERNAL_ERROR
00456     };
00457     
00458 
00459   Sew_Error SewFreeBorder (const SMDS_MeshNode* theBorderFirstNode,
00460                            const SMDS_MeshNode* theBorderSecondNode,
00461                            const SMDS_MeshNode* theBorderLastNode,
00462                            const SMDS_MeshNode* theSide2FirstNode,
00463                            const SMDS_MeshNode* theSide2SecondNode,
00464                            const SMDS_MeshNode* theSide2ThirdNode = 0,
00465                            const bool           theSide2IsFreeBorder = true,
00466                            const bool           toCreatePolygons = false,
00467                            const bool           toCreatePolyedrs = false);
00468   // Sew the free border to the side2 by replacing nodes in
00469   // elements on the free border with nodes of the elements
00470   // of the side 2. If nb of links in the free border and
00471   // between theSide2FirstNode and theSide2LastNode are different,
00472   // additional nodes are inserted on a link provided that no
00473   // volume elements share the splitted link.
00474   // The side 2 is a free border if theSide2IsFreeBorder == true.
00475   // Sewing is peformed between the given first, second and last
00476   // nodes on the sides.
00477   // theBorderFirstNode is merged with theSide2FirstNode.
00478   // if (!theSide2IsFreeBorder) then theSide2SecondNode gives
00479   // the last node on the side 2, which will be merged with
00480   // theBorderLastNode.
00481   // if (theSide2IsFreeBorder) then theSide2SecondNode will
00482   // be merged with theBorderSecondNode.
00483   // if (theSide2IsFreeBorder && theSide2ThirdNode == 0) then
00484   // the 2 free borders are sewn link by link and no additional
00485   // nodes are inserted.
00486   // Return false, if sewing failed.
00487 
00488   Sew_Error SewSideElements (TIDSortedElemSet&    theSide1,
00489                              TIDSortedElemSet&    theSide2,
00490                              const SMDS_MeshNode* theFirstNode1ToMerge,
00491                              const SMDS_MeshNode* theFirstNode2ToMerge,
00492                              const SMDS_MeshNode* theSecondNode1ToMerge,
00493                              const SMDS_MeshNode* theSecondNode2ToMerge);
00494   // Sew two sides of a mesh. Nodes belonging to theSide1 are
00495   // merged with nodes of elements of theSide2.
00496   // Number of elements in theSide1 and in theSide2 must be
00497   // equal and they should have similar node connectivity.
00498   // The nodes to merge should belong to side s borders and
00499   // the first node should be linked to the second.
00500 
00501   void InsertNodesIntoLink(const SMDS_MeshElement*          theFace,
00502                            const SMDS_MeshNode*             theBetweenNode1,
00503                            const SMDS_MeshNode*             theBetweenNode2,
00504                            std::list<const SMDS_MeshNode*>& theNodesToInsert,
00505                            const bool                       toCreatePoly = false);
00506   // insert theNodesToInsert into theFace between theBetweenNode1 and theBetweenNode2.
00507   // If toCreatePoly is true, replace theFace by polygon, else split theFace.
00508 
00509   void UpdateVolumes (const SMDS_MeshNode*             theBetweenNode1,
00510                       const SMDS_MeshNode*             theBetweenNode2,
00511                       std::list<const SMDS_MeshNode*>& theNodesToInsert);
00512   // insert theNodesToInsert into all volumes, containing link
00513   // theBetweenNode1 - theBetweenNode2, between theBetweenNode1 and theBetweenNode2.
00514 
00515   void ConvertToQuadratic(const bool theForce3d);
00516   //converts all mesh to quadratic one, deletes old elements, replacing 
00517   //them with quadratic ones with the same id.
00518 
00519   bool ConvertFromQuadratic();
00520   //converts all mesh from quadratic to ordinary ones, deletes old quadratic elements, replacing 
00521   //them with ordinary mesh elements with the same id.
00522 
00523 
00524 //  static int SortQuadNodes (const SMDS_Mesh * theMesh,
00525 //                            int               theNodeIds[] );
00526 //  // Set 4 nodes of a quadrangle face in a good order.
00527 //  // Swap 1<->2 or 2<->3 nodes and correspondingly return
00528 //  // 1 or 2 else 0.
00529 //
00530 //  static bool SortHexaNodes (const SMDS_Mesh * theMesh,
00531 //                             int               theNodeIds[] );
00532 //  // Set 8 nodes of a hexahedron in a good order.
00533 //  // Return success status
00534 
00535   static void AddToSameGroups (const SMDS_MeshElement* elemToAdd,
00536                                const SMDS_MeshElement* elemInGroups,
00537                                SMESHDS_Mesh *          aMesh);
00538   // Add elemToAdd to the all groups the elemInGroups belongs to
00539 
00540   static void RemoveElemFromGroups (const SMDS_MeshElement* element,
00541                                     SMESHDS_Mesh *          aMesh);
00542   // remove element from the all groups
00543 
00544   static void ReplaceElemInGroups (const SMDS_MeshElement* elemToRm,
00545                                    const SMDS_MeshElement* elemToAdd,
00546                                    SMESHDS_Mesh *          aMesh);
00547   // replace elemToRm by elemToAdd in the all groups
00548 
00552   static void GetLinkedNodes( const SMDS_MeshNode* node,
00553                               TIDSortedElemSet &   linkedNodes,
00554                               SMDSAbs_ElementType  type = SMDSAbs_All );
00555 
00556   static const SMDS_MeshElement*
00557     FindFaceInSet(const SMDS_MeshNode*    n1,
00558                   const SMDS_MeshNode*    n2,
00559                   const TIDSortedElemSet& elemSet,
00560                   const TIDSortedElemSet& avoidSet);
00561   // Return a face having linked nodes n1 and n2 and which is
00562   // - not in avoidSet,
00563   // - in elemSet provided that !elemSet.empty()
00564 
00576   static Sew_Error FindMatchingNodes(std::set<const SMDS_MeshElement*>& theSide1,
00577                                      std::set<const SMDS_MeshElement*>& theSide2,
00578                                      const SMDS_MeshNode*          theFirstNode1,
00579                                      const SMDS_MeshNode*          theFirstNode2,
00580                                      const SMDS_MeshNode*          theSecondNode1,
00581                                      const SMDS_MeshNode*          theSecondNode2,
00582                                      TNodeNodeMap &                nReplaceMap);
00583 
00590   static bool IsMedium(const SMDS_MeshNode*      node,
00591                        const SMDSAbs_ElementType typeToCheck = SMDSAbs_All);
00592 
00593   int FindShape (const SMDS_MeshElement * theElem);
00594   // Return an index of the shape theElem is on
00595   // or zero if a shape not found
00596 
00597   SMESH_Mesh * GetMesh() { return myMesh; }
00598 
00599   SMESHDS_Mesh * GetMeshDS() { return myMesh->GetMeshDS(); }
00600 
00601   const SMESH_SequenceOfElemPtr& GetLastCreatedNodes() const { return myLastCreatedNodes; }
00602 
00603   const SMESH_SequenceOfElemPtr& GetLastCreatedElems() const { return myLastCreatedElems; }
00604 
00605   bool DoubleNodes( const std::list< int >& theListOfNodes, 
00606                     const std::list< int >& theListOfModifiedElems );
00607   
00608   bool DoubleNodes( const TIDSortedElemSet& theElems, 
00609                     const TIDSortedElemSet& theNodesNot,
00610                     const TIDSortedElemSet& theAffectedElems );
00611 
00612   bool DoubleNodesInRegion( const TIDSortedElemSet& theElems, 
00613                             const TIDSortedElemSet& theNodesNot,
00614                             const TopoDS_Shape&     theShape );
00615   
00621   bool Make2DMeshFrom3D();
00622   
00623 private:
00624 
00629   int convertElemToQuadratic(SMESHDS_SubMesh *   theSm,
00630                              SMESH_MesherHelper& theHelper,
00631                              const bool          theForce3d);
00632 
00637   int removeQuadElem( SMESHDS_SubMesh *    theSm,
00638                       SMDS_ElemIteratorPtr theItr,
00639                       const int            theShapeID);
00646   PGroupIDs generateGroups(const SMESH_SequenceOfElemPtr& nodeGens,
00647                            const SMESH_SequenceOfElemPtr& elemGens,
00648                            const std::string&             postfix,
00649                            SMESH_Mesh*                    targetMesh=0);
00650 
00651 
00652   typedef std::map<const SMDS_MeshNode*, std::list<const SMDS_MeshNode*> > TNodeOfNodeListMap;
00653   typedef TNodeOfNodeListMap::iterator                                     TNodeOfNodeListMapItr;
00654   typedef std::vector<TNodeOfNodeListMapItr>                               TVecOfNnlmiMap;
00655   typedef std::map<const SMDS_MeshElement*, TVecOfNnlmiMap >               TElemOfVecOfNnlmiMap;
00656 
00665   void sweepElement(const SMDS_MeshElement*                    elem,
00666                     const std::vector<TNodeOfNodeListMapItr> & newNodesItVec,
00667                     std::list<const SMDS_MeshElement*>&        newElems,
00668                     const int                                  nbSteps,
00669                     SMESH_SequenceOfElemPtr&                   srcElements);
00670 
00680   void makeWalls (TNodeOfNodeListMap &     mapNewNodes,
00681                   TElemOfElemListMap &     newElemsMap,
00682                   TElemOfVecOfNnlmiMap &   elemNewNodesMap,
00683                   TIDSortedElemSet&        elemSet,
00684                   const int                nbSteps,
00685                   SMESH_SequenceOfElemPtr& srcElements);
00686 
00690   Extrusion_Error MakeEdgePathPoints(std::list<double>& aPrms,
00691                                      const TopoDS_Edge& aTrackEdge,
00692                                      bool FirstIsStart,
00693                                      list<SMESH_MeshEditor_PathPoint>& LPP);
00694   Extrusion_Error MakeExtrElements(TIDSortedElemSet& theElements,
00695                                    list<SMESH_MeshEditor_PathPoint>& fullList,
00696                                    const bool theHasAngles,
00697                                    list<double>& theAngles,
00698                                    const bool theLinearVariation,
00699                                    const bool theHasRefPoint,
00700                                    const gp_Pnt& theRefPoint,
00701                                    const bool theMakeGroups);
00702   void LinearAngleVariation(const int NbSteps,
00703                             list<double>& theAngles);
00704 
00705   bool doubleNodes( SMESHDS_Mesh*     theMeshDS,
00706                     const TIDSortedElemSet& theElems,
00707                     const TIDSortedElemSet& theNodesNot,
00708                     std::map< const SMDS_MeshNode*,
00709                     const SMDS_MeshNode* >& theNodeNodeMap,
00710                     const bool theIsDoubleElem );
00711 
00712 private:
00713 
00714   SMESH_Mesh * myMesh;
00715 
00719   SMESH_SequenceOfElemPtr myLastCreatedNodes;
00720 
00724   SMESH_SequenceOfElemPtr myLastCreatedElems;
00725 
00726 };
00727 
00728 #endif
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Friends Defines