X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH%2FSMESH_Algo.cxx;h=a03fa748995b9a01a56824338013b169fb021882;hp=e31bf02d9ee800e26adf002705c08c46f7399ac4;hb=HEAD;hpb=466da2436e3a2de79c6c79edafc0d4cac819f839 diff --git a/src/SMESH/SMESH_Algo.cxx b/src/SMESH/SMESH_Algo.cxx index e31bf02d9..a03fa7489 100644 --- a/src/SMESH/SMESH_Algo.cxx +++ b/src/SMESH/SMESH_Algo.cxx @@ -1,4 +1,4 @@ -// 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 @@ -20,7 +20,7 @@ // 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 @@ -42,8 +42,6 @@ #include "SMESH_TypeDefs.hxx" #include "SMESH_subMesh.hxx" -#include - #include #include #include @@ -87,7 +85,7 @@ using namespace std; 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; @@ -171,12 +169,12 @@ const SMESH_Algo::Features& SMESH_Algo::GetFeatures( const std::string& algoType //============================================================================= /*! - * + * */ //============================================================================= -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; @@ -188,7 +186,7 @@ SMESH_Algo::SMESH_Algo (int hypId, int studyId, SMESH_Gen * gen) //============================================================================= /*! - * + * */ //============================================================================= @@ -200,30 +198,30 @@ SMESH_Algo::~SMESH_Algo() //============================================================================= /*! - * + * */ //============================================================================= -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; @@ -231,7 +229,7 @@ SMESH_3D_Algo::SMESH_3D_Algo(int hypId, int studyId, SMESH_Gen* gen) //============================================================================= /*! - * Usually an algoritm has nothing to save + * Usually an algorithm has nothing to save */ //============================================================================= @@ -240,7 +238,7 @@ istream & SMESH_Algo::LoadFrom(istream & load) { return load; } //============================================================================= /*! - * + * */ //============================================================================= @@ -254,7 +252,7 @@ const vector < string > &SMESH_Algo::GetCompatibleHypothesis() * 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. */ //============================================================================= @@ -265,35 +263,36 @@ SMESH_Algo::GetUsedHypothesis(SMESH_Mesh & aMesh, const bool ignoreAuxiliary) const { SMESH_Algo* me = const_cast< SMESH_Algo* >( this ); + + std::list 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 & -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; } //============================================================================= @@ -360,12 +359,9 @@ bool SMESH_Algo::GetNodeParamOnEdge(const SMESHDS_Mesh* theMesh, 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(node->GetPosition()); if ( !paramSet.insert( epos->GetUParameter() ).second ) return false; // equal parameters } @@ -426,11 +422,9 @@ bool SMESH_Algo::GetSortedNodesOnEdge(const SMESHDS_Mesh* theM 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(node->GetPosition()); theNodes.insert( theNodes.end(), make_pair( epos->GetUParameter(), node )); ++nbNodes; } @@ -440,13 +434,15 @@ bool SMESH_Algo::GetSortedNodesOnEdge(const SMESHDS_Mesh* theM 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; @@ -494,10 +490,11 @@ SMESH_Algo::GetCompatibleHypoFilter(const bool ignoreAuxiliary) const */ //================================================================================ -GeomAbs_Shape SMESH_Algo::Continuity(TopoDS_Edge E1, - TopoDS_Edge E2) +GeomAbs_Shape SMESH_Algo::Continuity(const TopoDS_Edge& theE1, + const TopoDS_Edge& theE2) { - //E1.Orientation(TopAbs_FORWARD), E2.Orientation(TopAbs_FORWARD); // avoid pb with internal edges + // avoid pb with internal edges + TopoDS_Edge E1 = theE1, E2 = theE2; if (E1.Orientation() > TopAbs_REVERSED) // INTERNAL E1.Orientation( TopAbs_FORWARD ); if (E2.Orientation() > TopAbs_REVERSED) // INTERNAL @@ -521,7 +518,7 @@ GeomAbs_Shape SMESH_Algo::Continuity(TopoDS_Edge E1, OCC_CATCH_SIGNALS; return BRepLProp::Continuity(C1, C2, u1, u2, tol, angTol); } - catch (Standard_Failure) { + catch (Standard_Failure&) { } return GeomAbs_C0; } @@ -550,28 +547,35 @@ bool SMESH_Algo::IsStraight( const TopoDS_Edge & E, 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; @@ -583,8 +587,10 @@ bool SMESH_Algo::IsStraight( const TopoDS_Edge & E, */ //================================================================================ -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 ); @@ -746,7 +752,7 @@ SMESH_Algo::EMeshError SMESH_Algo::GetMeshError(SMESH_subMesh* subMesh) 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() ) { @@ -810,7 +816,7 @@ SMESH_Algo::EMeshError SMESH_Algo::GetMeshError(SMESH_subMesh* subMesh) /*! * \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 */ @@ -847,6 +853,16 @@ bool SMESH_Algo::Compute(SMESH_Mesh & /*aMesh*/, SMESH_MesherHelper* /*aHelper*/ 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 @@ -894,7 +910,12 @@ bool SMESH_Algo::error(SMESH_ComputeErrorPtr error) if ( error ) { _error = error->myName; _comment = error->myComment; - _badInputElements = error->myBadElements; + if ( error->HasBadElems() ) + { + SMESH_BadInputElements* badElems = static_cast( error.get() ); + _badInputElements = badElems->GetElements(); + _mesh = badElems->GetMesh(); + } return error->IsOK(); } return true; @@ -908,11 +929,15 @@ bool SMESH_Algo::error(SMESH_ComputeErrorPtr error) 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&) _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&) _badInputElements ); + return SMESH_ComputeErrorPtr( err ); + } + return SMESH_ComputeError::New( _error, _comment, this ); } //================================================================================ @@ -925,11 +950,11 @@ void SMESH_Algo::InitComputeError() { _error = COMPERR_OK; _comment.clear(); - list::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; @@ -989,12 +1014,13 @@ void SMESH_Algo::addBadInputElements(const SMESHDS_SubMesh* sm, SMDS_ElemIteratorPtr eIt = sm->GetElements(); while ( eIt->more() ) addBadInputElement( eIt->next() ); } + _mesh = sm->GetParent(); } } //============================================================================= /*! - * + * */ //============================================================================= @@ -1008,16 +1034,16 @@ void SMESH_Algo::addBadInputElements(const SMESHDS_SubMesh* sm, //============================================================================= /*! - * + * */ //============================================================================= -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 ?) @@ -1042,6 +1068,7 @@ bool SMESH_2D_Algo::FixInternalNodes(const SMESH_ProxyMesh& mesh, 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; @@ -1118,7 +1145,7 @@ bool SMESH_2D_Algo::FixInternalNodes(const SMESH_ProxyMesh& mesh, { ++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, @@ -1158,17 +1185,28 @@ bool SMESH_2D_Algo::FixInternalNodes(const SMESH_ProxyMesh& mesh, // 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 ) @@ -1181,15 +1219,23 @@ bool SMESH_2D_Algo::FixInternalNodes(const SMESH_ProxyMesh& mesh, 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 ) @@ -1200,32 +1246,96 @@ bool SMESH_2D_Algo::FixInternalNodes(const SMESH_ProxyMesh& mesh, // 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() ); +}