X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH%2FSMESH_MeshEditor.hxx;h=8e605ab9294f43ebb94a88e69554620dc3c40714;hp=1dbed7d991705c59321a0e935eb31bc9a5a09022;hb=441a2df90cb97ea7d035771a49e28dc53469e3d6;hpb=b22e182dd1a2c30be324b21074158390d00714b3 diff --git a/src/SMESH/SMESH_MeshEditor.hxx b/src/SMESH/SMESH_MeshEditor.hxx index 1dbed7d99..8e605ab92 100644 --- a/src/SMESH/SMESH_MeshEditor.hxx +++ b/src/SMESH/SMESH_MeshEditor.hxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2016 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 @@ -30,9 +30,7 @@ #include "SMESH_SMESH.hxx" -#include "SMDS_MeshElement.hxx" #include "SMESH_Controls.hxx" -#include "SMESH_Mesh.hxx" #include "SMESH_TypeDefs.hxx" #include "SMESH_ComputeError.hxx" @@ -45,13 +43,24 @@ #include #include +class SMDS_MeshElement; class SMDS_MeshFace; class SMDS_MeshNode; -class gp_Ax1; -class gp_Vec; -class gp_Pnt; +class SMESHDS_Group; +class SMESHDS_Mesh; +class SMESHDS_SubMesh; +class SMESH_ElementSearcher; +class SMESH_Group; +class SMESH_Mesh; class SMESH_MesherHelper; class SMESH_NodeSearcher; +class SMESH_subMesh; +class TopoDS_Edge; +class TopoDS_Shape; +class TopoDS_Vertex; +class gp_Ax1; +class gp_Pnt; +class gp_Vec; // ============================================================ /*! @@ -65,8 +74,8 @@ public: SMESH_MeshEditor( SMESH_Mesh* theMesh ); - SMESH_Mesh * GetMesh() { return myMesh; } - SMESHDS_Mesh * GetMeshDS() { return myMesh->GetMeshDS(); } + SMESH_Mesh * GetMesh() { return myMesh; } + SMESHDS_Mesh * GetMeshDS(); const SMESH_SequenceOfElemPtr& GetLastCreatedNodes() const { return myLastCreatedNodes; } const SMESH_SequenceOfElemPtr& GetLastCreatedElems() const { return myLastCreatedElems; } @@ -76,34 +85,35 @@ public: // -------------------------------------------------------------------------------- struct ElemFeatures //!< Features of element to create { - SMDSAbs_ElementType myType; - bool myIsPoly, myIsQuad; - int myID; - double myBallDiameter; - std::vector myPolyhedQuantities; - - ElemFeatures( SMDSAbs_ElementType type=SMDSAbs_All, bool isPoly=false, bool isQuad=false ) + SMDSAbs_ElementType myType; + bool myIsPoly, myIsQuad; + int myID; + double myBallDiameter; + std::vector myPolyhedQuantities; + std::vector myNodes; // not managed by ElemFeatures + + SMESH_EXPORT ElemFeatures( SMDSAbs_ElementType type=SMDSAbs_All, bool isPoly=false, bool isQuad=false ) :myType( type ), myIsPoly(isPoly), myIsQuad(isQuad), myID(-1), myBallDiameter(0) {} - ElemFeatures& Init( SMDSAbs_ElementType type, bool isPoly=false, bool isQuad=false ) + SMESH_EXPORT ElemFeatures& Init( SMDSAbs_ElementType type, bool isPoly=false, bool isQuad=false ) { myType = type; myIsPoly = isPoly; myIsQuad = isQuad; return *this; } - ElemFeatures& Init( const SMDS_MeshElement* elem, bool basicOnly=true ); + SMESH_EXPORT ElemFeatures& Init( const SMDS_MeshElement* elem, bool basicOnly=true ); - ElemFeatures& Init( double diameter ) + SMESH_EXPORT ElemFeatures& Init( double diameter ) { myType = SMDSAbs_Ball; myBallDiameter = diameter; return *this; } - ElemFeatures& Init( vector& quanities, bool isQuad=false ) + SMESH_EXPORT ElemFeatures& Init( std::vector& quanities, bool isQuad=false ) { myType = SMDSAbs_Volume; myIsPoly = 1; myIsQuad = isQuad; myPolyhedQuantities.swap( quanities ); return *this; } - ElemFeatures& Init( const vector& quanities, bool isQuad=false ) + SMESH_EXPORT ElemFeatures& Init( const std::vector& quanities, bool isQuad=false ) { myType = SMDSAbs_Volume; myIsPoly = 1; myIsQuad = isQuad; myPolyhedQuantities = quanities; return *this; } - ElemFeatures& SetPoly(bool isPoly) { myIsPoly = isPoly; return *this; } - ElemFeatures& SetQuad(bool isQuad) { myIsQuad = isQuad; return *this; } - ElemFeatures& SetID (int ID) { myID = ID; return *this; } + SMESH_EXPORT ElemFeatures& SetPoly(bool isPoly) { myIsPoly = isPoly; return *this; } + SMESH_EXPORT ElemFeatures& SetQuad(bool isQuad) { myIsQuad = isQuad; return *this; } + SMESH_EXPORT ElemFeatures& SetID (int ID) { myID = ID; return *this; } }; /*! @@ -122,9 +132,9 @@ public: // Modify a compute state of sub-meshes which become empty void Create0DElementsOnAllNodes( const TIDSortedElemSet& elements, - TIDSortedElemSet& all0DElems); - // Create 0D elements on all nodes of the given object except those - // nodes on which a 0D element already exists. \a all0DElems returns + TIDSortedElemSet& all0DElems, + const bool duplicateElements); + // Create 0D elements on all nodes of the given. \a all0DElems returns // all 0D elements found or created on nodes of \a elements bool InverseDiag (const SMDS_MeshElement * theTria1, @@ -165,7 +175,7 @@ public: * \param theElems - The triangles to be fused. * \param theCriterion - Is used to choose a neighbour to fuse with. * \param theMaxAngle - Is a max angle between element normals at which fusion - * is still performed; theMaxAngle is mesured in radians. + * is still performed; theMaxAngle is measured in radians. * \return bool - Success or not. */ bool TriToQuad (TIDSortedElemSet & theElems, @@ -173,7 +183,7 @@ public: const double theMaxAngle); /*! * \brief Split quadrangles into triangles. - * \param theElems - The faces to be splitted. + * \param theElems - The faces to be split. * \param theCriterion - Is used to choose a diagonal for splitting. * \return bool - Success or not. */ @@ -181,7 +191,7 @@ public: SMESH::Controls::NumericalFunctorPtr theCriterion); /*! * \brief Split quadrangles into triangles. - * \param theElems - The faces to be splitted. + * \param theElems - The faces to be split. * \param the13Diag - Is used to choose a diagonal for splitting. * \return bool - Success or not. */ @@ -189,7 +199,7 @@ public: const bool the13Diag); /*! * \brief Split each of given quadrangles into 4 triangles. - * \param theElems - The faces to be splitted. If empty all faces are split. + * \param theElems - The faces to be split. If empty all faces are split. */ void QuadTo4Tri (TIDSortedElemSet & theElems); @@ -221,7 +231,7 @@ public: /*! * \brief For hexahedra that will be split into prisms, finds facets to - * split into triangles + * split into triangles * \param [in,out] theHexas - the hexahedra * \param [in] theFacetNormal - facet normal * \param [out] theFacets - the hexahedra and found facet IDs @@ -230,6 +240,16 @@ public: const gp_Ax1& theFacetNormal, TFacetOfElem & theFacets); + /*! + * \brief Split bi-quadratic elements into linear ones without creation of additional nodes + * - bi-quadratic triangle will be split into 3 linear quadrangles; + * - bi-quadratic quadrangle will be split into 4 linear quadrangles; + * - tri-quadratic hexahedron will be split into 8 linear hexahedra; + * Quadratic elements of lower dimension adjacent to the split bi-quadratic element + * will be split in order to keep the mesh conformal. + * \param elems - elements to split + */ + void SplitBiQuadraticIntoLinear(TIDSortedElemSet& theElems); enum SmoothMethod { LAPLACIAN = 0, CENTROIDAL }; @@ -276,21 +296,26 @@ public: * else step size is measured along average normal of any element * USE_INPUT_ELEMS_ONLY: to use only input elements to compute extrusion direction * for ExtrusionByNormal() + * SCALE_LINEAR_VARIATION: to make linear variation of scale factors */ enum ExtrusionFlags { EXTRUSION_FLAG_BOUNDARY = 0x01, EXTRUSION_FLAG_SEW = 0x02, EXTRUSION_FLAG_GROUPS = 0x04, EXTRUSION_FLAG_BY_AVG_NORMAL = 0x08, - EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY = 0x10 + EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY = 0x10, + EXTRUSION_FLAG_SCALE_LINEAR_VARIATION = 0x20 }; /*! * Generator of nodes for extrusion functionality */ - class SMESH_EXPORT ExtrusParam { + class SMESH_EXPORT ExtrusParam + { gp_Dir myDir; // direction of extrusion Handle(TColStd_HSequenceOfReal) mySteps; // magnitudes for each step + std::vector myScales, myMediumScales;// scale factors + gp_XYZ myBaseP; // scaling center SMESH_SequenceOfNode myNodes; // nodes for using in sewing int myFlags; // see ExtrusionFlags double myTolerance; // tolerance for sewing nodes @@ -302,29 +327,33 @@ public: const bool makeMediumNodes); public: - ExtrusParam( const gp_Vec& theStep, - const int theNbSteps, - const int theFlags = 0, - const double theTolerance = 1e-6); + ExtrusParam( const gp_Vec& theStep, + const int theNbSteps, + const std::list& theScales, + const gp_XYZ* theBaseP, + const int theFlags = 0, + const double theTolerance = 1e-6); ExtrusParam( const gp_Dir& theDir, Handle(TColStd_HSequenceOfReal) theSteps, const int theFlags = 0, const double theTolerance = 1e-6); - ExtrusParam( const double theStep, - const int theNbSteps, - const int theFlags, - const int theDim); // for extrusion by normal + ExtrusParam( const double theStep, + const int theNbSteps, + const int theFlags, + const int theDim); // for extrusion by normal SMESH_SequenceOfNode& ChangeNodes() { return myNodes; } int& Flags() { return myFlags; } bool ToMakeBoundary() const { return myFlags & EXTRUSION_FLAG_BOUNDARY; } bool ToMakeGroups() const { return myFlags & EXTRUSION_FLAG_GROUPS; } bool ToUseInpElemsOnly() const { return myFlags & EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY; } + bool IsLinearVariation() const { return myFlags & EXTRUSION_FLAG_SCALE_LINEAR_VARIATION; } int NbSteps() const { return mySteps->Length(); } // stores elements to use for extrusion by normal, depending on - // state of EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY flag - void SetElementsToUse( const TIDSortedElemSet& elems ); + // state of EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY flag; + // define myBaseP for scaling + void SetElementsToUse( const TIDSortedElemSet& elems, const TIDSortedElemSet& nodes ); // creates nodes and returns number of nodes added in \a newNodes int MakeNodes( SMESHDS_Mesh* mesh, @@ -436,6 +465,14 @@ public: SMESH_Mesh* theTargetMesh=0); // Move or copy theElements applying theTrsf to their nodes + PGroupIDs Offset( TIDSortedElemSet & theElements, + const double theValue, + SMESH_Mesh* theTgtMesh, + const bool theMakeGroups, + const bool theCopyElements, + const bool theFixSelfIntersection); + // Make an offset mesh from a source 2D mesh + typedef std::list< std::list< const SMDS_MeshNode* > > TListOfListOfNodes; void FindCoincidentNodes (TIDSortedNodeSet & theNodes, @@ -445,7 +482,8 @@ public: // Return list of group of nodes close to each other within theTolerance. // Search among theNodes or in the whole mesh if theNodes is empty. - void MergeNodes (TListOfListOfNodes & theNodeGroups); + void MergeNodes (TListOfListOfNodes & theNodeGroups, + const bool theAvoidMakingHoles = false); // In each group, the cdr of nodes are substituted by the first one // in all elements. @@ -512,9 +550,9 @@ public: // of the side 2. If nb of links in the free border and // between theSide2FirstNode and theSide2LastNode are different, // additional nodes are inserted on a link provided that no - // volume elements share the splitted link. + // volume elements share the split link. // The side 2 is a free border if theSide2IsFreeBorder == true. - // Sewing is peformed between the given first, second and last + // Sewing is performed between the given first, second and last // nodes on the sides. // theBorderFirstNode is merged with theSide2FirstNode. // if (!theSide2IsFreeBorder) then theSide2SecondNode gives @@ -679,6 +717,49 @@ public: bool toAddExistingBondary = false, bool aroundElements = false); + + // structure used in MakePolyLine() to define a cutting plane + struct PolySegment + { + // 2 points, each defined as follows: + // ( myNode1 && myNode2 ) ==> point is in the middle of an edge defined by two nodes + // ( myNode1 && !myNode2 ) ==> point is at myNode1 + // else ==> point is at myXYZ + const SMDS_MeshNode* myNode1[2]; + const SMDS_MeshNode* myNode2[2]; + gp_XYZ myXYZ [2]; + + // face on which myXYZ projects (found by MakePolyLine()) + const SMDS_MeshElement* myFace [2]; + + // vector on the plane; to use a default plane set vector = (0,0,0) + gp_Vec myVector; + + // point to return coordinates of a middle of the two points, projected to mesh + gp_Pnt myMidProjPoint; + }; + typedef std::vector TListOfPolySegments; + + /*! + * \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of + * the initial mesh. Positions of new nodes are found by cutting the mesh by the + * plane passing through pairs of points specified by each PolySegment structure. + * If there are several paths connecting a pair of points, the shortest path is + * selected by the module. Position of the cutting plane is defined by the two + * points and an optional vector lying on the plane specified by a PolySegment. + * By default the vector is defined by Mesh module as following. A middle point + * of the two given points is computed. The middle point is projected to the mesh. + * The vector goes from the middle point to the projection point. In case of planar + * mesh, the vector is normal to the mesh. + * \param [inout] segments - PolySegment's defining positions of cutting planes. + * Return the used vector and position of the middle point. + * \param [in] group - an optional group where created mesh segments will + * be added. + */ + void MakePolyLine( TListOfPolySegments& segments, + SMESHDS_Group* group=0, + SMESH_ElementSearcher* searcher=0); + private: /*! @@ -720,9 +801,23 @@ public: void sweepElement(const SMDS_MeshElement* elem, const std::vector & newNodesItVec, std::list& newElems, - const int nbSteps, + const size_t nbSteps, SMESH_SequenceOfElemPtr& srcElements); + /*! + * \brief Computes new connectivity of an element after merging nodes + * \param [in] elems - the element + * \param [out] newElemDefs - definition(s) of result element(s) + * \param [inout] nodeNodeMap - nodes to merge + * \param [in] avoidMakingHoles - if true and and the element becomes invalid + * after merging (but not degenerated), removes nodes causing + * the invalidity from \a nodeNodeMap. + * \return bool - true if the element should be removed + */ + bool applyMerge( const SMDS_MeshElement* elems, + std::vector< ElemFeatures >& newElemDefs, + TNodeNodeMap& nodeNodeMap, + const bool avoidMakingHoles ); /*! * \brief Create 1D and 2D elements around swept elements * \param mapNewNodes - source nodes and ones generated from them @@ -755,11 +850,11 @@ public: double Angle ()const { return myAngle; } double Parameter ()const { return myPrm; } }; - Extrusion_Error MakeEdgePathPoints(std::list& aPrms, + Extrusion_Error makeEdgePathPoints(std::list& aPrms, const TopoDS_Edge& aTrackEdge, bool aFirstIsStart, std::list& aLPP); - Extrusion_Error MakeExtrElements(TIDSortedElemSet theElements[2], + Extrusion_Error makeExtrElements(TIDSortedElemSet theElements[2], std::list& theFullList, const bool theHasAngles, std::list& theAngles, @@ -767,8 +862,8 @@ public: const bool theHasRefPoint, const gp_Pnt& theRefPoint, const bool theMakeGroups); - void LinearAngleVariation(const int NbSteps, - list& theAngles); + static void linearAngleVariation(const int NbSteps, + std::list& theAngles); bool doubleNodes( SMESHDS_Mesh* theMeshDS, const TIDSortedElemSet& theElems, @@ -786,7 +881,7 @@ private: // Nodes and elements created during last operation SMESH_SequenceOfElemPtr myLastCreatedNodes, myLastCreatedElems; - // Description of error/warning occured during last operation + // Description of error/warning occurred during last operation SMESH_ComputeErrorPtr myError; };