-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016 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
#include <limits>
using namespace std;
+using namespace StdMeshers;
//=============================================================================
/*!
//=============================================================================
/*!
- *
+ *
*/
//=============================================================================
const list <const SMESHDS_Hypothesis * > & hyps =
GetUsedHypothesis(aMesh, aShape, /*ignoreAuxiliaryHyps=*/false);
+ const SMESH_HypoFilter & propagFilter = StdMeshers_Propagation::GetFilter();
+
// find non-auxiliary hypothesis
const SMESHDS_Hypothesis *theHyp = 0;
+ set< string > propagTypes;
list <const SMESHDS_Hypothesis * >::const_iterator h = hyps.begin();
for ( ; h != hyps.end(); ++h ) {
if ( static_cast<const SMESH_Hypothesis*>(*h)->IsAuxiliary() ) {
if ( strcmp( "QuadraticMesh", (*h)->GetName() ) == 0 )
_quadraticMesh = true;
+ if ( propagFilter.IsOk( static_cast< const SMESH_Hypothesis*>( *h ), aShape ))
+ propagTypes.insert( (*h)->GetName() );
}
else {
if ( !theHyp )
else if (hypName == "NumberOfSegments")
{
+ MESSAGE("CheckHypothesis: NumberOfSegments");
const StdMeshers_NumberOfSegments * hyp =
dynamic_cast <const StdMeshers_NumberOfSegments * >(theHyp);
ASSERT(hyp);
ASSERT(_adaptiveHyp);
_hypType = ADAPTIVE;
_onlyUnaryInput = false;
+ aStatus = SMESH_Hypothesis::HYP_OK;
}
else
+ {
aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE;
+ }
+
+ if ( propagTypes.size() > 1 && aStatus == HYP_OK )
+ {
+ // detect concurrent Propagation hyps
+ _usedHypList.clear();
+ list< TopoDS_Shape > assignedTo;
+ if ( aMesh.GetHypotheses( aShape, propagFilter, _usedHypList, true, &assignedTo ) > 1 )
+ {
+ // find most simple shape and a hyp on it
+ int simpleShape = TopAbs_COMPOUND;
+ const SMESHDS_Hypothesis* localHyp = 0;
+ list< TopoDS_Shape >::iterator shape = assignedTo.begin();
+ list< const SMESHDS_Hypothesis *>::iterator hyp = _usedHypList.begin();
+ for ( ; shape != assignedTo.end(); ++shape )
+ if ( shape->ShapeType() > simpleShape )
+ {
+ simpleShape = shape->ShapeType();
+ localHyp = (*hyp);
+ }
+ // check if there a different hyp on simpleShape
+ shape = assignedTo.begin();
+ hyp = _usedHypList.begin();
+ for ( ; hyp != _usedHypList.end(); ++hyp, ++shape )
+ if ( shape->ShapeType() == simpleShape &&
+ !localHyp->IsSameName( **hyp ))
+ {
+ aStatus = HYP_INCOMPAT_HYPS;
+ return error( SMESH_Comment("Hypotheses of both \"")
+ << StdMeshers_Propagation::GetName() << "\" and \""
+ << StdMeshers_PropagOfDistribution::GetName()
+ << "\" types can't be applied to the same edge");
+ }
+ }
+ }
- return ( _hypType != NONE );
+ return ( aStatus == SMESH_Hypothesis::HYP_OK );
}
-static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last,
- double length, bool theReverse,
- int nbSeg, Function& func,
+static bool computeParamByFunc(Adaptor3d_Curve& C3d,
+ double first, double last, double length,
+ bool theReverse, int nbSeg, Function& func,
list<double>& theParams)
{
// never do this way
int nbPnt = 1 + nbSeg;
vector<double> x(nbPnt, 0.);
- if (!buildDistribution(func, 0.0, 1.0, nbSeg, x, 1E-4))
+ 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)
+ double sign = 1.;
+ if ( theReverse )
{
prevU = last;
- sign = -1.;
+ sign = -1.;
}
- for( int i = 1; i < nbSeg; i++ )
+
+ for ( int i = 1; i < nbSeg; i++ )
{
double curvLength = length * (x[i] - x[i-1]) * sign;
- GCPnts_AbscissaPoint Discret( C3d, curvLength, prevU );
+ double tol = Min( Precision::Confusion(), curvLength / 100. );
+ GCPnts_AbscissaPoint Discret( tol, C3d, curvLength, prevU );
if ( !Discret.IsDone() )
return false;
double U = Discret.Parameter();
}
if ( _hypType == NB_SEGMENTS )
{
+ MESSAGE("redistributeNearVertices NB_SEGMENTS");
compensateError(0, vertexLength, f, l, theLength, theC3d, theParameters, true );
}
else if ( nPar <= 3 )
const bool theReverse,
bool theConsiderPropagation)
{
+ MESSAGE("computeInternalParameters");
theParams.clear();
double f = theFirstU, l = theLastU;
if ( smDS->NbNodes() < 1 )
return true; // 1 segment
- vector< double > mainEdgeParams;
- if ( ! SMESH_Algo::GetNodeParamOnEdge( theMesh.GetMeshDS(), mainEdge, mainEdgeParams ))
+ map< double, const SMDS_MeshNode* > mainEdgeParamsOfNodes;
+ if ( ! SMESH_Algo::GetSortedNodesOnEdge( theMesh.GetMeshDS(), mainEdge, _quadraticMesh,
+ mainEdgeParamsOfNodes, SMDSAbs_Edge ))
return error("Bad node parameters on the source edge of Propagation Of Distribution");
-
- vector< double > segLen( mainEdgeParams.size() - 1 );
+ MESSAGE("mainEdgeParamsOfNodes.size(): " << mainEdgeParamsOfNodes.size());
+ vector< double > segLen( mainEdgeParamsOfNodes.size() - 1 );
double totalLen = 0;
BRepAdaptor_Curve mainEdgeCurve( mainEdge );
- for ( size_t i = 1; i < mainEdgeParams.size(); ++i )
+ map< double, const SMDS_MeshNode* >::iterator
+ u_n2 = mainEdgeParamsOfNodes.begin(), u_n1 = u_n2++;
+ for ( size_t i = 1; i < mainEdgeParamsOfNodes.size(); ++i, ++u_n1, ++u_n2 )
{
segLen[ i-1 ] = GCPnts_AbscissaPoint::Length( mainEdgeCurve,
- mainEdgeParams[i-1],
- mainEdgeParams[i]);
+ u_n1->first,
+ u_n2->first);
totalLen += segLen[ i-1 ];
}
for ( size_t i = 0; i < segLen.size(); ++i )
segLen[ i ] *= theLength / totalLen;
- size_t iSeg = theReverse ? segLen.size()-1 : 0;
- size_t dSeg = theReverse ? -1 : +1;
+ size_t iSeg = theReverse ? segLen.size()-1 : 0;
+ size_t dSeg = theReverse ? -1 : +1;
double param = theFirstU;
- int nbParams = 0;
+ size_t nbParams = 0;
for ( int i = 0, nb = segLen.size()-1; i < nb; ++i, iSeg += dSeg )
{
GCPnts_AbscissaPoint Discret( theC3d, segLen[ iSeg ], param );
++nbParams;
}
if ( nbParams != segLen.size()-1 )
- return error( SMESH_Comment("Can't divide into ") << segLen.size() << " segements");
+ return error( SMESH_Comment("Can't divide into ") << segLen.size() << " segments");
compensateError( segLen[ theReverse ? segLen.size()-1 : 0 ],
segLen[ theReverse ? 0 : segLen.size()-1 ],
case LOCAL_LENGTH:
case MAX_LENGTH:
case NB_SEGMENTS: {
-
+ MESSAGE("computeInternalParameters: LOCAL_LENGTH MAX_LENGTH NB_SEGMENTS");
double eltSize = 1;
int nbSegments;
if ( _hypType == MAX_LENGTH )
if (computed) {
SMESHDS_SubMesh* smds = sm->GetSubMeshDS();
int nb_segments = smds->NbElements();
+ MESSAGE("nb_segments: "<<nb_segments);
if (nbseg - 1 <= nb_segments && nb_segments <= nbseg + 1) {
isFound = true;
nbseg = nb_segments;
break;
case StdMeshers_NumberOfSegments::DT_Regular:
eltSize = theLength / nbSegments;
+ MESSAGE("eltSize = theLength / nbSegments " << eltSize << " = " << theLength << " / " << nbSegments );
break;
default:
return false;
for ( int i = 2; i < NbPoints; i++ ) // skip 1st and last points
{
double param = Discret.Parameter(i);
+ MESSAGE("computeInternalParameters: theParams " << i << " " << param);
theParams.push_back( param );
}
compensateError( eltSize, eltSize, f, l, theLength, theC3d, theParams, true ); // for PAL9899
{
if ( Abs( param - Un ) < 0.2 * Abs( param - theParams.back() ))
{
- compensateError( a1, eltSize, U1, Un, theLength, theC3d, theParams );
+ compensateError( a1, Abs(eltSize), U1, Un, theLength, theC3d, theParams );
}
else if ( Abs( Un - theParams.back() ) <
- 0.2 * Abs( theParams.back() - *(--theParams.rbegin())))
+ 0.2 * Abs( theParams.back() - *(++theParams.rbegin())))
{
theParams.pop_back();
- compensateError( a1, an, U1, Un, theLength, theC3d, theParams );
+ compensateError( a1, Abs(an), U1, Un, theLength, theC3d, theParams );
}
}
if (theReverse) theParams.reverse(); // NPAL18025
case FIXED_POINTS_1D: {
const std::vector<double>& aPnts = _fpHyp->GetPoints();
const std::vector<int>& nbsegs = _fpHyp->GetNbSegments();
- int i = 0;
TColStd_SequenceOfReal Params;
- for(; i<aPnts.size(); i++) {
+ for ( size_t i = 0; i < aPnts.size(); i++ )
+ {
if( aPnts[i]<0.0001 || aPnts[i]>0.9999 ) continue;
int j=1;
bool IsExist = false;
}
double eltSize, segmentSize = 0.;
double currAbscissa = 0;
- for(i=0; i<Params.Length(); i++) {
- int nbseg = ( i > nbsegs.size()-1 ) ? nbsegs[0] : nbsegs[i];
+ for ( int i = 0; 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);
par1 = par2;
}
// add for last
- int nbseg = ( nbsegs.size() > Params.Length() ) ? nbsegs[Params.Length()] : nbsegs[0];
+ int nbseg = ( (int)nbsegs.size() > Params.Length() ) ? nbsegs[Params.Length()] : nbsegs[0];
segmentSize = theLength - currAbscissa;
eltSize = segmentSize/nbseg;
GCPnts_UniformAbscissa Discret;
bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & theShape)
{
+ MESSAGE("Compute");
if ( _hypType == NONE )
return false;
}
if ( !_mainEdge.IsNull() ) {
// 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 );
- int mainID = meshDS->ShapeToIndex(_mainEdge);
- if ( std::find( _revEdgesIDs.begin(), _revEdgesIDs.end(), mainID) != _revEdgesIDs.end())
- reversed = !reversed;
+ if ( !_isPropagOfDistribution ) {
+ int mainID = meshDS->ShapeToIndex(_mainEdge);
+ if ( std::find( _revEdgesIDs.begin(), _revEdgesIDs.end(), mainID) != _revEdgesIDs.end())
+ reversed = !reversed;
+ }
}
// take into account this edge reversing
if ( std::find( _revEdgesIDs.begin(), _revEdgesIDs.end(), shapeID) != _revEdgesIDs.end())
//Add the Node in the DataStructure
SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z());
+ MESSAGE("meshDS->AddNode parameter " << param << " coords=" << "("<< P.X() <<", " << P.Y() << ", " << P.Z() << ")");
meshDS->SetNodeOnEdge(node, shapeID, param);
if(_quadraticMesh) {
