ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-01-26 10:30:32 +05:00
Code Issues Packages Projects Releases Wiki Activity

Fix

Browse Source 
1) SALOME Forum bug http://www.salome-platform.org/forum/forum_14/610436714
2) Regressions of SALOME_TESTS/Grids/smesh/imps_09/K0
This commit is contained in:
eap 2013-10-09 16:06:33 +00:00
parent 257245a11f
commit 2bdf78860b
1 changed files with 223 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

293
src/StdMeshers/StdMeshers_ViscousLayers2D.cxx
View File

@ -228,13 +228,17 @@ namespace VISCOUS_2D
bool _isBlocked;// is more inflation possible or not bool _isBlocked;// is more inflation possible or not
gp_XY _normal2D; // to pcurve gp_XY _normal2D; // to curve
double _len2dTo3dRatio; // to pass 2D <--> 3D double _len2dTo3dRatio; // to pass 2D <--> 3D
gp_Ax2d _ray; // a ray starting at _uvOut gp_Ax2d _ray; // a ray starting at _uvOut
vector<gp_XY> _uvRefined; // divisions by layers vector<gp_XY> _uvRefined; // divisions by layers
bool SetNewLength( const double length ); bool SetNewLength( const double length );
#ifdef _DEBUG_
int _ID;
#endif
}; };
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
/*! /*!
@ -275,13 +279,13 @@ namespace VISCOUS_2D
} }
bool IsAdjacent( const _Segment& seg, const _LayerEdge* LE=0 ) const bool IsAdjacent( const _Segment& seg, const _LayerEdge* LE=0 ) const
{ {
if ( LE && seg._indexInLine < _lEdges.size() && if ( LE /*&& seg._indexInLine < _lEdges.size()*/ )
( seg._uv[0] == & LE->_uvIn || return ( seg._uv[0] == & LE->_uvIn ||
seg._uv[1] == & LE->_uvIn )) seg._uv[1] == & LE->_uvIn );
return true;
return ( & seg == &_leftLine->_segments.back() || return ( & seg == &_leftLine->_segments.back() ||
& seg == &_rightLine->_segments[0] ); & seg == &_rightLine->_segments[0] );
} }
bool IsConcave() const;
}; };
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
/*! /*!
@ -296,6 +300,7 @@ namespace VISCOUS_2D
bool Compute(const _Segment& seg1, const _Segment& seg2, bool seg2IsRay = false ) bool Compute(const _Segment& seg1, const _Segment& seg2, bool seg2IsRay = false )
{ {
// !!! If seg2IsRay, returns true at any _param2 !!!
const double eps = 1e-10; const double eps = 1e-10;
_vec1 = seg1.p2() - seg1.p1(); _vec1 = seg1.p2() - seg1.p1();
_vec2 = seg2.p2() - seg2.p1(); _vec2 = seg2.p2() - seg2.p1();
@ -306,10 +311,8 @@ namespace VISCOUS_2D
_param1 = _vec2.Crossed(_vec21) / _D; _param1 = _vec2.Crossed(_vec21) / _D;
if (_param1 < -eps || _param1 > 1 + eps ) if (_param1 < -eps || _param1 > 1 + eps )
return false; return false;
_param2 = _vec1.Crossed(_vec21) / _D; _param2 = _vec1.Crossed(_vec21) / _D;
if (_param2 < -eps || ( !seg2IsRay && _param2 > 1 + eps )) return seg2IsRay || ( _param2 > -eps && _param2 < 1 + eps );
return false;
return true;
} }
bool Compute( const _Segment& seg1, const gp_Ax2d& ray ) bool Compute( const _Segment& seg1, const gp_Ax2d& ray )
{ {
@ -350,10 +353,13 @@ namespace VISCOUS_2D
const TopoDS_Edge& E, const TopoDS_Edge& E,
const TopoDS_Vertex& V); const TopoDS_Vertex& V);
void setLenRatio( _LayerEdge& LE, const gp_Pnt& pOut ); void setLenRatio( _LayerEdge& LE, const gp_Pnt& pOut );
void setLayerEdgeData( _LayerEdge& lEdge, void setLayerEdgeData( _LayerEdge& lEdge,
const double u, const double u,
Handle(Geom2d_Curve)& pcurve, Handle(Geom2d_Curve)& pcurve,
const bool reverse); Handle(Geom_Curve)& curve,
const gp_Pnt pOut,
const bool reverse,
GeomAPI_ProjectPointOnSurf* faceProj);
void adjustCommonEdge( _PolyLine& LL, _PolyLine& LR ); void adjustCommonEdge( _PolyLine& LL, _PolyLine& LR );
void calcLayersHeight(const double totalThick, void calcLayersHeight(const double totalThick,
vector<double>& heights); vector<double>& heights);
@ -382,6 +388,7 @@ namespace VISCOUS_2D
SMESH_MesherHelper _helper; SMESH_MesherHelper _helper;
TSideVector _faceSideVec; // wires (StdMeshers_FaceSide) of _face TSideVector _faceSideVec; // wires (StdMeshers_FaceSide) of _face
vector<_PolyLine> _polyLineVec; // fronts to advance vector<_PolyLine> _polyLineVec; // fronts to advance
bool _is2DIsotropic; // is same U and V resoulution of _face
double _fPowN; // to compute thickness of layers double _fPowN; // to compute thickness of layers
double _thickness; // required or possible layers thickness double _thickness; // required or possible layers thickness
@ -394,6 +401,7 @@ namespace VISCOUS_2D
// are inflated along such EDGEs but then such _LayerEdge's are turned into // are inflated along such EDGEs but then such _LayerEdge's are turned into
// a node on VERTEX, i.e. all nodes on a _LayerEdge are melded into one node. // a node on VERTEX, i.e. all nodes on a _LayerEdge are melded into one node.
int _nbLE; // for DEBUG
}; };
//================================================================================ //================================================================================
@ -551,6 +559,8 @@ _ViscousBuilder2D::_ViscousBuilder2D(SMESH_Mesh& theMesh,
if ( _hyp ) if ( _hyp )
_fPowN = pow( _hyp->GetStretchFactor(), _hyp->GetNumberLayers() ); _fPowN = pow( _hyp->GetStretchFactor(), _hyp->GetNumberLayers() );
_nbLE = 0;
} }
//================================================================================ //================================================================================
@ -702,7 +712,7 @@ bool _ViscousBuilder2D::findEdgesWithLayers(const TopoDS_Shape& theShapeHypAssig
//================================================================================ //================================================================================
/*! /*!
* \brief Create the inner front of the viscous layers and prepare data for infation * \brief Create the inner front of the viscous layers and prepare data for inflation
*/ */
//================================================================================ //================================================================================
@ -713,9 +723,35 @@ bool _ViscousBuilder2D::makePolyLines()
// count total nb of EDGEs to allocate _polyLineVec // count total nb of EDGEs to allocate _polyLineVec
int nbEdges = 0; int nbEdges = 0;
for ( size_t iWire = 0; iWire < _faceSideVec.size(); ++iWire ) for ( size_t iWire = 0; iWire < _faceSideVec.size(); ++iWire )
nbEdges += _faceSideVec[ iWire ]->NbEdges(); {
StdMeshers_FaceSidePtr wire = _faceSideVec[ iWire ];
nbEdges += wire->NbEdges();
if ( wire->GetUVPtStruct().empty() && wire->NbPoints() > 0 )
return error("Invalid node parameters on some EDGE");
}
_polyLineVec.resize( nbEdges ); _polyLineVec.resize( nbEdges );
// check if 2D normal should be computed by 3D one by means of projection
GeomAPI_ProjectPointOnSurf* faceProj = 0;
TopLoc_Location loc;
{
_LayerEdge tmpLE;
const UVPtStruct& uv = _faceSideVec[0]->GetUVPtStruct()[0];
gp_Pnt p = SMESH_TNodeXYZ( uv.node );
tmpLE._uvOut.SetCoord( uv.u, uv.v );
tmpLE._normal2D.SetCoord( 1., 0. );
setLenRatio( tmpLE, p );
const double r1 = tmpLE._len2dTo3dRatio;
tmpLE._normal2D.SetCoord( 0., 1. );
setLenRatio( tmpLE, p );
const double r2 = tmpLE._len2dTo3dRatio;
// projection is needed if two _len2dTo3dRatio's differ too much
const double maxR = Max( r2, r1 );
if ( Abs( r2-r1 )/maxR > 0.2*maxR )
faceProj = & _helper.GetProjector( _face, loc );
}
_is2DIsotropic = !faceProj;
// Assign data to _PolyLine's // Assign data to _PolyLine's
// --------------------------- // ---------------------------
@ -724,8 +760,6 @@ bool _ViscousBuilder2D::makePolyLines()
{ {
StdMeshers_FaceSidePtr wire = _faceSideVec[ iWire ]; StdMeshers_FaceSidePtr wire = _faceSideVec[ iWire ];
const vector<UVPtStruct>& points = wire->GetUVPtStruct(); const vector<UVPtStruct>& points = wire->GetUVPtStruct();
if ( points.empty() && wire->NbPoints() > 0 )
return error("Invalid node parameters on some EDGE");
int iPnt = 0; int iPnt = 0;
for ( int iE = 0; iE < wire->NbEdges(); ++iE ) for ( int iE = 0; iE < wire->NbEdges(); ++iE )
{ {
@ -748,23 +782,29 @@ bool _ViscousBuilder2D::makePolyLines()
// TODO: add more _LayerEdge's to strongly curved EDGEs // TODO: add more _LayerEdge's to strongly curved EDGEs
// in order not to miss collisions // in order not to miss collisions
double u; gp_Pnt p;
Handle(Geom_Curve) curve = BRep_Tool::Curve( L._wire->Edge( iE ), loc, u, u );
Handle(Geom2d_Curve) pcurve = L._wire->Curve2d( L._edgeInd ); Handle(Geom2d_Curve) pcurve = L._wire->Curve2d( L._edgeInd );
const bool reverse = (( L._wire->Edge( iE ).Orientation() == TopAbs_REVERSED ) ^ const bool reverse = (( L._wire->Edge( iE ).Orientation() == TopAbs_REVERSED ) ^
(_face.Orientation() == TopAbs_REVERSED )); (_face.Orientation() == TopAbs_REVERSED ));
for ( int i = L._firstPntInd; i <= L._lastPntInd; ++i ) for ( int i = L._firstPntInd; i <= L._lastPntInd; ++i )
{ {
_LayerEdge& lEdge = L._lEdges[ i - L._firstPntInd ]; _LayerEdge& lEdge = L._lEdges[ i - L._firstPntInd ];
const double u = ( i == L._firstPntInd ? wire->FirstU(iE) : points[ i ].param ); u = ( i == L._firstPntInd ? wire->FirstU(iE) : points[ i ].param );
setLayerEdgeData( lEdge, u, pcurve, reverse ); p = SMESH_TNodeXYZ( points[ i ].node );
setLenRatio( lEdge, SMESH_TNodeXYZ( points[ i ].node ) ); setLayerEdgeData( lEdge, u, pcurve, curve, p, reverse, faceProj );
setLenRatio( lEdge, p );
} }
if ( L._lastPntInd - L._firstPntInd + 1 < 3 ) // add 3d _LayerEdge in the middle if ( L._lastPntInd - L._firstPntInd + 1 < 3 ) // add 3-d _LayerEdge in the middle
{ {
L._lEdges[2] = L._lEdges[1]; L._lEdges[2] = L._lEdges[1];
const double u = 0.5 * ( wire->FirstU(iE) + wire->LastU(iE) ); u = 0.5 * ( wire->FirstU(iE) + wire->LastU(iE) );
setLayerEdgeData( L._lEdges[1], u, pcurve, reverse ); if ( !curve.IsNull() )
gp_Pnt p = 0.5 * ( SMESH_TNodeXYZ( points[ L._firstPntInd ].node ) + p = curve->Value( u );
SMESH_TNodeXYZ( points[ L._lastPntInd ].node )); else
p = 0.5 * ( SMESH_TNodeXYZ( points[ L._firstPntInd ].node ) +
SMESH_TNodeXYZ( points[ L._lastPntInd ].node ));
setLayerEdgeData( L._lEdges[1], u, pcurve, curve, p, reverse, faceProj );
setLenRatio( L._lEdges[1], p ); setLenRatio( L._lEdges[1], p );
} }
} }
@ -831,8 +871,7 @@ bool _ViscousBuilder2D::makePolyLines()
{ {
double distToL2 = intersection._param2 / L1._lEdges[iLE]._len2dTo3dRatio; double distToL2 = intersection._param2 / L1._lEdges[iLE]._len2dTo3dRatio;
double psblThick = distToL2 / ( 1 + L1._advancable + L2._advancable ); double psblThick = distToL2 / ( 1 + L1._advancable + L2._advancable );
if ( maxPossibleThick < psblThick ) maxPossibleThick = Max( psblThick, maxPossibleThick );
maxPossibleThick = psblThick;
} }
} }
} }
@ -883,8 +922,8 @@ bool _ViscousBuilder2D::makePolyLines()
for ( iPoLine = 0; iPoLine < _polyLineVec.size(); ++iPoLine ) for ( iPoLine = 0; iPoLine < _polyLineVec.size(); ++iPoLine )
{ {
lineBoxes[ iPoLine ] = *_polyLineVec[ iPoLine ]._segTree->getBox(); lineBoxes[ iPoLine ] = *_polyLineVec[ iPoLine ]._segTree->getBox();
if ( _polyLineVec[ iPoLine ]._advancable ) lineBoxes[ iPoLine ].Enlarge( maxLen2dTo3dRatio * _thickness *
lineBoxes[ iPoLine ].Enlarge( maxLen2dTo3dRatio * _thickness * 2 ); ( _polyLineVec[ iPoLine ]._advancable ? 2. : 1.2 ));
} }
// _reachableLines // _reachableLines
for ( iPoLine = 0; iPoLine < _polyLineVec.size(); ++iPoLine ) for ( iPoLine = 0; iPoLine < _polyLineVec.size(); ++iPoLine )
@ -1027,15 +1066,18 @@ void _ViscousBuilder2D::adjustCommonEdge( _PolyLine& LL, _PolyLine& LR )
lastIntersection._param1 = intersection._param1; lastIntersection._param1 = intersection._param1;
lastIntersection._param2 = intersection._param2; lastIntersection._param2 = intersection._param2;
} }
if ( iLE >= L._lEdges.size () - 1 ) if ( iLE >= L._lEdges.size() - 1 )
{ {
// all _LayerEdge's intersect the segCommon, limit inflation // all _LayerEdge's intersect the segCommon, limit inflation
// of remaining 2 _LayerEdge's // of remaining 3 _LayerEdge's
vector< _LayerEdge > newEdgeVec( Min( 3, L._lEdges.size() )); vector< _LayerEdge > newEdgeVec( Min( 3, L._lEdges.size() ));
newEdgeVec.front() = L._lEdges.front(); newEdgeVec.front() = L._lEdges.front();
newEdgeVec.back() = L._lEdges.back(); newEdgeVec.back() = L._lEdges.back();
if ( newEdgeVec.size() == 3 ) if ( newEdgeVec.size() == 3 )
newEdgeVec[1] = L._lEdges[ L._lEdges.size() / 2 ]; {
newEdgeVec[1] = L._lEdges[ isR ? (L._lEdges.size() - 2) : 1 ];
newEdgeVec[1]._len2dTo3dRatio *= lastIntersection._param2;
}
L._lEdges.swap( newEdgeVec ); L._lEdges.swap( newEdgeVec );
if ( !isR ) std::swap( lastIntersection._param1 , lastIntersection._param2 ); if ( !isR ) std::swap( lastIntersection._param1 , lastIntersection._param2 );
L._lEdges.front()._len2dTo3dRatio *= lastIntersection._param1; // ?? L._lEdges.front()._len2dTo3dRatio *= lastIntersection._param1; // ??
@ -1078,22 +1120,52 @@ void _ViscousBuilder2D::adjustCommonEdge( _PolyLine& LL, _PolyLine& LR )
*/ */
//================================================================================ //================================================================================
void _ViscousBuilder2D::setLayerEdgeData( _LayerEdge& lEdge, void _ViscousBuilder2D::setLayerEdgeData( _LayerEdge& lEdge,
const double u, const double u,
Handle(Geom2d_Curve)& pcurve, Handle(Geom2d_Curve)& pcurve,
const bool reverse) Handle(Geom_Curve)& curve,
const gp_Pnt pOut,
const bool reverse,
GeomAPI_ProjectPointOnSurf* faceProj)
{ {
gp_Pnt2d uv; gp_Vec2d tangent; gp_Pnt2d uv;
pcurve->D1( u, uv, tangent ); if ( faceProj && !curve.IsNull() )
tangent.Normalize(); {
if ( reverse ) uv = pcurve->Value( u );
tangent.Reverse(); gp_Vec tangent; gp_Pnt p; gp_Vec du, dv;
curve->D1( u, p, tangent );
if ( reverse )
tangent.Reverse();
_surface->D1( uv.X(), uv.Y(), p, du, dv );
gp_Vec faceNorm = du ^ dv;
gp_Vec normal = faceNorm ^ tangent;
normal.Normalize();
p = pOut.XYZ() + normal.XYZ() * /*1e-2 * */_hyp->GetTotalThickness() / _hyp->GetNumberLayers();
faceProj->Perform( p );
if ( !faceProj->IsDone() || faceProj->NbPoints() < 1 )
return setLayerEdgeData( lEdge, u, pcurve, curve, p, reverse, NULL );
Quantity_Parameter U,V;
faceProj->LowerDistanceParameters(U,V);
lEdge._normal2D.SetCoord( U - uv.X(), V - uv.Y() );
lEdge._normal2D.Normalize();
}
else
{
gp_Vec2d tangent;
pcurve->D1( u, uv, tangent );
tangent.Normalize();
if ( reverse )
tangent.Reverse();
lEdge._normal2D.SetCoord( -tangent.Y(), tangent.X() );
}
lEdge._uvOut = lEdge._uvIn = uv.XY(); lEdge._uvOut = lEdge._uvIn = uv.XY();
lEdge._normal2D.SetCoord( -tangent.Y(), tangent.X() ); lEdge._ray.SetLocation ( lEdge._uvOut );
lEdge._ray.SetLocation( lEdge._uvOut );
lEdge._ray.SetDirection( lEdge._normal2D ); lEdge._ray.SetDirection( lEdge._normal2D );
lEdge._isBlocked = false; lEdge._isBlocked = false;
lEdge._length2D = 0; lEdge._length2D = 0;
#ifdef _DEBUG_
lEdge._ID = _nbLE++;
#endif
} }
//================================================================================ //================================================================================
@ -1144,7 +1216,7 @@ bool _ViscousBuilder2D::inflate()
{ {
double distToL2 = intersection._param2 / L1._lEdges[iLE]._len2dTo3dRatio; double distToL2 = intersection._param2 / L1._lEdges[iLE]._len2dTo3dRatio;
double size = distToL2 / ( 1 + L1._advancable + L2._advancable ); double size = distToL2 / ( 1 + L1._advancable + L2._advancable );
if ( size < minSize ) if ( 1e-10 < size && size < minSize )
minSize = size; minSize = size;
if ( size > maxSize ) if ( size > maxSize )
maxSize = size; maxSize = size;
@ -1261,7 +1333,6 @@ bool _ViscousBuilder2D::fixCollisions()
{ {
// look for intersections of _Segment's by intersecting _LayerEdge's with // look for intersections of _Segment's by intersecting _LayerEdge's with
// _Segment's // _Segment's
//double maxStep = 0, minStep = 1e+100;
vector< const _Segment* > foundSegs; vector< const _Segment* > foundSegs;
_SegmentIntersection intersection; _SegmentIntersection intersection;
@ -1290,10 +1361,10 @@ bool _ViscousBuilder2D::fixCollisions()
double newLen2D = dist2DToL2 / 2; double newLen2D = dist2DToL2 / 2;
if ( newLen2D < 1.1 * LE1._length2D ) // collision! if ( newLen2D < 1.1 * LE1._length2D ) // collision!
{ {
if ( newLen2D < LE1._length2D ) if ( newLen2D > 0 || !L1._advancable )
{ {
blockedEdgesList.push_back( &LE1 ); blockedEdgesList.push_back( &LE1 );
if ( L1._advancable ) if ( L1._advancable && newLen2D > 0 )
{ {
edgeLenLimitList.push_back( make_pair( &LE1, newLen2D )); edgeLenLimitList.push_back( make_pair( &LE1, newLen2D ));
blockedEdgesList.push_back( &L2._lEdges[ foundSegs[i]->_indexInLine ]); blockedEdgesList.push_back( &L2._lEdges[ foundSegs[i]->_indexInLine ]);
@ -1301,14 +1372,16 @@ bool _ViscousBuilder2D::fixCollisions()
} }
else // here dist2DToL2 < 0 and LE1._length2D == 0 else // here dist2DToL2 < 0 and LE1._length2D == 0
{ {
_LayerEdge LE2[2] = { L2._lEdges[ foundSegs[i]->_indexInLine ], _LayerEdge* LE2[2] = { & L2._lEdges[ foundSegs[i]->_indexInLine ],
L2._lEdges[ foundSegs[i]->_indexInLine + 1 ] }; & L2._lEdges[ foundSegs[i]->_indexInLine + 1 ] };
_Segment outSeg2( LE2[0]._uvOut, LE2[1]._uvOut ); _Segment outSeg2( LE2[0]->_uvOut, LE2[1]->_uvOut );
intersection.Compute( outSeg2, LE1._ray ); intersection.Compute( outSeg2, LE1._ray );
newLen2D = intersection._param2 / 2; newLen2D = intersection._param2 / 2;
if ( newLen2D > 0 )
edgeLenLimitList.push_back( make_pair( &LE2[0], newLen2D )); {
edgeLenLimitList.push_back( make_pair( &LE2[1], newLen2D )); edgeLenLimitList.push_back( make_pair( LE2[0], newLen2D ));
edgeLenLimitList.push_back( make_pair( LE2[1], newLen2D ));
}
} }
} }
} }
@ -1318,12 +1391,52 @@ bool _ViscousBuilder2D::fixCollisions()
} }
} }
// limit length of _LayerEdge's that are extrema of _PolyLine's
// to avoid intersection of these _LayerEdge's
for ( size_t iL1 = 0; iL1 < _polyLineVec.size(); ++iL1 )
{
_PolyLine& L = _polyLineVec[ iL1 ];
if ( L._lEdges.size() < 4 ) // all intermediate _LayerEdge's intersect with extremum ones
{
_LayerEdge& LEL = L._leftLine->_lEdges.back();
_LayerEdge& LER = L._lEdges.back();
_Segment segL( LEL._uvOut, LEL._uvIn );
_Segment segR( LER._uvOut, LER._uvIn );
double newLen2DL, newLen2DR;
if ( intersection.Compute( segL, LER._ray ))
{
newLen2DR = intersection._param2 / 2;
newLen2DL = LEL._length2D * intersection._param1 / 2;
}
else if ( intersection.Compute( segR, LEL._ray ))
{
newLen2DL = intersection._param2 / 2;
newLen2DR = LER._length2D * intersection._param1 / 2;
}
else
{
continue;
}
if ( newLen2DL > 0 && newLen2DR > 0 )
{
if ( newLen2DL < 1.1 * LEL._length2D )
edgeLenLimitList.push_back( make_pair( &LEL, newLen2DL ));
if ( newLen2DR < 1.1 * LER._length2D )
edgeLenLimitList.push_back( make_pair( &LER, newLen2DR ));
}
}
}
// set limited length to _LayerEdge's // set limited length to _LayerEdge's
list< pair< _LayerEdge*, double > >::iterator edge2Len = edgeLenLimitList.begin(); list< pair< _LayerEdge*, double > >::iterator edge2Len = edgeLenLimitList.begin();
for ( ; edge2Len != edgeLenLimitList.end(); ++edge2Len ) for ( ; edge2Len != edgeLenLimitList.end(); ++edge2Len )
{ {
_LayerEdge* LE = edge2Len->first; _LayerEdge* LE = edge2Len->first;
LE->SetNewLength( edge2Len->second / LE->_len2dTo3dRatio ); if ( LE->_length2D > edge2Len->second )
{
LE->_isBlocked = false;
LE->SetNewLength( edge2Len->second / LE->_len2dTo3dRatio );
}
LE->_isBlocked = true; LE->_isBlocked = true;
} }
@ -1848,20 +1961,21 @@ bool _ViscousBuilder2D::refine()
{ {
size_t iF = 0, iL = L._lEdges.size()-1; size_t iF = 0, iL = L._lEdges.size()-1;
size_t *i = isR ? &iL : &iF; size_t *i = isR ? &iL : &iF;
//size_t iRef = *i;
_LayerEdge* prevLE = & L._lEdges[ *i ]; _LayerEdge* prevLE = & L._lEdges[ *i ];
double weight = 0; double weight = 0;
for ( ++iF, --iL; iF < L._lEdges.size()-1; ++iF, --iL ) for ( ++iF, --iL; iF < L._lEdges.size()-1; ++iF, --iL )
{ {
_LayerEdge& LE = L._lEdges[*i]; _LayerEdge& LE = L._lEdges[*i];
if ( prevLE->_length2D > 0 ) { if ( prevLE->_length2D > 0 )
{
gp_XY tangent ( LE._normal2D.Y(), -LE._normal2D.X() ); gp_XY tangent ( LE._normal2D.Y(), -LE._normal2D.X() );
weight += Abs( tangent * ( prevLE->_uvIn - LE._uvIn )) / segLen.back(); weight += Abs( tangent * ( prevLE->_uvIn - LE._uvIn )) / segLen.back();
gp_XY prevTang = ( LE._uvOut - prevLE->_uvOut ); // gp_XY prevTang( LE._uvOut - prevLE->_uvOut );
gp_XY prevNorm = gp_XY( -prevTang.Y(), prevTang.X() ); // gp_XY prevNorm( -prevTang.Y(), prevTang.X() );
double prevProj = prevNorm * ( prevLE->_uvIn - prevLE->_uvOut ); gp_XY prevNorm = LE._normal2D;
double prevProj = prevNorm * ( prevLE->_uvIn - prevLE->_uvOut );
if ( prevProj > 0 ) { if ( prevProj > 0 ) {
prevProj /= prevTang.Modulus(); prevProj /= prevNorm.Modulus();
if ( LE._length2D < prevProj ) if ( LE._length2D < prevProj )
weight += 0.75 * ( 1 - weight ); // length decrease is more preferable weight += 0.75 * ( 1 - weight ); // length decrease is more preferable
LE._length2D = weight * LE._length2D + ( 1 - weight ) * prevProj; LE._length2D = weight * LE._length2D + ( 1 - weight ) * prevProj;
@ -1871,8 +1985,10 @@ bool _ViscousBuilder2D::refine()
prevLE = & LE; prevLE = & LE;
} }
} }
// DEBUG: to see _uvRefined. cout can be redirected to hide NETGEN output
// cerr << "import smesh" << endl << "mesh = smesh.Mesh()"<< endl;
// calculate intermediate UV on _LayerEdge's ( _LayerEdge::_uvRefined ) // calculate intermediate UV on _LayerEdge's ( _LayerEdge::_uvRefined )
for ( ; iLE < nbLE; ++iLE ) for ( ; iLE < nbLE; ++iLE )
{ {
_LayerEdge& LE = L._lEdges[iLE]; _LayerEdge& LE = L._lEdges[iLE];
@ -1883,13 +1999,21 @@ bool _ViscousBuilder2D::refine()
} }
for ( size_t i = 0; i < layersHeight.size(); ++i ) for ( size_t i = 0; i < layersHeight.size(); ++i )
LE._uvRefined.push_back( LE._uvOut + LE._normal2D * layersHeight[i] ); LE._uvRefined.push_back( LE._uvOut + LE._normal2D * layersHeight[i] );
// DEBUG: to see _uvRefined
// for ( size_t i = 0; i < LE._uvRefined.size(); ++i )
// {
// gp_XY uv = LE._uvRefined[i];
// gp_Pnt p = _surface->Value( uv.X(), uv.Y() );
// cerr << "mesh.AddNode( " << p.X() << ", " << p.Y() << ", " << p.Z() << " )" << endl;
// }
} }
// nodes to create 1 layer of faces // nodes to create 1 layer of faces
vector< const SMDS_MeshNode* > outerNodes( L._lastPntInd - L._firstPntInd + 1 ); vector< const SMDS_MeshNode* > outerNodes( L._lastPntInd - L._firstPntInd + 1 );
vector< const SMDS_MeshNode* > innerNodes( L._lastPntInd - L._firstPntInd + 1 ); vector< const SMDS_MeshNode* > innerNodes( L._lastPntInd - L._firstPntInd + 1 );
// initialize outerNodes by node on the L._wire // initialize outerNodes by nodes of the L._wire
const vector<UVPtStruct>& points = L._wire->GetUVPtStruct(); const vector<UVPtStruct>& points = L._wire->GetUVPtStruct();
for ( int i = L._firstPntInd; i <= L._lastPntInd; ++i ) for ( int i = L._firstPntInd; i <= L._lastPntInd; ++i )
outerNodes[ i-L._firstPntInd ] = points[i].node; outerNodes[ i-L._firstPntInd ] = points[i].node;
@ -1905,11 +2029,11 @@ bool _ViscousBuilder2D::refine()
// Create layers of faces // Create layers of faces
bool hasLeftNode = ( !L._leftLine->_rightNodes.empty() && leftEdgeShared ); bool hasLeftNode = ( !L._leftLine->_rightNodes.empty() && leftEdgeShared );
bool hasRightNode = ( !L._rightLine->_leftNodes.empty() && rightEdgeShared ); bool hasRightNode = ( !L._rightLine->_leftNodes.empty() && rightEdgeShared );
bool hasOwnLeftNode = ( !L._leftNodes.empty() ); bool hasOwnLeftNode = ( !L._leftNodes.empty() );
bool hasOwnRightNode = ( !L._rightNodes.empty() ); bool hasOwnRightNode = ( !L._rightNodes.empty() );
bool isClosedEdge = ( outerNodes.front() == outerNodes.back() ); bool isClosedEdge = ( outerNodes.front() == outerNodes.back() );
size_t iS, size_t iS,
iN0 = ( hasLeftNode || hasOwnLeftNode || isClosedEdge ), iN0 = ( hasLeftNode || hasOwnLeftNode || isClosedEdge ),
nbN = innerNodes.size() - ( hasRightNode || hasOwnRightNode ); nbN = innerNodes.size() - ( hasRightNode || hasOwnRightNode );
@ -1920,11 +2044,22 @@ bool _ViscousBuilder2D::refine()
for ( int iF = 0; iF < _hyp->GetNumberLayers(); ++iF ) // loop on layers of faces for ( int iF = 0; iF < _hyp->GetNumberLayers(); ++iF ) // loop on layers of faces
{ {
// get accumulated length of intermediate segments // get accumulated length of intermediate segments
for ( iS = 1; iS < segLen.size(); ++iS ) if ( _is2DIsotropic )
{ for ( iS = 1; iS < segLen.size(); ++iS )
double sLen = (L._lEdges[iS-1]._uvRefined[iF] - L._lEdges[iS]._uvRefined[iF] ).Modulus(); {
segLen[iS] = segLen[iS-1] + sLen; double sLen = (L._lEdges[iS-1]._uvRefined[iF] - L._lEdges[iS]._uvRefined[iF] ).Modulus();
} segLen[iS] = segLen[iS-1] + sLen;
}
else
for ( iS = 1; iS < segLen.size(); ++iS )
{
const gp_XY& uv1 = L._lEdges[iS-1]._uvRefined[iF];
const gp_XY& uv2 = L._lEdges[iS ]._uvRefined[iF];
gp_Pnt p1 = _surface->Value( uv1.X(), uv1.Y() );
gp_Pnt p2 = _surface->Value( uv2.X(), uv2.Y() );
double sLen = p1.Distance( p2 );
segLen[iS] = segLen[iS-1] + sLen;
}
// normalize the accumulated length // normalize the accumulated length
for ( iS = 1; iS < segLen.size(); ++iS ) for ( iS = 1; iS < segLen.size(); ++iS )
segLen[iS] /= segLen.back(); segLen[iS] /= segLen.back();
@ -2162,6 +2297,24 @@ bool _PolyLine::IsCommonEdgeShared( const _PolyLine& other )
return false; return false;
} }
//================================================================================
/*!
* \brief Return \c true if the EDGE of this _PolyLine is concave
*/
//================================================================================
bool _PolyLine::IsConcave() const
{
if ( _lEdges.size() < 2 )
return false;
gp_Vec2d v1( _lEdges[0]._uvOut, _lEdges[1]._uvOut );
gp_Vec2d v2( _lEdges[0]._uvOut, _lEdges[2]._uvOut );
const double size2 = v2.Magnitude();
return ( v1 ^ v2 ) / size2 < -1e-3 * size2;
}
//================================================================================ //================================================================================
/*! /*!
* \brief Constructor of SegmentTree * \brief Constructor of SegmentTree