Editor of a mesh. More...

#include <SMESH_MeshEditor.hxx>

Classes

struct  ElemFeatures
 < Features of element to create More...
 
class  ExtrusParam
 

Public Types

enum  Bnd_Dimension { BND_2DFROM3D , BND_1DFROM3D , BND_1DFROM2D }
 
enum  Extrusion_Error {
  EXTR_OK , EXTR_NO_ELEMENTS , EXTR_PATH_NOT_EDGE , EXTR_BAD_PATH_SHAPE ,
  EXTR_BAD_STARTING_NODE , EXTR_BAD_ANGLES_NUMBER , EXTR_CANT_GET_TANGENT
}
 
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
}
 
typedef std::unique_ptr< std::list< int > > PGroupIDs
 
enum  Sew_Error {
  SEW_OK , SEW_BORDER1_NOT_FOUND , SEW_BORDER2_NOT_FOUND , SEW_BOTH_BORDERS_NOT_FOUND ,
  SEW_BAD_SIDE_NODES , SEW_VOLUMES_TO_SPLIT , SEW_DIFF_NB_OF_ELEMENTS , SEW_TOPO_DIFF_SETS_OF_ELEMENTS ,
  SEW_BAD_SIDE1_NODES , SEW_BAD_SIDE2_NODES , SEW_INTERNAL_ERROR
}
 
enum  SmoothMethod { LAPLACIAN = 0 , CENTROIDAL }
 
enum  SplitVolumToTetraFlags {
  HEXA_TO_5 = 1 , HEXA_TO_6 , HEXA_TO_24 , HEXA_TO_2_PRISMS ,
  HEXA_TO_4_PRISMS
}
 
typedef std::map< const SMDS_MeshElement *, TVecOfNnlmiMap, TElemSortTElemOfVecOfNnlmiMap
 
typedef TIDTypeCompare TElemSort
 
typedef std::map< const SMDS_MeshElement *, int, TIDCompareTFacetOfElem
 2nd arg of SplitVolumes() More...
 
typedef std::list< std::list< int > > TListOfListOfElementsID
 
typedef std::list< std::list< const SMDS_MeshNode * > > TListOfListOfNodes
 
typedef std::map< const SMDS_MeshNode *, std::list< const SMDS_MeshNode * > > TNodeOfNodeListMap
 
typedef TNodeOfNodeListMap::iterator TNodeOfNodeListMapItr
 
typedef std::map< const SMDS_MeshElement *, std::list< const SMDS_MeshElement * >, TElemSortTTElemOfElemListMap
 
typedef std::vector< TNodeOfNodeListMapItrTVecOfNnlmiMap
 

Public Member Functions

SMDS_MeshElementAddElement (const std::vector< const SMDS_MeshNode * > &nodes, const ElemFeatures &features)
 Add element. More...
 
SMDS_MeshElementAddElement (const std::vector< int > &nodeIDs, const ElemFeatures &features)
 Add element. More...
 
bool AffectedElemGroupsInRegion (const TIDSortedElemSet &theElems, const TIDSortedElemSet &theNodesNot, const TopoDS_Shape &theShape, TIDSortedElemSet &theAffectedElems)
 Identify the elements that will be affected by node duplication (actual duplication is not performed). This method is the first step of DoubleNodeElemGroupsInRegion. More...
 
int BestSplit (const SMDS_MeshElement *theQuad, SMESH::Controls::NumericalFunctorPtr theCriterion)
 Find better diagonal for splitting. More...
 
void ClearLastCreated ()
 Clears myLastCreatedNodes and myLastCreatedElems. More...
 
bool ConvertFromQuadratic ()
 
void ConvertFromQuadratic (TIDSortedElemSet &theElements)
 Makes given elements linear. More...
 
void ConvertToQuadratic (const bool theForce3d, const bool theToBiQuad)
 
void ConvertToQuadratic (const bool theForce3d, TIDSortedElemSet &theElements, const bool theToBiQuad)
 Makes given elements quadratic. More...
 
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. More...
 
bool CreateFlatElementsOnFacesGroups (const std::vector< TIDSortedElemSet > &theElems)
 Double nodes on some external faces and create flat elements. Flat elements are mainly used by some types of mechanic calculations. More...
 
void CreateHoleSkin (double radius, const TopoDS_Shape &theShape, SMESH_NodeSearcher *theNodeSearcher, const char *groupName, std::vector< double > &nodesCoords, std::vector< std::vector< int > > &listOfListOfNodes)
 identify all the elements around a geom shape, get the faces delimiting the hole Build groups of volume to remove, groups of faces to replace on the skin of the object, groups of faces to remove inside the object, (idem edges). Build ordered list of nodes at the border of each group of faces to replace (to be used to build a geom subshape) More...
 
bool DeleteDiag (const SMDS_MeshNode *theNode1, const SMDS_MeshNode *theNode2)
 
void DoubleElements (const TIDSortedElemSet &theElements)
 Create elements equal (on same nodes) to given ones. More...
 
bool DoubleNodes (const std::list< int > &theListOfNodes, const std::list< int > &theListOfModifiedElems)
 Creates a hole in a mesh by doubling the nodes of some particular elements. More...
 
bool DoubleNodes (const TIDSortedElemSet &theElems, const TIDSortedElemSet &theNodesNot, const TIDSortedElemSet &theAffectedElems)
 Creates a hole in a mesh by doubling the nodes of some particular elements. More...
 
bool DoubleNodesInRegion (const TIDSortedElemSet &theElems, const TIDSortedElemSet &theNodesNot, const TopoDS_Shape &theShape)
 Creates a hole in a mesh by doubling the nodes of some particular elements. More...
 
bool DoubleNodesOnGroupBoundaries (const std::vector< TIDSortedElemSet > &theElems, bool createJointElems, bool onAllBoundaries)
 Double nodes on shared faces between groups of volumes and create flat elements on demand. The list of groups must contain at least two groups. The groups have to be disjoint: no common element into two different groups. The nodes of the internal faces at the boundaries of the groups are doubled. Optionally, the internal faces are replaced by flat elements. Triangles are transformed into prisms, and quadrangles into hexahedrons. The flat elements are stored in groups of volumes. These groups are named according to the position of the group in the list: the group j_n_p is the group of the flat elements that are built between the group #n and the group #p in the list. If there is no shared faces between the group #n and the group #p in the list, the group j_n_p is not created. All the flat elements are gathered into the group named "joints3D" (or "joints2D" in 2D situation). The flat element of the multiple junctions between the simple junction are stored in a group named "jointsMultiples". More...
 
Extrusion_Error ExtrusionAlongTrack (TIDSortedElemSet theElements[2], SMESH_Mesh *theTrackPattern, const SMDS_MeshNode *theNodeStart, const bool theHasAngles, std::list< double > &theAngles, const bool theLinearVariation, const bool theHasRefPoint, const gp_Pnt &theRefPoint, const bool theMakeGroups)
 
Extrusion_Error ExtrusionAlongTrack (TIDSortedElemSet theElements[2], SMESH_subMesh *theTrackPattern, const SMDS_MeshNode *theNodeStart, const bool theHasAngles, std::list< double > &theAngles, const bool theLinearVariation, const bool theHasRefPoint, const gp_Pnt &theRefPoint, const bool theMakeGroups)
 
PGroupIDs ExtrusionSweep (TIDSortedElemSet theElems[2], const gp_Vec &theStep, const int theNbSteps, TTElemOfElemListMap &newElemsMap, const int theFlags, const double theTolerance=1.e-6)
 
PGroupIDs ExtrusionSweep (TIDSortedElemSet theElems[2], ExtrusParam &theParams, TTElemOfElemListMap &newElemsMap)
 
void FindCoincidentNodes (TIDSortedNodeSet &theNodes, const double theTolerance, TListOfListOfNodes &theGroupsOfNodes, bool theSeparateCornersAndMedium)
 Return list of group of nodes close to each other within theTolerance. More...
 
void FindEqualElements (TIDSortedElemSet &theElements, TListOfListOfElementsID &theGroupsOfElementsID)
 
int FindShape (const SMDS_MeshElement *theElem)
 
SMESH_ComputeErrorPtr & GetError ()
 
void GetHexaFacetsToSplit (TIDSortedElemSet &theHexas, const gp_Ax1 &theFacetNormal, TFacetOfElem &theFacets)
 For hexahedra that will be split into prisms, finds facets to split into triangles. More...
 
const SMESH_SequenceOfElemPtr & GetLastCreatedElems () const
 
const SMESH_SequenceOfElemPtr & GetLastCreatedNodes () const
 
SMESH_MeshGetMesh ()
 
SMESHDS_MeshGetMeshDS ()
 
void InsertNodesIntoLink (const SMDS_MeshElement *theFace, const SMDS_MeshNode *theBetweenNode1, const SMDS_MeshNode *theBetweenNode2, std::list< const SMDS_MeshNode * > &theNodesToInsert, const bool toCreatePoly=false)
 
bool InverseDiag (const SMDS_MeshElement *theTria1, const SMDS_MeshElement *theTria2)
 
bool InverseDiag (const SMDS_MeshNode *theNode1, const SMDS_MeshNode *theNode2)
 
bool Make2DMeshFrom3D ()
 Generated skin mesh (containing 2D cells) from 3D mesh The created 2D mesh elements based on nodes of free faces of boundary volumes. More...
 
int MakeBoundaryMesh (const TIDSortedElemSet &elements, Bnd_Dimension dimension, SMESH_Group *group=0, SMESH_Mesh *targetMesh=0, bool toCopyElements=false, bool toCopyExistingBondary=false, bool toAddExistingBondary=false, bool aroundElements=false)
 Creates missing boundary elements. More...
 
void MergeElements (TListOfListOfElementsID &theGroupsOfElementsID)
 
void MergeEqualElements ()
 
void MergeNodes (TListOfListOfNodes &theNodeGroups)
 
double OrientedAngle (const gp_Pnt &p0, const gp_Pnt &p1, const gp_Pnt &g1, const gp_Pnt &g2)
 compute an oriented angle between two planes defined by four points. The vector (p0,p1) defines the intersection of the 2 planes (p0,p1,g1) and (p0,p1,g2) More...
 
void QuadTo4Tri (TIDSortedElemSet &theElems)
 Split each of given quadrangles into 4 triangles. More...
 
bool QuadToTri (TIDSortedElemSet &theElems, const bool the13Diag)
 Split quadrangles into triangles. More...
 
bool QuadToTri (TIDSortedElemSet &theElems, SMESH::Controls::NumericalFunctorPtr theCriterion)
 Split quadrangles into triangles. More...
 
int Remove (const std::list< int > &theElemIDs, const bool isNodes)
 
bool Reorient (const SMDS_MeshElement *theElement)
 
int Reorient2D (TIDSortedElemSet &theFaces, const gp_Dir &theDirection, const SMDS_MeshElement *theFace)
 Reorient faces. More...
 
int Reorient2DBy3D (TIDSortedElemSet &theFaces, TIDSortedElemSet &theVolumes, const bool theOutsideNormal)
 Reorient faces basing on orientation of adjacent volumes. More...
 
PGroupIDs RotationSweep (TIDSortedElemSet theElements[2], const gp_Ax1 &theAxis, const double theAngle, const int theNbSteps, const double theToler, const bool theMakeGroups, const bool theMakeWalls=true)
 
Sew_Error SewFreeBorder (const SMDS_MeshNode *theBorderFirstNode, const SMDS_MeshNode *theBorderSecondNode, const SMDS_MeshNode *theBorderLastNode, const SMDS_MeshNode *theSide2FirstNode, const SMDS_MeshNode *theSide2SecondNode, const SMDS_MeshNode *theSide2ThirdNode=0, const bool theSide2IsFreeBorder=true, const bool toCreatePolygons=false, const bool toCreatePolyedrs=false)
 
Sew_Error SewSideElements (TIDSortedElemSet &theSide1, TIDSortedElemSet &theSide2, const SMDS_MeshNode *theFirstNode1ToMerge, const SMDS_MeshNode *theFirstNode2ToMerge, const SMDS_MeshNode *theSecondNode1ToMerge, const SMDS_MeshNode *theSecondNode2ToMerge)
 
int SimplifyFace (const std::vector< const SMDS_MeshNode * > &faceNodes, std::vector< const SMDS_MeshNode * > &poly_nodes, std::vector< int > &quantities) const
 
 SMESH_MeshEditor (SMESH_Mesh *theMesh)
 
void Smooth (TIDSortedElemSet &theElements, std::set< const SMDS_MeshNode * > &theFixedNodes, const SmoothMethod theSmoothMethod, const int theNbIterations, double theTgtAspectRatio=1.0, const bool the2D=true)
 
void SplitBiQuadraticIntoLinear (TIDSortedElemSet &theElems)
 Split bi-quadratic elements into linear ones without creation of additional nodes. More...
 
void SplitVolumes (const TFacetOfElem &theElems, const int theMethodFlags)
 Split volumic elements into tetrahedra or prisms. If facet ID < 0, element is split into tetrahedra, else a hexahedron is split into prisms so that the given facet is split into triangles. More...
 
PGroupIDs Transform (TIDSortedElemSet &theElements, const gp_Trsf &theTrsf, const bool theCopy, const bool theMakeGroups, SMESH_Mesh *theTargetMesh=0)
 Move or copy theElements applying theTrsf to their nodes. More...
 
bool TriToQuad (TIDSortedElemSet &theElems, SMESH::Controls::NumericalFunctorPtr theCriterion, const double theMaxAngle)
 Fuse neighbour triangles into quadrangles. More...
 
void UpdateVolumes (const SMDS_MeshNode *theBetweenNode1, const SMDS_MeshNode *theBetweenNode2, std::list< const SMDS_MeshNode * > &theNodesToInsert)
 

Static Public Member Functions

static void AddToSameGroups (const SMDS_MeshElement *elemToAdd, const SMDS_MeshElement *elemInGroups, SMESHDS_Mesh *aMesh)
 
static bool CheckFreeBorderNodes (const SMDS_MeshNode *theNode1, const SMDS_MeshNode *theNode2, const SMDS_MeshNode *theNode3=0)
 
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)
 
static Sew_Error FindMatchingNodes (std::set< const SMDS_MeshElement * > &theSide1, std::set< const SMDS_MeshElement * > &theSide2, const SMDS_MeshNode *theFirstNode1, const SMDS_MeshNode *theFirstNode2, const SMDS_MeshNode *theSecondNode1, const SMDS_MeshNode *theSecondNode2, TNodeNodeMap &theNodeReplaceMap)
 Find corresponding nodes in two sets of faces. More...
 
static void GetLinkedNodes (const SMDS_MeshNode *node, TIDSortedElemSet &linkedNodes, SMDSAbs_ElementType type=SMDSAbs_All)
 Return nodes linked to the given one in elements of the type. More...
 
static bool IsMedium (const SMDS_MeshNode *node, const SMDSAbs_ElementType typeToCheck=SMDSAbs_All)
 Returns true if given node is medium. More...
 
static void RemoveElemFromGroups (const SMDS_MeshElement *element, SMESHDS_Mesh *aMesh)
 
static void ReplaceElemInGroups (const SMDS_MeshElement *elemToRm, const SMDS_MeshElement *elemToAdd, SMESHDS_Mesh *aMesh)
 Replace elemToRm by elemToAdd in the all groups. More...
 
static void ReplaceElemInGroups (const SMDS_MeshElement *elemToRm, const std::vector< const SMDS_MeshElement * > &elemToAdd, SMESHDS_Mesh *aMesh)
 Replace elemToRm by elemToAdd in the all groups. More...
 

Detailed Description

Editor of a mesh.

Member Typedef Documentation

◆ PGroupIDs

typedef std::unique_ptr< std::list<int> > SMESH_MeshEditor::PGroupIDs

◆ TElemOfVecOfNnlmiMap

◆ TElemSort

◆ TFacetOfElem

2nd arg of SplitVolumes()

◆ TListOfListOfElementsID

typedef std::list< std::list< int > > SMESH_MeshEditor::TListOfListOfElementsID

◆ TListOfListOfNodes

typedef std::list< std::list< const SMDS_MeshNode* > > SMESH_MeshEditor::TListOfListOfNodes

◆ TNodeOfNodeListMap

typedef std::map<const SMDS_MeshNode*, std::list<const SMDS_MeshNode*> > SMESH_MeshEditor::TNodeOfNodeListMap

◆ TNodeOfNodeListMapItr

typedef TNodeOfNodeListMap::iterator SMESH_MeshEditor::TNodeOfNodeListMapItr

◆ TTElemOfElemListMap

typedef std::map< const SMDS_MeshElement*, std::list<const SMDS_MeshElement*>, TElemSort > SMESH_MeshEditor::TTElemOfElemListMap

◆ TVecOfNnlmiMap

Member Enumeration Documentation

◆ Bnd_Dimension

Enumerator
BND_2DFROM3D 
BND_1DFROM3D 
BND_1DFROM2D 

◆ Extrusion_Error

Enumerator
EXTR_OK 
EXTR_NO_ELEMENTS 
EXTR_PATH_NOT_EDGE 
EXTR_BAD_PATH_SHAPE 
EXTR_BAD_STARTING_NODE 
EXTR_BAD_ANGLES_NUMBER 
EXTR_CANT_GET_TANGENT 

◆ ExtrusionFlags

Flags of extrusion. BOUNDARY: create or not boundary for result of extrusion SEW: try to use existing nodes or create new nodes in any case GROUPS: to create groups BY_AVG_NORMAL: step size is measured along average normal to elements, 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()

Enumerator
EXTRUSION_FLAG_BOUNDARY 
EXTRUSION_FLAG_SEW 
EXTRUSION_FLAG_GROUPS 
EXTRUSION_FLAG_BY_AVG_NORMAL 
EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY 

◆ Sew_Error

Enumerator
SEW_OK 
SEW_BORDER1_NOT_FOUND 
SEW_BORDER2_NOT_FOUND 
SEW_BOTH_BORDERS_NOT_FOUND 
SEW_BAD_SIDE_NODES 
SEW_VOLUMES_TO_SPLIT 
SEW_DIFF_NB_OF_ELEMENTS 
SEW_TOPO_DIFF_SETS_OF_ELEMENTS 
SEW_BAD_SIDE1_NODES 
SEW_BAD_SIDE2_NODES 
SEW_INTERNAL_ERROR 

◆ SmoothMethod

Enumerator
LAPLACIAN 
CENTROIDAL 

◆ SplitVolumToTetraFlags

Enumerator
HEXA_TO_5 
HEXA_TO_6 
HEXA_TO_24 
HEXA_TO_2_PRISMS 
HEXA_TO_4_PRISMS 

Constructor & Destructor Documentation

◆ SMESH_MeshEditor()

SMESH_MeshEditor::SMESH_MeshEditor ( SMESH_Mesh theMesh)

Member Function Documentation

◆ AddElement() [1/2]

◆ AddElement() [2/2]

SMDS_MeshElement * SMESH_MeshEditor::AddElement ( const std::vector< int > &  nodeIDs,
const ElemFeatures features 
)

Add element.

References AddElement(), and GetMeshDS().

◆ AddToSameGroups()

void SMESH_MeshEditor::AddToSameGroups ( const SMDS_MeshElement elemToAdd,
const SMDS_MeshElement elemInGroups,
SMESHDS_Mesh aMesh 
)
static

◆ AffectedElemGroupsInRegion()

bool SMESH_MeshEditor::AffectedElemGroupsInRegion ( const TIDSortedElemSet &  theElems,
const TIDSortedElemSet &  theNodesNot,
const TopoDS_Shape &  theShape,
TIDSortedElemSet &  theAffectedElems 
)

Identify the elements that will be affected by node duplication (actual duplication is not performed). This method is the first step of DoubleNodeElemGroupsInRegion.

Parameters
theElems- list of groups of elements (edges or faces) to be replicated
theNodesNot- list of groups of nodes not to replicated
theShape- shape to detect affected elements (element which geometric center located on or inside shape). If the shape is null, detection is done on faces orientations (select elements with a gravity center on the side given by faces normals). This mode (null shape) is faster, but works only when theElems are faces, with coherents orientations. The replicated nodes should be associated to affected elements.
Returns
groups of affected elements
See also
DoubleNodeElemGroupsInRegion()

References SMESH_MeshAlgos::FaceNormal(), SMDS_MeshNode::GetInverseElementIterator(), SMDS_MeshElement::GetType(), SMDS_MeshElement::nodesIterator(), SMDS_MeshNode::X(), SMDS_MeshNode::Y(), and SMDS_MeshNode::Z().

◆ BestSplit()

int SMESH_MeshEditor::BestSplit ( const SMDS_MeshElement theQuad,
SMESH::Controls::NumericalFunctorPtr  theCriterion 
)

Find better diagonal for splitting.

Parameters
theQuad- The face to find better splitting of.
theCriterion- Is used to choose a diagonal for splitting.
Returns
int - 1 for 1-3 diagonal, 2 for 2-4, -1 - for errors.

References SMDS_MeshElement::GetType(), SMDS_MeshElement::IsQuadratic(), SMDS_MeshElement::NbNodes(), and SMDS_MeshElement::nodesIterator().

◆ CheckFreeBorderNodes()

bool SMESH_MeshEditor::CheckFreeBorderNodes ( const SMDS_MeshNode theNode1,
const SMDS_MeshNode theNode2,
const SMDS_MeshNode theNode3 = 0 
)
static

References FindFreeBorder().

◆ ClearLastCreated()

void SMESH_MeshEditor::ClearLastCreated ( )

Clears myLastCreatedNodes and myLastCreatedElems.

Referenced by DoubleElements().

◆ ConvertFromQuadratic() [1/2]

◆ ConvertFromQuadratic() [2/2]

void SMESH_MeshEditor::ConvertFromQuadratic ( TIDSortedElemSet &  theElements)

Makes given elements linear.

References SMESH_MeshAlgos::GetCommonNodes(), GetMeshDS(), and SMDS_MeshElement::IsQuadratic().

◆ ConvertToQuadratic() [1/2]

◆ ConvertToQuadratic() [2/2]

◆ Create0DElementsOnAllNodes()

void SMESH_MeshEditor::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.

Parameters
elements- Elements on whose nodes to create 0D elements; if empty, the all mesh is treated
all0DElems- returns all 0D elements found or created on nodes of elements

References SMDS_Mesh::elementsIterator(), and GetMeshDS().

◆ CreateFlatElementsOnFacesGroups()

bool SMESH_MeshEditor::CreateFlatElementsOnFacesGroups ( const std::vector< TIDSortedElemSet > &  theElems)

Double nodes on some external faces and create flat elements. Flat elements are mainly used by some types of mechanic calculations.

Each group of the list must be constituted of faces. Triangles are transformed in prisms, and quadrangles in hexahedrons.

Parameters
theElems- list of groups of faces, where a group of faces is a set of SMDS_MeshElements sorted by Id.
Returns
TRUE if operation has been completed successfully, FALSE otherwise

References SMESHDS_Group::Add(), SMESH_Mesh::AddGroup(), SMESHDS_Mesh::AddNode(), SMESHDS_Mesh::AddVolume(), SMDS_MeshCell::ChangeNodes(), draftmake.make_clone::clone, SMDS_MeshElement::GetID(), SMESH_Mesh::GetMeshDS(), SMDS_MeshFace::GetVtkType(), SMDS_MeshElement::IsMediumNode(), SMDS_MeshElement::IsQuadratic(), SMDS_MeshElement::nodesIterator(), SMDS_MeshNode::X(), SMDS_MeshNode::Y(), and SMDS_MeshNode::Z().

◆ CreateHoleSkin()

void SMESH_MeshEditor::CreateHoleSkin ( double  radius,
const TopoDS_Shape &  theShape,
SMESH_NodeSearcher theNodeSearcher,
const char *  groupName,
std::vector< double > &  nodesCoords,
std::vector< std::vector< int > > &  listOfListOfNodes 
)

identify all the elements around a geom shape, get the faces delimiting the hole Build groups of volume to remove, groups of faces to replace on the skin of the object, groups of faces to remove inside the object, (idem edges). Build ordered list of nodes at the border of each group of faces to replace (to be used to build a geom subshape)

References SMESHDS_Group::Add(), SMESH_Mesh::AddGroup(), SMESHDS_Mesh::BuildDownWardConnectivity(), SMESHDS_Group::Contains(), SMESH_NodeSearcher::FindClosestTo(), SMDS_Mesh::FindElement(), SMDS_Mesh::fromVtkToSmds(), SMDS_Downward::getCellDimension(), SMESHDS_Group::GetElements(), SMESHDS_GroupBase::GetElements(), SMDS_Mesh::getGrid(), SMESH_Group::GetGroupDS(), SMESH_Mesh::GetGroups(), SMDS_MeshElement::GetID(), SMDS_MeshNode::GetInverseElementIterator(), SMESH_Mesh::GetMeshDS(), SMDS_MeshElement::getshapeId(), SMESHDS_GroupBase::GetType(), SMDS_MeshElement::getVtkId(), and SMESHDS_GroupBase::IsEmpty().

◆ DeleteDiag()

◆ DoubleElements()

void SMESH_MeshEditor::DoubleElements ( const TIDSortedElemSet &  theElements)

Create elements equal (on same nodes) to given ones.

Parameters
[in]theElements- a set of elems to duplicate. If it is empty, all elements of the uppest dimension are duplicated.

References AddElement(), SMDS_MeshElement::begin_nodes(), ClearLastCreated(), SMDS_MeshElement::end_nodes(), GetMeshDS(), SMDS_MeshElement::GetType(), and SMESH_MeshEditor::ElemFeatures::Init().

◆ DoubleNodes() [1/2]

bool SMESH_MeshEditor::DoubleNodes ( const std::list< int > &  theListOfNodes,
const std::list< int > &  theListOfModifiedElems 
)

Creates a hole in a mesh by doubling the nodes of some particular elements.

Parameters
theNodes- identifiers of nodes to be doubled
theModifiedElems- identifiers of elements to be updated by the new (doubled) nodes. If list of element identifiers is empty then nodes are doubled but they not assigned to elements
Returns
TRUE if operation has been completed successfully, FALSE otherwise

References SMESHDS_Mesh::AddNode(), SMESHDS_Mesh::ChangeElementNodes(), SMDS_Mesh::FindElement(), SMDS_Mesh::FindNode(), GetMeshDS(), SMDS_MeshElement::NbNodes(), SMDS_MeshElement::nodesIterator(), SMDS_MeshNode::X(), SMDS_MeshNode::Y(), and SMDS_MeshNode::Z().

Referenced by DoubleNodesInRegion().

◆ DoubleNodes() [2/2]

bool SMESH_MeshEditor::DoubleNodes ( const TIDSortedElemSet &  theElems,
const TIDSortedElemSet &  theNodesNot,
const TIDSortedElemSet &  theAffectedElems 
)

Creates a hole in a mesh by doubling the nodes of some particular elements.

Parameters
theElems- the list of elements (edges or faces) to be replicated The nodes for duplication could be found from these elements
theNodesNot- list of nodes to NOT replicate
theAffectedElems- the list of elements (cells and edges) to which the replicated nodes should be associated to.
Returns
TRUE if operation has been completed successfully, FALSE otherwise

References GetMeshDS().

◆ DoubleNodesInRegion()

bool SMESH_MeshEditor::DoubleNodesInRegion ( const TIDSortedElemSet &  theElems,
const TIDSortedElemSet &  theNodesNot,
const TopoDS_Shape &  theShape 
)

Creates a hole in a mesh by doubling the nodes of some particular elements.

Parameters
theElems- group of of elements (edges or faces) to be replicated
theNodesNot- group of nodes not to replicate
theShape- shape to detect affected elements (element which geometric center located on or inside shape). The replicated nodes should be associated to affected elements.
Returns
TRUE if operation has been completed successfully, FALSE otherwise

References DoubleNodes(), SMDS_MeshNode::GetInverseElementIterator(), and SMDS_MeshElement::nodesIterator().

◆ DoubleNodesOnGroupBoundaries()

bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries ( const std::vector< TIDSortedElemSet > &  theElems,
bool  createJointElems,
bool  onAllBoundaries 
)

Double nodes on shared faces between groups of volumes and create flat elements on demand. The list of groups must contain at least two groups. The groups have to be disjoint: no common element into two different groups. The nodes of the internal faces at the boundaries of the groups are doubled. Optionally, the internal faces are replaced by flat elements. Triangles are transformed into prisms, and quadrangles into hexahedrons. The flat elements are stored in groups of volumes. These groups are named according to the position of the group in the list: the group j_n_p is the group of the flat elements that are built between the group #n and the group #p in the list. If there is no shared faces between the group #n and the group #p in the list, the group j_n_p is not created. All the flat elements are gathered into the group named "joints3D" (or "joints2D" in 2D situation). The flat element of the multiple junctions between the simple junction are stored in a group named "jointsMultiples".

Parameters
theElems- list of groups of volumes, where a group of volume is a set of SMDS_MeshElements sorted by Id.
createJointElems- if TRUE, create the elements
onAllBoundaries- if TRUE, the nodes and elements are also created on the boundary between theDomains and the rest mesh
Returns
TRUE if operation has been completed successfully, FALSE otherwise

References SMESHDS_Group::Add(), SMDS_Mesh::AddFaceFromVtkIds(), SMESH_Mesh::AddGroup(), SMESHDS_Mesh::AddNode(), SMDS_Mesh::AddVolumeFromVtkIds(), SMESHDS_Mesh::BuildDownWardConnectivity(), SMESHDS_Mesh::CleanDownWardConnectivity(), SMDS_Mesh::FindElement(), SMDS_Mesh::FindNodeVtk(), SMDS_Mesh::fromVtkToSmds(), SMDS_Mesh::getGrid(), SMDS_MeshElement::GetID(), SMESH_Mesh::GetMeshDS(), GetMeshDS(), SMDS_MeshElement::GetType(), SMDS_MeshElement::getVtkId(), SMDS_VtkVolume::gravityCenter(), SMESHDS_Mesh::ModifyCellNodes(), OrientedAngle(), SMESH_Mesh::RemoveGroup(), and counters::stats().

◆ ExtrusionAlongTrack() [1/2]

◆ ExtrusionAlongTrack() [2/2]

SMESH_MeshEditor::Extrusion_Error SMESH_MeshEditor::ExtrusionAlongTrack ( TIDSortedElemSet  theElements[2],
SMESH_subMesh theTrackPattern,
const SMDS_MeshNode theNodeStart,
const bool  theHasAngles,
std::list< double > &  theAngles,
const bool  theLinearVariation,
const bool  theHasRefPoint,
const gp_Pnt &  theRefPoint,
const bool  theMakeGroups 
)

◆ ExtrusionSweep() [1/2]

SMESH_MeshEditor::PGroupIDs SMESH_MeshEditor::ExtrusionSweep ( TIDSortedElemSet  theElems[2],
const gp_Vec &  theStep,
const int  theNbSteps,
TTElemOfElemListMap newElemsMap,
const int  theFlags,
const double  theTolerance = 1.e-6 
)

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 current method.

Parameters
theElems- list of elements for extrusion
newElemsMapreturns history of extrusion
theFlagsset flags for performing extrusion (see description of enum ExtrusionFlags for additional information)
theTolerance- uses for comparing locations of nodes if flag EXTRUSION_FLAG_SEW is set

◆ ExtrusionSweep() [2/2]

SMESH_MeshEditor::PGroupIDs SMESH_MeshEditor::ExtrusionSweep ( TIDSortedElemSet  theElems[2],
ExtrusParam theParams,
TTElemOfElemListMap newElemsMap 
)

Generate new elements by extrusion of theElements

Parameters
theElems- list of elements for extrusion
newElemsMapreturns history of extrusion
theFlagsset flags for performing extrusion (see description of enum ExtrusionFlags for additional information)
theTolerance- uses for comparing locations of nodes if flag EXTRUSION_FLAG_SEW is set
theParams- special structure for manage of extrusion

References SMDS_MeshElement::GetEntityType(), SMDS_MeshNode::GetInverseElementIterator(), GetMeshDS(), SMDS_MeshElement::GetType(), SMDS_MeshElement::IsMediumNode(), SMDS_MeshElement::IsQuadratic(), SMESH_MeshEditor::ExtrusParam::MakeNodes(), SMESH_Mesh::NbEdges(), SMESH_Mesh::NbFaces(), SMDS_MeshElement::NbNodes(), SMESH_MeshEditor::ExtrusParam::NbSteps(), SMESH_Mesh::NbVolumes(), SMDS_MeshElement::nodesIterator(), SMESH_MeshEditor::ExtrusParam::SetElementsToUse(), SMESH_MeshEditor::ExtrusParam::ToMakeBoundary(), and SMESH_MeshEditor::ExtrusParam::ToMakeGroups().

◆ FindCoincidentNodes()

void SMESH_MeshEditor::FindCoincidentNodes ( TIDSortedNodeSet &  theNodes,
const double  theTolerance,
TListOfListOfNodes theGroupsOfNodes,
bool  theSeparateCornersAndMedium 
)

Return list of group of nodes close to each other within theTolerance.

** Search among theNodes or in the whole mesh if theNodes is empty using

  • an Octree algorithm
    Parameters
    [in,out]theNodes- the nodes to treat
    [in]theTolerance- the tolerance
    [out]theGroupsOfNodes- the result groups of coincident nodes
    [in]theSeparateCornersAndMedium- if true, in quadratic mesh puts corner and medium nodes in separate groups

References SMESH_OctreeNode::FindCoincidentNodes(), GetMeshDS(), SMESH_MesherHelper::IsMedium(), SMESH_Mesh::NbEdges(), SMESH_Mesh::NbFaces(), SMESH_Mesh::NbVolumes(), and SMDS_Mesh::nodesIterator().

◆ FindEqualElements()

void SMESH_MeshEditor::FindEqualElements ( TIDSortedElemSet &  theElements,
TListOfListOfElementsID theGroupsOfElementsID 
)

◆ FindFreeBorder()

bool SMESH_MeshEditor::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 
)
static

◆ FindMatchingNodes()

SMESH_MeshEditor::Sew_Error SMESH_MeshEditor::FindMatchingNodes ( std::set< const SMDS_MeshElement * > &  theSide1,
std::set< const SMDS_MeshElement * > &  theSide2,
const SMDS_MeshNode theFirstNode1,
const SMDS_MeshNode theFirstNode2,
const SMDS_MeshNode theSecondNode1,
const SMDS_MeshNode theSecondNode2,
TNodeNodeMap &  nReplaceMap 
)
static

Find corresponding nodes in two sets of faces.

Parameters
theSide1- first face set
theSide2- second first face
theFirstNode1- a boundary node of set 1
theFirstNode2- a node of set 2 corresponding to theFirstNode1
theSecondNode1- a boundary node of set 1 linked with theFirstNode1
theSecondNode2- a node of set 2 corresponding to theSecondNode1
nReplaceMap- output map of corresponding nodes
Returns
Sew_Error - is a success or not
Parameters
theSide1- first face set
theSide2- second first face
theFirstNode1- a boundary node of set 1
theFirstNode2- a node of set 2 corresponding to theFirstNode1
theSecondNode1- a boundary node of set 1 linked with theFirstNode1
theSecondNode2- a node of set 2 corresponding to theSecondNode1
nReplaceMap- output map of corresponding nodes
Returns
bool - is a success or not

References SMDS_MeshElement::GetID(), SMDS_MeshNode::GetInverseElementIterator(), SMDS_MeshElement::GetNode(), SEW_BAD_SIDE1_NODES, SEW_BAD_SIDE2_NODES, SEW_OK, and SEW_TOPO_DIFF_SETS_OF_ELEMENTS.

Referenced by StdMeshers_ProjectionUtils::FindMatchingNodesOnFaces().

◆ FindShape()

◆ GetError()

SMESH_ComputeErrorPtr& SMESH_MeshEditor::GetError ( )

◆ GetHexaFacetsToSplit()

void SMESH_MeshEditor::GetHexaFacetsToSplit ( TIDSortedElemSet &  theHexas,
const gp_Ax1 &  theFacetNormal,
TFacetOfElem theFacets 
)

◆ GetLastCreatedElems()

const SMESH_SequenceOfElemPtr& SMESH_MeshEditor::GetLastCreatedElems ( ) const

◆ GetLastCreatedNodes()

const SMESH_SequenceOfElemPtr& SMESH_MeshEditor::GetLastCreatedNodes ( ) const

◆ GetLinkedNodes()

void SMESH_MeshEditor::GetLinkedNodes ( const SMDS_MeshNode theNode,
TIDSortedElemSet &  linkedNodes,
SMDSAbs_ElementType  type = SMDSAbs_All 
)
static

Return nodes linked to the given one in elements of the type.

Return nodes linked to the given one.

Parameters
theNode- the node
linkedNodes- the found nodes
type- the type of elements to check

Medium nodes are ignored

References SMDS_MeshNode::GetInverseElementIterator(), SMDS_MeshElement::GetNodeWrap(), SMDS_MeshElement::GetType(), SMDS_VolumeTool::IsLinked(), SMDS_MeshElement::IsQuadratic(), SMDS_MeshElement::NbNodes(), SMDS_MeshElement::nodesIterator(), and SMESH_MesherHelper::WrapIndex().

◆ GetMesh()

◆ GetMeshDS()

◆ InsertNodesIntoLink()

◆ InverseDiag() [1/2]

◆ InverseDiag() [2/2]

bool SMESH_MeshEditor::InverseDiag ( const SMDS_MeshNode theNode1,
const SMDS_MeshNode theNode2 
)

◆ IsMedium()

bool SMESH_MeshEditor::IsMedium ( const SMDS_MeshNode node,
const SMDSAbs_ElementType  typeToCheck = SMDSAbs_All 
)
static

Returns true if given node is medium.

Parameters
n- node to check
typeToCheck- type of elements containing the node to ask about node status
Returns
bool - check result

References SMDS_MeshNode::GetInverseElementIterator(), and SMDS_MeshElement::IsMediumNode().

Referenced by StdMeshers_FaceSide::GetEdgeNodes(), SMESH_MesherHelper::IsMedium(), SMESH_Pattern::Load(), and Smooth().

◆ Make2DMeshFrom3D()

bool SMESH_MeshEditor::Make2DMeshFrom3D ( )

Generated skin mesh (containing 2D cells) from 3D mesh The created 2D mesh elements based on nodes of free faces of boundary volumes.

Generates skin mesh (containing 2D cells) from 3D mesh The created 2D mesh elements based on nodes of free faces of boundary volumes.

Returns
TRUE if operation has been completed successfully, FALSE otherwise

References AddElement(), SMDS_Mesh::FindElement(), SMDS_VolumeTool::GetFaceNodes(), GetMeshDS(), SMDS_VolumeTool::IsFreeFace(), SMDS_MeshElement::IsQuadratic(), SMDS_VolumeTool::NbFaceNodes(), SMDS_VolumeTool::NbFaces(), SMDS_VolumeTool::SetExternalNormal(), SMESH_MeshEditor::ElemFeatures::SetPoly(), SMESH_MeshEditor::ElemFeatures::SetQuad(), and SMDS_Mesh::volumesIterator().

◆ MakeBoundaryMesh()

int SMESH_MeshEditor::MakeBoundaryMesh ( const TIDSortedElemSet &  elements,
Bnd_Dimension  dimension,
SMESH_Group group = 0,
SMESH_Mesh targetMesh = 0,
bool  toCopyElements = false,
bool  toCopyExistingBoundary = false,
bool  toAddExistingBondary = false,
bool  aroundElements = false 
)

Creates missing boundary elements.

Parameters
elements- elements whose boundary is to be checked
dimension- defines type of boundary elements to create
group- a group to store created boundary elements in
targetMesh- a mesh to store created boundary elements in
toCopyElements- if true, the checked elements will be copied into the targetMesh
toCopyExistingBoundary- if true, not only new but also pre-existing boundary elements will be copied into the targetMesh
toAddExistingBondary- if true, not only new but also pre-existing boundary elements will be added into the new group
aroundElements- if true, elements will be created on boundary of given elements else, on boundary of the whole mesh.
Returns
nb of added boundary elements

References AddElement(), BND_1DFROM2D, BND_2DFROM3D, SMDS_Mesh::elementsIterator(), SMDS_Mesh::FindEdge(), SMDS_Mesh::FindElement(), SMESH_MeshAlgos::FindFaceInSet(), SMDS_VolumeTool::GetCenterNodeIndex(), SMDS_VolumeTool::GetFaceNodes(), SMESH_MesherHelper::GetMediumPos(), GetMesh(), GetMeshDS(), SMDS_MeshElement::GetNode(), SMDS_VolumeTool::GetNodes(), SMDS_MeshElement::GetType(), SMESHDS_Mesh::IndexToShape(), SMESH_MeshEditor::ElemFeatures::Init(), SMDS_MeshElement::interlacedNodesElemIterator(), SMDS_VolumeTool::IsFreeFace(), SMDS_MeshElement::IsQuadratic(), SMESH_MesherHelper::IsSubShape(), SMDS_MeshElement::NbCornerNodes(), SMDS_VolumeTool::NbFaceNodes(), SMDS_VolumeTool::NbFaces(), SMDS_MeshElement::NbNodes(), SMDS_VolumeTool::Set(), SMDS_VolumeTool::SetExternalNormal(), and SMESHDS_Mesh::SetMeshElementOnShape().

◆ MergeElements()

void SMESH_MeshEditor::MergeElements ( TListOfListOfElementsID theGroupsOfElementsID)

◆ MergeEqualElements()

void SMESH_MeshEditor::MergeEqualElements ( )

◆ MergeNodes()

◆ OrientedAngle()

double SMESH_MeshEditor::OrientedAngle ( const gp_Pnt &  p0,
const gp_Pnt &  p1,
const gp_Pnt &  g1,
const gp_Pnt &  g2 
)

compute an oriented angle between two planes defined by four points. The vector (p0,p1) defines the intersection of the 2 planes (p0,p1,g1) and (p0,p1,g2)

Parameters
p0base of the rotation axe
p1extremity of the rotation axe
g1belongs to the first plane
g2belongs to the second plane

References draftgeoutils.general::v1().

Referenced by DoubleNodesOnGroupBoundaries().

◆ QuadTo4Tri()

◆ QuadToTri() [1/2]

◆ QuadToTri() [2/2]

◆ Remove()

◆ RemoveElemFromGroups()

void SMESH_MeshEditor::RemoveElemFromGroups ( const SMDS_MeshElement element,
SMESHDS_Mesh aMesh 
)
static

◆ Reorient()

◆ Reorient2D()

int SMESH_MeshEditor::Reorient2D ( TIDSortedElemSet &  theFaces,
const gp_Dir &  theDirection,
const SMDS_MeshElement theFace 
)

Reorient faces.

Parameters
theFaces- the faces to reorient. If empty the whole mesh is meant
theDirection- desired direction of normal of theFace
theFace- one of theFaces that sould be oriented according to theDirection and whose orientation defines orientation of other faces
Returns
number of reoriented faces.

References SMESH_MeshAlgos::FaceNormal(), SMDS_Mesh::facesIterator(), SMESH_MeshAlgos::FindFaceInSet(), GetMeshDS(), SMDS_MeshElement::GetNode(), SMDS_MeshElement::GetType(), SMDS_MeshElement::NbCornerNodes(), and Reorient().

◆ Reorient2DBy3D()

int SMESH_MeshEditor::Reorient2DBy3D ( TIDSortedElemSet &  theFaces,
TIDSortedElemSet &  theVolumes,
const bool  theOutsideNormal 
)

Reorient faces basing on orientation of adjacent volumes.

Parameters
theFaces- faces to reorient. If empty, all mesh faces are treated.
theVolumes- reference volumes.
theOutsideNormal- to orient faces to have their normal pointing either outside or inside the adjacent volumes.
Returns
number of reoriented faces.

References SMDS_Mesh::elementsIterator(), SMDS_VolumeTool::GetFaceIndex(), SMDS_VolumeTool::GetFaceNodes(), GetMeshDS(), SMDS_MeshElement::GetNodeIndex(), SMDS_MeshElement::NbCornerNodes(), Reorient(), SMDS_VolumeTool::Set(), and SMDS_VolumeTool::SetExternalNormal().

◆ ReplaceElemInGroups() [1/2]

void SMESH_MeshEditor::ReplaceElemInGroups ( const SMDS_MeshElement elemToRm,
const SMDS_MeshElement elemToAdd,
SMESHDS_Mesh aMesh 
)
static

◆ ReplaceElemInGroups() [2/2]

void SMESH_MeshEditor::ReplaceElemInGroups ( const SMDS_MeshElement elemToRm,
const std::vector< const SMDS_MeshElement * > &  elemToAdd,
SMESHDS_Mesh aMesh 
)
static

Replace elemToRm by elemToAdd in the all groups.

References SMDS_MeshGroup::Add(), SMESHDS_Mesh::GetGroups(), and SMESHDS_Group::SMDSGroup().

◆ RotationSweep()

◆ SewFreeBorder()

◆ SewSideElements()

◆ SimplifyFace()

int SMESH_MeshEditor::SimplifyFace ( const std::vector< const SMDS_MeshNode * > &  faceNodes,
std::vector< const SMDS_MeshNode * > &  poly_nodes,
std::vector< int > &  quantities 
) const

Referenced by MergeNodes().

◆ Smooth()

◆ SplitBiQuadraticIntoLinear()

void SMESH_MeshEditor::SplitBiQuadraticIntoLinear ( TIDSortedElemSet &  theElems)

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.
    Parameters
    elems- elements to split

References SMESHDS_SubMesh::AddElement(), AddElement(), SMDS_MeshElement::begin_nodes(), SMDS_MeshElement::end_nodes(), SMDS_MeshElement::GetEntityType(), GetMeshDS(), SMDS_MeshElement::getshapeId(), and ReplaceElemInGroups().

◆ SplitVolumes()

◆ Transform()

SMESH_MeshEditor::PGroupIDs SMESH_MeshEditor::Transform ( TIDSortedElemSet &  theElems,
const gp_Trsf &  theTrsf,
const bool  theCopy,
const bool  theMakeGroups,
SMESH_Mesh theTargetMesh = 0 
)

Move or copy theElements applying theTrsf to their nodes.

Parameters
theElems- elements to transform, if theElems is empty then apply to all mesh nodes
theTrsf- transformation to apply
theCopy- if true, create translated copies of theElems
theMakeGroups- if true and theCopy, create translated groups
theTargetMesh- mesh to copy translated elements into
Returns
SMESH_MeshEditor::PGroupIDs - list of ids of created groups

References SMESHDS_Mesh::AddNode(), SMESHDS_Mesh::ChangeElementNodes(), SMDS_Mesh::elementsIterator(), draftgeoutils.general::geomType(), SMDS_MeshElement::GetEntityType(), SMDS_VtkVolume::GetFaceNode(), SMDS_MeshElement::GetGeomType(), SMDS_MeshNode::GetInverseElementIterator(), SMESH_Mesh::GetMeshDS(), GetMeshDS(), SMDS_MeshNode::GetXYZ(), SMESH_MeshEditor::ElemFeatures::Init(), SMESHDS_Mesh::MoveNode(), SMDS_VtkVolume::NbFaceNodes(), SMDS_VtkVolume::NbFaces(), SMDS_MeshNode::NbInverseElements(), SMDS_MeshElement::NbNodes(), SMDS_MeshElement::nodesIterator(), SMDS_Mesh::nodesIterator(), SMDS_SpacePosition::originSpacePosition(), and SMDS_MeshCell::reverseSmdsOrder().

◆ TriToQuad()

bool SMESH_MeshEditor::TriToQuad ( TIDSortedElemSet &  theElems,
SMESH::Controls::NumericalFunctorPtr  theCriterion,
const double  theMaxAngle 
)

Fuse neighbour triangles into quadrangles.

Parameters
theElems- The triangles to be fused.
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.
Returns
bool - Success or not.

References SMESHDS_Mesh::AddFace(), AddToSameGroups(), GetMeshDS(), SMDS_MeshElement::getshapeId(), SMDS_MeshElement::GetType(), SMDS_MeshElement::NbCornerNodes(), SMDS_MeshElement::NbNodes(), SMDS_MeshElement::nodeIterator(), SMESHDS_Mesh::RemoveElement(), SMESHDS_Mesh::RemoveNode(), and SMESHDS_Mesh::SetMeshElementOnShape().

◆ UpdateVolumes()


The documentation for this class was generated from the following files:
  • Sources/FreeCAD/src/3rdParty/salomesmesh/inc/SMESH_MeshEditor.hxx
  • Sources/FreeCAD/src/3rdParty/salomesmesh/src/SMESH/SMESH_MeshEditor.cpp