-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2014 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
// 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.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "SMESH_Pattern.hxx"
+#include "SMDS_EdgePosition.hxx"
+#include "SMDS_FacePosition.hxx"
+#include "SMDS_MeshElement.hxx"
+#include "SMDS_MeshFace.hxx"
+#include "SMDS_MeshNode.hxx"
+#include "SMDS_VolumeTool.hxx"
+#include "SMESHDS_Group.hxx"
+#include "SMESHDS_Mesh.hxx"
+#include "SMESHDS_SubMesh.hxx"
+#include "SMESH_Block.hxx"
+#include "SMESH_Mesh.hxx"
+#include "SMESH_MeshAlgos.hxx"
+#include "SMESH_MesherHelper.hxx"
+#include "SMESH_subMesh.hxx"
+
#include <BRepAdaptor_Curve.hxx>
#include <BRepTools.hxx>
#include <BRepTools_WireExplorer.hxx>
#include <gp_XY.hxx>
#include <gp_XYZ.hxx>
-#include "SMDS_EdgePosition.hxx"
-#include "SMDS_FacePosition.hxx"
-#include "SMDS_MeshElement.hxx"
-#include "SMDS_MeshFace.hxx"
-#include "SMDS_MeshNode.hxx"
-#include "SMDS_VolumeTool.hxx"
-#include "SMESHDS_Group.hxx"
-#include "SMESHDS_Mesh.hxx"
-#include "SMESHDS_SubMesh.hxx"
-#include "SMESH_Block.hxx"
-#include "SMESH_Mesh.hxx"
-#include "SMESH_MesherHelper.hxx"
-#include "SMESH_subMesh.hxx"
-
#include <Basics_OCCTVersion.hxx>
#include <Basics_Utils.hxx>
#define smdsNode( elem ) static_cast<const SMDS_MeshNode*>( elem )
-//=======================================================================
-//function : SMESH_Pattern
-//purpose :
-//=======================================================================
-
-SMESH_Pattern::SMESH_Pattern ()
+namespace
{
-}
+
//=======================================================================
//function : getInt
//purpose :
//=======================================================================
-static inline int getInt( const char * theSring )
+inline int getInt( const char * theSring )
{
if ( *theSring < '0' || *theSring > '9' )
return -1;
//purpose :
//=======================================================================
-static inline double getDouble( const char * theSring )
+inline double getDouble( const char * theSring )
{
char *ptr;
return strtod( theSring, &ptr );
// Return the number of the found tokens
//=======================================================================
-static int readLine (list <const char*> & theFields,
- const char* & theLineBeg,
- const bool theClearFields )
+int readLine (list <const char*> & theFields,
+ const char* & theLineBeg,
+ const bool theClearFields )
{
if ( theClearFields )
theFields.clear();
return nbRead;
}
+//=======================================================================
+//function : isRealSeam
+//purpose : return true if an EDGE encounters twice in a FACE
+//=======================================================================
+
+// bool isRealSeam( const TopoDS_Edge& e, const TopoDS_Face& f )
+// {
+// if ( BRep_Tool::IsClosed( e, f ))
+// {
+// int nb = 0;
+// for (TopExp_Explorer exp( f, TopAbs_EDGE ); exp.More(); exp.Next())
+// if ( exp.Current().IsSame( e ))
+// if ( ++nb == 2 )
+// return true;
+// }
+// return false;
+// }
+
+//=======================================================================
+//function : loadVE
+//purpose : load VERTEXes and EDGEs in a map. Return nb loaded VERTEXes
+//=======================================================================
+
+int loadVE( const list< TopoDS_Edge > & eList,
+ TopTools_IndexedMapOfOrientedShape & map )
+{
+ list< TopoDS_Edge >::const_iterator eIt = eList.begin();
+ // vertices
+ int nbV;
+ for ( eIt = eList.begin(); eIt != eList.end(); eIt++ )
+ {
+ nbV = map.Extent();
+ map.Add( TopExp::FirstVertex( *eIt, true ));
+ bool added = ( nbV < map.Extent() );
+ if ( !added ) { // vertex encountered twice
+ // a seam vertex have two corresponding key points
+ map.Add( TopExp::FirstVertex( *eIt, true ).Reversed());
+ }
+ }
+ nbV = map.Extent();
+
+ // edges
+ for ( eIt = eList.begin(); eIt != eList.end(); eIt++ )
+ map.Add( *eIt );
+
+ return nbV;
+}
+
+} // namespace
+
+//=======================================================================
+//function : SMESH_Pattern
+//purpose :
+//=======================================================================
+
+SMESH_Pattern::SMESH_Pattern ()
+{
+}
+
//=======================================================================
//function : Load
//purpose : Load a pattern from <theFile>
}
double u, v, minVal = DBL_MAX;
for ( int i = theProjectorPS.NbExt(); i > 0; i-- )
-#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1
if ( theProjectorPS.SquareDistance( i ) < minVal ) {
minVal = theProjectorPS.SquareDistance( i );
-#else
- if ( theProjectorPS.Value( i ) < minVal ) {
- minVal = theProjectorPS.Value( i );
-#endif
theProjectorPS.Point( i ).Parameter( u, v );
}
return gp_XY( u, v );
bool SMESH_Pattern::Load (SMESH_Mesh* theMesh,
const TopoDS_Face& theFace,
- bool theProject)
+ bool theProject,
+ TopoDS_Vertex the1stVertex)
{
MESSAGE(" ::Load(face) " );
Clear();
// check if face is closed
bool isClosed = helper.HasSeam();
- TopoDS_Vertex bidon;
list<TopoDS_Edge> eList;
list<TopoDS_Edge>::iterator elIt;
- SMESH_Block::GetOrderedEdges( face, bidon, eList, myNbKeyPntInBoundary );
+ SMESH_Block::GetOrderedEdges( face, eList, myNbKeyPntInBoundary, the1stVertex );
// check that requested or needed projection is possible
bool isMainShape = theMesh->IsMainShape( face );
// Load shapes in the consequent order and count nb of points
- // vertices
- for ( elIt = eList.begin(); elIt != eList.end(); elIt++ ) {
- int nbV = myShapeIDMap.Extent();
- myShapeIDMap.Add( TopExp::FirstVertex( *elIt, true ));
- bool added = ( nbV < myShapeIDMap.Extent() );
- if ( !added ) { // vertex encountered twice
- // a seam vertex have two corresponding key points
- myShapeIDMap.Add( TopExp::FirstVertex( *elIt, true ).Reversed());
- ++nbNodes;
- }
+ loadVE( eList, myShapeIDMap );
+ myShapeIDMap.Add( face );
+
+ nbNodes += myShapeIDMap.Extent() - 1;
+
+ for ( elIt = eList.begin(); elIt != eList.end(); elIt++ )
if ( SMESHDS_SubMesh * eSubMesh = aMeshDS->MeshElements( *elIt ))
nbNodes += eSubMesh->NbNodes() + 1;
- }
- // edges
- for ( elIt = eList.begin(); elIt != eList.end(); elIt++ )
- myShapeIDMap.Add( *elIt );
- // the face
- myShapeIDMap.Add( face );
myPoints.resize( nbNodes );
// Load U of points on edges
- for ( elIt = eList.begin(); elIt != eList.end(); elIt++ )
+ list<int>::iterator nbEinW = myNbKeyPntInBoundary.begin();
+ int iE = 0;
+ vector< TopoDS_Edge > eVec;
+ for ( elIt = eList.begin(); elIt != eList.end(); elIt++, iE++ )
{
+ if ( isClosed && ( iE == 0 || iE == *nbEinW ))
+ {
+ // new wire begins; put EDGEs in eVec
+ list<TopoDS_Edge>::iterator eEnd = elIt;
+ std::advance( eEnd, *nbEinW );
+ eVec.assign( elIt, eEnd );
+ if ( iE > 0 )
+ ++nbEinW;
+ iE = 0;
+ }
TopoDS_Edge & edge = *elIt;
list< TPoint* > & ePoints = getShapePoints( edge );
double f, l;
TopoDS_Shape & v = is2 ? v2 : v1;
if ( helper.IsRealSeam( v ) ) {
// reverse or not depending on orientation of adjacent seam
- TopoDS_Edge seam;
- list<TopoDS_Edge>::iterator eIt2 = elIt;
- if ( is2 )
- seam = ( ++eIt2 == eList.end() ? eList.front() : *eIt2 );
- else
- seam = ( eIt2 == eList.begin() ? eList.back() : *(--eIt2) );
- if ( seam.Orientation() == TopAbs_REVERSED )
+ int iSeam = helper.WrapIndex( iE + ( is2 ? +1 : -1 ), eVec.size() );
+ if ( eVec[ iSeam ].Orientation() == TopAbs_REVERSED )
v.Reverse();
}
}
BRep_Tool::CurveOnSurface( theEdge, TopoDS::Face( myShape ), f, l );
ePoints.back()->myInitU = 1.0;
+ //ePoints.front()->myInitU = 0.0; //myUV = C2d->Value( isForward ? f : l ).XY();
list< TPoint* >::const_iterator pIt = ePoints.begin();
for ( pIt++; pIt != ePoints.end(); pIt++ )
{
list< TopoDS_Edge > eList;
list< int > nbVertexInWires;
- int nbWires = SMESH_Block::GetOrderedEdges( face, theVertexOnKeyPoint1, eList, nbVertexInWires);
+ int nbWires = SMESH_Block::GetOrderedEdges( face, eList, nbVertexInWires, theVertexOnKeyPoint1);
if ( !theVertexOnKeyPoint1.IsSame( TopExp::FirstVertex( eList.front(), true )))
{
MESSAGE( " theVertexOnKeyPoint1 not found in the outer wire ");
}
// here shapes get IDs, for the outer wire IDs are OK
- list<TopoDS_Edge>::iterator elIt = eList.begin();
- for ( ; elIt != eList.end(); elIt++ ) {
- myShapeIDMap.Add( TopExp::FirstVertex( *elIt, true ));
- bool isClosed1 = BRep_Tool::IsClosed( *elIt, theFace );
- // BEGIN: jfa for bug 0019943
- if (isClosed1) {
- isClosed1 = false;
- for (TopExp_Explorer expw (theFace, TopAbs_WIRE); expw.More() && !isClosed1; expw.Next()) {
- const TopoDS_Wire& wire = TopoDS::Wire(expw.Current());
- int nbe = 0;
- for (BRepTools_WireExplorer we (wire, theFace); we.More() && !isClosed1; we.Next()) {
- if (we.Current().IsSame(*elIt)) {
- nbe++;
- if (nbe == 2) isClosed1 = true;
- }
- }
- }
- }
- // END: jfa for bug 0019943
- if (isClosed1)
- myShapeIDMap.Add( TopExp::LastVertex( *elIt, true ));// vertex orienation is REVERSED
- }
- int nbVertices = myShapeIDMap.Extent();
-
- for ( elIt = eList.begin(); elIt != eList.end(); elIt++ )
- myShapeIDMap.Add( *elIt );
-
+ int nbVertices = loadVE( eList, myShapeIDMap );
myShapeIDMap.Add( face );
if ( myShapeIDToPointsMap.size() != myShapeIDMap.Extent() ) {
list< list< TPoint* > > edgesPointsList;
edgesPointsList.push_back( list< TPoint* >() );
list< TPoint* > * edgesPoints = & edgesPointsList.back();
- list< TPoint* >::iterator pIt;
+ list< TPoint* >::iterator pIt, pEnd;
// compute UV of points on the outer wire
int iE, nbEdgesInOuterWire = nbVertexInWires.front();
+ list< TopoDS_Edge >::iterator elIt;
for (iE = 0, elIt = eList.begin();
iE < nbEdgesInOuterWire && elIt != eList.end();
iE++, elIt++ )
// re-fill myShapeIDMap - all shapes get good IDs
myShapeIDMap.Clear();
- for ( elIt = eList.begin(); elIt != eList.end(); elIt++ )
- myShapeIDMap.Add( TopExp::FirstVertex( *elIt, true ));
- for ( elIt = eList.begin(); elIt != eList.end(); elIt++ )
- myShapeIDMap.Add( *elIt );
+ nbVertices = loadVE( eList, myShapeIDMap );
myShapeIDMap.Add( face );
} // there are inner wires
+ // Set XYZ of on-vertex points
+
+ // for ( int iV = 1; iV <= nbVertices; ++iV )
+ // {
+ // const TopoDS_Vertex& V = TopoDS::Vertex( myShapeIDMap( iV ));
+ // list< TPoint* > & vPoints = getShapePoints( iV );
+ // if ( !vPoints.empty() )
+ // {
+ // //vPoints.front()->myUV = BRep_Tool::Parameters( V, theFace ).XY();
+ // vPoints.front()->myXYZ = BRep_Tool::Pnt( V );
+ // }
+ // }
+
// Compute XYZ of on-edge points
TopLoc_Location loc;
{
BRepAdaptor_Curve C3d( *elIt );
list< TPoint* > & ePoints = getShapePoints( iE++ );
- pIt = ePoints.begin();
- for ( pIt++; pIt != ePoints.end(); pIt++ )
+ for ( pIt = ++ePoints.begin(), pEnd = ePoints.end(); pIt != pEnd; pIt++ )
{
TPoint* point = *pIt;
point->myXYZ = C3d.Value( point->myU );
list< const SMDS_MeshNode* > nodes;
list< const SMDS_MeshNode* >::iterator n = nodes.end();
- SMDS_ElemIteratorPtr noIt = theFace->nodesIterator();
+ SMDS_NodeIteratorPtr noIt = theFace->nodeIterator();
int iSub = 0;
while ( noIt->more() && iSub < nbFaceNodes ) {
- const SMDS_MeshNode* node = smdsNode( noIt->next() );
+ const SMDS_MeshNode* node = noIt->next();
nodes.push_back( node );
if ( iSub++ == theNodeIndexOnKeyPoint1 )
n = --nodes.end();
list< gp_XYZ > xyzList;
myOrderedNodes.resize( nbFaceNodes );
for ( iSub = 0, n = nodes.begin(); n != nodes.end(); ++n ) {
- xyzList.push_back( gp_XYZ( (*n)->X(), (*n)->Y(), (*n)->Z() ));
+ xyzList.push_back( SMESH_TNodeXYZ( *n ));
myOrderedNodes[ iSub++] = *n;
}
myXYZ.resize( myPoints.size() * theFaces.size(), undefinedXYZ() );
myElements.reserve( theFaces.size() );
- // to find point index
- map< TPoint*, int > pointIndex;
- for ( int i = 0; i < myPoints.size(); i++ )
- pointIndex.insert( make_pair( & myPoints[ i ], i ));
-
int ind1 = 0; // lowest point index for a face
// meshed geometry
{
list< TPoint* > & linkPoints = getShapePoints( eID++ );
const SMDS_MeshNode* n1 = myOrderedNodes[ i ];
- const SMDS_MeshNode* n2 = myOrderedNodes[ i + 1 == nbNodes ? 0 : i + 1 ];
+ const SMDS_MeshNode* n2 = myOrderedNodes[( i+1 ) % nbNodes ];
// make a link and a node set
TNodeSet linkSet, node1Set;
linkSet.insert( n1 );
list< TPoint* >::iterator p = linkPoints.begin();
{
// map the first link point to n1
- int nId = pointIndex[ *p ] + ind1;
+ int nId = ( *p - &myPoints[0] ) + ind1;
myXYZIdToNodeMap[ nId ] = n1;
list< list< int > >& groups = myIdsOnBoundary[ node1Set ];
groups.push_back(list< int > ());
list< int >& indList = groups.back();
// add points to the map excluding the end points
for ( p++; *p != linkPoints.back(); p++ )
- indList.push_back( pointIndex[ *p ] + ind1 );
+ indList.push_back( ( *p - &myPoints[0] ) + ind1 );
}
ind1 += myPoints.size();
}
Bnd_Box box;
TNodeSet::const_iterator n = nodes.begin();
for ( ; n != nodes.end(); ++n )
- box.Add( gp_Pnt( (*n)->X(), (*n)->Y(), (*n)->Z() ));
+ box.Add( gp_Pnt( SMESH_TNodeXYZ( *n )));
double x, y, z, X, Y, Z;
box.Get( x, y, z, X, Y, Z );
gp_Pnt p( x, y, z ), P( X, Y, Z );
bool unite = ( uniteGroups && nodes.size() == 2 );
map< double, int > distIndMap;
const SMDS_MeshNode* node = *nodes.begin();
- gp_Pnt P( node->X(), node->Y(), node->Z() );
+ gp_Pnt P = SMESH_TNodeXYZ( node );
// compare points, replace indices
while (true)
{
const SMDS_MeshElement* face =
- SMESH_MeshEditor::FindFaceInSet( n1, n2, elemSet, avoidSet );
+ SMESH_MeshAlgos::FindFaceInSet( n1, n2, elemSet, avoidSet );
if ( face )
{
avoidSet.insert ( face );
}
}
+//=======================================================================
+//function : findExistingNodes
+//purpose : fills nodes vector with nodes existing on a given shape (IMP 22368)
+// Returns true if all nodes for all points on S are found
+//=======================================================================
+
+bool SMESH_Pattern::findExistingNodes( SMESH_Mesh* mesh,
+ const TopoDS_Shape& S,
+ const std::list< TPoint* > & points,
+ vector< const SMDS_MeshNode* > & nodesVector)
+{
+ if ( S.IsNull() || points.empty() )
+ return false;
+
+ SMESHDS_Mesh* aMeshDS = mesh->GetMeshDS();
+
+ switch ( S.ShapeType() )
+ {
+ case TopAbs_VERTEX:
+ {
+ int pIndex = points.back() - &myPoints[0];
+ if ( !nodesVector[ pIndex ] )
+ nodesVector[ pIndex ] = SMESH_Algo::VertexNode( TopoDS::Vertex( S ), aMeshDS );
+ return nodesVector[ pIndex ];
+ }
+ case TopAbs_EDGE:
+ {
+ const TopoDS_Edge& edge = TopoDS::Edge( S );
+ map< double, const SMDS_MeshNode* > paramsOfNodes;
+ if ( !SMESH_Algo::GetSortedNodesOnEdge( aMeshDS, edge,
+ /*ignoreMediumNodes=*/false,
+ paramsOfNodes )
+ || paramsOfNodes.size() < 3 )
+ break;
+ // points on VERTEXes are included with wrong myU
+ list< TPoint* >::const_reverse_iterator pItR = ++points.rbegin();
+ list< TPoint* >::const_iterator pItF = ++points.begin();
+ const bool isForward = ( (*pItF)->myU < (*pItR)->myU );
+ map< double, const SMDS_MeshNode* >::iterator u2n = ++paramsOfNodes.begin();
+ map< double, const SMDS_MeshNode* >::iterator u2nEnd = --paramsOfNodes.end();
+ TPoint* p;
+ if ( paramsOfNodes.size() == points.size() )
+ {
+ for ( ; u2n != u2nEnd; ++u2n )
+ {
+ p = ( isForward ? *pItF : *pItR );
+ int pIndex = p - &myPoints[0];
+ if ( !nodesVector [ pIndex ] )
+ nodesVector [ pIndex ] = u2n->second;
+ ++pItF;
+ ++pItR;
+ }
+ return true;
+ }
+ else
+ {
+ const double tolFact = 0.05;
+ while ( u2n != u2nEnd && pItF != points.end() )
+ {
+ const double u = u2n->first;
+ const SMDS_MeshNode* n = u2n->second;
+ const double tol = ( (++u2n)->first - u ) * tolFact;
+ do
+ {
+ p = ( isForward ? *pItF : *pItR );
+ if ( Abs( u - p->myU ) < tol )
+ {
+ int pIndex = p - &myPoints[0];
+ if ( !nodesVector [ pIndex ] )
+ nodesVector [ pIndex ] = n;
+ ++pItF;
+ ++pItR;
+ break;
+ }
+ }
+ while ( p->myU < u && ( ++pItF, ++pItR != points.rend() ));
+ }
+ }
+ break;
+ } // case TopAbs_EDGE:
+
+ default:;
+ } // switch ( S.ShapeType() )
+
+ return false;
+}
+
//=======================================================================
//function : MakeMesh
//purpose : Create nodes and elements in <theMesh> using nodes
// coordinates computed by either of Apply...() methods
-// WARNING : StdMeshers_Projection_... relies on MakeMesh() behavior: that
-// it does not care of nodes and elements already existing on
-// sub-shapes. DO NOT MERGE them or modify also StdMeshers_Projection_..
//=======================================================================
bool SMESH_Pattern::MakeMesh(SMESH_Mesh* theMesh,
myXYZ[ i ].Y(),
myXYZ[ i ].Z());
}
- }
+ if ( theMesh->HasShapeToMesh() )
+ {
+ // set nodes on EDGEs (IMP 22368)
+ SMESH_MesherHelper helper( *theMesh );
+ helper.ToFixNodeParameters( true );
+ map< TNodeSet, list< list< int > > >::iterator idListIt = myIdsOnBoundary.begin();
+ for ( ; idListIt != myIdsOnBoundary.end(); idListIt++ )
+ {
+ list<list< int > >& groups = idListIt->second;
+ const TNodeSet& nodes = idListIt->first;
+ if ( nodes.size() != 2 )
+ continue; // not a link
+ const SMDS_MeshNode* n1 = *nodes.begin();
+ const SMDS_MeshNode* n2 = *nodes.rbegin();
+ TopoDS_Shape S1 = helper.GetSubShapeByNode( n1, aMeshDS );
+ TopoDS_Shape S2 = helper.GetSubShapeByNode( n2, aMeshDS );
+ if ( S1.IsNull() || S1.ShapeType() < TopAbs_EDGE ||
+ S2.IsNull() || S2.ShapeType() < TopAbs_EDGE )
+ continue;
+ TopoDS_Shape S;
+ if ( S1.ShapeType() == TopAbs_EDGE )
+ {
+ if ( S1 == S2 || helper.IsSubShape( S2, S1 ))
+ S = S1;
+ }
+ else if ( S2.ShapeType() == TopAbs_EDGE )
+ {
+ if ( helper.IsSubShape( S1, S2 ))
+ S = S2;
+ }
+ else
+ {
+ S = helper.GetCommonAncestor( S1, S2, *theMesh, TopAbs_EDGE );
+ }
+ if ( S.IsNull() )
+ continue;
+ const TopoDS_Edge & E = TopoDS::Edge( S );
+ helper.SetSubShape( E );
+ list<list< int > >::iterator g = groups.begin();
+ for ( ; g != groups.end(); ++g )
+ {
+ list< int >& ids = *g;
+ list< int >::iterator id = ids.begin();
+ for ( ; id != ids.end(); ++id )
+ if ( nodesVector[ *id ] && nodesVector[ *id ]->getshapeId() < 1 )
+ {
+ double u = 1e100;
+ aMeshDS->SetNodeOnEdge( nodesVector[ *id ], E, u );
+ helper.CheckNodeU( E, nodesVector[ *id ], u, 1e-7, true );
+ }
+ }
+ }
+ }
+ } // if ( onMeshElements )
+
else
{
nodesVector.resize( myPoints.size(), 0 );
- // to find point index
- map< TPoint*, int > pointIndex;
- for ( int i = 0; i < myPoints.size(); i++ )
- pointIndex.insert( make_pair( & myPoints[ i ], i ));
-
// loop on sub-shapes of myShape: create nodes
map< int, list< TPoint* > >::iterator idPointIt = myShapeIDToPointsMap.begin();
for ( ; idPointIt != myShapeIDToPointsMap.end(); idPointIt++ )
{
+ list< TPoint* > & points = idPointIt->second;
TopoDS_Shape S;
- //SMESHDS_SubMesh * subMeshDS = 0;
- if ( !myShapeIDMap.IsEmpty() ) {
+ if ( !myShapeIDMap.IsEmpty() )
S = myShapeIDMap( idPointIt->first );
- //subMeshDS = aMeshDS->MeshElements( S );
- }
- list< TPoint* > & points = idPointIt->second;
+
+ // find existing nodes on EDGEs and VERTEXes
+ if ( findExistingNodes( theMesh, S, points, nodesVector ))
+ continue;
+
list< TPoint* >::iterator pIt = points.begin();
for ( ; pIt != points.end(); pIt++ )
{
TPoint* point = *pIt;
- int pIndex = pointIndex[ point ];
+ int pIndex = point - &myPoints[0];
if ( nodesVector [ pIndex ] )
continue;
SMDS_MeshNode* node = aMeshDS->AddNode (point->myXYZ.X(),
point->myXYZ.Z());
nodesVector [ pIndex ] = node;
- if ( !S.IsNull() /*subMeshDS*/ ) {
- // !!!!! do not merge new nodes with ones existing on submeshes (see method comment)
+ if ( !S.IsNull() ) {
+
switch ( S.ShapeType() ) {
case TopAbs_VERTEX: {
aMeshDS->SetNodeOnVertex( node, TopoDS::Vertex( S )); break;
SMDS_ElemIteratorPtr noIt = elem->nodesIterator();
while ( noIt->more() ) {
SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>(smdsNode( noIt->next() ));
- if (!node->getshapeId() &&
- shellNodes.find( node ) == shellNodes.end() ) {
+ if ( node->getshapeId() < 1 &&
+ shellNodes.find( node ) == shellNodes.end() )
+ {
if ( S.ShapeType() == TopAbs_FACE )
aMeshDS->SetNodeOnFace( node, shapeID,
Precision::Infinite(),// <- it's a sign that UV is not set
TopTools_MapOfShape seamVertices;
TopoDS_Face face = TopoDS::Face( theShape );
TopExp_Explorer eExp( theShape, TopAbs_EDGE );
- for ( ; eExp.More() && nbNodeOnSeamEdge == 0; eExp.Next() ) {
+ for ( ; eExp.More() /*&& nbNodeOnSeamEdge == 0*/; eExp.Next() ) {
const TopoDS_Edge& ee = TopoDS::Edge(eExp.Current());
if ( BRep_Tool::IsClosed(ee, face) ) {
// seam edge and vertices encounter twice in theFace
