-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2022 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
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Algo.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH
#include "SMESH_TypeDefs.hxx"
#include "SMESH_subMesh.hxx"
-#include <Basics_OCCTVersion.hxx>
-
#include <BRepAdaptor_Curve.hxx>
#include <BRepLProp.hxx>
#include <BRep_Tool.hxx>
bool SMESH_Algo::Features::IsCompatible( const SMESH_Algo::Features& algo2 ) const
{
if ( _dim > algo2._dim ) return algo2.IsCompatible( *this );
- // algo2 is of highter dimension
+ // algo2 is of higher dimension
if ( _outElemTypes.empty() || algo2._inElemTypes.empty() )
return false;
bool compatible = true;
*/
//=============================================================================
-SMESH_Algo::SMESH_Algo (int hypId, int studyId, SMESH_Gen * gen)
- : SMESH_Hypothesis(hypId, studyId, gen)
+SMESH_Algo::SMESH_Algo (int hypId, SMESH_Gen * gen)
+ : SMESH_Hypothesis(hypId, gen)
{
_compatibleAllHypFilter = _compatibleNoAuxHypFilter = NULL;
_onlyUnaryInput = _requireDiscreteBoundary = _requireShape = true;
*/
//=============================================================================
-SMESH_0D_Algo::SMESH_0D_Algo(int hypId, int studyId, SMESH_Gen* gen)
- : SMESH_Algo(hypId, studyId, gen)
+SMESH_0D_Algo::SMESH_0D_Algo(int hypId, SMESH_Gen* gen)
+ : SMESH_Algo(hypId, gen)
{
_shapeType = (1 << TopAbs_VERTEX);
_type = ALGO_0D;
}
-SMESH_1D_Algo::SMESH_1D_Algo(int hypId, int studyId, SMESH_Gen* gen)
- : SMESH_Algo(hypId, studyId, gen)
+SMESH_1D_Algo::SMESH_1D_Algo(int hypId, SMESH_Gen* gen)
+ : SMESH_Algo(hypId, gen)
{
_shapeType = (1 << TopAbs_EDGE);
_type = ALGO_1D;
}
-SMESH_2D_Algo::SMESH_2D_Algo(int hypId, int studyId, SMESH_Gen* gen)
- : SMESH_Algo(hypId, studyId, gen)
+SMESH_2D_Algo::SMESH_2D_Algo(int hypId, SMESH_Gen* gen)
+ : SMESH_Algo(hypId, gen)
{
_shapeType = (1 << TopAbs_FACE);
_type = ALGO_2D;
}
-SMESH_3D_Algo::SMESH_3D_Algo(int hypId, int studyId, SMESH_Gen* gen)
- : SMESH_Algo(hypId, studyId, gen)
+SMESH_3D_Algo::SMESH_3D_Algo(int hypId, SMESH_Gen* gen)
+ : SMESH_Algo(hypId, gen)
{
_shapeType = (1 << TopAbs_SOLID);
_type = ALGO_3D;
const bool ignoreAuxiliary) const
{
SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
+
+ std::list<const SMESHDS_Hypothesis *> savedHyps; // don't delete the list if
+ savedHyps.swap( me->_usedHypList ); // it does not change (#16578)
+
me->_usedHypList.clear();
+ me->_assigedShapeList.clear();
if ( const SMESH_HypoFilter* filter = GetCompatibleHypoFilter( ignoreAuxiliary ))
{
- aMesh.GetHypotheses( aShape, *filter, me->_usedHypList, true );
+ aMesh.GetHypotheses( aShape, *filter, me->_usedHypList, true, & me->_assigedShapeList );
if ( ignoreAuxiliary && _usedHypList.size() > 1 )
+ {
me->_usedHypList.clear(); //only one compatible hypothesis allowed
+ me->_assigedShapeList.clear();
+ }
}
+ if ( _usedHypList == savedHyps )
+ savedHyps.swap( me->_usedHypList );
+
return _usedHypList;
}
-//=============================================================================
+//================================================================================
/*!
- * List the relevant hypothesis associated to the shape. Relevant hypothesis
- * have a name (type) listed in the algorithm. Hypothesis associated to
- * father shape -are not- taken into account (see GetUsedHypothesis)
+ * Return sub-shape to which hypotheses returned by GetUsedHypothesis() are assigned
*/
-//=============================================================================
+//================================================================================
-const list<const SMESHDS_Hypothesis *> &
-SMESH_Algo::GetAppliedHypothesis(SMESH_Mesh & aMesh,
- const TopoDS_Shape & aShape,
- const bool ignoreAuxiliary) const
+const std::list < TopoDS_Shape > & SMESH_Algo::GetAssignedShapes() const
{
- SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
- me->_appliedHypList.clear();
- if ( const SMESH_HypoFilter* filter = GetCompatibleHypoFilter( ignoreAuxiliary ))
- aMesh.GetHypotheses( aShape, *filter, me->_appliedHypList, false );
-
- return _appliedHypList;
+ return _assigedShapeList;
}
//=============================================================================
SMDS_NodeIteratorPtr nIt = eSubMesh->GetNodes();
while ( nIt->more() )
{
- const SMDS_MeshNode* node = nIt->next();
- const SMDS_PositionPtr& pos = node->GetPosition();
- if ( pos->GetTypeOfPosition() != SMDS_TOP_EDGE )
+ SMDS_EdgePositionPtr epos = nIt->next()->GetPosition();
+ if ( !epos )
return false;
- const SMDS_EdgePosition* epos =
- static_cast<const SMDS_EdgePosition*>(node->GetPosition());
if ( !paramSet.insert( epos->GetUParameter() ).second )
return false; // equal parameters
}
const SMDS_MeshNode* node = nIt->next();
if ( ignoreMediumNodes && SMESH_MesherHelper::IsMedium( node, typeToCheck ))
continue;
- const SMDS_PositionPtr& pos = node->GetPosition();
- if ( pos->GetTypeOfPosition() != SMDS_TOP_EDGE )
+ SMDS_EdgePositionPtr epos = node->GetPosition();
+ if ( ! epos )
return false;
- const SMDS_EdgePosition* epos =
- static_cast<const SMDS_EdgePosition*>(node->GetPosition());
theNodes.insert( theNodes.end(), make_pair( epos->GetUParameter(), node ));
++nbNodes;
}
OCC_CATCH_SIGNALS;
return BRepLProp::Continuity(C1, C2, u1, u2, tol, angTol);
}
- catch (Standard_Failure) {
+ catch (Standard_Failure&) {
}
return GeomAbs_C0;
}
case GeomAbs_Hyperbola:
case GeomAbs_Parabola:
return false;
- // case GeomAbs_BezierCurve:
- // case GeomAbs_BSplineCurve:
- // case GeomAbs_OtherCurve:
+ // case GeomAbs_BezierCurve:
+ // case GeomAbs_BSplineCurve:
+ // case GeomAbs_OtherCurve:
default:;
}
- const double f = curve.FirstParameter();
- const double l = curve.LastParameter();
- const gp_Pnt pf = curve.Value( f );
- const gp_Pnt pl = curve.Value( l );
- const gp_Vec v1( pf, pl );
- const double v1Len = v1.Magnitude();
- if ( v1Len < std::numeric_limits< double >::min() )
+
+ // evaluate how far from a straight line connecting the curve ends
+ // stand internal points of the curve
+ double f = curve.FirstParameter();
+ double l = curve.LastParameter();
+ gp_Pnt pf = curve.Value( f );
+ gp_Pnt pl = curve.Value( l );
+ gp_Vec lineVec( pf, pl );
+ double lineLen2 = lineVec.SquareMagnitude();
+ if ( lineLen2 < std::numeric_limits< double >::min() )
return false; // E seems closed
- const double tol = Min( 10 * curve.Tolerance(), v1Len * 1e-2 );
+
+ double edgeTol = 10 * curve.Tolerance();
+ double lenTol2 = lineLen2 * 1e-4;
+ double tol2 = Min( edgeTol * edgeTol, lenTol2 );
+
const double nbSamples = 7;
for ( int i = 0; i < nbSamples; ++i )
{
- const double r = ( i + 1 ) / nbSamples;
- const gp_Pnt pi = curve.Value( f * r + l * ( 1 - r ));
- const gp_Vec vi( pf, pi );
- const double h = 0.5 * v1.Crossed( vi ).Magnitude() / v1Len;
- if ( h > tol )
+ double r = ( i + 1 ) / nbSamples;
+ gp_Pnt pi = curve.Value( f * r + l * ( 1 - r ));
+ gp_Vec vi( pf, pi );
+ double h2 = lineVec.Crossed( vi ).SquareMagnitude() / lineLen2;
+ if ( h2 > tol2 )
return false;
}
return true;
if ( !fIt->more() )
return MEr_EMPTY;
- // We check that only links on EDGEs encouter once, the rest links, twice
+ // We check that only links on EDGEs encounter once, the rest links, twice
set< SMESH_TLink > links;
while ( fIt->more() )
{
return error( COMPERR_BAD_INPUT_MESH, "Mesh built on shape expected");
}
+//=======================================================================
+//function : IsApplicableToShape
+//purpose : Return true if the algorithm can mesh a given shape
+//=======================================================================
+
+bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & /*shape*/, bool /*toCheckAll*/) const
+{
+ return true;
+}
+
//=======================================================================
//function : CancelCompute
//purpose : Sets _computeCanceled to true. It's usage depends on
if ( error ) {
_error = error->myName;
_comment = error->myComment;
- _badInputElements = error->myBadElements;
+ if ( error->HasBadElems() )
+ {
+ SMESH_BadInputElements* badElems = static_cast<SMESH_BadInputElements*>( error.get() );
+ _badInputElements = badElems->GetElements();
+ _mesh = badElems->GetMesh();
+ }
return error->IsOK();
}
return true;
SMESH_ComputeErrorPtr SMESH_Algo::GetComputeError() const
{
- SMESH_ComputeErrorPtr err = SMESH_ComputeError::New( _error, _comment, this );
- // hope this method is called by only SMESH_subMesh after this->Compute()
- err->myBadElements.splice( err->myBadElements.end(),
- (list<const SMDS_MeshElement*>&) _badInputElements );
- return err;
+ if ( !_badInputElements.empty() && _mesh )
+ {
+ SMESH_BadInputElements* err = new SMESH_BadInputElements( _mesh, _error, _comment, this );
+ // hope this method is called by only SMESH_subMesh after this->Compute()
+ err->myBadElements.splice( err->myBadElements.end(),
+ (list<const SMDS_MeshElement*>&) _badInputElements );
+ return SMESH_ComputeErrorPtr( err );
+ }
+ return SMESH_ComputeError::New( _error, _comment, this );
}
//================================================================================
{
_error = COMPERR_OK;
_comment.clear();
- list<const SMDS_MeshElement*>::iterator elem = _badInputElements.begin();
- for ( ; elem != _badInputElements.end(); ++elem )
- if ( (*elem)->GetID() < 1 )
- delete *elem;
+ for ( const SMDS_MeshElement* & elem : _badInputElements )
+ if ( !elem->IsNull() && elem->GetID() < 1 )
+ delete elem;
_badInputElements.clear();
+ _mesh = 0;
_computeCanceled = false;
_progressTic = 0;
SMDS_ElemIteratorPtr eIt = sm->GetElements();
while ( eIt->more() ) addBadInputElement( eIt->next() );
}
+ _mesh = sm->GetParent();
}
}
*/
//=============================================================================
-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_FacePosition* pos = dynamic_cast< SMDS_FacePosition*>( 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;
}
+
+//=======================================================================
+//function : IsApplicableToShape
+//purpose : Return true if the algorithm can mesh a given shape
+//=======================================================================
+
+bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
+{
+ return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_EDGE ).More() );
+}
+
+//=======================================================================
+//function : IsApplicableToShape
+//purpose : Return true if the algorithm can mesh a given shape
+//=======================================================================
+
+bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
+{
+ return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_FACE ).More() );
+}
+
+//=======================================================================
+//function : IsApplicableToShape
+//purpose : Return true if the algorithm can mesh a given shape
+//=======================================================================
+
+bool SMESH_3D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
+{
+ return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_SOLID ).More() );
+}