X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FStdMeshers%2FStdMeshers_Regular_1D.cxx;h=296480964ca6bbc678ab2f018121e7b89b9c9098;hp=7025642b3b9bbdc5c5c53b93e171fd6a00a24de8;hb=b09372829929f8f561495d6c16527134971a1909;hpb=004925bca40d46c25cf9cc837193335163c2d44f diff --git a/src/StdMeshers/StdMeshers_Regular_1D.cxx b/src/StdMeshers/StdMeshers_Regular_1D.cxx index 7025642b3..296480964 100644 --- a/src/StdMeshers/StdMeshers_Regular_1D.cxx +++ b/src/StdMeshers/StdMeshers_Regular_1D.cxx @@ -1,4 +1,4 @@ -// 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 @@ -29,6 +29,7 @@ #include "SMDS_MeshElement.hxx" #include "SMDS_MeshNode.hxx" +#include "SMESHDS_Mesh.hxx" #include "SMESH_Comment.hxx" #include "SMESH_Gen.hxx" #include "SMESH_HypoFilter.hxx" @@ -37,8 +38,8 @@ #include "SMESH_subMeshEventListener.hxx" #include "StdMeshers_Adaptive1D.hxx" #include "StdMeshers_Arithmetic1D.hxx" -#include "StdMeshers_Geometric1D.hxx" #include "StdMeshers_AutomaticLength.hxx" +#include "StdMeshers_Geometric1D.hxx" #include "StdMeshers_Deflection1D.hxx" #include "StdMeshers_Distribution.hxx" #include "StdMeshers_FixedPoints1D.hxx" @@ -49,8 +50,8 @@ #include "StdMeshers_SegmentLengthAroundVertex.hxx" #include "StdMeshers_StartEndLength.hxx" -#include "Utils_SALOME_Exception.hxx" -#include "utilities.h" +#include +#include #include #include @@ -77,9 +78,8 @@ using namespace StdMeshers; //============================================================================= StdMeshers_Regular_1D::StdMeshers_Regular_1D(int hypId, - int studyId, SMESH_Gen * gen) - :SMESH_1D_Algo( hypId, studyId, gen ) + :SMESH_1D_Algo( hypId, gen ) { _name = "Regular_1D"; _shapeType = (1 << TopAbs_EDGE); @@ -121,10 +121,11 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh, const TopoDS_Shape& aShape, Hypothesis_Status& aStatus ) { - _hypType = NONE; - _quadraticMesh = false; + _hypType = NONE; + _quadraticMesh = false; _onlyUnaryInput = true; + // check propagation in a redefined GetUsedHypothesis() const list & hyps = GetUsedHypothesis(aMesh, aShape, /*ignoreAuxiliaryHyps=*/false); @@ -155,13 +156,17 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh, string hypName = theHyp->GetName(); - if ( hypName == "LocalLength" ) + if ( !_mainEdge.IsNull() && _hypType == DISTRIB_PROPAGATION ) + { + aStatus = SMESH_Hypothesis::HYP_OK; + } + else if ( hypName == "LocalLength" ) { const StdMeshers_LocalLength * hyp = dynamic_cast (theHyp); ASSERT(hyp); _value[ BEG_LENGTH_IND ] = hyp->GetLength(); - _value[ PRECISION_IND ] = hyp->GetPrecision(); + _value[ PRECISION_IND ] = hyp->GetPrecision(); ASSERT( _value[ BEG_LENGTH_IND ] > 0 ); _hypType = LOCAL_LENGTH; aStatus = SMESH_Hypothesis::HYP_OK; @@ -345,7 +350,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh, static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last, double length, - bool theReverse, int nbSeg, Function& func, + bool theReverse, smIdType nbSeg, Function& func, list& theParams) { // never do this way @@ -354,10 +359,13 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d, if ( nbSeg <= 0 ) return false; - int nbPnt = 1 + nbSeg; + smIdType nbPnt = 1 + nbSeg; vector x( nbPnt, 0. ); - if ( !buildDistribution( func, 0.0, 1.0, nbSeg, x, 1E-4 )) + + const double eps = Min( 1E-4, 0.01 / double( nbSeg )); + + if ( !buildDistribution( func, 0.0, 1.0, nbSeg, x, eps )) return false; // apply parameters in range [0,1] to the space of the curve @@ -369,7 +377,7 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d, sign = -1.; } - for ( int i = 1; i < nbSeg; i++ ) + for ( smIdType i = 1; i < nbSeg; i++ ) { double curvLength = length * (x[i] - x[i-1]) * sign; double tol = Min( Precision::Confusion(), curvLength / 100. ); @@ -385,6 +393,7 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d, } if ( theReverse ) theParams.reverse(); + return true; } @@ -392,15 +401,15 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d, //================================================================================ /*! * \brief adjust internal node parameters so that the last segment length == an - * \param a1 - the first segment length - * \param an - the last segment length - * \param U1 - the first edge parameter - * \param Un - the last edge parameter - * \param length - the edge length - * \param C3d - the edge curve - * \param theParams - internal node parameters to adjust - * \param adjustNeighbors2an - to adjust length of segments next to the last one - * and not to remove parameters + * \param a1 - the first segment length + * \param an - the last segment length + * \param U1 - the first edge parameter + * \param Un - the last edge parameter + * \param length - the edge length + * \param C3d - the edge curve + * \param theParams - internal node parameters to adjust + * \param adjustNeighbors2an - to adjust length of segments next to the last one + * and not to remove parameters */ //================================================================================ @@ -411,20 +420,21 @@ static void compensateError(double a1, double an, list & theParams, bool adjustNeighbors2an = false) { - int i, nPar = theParams.size(); + smIdType i, nPar = theParams.size(); if ( a1 + an <= length && nPar > 1 ) { bool reverse = ( U1 > Un ); - GCPnts_AbscissaPoint Discret(C3d, reverse ? an : -an, Un); + double tol = Min( Precision::Confusion(), 0.01 * an ); + GCPnts_AbscissaPoint Discret( tol, C3d, reverse ? an : -an, Un ); if ( !Discret.IsDone() ) return; double Utgt = Discret.Parameter(); // target value of the last parameter list::reverse_iterator itU = theParams.rbegin(); double Ul = *itU++; // real value of the last parameter double dUn = Utgt - Ul; // parametric error of - if ( Abs(dUn) <= Precision::Confusion() ) - return; double dU = Abs( Ul - *itU ); // parametric length of the last but one segment + if ( Abs(dUn) <= 1e-3 * dU ) + return; if ( adjustNeighbors2an || Abs(dUn) < 0.5 * dU ) { // last segment is a bit shorter than it should // move the last parameter to the edge beginning } @@ -449,7 +459,7 @@ static void compensateError(double a1, double an, } else { - double q = dUn / ( nPar - 1 ); + double q = dUn / double( nPar - 1 ); theParams.back() += dUn; double sign = reverse ? -1 : 1; double prevU = theParams.back(); @@ -494,7 +504,7 @@ static void compensateError(double a1, double an, // * \brief Clean mesh on edges // * \param event - algo_event or compute_event itself (of SMESH_subMesh) // * \param eventType - ALGO_EVENT or COMPUTE_EVENT (of SMESH_subMesh) -// * \param subMesh - the submesh where the event occures +// * \param subMesh - the submesh where the event occurs // */ // void ProcessEvent(const int event, const int eventType, SMESH_subMesh* subMesh, // EventListenerData*, const SMESH_Hypothesis*) @@ -530,7 +540,7 @@ void StdMeshers_Regular_1D::SetEventListener(SMESH_subMesh* subMesh) */ //============================================================================= -void StdMeshers_Regular_1D::SubmeshRestored(SMESH_subMesh* subMesh) +void StdMeshers_Regular_1D::SubmeshRestored(SMESH_subMesh* /*subMesh*/) { } @@ -555,14 +565,68 @@ StdMeshers_Regular_1D::getVertexHyp(SMESH_Mesh & theMesh, return 0; } +//================================================================================ +/*! + * \brief Divide a curve into equal segments + */ +//================================================================================ + +bool StdMeshers_Regular_1D::divideIntoEqualSegments( SMESH_Mesh & theMesh, + Adaptor3d_Curve & theC3d, + smIdType theNbPoints, + double theTol, + double theLength, + double theFirstU, + double theLastU, + std::list & theParameters ) +{ + bool ok = false; + if ( theNbPoints < IntegerLast() ) + { + int nbPnt = FromSmIdType( theNbPoints ); + GCPnts_UniformAbscissa discret(theC3d, nbPnt, theFirstU, theLastU, theTol ); + if ( !discret.IsDone() ) + return error( "GCPnts_UniformAbscissa failed"); + if ( discret.NbPoints() < nbPnt ) + discret.Initialize(theC3d, nbPnt + 1, theFirstU, theLastU, theTol ); + + int nbPoints = Min( discret.NbPoints(), nbPnt ); + for ( int i = 2; i < nbPoints; i++ ) // skip 1st and last points + { + double param = discret.Parameter(i); + theParameters.push_back( param ); + } + ok = true; + } + else // huge nb segments + { + // use FIXED_POINTS_1D method + StdMeshers_FixedPoints1D fixedPointsHyp( GetGen()->GetANewId(), GetGen() ); + _fpHyp = &fixedPointsHyp; + std::vector params = { 0., 1. }; + std::vector nbSegs = { theNbPoints - 1 }; + fixedPointsHyp.SetPoints( params ); + fixedPointsHyp.SetNbSegments( nbSegs ); + + HypothesisType curType = _hypType; + _hypType = FIXED_POINTS_1D; + + ok = computeInternalParameters( theMesh, theC3d, theLength, theFirstU, theLastU, + theParameters, /*reverse=*/false ); + _hypType = curType; + _fpHyp = 0; + } + return ok; +} + //================================================================================ /*! * \brief Tune parameters to fit "SegmentLengthAroundVertex" hypothesis - * \param theC3d - wire curve - * \param theLength - curve length - * \param theParameters - internal nodes parameters to modify - * \param theVf - 1st vertex - * \param theVl - 2nd vertex + * \param theC3d - wire curve + * \param theLength - curve length + * \param theParameters - internal nodes parameters to modify + * \param theVf - 1st vertex + * \param theVl - 2nd vertex */ //================================================================================ @@ -574,7 +638,7 @@ void StdMeshers_Regular_1D::redistributeNearVertices (SMESH_Mesh & theM const TopoDS_Vertex & theVl) { double f = theC3d.FirstParameter(), l = theC3d.LastParameter(); - int nPar = theParameters.size(); + size_t nPar = theParameters.size(); for ( int isEnd1 = 0; isEnd1 < 2; ++isEnd1 ) { const TopoDS_Vertex & V = isEnd1 ? theVf : theVl; @@ -595,7 +659,8 @@ void StdMeshers_Regular_1D::redistributeNearVertices (SMESH_Mesh & theM { if ( !isEnd1 ) vertexLength = -vertexLength; - GCPnts_AbscissaPoint Discret(theC3d, vertexLength, l); + double tol = Min( Precision::Confusion(), 0.01 * vertexLength ); + GCPnts_AbscissaPoint Discret( tol, theC3d, vertexLength, l ); if ( Discret.IsDone() ) { if ( nPar == 0 ) theParameters.push_back( Discret.Parameter()); @@ -612,7 +677,7 @@ void StdMeshers_Regular_1D::redistributeNearVertices (SMESH_Mesh & theM { // recompute params between the last segment and a middle one. // find size of a middle segment - int nHalf = ( nPar-1 ) / 2; + smIdType nHalf = ( nPar-1 ) / 2; list< double >::reverse_iterator itU = theParameters.rbegin(); std::advance( itU, nHalf ); double Um = *itU++; @@ -620,7 +685,7 @@ void StdMeshers_Regular_1D::redistributeNearVertices (SMESH_Mesh & theM double L = GCPnts_AbscissaPoint::Length( theC3d, *itU, l); static StdMeshers_Regular_1D* auxAlgo = 0; if ( !auxAlgo ) { - auxAlgo = new StdMeshers_Regular_1D( _gen->GetANewId(), _studyId, _gen ); + auxAlgo = new StdMeshers_Regular_1D( _gen->GetANewId(), _gen ); auxAlgo->_hypType = BEG_END_LENGTH; } auxAlgo->_value[ BEG_LENGTH_IND ] = Lm; @@ -669,10 +734,10 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, // Propagation Of Distribution // - if ( !_mainEdge.IsNull() && _isPropagOfDistribution ) + if ( !_mainEdge.IsNull() && _hypType == DISTRIB_PROPAGATION ) { TopoDS_Edge mainEdge = TopoDS::Edge( _mainEdge ); // should not be a reference! - _gen->Compute( theMesh, mainEdge, /*aShapeOnly=*/true, /*anUpward=*/true); + _gen->Compute( theMesh, mainEdge, SMESH_Gen::SHAPE_ONLY_UPWARD ); SMESHDS_SubMesh* smDS = theMesh.GetMeshDS()->MeshElements( mainEdge ); if ( !smDS ) @@ -703,9 +768,10 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, size_t dSeg = theReverse ? -1 : +1; double param = theFirstU; size_t nbParams = 0; - for ( int i = 0, nb = segLen.size()-1; i < nb; ++i, iSeg += dSeg ) + for ( size_t i = 1; i < segLen.size(); ++i, iSeg += dSeg ) { - GCPnts_AbscissaPoint Discret( theC3d, segLen[ iSeg ], param ); + double tol = Min( Precision::Confusion(), 0.01 * segLen[ iSeg ]); + GCPnts_AbscissaPoint Discret( tol, theC3d, segLen[ iSeg ], param ); if ( !Discret.IsDone() ) break; param = Discret.Parameter(); theParams.push_back( param ); @@ -728,14 +794,14 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, case NB_SEGMENTS: { double eltSize = 1; - int nbSegments; + smIdType nbSegments; if ( _hypType == MAX_LENGTH ) { double nbseg = ceil(theLength / _value[ BEG_LENGTH_IND ]); // integer sup if (nbseg <= 0) - nbseg = 1; // degenerated edge - eltSize = theLength / nbseg; - nbSegments = (int) nbseg; + nbseg = 1; // degenerated edge + eltSize = theLength / nbseg * ( 1. - 1e-9 ); + nbSegments = ToSmIdType( nbseg ); } else if ( _hypType == LOCAL_LENGTH ) { @@ -758,10 +824,10 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, } if (computed) { SMESHDS_SubMesh* smds = sm->GetSubMeshDS(); - int nb_segments = smds->NbElements(); + smIdType nb_segments = smds->NbElements(); if (nbseg - 1 <= nb_segments && nb_segments <= nbseg + 1) { isFound = true; - nbseg = nb_segments; + nbseg = FromSmIdType( nb_segments ); } } } @@ -776,7 +842,7 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, if (nbseg <= 0) nbseg = 1; // degenerated edge eltSize = theLength / nbseg; - nbSegments = (int) nbseg; + nbSegments = ToSmIdType( nbseg ); } else { @@ -793,28 +859,30 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, if (fabs(scale - 1.0) < Precision::Confusion()) { // special case to avoid division by zero - for (int i = 1; i < nbSegments; i++) { - double param = f + (l - f) * i / nbSegments; + for ( smIdType i = 1; i < nbSegments; i++) { + double param = f + (l - f) * double( i ) / double( nbSegments ); theParams.push_back( param ); } - } else { - // general case of scale distribution + } + else { // general case of scale distribution if ( theReverse ) scale = 1.0 / scale; - double alpha = pow(scale, 1.0 / (nbSegments - 1)); + double alpha = pow(scale, 1.0 / double( nbSegments - 1 )); double factor = (l - f) / (1.0 - pow(alpha, nbSegments)); - for (int i = 1; i < nbSegments; i++) { + for ( smIdType i = 1; i < nbSegments; i++) { double param = f + factor * (1.0 - pow(alpha, i)); theParams.push_back( param ); } } const double lenFactor = theLength/(l-f); + const double minSegLen = Min( theParams.front() - f, l - theParams.back() ); + const double tol = Min( Precision::Confusion(), 0.01 * minSegLen ); list::iterator u = theParams.begin(), uEnd = theParams.end(); for ( ; u != uEnd; ++u ) { - GCPnts_AbscissaPoint Discret( theC3d, ((*u)-f) * lenFactor, f ); + GCPnts_AbscissaPoint Discret( tol, theC3d, ((*u)-f) * lenFactor, f ); if ( Discret.IsDone() ) *u = Discret.Parameter(); } @@ -823,7 +891,7 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, break; case StdMeshers_NumberOfSegments::DT_TabFunc: { - FunctionTable func(_vvalue[ TAB_FUNC_IND ], _ivalue[ CONV_MODE_IND ]); + FunctionTable func(_vvalue[ TAB_FUNC_IND ], FromSmIdType( _ivalue[ CONV_MODE_IND ])); return computeParamByFunc(theC3d, f, l, theLength, theReverse, _ivalue[ NB_SEGMENTS_IND ], func, theParams); @@ -831,33 +899,30 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, break; case StdMeshers_NumberOfSegments::DT_ExprFunc: { - FunctionExpr func(_svalue[ EXPR_FUNC_IND ].c_str(), _ivalue[ CONV_MODE_IND ]); + FunctionExpr func(_svalue[ EXPR_FUNC_IND ].c_str(), + FromSmIdType( _ivalue[ CONV_MODE_IND ])); return computeParamByFunc(theC3d, f, l, theLength, theReverse, _ivalue[ NB_SEGMENTS_IND ], func, theParams); } break; case StdMeshers_NumberOfSegments::DT_Regular: - eltSize = theLength / nbSegments; + eltSize = theLength / double( nbSegments ); break; default: return false; } } - GCPnts_UniformAbscissa Discret(theC3d, eltSize, f, l); - if ( !Discret.IsDone() ) - return error( "GCPnts_UniformAbscissa failed"); - int NbPoints = Min( Discret.NbPoints(), nbSegments + 1 ); - for ( int i = 2; i < NbPoints; i++ ) // skip 1st and last points - { - double param = Discret.Parameter(i); - theParams.push_back( param ); - } + double tol = Min( Precision::Confusion(), 0.01 * eltSize ); + divideIntoEqualSegments( theMesh, theC3d, nbSegments + 1, tol, + theLength, theFirstU, theLastU, theParams ); + compensateError( eltSize, eltSize, f, l, theLength, theC3d, theParams, true ); // for PAL9899 return true; } + case BEG_END_LENGTH: { // geometric progression: SUM(n) = ( a1 - an * q ) / ( 1 - q ) = theLength @@ -869,14 +934,15 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, return error ( SMESH_Comment("Invalid segment lengths (")< at the distance // from the point of parameter . - GCPnts_AbscissaPoint Discret( theC3d, eltSize, param ); + GCPnts_AbscissaPoint Discret( tol, theC3d, eltSize, param ); if ( !Discret.IsDone() ) break; param = Discret.Parameter(); if ( f < param && param < l ) @@ -903,10 +969,11 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, double q = ( an - a1 ) / ( 2 *theLength/( a1 + an ) - 1 ); int n = int(fabs(q) > numeric_limits::min() ? ( 1+( an-a1 )/q ) : ( 1+theLength/a1 )); - double U1 = theReverse ? l : f; - double Un = theReverse ? f : l; - double param = U1; + double U1 = theReverse ? l : f; + double Un = theReverse ? f : l; + double param = U1; double eltSize = a1; + double tol = Min( Precision::Confusion(), 0.01 * Min( a1, an )); if ( theReverse ) { eltSize = -eltSize; q = -q; @@ -914,7 +981,7 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, while ( n-- > 0 && eltSize * ( Un - U1 ) > 0 ) { // computes a point on a curve at the distance // from the point of parameter . - GCPnts_AbscissaPoint Discret( theC3d, eltSize, param ); + GCPnts_AbscissaPoint Discret( tol, theC3d, eltSize, param ); if ( !Discret.IsDone() ) break; param = Discret.Parameter(); if ( param > f && param < l ) @@ -945,7 +1012,8 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, while ( true ) { // computes a point on a curve at the distance // from the point of parameter . - GCPnts_AbscissaPoint Discret( theC3d, eltSize, param ); + double tol = Min( Precision::Confusion(), 0.01 * eltSize ); + GCPnts_AbscissaPoint Discret( tol, theC3d, eltSize, param ); if ( !Discret.IsDone() ) break; param = Discret.Parameter(); if ( f < param && param < l ) @@ -955,6 +1023,8 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, an = eltSize; eltSize *= q; ++nbParams; + if ( q < 1. && eltSize < 1e-100 ) + return error("Too small common ratio causes too many segments"); } if ( nbParams > 1 ) { @@ -977,96 +1047,96 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, case FIXED_POINTS_1D: { const std::vector& aPnts = _fpHyp->GetPoints(); - const std::vector& nbsegs = _fpHyp->GetNbSegments(); + std::vector nbsegs = _fpHyp->GetNbSegments(); + + // sort normalized params, taking into account theReverse TColStd_SequenceOfReal Params; + double tol = 1e-7; for ( size_t i = 0; i < aPnts.size(); i++ ) { - if( aPnts[i]<0.0001 || aPnts[i]>0.9999 ) continue; - int j=1; + if( aPnts[i] < tol || aPnts[i] > 1 - tol ) + continue; + double u = theReverse ? ( 1 - aPnts[i] ) : aPnts[i]; + int j = 1; bool IsExist = false; - for ( ; j <= Params.Length(); j++ ) { - if ( Abs( aPnts[i] - Params.Value(j) ) < 1e-4 ) { - IsExist = true; - break; - } - if ( aPnts[i] Params.Length() - 1 ) + nbsegs.resize( Params.Length() - 1 ); + std::reverse( nbsegs.begin(), nbsegs.end() ); + } + if ( nbsegs.empty() ) + { + nbsegs.push_back( 1 ); } - double eltSize, segmentSize = 0.; - double currAbscissa = 0; - for ( int i = 0; i < Params.Length(); i++ ) + if ((int) nbsegs.size() < Params.Length() - 1 ) + nbsegs.resize( Params.Length() - 1, nbsegs[0] ); + + // care of huge nbsegs - additionally divide diapasons + for ( int i = 2; i <= Params.Length(); i++ ) { - int nbseg = ( i > (int)nbsegs.size()-1 ) ? nbsegs[0] : nbsegs[i]; - segmentSize = Params.Value( i+1 ) * theLength - currAbscissa; - currAbscissa += segmentSize; - GCPnts_AbscissaPoint APnt( theC3d, sign*segmentSize, par1 ); + smIdType nbTot = nbsegs[ i-2 ]; + if ( nbTot <= IntegerLast() ) + continue; + smIdType nbDiapason = nbTot / IntegerLast() + 1; + smIdType nbSegPerDiap = nbTot / nbDiapason; + double par0 = Params( i - 1 ), par1 = Params( i ); + for ( smIdType iDiap = 0; iDiap < nbDiapason - 1; ++iDiap ) + { + double r = double( nbSegPerDiap * ( iDiap + 1 )) / double( nbTot ); + double parI = par0 + ( par1 - par0 ) * r; + Params.InsertBefore( i, parI ); + auto it = nbsegs.begin(); + smIdType incr_it = i - 2 + iDiap; + nbsegs.insert( it + incr_it, nbSegPerDiap ); + } + nbsegs[ i-2 + nbDiapason - 1 ] = nbSegPerDiap + nbTot % nbDiapason; + } + + // transform normalized Params into real ones + std::vector< double > uVec( Params.Length() ); + uVec[ 0 ] = theFirstU; + double abscissa; + for ( int i = 2; i < Params.Length(); i++ ) + { + abscissa = Params( i ) * theLength; + tol = Min( Precision::Confusion(), 0.01 * abscissa ); + GCPnts_AbscissaPoint APnt( tol, theC3d, abscissa, theFirstU ); if ( !APnt.IsDone() ) return error( "GCPnts_AbscissaPoint failed"); - par2 = APnt.Parameter(); - eltSize = segmentSize/nbseg; - GCPnts_UniformAbscissa Discret( theC3d, eltSize, par1, par2 ); - if ( theReverse ) - Discret.Initialize( theC3d, eltSize, par2, par1 ); - else - Discret.Initialize( theC3d, eltSize, par1, par2 ); - if ( !Discret.IsDone() ) - return error( "GCPnts_UniformAbscissa failed"); - int NbPoints = Discret.NbPoints(); - list tmpParams; - for ( int i = 2; i < NbPoints; i++ ) { - double param = Discret.Parameter(i); - tmpParams.push_back( param ); - } - if ( theReverse ) { - compensateError( eltSize, eltSize, par2, par1, segmentSize, theC3d, tmpParams ); - tmpParams.reverse(); - } - else { - compensateError( eltSize, eltSize, par1, par2, segmentSize, theC3d, tmpParams ); + uVec[ i-1 ] = APnt.Parameter(); + } + uVec.back() = theLastU; + + // divide segments + double eltSize, segmentSize, par1, par2; + for ( int i = 0; i < (int)uVec.size()-1; i++ ) + { + par1 = uVec[ i ]; + par2 = uVec[ i+1 ]; + smIdType nbseg = ( i < (int) nbsegs.size() ) ? nbsegs[i] : nbsegs[0]; + if ( nbseg > 1 ) + { + segmentSize = ( Params( i+2 ) - Params( i+1 )) * theLength; + eltSize = segmentSize / double( nbseg ); + tol = Min( Precision::Confusion(), 0.01 * eltSize ); + if ( !divideIntoEqualSegments( theMesh, theC3d, nbseg + 1, tol, + segmentSize, par1, par2, theParams )) + return false; } - theParams.splice( theParams.end(), tmpParams ); theParams.push_back( par2 ); - - par1 = par2; - } - // add for last - int nbseg = ( (int)nbsegs.size() > Params.Length() ) ? nbsegs[Params.Length()] : nbsegs[0]; - segmentSize = theLength - currAbscissa; - eltSize = segmentSize/nbseg; - GCPnts_UniformAbscissa Discret; - if ( theReverse ) - Discret.Initialize( theC3d, eltSize, par1, lp ); - else - Discret.Initialize( theC3d, eltSize, lp, par1 ); - if ( !Discret.IsDone() ) - return error( "GCPnts_UniformAbscissa failed"); - int NbPoints = Discret.NbPoints(); - list tmpParams; - for ( int i = 2; i < NbPoints; i++ ) { - double param = Discret.Parameter(i); - tmpParams.push_back( param ); - } - if ( theReverse ) { - compensateError( eltSize, eltSize, lp, par1, segmentSize, theC3d, tmpParams ); - tmpParams.reverse(); } - else { - compensateError( eltSize, eltSize, par1, lp, segmentSize, theC3d, tmpParams ); - } - theParams.splice( theParams.end(), tmpParams ); - - if ( theReverse ) - theParams.reverse(); // NPAL18025 + theParams.pop_back(); return true; } @@ -1124,15 +1194,14 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t ASSERT(!VFirst.IsNull()); ASSERT(!VLast.IsNull()); - const SMDS_MeshNode * idFirst = SMESH_Algo::VertexNode( VFirst, meshDS ); - const SMDS_MeshNode * idLast = SMESH_Algo::VertexNode( VLast, meshDS ); - if (!idFirst || !idLast) + const SMDS_MeshNode * nFirst = SMESH_Algo::VertexNode( VFirst, meshDS ); + const SMDS_MeshNode * nLast = SMESH_Algo::VertexNode( VLast, meshDS ); + if ( !nFirst || !nLast ) return error( COMPERR_BAD_INPUT_MESH, "No node on vertex"); - // remove elements created by e.g. patern mapping (PAL21999) + // remove elements created by e.g. pattern mapping (PAL21999) // CLEAN event is incorrectly ptopagated seemingly due to Propagation hyp // so TEMPORARY solution is to clean the submesh manually - //theMesh.GetSubMesh(theShape)->ComputeStateEngine( SMESH_subMesh::CLEAN ); if (SMESHDS_SubMesh * subMeshDS = meshDS->MeshElements(theShape)) { SMDS_ElemIteratorPtr ite = subMeshDS->GetElements(); @@ -1148,11 +1217,12 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t } } - if (!Curve.IsNull()) + double length = EdgeLength( E ); + if ( !Curve.IsNull() && length > 0 ) { list< double > params; bool reversed = false; - if ( theMesh.GetShapeToMesh().ShapeType() >= TopAbs_WIRE ) { + if ( theMesh.GetShapeToMesh().ShapeType() >= TopAbs_WIRE && _revEdgesIDs.empty() ) { // if the shape to mesh is WIRE or EDGE reversed = ( EE.Orientation() == TopAbs_REVERSED ); } @@ -1160,7 +1230,7 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t // take into account reversing the edge the hypothesis is propagated from // (_mainEdge.Orientation() marks mutual orientation of EDGEs in propagation chain) reversed = ( _mainEdge.Orientation() == TopAbs_REVERSED ); - if ( !_isPropagOfDistribution ) { + if ( _hypType != DISTRIB_PROPAGATION ) { int mainID = meshDS->ShapeToIndex(_mainEdge); if ( std::find( _revEdgesIDs.begin(), _revEdgesIDs.end(), mainID) != _revEdgesIDs.end()) reversed = !reversed; @@ -1171,7 +1241,6 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t reversed = !reversed; BRepAdaptor_Curve C3d( E ); - double length = EdgeLength( E ); if ( ! computeInternalParameters( theMesh, C3d, length, f, l, params, reversed, true )) { return false; } @@ -1180,19 +1249,10 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t // edge extrema (indexes : 1 & NbPoints) already in SMDS (TopoDS_Vertex) // only internal nodes receive an edge position with param on curve - const SMDS_MeshNode * idPrev = idFirst; + const SMDS_MeshNode * nPrev = nFirst; double parPrev = f; double parLast = l; - /* NPAL18025 - if (reversed) { - idPrev = idLast; - idLast = idFirst; - idFirst = idPrev; - parPrev = l; - parLast = f; - } - */ for (list::iterator itU = params.begin(); itU != params.end(); itU++) { double param = *itU; gp_Pnt P = Curve->Value(param); @@ -1204,18 +1264,18 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t if(_quadraticMesh) { // create medium node double prm = ( parPrev + param )/2; - gp_Pnt PM = Curve->Value(prm); + gp_Pnt PM = Curve->Value(prm); SMDS_MeshNode * NM = meshDS->AddNode(PM.X(), PM.Y(), PM.Z()); meshDS->SetNodeOnEdge(NM, shapeID, prm); - SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node, NM); + SMDS_MeshEdge * edge = meshDS->AddEdge(nPrev, node, NM); meshDS->SetMeshElementOnShape(edge, shapeID); } else { - SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node); + SMDS_MeshEdge * edge = meshDS->AddEdge(nPrev, node); meshDS->SetMeshElementOnShape(edge, shapeID); } - idPrev = node; + nPrev = node; parPrev = param; } if(_quadraticMesh) { @@ -1223,11 +1283,11 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t gp_Pnt PM = Curve->Value(prm); SMDS_MeshNode * NM = meshDS->AddNode(PM.X(), PM.Y(), PM.Z()); meshDS->SetNodeOnEdge(NM, shapeID, prm); - SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, idLast, NM); + SMDS_MeshEdge * edge = meshDS->AddEdge(nPrev, nLast, NM); meshDS->SetMeshElementOnShape(edge, shapeID); } else { - SMDS_MeshEdge* edge = meshDS->AddEdge(idPrev, idLast); + SMDS_MeshEdge* edge = meshDS->AddEdge(nPrev, nLast); meshDS->SetMeshElementOnShape(edge, shapeID); } } @@ -1240,7 +1300,7 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t gp_Pnt P = BRep_Tool::Pnt(VFirst); - const SMDS_MeshNode * idPrev = idFirst; + const SMDS_MeshNode * nPrev = nFirst; for (int i = 2; i < NbPoints; i++) { double param = f + (i - 1) * du; SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z()); @@ -1249,26 +1309,26 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t double prm = param - du/2.; SMDS_MeshNode * NM = meshDS->AddNode(P.X(), P.Y(), P.Z()); meshDS->SetNodeOnEdge(NM, shapeID, prm); - SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node, NM); + SMDS_MeshEdge * edge = meshDS->AddEdge(nPrev, node, NM); meshDS->SetMeshElementOnShape(edge, shapeID); } else { - SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node); + SMDS_MeshEdge * edge = meshDS->AddEdge(nPrev, node); meshDS->SetMeshElementOnShape(edge, shapeID); } meshDS->SetNodeOnEdge(node, shapeID, param); - idPrev = node; + nPrev = node; } if(_quadraticMesh) { // create medium node double prm = l - du/2.; SMDS_MeshNode * NM = meshDS->AddNode(P.X(), P.Y(), P.Z()); meshDS->SetNodeOnEdge(NM, shapeID, prm); - SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, idLast, NM); + SMDS_MeshEdge * edge = meshDS->AddEdge(nPrev, nLast, NM); meshDS->SetMeshElementOnShape(edge, shapeID); } else { - SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, idLast); + SMDS_MeshEdge * edge = meshDS->AddEdge(nPrev, nLast); meshDS->SetMeshElementOnShape(edge, shapeID); } } @@ -1282,9 +1342,9 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t */ //============================================================================= -bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh, +bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh, const TopoDS_Shape & theShape, - MapShapeNbElems& aResMap) + MapShapeNbElems& theResMap) { if ( _hypType == NONE ) return false; @@ -1292,7 +1352,7 @@ bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh, if ( _hypType == ADAPTIVE ) { _adaptiveHyp->GetAlgo()->InitComputeError(); - _adaptiveHyp->GetAlgo()->Evaluate( theMesh, theShape, aResMap ); + _adaptiveHyp->GetAlgo()->Evaluate( theMesh, theShape, theResMap ); return error( _adaptiveHyp->GetAlgo()->GetComputeError() ); } @@ -1308,16 +1368,16 @@ bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh, ASSERT(!VFirst.IsNull()); ASSERT(!VLast.IsNull()); - std::vector aVec(SMDSEntity_Last,0); + std::vector aVec(SMDSEntity_Last,0); - if (!Curve.IsNull()) { + double length = EdgeLength( E ); + if ( !Curve.IsNull() && length > 0 ) + { list< double > params; - BRepAdaptor_Curve C3d( E ); - double length = EdgeLength( E ); if ( ! computeInternalParameters( theMesh, C3d, length, f, l, params, false, true )) { SMESH_subMesh * sm = theMesh.GetSubMesh(theShape); - aResMap.insert(std::make_pair(sm,aVec)); + theResMap.insert(std::make_pair(sm,aVec)); SMESH_ComputeErrorPtr& smError = sm->GetComputeError(); smError.reset( new SMESH_ComputeError(COMPERR_ALGO_FAILED,"Submesh can not be evaluated",this)); return false; @@ -1325,19 +1385,19 @@ bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh, redistributeNearVertices( theMesh, C3d, length, params, VFirst, VLast ); if(_quadraticMesh) { - aVec[SMDSEntity_Node] = 2*params.size() + 1; + aVec[SMDSEntity_Node ] = 2*params.size() + 1; aVec[SMDSEntity_Quad_Edge] = params.size() + 1; } else { aVec[SMDSEntity_Node] = params.size(); aVec[SMDSEntity_Edge] = params.size() + 1; } - + } else { // Edge is a degenerated Edge : We put n = 5 points on the edge. if ( _quadraticMesh ) { - aVec[SMDSEntity_Node] = 11; + aVec[SMDSEntity_Node ] = 11; aVec[SMDSEntity_Quad_Edge] = 6; } else { @@ -1346,8 +1406,8 @@ bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh, } } - SMESH_subMesh * sm = theMesh.GetSubMesh(theShape); - aResMap.insert(std::make_pair(sm,aVec)); + SMESH_subMesh * sm = theMesh.GetSubMesh( theShape ); + theResMap.insert( std::make_pair( sm, aVec )); return true; } @@ -1376,10 +1436,13 @@ StdMeshers_Regular_1D::GetUsedHypothesis(SMESH_Mesh & aMesh, if (nbHyp == 0 && aShape.ShapeType() == TopAbs_EDGE) { // Check, if propagated from some other edge + bool isPropagOfDistribution = false; _mainEdge = StdMeshers_Propagation::GetPropagationSource( aMesh, aShape, - _isPropagOfDistribution ); + isPropagOfDistribution ); if ( !_mainEdge.IsNull() ) { + if ( isPropagOfDistribution ) + _hypType = DISTRIB_PROPAGATION; // Propagation of 1D hypothesis from on this edge; // get non-auxiliary assigned to _mainEdge nbHyp = aMesh.GetHypotheses( _mainEdge, *compatibleFilter, _usedHypList, true ); @@ -1389,7 +1452,7 @@ StdMeshers_Regular_1D::GetUsedHypothesis(SMESH_Mesh & aMesh, if (nbHyp == 0) // nothing propagated nor assigned to aShape { SMESH_Algo::GetUsedHypothesis( aMesh, aShape, ignoreAuxiliary ); - nbHyp = _usedHypList.size(); + nbHyp = (int)_usedHypList.size(); } else {