-// Copyright (C) 2007-2011 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2011 CEA/DEN, EDF R&D, OPEN CASCADE
//
-// 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 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.
+// 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
+// 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
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File : StdMeshers_ViscousLayers.cxx
void Copy( _LayerEdge& other, SMESH_MesherHelper& helper );
void SetCosin( double cosin );
};
+ struct _LayerEdgeCmp
+ {
+ bool operator () (const _LayerEdge* e1, const _LayerEdge* e2) const
+ {
+ const bool cmpNodes = ( e1 && e2 && e1->_nodes.size() && e2->_nodes.size() );
+ return cmpNodes ? ( e1->_nodes[0]->GetID() < e2->_nodes[0]->GetID()) : ( e1 < e2 );
+ }
+ };
//--------------------------------------------------------------------------------
typedef map< const SMDS_MeshNode*, _LayerEdge*, TIDCompare > TNode2Edge;
if ( nextN->GetPosition()->GetTypeOfPosition() == SMDS_TOP_FACE ||
curN->GetPosition()->GetTypeOfPosition() == SMDS_TOP_FACE )
{
- double dist = SMESH_MeshEditor::TNodeXYZ( face->GetNode(i)).Distance( nextN );
+ double dist = SMESH_TNodeXYZ( face->GetNode(i)).Distance( nextN );
if ( dist < minSize )
minSize = dist, iN = i;
}
if ( data._stepSizeNodes[0] )
{
double dist =
- SMESH_MeshEditor::TNodeXYZ(data._stepSizeNodes[0]).Distance(data._stepSizeNodes[1]);
+ SMESH_TNodeXYZ(data._stepSizeNodes[0]).Distance(data._stepSizeNodes[1]);
data._stepSizeCoeff = data._stepSize / dist;
}
}
}
else
{
- edge._pos.push_back( SMESH_MeshEditor::TNodeXYZ( node ));
+ edge._pos.push_back( SMESH_TNodeXYZ( node ));
if ( posType == SMDS_TOP_FACE )
{
double avgNormProj = 0, avgLen = 0;
for ( unsigned i = 0; i < edge._simplices.size(); ++i )
{
- gp_XYZ vec = edge._pos.back() - SMESH_MeshEditor::TNodeXYZ( edge._simplices[i]._nPrev );
+ gp_XYZ vec = edge._pos.back() - SMESH_TNodeXYZ( edge._simplices[i]._nPrev );
avgNormProj += edge._normal * vec;
avgLen += vec.Modulus();
}
if ( _nodes[0]->GetPosition()->GetTypeOfPosition() != SMDS_TOP_EDGE )
return;
- gp_XYZ pos = SMESH_MeshEditor::TNodeXYZ( _nodes[0] );
- gp_XYZ vec1 = pos - SMESH_MeshEditor::TNodeXYZ( n1 );
- gp_XYZ vec2 = pos - SMESH_MeshEditor::TNodeXYZ( n2 );
+ gp_XYZ pos = SMESH_TNodeXYZ( _nodes[0] );
+ gp_XYZ vec1 = pos - SMESH_TNodeXYZ( n1 );
+ gp_XYZ vec2 = pos - SMESH_TNodeXYZ( n2 );
// Set _curvature
for ( unsigned j = 0 ; j < _sdVec[i]._edges.size(); ++j )
{
_LayerEdge& edge = *_sdVec[i]._edges[j];
- SMESH_MeshEditor::TNodeXYZ nXYZ( edge._nodes[0] );
+ SMESH_TNodeXYZ nXYZ( edge._nodes[0] );
nXYZ += edge._normal * _sdVec[i]._stepSize;
dumpCmd(SMESH_Comment("mesh.AddEdge([ ") <<edge._nodes[0]->GetID()
<< ", mesh.AddNode( " << nXYZ.X()<<","<< nXYZ.Y()<<","<< nXYZ.Z()<<")])");
limitStepSize( data, 0.25 * distToIntersection );
if ( data._stepSizeNodes[0] )
data._stepSize = data._stepSizeCoeff *
- SMESH_MeshEditor::TNodeXYZ(data._stepSizeNodes[0]).Distance(data._stepSizeNodes[1]);
+ SMESH_TNodeXYZ(data._stepSizeNodes[0]).Distance(data._stepSizeNodes[1]);
}
if (nbSteps == 0 )
for ( int i = iBeg; i < iEnd; ++i )
{
_LayerEdge* edge = data._edges[i];
- SMESH_MeshEditor::TNodeXYZ tgtXYZ( edge->_nodes.back() );
+ SMESH_TNodeXYZ tgtXYZ( edge->_nodes.back() );
for ( unsigned j = 0; j < edge->_simplices.size(); ++j )
if ( !edge->_simplices[j].IsForward( edge->_nodes[0], &tgtXYZ ))
{
distToIntersection = Precision::Infinite();
double dist;
- const SMDS_MeshElement* intFace = 0, *closestFace = 0;
+ const SMDS_MeshElement* intFace = 0;
+#ifdef __myDEBUG
+ const SMDS_MeshElement* *closestFace = 0;
int iLE = 0;
+#endif
for ( unsigned i = 0; i < data._edges.size(); ++i )
{
if ( data._edges[i]->FindIntersection( *searcher, dist, data._epsilon, &intFace ))
return false;
if ( distToIntersection > dist )
- distToIntersection = dist, closestFace = intFace, iLE = i;
+ {
+ distToIntersection = dist;
+#ifdef __myDEBUG
+ iLE = i;
+ closestFace = intFace;
+#endif
+ }
}
#ifdef __myDEBUG
if ( closestFace )
// 1) Find intersections
double dist;
const SMDS_MeshElement* face;
- map< _LayerEdge*, set< _LayerEdge* > > edge2CloseEdge;
+ typedef map< _LayerEdge*, set< _LayerEdge*, _LayerEdgeCmp >, _LayerEdgeCmp > TLEdge2LEdgeSet;
+ TLEdge2LEdgeSet edge2CloseEdge;
const double eps = data._epsilon * data._epsilon;
for ( unsigned i = 0; i < data._edges.size(); ++i )
if ( edge->FindIntersection( *searcher, dist, eps, &face ))
{
const TmpMeshFaceOnEdge* f = (const TmpMeshFaceOnEdge*) face;
- set< _LayerEdge* > & ee = edge2CloseEdge[ edge ];
+ set< _LayerEdge*, _LayerEdgeCmp > & ee = edge2CloseEdge[ edge ];
ee.insert( f->_le1 );
ee.insert( f->_le2 );
if ( f->_le1->IsOnEdge() && f->_le1->_sWOL.IsNull() )
{
dumpFunction(SMESH_Comment("updateNormals")<<data._index);
- map< _LayerEdge*, set< _LayerEdge* > >::iterator e2ee = edge2CloseEdge.begin();
+ TLEdge2LEdgeSet::iterator e2ee = edge2CloseEdge.begin();
for ( ; e2ee != edge2CloseEdge.end(); ++e2ee )
{
_LayerEdge* edge1 = e2ee->first;
_LayerEdge* edge2 = 0;
- set< _LayerEdge* >& ee = e2ee->second;
+ set< _LayerEdge*, _LayerEdgeCmp >& ee = e2ee->second;
// find EDGEs the edges reside
TopoDS_Edge E1, E2;
gp_Ax1 segDir;
if ( iPrev < 0 )
{
- segDir.SetLocation( SMESH_MeshEditor::TNodeXYZ( _nodes[0] ));
+ segDir.SetLocation( SMESH_TNodeXYZ( _nodes[0] ));
segDir.SetDirection( _normal );
segLen = 0;
}
Handle(Geom_Surface) surface = BRep_Tool::Surface( TopoDS::Face(_sWOL), loc );
pPrev = surface->Value( pPrev.X(), pPrev.Y() ).Transformed( loc );
}
- dir = SMESH_MeshEditor::TNodeXYZ( _nodes.back() ) - pPrev.XYZ();
+ dir = SMESH_TNodeXYZ( _nodes.back() ) - pPrev.XYZ();
}
segDir.SetLocation( pPrev );
segDir.SetDirection( dir );
gp_XYZ orig = lastSegment.Location().XYZ();
gp_XYZ dir = lastSegment.Direction().XYZ();
- SMESH_MeshEditor::TNodeXYZ vert0( n0 );
- SMESH_MeshEditor::TNodeXYZ vert1( n1 );
- SMESH_MeshEditor::TNodeXYZ vert2( n2 );
+ SMESH_TNodeXYZ vert0( n0 );
+ SMESH_TNodeXYZ vert1( n1 );
+ SMESH_TNodeXYZ vert2( n2 );
/* calculate distance from vert0 to ray origin */
gp_XYZ tvec = orig - vert0;
ASSERT( IsOnEdge() );
SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( _nodes.back() );
- SMESH_MeshEditor::TNodeXYZ oldPos( tgtNode );
+ SMESH_TNodeXYZ oldPos( tgtNode );
double dist01, distNewOld;
- SMESH_MeshEditor::TNodeXYZ p0( _2neibors->_nodes[0]);
- SMESH_MeshEditor::TNodeXYZ p1( _2neibors->_nodes[1]);
+ SMESH_TNodeXYZ p0( _2neibors->_nodes[0]);
+ SMESH_TNodeXYZ p1( _2neibors->_nodes[1]);
dist01 = p0.Distance( _2neibors->_nodes[1] );
gp_Pnt newPos = p0 * _2neibors->_wgt[0] + p1 * _2neibors->_wgt[1];
if ( _2neibors->_plnNorm )
{
// put newPos on the plane defined by source node and _plnNorm
- gp_XYZ new2src = SMESH_MeshEditor::TNodeXYZ( _nodes[0] ) - newPos.XYZ();
+ gp_XYZ new2src = SMESH_TNodeXYZ( _nodes[0] ) - newPos.XYZ();
double new2srcProj = (*_2neibors->_plnNorm) * new2src;
newPos.ChangeCoord() += (*_2neibors->_plnNorm) * new2srcProj;
}
// compute new position for the last _pos
gp_XYZ newPos (0,0,0);
for ( unsigned i = 0; i < _simplices.size(); ++i )
- newPos += SMESH_MeshEditor::TNodeXYZ( _simplices[i]._nPrev );
+ newPos += SMESH_TNodeXYZ( _simplices[i]._nPrev );
newPos /= _simplices.size();
if ( _curvature )
// }
// count quality metrics (orientation) of tetras around _tgtNode
int nbOkBefore = 0;
- SMESH_MeshEditor::TNodeXYZ tgtXYZ( _nodes.back() );
+ SMESH_TNodeXYZ tgtXYZ( _nodes.back() );
for ( unsigned i = 0; i < _simplices.size(); ++i )
nbOkBefore += _simplices[i].IsForward( _nodes[0], &tgtXYZ );
SMDS_MeshNode* n = const_cast< SMDS_MeshNode* >( _nodes.back() );
- _len -= prevPos.Distance(SMESH_MeshEditor::TNodeXYZ( n ));
+ _len -= prevPos.Distance(SMESH_TNodeXYZ( n ));
_len += prevPos.Distance(newPos);
n->setXYZ( newPos.X(), newPos.Y(), newPos.Z());
}
SMDS_MeshNode* n = const_cast< SMDS_MeshNode*>( _nodes.back() );
- SMESH_MeshEditor::TNodeXYZ oldXYZ( n );
+ SMESH_TNodeXYZ oldXYZ( n );
gp_XYZ nXYZ = oldXYZ + _normal * ( len - _len ) * _lenFactor;
n->setXYZ( nXYZ.X(), nXYZ.Y(), nXYZ.Z() );
// Find out orientation and type of face to create
- bool reverse = false, tria = false, isOnFace;
+ bool reverse = false, isOnFace;
map< TGeomID, TopoDS_Shape >::iterator e2f =
data._shrinkShape2Shape.find( getMeshDS()->ShapeToIndex( E ));
TopoDS_Shape F;
- if ( isOnFace = ( e2f != data._shrinkShape2Shape.end() ))
+ if (( isOnFace = ( e2f != data._shrinkShape2Shape.end() )))
{
F = e2f->second.Oriented( TopAbs_FORWARD );
reverse = ( helper.GetSubShapeOri( F, E ) == TopAbs_REVERSED );
!_ignoreShapeIds.count( e2f->first ))
F = *pF;
}
-
- tria = true;
}
// Find the sub-mesh to add new faces
SMESHDS_SubMesh* sm = 0;
// Make faces
const int dj1 = reverse ? 0 : 1;
const int dj2 = reverse ? 1 : 0;
- vector<SMDS_MeshElement*> newFaces;
- newFaces.reserve(( ledges.size() - 1 ) * (ledges[0]->_nodes.size() - 1 ));
for ( unsigned j = 1; j < ledges.size(); ++j )
{
vector< const SMDS_MeshNode*>& nn1 = ledges[j-dj1]->_nodes;
