X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FStdMeshers%2FStdMeshers_Regular_1D.cxx;h=017af4544b42d5b05d5f3e79ecf9c7b4e67bcd66;hp=d7d2e844e7f99fa4079d1fa6628e88df670fb2c8;hb=a310184e130f7120d794d8202cbfd538a2d535a3;hpb=ed456586bfb1411c5bff73b221658766689a6253 diff --git a/src/StdMeshers/StdMeshers_Regular_1D.cxx b/src/StdMeshers/StdMeshers_Regular_1D.cxx index d7d2e844e..017af4544 100644 --- a/src/StdMeshers/StdMeshers_Regular_1D.cxx +++ b/src/StdMeshers/StdMeshers_Regular_1D.cxx @@ -178,13 +178,57 @@ bool StdMeshers_Regular_1D::CheckHypothesis return ( _hypType != NONE ); } +//======================================================================= +//function : compensateError +//purpose : adjust theParams so that the last segment length == an +//======================================================================= + +static void compensateError(double a1, double an, + double U1, double Un, + double length, + GeomAdaptor_Curve& C3d, + list & theParams) +{ + int i, nPar = theParams.size(); + if ( a1 + an < length && nPar > 1 ) + { + list::reverse_iterator itU = theParams.rbegin(); + double Ul = *itU++; + // dist from the last point to the edge end , it should be equal + double Ln = GCPnts_AbscissaPoint::Length( C3d, Ul, Un ); + double dLn = an - Ln; // error of + if ( Abs( dLn ) <= Precision::Confusion() ) + return; + double dU = Abs( Ul - *itU ); // parametric length of the last but one segment + double dUn = dLn * Abs( Un - U1 ) / length; // parametric error of + if ( dUn < 0.5 * dU ) { // last segment is a bit shorter than it should + dUn = -dUn; // move the last parameter to the edge beginning + } + else { // last segment is much shorter than it should -> remove the last param and + theParams.pop_back(); nPar--; // move the rest points toward the edge end + Ln = GCPnts_AbscissaPoint::Length( C3d, theParams.back(), Un ); + dUn = ( an - Ln ) * Abs( Un - U1 ) / length; + if ( dUn < 0.5 * dU ) + dUn = -dUn; + } + if ( U1 > Un ) + dUn = -dUn; + double q = dUn / ( nPar - 1 ); + for ( itU = theParams.rbegin(), i = 1; i < nPar; itU++, i++ ) { + (*itU) += dUn; + dUn -= q; + } + } +} + //============================================================================= /*! * */ //============================================================================= bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge, - list & theParams) const + list & theParams, + const bool theReverse) const { theParams.clear(); @@ -193,7 +237,6 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge GeomAdaptor_Curve C3d(Curve); double length = EdgeLength(theEdge); - //SCRUTE(length); switch( _hypType ) { @@ -213,15 +256,16 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge double epsilon = 0.001; if (fabs(_value[ SCALE_FACTOR_IND ] - 1.0) > epsilon) { - double alpha = - pow( _value[ SCALE_FACTOR_IND ], 1.0 / (_value[ NB_SEGMENTS_IND ] - 1)); - double factor = - length / (1 - pow( alpha,_value[ NB_SEGMENTS_IND ])); + double scale = _value[ SCALE_FACTOR_IND ]; + if ( theReverse ) + scale = 1. / scale; + double alpha = pow( scale , 1.0 / (_value[ NB_SEGMENTS_IND ] - 1)); + double factor = (l - f) / (1 - pow( alpha,_value[ NB_SEGMENTS_IND ])); - int i, NbPoints = (int) _value[ NB_SEGMENTS_IND ]; + int i, NbPoints = 1 + (int) _value[ NB_SEGMENTS_IND ]; for ( i = 2; i < NbPoints; i++ ) { - double param = factor * (1 - pow(alpha, i - 1)); + double param = f + factor * (1 - pow(alpha, i - 1)); theParams.push_back( param ); } return true; @@ -253,102 +297,77 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge double an = _value[ END_LENGTH_IND ]; double q = ( length - a1 ) / ( length - an ); - double U1 = Min ( f, l ); - double Un = Max ( f, l ); + double U1 = theReverse ? l : f; + double Un = theReverse ? f : l; double param = U1; - double eltSize = a1; + double eltSize = theReverse ? -a1 : a1; while ( 1 ) { // computes a point on a curve at the distance // from the point of parameter . GCPnts_AbscissaPoint Discret( C3d, eltSize, param ); if ( !Discret.IsDone() ) break; param = Discret.Parameter(); - if ( param < Un ) + if ( param > f && param < l ) theParams.push_back( param ); else break; eltSize *= q; } - if ( a1 + an < length ) { - // compensate error - double Ln = GCPnts_AbscissaPoint::Length( C3d, theParams.back(), Un ); - double dLn = an - Ln; - if ( dLn < 0.5 * an ) - dLn = -dLn; - else { - theParams.pop_back(); - Ln = GCPnts_AbscissaPoint::Length( C3d, theParams.back(), Un ); - dLn = an - Ln; - if ( dLn < 0.5 * an ) - dLn = -dLn; - } - double dUn = dLn * ( Un - U1 ) / length; -// SCRUTE( Ln ); -// SCRUTE( dLn ); -// SCRUTE( dUn ); - list::reverse_iterator itU = theParams.rbegin(); - int i, n = theParams.size(); - for ( i = 1 ; i < n; itU++, i++ ) { - (*itU) += dUn; - dUn /= q; - } - } - - return true; - } - - case DEFLECTION: { - - GCPnts_UniformDeflection Discret(C3d, _value[ DEFLECTION_IND ], true); - if ( !Discret.IsDone() ) - return false; - - int NbPoints = Discret.NbPoints(); - for ( int i = 2; i < NbPoints; i++ ) - { - double param = Discret.Parameter(i); - theParams.push_back( param ); - } + compensateError( a1, an, U1, Un, length, C3d, theParams ); return true; - } case ARITHMETIC_1D: { - // arithmetic progression: SUM(n) = ( an - a1 + q ) * ( a1 + an ) / ( 2 * q ) = length + + // arithmetic progression: SUM(n) = ( an - a1 + q ) * ( a1 + an ) / ( 2 * q ) = length double a1 = _value[ BEG_LENGTH_IND ]; double an = _value[ END_LENGTH_IND ]; - double nd = (2 * length) / (an + a1) - 1; - int n = int(nd); - if(n != nd) - n++; + double q = ( an - a1 ) / ( 2 *length/( a1 + an ) - 1 ); + int n = int( 1 + ( an - a1 ) / q ); - double q = ((2 * length) / (n + 1) - 2 * a1) / n; - double U1 = Min ( f, l ); - double Un = Max ( f, l ); + double U1 = theReverse ? l : f; + double Un = theReverse ? f : l; double param = U1; double eltSize = a1; - - double L=0; - while ( 1 ) { - L+=eltSize; + if ( theReverse ) { + eltSize = -eltSize; + q = -q; + } + while ( n-- > 0 && eltSize * ( Un - U1 ) > 0 ) { // computes a point on a curve at the distance // from the point of parameter . GCPnts_AbscissaPoint Discret( C3d, eltSize, param ); if ( !Discret.IsDone() ) break; param = Discret.Parameter(); - if ( fabs(param - Un) > Precision::Confusion() && param < Un) { + if ( param > f && param < l ) theParams.push_back( param ); - } else break; eltSize += q; } + compensateError( a1, an, U1, Un, length, C3d, theParams ); return true; } + case DEFLECTION: { + + GCPnts_UniformDeflection Discret(C3d, _value[ DEFLECTION_IND ], true); + if ( !Discret.IsDone() ) + return false; + + int NbPoints = Discret.NbPoints(); + for ( int i = 2; i < NbPoints; i++ ) + { + double param = Discret.Parameter(i); + theParams.push_back( param ); + } + return true; + + } + default:; } @@ -401,8 +420,11 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aSh if (!Curve.IsNull()) { list< double > params; + bool reversed = false; + if ( !_mainEdge.IsNull() ) + reversed = aMesh.IsReversedInChain( EE, _mainEdge ); try { - if ( ! computeInternalParameters( E, params )) + if ( ! computeInternalParameters( E, params, reversed )) return false; } catch ( Standard_Failure ) { @@ -480,15 +502,17 @@ const list & StdMeshers_Regular_1D::GetUsedHypothes _usedHypList.clear(); _usedHypList = GetAppliedHypothesis(aMesh, aShape); // copy int nbHyp = _usedHypList.size(); + _mainEdge.Nullify(); if (nbHyp == 0) { // Check, if propagated from some other edge - TopoDS_Shape aMainEdge; if (aShape.ShapeType() == TopAbs_EDGE && - aMesh.IsPropagatedHypothesis(aShape, aMainEdge)) + aMesh.IsPropagatedHypothesis(aShape, _mainEdge)) { // Propagation of 1D hypothesis from on this edge - _usedHypList = GetAppliedHypothesis(aMesh, aMainEdge); // copy + //_usedHypList = GetAppliedHypothesis(aMesh, _mainEdge); // copy + // use a general method in order not to nullify _mainEdge + _usedHypList = SMESH_Algo::GetUsedHypothesis(aMesh, _mainEdge); // copy nbHyp = _usedHypList.size(); } }