-// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2020 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;
//=============================================================================
/*!
- * Usually an algoritm has nothing to save
+ * Usually an algorithm has nothing to save
*/
//=============================================================================
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;
}
TopExp::Vertices(theEdge, v1, v2);
const SMDS_MeshNode* n1 = VertexNode( v1, eSubMesh, 0 );
const SMDS_MeshNode* n2 = VertexNode( v2, eSubMesh, 0 );
+ const SMDS_MeshNode* nEnd[2] = { nbNodes ? theNodes.begin()->second : 0,
+ nbNodes ? theNodes.rbegin()->second : 0 };
Standard_Real f, l;
BRep_Tool::Range(theEdge, f, l);
if ( v1.Orientation() != TopAbs_FORWARD )
std::swap( f, l );
- if ( n1 && ++nbNodes )
+ if ( n1 && n1 != nEnd[0] && n1 != nEnd[1] && ++nbNodes )
theNodes.insert( make_pair( f, n1 ));
- if ( n2 && ++nbNodes )
+ if ( n2 && n2 != nEnd[0] && n2 != nEnd[1] && ++nbNodes )
theNodes.insert( make_pair( l, n2 ));
return (int)theNodes.size() == 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;
*/
//================================================================================
-bool SMESH_Algo::isDegenerated( const TopoDS_Edge & E )
+bool SMESH_Algo::isDegenerated( const TopoDS_Edge & E, const bool checkLength )
{
+ if ( checkLength )
+ return EdgeLength( E ) == 0;
double f,l;
TopLoc_Location loc;
Handle(Geom_Curve) C = BRep_Tool::Curve( E, loc, f,l );
if ( !fIt->more() )
return MEr_EMPTY;
- // We check that olny 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();
}
}
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() ))
+ 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() );
+}