-// Copyright (C) 2007-2020 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
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
* List the hypothesis used by the algorithm associated to the shape.
* Hypothesis associated to father shape -are- taken into account (see
* GetAppliedHypothesis). Relevant hypothesis have a name (type) listed in
- * the algorithm. This method could be surcharged by specific algorithms, in
+ * the algorithm. This method could be surcharged by specific algorithms, in
* case of several hypothesis simultaneously applicable.
*/
//=============================================================================
{
SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
- std::list<const SMESHDS_Hypothesis *> savedHyps; // don't delete the list if
+ std::list<const SMESHDS_Hypothesis *> savedHyps; // don't delete the list if
savedHyps.swap( me->_usedHypList ); // it does not change (#16578)
me->_usedHypList.clear();
OCC_CATCH_SIGNALS;
return BRepLProp::Continuity(C1, C2, u1, u2, tol, angTol);
}
- catch (Standard_Failure) {
+ catch (Standard_Failure&) {
}
return GeomAbs_C0;
}
return false; // E seems closed
double edgeTol = 10 * curve.Tolerance();
- double lenTol2 = lineLen2 * 1e-4;
+ double lenTol2 = lineLen2 * 1e-4;
double tol2 = Min( edgeTol * edgeTol, lenTol2 );
const double nbSamples = 7;
/*!
* \brief Sets event listener to submeshes if necessary
* \param subMesh - submesh where algo is set
- *
+ *
* After being set, event listener is notified on each event of a submesh.
* By default non listener is set
*/
//purpose : Return true if the algorithm can mesh a given shape
//=======================================================================
-bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
+bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & /*shape*/, bool /*toCheckAll*/) const
{
return true;
}
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
-int SMESH_Algo::NumberOfPoints(SMESH_Mesh& aMesh, const TopoDS_Wire& W)
+smIdType SMESH_Algo::NumberOfPoints(SMESH_Mesh& aMesh, const TopoDS_Wire& W)
{
- int nbPoints = 0;
+ smIdType nbPoints = 0;
for (TopExp_Explorer exp(W,TopAbs_EDGE); exp.More(); exp.Next()) {
const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
- int nb = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
+ smIdType nb = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
if(_quadraticMesh)
nb = nb/2;
nbPoints += nb + 1; // internal points plus 1 vertex of 2 (last point ?)
return false;
SMESH_MesherHelper helper( *mesh.GetMesh() );
+ helper.SetSubShape( face );
// get all faces from a proxy sub-mesh
typedef SMDS_StdIterator< const SMDS_MeshElement*, SMDS_ElemIteratorPtr > TIterator;
{
++iRow1, ++iRow2;
- // get the first quad in the next face row
+ // get the first quad in the next face row
if (( quad = SMESH_MeshAlgos::FindFaceInSet( nodeRows[iRow1][0],
nodeRows[iRow1][1],
allFaces, /*avoid=*/firstRowQuads,
// get params of the first (bottom) and last (top) node rows
UVPtStructVec uvB( nodeRows[0].size() ), uvT( nodeRows[0].size() );
+ bool uvOk = false, *toCheck = helper.GetPeriodicIndex() ? &uvOk : nullptr;
+ const bool isFix3D = helper.HasDegeneratedEdges();
for ( int isBot = 0; isBot < 2; ++isBot )
{
+ iRow1 = isBot ? 0 : nodeRows.size()-1;
+ iRow2 = isBot ? 1 : nodeRows.size()-2;
UVPtStructVec & uvps = isBot ? uvB : uvT;
- vector< const SMDS_MeshNode* >& nodes = nodeRows[ isBot ? 0 : nodeRows.size()-1 ];
- for ( size_t i = 0; i < nodes.size(); ++i )
+ vector< const SMDS_MeshNode* >& nodes = nodeRows[ iRow1 ];
+ const size_t rowLen = nodes.size();
+ for ( size_t i = 0; i < rowLen; ++i )
{
uvps[i].node = nodes[i];
- gp_XY uv = helper.GetNodeUV( face, uvps[i].node );
- uvps[i].u = uv.Coord(1);
- uvps[i].v = uv.Coord(2);
uvps[i].x = 0;
+ if ( !isFix3D )
+ {
+ size_t i2 = i;
+ if ( i == 0 ) i2 = 1;
+ if ( i == rowLen - 1 ) i2 = rowLen - 2;
+ gp_XY uv = helper.GetNodeUV( face, uvps[i].node, nodeRows[iRow2][i2], toCheck );
+ uvps[i].u = uv.Coord(1);
+ uvps[i].v = uv.Coord(2);
+ }
}
// calculate x (normalized param)
for ( size_t i = 1; i < nodes.size(); ++i )
UVPtStructVec uvL( nodeRows.size() ), uvR( nodeRows.size() );
for ( int isLeft = 0; isLeft < 2; ++isLeft )
{
- UVPtStructVec & uvps = isLeft ? uvL : uvR;
- const int iCol = isLeft ? 0 : nodeRows[0].size() - 1;
- for ( size_t i = 0; i < nodeRows.size(); ++i )
+ UVPtStructVec & uvps = isLeft ? uvL : uvR;
+ const int iCol1 = isLeft ? 0 : nodeRows[0].size() - 1;
+ const int iCol2 = isLeft ? 1 : nodeRows[0].size() - 2;
+ const size_t nbRows = nodeRows.size();
+ for ( size_t i = 0; i < nbRows; ++i )
{
- uvps[i].node = nodeRows[i][iCol];
- gp_XY uv = helper.GetNodeUV( face, uvps[i].node );
- uvps[i].u = uv.Coord(1);
- uvps[i].v = uv.Coord(2);
+ uvps[i].node = nodeRows[i][iCol1];
uvps[i].y = 0;
+ if ( !isFix3D )
+ {
+ size_t i2 = i;
+ if ( i == 0 ) i2 = 1;
+ if ( i == nbRows - 1 ) i2 = nbRows - 2;
+ gp_XY uv = helper.GetNodeUV( face, uvps[i].node, nodeRows[i2][iCol2], toCheck );
+ uvps[i].u = uv.Coord(1);
+ uvps[i].v = uv.Coord(2);
+ }
}
// calculate y (normalized param)
for ( size_t i = 1; i < nodeRows.size(); ++i )
// update node coordinates
SMESHDS_Mesh* meshDS = mesh.GetMeshDS();
- Handle(Geom_Surface) S = BRep_Tool::Surface( face );
- gp_XY a0 ( uvB.front().u, uvB.front().v );
- gp_XY a1 ( uvB.back().u, uvB.back().v );
- gp_XY a2 ( uvT.back().u, uvT.back().v );
- gp_XY a3 ( uvT.front().u, uvT.front().v );
- for ( size_t iRow = 1; iRow < nodeRows.size()-1; ++iRow )
+ if ( !isFix3D )
{
- gp_XY p1 ( uvR[ iRow ].u, uvR[ iRow ].v );
- gp_XY p3 ( uvL[ iRow ].u, uvL[ iRow ].v );
- const double y0 = uvL[ iRow ].y;
- const double y1 = uvR[ iRow ].y;
- for ( size_t iCol = 1; iCol < nodeRows[0].size()-1; ++iCol )
+ Handle(Geom_Surface) S = BRep_Tool::Surface( face );
+ gp_XY a0 ( uvB.front().u, uvB.front().v );
+ gp_XY a1 ( uvB.back().u, uvB.back().v );
+ gp_XY a2 ( uvT.back().u, uvT.back().v );
+ gp_XY a3 ( uvT.front().u, uvT.front().v );
+ for ( size_t iRow = 1; iRow < nodeRows.size()-1; ++iRow )
{
- gp_XY p0 ( uvB[ iCol ].u, uvB[ iCol ].v );
- gp_XY p2 ( uvT[ iCol ].u, uvT[ iCol ].v );
- const double x0 = uvB[ iCol ].x;
- const double x1 = uvT[ iCol ].x;
- double x = (x0 + y0 * (x1 - x0)) / (1 - (y1 - y0) * (x1 - x0));
- double y = y0 + x * (y1 - y0);
- gp_XY uv = helper.calcTFI( x, y, a0,a1,a2,a3, p0,p1,p2,p3 );
- gp_Pnt p = S->Value( uv.Coord(1), uv.Coord(2));
- const SMDS_MeshNode* n = nodeRows[iRow][iCol];
- meshDS->MoveNode( n, p.X(), p.Y(), p.Z() );
- if ( SMDS_FacePositionPtr pos = n->GetPosition() )
- pos->SetParameters( uv.Coord(1), uv.Coord(2) );
+ gp_XY p1 ( uvR[ iRow ].u, uvR[ iRow ].v );
+ gp_XY p3 ( uvL[ iRow ].u, uvL[ iRow ].v );
+ const double y0 = uvL[ iRow ].y;
+ const double y1 = uvR[ iRow ].y;
+ for ( size_t iCol = 1; iCol < nodeRows[0].size()-1; ++iCol )
+ {
+ gp_XY p0 ( uvB[ iCol ].u, uvB[ iCol ].v );
+ gp_XY p2 ( uvT[ iCol ].u, uvT[ iCol ].v );
+ const double x0 = uvB[ iCol ].x;
+ const double x1 = uvT[ iCol ].x;
+ double x = (x0 + y0 * (x1 - x0)) / (1 - (y1 - y0) * (x1 - x0));
+ double y = y0 + x * (y1 - y0);
+ gp_XY uv = helper.calcTFI( x, y, a0,a1,a2,a3, p0,p1,p2,p3 );
+ gp_Pnt p = S->Value( uv.Coord(1), uv.Coord(2));
+ const SMDS_MeshNode* n = nodeRows[iRow][iCol];
+ meshDS->MoveNode( n, p.X(), p.Y(), p.Z() );
+ if ( SMDS_FacePositionPtr pos = n->GetPosition() )
+ pos->SetParameters( uv.Coord(1), uv.Coord(2) );
+ }
+ }
+ }
+ else
+ {
+ Handle(ShapeAnalysis_Surface) S = helper.GetSurface( face );
+ SMESH_NodeXYZ a0 ( uvB.front().node );
+ SMESH_NodeXYZ a1 ( uvB.back().node );
+ SMESH_NodeXYZ a2 ( uvT.back().node );
+ SMESH_NodeXYZ a3 ( uvT.front().node );
+ for ( size_t iRow = 1; iRow < nodeRows.size()-1; ++iRow )
+ {
+ SMESH_NodeXYZ p1 ( uvR[ iRow ].node );
+ SMESH_NodeXYZ p3 ( uvL[ iRow ].node );
+ const double y0 = uvL[ iRow ].y;
+ const double y1 = uvR[ iRow ].y;
+ for ( size_t iCol = 1; iCol < nodeRows[0].size()-1; ++iCol )
+ {
+ SMESH_NodeXYZ p0 ( uvB[ iCol ].node );
+ SMESH_NodeXYZ p2 ( uvT[ iCol ].node );
+ const double x0 = uvB[ iCol ].x;
+ const double x1 = uvT[ iCol ].x;
+ double x = (x0 + y0 * (x1 - x0)) / (1 - (y1 - y0) * (x1 - x0));
+ double y = y0 + x * (y1 - y0);
+ gp_Pnt p = helper.calcTFI( x, y, a0,a1,a2,a3, p0,p1,p2,p3 );
+ gp_Pnt2d uv = S->ValueOfUV( p, Precision::Confusion() );
+ p = S->Value( uv );
+ const SMDS_MeshNode* n = nodeRows[iRow][iCol];
+ meshDS->MoveNode( n, p.X(), p.Y(), p.Z() );
+ if ( SMDS_FacePositionPtr pos = n->GetPosition() )
+ pos->SetParameters( uv.Coord(1), uv.Coord(2) );
+ }
}
}
return true;
//purpose : Return true if the algorithm can mesh a given shape
//=======================================================================
-bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
+bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_EDGE ).More() );
}
//purpose : Return true if the algorithm can mesh a given shape
//=======================================================================
-bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
+bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_FACE ).More() );
}
//purpose : Return true if the algorithm can mesh a given shape
//=======================================================================
-bool SMESH_3D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool toCheckAll) const
+bool SMESH_3D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
{
return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_SOLID ).More() );
}
