-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024 CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
{
SMDSAbs_ElementType myType;
bool myIsPoly, myIsQuad;
- int myID;
+ smIdType myID;
double myBallDiameter;
std::vector<int> myPolyhedQuantities;
std::vector<const SMDS_MeshNode*> myNodes; // not managed by ElemFeatures
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; }
+ SMESH_EXPORT ElemFeatures& SetID (smIdType ID) { myID = ID; return *this; }
};
/*!
/*!
* \brief Add element
*/
- SMDS_MeshElement* AddElement(const std::vector<int> & nodeIDs,
- const ElemFeatures& features);
+ SMDS_MeshElement* AddElement(const std::vector<smIdType> & nodeIDs,
+ const ElemFeatures& features);
+ /*!
+ * \brief Remove a node and fill a hole appeared by changing surrounding faces
+ */
+ void RemoveNodeWithReconnection( const SMDS_MeshNode* node );
- int Remove (const std::list< int >& theElemIDs, const bool isNodes);
+ smIdType Remove (const std::list< smIdType >& theElemIDs, const bool isNodes);
// Remove a node or an element.
// Modify a compute state of sub-meshes which become empty
// with a quadrangle built on the same 4 nodes.
// Return false if proper faces not found
+ void SplitEdge (const SMDS_MeshNode * theNode1,
+ const SMDS_MeshNode * theNode2,
+ double thePosition);
+ // Replace each triangle bound by theNode1-theNode2 link
+ // with two triangles by connecting a node made on the link with a node opposite to the link.
+
+ void SplitFace (const SMDS_MeshElement * theFace,
+ double theX,
+ double theY,
+ double theZ );
+ // Split a face into triangles each formed by two nodes of the face and a new node added
+ // at the given coordinates.
+
+
bool Reorient (const SMDS_MeshElement * theElement);
// Reverse theElement orientation
- int Reorient2D (TIDSortedElemSet & theFaces,
- const gp_Dir& theDirection,
- const SMDS_MeshElement * theFace);
- // Reverse theFaces whose orientation to be same as that of theFace
- // oriented according to theDirection. Return nb of reoriented faces
+ int Reorient2D (TIDSortedElemSet & theFaces,
+ const gp_Vec& theDirection,
+ TIDSortedElemSet & theRefFaces,
+ bool theAllowNonManifold);
+ // Reverse theFaces whose orientation to be same as that of theRefFaces
+ // optionally oriented according to theDirection. Return nb of reoriented faces
int Reorient2DBy3D (TIDSortedElemSet & theFaces,
TIDSortedElemSet & theVolumes,
typedef TNodeOfNodeListMap::iterator TNodeOfNodeListMapItr;
typedef std::vector<TNodeOfNodeListMapItr> TVecOfNnlmiMap;
typedef std::map<const SMDS_MeshElement*, TVecOfNnlmiMap, TElemSort > TElemOfVecOfNnlmiMap;
- typedef std::auto_ptr< std::list<int> > PGroupIDs;
+ typedef std::unique_ptr< std::list< int > > PGroupIDs;
PGroupIDs RotationSweep (TIDSortedElemSet theElements[2],
const gp_Ax1& theAxis,
* 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
+ * ANGLE_LINEAR_VARIATION: to make linear variation of angles
*/
enum ExtrusionFlags {
EXTRUSION_FLAG_BOUNDARY = 0x01,
EXTRUSION_FLAG_GROUPS = 0x04,
EXTRUSION_FLAG_BY_AVG_NORMAL = 0x08,
EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY = 0x10,
- EXTRUSION_FLAG_SCALE_LINEAR_VARIATION = 0x20
+ EXTRUSION_FLAG_SCALE_LINEAR_VARIATION = 0x20,
+ EXTRUSION_FLAG_ANGLE_LINEAR_VARIATION = 0x40
};
/*!
*/
class SMESH_EXPORT ExtrusParam
{
- gp_Dir myDir; // direction of extrusion
- Handle(TColStd_HSequenceOfReal) mySteps; // magnitudes for each step
- std::vector<double> 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
- const TIDSortedElemSet* myElemsToUse; // elements to use for extrusion by normal
-
- int (ExtrusParam::*myMakeNodesFun)(SMESHDS_Mesh* mesh,
- const SMDS_MeshNode* srcNode,
- std::list<const SMDS_MeshNode*> & newNodes,
- const bool makeMediumNodes);
-
public:
+ //! Point on extrusion path
+ struct PathPoint
+ {
+ gp_Pnt myPnt;
+ gp_Dir myTgt;
+ double myAngle, myScale;
+ PathPoint(): myPnt(99., 99., 99.), myTgt(1.,0.,0.), myAngle(0), myScale(0) {}
+ };
+
ExtrusParam( const gp_Vec& theStep,
const int theNbSteps,
const std::list<double>& theScales,
+ const std::list<double>& theAngles,
const gp_XYZ* theBaseP,
const int theFlags = 0,
const double theTolerance = 1e-6);
const int theNbSteps,
const int theFlags,
const int theDim); // for extrusion by normal
+ ExtrusParam( const std::vector< PathPoint >& thePoints,
+ const gp_Pnt* theBaseP,
+ const std::list<double>& theScales,
+ const bool theMakeGroups); // for extrusion along path
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(); }
-
+ bool IsScaleVariation() const { return myFlags & EXTRUSION_FLAG_SCALE_LINEAR_VARIATION; }
+ bool IsAngleVariation() const { return myFlags & EXTRUSION_FLAG_ANGLE_LINEAR_VARIATION; }
+ int NbSteps() const {
+ return mySteps.IsNull() ? (int)myPathPoints.size() - 1: mySteps->Length();
+ }
// stores elements to use for extrusion by normal, depending on
// state of EXTRUSION_FLAG_USE_INPUT_ELEMS_ONLY flag;
// define myBaseP for scaling
}
private:
+ gp_Dir myDir; // direction of extrusion
+ Handle(TColStd_HSequenceOfReal) mySteps; // magnitudes for each step
+ std::vector<double> myScales;// scale factors
+ std::vector<double> myAngles;// angles
+ gp_XYZ myBaseP; // scaling/rotation center
+ SMESH_SequenceOfNode myNodes; // nodes for using in sewing
+ int myFlags; // see ExtrusionFlags
+ double myTolerance; // tolerance for sewing nodes
+ const TIDSortedElemSet* myElemsToUse; // elements to use for extrusion by normal
+ std::vector< PathPoint > myPathPoints; // points along a path
+ int (ExtrusParam::* myMakeNodesFun)(SMESHDS_Mesh*, // function of extrusion method
+ const SMDS_MeshNode*,
+ std::list<const SMDS_MeshNode*> &,
+ const bool);
int makeNodesByDir( SMESHDS_Mesh* mesh,
const SMDS_MeshNode* srcNode,
std::list<const SMDS_MeshNode*> & newNodes,
const SMDS_MeshNode* srcNode,
std::list<const SMDS_MeshNode*> & newNodes,
const bool makeMediumNodes);
+ int makeNodesAlongTrack( SMESHDS_Mesh* mesh,
+ const SMDS_MeshNode* srcNode,
+ std::list<const SMDS_MeshNode*> & newNodes,
+ const bool makeMediumNodes);
// step iteration
void beginStepIter( bool withMediumNodes );
bool moreSteps();
};
Extrusion_Error ExtrusionAlongTrack (TIDSortedElemSet theElements[2],
- SMESH_subMesh* theTrackPattern,
+ SMESH_Mesh* theTrackMesh,
+ SMDS_ElemIteratorPtr theTrackIterator,
const SMDS_MeshNode* theNodeStart,
- const bool theHasAngles,
std::list<double>& theAngles,
- const bool theLinearVariation,
- const bool theHasRefPoint,
- const gp_Pnt& theRefPoint,
+ const bool theAngleVariation,
+ std::list<double>& theScales,
+ const bool theScaleVariation,
+ const gp_Pnt* theRefPoint,
const bool theMakeGroups);
- 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);
- // Generate new elements by extrusion of theElements along path given by theTrackPattern,
+ // Generate new elements by extrusion of theElements along path given by theTrackIterator,
// theHasAngles are the rotation angles, base point can be given by theRefPoint
PGroupIDs Transform (TIDSortedElemSet & theElements,
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,
// In each group, the cdr of nodes are substituted by the first one
// in all elements.
- typedef std::list< std::list< int > > TListOfListOfElementsID;
+ typedef std::list< std::list< smIdType > > TListOfListOfElementsID;
void FindEqualElements(TIDSortedElemSet & theElements,
TListOfListOfElementsID & theGroupsOfElementsID);
bool toCopyElements = false,
bool toCopyExistingBondary = false,
bool toAddExistingBondary = false,
- bool aroundElements = false);
-
-
- // structure used in MakePolyLine() to define a cutting plane
- struct PolySegment
- {
- // 2 points: if myNode2 != 0, then the point is the middle of a face edge defined
- // by two nodes, else it is at myNode1
- const SMDS_MeshNode* myNode1[2];
- const SMDS_MeshNode* myNode2[2];
-
- gp_Vec myVector; // vector on the plane; to use a default plane set vector = (0,0,0)
-
- // point to return coordinates of a middle of the two points, projected to mesh
- gp_Pnt myMidProjPoint;
- };
- typedef std::vector<PolySegment> 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);
+ bool aroundElements = false,
+ bool toCreateAllElements= false);
private:
/*!
* \brief Convert elements contained in a submesh to quadratic
- * \return int - nb of checked elements
+ * \return smIdType - nb of checked elements
*/
- int convertElemToQuadratic(SMESHDS_SubMesh * theSm,
- SMESH_MesherHelper& theHelper,
- const bool theForce3d);
+ smIdType convertElemToQuadratic(SMESHDS_SubMesh * theSm,
+ SMESH_MesherHelper& theHelper,
+ const bool theForce3d);
/*!
* \brief Convert quadratic elements to linear ones and remove quadratic nodes
* \return nb of checked elements
*/
- int removeQuadElem( SMESHDS_SubMesh * theSm,
- SMDS_ElemIteratorPtr theItr,
- const int theShapeID);
+ smIdType removeQuadElem( SMESHDS_SubMesh * theSm,
+ SMDS_ElemIteratorPtr theItr,
+ const int theShapeID);
/*!
* \brief Create groups of elements made during transformation
* \param nodeGens - nodes making corresponding myLastCreatedNodes
const int nbSteps,
SMESH_SequenceOfElemPtr& srcElements);
- struct SMESH_MeshEditor_PathPoint
- {
- gp_Pnt myPnt;
- gp_Dir myTgt;
- double myAngle, myPrm;
-
- SMESH_MeshEditor_PathPoint(): myPnt(99., 99., 99.), myTgt(1.,0.,0.), myAngle(0), myPrm(0) {}
- void SetPnt (const gp_Pnt& aP3D) { myPnt =aP3D; }
- void SetTangent (const gp_Dir& aTgt) { myTgt =aTgt; }
- void SetAngle (const double& aBeta) { myAngle=aBeta; }
- void SetParameter(const double& aPrm) { myPrm =aPrm; }
- const gp_Pnt& Pnt ()const { return myPnt; }
- const gp_Dir& Tangent ()const { return myTgt; }
- double Angle ()const { return myAngle; }
- double Parameter ()const { return myPrm; }
- };
- Extrusion_Error makeEdgePathPoints(std::list<double>& aPrms,
- const TopoDS_Edge& aTrackEdge,
- bool aFirstIsStart,
- std::list<SMESH_MeshEditor_PathPoint>& aLPP);
- Extrusion_Error makeExtrElements(TIDSortedElemSet theElements[2],
- std::list<SMESH_MeshEditor_PathPoint>& theFullList,
- const bool theHasAngles,
- std::list<double>& theAngles,
- const bool theLinearVariation,
- const bool theHasRefPoint,
- const gp_Pnt& theRefPoint,
- const bool theMakeGroups);
static void linearAngleVariation(const int NbSteps,
std::list<double>& theAngles);
+ static void linearScaleVariation(const int NbSteps,
+ std::list<double>& theScales);
bool doubleNodes( SMESHDS_Mesh* theMeshDS,
const TIDSortedElemSet& theElems,
