-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2021 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
class StdMeshers_QuadFromMedialAxis_1D2D::Algo1D : public StdMeshers_Regular_1D
{
public:
- Algo1D(int studyId, SMESH_Gen* gen):
- StdMeshers_Regular_1D( gen->GetANewId(), studyId, gen )
+ Algo1D(SMESH_Gen* gen):
+ StdMeshers_Regular_1D( gen->GetANewId(), gen )
{
}
void SetSegmentLength( double len )
//================================================================================
StdMeshers_QuadFromMedialAxis_1D2D::StdMeshers_QuadFromMedialAxis_1D2D(int hypId,
- int studyId,
SMESH_Gen* gen)
- : StdMeshers_Quadrangle_2D(hypId, studyId, gen),
+ : StdMeshers_Quadrangle_2D(hypId, gen),
_regular1D( 0 )
{
_name = "QuadFromMedialAxis_1D2D";
virtual void ProcessEvent(const int event,
const int eventType,
SMESH_subMesh* faceSubMesh,
- SMESH_subMeshEventListenerData* data,
- const SMESH_Hypothesis* hyp)
+ SMESH_subMeshEventListenerData* /*data*/,
+ const SMESH_Hypothesis* /*hyp*/)
{
if ( eventType == SMESH_subMesh::ALGO_EVENT )
{
theSinuEdges [0].size() > 0 && theSinuEdges [1].size() > 0 );
// the sinuous EDGEs can be composite and C0 continuous,
- // therefor we use a complex criterion to find TWO short non-sinuous EDGEs
+ // therefore we use a complex criterion to find TWO short non-sinuous EDGEs
// and the rest EDGEs will be treated as sinuous.
// A short edge should have the following features:
// a) straight
}
// cout << "from salome.geom import geomBuilder" << endl;
- // cout << "geompy = geomBuilder.New(salome.myStudy)" << endl;
+ // cout << "geompy = geomBuilder.New()" << endl;
Handle(TColgp_HArray1OfPnt) points = new TColgp_HArray1OfPnt(1, pnt.size());
for ( size_t i = 0; i < pnt.size(); ++i )
{
* \param [in] theDivPoints - projections of VERTEXes to MA
* \param [in] theSinuEdges - the sinuous EDGEs
* \param [in] theSideEdgeIDs - indices of sinuous EDGEs per side
- * \param [in] theIsEdgeComputed - is sinuous EGDE is meshed
+ * \param [in] theIsEdgeComputed - is sinuous EDGE is meshed
* \param [in,out] thePointsOnE - the map to fill
* \param [out] theNodes2Merge - the map of nodes to merge
*/
bool isShortPrev[2], isShortNext[2], isPrevCloser[2];
TMAPar2NPoints::iterator u2NPPrev = u2NP, u2NPNext = u2NP;
--u2NPPrev; ++u2NPNext;
+ if ( u2NPNext == thePointsOnE.end() )
+ u2NPNext = thePointsOnE.begin(); // hope theSinuFace.IsRing()
for ( int iS = 0; iS < 2; ++iS ) // side with Vertex and side with Nodes
{
NodePoint np = get( u2NP->second, iS );
//================================================================================
void separateNodes( SMESH_MesherHelper& theHelper,
- const SMESH_MAT2d::MedialAxis& theMA,
+ const SMESH_MAT2d::MedialAxis& /*theMA*/,
TMAPar2NPoints & thePointsOnE,
SinuousFace& theSinuFace,
const vector< bool >& theIsComputedEdge)
const SMESH_MAT2d::MedialAxis& theMA,
TMAPar2NPoints & thePointsOnE )
{
+ SMESH_Mesh* mesh = theHelper.GetMesh();
+ SMESHDS_Mesh* meshDS = theHelper.GetMeshDS();
+
list< TopoDS_Edge > ee1( theSinuFace._sinuSide [0].begin(), theSinuFace._sinuSide [0].end() );
list< TopoDS_Edge > ee2( theSinuFace._sinuSide [1].begin(), theSinuFace._sinuSide [1].end() );
- StdMeshers_FaceSide sideOut( theSinuFace.Face(), ee1, theHelper.GetMesh(), true, true );
- StdMeshers_FaceSide sideIn ( theSinuFace.Face(), ee2, theHelper.GetMesh(), true, true );
+ StdMeshers_FaceSide sideOut( theSinuFace.Face(), ee1, mesh, true, true, &theHelper );
+ StdMeshers_FaceSide sideIn ( theSinuFace.Face(), ee2, mesh, true, true, &theHelper );
const UVPtStructVec& uvsOut = sideOut.GetUVPtStruct();
const UVPtStructVec& uvsIn = sideIn.GetUVPtStruct();
// if ( uvs1.size() != uvs2.size() )
const SMESH_MAT2d::Branch& branch = *theMA.getBranch(0);
SMESH_MAT2d::BoundaryPoint bp[2];
SMESH_MAT2d::BranchPoint brp;
- SMESHDS_Mesh* meshDS = theHelper.GetMeshDS();
map< double, const SMDS_MeshNode* > nodeParams; // params of existing nodes
map< double, const SMDS_MeshNode* >::iterator u2n;
for ( int i = 0; i < 4; ++i )
{
theFace._quad->side[i] = StdMeshers_FaceSide::New( face, side[i], mesh, i < QUAD_TOP_SIDE,
- /*skipMediumNodes=*/true, proxyMesh );
+ /*skipMediumNodes=*/true,
+ &theHelper, proxyMesh );
}
if ( theFace.IsRing() )
//================================================================================
/*!
* \brief Divide the sinuous EDGEs by projecting the division point of Medial
- * Axis to the EGDEs
+ * Axis to the EDGEs
* \param [in] theHelper - the helper
* \param [in] theMinSegLen - minimal segment length
* \param [in] theMA - the Medial Axis
if ( isComputed[ edgeIDs1[i]] &&
isComputed[ edgeIDs2[i]] )
{
- int nbNodes1 = meshDS->MeshElements(edgeIDs[ edgeIDs1[i]] )->NbNodes();
- int nbNodes2 = meshDS->MeshElements(edgeIDs[ edgeIDs2[i]] )->NbNodes();
+ smIdType nbNodes1 = meshDS->MeshElements(edgeIDs[ edgeIDs1[i]] )->NbNodes();
+ smIdType nbNodes2 = meshDS->MeshElements(edgeIDs[ edgeIDs2[i]] )->NbNodes();
if ( nbNodes1 != nbNodes2 )
return false;
if (( int(i)-1 >= 0 ) &&
continue;
StdMeshers_FaceSide side( face, theSinuEdges[i], mesh,
- /*isFwd=*/true, /*skipMediumNodes=*/true );
+ /*isFwd=*/true, /*skipMediumNodes=*/true, &theHelper );
vector<const SMDS_MeshNode*> nodes = side.GetOrderedNodes();
for ( size_t in = 1; in < nodes.size(); ++in )
{
const vector<TopoDS_Edge>& theShortEdges,
SMESH_Algo* the1dAlgo,
const bool theHasRadialHyp,
- const bool theIs2nd)
+ const bool /*theIs2nd*/)
{
SMESH_Hypothesis::Hypothesis_Status aStatus;
for ( size_t i = 0; i < theShortEdges.size(); ++i )
SMESH_MAT2d::MedialAxis ma( F, sinuFace._sinuEdges, minSegLen, /*ignoreCorners=*/true );
if ( !_regular1D )
- _regular1D = new Algo1D( _studyId, _gen );
+ _regular1D = new Algo1D( _gen );
_regular1D->SetSegmentLength( minSegLen );
vector<double> maParams;