X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FStdMeshers%2FStdMeshers_Regular_1D.cxx;h=8d900955d284778f5dadb9fddb78416b11f5311e;hp=a24abbb98acc4093f57b2dbedb4950b11815224f;hb=bd4e115a78b52e3fbc016e5e30bb0e19b2a9e7d6;hpb=58187d6f689f07303e5a147e853155e8c5f058d8 diff --git a/src/StdMeshers/StdMeshers_Regular_1D.cxx b/src/StdMeshers/StdMeshers_Regular_1D.cxx index a24abbb98..8d900955d 100644 --- a/src/StdMeshers/StdMeshers_Regular_1D.cxx +++ b/src/StdMeshers/StdMeshers_Regular_1D.cxx @@ -1,70 +1,72 @@ -// SMESH SMESH : implementaion of SMESH idl descriptions +// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE // -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. // +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// + // File : StdMeshers_Regular_1D.cxx // Moved here from SMESH_Regular_1D.cxx // Author : Paul RASCLE, EDF // Module : SMESH -// $Header$ - -using namespace std; - +// #include "StdMeshers_Regular_1D.hxx" -#include "SMESH_Gen.hxx" -#include "SMESH_Mesh.hxx" +#include "StdMeshers_Distribution.hxx" +#include "StdMeshers_Arithmetic1D.hxx" +#include "StdMeshers_AutomaticLength.hxx" +#include "StdMeshers_Deflection1D.hxx" #include "StdMeshers_LocalLength.hxx" +#include "StdMeshers_MaxLength.hxx" #include "StdMeshers_NumberOfSegments.hxx" -#include "StdMeshers_Arithmetic1D.hxx" +#include "StdMeshers_Propagation.hxx" +#include "StdMeshers_SegmentLengthAroundVertex.hxx" #include "StdMeshers_StartEndLength.hxx" -#include "StdMeshers_Deflection1D.hxx" + +#include "SMESH_Gen.hxx" +#include "SMESH_Mesh.hxx" +#include "SMESH_HypoFilter.hxx" +#include "SMESH_subMesh.hxx" +#include "SMESH_subMeshEventListener.hxx" +#include "SMESH_Comment.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 #include -#include -#include -#include -#include #include #include #include -#include #include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include -#include +#include + +using namespace std; //============================================================================= /*! @@ -73,17 +75,24 @@ using namespace std; //============================================================================= StdMeshers_Regular_1D::StdMeshers_Regular_1D(int hypId, int studyId, - SMESH_Gen * gen):SMESH_1D_Algo(hypId, studyId, gen) + SMESH_Gen * gen):SMESH_1D_Algo(hypId, studyId, gen) { - MESSAGE("StdMeshers_Regular_1D::StdMeshers_Regular_1D"); - _name = "Regular_1D"; - _shapeType = (1 << TopAbs_EDGE); - - _compatibleHypothesis.push_back("LocalLength"); - _compatibleHypothesis.push_back("NumberOfSegments"); - _compatibleHypothesis.push_back("StartEndLength"); - _compatibleHypothesis.push_back("Deflection1D"); - _compatibleHypothesis.push_back("Arithmetic1D"); + MESSAGE("StdMeshers_Regular_1D::StdMeshers_Regular_1D"); + _name = "Regular_1D"; + _shapeType = (1 << TopAbs_EDGE); + _fpHyp = 0; + + _compatibleHypothesis.push_back("LocalLength"); + _compatibleHypothesis.push_back("MaxLength"); + _compatibleHypothesis.push_back("NumberOfSegments"); + _compatibleHypothesis.push_back("StartEndLength"); + _compatibleHypothesis.push_back("Deflection1D"); + _compatibleHypothesis.push_back("Arithmetic1D"); + _compatibleHypothesis.push_back("FixedPoints1D"); + _compatibleHypothesis.push_back("AutomaticLength"); + + _compatibleHypothesis.push_back("QuadraticMesh"); // auxiliary !!! + _compatibleHypothesis.push_back("Propagation"); // auxiliary !!! } //============================================================================= @@ -103,22 +112,36 @@ StdMeshers_Regular_1D::~StdMeshers_Regular_1D() //============================================================================= bool StdMeshers_Regular_1D::CheckHypothesis - (SMESH_Mesh& aMesh, - const TopoDS_Shape& aShape, + (SMESH_Mesh& aMesh, + const TopoDS_Shape& aShape, SMESH_Hypothesis::Hypothesis_Status& aStatus) { _hypType = NONE; + _quadraticMesh = false; + + const list & hyps = + GetUsedHypothesis(aMesh, aShape, /*ignoreAuxiliaryHyps=*/false); + + // find non-auxiliary hypothesis + const SMESHDS_Hypothesis *theHyp = 0; + list ::const_iterator h = hyps.begin(); + for ( ; h != hyps.end(); ++h ) { + if ( static_cast(*h)->IsAuxiliary() ) { + if ( strcmp( "QuadraticMesh", (*h)->GetName() ) == 0 ) + _quadraticMesh = true; + } + else { + if ( !theHyp ) + theHyp = *h; // use only the first non-auxiliary hypothesis + } + } - const list &hyps = GetUsedHypothesis(aMesh, aShape); - if (hyps.size() == 0) + if ( !theHyp ) { aStatus = SMESH_Hypothesis::HYP_MISSING; return false; // can't work without a hypothesis } - // use only the first hypothesis - const SMESHDS_Hypothesis *theHyp = hyps.front(); - string hypName = theHyp->GetName(); if (hypName == "LocalLength") @@ -126,12 +149,28 @@ bool StdMeshers_Regular_1D::CheckHypothesis const StdMeshers_LocalLength * hyp = dynamic_cast (theHyp); ASSERT(hyp); - _value[ BEG_LENGTH_IND ] = _value[ END_LENGTH_IND ] = hyp->GetLength(); + _value[ BEG_LENGTH_IND ] = hyp->GetLength(); + _value[ PRECISION_IND ] = hyp->GetPrecision(); ASSERT( _value[ BEG_LENGTH_IND ] > 0 ); _hypType = LOCAL_LENGTH; aStatus = SMESH_Hypothesis::HYP_OK; } + else if (hypName == "MaxLength") + { + const StdMeshers_MaxLength * hyp = + dynamic_cast (theHyp); + ASSERT(hyp); + _value[ BEG_LENGTH_IND ] = hyp->GetLength(); + if ( hyp->GetUsePreestimatedLength() ) { + if ( int nbSeg = aMesh.GetGen()->GetBoundaryBoxSegmentation() ) + _value[ BEG_LENGTH_IND ] = aMesh.GetShapeDiagonalSize() / nbSeg; + } + ASSERT( _value[ BEG_LENGTH_IND ] > 0 ); + _hypType = MAX_LENGTH; + aStatus = SMESH_Hypothesis::HYP_OK; + } + else if (hypName == "NumberOfSegments") { const StdMeshers_NumberOfSegments * hyp = @@ -144,12 +183,15 @@ bool StdMeshers_Regular_1D::CheckHypothesis { case StdMeshers_NumberOfSegments::DT_Scale: _value[ SCALE_FACTOR_IND ] = hyp->GetScaleFactor(); + _revEdgesIDs = hyp->GetReversedEdges(); break; case StdMeshers_NumberOfSegments::DT_TabFunc: _vvalue[ TAB_FUNC_IND ] = hyp->GetTableFunction(); + _revEdgesIDs = hyp->GetReversedEdges(); break; case StdMeshers_NumberOfSegments::DT_ExprFunc: _svalue[ EXPR_FUNC_IND ] = hyp->GetExpressionFunction(); + _revEdgesIDs = hyp->GetReversedEdges(); break; case StdMeshers_NumberOfSegments::DT_Regular: break; @@ -159,7 +201,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis } if (_ivalue[ DISTR_TYPE_IND ] == StdMeshers_NumberOfSegments::DT_TabFunc || _ivalue[ DISTR_TYPE_IND ] == StdMeshers_NumberOfSegments::DT_ExprFunc) - _ivalue[ EXP_MODE_IND ] = (int) hyp->IsExponentMode(); + _ivalue[ CONV_MODE_IND ] = hyp->ConversionMode(); _hypType = NB_SEGMENTS; aStatus = SMESH_Hypothesis::HYP_OK; } @@ -173,6 +215,19 @@ bool StdMeshers_Regular_1D::CheckHypothesis _value[ END_LENGTH_IND ] = hyp->GetLength( false ); ASSERT( _value[ BEG_LENGTH_IND ] > 0 && _value[ END_LENGTH_IND ] > 0 ); _hypType = ARITHMETIC_1D; + + _revEdgesIDs = hyp->GetReversedEdges(); + + aStatus = SMESH_Hypothesis::HYP_OK; + } + + else if (hypName == "FixedPoints1D") { + _fpHyp = dynamic_cast (theHyp); + ASSERT(_fpHyp); + _hypType = FIXED_POINTS_1D; + + _revEdgesIDs = _fpHyp->GetReversedEdges(); + aStatus = SMESH_Hypothesis::HYP_OK; } @@ -185,6 +240,9 @@ bool StdMeshers_Regular_1D::CheckHypothesis _value[ END_LENGTH_IND ] = hyp->GetLength( false ); ASSERT( _value[ BEG_LENGTH_IND ] > 0 && _value[ END_LENGTH_IND ] > 0 ); _hypType = BEG_END_LENGTH; + + _revEdgesIDs = hyp->GetReversedEdges(); + aStatus = SMESH_Hypothesis::HYP_OK; } @@ -198,312 +256,331 @@ bool StdMeshers_Regular_1D::CheckHypothesis _hypType = DEFLECTION; aStatus = SMESH_Hypothesis::HYP_OK; } + + else if (hypName == "AutomaticLength") + { + StdMeshers_AutomaticLength * hyp = const_cast + (dynamic_cast (theHyp)); + ASSERT(hyp); + _value[ BEG_LENGTH_IND ] = _value[ END_LENGTH_IND ] = hyp->GetLength( &aMesh, aShape ); +// _value[ BEG_LENGTH_IND ] = hyp->GetLength( &aMesh, aShape ); +// _value[ END_LENGTH_IND ] = Precision::Confusion(); // ?? or set to zero? + ASSERT( _value[ BEG_LENGTH_IND ] > 0 ); + _hypType = MAX_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 bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last, + double length, bool theReverse, + int nbSeg, Function& func, + list& theParams) +{ + // never do this way + //OSD::SetSignal( true ); + + if (nbSeg <= 0) + return false; + + MESSAGE( "computeParamByFunc" ); + + int nbPnt = 1 + nbSeg; + vector x(nbPnt, 0.); + + if (!buildDistribution(func, 0.0, 1.0, nbSeg, x, 1E-4)) + return false; + + 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; + } + if ( theReverse ) + theParams.reverse(); + return true; +} + + +//================================================================================ +/*! + * \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 + */ +//================================================================================ static void compensateError(double a1, double an, double U1, double Un, - double length, - GeomAdaptor_Curve& C3d, - list & theParams) + double length, + Adaptor3d_Curve& C3d, + list & theParams, + bool adjustNeighbors2an = false) { int i, nPar = theParams.size(); if ( a1 + an < length && nPar > 1 ) { + bool reverse = ( U1 > Un ); + GCPnts_AbscissaPoint Discret(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++; - // 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() ) + 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 - 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 + if ( adjustNeighbors2an || Abs(dUn) < 0.5 * dU ) { // last segment is a bit shorter than it should + // 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; + dUn = Utgt - theParams.back(); } - if ( U1 > Un ) - dUn = -dUn; + double q = dUn / ( nPar - 1 ); - for ( itU = theParams.rbegin(), i = 1; i < nPar; itU++, i++ ) { - (*itU) += dUn; - dUn -= q; + if ( !adjustNeighbors2an ) + { + q = dUn / ( Utgt - Un ); // (signed) factor of segment length change + for ( itU = theParams.rbegin(), i = 1; i < nPar; i++ ) { + double prevU = *itU; + (*itU) += dUn; + ++itU; + dUn = q * (*itU - prevU) * (prevU-U1)/(Un-U1); + } + } + else { + theParams.back() += dUn; + double sign = reverse ? -1 : 1; + double prevU = theParams.back(); + itU = theParams.rbegin(); + for ( ++itU, i = 2; i < nPar; ++itU, i++ ) { + double newU = *itU + dUn; + if ( newU*sign < prevU*sign ) { + prevU = *itU = newU; + dUn -= q; + } + else { // set U between prevU and next valid param + list::reverse_iterator itU2 = itU; + ++itU2; + int nb = 2; + while ( (*itU2)*sign > prevU*sign ) { + ++itU2; ++nb; + } + dU = ( *itU2 - prevU ) / nb; + while ( itU != itU2 ) { + *itU += dU; ++itU; + } + break; + } + } } } } +//================================================================================ /*! - * \brief This class provides interface for a density function + * \brief Class used to clean mesh on edges when 0D hyp modified. + * Common approach doesn't work when 0D algo is missing because the 0D hyp is + * considered as not participating in computation whereas it is used by 1D algo. */ -class Function -{ -public: - Function(bool expMode) : _expMode(expMode) {} - double operator() (double t) const; - virtual bool IsReady() const = 0; -protected: - virtual double compute(double t) const = 0; -private: - bool _expMode; -}; +//================================================================================ -/*! - * \brief This class provides computation of density function given by a table - */ -class TabFunction: public Function -{ -public: - TabFunction(const vector& table, bool expMode); - virtual bool IsReady() const; -protected: - virtual double compute(double t) const; -private: - const vector& _table; -}; +// struct VertexEventListener : public SMESH_subMeshEventListener +// { +// VertexEventListener():SMESH_subMeshEventListener(0) // won't be deleted by submesh +// {} +// /*! +// * \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 +// */ +// void ProcessEvent(const int event, const int eventType, SMESH_subMesh* subMesh, +// EventListenerData*, const SMESH_Hypothesis*) +// { +// if ( eventType == SMESH_subMesh::ALGO_EVENT) // all algo events +// { +// subMesh->ComputeStateEngine( SMESH_subMesh::MODIF_ALGO_STATE ); +// } +// } +// }; // struct VertexEventListener +//============================================================================= /*! - * \brief This class provides computation of density function given by an expression + * \brief Sets event listener to vertex submeshes + * \param subMesh - submesh where algo is set + * + * This method is called when a submesh gets HYP_OK algo_state. + * After being set, event listener is notified on each event of a submesh. */ -class ExprFunction: public Function -{ -public: - ExprFunction(const char* expr, bool expMode); - virtual bool IsReady() const; -protected: - virtual double compute(double t) const; -private: - Handle(Expr_GeneralExpression) _expression; - Expr_Array1OfNamedUnknown _var; - mutable TColStd_Array1OfReal _val; -}; - -double Function::operator() (double t) const -{ - double res = compute(t); - if (_expMode) - res = pow(10, res); - return res; -} - -TabFunction::TabFunction(const vector& table, bool expMode) - : Function(expMode), - _table(table) -{ -} - -bool TabFunction::IsReady() const -{ - return true; -} - -double TabFunction::compute (double t) const -{ - //find place of in table - int i; - for (i=0; i < _table.size()/2; i++) - if (_table[i*2] > t) - break; - if (i >= _table.size()/2) - i = _table.size()/2 - 1; - - if (i == 0) - return _table[1]; - - // interpolate function value on found interval - // (t - x[i-1]) / (x[i] - x[i-1]) = (y - f[i-1]) / (f[i] - f[i-1]) - // => y = f[i-1] + (f[i] - f[i-1]) * (t - x[i-1]) / (x[i] - x[i-1]) - double x1 = _table[(i-1)*2]; - double x2 = _table[i*2]; - double y1 = _table[(i-1)*2+1]; - double y2 = _table[i*2+1]; - if (x2 - x1 < Precision::Confusion()) - throw SALOME_Exception("TabFunction::compute : confused points"); - return y1 + (y2 - y1) * ((t - x1) / (x2 - x1)); -} +//============================================================================= -ExprFunction::ExprFunction(const char* expr, bool expMode) - : Function(expMode), - _var(1,1), - _val(1,1) +void StdMeshers_Regular_1D::SetEventListener(SMESH_subMesh* subMesh) { - Handle( ExprIntrp_GenExp ) gen = ExprIntrp_GenExp::Create(); - gen->Process(TCollection_AsciiString((char*)expr)); - if (gen->IsDone()) - { - _expression = gen->Expression(); - _var(1) = new Expr_NamedUnknown("t"); - } + StdMeshers_Propagation::SetPropagationMgr( subMesh ); } -bool ExprFunction::IsReady() const -{ - return !_expression.IsNull(); -} +//============================================================================= +/*! + * \brief Do nothing + * \param subMesh - restored submesh + * + * This method is called only if a submesh has HYP_OK algo_state. + */ +//============================================================================= -double ExprFunction::compute (double t) const +void StdMeshers_Regular_1D::SubmeshRestored(SMESH_subMesh* subMesh) { - ASSERT(!_expression.IsNull()); - _val(1) = t; - return _expression->Evaluate(_var, _val); } -//================================================================================ +//============================================================================= /*! - * \brief Compute next abscissa when two previous ones are given - * \param sm2 - before previous abscissa - * \param sm1 - previous abscissa - * \param func - function of density - * \param reverse - the direction of next abscissa, increase (0) or decrease (1) - * \retval double - the new abscissa - * - * The abscissa s is given by the formulae - * - * ....|--------|----------------|..... - * sm2 sm1 s - * - * func(sm2) / func(sm1) = (sm1-sm2) / (s-sm1) - * => (s-sm1) * func(sm2) = (sm1-sm2) * func(sm1) - * => s = sm1 + (sm1-sm2) * func(sm1) / func(sm2) + * \brief Return StdMeshers_SegmentLengthAroundVertex assigned to vertex */ -//================================================================================ +//============================================================================= -static double nextAbscissa(double sm2, double sm1, const Function& func, int reverse) +const StdMeshers_SegmentLengthAroundVertex* +StdMeshers_Regular_1D::getVertexHyp(SMESH_Mesh & theMesh, + const TopoDS_Vertex & theV) { - if (reverse) + static SMESH_HypoFilter filter( SMESH_HypoFilter::HasName("SegmentAroundVertex_0D")); + if ( const SMESH_Hypothesis * h = theMesh.GetHypothesis( theV, filter, true )) { - sm1 = 1.0 - sm1; - sm2 = 1.0 - sm2; + SMESH_Algo* algo = const_cast< SMESH_Algo* >( static_cast< const SMESH_Algo* > ( h )); + const list & hypList = algo->GetUsedHypothesis( theMesh, theV, 0 ); + if ( !hypList.empty() && string("SegmentLengthAroundVertex") == hypList.front()->GetName() ) + return static_cast( hypList.front() ); } - return sm1 + (sm1-sm2) * func(sm1) / func(sm2); + return 0; } //================================================================================ /*! - * \brief Compute distribution of points on a curve following the law of a function - * \param C3d - the curve to discretize - * \param first - the first parameter on the curve - * \param last - the last parameter on the curve - * \param theReverse - flag indicating that the curve must be reversed - * \param nbSeg - number of output segments - * \param func - the function f(t) - * \param theParams - output points - * \retval bool - true if success + * \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 */ //================================================================================ -static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last, - double length, bool theReverse, - int nbSeg, const Function& func, - list& theParams) +void StdMeshers_Regular_1D::redistributeNearVertices (SMESH_Mesh & theMesh, + Adaptor3d_Curve & theC3d, + double theLength, + std::list< double > & theParameters, + const TopoDS_Vertex & theVf, + const TopoDS_Vertex & theVl) { - if (!func.IsReady()) - return false; - vector xxx[2]; - int nbPnt = 1 + nbSeg; - int rev, i; - for (rev=0; rev < 2; rev++) + double f = theC3d.FirstParameter(), l = theC3d.LastParameter(); + int nPar = theParameters.size(); + for ( int isEnd1 = 0; isEnd1 < 2; ++isEnd1 ) { - // curv abscisses initialisation - vector x(nbPnt, 0.); - // the first abscissa is 0.0 - - // The aim of the algorithm is to find a second abscisse x[1] such as the last - // one x[nbSeg] is very close to 1.0 with the epsilon precision - - double x1_too_small = 0.0; - double x1_too_large = RealLast(); - double x1 = 1.0/nbSeg; - while (1) - { - x[1] = x1; - - // Check if the abscissa of the point 2 to N-1 - // are in the segment ... - - bool ok = true; - for (i=2; i <= nbSeg; i++) + const TopoDS_Vertex & V = isEnd1 ? theVf : theVl; + const StdMeshers_SegmentLengthAroundVertex* hyp = getVertexHyp (theMesh, V ); + if ( hyp ) { + double vertexLength = hyp->GetLength(); + if ( vertexLength > theLength / 2.0 ) + continue; + if ( isEnd1 ) { // to have a segment of interest at end of theParameters + theParameters.reverse(); + std::swap( f, l ); + } + if ( _hypType == NB_SEGMENTS ) { - x[i] = nextAbscissa(x[i-2], x[i-1], func, rev); - if (x[i] - 1.0 > Precision::Confusion()) - { - x[nbSeg] = x[i]; - ok = false; - break; - } + compensateError(0, vertexLength, f, l, theLength, theC3d, theParameters, true ); } - if (!ok) + else if ( nPar <= 3 ) { - // The segments are to large - // Decrease x1 ... - x1_too_large = x1; - x1 = (x1_too_small+x1_too_large)/2; - continue; + if ( !isEnd1 ) + vertexLength = -vertexLength; + GCPnts_AbscissaPoint Discret(theC3d, vertexLength, l); + if ( Discret.IsDone() ) { + if ( nPar == 0 ) + theParameters.push_back( Discret.Parameter()); + else { + double L = GCPnts_AbscissaPoint::Length( theC3d, theParameters.back(), l); + if ( vertexLength < L / 2.0 ) + theParameters.push_back( Discret.Parameter()); + else + compensateError(0, vertexLength, f, l, theLength, theC3d, theParameters, true ); + } + } } - - // Look at the abscissa of the point N - // which is to be close to 1.0 - - // break condition --> algo converged !! - - if (1.0 - x[nbSeg] < Precision::Confusion()) - break; - - // not ok ... - - x1_too_small = x1; - - // Modify x1 value - - if (x1_too_large > 1e100) - x1 = 2*x1; else - x1 = (x1_too_small+x1_too_large)/2; + { + // recompute params between the last segment and a middle one. + // find size of a middle segment + int nHalf = ( nPar-1 ) / 2; + list< double >::reverse_iterator itU = theParameters.rbegin(); + std::advance( itU, nHalf ); + double Um = *itU++; + double Lm = GCPnts_AbscissaPoint::Length( theC3d, Um, *itU); + double L = GCPnts_AbscissaPoint::Length( theC3d, *itU, l); + StdMeshers_Regular_1D algo( *this ); + algo._hypType = BEG_END_LENGTH; + algo._value[ BEG_LENGTH_IND ] = Lm; + algo._value[ END_LENGTH_IND ] = vertexLength; + double from = *itU, to = l; + if ( isEnd1 ) { + std::swap( from, to ); + std::swap( algo._value[ BEG_LENGTH_IND ], algo._value[ END_LENGTH_IND ]); + } + list params; + if ( algo.computeInternalParameters( theMesh, theC3d, L, from, to, params, false )) + { + if ( isEnd1 ) params.reverse(); + while ( 1 + nHalf-- ) + theParameters.pop_back(); + theParameters.splice( theParameters.end(), params ); + } + else + { + compensateError(0, vertexLength, f, l, theLength, theC3d, theParameters, true ); + } + } + if ( isEnd1 ) + theParameters.reverse(); } - xxx[rev] = x; } - - // average - vector x(nbPnt, 0.); - for (i=0; i < nbPnt; i++) - x[i] = (xxx[0][i] + (1.0 - xxx[1][nbPnt-i])) / 2; - - // 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 (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 false; } //============================================================================= @@ -511,81 +588,142 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last, * */ //============================================================================= -bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge, - list & theParams, - const bool theReverse) const +bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, + Adaptor3d_Curve& theC3d, + double theLength, + double theFirstU, + double theLastU, + list & theParams, + const bool theReverse, + bool theConsiderPropagation) { theParams.clear(); - double f, l; - Handle(Geom_Curve) Curve = BRep_Tool::Curve(theEdge, f, l); - GeomAdaptor_Curve C3d(Curve); - - double length = EdgeLength(theEdge); + double f = theFirstU, l = theLastU; switch( _hypType ) { case LOCAL_LENGTH: + case MAX_LENGTH: case NB_SEGMENTS: { double eltSize = 1; - if ( _hypType == LOCAL_LENGTH ) + if ( _hypType == MAX_LENGTH ) + { + double nbseg = ceil(theLength / _value[ BEG_LENGTH_IND ]); // integer sup + if (nbseg <= 0) + nbseg = 1; // degenerated edge + eltSize = theLength / nbseg; + } + else if ( _hypType == LOCAL_LENGTH ) { // Local Length hypothesis - double nbseg = ceil(length / _value[ BEG_LENGTH_IND ]); // integer sup + double nbseg = ceil(theLength / _value[ BEG_LENGTH_IND ]); // integer sup + + // NPAL17873: + bool isFound = false; + if (theConsiderPropagation && !_mainEdge.IsNull()) // propagated from some other edge + { + // Advanced processing to assure equal number of segments in case of Propagation + SMESH_subMesh* sm = theMesh.GetSubMeshContaining(_mainEdge); + if (sm) { + bool computed = sm->IsMeshComputed(); + if (!computed) { + if (sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE) { + _gen->Compute( theMesh, _mainEdge, /*anUpward=*/true); + computed = sm->IsMeshComputed(); + } + } + if (computed) { + SMESHDS_SubMesh* smds = sm->GetSubMeshDS(); + int nb_segments = smds->NbElements(); + if (nbseg - 1 <= nb_segments && nb_segments <= nbseg + 1) { + isFound = true; + nbseg = nb_segments; + } + } + } + } + if (!isFound) // not found by meshed edge in the propagation chain, use precision + { + double aPrecision = _value[ PRECISION_IND ]; + double nbseg_prec = ceil((theLength / _value[ BEG_LENGTH_IND ]) - aPrecision); + if (nbseg_prec == (nbseg - 1)) nbseg--; + } + if (nbseg <= 0) nbseg = 1; // degenerated edge - eltSize = length / nbseg; + eltSize = theLength / nbseg; } else { // Number Of Segments hypothesis + int NbSegm = _ivalue[ NB_SEGMENTS_IND ]; + if ( NbSegm < 1 ) return false; + if ( NbSegm == 1 ) return true; + switch (_ivalue[ DISTR_TYPE_IND ]) { case StdMeshers_NumberOfSegments::DT_Scale: { 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++ ) + if (fabs(scale - 1.0) < Precision::Confusion()) { + // special case to avoid division by zero + for (int i = 1; i < NbSegm; i++) { + double param = f + (l - f) * i / NbSegm; + theParams.push_back( param ); + } + } else { + // general case of scale distribution + if ( theReverse ) + scale = 1.0 / scale; + + double alpha = pow(scale, 1.0 / (NbSegm - 1)); + double factor = (l - f) / (1.0 - pow(alpha, NbSegm)); + + for (int i = 1; i < NbSegm; i++) { + double param = f + factor * (1.0 - pow(alpha, i)); + theParams.push_back( param ); + } + } + const double lenFactor = theLength/(l-f); + list::iterator u = theParams.begin(), uEnd = theParams.end(); + for ( ; u != uEnd; ++u ) { - double param = f + factor * (1 - pow(alpha, i - 1)); - theParams.push_back( param ); + GCPnts_AbscissaPoint Discret( theC3d, ((*u)-f) * lenFactor, f ); + if ( Discret.IsDone() ) + *u = Discret.Parameter(); } return true; } break; case StdMeshers_NumberOfSegments::DT_TabFunc: { - TabFunction func(_vvalue[ TAB_FUNC_IND ], (bool)_ivalue[ EXP_MODE_IND ]); - return computeParamByFunc(C3d, f, l, length, theReverse, + FunctionTable func(_vvalue[ TAB_FUNC_IND ], _ivalue[ CONV_MODE_IND ]); + return computeParamByFunc(theC3d, f, l, theLength, theReverse, _ivalue[ NB_SEGMENTS_IND ], func, theParams); } break; case StdMeshers_NumberOfSegments::DT_ExprFunc: { - ExprFunction func(_svalue[ EXPR_FUNC_IND ].c_str(), (bool)_ivalue[ EXP_MODE_IND ]); - return computeParamByFunc(C3d, f, l, length, theReverse, + FunctionExpr func(_svalue[ EXPR_FUNC_IND ].c_str(), _ivalue[ CONV_MODE_IND ]); + return computeParamByFunc(theC3d, f, l, theLength, theReverse, _ivalue[ NB_SEGMENTS_IND ], func, theParams); } break; case StdMeshers_NumberOfSegments::DT_Regular: - eltSize = length / _ivalue[ NB_SEGMENTS_IND ]; + eltSize = theLength / _ivalue[ NB_SEGMENTS_IND ]; break; default: return false; } } - - GCPnts_UniformAbscissa Discret(C3d, eltSize, f, l); + GCPnts_UniformAbscissa Discret(theC3d, eltSize, f, l); if ( !Discret.IsDone() ) - return false; + return error( "GCPnts_UniformAbscissa failed"); int NbPoints = Discret.NbPoints(); for ( int i = 2; i < NbPoints; i++ ) @@ -593,46 +731,54 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge double param = Discret.Parameter(i); theParams.push_back( param ); } + compensateError( eltSize, eltSize, f, l, theLength, theC3d, theParams ); // for PAL9899 return true; } case BEG_END_LENGTH: { - // geometric progression: SUM(n) = ( a1 - an * q ) / ( 1 - q ) = length + // geometric progression: SUM(n) = ( a1 - an * q ) / ( 1 - q ) = theLength double a1 = _value[ BEG_LENGTH_IND ]; double an = _value[ END_LENGTH_IND ]; - double q = ( length - a1 ) / ( length - an ); + double q = ( theLength - a1 ) / ( theLength - an ); + if ( q < theLength/1e6 || 1.01*theLength < a1 + an) + return error ( SMESH_Comment("Invalid segment lengths (")< at the distance + // computes a point on a curve at the distance // from the point of parameter . - GCPnts_AbscissaPoint Discret( C3d, eltSize, param ); + GCPnts_AbscissaPoint Discret( theC3d, eltSize, param ); if ( !Discret.IsDone() ) break; param = Discret.Parameter(); - if ( param > f && param < l ) + if ( f < param && param < l ) theParams.push_back( param ); else break; eltSize *= q; } - compensateError( a1, an, U1, Un, length, C3d, theParams ); + compensateError( a1, an, U1, Un, theLength, theC3d, theParams ); + if (theReverse) theParams.reverse(); // NPAL18025 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 ) = theLength double a1 = _value[ BEG_LENGTH_IND ]; double an = _value[ END_LENGTH_IND ]; + if ( 1.01*theLength < a1 + an) + return error ( SMESH_Comment("Invalid segment lengths (")< numeric_limits::min() ? ( 1+( an-a1 )/q ) : ( 1+theLength/a1 )); double U1 = theReverse ? l : f; double Un = theReverse ? f : l; @@ -643,9 +789,9 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge q = -q; } while ( n-- > 0 && eltSize * ( Un - U1 ) > 0 ) { - // computes a point on a curve at the distance + // computes a point on a curve at the distance // from the point of parameter . - GCPnts_AbscissaPoint Discret( C3d, eltSize, param ); + GCPnts_AbscissaPoint Discret( theC3d, eltSize, param ); if ( !Discret.IsDone() ) break; param = Discret.Parameter(); if ( param > f && param < l ) @@ -654,14 +800,116 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge break; eltSize += q; } - compensateError( a1, an, U1, Un, length, C3d, theParams ); + compensateError( a1, an, U1, Un, theLength, theC3d, theParams ); + if (theReverse) theParams.reverse(); // NPAL18025 return true; } + case FIXED_POINTS_1D: { + const std::vector& aPnts = _fpHyp->GetPoints(); + const std::vector& nbsegs = _fpHyp->GetNbSegments(); + int i = 0; + TColStd_SequenceOfReal Params; + for(; i0.9999 ) continue; + int j=1; + bool IsExist = false; + for(; j<=Params.Length(); j++) { + if( fabs(aPnts[i]-Params.Value(j)) < 1e-4 ) { + IsExist = true; + break; + } + if( aPnts[i] nbsegs.size()-1 ) ? nbsegs[0] : nbsegs[i]; + segmentSize = Params.Value(i+1)*theLength - currAbscissa; + currAbscissa += segmentSize; + GCPnts_AbscissaPoint APnt(theC3d, sign*segmentSize, par1); + 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::iterator itP = tmpParams.begin(); + for(; itP != tmpParams.end(); itP++) { + theParams.push_back( *(itP) ); + } + theParams.push_back( par2 ); + + par1 = par2; + } + // add for last + int nbseg = ( 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::iterator itP = tmpParams.begin(); + for(; itP != tmpParams.end(); itP++) { + theParams.push_back( *(itP) ); + } + + if (theReverse) { + theParams.reverse(); // NPAL18025 + } + return true; + } + case DEFLECTION: { - GCPnts_UniformDeflection Discret(C3d, _value[ DEFLECTION_IND ], true); + GCPnts_UniformDeflection Discret(theC3d, _value[ DEFLECTION_IND ], f, l, true); if ( !Discret.IsDone() ) return false; @@ -672,7 +920,6 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge theParams.push_back( param ); } return true; - } default:; @@ -687,17 +934,14 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge */ //============================================================================= -bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape) +bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & theShape) { - MESSAGE("StdMeshers_Regular_1D::Compute"); - if ( _hypType == NONE ) return false; - SMESHDS_Mesh * meshDS = aMesh.GetMeshDS(); - aMesh.GetSubMesh(aShape); + SMESHDS_Mesh * meshDS = theMesh.GetMeshDS(); - const TopoDS_Edge & EE = TopoDS::Edge(aShape); + const TopoDS_Edge & EE = TopoDS::Edge(theShape); TopoDS_Edge E = TopoDS::Edge(EE.Oriented(TopAbs_FORWARD)); int shapeID = meshDS->ShapeToIndex( E ); @@ -708,44 +952,74 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aSh TopExp::Vertices(E, VFirst, VLast); // Vfirst corresponds to f and Vlast to l ASSERT(!VFirst.IsNull()); - SMDS_NodeIteratorPtr lid= aMesh.GetSubMesh(VFirst)->GetSubMeshDS()->GetNodes(); - if (!lid->more()) - { - MESSAGE (" NO NODE BUILT ON VERTEX "); - return false; - } - const SMDS_MeshNode * idFirst = lid->next(); - ASSERT(!VLast.IsNull()); - lid=aMesh.GetSubMesh(VLast)->GetSubMeshDS()->GetNodes(); - if (!lid->more()) + const SMDS_MeshNode * idFirst = SMESH_Algo::VertexNode( VFirst, meshDS ); + const SMDS_MeshNode * idLast = SMESH_Algo::VertexNode( VLast, meshDS ); + if (!idFirst || !idLast) + return error( COMPERR_BAD_INPUT_MESH, "No node on vertex"); + + // remove elements created by e.g. patern 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)) { - MESSAGE (" NO NODE BUILT ON VERTEX "); - return false; + SMDS_ElemIteratorPtr ite = subMeshDS->GetElements(); + while (ite->more()) + meshDS->RemoveFreeElement(ite->next(), subMeshDS); + SMDS_NodeIteratorPtr itn = subMeshDS->GetNodes(); + while (itn->more()) { + const SMDS_MeshNode * node = itn->next(); + if ( node->NbInverseElements() == 0 ) + meshDS->RemoveFreeNode(node, subMeshDS); + else + meshDS->RemoveNode(node); + } } - const SMDS_MeshNode * idLast = lid->next(); if (!Curve.IsNull()) { list< double > params; bool reversed = false; - if ( !_mainEdge.IsNull() ) - reversed = aMesh.IsReversedInChain( EE, _mainEdge ); - try { - if ( ! computeInternalParameters( E, params, reversed )) - return false; + if ( theMesh.GetShapeToMesh().ShapeType() >= TopAbs_WIRE ) { + // if the shape to mesh is WIRE or EDGE + reversed = ( EE.Orientation() == TopAbs_REVERSED ); + } + if ( !_mainEdge.IsNull() ) { + // take into account reversing the edge the hypothesis is propagated from + reversed = ( _mainEdge.Orientation() == TopAbs_REVERSED ); + int mainID = meshDS->ShapeToIndex(_mainEdge); + if ( std::find( _revEdgesIDs.begin(), _revEdgesIDs.end(), mainID) != _revEdgesIDs.end()) + reversed = !reversed; } - catch ( Standard_Failure ) { + // take into account this edge reversing + if ( std::find( _revEdgesIDs.begin(), _revEdgesIDs.end(), shapeID) != _revEdgesIDs.end()) + reversed = !reversed; + + BRepAdaptor_Curve C3d( E ); + double length = EdgeLength( E ); + if ( ! computeInternalParameters( theMesh, C3d, length, f, l, params, reversed, true )) { return false; } + redistributeNearVertices( theMesh, C3d, length, params, VFirst, VLast ); // 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; - - for (list::iterator itU = params.begin(); itU != params.end(); itU++) - { + 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); @@ -753,125 +1027,202 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aSh SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z()); meshDS->SetNodeOnEdge(node, shapeID, param); - SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node); - meshDS->SetMeshElementOnShape(edge, shapeID); + if(_quadraticMesh) { + // create medium node + double prm = ( parPrev + param )/2; + 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); + meshDS->SetMeshElementOnShape(edge, shapeID); + } + else { + SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node); + meshDS->SetMeshElementOnShape(edge, shapeID); + } + idPrev = node; + parPrev = param; + } + if(_quadraticMesh) { + double prm = ( parPrev + parLast )/2; + 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); + meshDS->SetMeshElementOnShape(edge, shapeID); + } + else { + SMDS_MeshEdge* edge = meshDS->AddEdge(idPrev, idLast); + meshDS->SetMeshElementOnShape(edge, shapeID); } - SMDS_MeshEdge* edge = meshDS->AddEdge(idPrev, idLast); - meshDS->SetMeshElementOnShape(edge, shapeID); } else { + //MESSAGE("************* Degenerated edge! *****************"); + // Edge is a degenerated Edge : We put n = 5 points on the edge. - int NbPoints = 5; - BRep_Tool::Range(E, f, l); + const int NbPoints = 5; + BRep_Tool::Range( E, f, l ); // PAL15185 double du = (l - f) / (NbPoints - 1); - //MESSAGE("************* Degenerated edge! *****************"); - TopoDS_Vertex V1, V2; - TopExp::Vertices(E, V1, V2); - gp_Pnt P = BRep_Tool::Pnt(V1); + gp_Pnt P = BRep_Tool::Pnt(VFirst); const SMDS_MeshNode * idPrev = idFirst; - for (int i = 2; i < NbPoints; i++) - { + for (int i = 2; i < NbPoints; i++) { double param = f + (i - 1) * du; SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z()); + if(_quadraticMesh) { + // create medium node + 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); + meshDS->SetMeshElementOnShape(edge, shapeID); + } + else { + SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node); + meshDS->SetMeshElementOnShape(edge, shapeID); + } meshDS->SetNodeOnEdge(node, shapeID, param); - - SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node); - meshDS->SetMeshElementOnShape(edge, shapeID); idPrev = node; } - SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, idLast); - meshDS->SetMeshElementOnShape(edge, shapeID); + 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); + meshDS->SetMeshElementOnShape(edge, shapeID); + } + else { + SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, idLast); + meshDS->SetMeshElementOnShape(edge, shapeID); + } } return true; } + //============================================================================= /*! - * See comments in SMESH_Algo.cxx + * */ //============================================================================= -const list & StdMeshers_Regular_1D::GetUsedHypothesis( - SMESH_Mesh & aMesh, const TopoDS_Shape & aShape) +bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh, + const TopoDS_Shape & theShape, + MapShapeNbElems& aResMap) { - _usedHypList.clear(); - _usedHypList = GetAppliedHypothesis(aMesh, aShape); // copy - int nbHyp = _usedHypList.size(); - _mainEdge.Nullify(); - if (nbHyp == 0) - { - // Check, if propagated from some other edge - if (aShape.ShapeType() == TopAbs_EDGE && - aMesh.IsPropagatedHypothesis(aShape, _mainEdge)) - { - // Propagation of 1D hypothesis from on this edge - //_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(); + if ( _hypType == NONE ) + return false; + + //SMESHDS_Mesh * meshDS = theMesh.GetMeshDS(); + + const TopoDS_Edge & EE = TopoDS::Edge(theShape); + 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); + + TopoDS_Vertex VFirst, VLast; + TopExp::Vertices(E, VFirst, VLast); // Vfirst corresponds to f and Vlast to l + + ASSERT(!VFirst.IsNull()); + ASSERT(!VLast.IsNull()); + + std::vector aVec(SMDSEntity_Last,0); + + if (!Curve.IsNull()) { + 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)); + SMESH_ComputeErrorPtr& smError = sm->GetComputeError(); + smError.reset( new SMESH_ComputeError(COMPERR_ALGO_FAILED,"Submesh can not be evaluated",this)); + return false; + } + redistributeNearVertices( theMesh, C3d, length, params, VFirst, VLast ); + + if(_quadraticMesh) { + 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; + } + } - if (nbHyp == 0) - { - TopTools_ListIteratorOfListOfShape ancIt( aMesh.GetAncestors( aShape )); - for (; ancIt.More(); ancIt.Next()) - { - const TopoDS_Shape& ancestor = ancIt.Value(); - _usedHypList = GetAppliedHypothesis(aMesh, ancestor); // copy - nbHyp = _usedHypList.size(); - if (nbHyp == 1) - break; + else { + //MESSAGE("************* Degenerated edge! *****************"); + // Edge is a degenerated Edge : We put n = 5 points on the edge. + if(_quadraticMesh) { + aVec[SMDSEntity_Node] = 11; + aVec[SMDSEntity_Quad_Edge] = 6; + } + else { + aVec[SMDSEntity_Node] = 5; + aVec[SMDSEntity_Edge] = 6; } } - if (nbHyp > 1) - _usedHypList.clear(); //only one compatible hypothesis allowed - return _usedHypList; -} -//============================================================================= -/*! - * - */ -//============================================================================= + SMESH_subMesh * sm = theMesh.GetSubMesh(theShape); + aResMap.insert(std::make_pair(sm,aVec)); -ostream & StdMeshers_Regular_1D::SaveTo(ostream & save) -{ - return save; + return true; } + //============================================================================= /*! - * + * See comments in SMESH_Algo.cxx */ //============================================================================= -istream & StdMeshers_Regular_1D::LoadFrom(istream & load) +const list & +StdMeshers_Regular_1D::GetUsedHypothesis(SMESH_Mesh & aMesh, + const TopoDS_Shape & aShape, + const bool ignoreAuxiliary) { - return load; -} + _usedHypList.clear(); + _mainEdge.Nullify(); -//============================================================================= -/*! - * - */ -//============================================================================= + SMESH_HypoFilter auxiliaryFilter, compatibleFilter; + auxiliaryFilter.Init( SMESH_HypoFilter::IsAuxiliary() ); + InitCompatibleHypoFilter( compatibleFilter, /*ignoreAux=*/true ); -ostream & operator <<(ostream & save, StdMeshers_Regular_1D & hyp) -{ - return hyp.SaveTo( save ); -} + // get non-auxiliary assigned directly to aShape + int nbHyp = aMesh.GetHypotheses( aShape, compatibleFilter, _usedHypList, false ); -//============================================================================= -/*! - * - */ -//============================================================================= + if (nbHyp == 0 && aShape.ShapeType() == TopAbs_EDGE) + { + // Check, if propagated from some other edge + _mainEdge = StdMeshers_Propagation::GetPropagationSource( aMesh, aShape ); + if ( !_mainEdge.IsNull() ) + { + // Propagation of 1D hypothesis from on this edge; + // get non-auxiliary assigned to _mainEdge + nbHyp = aMesh.GetHypotheses( _mainEdge, compatibleFilter, _usedHypList, true ); + } + } -istream & operator >>(istream & load, StdMeshers_Regular_1D & hyp) -{ - return hyp.LoadFrom( load ); + if (nbHyp == 0) // nothing propagated nor assigned to aShape + { + SMESH_Algo::GetUsedHypothesis( aMesh, aShape, ignoreAuxiliary ); + nbHyp = _usedHypList.size(); + } + else + { + // get auxiliary hyps from aShape + aMesh.GetHypotheses( aShape, auxiliaryFilter, _usedHypList, true ); + } + if ( nbHyp > 1 && ignoreAuxiliary ) + _usedHypList.clear(); //only one compatible non-auxiliary hypothesis allowed + + return _usedHypList; }