#include "StdMeshers_Arithmetic1D.hxx"
#include "StdMeshers_StartEndLength.hxx"
#include "StdMeshers_Deflection1D.hxx"
+#include <StdMeshers_AutomaticLength.hxx>
#include "SMDS_MeshElement.hxx"
#include "SMDS_MeshNode.hxx"
#include "SMDS_EdgePosition.hxx"
#include "SMESH_subMesh.hxx"
+#include "Utils_SALOME_Exception.hxx"
#include "utilities.h"
#include <BRep_Tool.hxx>
#include <GCPnts_UniformDeflection.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Precision.hxx>
+#include <Expr_GeneralExpression.hxx>
+#include <Expr_NamedUnknown.hxx>
+#include <Expr_Array1OfNamedUnknown.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <ExprIntrp_GenExp.hxx>
+
+#include <CASCatch_CatchSignals.hxx>
+#include <CASCatch_Failure.hxx>
+#include <CASCatch_ErrorHandler.hxx>
+#include <OSD.hxx>
+#include <math_GaussSingleIntegration.hxx>
#include <string>
-//#include <algorithm>
+#include <math.h>
//=============================================================================
/*!
_compatibleHypothesis.push_back("StartEndLength");
_compatibleHypothesis.push_back("Deflection1D");
_compatibleHypothesis.push_back("Arithmetic1D");
+ _compatibleHypothesis.push_back("AutomaticLength");
}
//=============================================================================
const StdMeshers_NumberOfSegments * hyp =
dynamic_cast <const StdMeshers_NumberOfSegments * >(theHyp);
ASSERT(hyp);
- _value[ NB_SEGMENTS_IND ] = hyp->GetNumberOfSegments();
- _value[ SCALE_FACTOR_IND ] = hyp->GetScaleFactor();
- ASSERT( _value[ NB_SEGMENTS_IND ] > 0 );
+ _ivalue[ NB_SEGMENTS_IND ] = hyp->GetNumberOfSegments();
+ ASSERT( _ivalue[ NB_SEGMENTS_IND ] > 0 );
+ _ivalue[ DISTR_TYPE_IND ] = (int) hyp->GetDistrType();
+ switch (_ivalue[ DISTR_TYPE_IND ])
+ {
+ case StdMeshers_NumberOfSegments::DT_Scale:
+ _value[ SCALE_FACTOR_IND ] = hyp->GetScaleFactor();
+ break;
+ case StdMeshers_NumberOfSegments::DT_TabFunc:
+ _vvalue[ TAB_FUNC_IND ] = hyp->GetTableFunction();
+ break;
+ case StdMeshers_NumberOfSegments::DT_ExprFunc:
+ _svalue[ EXPR_FUNC_IND ] = hyp->GetExpressionFunction();
+ break;
+ case StdMeshers_NumberOfSegments::DT_Regular:
+ break;
+ default:
+ ASSERT(0);
+ break;
+ }
+ if (_ivalue[ DISTR_TYPE_IND ] == StdMeshers_NumberOfSegments::DT_TabFunc ||
+ _ivalue[ DISTR_TYPE_IND ] == StdMeshers_NumberOfSegments::DT_ExprFunc)
+ _ivalue[ EXP_MODE_IND ] = (int) hyp->IsExponentMode();
_hypType = NB_SEGMENTS;
aStatus = SMESH_Hypothesis::HYP_OK;
}
_hypType = DEFLECTION;
aStatus = SMESH_Hypothesis::HYP_OK;
}
+
+ else if (hypName == "AutomaticLength")
+ {
+ StdMeshers_AutomaticLength * hyp = const_cast<StdMeshers_AutomaticLength *>
+ (dynamic_cast <const StdMeshers_AutomaticLength * >(theHyp));
+ ASSERT(hyp);
+ _value[ BEG_LENGTH_IND ] = _value[ END_LENGTH_IND ] = hyp->GetLength( &aMesh, aShape );
+ ASSERT( _value[ BEG_LENGTH_IND ] > 0 );
+ _hypType = LOCAL_LENGTH;
+ aStatus = SMESH_Hypothesis::HYP_OK;
+ }
else
aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
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<double> & theParams)
+{
+ int i, nPar = theParams.size();
+ if ( a1 + an < length && nPar > 1 )
+ {
+ list<double>::reverse_iterator itU = theParams.rbegin();
+ double Ul = *itU++;
+ // dist from the last point to the edge end <Un>, it should be equal <an>
+ double Ln = GCPnts_AbscissaPoint::Length( C3d, Ul, Un );
+ double dLn = an - Ln; // error of <an>
+ 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 <an>
+ 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;
+ }
+ }
+}
+
+class Function
+{
+public:
+ Function( const bool exp )
+ : myExp( exp )
+ {
+ }
+
+ virtual ~Function()
+ {
+ }
+
+ virtual bool value( const double, double& f )
+ {
+ if( myExp )
+ f = pow( 10, f );
+ return true;
+ }
+ virtual double integral( const double, const double ) = 0;
+
+private:
+ bool myExp;
+};
+
+class FunctionIntegral : public Function
+{
+public:
+ FunctionIntegral( Function*, const double );
+ virtual ~FunctionIntegral();
+ virtual bool value( const double, double& );
+ virtual double integral( const double, const double );
+
+private:
+ Function* myFunc;
+ double myStart;
+};
+
+FunctionIntegral::FunctionIntegral( Function* f, const double st )
+: Function( false )
+{
+ myFunc = f;
+ myStart = st;
+}
+
+FunctionIntegral::~FunctionIntegral()
+{
+}
+
+bool FunctionIntegral::value( const double t, double& f )
+{
+ f = myFunc ? myFunc->integral( myStart, t ) : 0;
+ return myFunc!=0 && Function::value( t, f );
+}
+
+double FunctionIntegral::integral( const double, const double )
+{
+ return 0;
+}
+
+class FunctionTable : public Function
+{
+public:
+ FunctionTable( const std::vector<double>&, const bool );
+ virtual ~FunctionTable();
+ virtual bool value( const double, double& );
+ virtual double integral( const double, const double );
+
+private:
+ bool findBounds( const double, int&, int& ) const;
+
+ //integral from x[i] to x[i+1]
+ double integral( const int i );
+
+ //integral from x[i] to x[i]+d
+ //warning: function is presented as linear on interaval from x[i] to x[i]+d,
+ // for correct result d must be >=0 and <=x[i+1]-x[i]
+ double integral( const int i, const double d );
+
+private:
+ std::vector<double> myData;
+};
+
+FunctionTable::FunctionTable( const std::vector<double>& data, const bool exp )
+: Function( exp )
+{
+ myData = data;
+}
+
+FunctionTable::~FunctionTable()
+{
+}
+
+bool FunctionTable::value( const double t, double& f )
+{
+ int i1, i2;
+ if( !findBounds( t, i1, i2 ) )
+ return false;
+
+ double
+ x1 = myData[2*i1], y1 = myData[2*i1+1],
+ x2 = myData[2*i2], y2 = myData[2*i2+1];
+
+ Function::value( x1, y1 );
+ Function::value( x2, y2 );
+
+ f = y1 + ( y2-y1 ) * ( t-x1 ) / ( x2-x1 );
+ return true;
+}
+
+double FunctionTable::integral( const int i )
+{
+ if( i>=0 && i<myData.size()-1 )
+ return integral( i, myData[2*(i+1)]-myData[2*i] );
+ else
+ return 0;
+}
+
+double FunctionTable::integral( const int i, const double d )
+{
+ double f, res = 0.0;
+ if( value( myData[2*i]+d, f ) )
+ res = ( myData[2*i] + f ) / 2.0 * d;
+
+ return res;
+}
+
+double FunctionTable::integral( const double a, const double b )
+{
+ int x1s, x1f, x2s, x2f;
+ findBounds( a, x1s, x1f );
+ findBounds( b, x2s, x2f );
+ double J = 0;
+ for( int i=x1s; i<x2s; i++ )
+ J+=integral( i );
+ J-=integral( x1s, a-myData[2*x1s] );
+ J+=integral( x2s, b-myData[2*x2s] );
+ return J;
+}
+
+bool FunctionTable::findBounds( const double x, int& x_ind_1, int& x_ind_2 ) const
+{
+ int n = myData.size();
+ if( n==0 || x<myData[0] )
+ {
+ x_ind_1 = x_ind_2 = 0;
+ return false;
+ }
+
+ for( int i=0; i<n-1; i++ )
+ if( myData[2*i]<=x && x<=myData[2*(i+1)] )
+ {
+ x_ind_1 = i;
+ x_ind_2 = i+1;
+ return true;
+ }
+ x_ind_1 = n-1;
+ x_ind_2 = n-1;
+ return false;
+}
+
+
+
+class FunctionExpr : public Function, public math_Function
+{
+public:
+ FunctionExpr( const char*, const bool );
+ virtual ~FunctionExpr();
+ virtual Standard_Boolean Value( Standard_Real, Standard_Real& );
+ virtual bool value( const double, double& ); //inherited from Function
+ virtual double integral( const double, const double );
+
+private:
+ Handle(ExprIntrp_GenExp) myExpr;
+ Expr_Array1OfNamedUnknown myVars;
+ TColStd_Array1OfReal myValues;
+};
+
+FunctionExpr::FunctionExpr( const char* str, const bool exp )
+: Function( exp ),
+ myVars( 1, 1 ),
+ myValues( 1, 1 )
+{
+ myExpr = ExprIntrp_GenExp::Create();
+ myExpr->Process( ( Standard_CString )str );
+ if( !myExpr->IsDone() )
+ myExpr.Nullify();
+
+ myVars.ChangeValue( 1 ) = new Expr_NamedUnknown( "t" );
+}
+
+FunctionExpr::~FunctionExpr()
+{
+}
+
+Standard_Boolean FunctionExpr::Value( Standard_Real T, Standard_Real& F )
+{
+ double f;
+ Standard_Boolean res = value( T, f );
+ F = f;
+ return res;
+}
+
+bool FunctionExpr::value( const double t, double& f )
+{
+ if( myExpr.IsNull() )
+ return false;
+
+ CASCatch_CatchSignals aCatchSignals;
+ aCatchSignals.Activate();
+
+ myValues.ChangeValue( 1 ) = t;
+ bool ok = true;
+ CASCatch_TRY {
+ f = myExpr->Expression()->Evaluate( myVars, myValues );
+ }
+ CASCatch_CATCH(CASCatch_Failure) {
+ aCatchSignals.Deactivate();
+ Handle(CASCatch_Failure) aFail = CASCatch_Failure::Caught();
+ f = 0.0;
+ }
+
+ aCatchSignals.Deactivate();
+ ok = Function::value( t, f ) && ok;
+ return ok;
+}
+
+double FunctionExpr::integral( const double a, const double b )
+{
+ double res = 0.0;
+ CASCatch_TRY
+ {
+ math_GaussSingleIntegration _int( *this, a, b, 20 );
+ if( _int.IsDone() )
+ res = _int.Value();
+ }
+ CASCatch_CATCH(CASCatch_Failure)
+ {
+ res = 0.0;
+ MESSAGE( "Exception in integral calculating" );
+ }
+ return res;
+}
+
+
+
+
+
+
+
+double dihotomySolve( Function& f, const double val, const double _start, const double _fin, const double eps, bool& ok )
+{
+ double start = _start, fin = _fin, start_val, fin_val; bool ok1, ok2;
+ ok1 = f.value( start, start_val );
+ ok2 = f.value( fin, fin_val );
+
+ if( !ok1 || !ok2 )
+ {
+ ok = false;
+ return 0.0;
+ }
+
+ bool start_pos = start_val>=val, fin_pos = fin_val>=val;
+ ok = true;
+
+ while( fin-start>eps )
+ {
+ double mid = ( start+fin )/2.0, mid_val;
+ ok = f.value( mid, mid_val );
+ if( !ok )
+ return 0.0;
+
+// char buf[1024];
+// sprintf( buf, "start=%f\nfin=%f\nmid_val=%f\n", float( start ), float( fin ), float( mid_val ) );
+// MESSAGE( buf );
+
+ bool mid_pos = mid_val>=val;
+ if( start_pos!=mid_pos )
+ {
+ fin_pos = mid_pos;
+ fin = mid;
+ }
+ else if( fin_pos!=mid_pos )
+ {
+ start_pos = mid_pos;
+ start = mid;
+ }
+ else
+ break;
+ }
+ return (start+fin)/2.0;
+}
+
+static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last,
+ double length, bool theReverse,
+ int nbSeg, Function& func,
+ list<double>& theParams)
+{
+ OSD::SetSignal( true );
+ if( nbSeg<=0 )
+ return false;
+
+ MESSAGE( "computeParamByFunc" );
+
+ int nbPnt = 1 + nbSeg;
+ vector<double> x(nbPnt, 0.);
+
+ x[0] = 0.0;
+ double J = func.integral( 0.0, 1.0 ) / nbSeg;
+ bool ok;
+ for( int i=1; i<nbSeg; i++ )
+ {
+ FunctionIntegral f_int( &func, x[i-1] );
+ x[i] = dihotomySolve( f_int, J, x[i-1], 1.0, 1E-4, ok );
+ if( !ok )
+ return false;
+ }
+
+ x[nbSeg] = 1.0;
+ MESSAGE( "Points:\n" );
+ char buf[1024];
+ for( int i=0; i<=nbSeg; i++ )
+ {
+ sprintf( buf, "%f\n", float(x[i] ) );
+ MESSAGE( buf );
+ }
+
+
+
+ // apply parameters in range [0,1] to the space of the curve
+ double prevU = first;
+ double sign = 1.;
+ if (theReverse)
+ {
+ prevU = last;
+ sign = -1.;
+ }
+ for( int i = 1; i < nbSeg; i++ )
+ {
+ double curvLength = length * (x[i] - x[i-1]) * sign;
+ GCPnts_AbscissaPoint Discret( C3d, curvLength, prevU );
+ if ( !Discret.IsDone() )
+ return false;
+ double U = Discret.Parameter();
+ if ( U > first && U < last )
+ theParams.push_back( U );
+ else
+ return false;
+ prevU = U;
+ }
+ return true;
+}
+
//=============================================================================
/*!
*
*/
//=============================================================================
bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge,
- list<double> & theParams) const
+ list<double> & theParams,
+ const bool theReverse) const
{
theParams.clear();
GeomAdaptor_Curve C3d(Curve);
double length = EdgeLength(theEdge);
- //SCRUTE(length);
switch( _hypType )
{
double eltSize = 1;
if ( _hypType == LOCAL_LENGTH )
{
+ // Local Length hypothesis
double nbseg = ceil(length / _value[ BEG_LENGTH_IND ]); // integer sup
if (nbseg <= 0)
nbseg = 1; // degenerated edge
}
else
{
- double epsilon = 0.001;
- if (fabs(_value[ SCALE_FACTOR_IND ] - 1.0) > epsilon)
+ // Number Of Segments hypothesis
+ switch (_ivalue[ DISTR_TYPE_IND ])
{
- double alpha =
- pow( _value[ SCALE_FACTOR_IND ], 1.0 / (_value[ NB_SEGMENTS_IND ] - 1));
- double factor =
- length / (1 - pow( alpha,_value[ NB_SEGMENTS_IND ]));
-
- int i, NbPoints = 1 + (int) _value[ NB_SEGMENTS_IND ];
- for ( i = 2; i < NbPoints; i++ )
+ case StdMeshers_NumberOfSegments::DT_Scale:
{
- double param = factor * (1 - pow(alpha, i - 1));
- theParams.push_back( param );
+ double scale = _value[ SCALE_FACTOR_IND ];
+ if ( theReverse )
+ scale = 1. / scale;
+ double alpha = pow( scale , 1.0 / (_ivalue[ NB_SEGMENTS_IND ] - 1));
+ double factor = (l - f) / (1 - pow( alpha,_ivalue[ NB_SEGMENTS_IND ]));
+
+ int i, NbPoints = 1 + _ivalue[ NB_SEGMENTS_IND ];
+ for ( i = 2; i < NbPoints; i++ )
+ {
+ double param = f + factor * (1 - pow(alpha, i - 1));
+ theParams.push_back( param );
+ }
+ return true;
}
- return true;
- }
- else
- {
- eltSize = length / _value[ NB_SEGMENTS_IND ];
+ break;
+ case StdMeshers_NumberOfSegments::DT_TabFunc:
+ {
+ FunctionTable func(_vvalue[ TAB_FUNC_IND ], (bool)_ivalue[ EXP_MODE_IND ]);
+ return computeParamByFunc(C3d, f, l, length, theReverse,
+ _ivalue[ NB_SEGMENTS_IND ], func,
+ theParams);
+ }
+ break;
+ case StdMeshers_NumberOfSegments::DT_ExprFunc:
+ {
+ FunctionExpr func(_svalue[ EXPR_FUNC_IND ].c_str(), (bool)_ivalue[ EXP_MODE_IND ]);
+ return computeParamByFunc(C3d, f, l, length, theReverse,
+ _ivalue[ NB_SEGMENTS_IND ], func,
+ theParams);
+ }
+ break;
+ case StdMeshers_NumberOfSegments::DT_Regular:
+ eltSize = length / _ivalue[ NB_SEGMENTS_IND ];
+ break;
+ default:
+ return false;
}
}
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 <C3d> at the distance <eltSize>
// from the point of parameter <param>.
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<double>::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 <C3d> at the distance <eltSize>
// from the point of parameter <param>.
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:;
}
const TopoDS_Edge & EE = TopoDS::Edge(aShape);
TopoDS_Edge E = TopoDS::Edge(EE.Oriented(TopAbs_FORWARD));
+ int shapeID = meshDS->ShapeToIndex( E );
double f, l;
Handle(Geom_Curve) Curve = BRep_Tool::Curve(E, f, l);
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 ) {
//Add the Node in the DataStructure
SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
- meshDS->SetNodeOnEdge(node, E);
-
- // **** edgePosition associe au point = param.
- SMDS_EdgePosition* epos =
- dynamic_cast<SMDS_EdgePosition *>(node->GetPosition().get());
- epos->SetUParameter(param);
+ meshDS->SetNodeOnEdge(node, shapeID, param);
SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node);
- meshDS->SetMeshElementOnShape(edge, E);
+ meshDS->SetMeshElementOnShape(edge, shapeID);
idPrev = node;
}
SMDS_MeshEdge* edge = meshDS->AddEdge(idPrev, idLast);
- meshDS->SetMeshElementOnShape(edge, E);
+ meshDS->SetMeshElementOnShape(edge, shapeID);
}
else
{
{
double param = f + (i - 1) * du;
SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
- meshDS->SetNodeOnEdge(node, E);
-
- SMDS_EdgePosition* epos =
- dynamic_cast<SMDS_EdgePosition*>(node->GetPosition().get());
- epos->SetUParameter(param);
+ meshDS->SetNodeOnEdge(node, shapeID, param);
SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node);
- meshDS->SetMeshElementOnShape(edge, E);
+ meshDS->SetMeshElementOnShape(edge, shapeID);
idPrev = node;
}
SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, idLast);
- meshDS->SetMeshElementOnShape(edge, E);
+ meshDS->SetMeshElementOnShape(edge, shapeID);
}
return true;
}
_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 <aMainEdge> 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();
}
}
