// 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
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
//
//
#include "SMESH_Mesh.hxx"
#include "SMESH_Controls.hxx"
+#include "SMESH_SequenceOfNode.hxx"
+#include "SMESH_SequenceOfElemPtr.hxx"
+#include "TColStd_HSequenceOfReal.hxx"
+#include "SMESH_MesherHelper.hxx"
+#include "SMDS_MeshElement.hxx"
+
+#include <gp_Dir.hxx>
#include <list>
#include <map>
-class SMDS_MeshElement;
+typedef map<const SMDS_MeshElement*,
+ list<const SMDS_MeshElement*> > TElemOfElemListMap;
+typedef map<const SMDS_MeshNode*, const SMDS_MeshNode*> TNodeNodeMap;
+
+typedef map<const SMDS_MeshNode*, SMESHDS_SubMesh*> RemoveQuadNodeMap;
+typedef map<const SMDS_MeshNode*, SMESHDS_SubMesh*>::iterator ItRemoveQuadNodeMap;
+
class SMDS_MeshFace;
class SMDS_MeshNode;
class gp_Ax1;
class gp_Vec;
class gp_Pnt;
+// ============================================================
+/*!
+ * \brief Set of elements sorted by ID, to be used to assure
+ * predictability of edition
+ */
+// ============================================================
+
+template < class TMeshElem >
+struct TIDCompare {
+ bool operator () (const TMeshElem* e1, const TMeshElem* e2) const
+ { return e1->GetID() < e2->GetID(); }
+};
+typedef std::set< const SMDS_MeshElement*, TIDCompare< SMDS_MeshElement> > TIDSortedElemSet;
+
+// ============================================================
+/*!
+ * \brief Editor of a mesh
+ */
+// ============================================================
+
class SMESH_MeshEditor {
- public:
+
+public:
SMESH_MeshEditor( SMESH_Mesh* theMesh );
// Reverse theElement orientation
- bool TriToQuad (std::set<const SMDS_MeshElement*> & theElems,
+ /*!
+ * \brief Fuse neighbour triangles into quadrangles.
+ * \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.
+ * \retval bool - Success or not.
+ */
+ bool TriToQuad (TIDSortedElemSet & theElems,
SMESH::Controls::NumericalFunctorPtr theCriterion,
const double theMaxAngle);
- // Fuse neighbour triangles into quadrangles.
- // theCriterion is used to choose a neighbour to fuse with.
- // theMaxAngle is a max angle between element normals at which
- // fusion is still performed; theMaxAngle is mesured in radians.
- bool QuadToTri (std::set<const SMDS_MeshElement*> & theElems,
+ /*!
+ * \brief Split quadrangles into triangles.
+ * \param theElems - The faces to be splitted.
+ * \param theCriterion - Is used to choose a diagonal for splitting.
+ * \retval bool - Success or not.
+ */
+ bool QuadToTri (TIDSortedElemSet & theElems,
SMESH::Controls::NumericalFunctorPtr theCriterion);
- // Cut quadrangles into triangles.
- // theCriterion is used to choose a diagonal to cut
- bool QuadToTri (std::set<const SMDS_MeshElement*> & theElems,
- const bool the13Diag);
- // Cut quadrangles into triangles
+ /*!
+ * \brief Split quadrangles into triangles.
+ * \param theElems - The faces to be splitted.
+ * \param the13Diag - Is used to choose a diagonal for splitting.
+ * \retval bool - Success or not.
+ */
+ bool QuadToTri (TIDSortedElemSet & theElems,
+ const bool the13Diag);
+
+ /*!
+ * \brief Find better diagonal for splitting.
+ * \param theQuad - The face to find better splitting of.
+ * \param theCriterion - Is used to choose a diagonal for splitting.
+ * \retval int - 1 for 1-3 diagonal, 2 for 2-4, -1 - for errors.
+ */
+ int BestSplit (const SMDS_MeshElement* theQuad,
+ SMESH::Controls::NumericalFunctorPtr theCriterion);
enum SmoothMethod { LAPLACIAN = 0, CENTROIDAL };
- void Smooth (std::set<const SMDS_MeshElement*> & theElements,
- std::set<const SMDS_MeshNode*> & theFixedNodes,
- const SmoothMethod theSmoothMethod,
- const int theNbIterations,
- double theTgtAspectRatio = 1.0);
+ void Smooth (TIDSortedElemSet & theElements,
+ std::set<const SMDS_MeshNode*> & theFixedNodes,
+ const SmoothMethod theSmoothMethod,
+ const int theNbIterations,
+ double theTgtAspectRatio = 1.0,
+ const bool the2D = true);
// Smooth theElements using theSmoothMethod during theNbIterations
// or until a worst element has aspect ratio <= theTgtAspectRatio.
// Aspect Ratio varies in range [1.0, inf].
// If theElements is empty, the whole mesh is smoothed.
// theFixedNodes contains additionally fixed nodes. Nodes built
// on edges and boundary nodes are always fixed.
+ // If the2D, smoothing is performed using UV parameters of nodes
+ // on geometrical faces
- void RotationSweep (std::set<const SMDS_MeshElement*> & theElements,
- const gp_Ax1& theAxis,
- const double theAngle,
- const int theNbSteps,
- const double theToler);
+ void RotationSweep (TIDSortedElemSet & theElements,
+ const gp_Ax1& theAxis,
+ const double theAngle,
+ const int theNbSteps,
+ const double theToler);
// Generate new elements by rotation of theElements around theAxis
// by theAngle by theNbSteps
- void ExtrusionSweep (std::set<const SMDS_MeshElement*> & theElements,
- const gp_Vec& theStep,
- const int theNbSteps);
+ /*!
+ * Auxilary flag for advanced extrusion.
+ * BOUNDARY: create or not boundary for result of extrusion
+ * SEW: try to use existing nodes or create new nodes in any case
+ */
+ enum ExtrusionFlags {
+ EXTRUSION_FLAG_BOUNDARY = 0x01,
+ EXTRUSION_FLAG_SEW = 0x02
+ };
+
+ /*!
+ * special structire for control of extrusion functionality
+ */
+ struct ExtrusParam {
+ gp_Dir myDir; // direction of extrusion
+ Handle(TColStd_HSequenceOfReal) mySteps; // magnitudes for each step
+ SMESH_SequenceOfNode myNodes; // nodes for using in sewing
+ };
+
+ /*!
+ * Create new node in the mesh with given coordinates
+ * (auxilary for advanced extrusion)
+ */
+ const SMDS_MeshNode* CreateNode(const double x,
+ const double y,
+ const double z,
+ const double tolnode,
+ SMESH_SequenceOfNode& aNodes);
+
+ /*!
+ * Generate new elements by extrusion of theElements
+ * It is a method used in .idl file. All functionality
+ * is implemented in the next method (see below) which
+ * is used in the cuurent method.
+ * param theElems - list of elements for extrusion
+ * param newElemsMap returns history of extrusion
+ * param theFlags set flags for performing extrusion (see description
+ * of enum ExtrusionFlags for additional information)
+ * param theTolerance - uses for comparing locations of nodes if flag
+ * EXTRUSION_FLAG_SEW is set
+ */
+ void ExtrusionSweep
+ (TIDSortedElemSet & theElems,
+ const gp_Vec& theStep,
+ const int theNbSteps,
+ TElemOfElemListMap& newElemsMap,
+ const int theFlags = EXTRUSION_FLAG_BOUNDARY,
+ const double theTolerance = 1.e-6);
+
+ /*!
+ * Generate new elements by extrusion of theElements
+ * param theElems - list of elements for extrusion
+ * param newElemsMap returns history of extrusion
+ * param theFlags set flags for performing extrusion (see description
+ * of enum ExtrusionFlags for additional information)
+ * param theTolerance - uses for comparing locations of nodes if flag
+ * EXTRUSION_FLAG_SEW is set
+ * param theParams - special structure for manage of extrusion
+ */
+ void ExtrusionSweep (TIDSortedElemSet & theElems,
+ ExtrusParam& theParams,
+ TElemOfElemListMap& newElemsMap,
+ const int theFlags,
+ const double theTolerance);
+
+
// Generate new elements by extrusion of theElements
// by theStep by theNbSteps
EXTR_CANT_GET_TANGENT
};
- Extrusion_Error ExtrusionAlongTrack (std::set<const SMDS_MeshElement*> & theElements,
- SMESH_subMesh* theTrackPattern,
- const SMDS_MeshNode* theNodeStart,
- const bool theHasAngles,
- std::list<double>& theAngles,
- const bool theHasRefPoint,
- const gp_Pnt& theRefPoint);
+ Extrusion_Error ExtrusionAlongTrack (TIDSortedElemSet & theElements,
+ SMESH_subMesh* theTrackPattern,
+ const SMDS_MeshNode* theNodeStart,
+ const bool theHasAngles,
+ std::list<double>& theAngles,
+ const bool theHasRefPoint,
+ const gp_Pnt& theRefPoint);
// Generate new elements by extrusion of theElements along path given by theTrackPattern,
// theHasAngles are the rotation angles, base point can be given by theRefPoint
- void Transform (std::set<const SMDS_MeshElement*> & theElements,
- const gp_Trsf& theTrsf,
- const bool theCopy);
+ void Transform (TIDSortedElemSet & theElements,
+ const gp_Trsf& theTrsf,
+ const bool theCopy);
// Move or copy theElements applying theTrsf to their nodes
typedef std::list< std::list< const SMDS_MeshNode* > > TListOfListOfNodes;
// Return list of group of nodes close to each other within theTolerance.
// Search among theNodes or in the whole mesh if theNodes is empty.
+ int SimplifyFace (const vector<const SMDS_MeshNode *> faceNodes,
+ vector<const SMDS_MeshNode *>& poly_nodes,
+ vector<int>& quantities) const;
+ // Split face, defined by <faceNodes>, into several faces by repeating nodes.
+ // Is used by MergeNodes()
+
void MergeNodes (TListOfListOfNodes & theNodeGroups);
// In each group, the cdr of nodes are substituted by the first one
// in all elements.
const SMDS_MeshNode* theNode3 = 0);
// Return true if the three nodes are on a free border
+ static bool FindFreeBorder (const SMDS_MeshNode* theFirstNode,
+ const SMDS_MeshNode* theSecondNode,
+ const SMDS_MeshNode* theLastNode,
+ std::list< const SMDS_MeshNode* > & theNodes,
+ std::list< const SMDS_MeshElement* >& theFaces);
+ // Return nodes and faces of a free border if found
+
enum Sew_Error {
SEW_OK,
// for SewFreeBorder()
SEW_DIFF_NB_OF_ELEMENTS,
SEW_TOPO_DIFF_SETS_OF_ELEMENTS,
SEW_BAD_SIDE1_NODES,
- SEW_BAD_SIDE2_NODES
+ SEW_BAD_SIDE2_NODES,
+ SEW_INTERNAL_ERROR
};
const SMDS_MeshNode* theSide2FirstNode,
const SMDS_MeshNode* theSide2SecondNode,
const SMDS_MeshNode* theSide2ThirdNode = 0,
- bool theSide2IsFreeBorder = true);
+ const bool theSide2IsFreeBorder = true,
+ const bool toCreatePolygons = false,
+ const bool toCreatePolyedrs = false);
// Sew the free border to the side2 by replacing nodes in
// elements on the free border with nodes of the elements
// of the side 2. If nb of links in the free border and
// nodes are inserted.
// Return false, if sewing failed.
- Sew_Error SewSideElements (std::set<const SMDS_MeshElement*>& theSide1,
- std::set<const SMDS_MeshElement*>& theSide2,
- const SMDS_MeshNode* theFirstNode1ToMerge,
- const SMDS_MeshNode* theFirstNode2ToMerge,
- const SMDS_MeshNode* theSecondNode1ToMerge,
- const SMDS_MeshNode* theSecondNode2ToMerge);
+ Sew_Error SewSideElements (TIDSortedElemSet& theSide1,
+ TIDSortedElemSet& theSide2,
+ const SMDS_MeshNode* theFirstNode1ToMerge,
+ const SMDS_MeshNode* theFirstNode2ToMerge,
+ const SMDS_MeshNode* theSecondNode1ToMerge,
+ const SMDS_MeshNode* theSecondNode2ToMerge);
// Sew two sides of a mesh. Nodes belonging to theSide1 are
// merged with nodes of elements of theSide2.
// Number of elements in theSide1 and in theSide2 must be
void InsertNodesIntoLink(const SMDS_MeshElement* theFace,
const SMDS_MeshNode* theBetweenNode1,
const SMDS_MeshNode* theBetweenNode2,
- std::list<const SMDS_MeshNode*>& theNodesToInsert);
- // insert theNodesToInsert into theFace between theBetweenNode1
- // and theBetweenNode2 and split theElement.
-
- static int SortQuadNodes (const SMDS_Mesh * theMesh,
- int theNodeIds[] );
- // Set 4 nodes of a quadrangle face in a good order.
- // Swap 1<->2 or 2<->3 nodes and correspondingly return
- // 1 or 2 else 0.
-
- static bool SortHexaNodes (const SMDS_Mesh * theMesh,
- int theNodeIds[] );
- // Set 8 nodes of a hexahedron in a good order.
- // Return success status
+ std::list<const SMDS_MeshNode*>& theNodesToInsert,
+ const bool toCreatePoly = false);
+ // insert theNodesToInsert into theFace between theBetweenNode1 and theBetweenNode2.
+ // If toCreatePoly is true, replace theFace by polygon, else split theFace.
+
+ void UpdateVolumes (const SMDS_MeshNode* theBetweenNode1,
+ const SMDS_MeshNode* theBetweenNode2,
+ std::list<const SMDS_MeshNode*>& theNodesToInsert);
+ // insert theNodesToInsert into all volumes, containing link
+ // theBetweenNode1 - theBetweenNode2, between theBetweenNode1 and theBetweenNode2.
+
+ void ConvertToQuadratic(const bool theForce3d);
+ //converts all mesh to quadratic one, deletes old elements, replacing
+ //them with quadratic ones with the same id.
+
+ bool ConvertFromQuadratic();
+ //converts all mesh from quadratic to ordinary ones, deletes old quadratic elements, replacing
+ //them with ordinary mesh elements with the same id.
+
+
+// static int SortQuadNodes (const SMDS_Mesh * theMesh,
+// int theNodeIds[] );
+// // Set 4 nodes of a quadrangle face in a good order.
+// // Swap 1<->2 or 2<->3 nodes and correspondingly return
+// // 1 or 2 else 0.
+//
+// static bool SortHexaNodes (const SMDS_Mesh * theMesh,
+// int theNodeIds[] );
+// // Set 8 nodes of a hexahedron in a good order.
+// // Return success status
static void AddToSameGroups (const SMDS_MeshElement* elemToAdd,
const SMDS_MeshElement* elemInGroups,
SMESHDS_Mesh * aMesh);
// Add elemToAdd to the groups the elemInGroups belongs to
+ static void RemoveElemFromGroups (const SMDS_MeshElement* removeelem,
+ SMESHDS_Mesh * aMesh);
+ // remove elemToAdd from the groups
+
static const SMDS_MeshElement*
- FindFaceInSet(const SMDS_MeshNode* n1,
- const SMDS_MeshNode* n2,
- const std::set<const SMDS_MeshElement*>& elemSet,
- const std::set<const SMDS_MeshElement*>& avoidSet);
+ FindFaceInSet(const SMDS_MeshNode* n1,
+ const SMDS_MeshNode* n2,
+ const TIDSortedElemSet& elemSet,
+ const TIDSortedElemSet& avoidSet);
// Return a face having linked nodes n1 and n2 and which is
// - not in avoidSet,
// - in elemSet provided that !elemSet.empty()
+ /*!
+ * \brief Find corresponding nodes in two sets of faces
+ * \param theSide1 - first face set
+ * \param theSide2 - second first face
+ * \param theFirstNode1 - a boundary node of set 1
+ * \param theFirstNode2 - a node of set 2 corresponding to theFirstNode1
+ * \param theSecondNode1 - a boundary node of set 1 linked with theFirstNode1
+ * \param theSecondNode2 - a node of set 2 corresponding to theSecondNode1
+ * \param nReplaceMap - output map of corresponding nodes
+ * \retval Sew_Error - is a success or not
+ */
+ static Sew_Error FindMatchingNodes(set<const SMDS_MeshElement*>& theSide1,
+ set<const SMDS_MeshElement*>& theSide2,
+ const SMDS_MeshNode* theFirstNode1,
+ const SMDS_MeshNode* theFirstNode2,
+ const SMDS_MeshNode* theSecondNode1,
+ const SMDS_MeshNode* theSecondNode2,
+ TNodeNodeMap & nReplaceMap);
+
+ /*!
+ * \brief Returns true if given node is medium
+ * \param n - node to check
+ * \param typeToCheck - type of elements containing the node to ask about node status
+ * \retval bool - check result
+ */
+ static bool IsMedium(const SMDS_MeshNode* node,
+ const SMDSAbs_ElementType typeToCheck = SMDSAbs_All);
+
int FindShape (const SMDS_MeshElement * theElem);
// Return an index of the shape theElem is on
// or zero if a shape not found
-
SMESH_Mesh * GetMesh() { return myMesh; }
SMESHDS_Mesh * GetMeshDS() { return myMesh->GetMeshDS(); }
+ SMESH_SequenceOfElemPtr GetLastCreatedNodes() { return myLastCreatedNodes; }
- private:
+ SMESH_SequenceOfElemPtr GetLastCreatedElems() { return myLastCreatedElems; }
+
+private:
+
+ void ConvertElemToQuadratic(SMESHDS_SubMesh *theSm,
+ SMESH_MesherHelper* theHelper,
+ const bool theForce3d);
+ //Auxiliary function for "ConvertToQuadratic" is intended to convert
+ //elements contained in submesh to quadratic
+
+ void RemoveQuadElem( SMESHDS_SubMesh *theSm,
+ SMDS_ElemIteratorPtr theItr,
+ RemoveQuadNodeMap& theRemoveNodeMap);
+ //Auxiliary function for "ConvertFromQuadratic" is intended to convert quadratic
+ //element to ordinary and for removing quadratic nodes
+
+private:
SMESH_Mesh * myMesh;
+ /*!
+ * Sequence for keeping nodes created during last operation
+ */
+ SMESH_SequenceOfElemPtr myLastCreatedNodes;
+
+ /*!
+ * Sequence for keeping elements created during last operation
+ */
+ SMESH_SequenceOfElemPtr myLastCreatedElems;
+
};
#endif