TopAbs_ShapeEnum ShapeType() const { return myShape.ShapeType(); }
const TopoDS_Shape& Shape() const { return myShape; }
const Bnd_B3d* GetBndBox() const { return & myBox; }
+ double Tolerance() const { return myTol; }
bool IsChecked() { return myFlags & theIsCheckedFlag; }
bool IsSetFlag( int flag ) const { return myFlags & flag; }
void SetChecked( bool is ) { is ? SetFlag( theIsCheckedFlag ) : UnsetFlag( theIsCheckedFlag ); }
myOctree = new OctreeClassifier( myWorkClassifiers );
}
- SMDS_ElemIteratorPtr aNodeItr = elem->nodesIterator();
- while (aNodeItr->more() && (isSatisfy == myAllNodesFlag))
+ for ( int i = 0, nb = elem->NbNodes(); i < nb && (isSatisfy == myAllNodesFlag); ++i )
{
- SMESH_TNodeXYZ aPnt( aNodeItr->next() );
+ SMESH_TNodeXYZ aPnt( elem->GetNode( i ));
centerXYZ += aPnt;
isNodeOut = true;
for ( int i = 0; i < nbChildren(); i++ )
{
OctreeClassifier* child = static_cast<OctreeClassifier*>( myChildren[ i ]);
- child->myIsLeaf = ( child->myClassifiers.size() <= 5 );
+ child->myIsLeaf = ( child->myClassifiers.size() <= 5 ||
+ child->maxSize() < child->myClassifiers[0]->Tolerance() );
}
}
theNodes.push_back( theSecondNode );
const SMDS_MeshNode *nIgnore = theFirstNode, *nStart = theSecondNode;
- TIDSortedElemSet foundElems;
+ //TIDSortedElemSet foundElems;
bool needTheLast = ( theLastNode != 0 );
+ vector<const SMDS_MeshNode*> nodes;
+
while ( nStart != theLastNode ) {
if ( nStart == theFirstNode )
return !needTheLast;
- // find all free border faces sharing form nStart
+ // find all free border faces sharing nStart
list< const SMDS_MeshElement* > curElemList;
list< const SMDS_MeshNode* > nStartList;
SMDS_ElemIteratorPtr invElemIt = nStart->GetInverseElementIterator(SMDSAbs_Face);
while ( invElemIt->more() ) {
const SMDS_MeshElement* e = invElemIt->next();
- if ( e == curElem || foundElems.insert( e ).second ) {
+ //if ( e == curElem || foundElems.insert( e ).second ) // e can encounter twice in border
+ {
// get nodes
- int iNode = 0, nbNodes = e->NbNodes();
- vector<const SMDS_MeshNode*> nodes( nbNodes+1 );
nodes.assign( SMDS_MeshElement::iterator( e->interlacedNodesIterator() ),
SMDS_MeshElement::iterator() );
nodes.push_back( nodes[ 0 ]);
// check 2 links
+ int iNode = 0, nbNodes = nodes.size() - 1;
for ( iNode = 0; iNode < nbNodes; iNode++ )
- if (((nodes[ iNode ] == nStart && nodes[ iNode + 1] != nIgnore ) ||
- (nodes[ iNode + 1] == nStart && nodes[ iNode ] != nIgnore )) &&
- ControlFreeBorder( &nodes[ iNode ], e->GetID() ))
+ if ((( nodes[ iNode ] == nStart && nodes[ iNode + 1] != nIgnore ) ||
+ ( nodes[ iNode + 1] == nStart && nodes[ iNode ] != nIgnore )) &&
+ ( ControlFreeBorder( &nodes[ iNode ], e->GetID() )))
{
- nStartList.push_back( nodes[ iNode + ( nodes[ iNode ] == nStart ? 1 : 0 )]);
+ nStartList.push_back( nodes[ iNode + ( nodes[ iNode ] == nStart )]);
curElemList.push_back( e );
}
}
else if ( !contNodes[0].empty() && !contNodes[1].empty() ) {
// choice: clear a worse one
int iLongest = ( contNodes[0].size() < contNodes[1].size() ? 1 : 0 );
- int iWorse = ( needTheLast ? 1 - iLongest : iLongest );
+ int iWorse = ( needTheLast ? 1 - iLongest : iLongest );
contNodes[ iWorse ].clear();
contFaces[ iWorse ].clear();
}
theNodes.pop_back(); // remove nIgnore
theNodes.pop_back(); // remove nStart
theFaces.pop_back(); // remove curElem
- list< const SMDS_MeshNode* >::iterator nIt = cNL->begin();
- list< const SMDS_MeshElement* >::iterator fIt = cFL->begin();
- for ( ; nIt != cNL->end(); nIt++ ) theNodes.push_back( *nIt );
- for ( ; fIt != cFL->end(); fIt++ ) theFaces.push_back( *fIt );
+ theNodes.splice( theNodes.end(), *cNL );
+ theFaces.splice( theFaces.end(), *cFL );
return true;
} // several continuations found
nIt[0] = nSide[0].begin(); eIt[0] = eSide[0].begin();
nIt[1] = nSide[1].begin(); eIt[1] = eSide[1].begin();
+ // element can be split while iterating on border if it has two edges in the border
+ std::map< const SMDS_MeshElement* , const SMDS_MeshElement* > elemReplaceMap;
+ std::map< const SMDS_MeshElement* , const SMDS_MeshElement* >::iterator elemReplaceMapIt;
+
TElemOfNodeListMap insertMap;
TElemOfNodeListMap::iterator insertMapIt;
// insertMap is
const SMDS_MeshNode* nIns = *nIt [ 1 - intoBord ];
if ( intoBord == 1 ) {
// move node of the border to be on a link of elem of the side
- gp_XYZ p1 (n1->X(), n1->Y(), n1->Z());
- gp_XYZ p2 (n2->X(), n2->Y(), n2->Z());
+ SMESH_NodeXYZ p1( n1 ), p2( n2 );
double ratio = du / ( param[ 1 ][ i[1] ] - param[ 1 ][ i[1]-1 ]);
gp_XYZ p = p2 * ( 1 - ratio ) + p1 * ratio;
GetMeshDS()->MoveNode( nIns, p.X(), p.Y(), p.Z() );
}
+ elemReplaceMapIt = elemReplaceMap.find( elem );
+ if ( elemReplaceMapIt != elemReplaceMap.end() )
+ elem = elemReplaceMapIt->second;
+
insertMapIt = insertMap.find( elem );
bool notFound = ( insertMapIt == insertMap.end() );
bool otherLink = ( !notFound && (*insertMapIt).second.front() != n1 );
UpdateVolumes(n12, n22, nodeList);
}
// 3. find an element appeared on n1 and n2 after the insertion
- insertMap.erase( elem );
- elem = findAdjacentFace( n1, n2, 0 );
+ insertMap.erase( insertMapIt );
+ const SMDS_MeshElement* elem2 = findAdjacentFace( n1, n2, 0 );
+ elemReplaceMap.insert( std::make_pair( elem, elem2 ));
+ elem = elem2;
}
if ( notFound || otherLink ) {
// add element and nodes of the side into the insertMap
gp_XYZ p = point.XYZ();
ElementBndBoxTree* ebbLeaf = ebbTree->getLeafAtPoint( p );
const Bnd_B3d* box = ebbLeaf ? ebbLeaf->getBox() : ebbTree->getBox();
- double radius = ( box->CornerMax() - box->CornerMin() ).Modulus();
+ gp_XYZ pMin = box->CornerMin(), pMax = box->CornerMax();
+ double radius = Precision::Infinite();
+ if ( ebbLeaf || !box->IsOut( p ))
+ {
+ for ( int i = 1; i <= 3; ++i )
+ {
+ double d = 0.5 * ( pMax.Coord(i) - pMin.Coord(i) );
+ if ( d > Precision::Confusion() )
+ radius = Min( d, radius );
+ }
+ if ( !ebbLeaf )
+ radius /= ebbTree->getHeight( /*full=*/true );
+ }
+ else // p outside of box
+ {
+ for ( int i = 1; i <= 3; ++i )
+ {
+ double d = 0;
+ if ( point.Coord(i) < pMin.Coord(i) )
+ d = pMin.Coord(i) - point.Coord(i);
+ else if ( point.Coord(i) > pMax.Coord(i) )
+ d = point.Coord(i) - pMax.Coord(i);
+ if ( d > Precision::Confusion() )
+ radius = Min( d, radius );
+ }
+ }
ElementBndBoxTree::TElemSeq elems;
ebbTree->getElementsInSphere( p, radius, elems );
while ( elems.empty() && radius < 1e100 )
{
- radius *= 1.5;
+ radius *= 1.1;
ebbTree->getElementsInSphere( p, radius, elems );
}
gp_XYZ proj, bestProj;
const SMDS_MeshElement* elem = 0;
- double minDist = 2 * radius;
+ double minDist = Precision::Infinite();
ElementBndBoxTree::TElemSeq::iterator e = elems.begin();
for ( ; e != elems.end(); ++e )
{
if ( nbBranches == 2 && !startIsBranchEnd ) // join two branches starting at the same node
{
- if ( nodeBranches[0].back() == nodeBranches[1].back() )
- {
- // it is a closed branch, keep theStartNode first
- nodeBranches[0].pop_back();
- nodeBranches[0].reserve( nodeBranches[0].size() + nodeBranches[1].size() );
- nodeBranches[0].insert( nodeBranches[0].end(),
- nodeBranches[1].rbegin(), nodeBranches[1].rend() );
- branches[0].reserve( branches[0].size() + branches[1].size() );
- branches[0].insert( branches[0].end(), branches[1].rbegin(), branches[1].rend() );
- }
- else
- {
- std::reverse( nodeBranches[0].begin(), nodeBranches[0].end() );
- nodeBranches[0].pop_back();
- nodeBranches[0].reserve( nodeBranches[0].size() + nodeBranches[1].size() );
- nodeBranches[0].insert( nodeBranches[0].end(),
- nodeBranches[1].begin(), nodeBranches[1].end() );
-
- std::reverse( branches[0].begin(), branches[0].end() );
- branches[0].reserve( branches[0].size() + branches[1].size() );
- branches[0].insert( branches[0].end(), branches[1].begin(), branches[1].end() );
- }
+ std::reverse( nodeBranches[0].begin(), nodeBranches[0].end() );
+ nodeBranches[0].pop_back();
+ nodeBranches[0].reserve( nodeBranches[0].size() + nodeBranches[1].size() );
+ nodeBranches[0].insert( nodeBranches[0].end(),
+ nodeBranches[1].begin(), nodeBranches[1].end() );
+
+ std::reverse( branches[0].begin(), branches[0].end() );
+ branches[0].reserve( branches[0].size() + branches[1].size() );
+ branches[0].insert( branches[0].end(), branches[1].begin(), branches[1].end() );
+
nodeBranches[1].clear();
branches[1].clear();
}
bool triangulate( std::vector< const SMDS_MeshNode*>& nodes, const size_t nbNodes );
- /*!
- * \brief Vertex of a polygon. Together with 2 neighbor Vertices represents a triangle
- */
- struct PolyVertex
- {
- SMESH_NodeXYZ _nxyz;
- size_t _index;
- gp_XY _xy;
- PolyVertex* _prev;
- PolyVertex* _next;
-
- void SetNodeAndNext( const SMDS_MeshNode* n, PolyVertex& v, size_t index );
- void GetTriaNodes( const SMDS_MeshNode** nodes, size_t* nodeIndices) const;
- double TriaArea() const;
- bool IsInsideTria( const PolyVertex* v );
- PolyVertex* Delete();
- };
+ struct PolyVertex;
struct Optimizer;
+ struct Data;
- std::vector< PolyVertex > _pv;
- std::vector< size_t > _nodeIndex;
- Optimizer* _optimizer;
+ Data* _data;
+ Optimizer* _optimizer;
};
// structure used in MakePolyLine() to define a cutting plane
EdgeLoop() : SMDS_PolygonalFaceOfNodes( std::vector<const SMDS_MeshNode *>() ) {}
void Clear() { myLinks.clear(); myIsBndConnected = false; myHasPending = false; }
bool SetConnected() { bool was = myIsBndConnected; myIsBndConnected = true; return !was; }
- bool Contains( const SMDS_MeshNode* n ) const
+ size_t Contains( const SMDS_MeshNode* n ) const
{
for ( size_t i = 0; i < myLinks.size(); ++i )
- if ( myLinks[i]->myNode1 == n ) return true;
- return false;
+ if ( myLinks[i]->myNode1 == n ) return i + 1;
+ return 0;
}
virtual int NbNodes() const { return myLinks.size(); }
virtual SMDS_ElemIteratorPtr nodesIterator() const
myLoopOfEdge[ Index( *loop->myLinks[ iE ] )] = 0;
loop->Clear();
}
+ void Join( EdgeLoop& loop1, size_t iAfterConcact,
+ EdgeLoop& loop2, size_t iFromEdge2 )
+ {
+ std::vector< const EdgePart* > linksAfterContact( loop1.myLinks.begin() + iAfterConcact,
+ loop1.myLinks.end() );
+ loop1.myLinks.reserve( loop2.myLinks.size() + loop1.myLinks.size() );
+ loop1.myLinks.resize( iAfterConcact );
+ loop1.myLinks.insert( loop1.myLinks.end(),
+ loop2.myLinks.begin() + iFromEdge2, loop2.myLinks.end() );
+ loop1.myLinks.insert( loop1.myLinks.end(),
+ loop2.myLinks.begin(), loop2.myLinks.begin() + iFromEdge2 );
+ loop1.myLinks.insert( loop1.myLinks.end(),
+ linksAfterContact.begin(), linksAfterContact.end() );
+ loop1.myIsBndConnected = loop2.myIsBndConnected;
+ loop2.Clear();
+ for ( size_t iE = 0; iE < loop1.myLinks.size(); ++iE )
+ myLoopOfEdge[ Index( *loop1.myLinks[ iE ] )] = & loop1;
+ }
size_t Index( const EdgePart& edge ) const { return &edge - myEdge0; }
EdgeLoop* GetLoopOf( const EdgePart* edge ) { return myLoopOfEdge[ Index( *edge )]; }
};
//================================================================================
/*!
* \brief Remove loops that are not connected to boundary edges of myFace by
- * adding edges connecting these loops to the boundary
+ * adding edges connecting these loops to the boundary.
+ * Such loops must be removed as they form polygons with ring topology.
*/
//================================================================================
while ( prevNbReached < nbReachedLoops );
- // add links connecting internal loops with the boundary ones
for ( size_t iL = 0; iL < theLoops.myNbLoops; ++iL )
{
EdgeLoop& loop = theLoops.myLoops[ iL ];
- if ( loop.myIsBndConnected )
+ if ( loop.myIsBndConnected || loop.myLinks.size() == 0 )
continue;
+ if ( loop.myHasPending )
+ {
+ // try to join the loop to another one, with which it contacts at a node
+
+ // look for a node where the loop reverses
+ const EdgePart* edgePrev = loop.myLinks.back();
+ for ( size_t iE = 0; iE < loop.myLinks.size(); edgePrev = loop.myLinks[ iE++ ] )
+ {
+ if ( !edgePrev->IsTwin( *loop.myLinks[ iE ]))
+ continue;
+ const SMDS_MeshNode* reverseNode = edgePrev->myNode2;
+
+ // look for a loop including reverseNode
+ size_t iContactEdge2; // index(+1) of edge starting at reverseNode
+ for ( size_t iL2 = 0; iL2 < theLoops.myNbLoops; ++iL2 )
+ {
+ if ( iL == iL2 )
+ continue;
+ EdgeLoop& loop2 = theLoops.myLoops[ iL2 ];
+ if ( ! ( iContactEdge2 = loop2.Contains( reverseNode )))
+ continue;
+
+ // insert loop2 into the loop
+ theLoops.Join( loop, iE, loop2, iContactEdge2 - 1 );
+ break;
+ }
+ if ( loop.myIsBndConnected )
+ break;
+ }
+
+ if ( loop.myIsBndConnected )
+ continue;
+ }
+
+ // add links connecting internal loops with the boundary ones
+
// find a pair of closest nodes
const SMDS_MeshNode *closestNode1, *closestNode2;
double minDist = 1e100;
while ( !theLoops.AllEdgesUsed() )
{
- theLoops.AddNewLoop();
+ EdgeLoop& loop = theLoops.AddNewLoop();
// add 1st edge to a new loop
size_t i1;
// choose among candidates
if ( theLoops.myCandidates.size() == 0 )
{
- theLoops.GetLoopOf( lastEdge )->myHasPending = true;
+ loop.myHasPending = bool( twinEdge );
lastEdge = twinEdge;
}
else if ( theLoops.myCandidates.size() == 1 )
}
while ( lastNode != firstNode );
+
+ if ( twinEdge == & myLinks[ i1 ])
+ loop.myHasPending = true;
+
} // while ( !theLoops.AllEdgesUsed() )
return;
int mySrcPntInd; //!< start point index
TIDSortedElemSet myElemSet, myAvoidSet;
- Path(): myLength(0.0), myFace(0) {}
+ Path(const SMDS_MeshElement* face=0, int srcInd=-1):
+ myLength(0.0), myFace(face), mySrcPntInd( srcInd ) {}
+
+ void CopyNoPoints( const Path& other );
+
+ bool Extend( const gp_XYZ& plnNorm, const gp_XYZ& plnOrig, std::vector< Path > * paths = 0 );
+
+ bool SetCutAtCorner( const SMESH_NodeXYZ& cornerNode,
+ const gp_XYZ& plnNorm,
+ const gp_XYZ& plnOrig,
+ std::vector< Path >* paths);
bool SetCutAtCorner( const SMESH_NodeXYZ& cornerNode,
const SMDS_MeshElement* face,
void AddPoint( const gp_XYZ& p );
- bool Extend( const gp_XYZ& plnNorm, const gp_XYZ& plnOrig );
-
bool ReachSamePoint( const Path& other );
static void Remove( std::vector< Path > & paths, size_t& i );
myFace == other.myFace );
}
+ //================================================================================
+ /*!
+ * \brief Copy data except points
+ */
+ //================================================================================
+
+ void Path::CopyNoPoints( const Path& other )
+ {
+ myLength = other.myLength;
+ mySrcPntInd = other.mySrcPntInd;
+ myFace = other.myFace;
+ myNode1 = other.myNode1;
+ myNode2 = other.myNode2;
+ myNodeInd1 = other.myNodeInd1;
+ myNodeInd2 = other.myNodeInd2;
+ myDot1 = other.myDot1;
+ myDot2 = other.myDot2;
+ }
+
//================================================================================
/*!
* \brief Remove a path from a vector
size_t j = paths.size() - 1; // last item to be removed
if ( i < j )
{
+ paths[ i ].CopyNoPoints ( paths[ j ]);
paths[ i ].myPoints.swap( paths[ j ].myPoints );
- paths[ i ].myLength = paths[ j ].myLength;
- paths[ i ].mySrcPntInd = paths[ j ].mySrcPntInd;
- paths[ i ].myFace = paths[ j ].myFace;
- paths[ i ].myNode1 = paths[ j ].myNode1;
- paths[ i ].myNode2 = paths[ j ].myNode2;
- paths[ i ].myNodeInd1 = paths[ j ].myNodeInd1;
- paths[ i ].myNodeInd2 = paths[ j ].myNodeInd2;
- paths[ i ].myDot1 = paths[ j ].myDot1;
- paths[ i ].myDot2 = paths[ j ].myDot2;
}
}
paths.pop_back();
--i;
}
+ //================================================================================
+ /*!
+ * \brief Try to extend self by a point located at a node.
+ * Return a success flag.
+ */
+ //================================================================================
+
+ bool Path::SetCutAtCorner( const SMESH_NodeXYZ& cornerNode,
+ const gp_XYZ& plnNorm,
+ const gp_XYZ& plnOrig,
+ std::vector< Path > * paths )
+ {
+ bool ok = false;
+ const bool isContinuation = myFace; // extend this path or find all possible paths?
+ const SMDS_MeshElement* lastFace = myFace;
+
+ myAvoidSet.clear();
+
+ SMDS_ElemIteratorPtr fIt = cornerNode->GetInverseElementIterator(SMDSAbs_Face);
+ while ( fIt->more() )
+ {
+ Path path( lastFace, mySrcPntInd );
+ if ( !path.SetCutAtCorner( cornerNode, fIt->next(), plnNorm, plnOrig ))
+ continue;
+
+ if ( !myAvoidSet.insert( path.myNode1.Node() ).second ||
+ !myAvoidSet.insert( path.myNode2.Node() ).second )
+ continue;
+
+ if ( isContinuation )
+ {
+ if ( ok ) // non-manifold continuation
+ {
+ path.myPoints = myPoints;
+ path.myLength = myLength;
+ path.AddPoint( cornerNode );
+ paths->push_back( path );
+ }
+ else
+ {
+ double len = myLength;
+ this->CopyNoPoints( path );
+ this->myLength = len;
+ this->AddPoint( path.myPoints.back() );
+ }
+ }
+ else
+ {
+ paths->push_back( path );
+ }
+ ok = true;
+ }
+
+ return ok;
+ }
+
//================================================================================
/*!
* \brief Store a point that is at a node of a face if the face is intersected by plane.
* \brief Try to find the next point
* \param [in] plnNorm - cutting plane normal
* \param [in] plnOrig - cutting plane origin
+ * \param [in] paths - all paths
*/
//================================================================================
- bool Path::Extend( const gp_XYZ& plnNorm, const gp_XYZ& plnOrig )
+ bool Path::Extend( const gp_XYZ& plnNorm, const gp_XYZ& plnOrig, std::vector< Path > * paths )
{
+ bool ok = false;
+
int nodeInd3 = ( myNodeInd1 + 1 ) % myFace->NbCornerNodes();
if ( myNodeInd2 == nodeInd3 )
nodeInd3 = ( myNodeInd1 + 2 ) % myFace->NbCornerNodes();
}
else if ( dot3 == 0. )
{
- SMDS_ElemIteratorPtr fIt = node3._node->GetInverseElementIterator(SMDSAbs_Face);
- while ( fIt->more() )
- if ( SetCutAtCorner( node3, fIt->next(), plnNorm, plnOrig ))
- return true;
- return false;
+ ok = SetCutAtCorner( node3, plnNorm, plnOrig, paths );
+ return ok;
}
else if ( myDot2 == 0. )
{
- SMESH_NodeXYZ node2 = myNode2; // copy as myNode2 changes in SetCutAtCorner()
- SMDS_ElemIteratorPtr fIt = node2._node->GetInverseElementIterator(SMDSAbs_Face);
- while ( fIt->more() )
- if ( SetCutAtCorner( node2, fIt->next(), plnNorm, plnOrig ))
- return true;
- return false;
+ ok = SetCutAtCorner( myNode2, plnNorm, plnOrig, paths );
+ return ok;
}
double r = Abs( myDot1 / ( myDot2 - myDot1 ));
myAvoidSet.clear();
myAvoidSet.insert( myFace );
- myFace = SMESH_MeshAlgos::FindFaceInSet( myNode1._node, myNode2._node,
- myElemSet, myAvoidSet,
- &myNodeInd1, &myNodeInd2 );
- return myFace;
+ const SMDS_MeshElement* nextFace;
+ int ind1, ind2;
+ while (( nextFace = SMESH_MeshAlgos::FindFaceInSet( myNode1._node, myNode2._node,
+ myElemSet, myAvoidSet,
+ &ind1, &ind2 )))
+ {
+ if ( ok ) // non-manifold continuation
+ {
+ paths->push_back( *this );
+ paths->back().myFace = nextFace;
+ paths->back().myNodeInd1 = ind1;
+ paths->back().myNodeInd2 = ind2;
+ }
+ else
+ {
+ myFace = nextFace;
+ myNodeInd1 = ind1;
+ myNodeInd2 = ind2;
+ }
+ ok = true;
+ if ( !paths )
+ break;
+ myAvoidSet.insert( nextFace );
+ }
+
+ return ok;
}
//================================================================================
{
SMESH_MeshAlgos::PolySegment& polySeg = mySegments[ iSeg ];
+ if ( ( polySeg.myXYZ[0] - polySeg.myXYZ[1] ).SquareModulus() == 0 )
+ {
+ myPaths[ iSeg ].AddPoint( polySeg.myXYZ[0] );
+ myPaths[ iSeg ].AddPoint( polySeg.myXYZ[1] );
+ return;
+ }
+
// the cutting plane
gp_XYZ plnNorm = ( polySeg.myXYZ[0] - polySeg.myXYZ[1] ) ^ polySeg.myVector.XYZ();
gp_XYZ plnOrig = polySeg.myXYZ[1];
for ( int iP = 0; iP < 2; ++iP ) // loop on the polySeg end points
{
- Path path;
- path.mySrcPntInd = iP;
+ Path path( 0, iP );
size_t nbPaths = paths.size();
if ( polySeg.myFace[ iP ]) // the end point lies on polySeg.myFace[ iP ]
{
// check coincidence of polySeg.myXYZ[ iP ] with nodes
- const double tol = 1e-20;
+ const double tol = 1e-17;
SMESH_NodeXYZ nodes[4];
for ( int i = 0; i < 3 && !polySeg.myNode1[ iP ]; ++i )
{
}
nodes[ 3 ] = nodes[ 0 ];
+ double dot[ 4 ];
+ for ( int i = 0; i < 3; ++i )
+ dot[ i ] = plnNorm * ( nodes[ i ] - plnOrig );
+ dot[ 3 ] = dot[ 0 ];
+
// check coincidence of polySeg.myXYZ[ iP ] with edges
for ( int i = 0; i < 3 && !polySeg.myNode1[ iP ]; ++i )
{
{
polySeg.myNode1[ iP ] = nodes[ i ].Node();
polySeg.myNode2[ iP ] = nodes[ i + 1 ].Node();
+
+ int i3 = ( i + 2 ) % 3;
+ if ( dot[ i ] * dot [ i3 ] > 0 &&
+ dot[ i+1 ] * dot [ i3 ] > 0 ) // point iP is inside a neighbor triangle
+ {
+ path.myAvoidSet.insert( polySeg.myFace[ iP ]);
+ const SMDS_MeshElement* face2 =
+ SMESH_MeshAlgos::FindFaceInSet( polySeg.myNode1[ iP ],
+ polySeg.myNode2[ iP ],
+ path.myElemSet,
+ path.myAvoidSet );
+ if ( face2 )
+ polySeg.myFace[ iP ] = face2;
+ else
+ ;// ??
+ for ( int i = 0; i < 3; ++i )
+ {
+ nodes[ i ] = polySeg.myFace[ iP ]->GetNode( i );
+ dot[ i ] = plnNorm * ( nodes[ i ] - plnOrig );
+ }
+ dot[ 3 ] = dot[ 0 ];
+ polySeg.myNode1[ iP ] = polySeg.myNode2[ iP ] = 0;
+ break;
+ }
}
}
if ( !polySeg.myNode1[ iP ] ) // polySeg.myXYZ[ iP ] is within polySeg.myFace[ iP ]
{
- double dot[ 4 ];
- for ( int i = 0; i < 3; ++i )
- dot[ i ] = plnNorm * ( nodes[ i ] - plnOrig );
- dot[ 3 ] = dot[ 0 ];
-
int iCut = 0; // index of a cut edge
if ( dot[ 1 ] * dot[ 2 ] < 0. ) iCut = 1;
else if ( dot[ 2 ] * dot[ 3 ] < 0. ) iCut = 2;
path.AddPoint( polySeg.myXYZ[ iP ]);
path.myAvoidSet.insert( path.myFace );
paths.push_back( path );
+ std::swap( polySeg.myNode1[ iP ], polySeg.myNode2[ iP ]);
}
if ( nbPaths == paths.size() )
throw SALOME_Exception ( SMESH_Comment("No face edge found by point ") << iP+1
<< " in a PolySegment " << iSeg );
- }
- else if ( polySeg.myNode1[ iP ] ) // the end point is at a node
- {
- std::set<const SMDS_MeshNode* > nodes;
- SMDS_ElemIteratorPtr fIt = polySeg.myNode1[ iP ]->GetInverseElementIterator(SMDSAbs_Face);
- while ( fIt->more() )
+
+ if ( path.myDot1 == 0. &&
+ path.myDot2 == 0. &&
+ paths.size() - nbPaths >= 2 ) // use a face non-parallel to the plane
{
- path.myPoints.clear();
- if ( path.SetCutAtCorner( polySeg.myNode1[ iP ], fIt->next(), plnNorm, plnOrig ))
+ const SMDS_MeshElement* goodFace = 0;
+ for ( size_t j = nbPaths; j < paths.size(); ++j )
{
- if (( path.myDot1 * path.myDot2 != 0 ) ||
- ( nodes.insert( path.myDot1 == 0 ? path.myNode1._node : path.myNode2._node ).second ))
- paths.push_back( path );
+ path = paths[j];
+ if ( path.Extend( plnNorm, plnOrig ))
+ goodFace = paths[j].myFace;
+ else
+ paths[j].myFace = 0;
}
+ if ( !goodFace )
+ throw SALOME_Exception ( SMESH_Comment("Cant move from point ") << iP+1
+ << " of a PolySegment " << iSeg );
+ for ( size_t j = nbPaths; j < paths.size(); ++j )
+ if ( !paths[j].myFace )
+ {
+ paths[j].myFace = goodFace;
+ paths[j].myNodeInd1 = goodFace->GetNodeIndex( paths[j].myNode1.Node() );
+ paths[j].myNodeInd2 = goodFace->GetNodeIndex( paths[j].myNode2.Node() );
+ }
}
}
+ else if ( polySeg.myNode1[ iP ] ) // the end point is at a node
+ {
+ path.myFace = 0;
+ path.SetCutAtCorner( polySeg.myNode1[ iP ], plnNorm, plnOrig, &paths );
+ }
+
+
// look for a one-segment path
for ( size_t i = 0; i < nbPaths; ++i )
for ( size_t j = nbPaths; j < paths.size(); ++j )
myPaths[ iSeg ].myPoints.push_back( paths[j].myPoints[0] );
paths.clear();
}
- }
+
+ } // loop on the polySeg end points to initialize all possible paths
+
// 2) extend paths and compose the shortest one connecting the two points
for ( size_t i = 0; i < paths.size(); ++i )
{
Path& path = paths[ i ];
- if ( !path.Extend( plnNorm, plnOrig ) || // path reached a mesh boundary
- path.myLength > myPaths[ iSeg ].myLength ) // path is longer than others
+ if ( !path.Extend( plnNorm, plnOrig, &paths ) || // path reached a mesh boundary
+ path.myLength > myPaths[ iSeg ].myLength ) // path is longer than others
{
Path::Remove( paths, i );
continue;
paths[j].myPoints.rbegin(),
paths[j].myPoints.rend() );
}
+ if ( i < j ) std::swap( i, j );
Path::Remove( paths, i );
Path::Remove( paths, j );
+ break;
}
}
}
gp_XYZ plnNorm = ( p1 - p2 ) ^ polySeg.myVector.XYZ();
isVectorOK[ iSeg ] = ( plnNorm.Modulus() > std::numeric_limits<double>::min() );
- if ( !isVectorOK[ iSeg ])
+ if ( !isVectorOK[ iSeg ] && ( p1 - p2 ).SquareModulus() > 0. )
{
gp_XYZ pMid = 0.5 * ( p1 + p2 );
const SMDS_MeshElement* face;
polySeg.myVector = polySeg.myMidProjPoint.XYZ() - pMid;
gp_XYZ faceNorm;
- SMESH_MeshAlgos::FaceNormal( face, faceNorm );
+ SMESH_MeshAlgos::FaceNormal( face, faceNorm, /*normalized=*/false );
- if ( polySeg.myVector.Magnitude() < Precision::Confusion() ||
- polySeg.myVector * faceNorm < Precision::Confusion() )
+ const double tol = Precision::Confusion();
+ if ( polySeg.myVector.Magnitude() < tol || polySeg.myVector * faceNorm < tol )
{
polySeg.myVector = faceNorm;
polySeg.myMidProjPoint = pMid + faceNorm * ( p1 - p2 ).Modulus() * planarCoef;
}
+ plnNorm = ( p1 - p2 ) ^ polySeg.myVector.XYZ();
+ if ( plnNorm.SquareModulus() == 0 ) // p1-p2 perpendicular to mesh
+ {
+ double radius = faceNorm.Modulus();
+ std::vector< const SMDS_MeshElement* > foundElems;
+ while ( plnNorm.SquareModulus() == 0 && radius < 1e200 )
+ {
+ foundElems.clear();
+ searcher->GetElementsInSphere( p1, radius, SMDSAbs_Face, foundElems );
+ searcher->GetElementsInSphere( p2, radius, SMDSAbs_Face, foundElems );
+ radius *= 2;
+ polySeg.myVector.SetCoord( 0,0,0 );
+ for ( size_t i = 0; i < foundElems.size(); ++i )
+ {
+ SMESH_MeshAlgos::FaceNormal( foundElems[i], faceNorm );
+ polySeg.myVector += faceNorm / foundElems.size();
+ }
+ plnNorm = ( p1 - p2 ) ^ polySeg.myVector.XYZ();
+ }
+ }
+
}
else
{
}
bool operator<(const Node& other) const { return _triaIndex < other._triaIndex; }
};
- typedef boost::container::flat_set< Node > TNodeSet;
+ typedef boost::container::flat_set< Node > TriaNodeSet;
}
+/*!
+ * \brief Vertex of a polygon. Together with 2 neighbor Vertices represents a triangle
+ */
+struct Triangulate::PolyVertex
+{
+ SMESH_NodeXYZ _nxyz;
+ size_t _index;
+ gp_XY _xy;
+ PolyVertex* _prev;
+ PolyVertex* _next;
+
+ void SetNodeAndNext( const SMDS_MeshNode* n, PolyVertex& v, size_t index );
+ void GetTriaNodes( const SMDS_MeshNode** nodes, size_t* nodeIndices) const;
+ double TriaArea() const;
+ bool IsInsideTria( const PolyVertex* v );
+ PolyVertex* Delete();
+
+ struct Compare // compare PolyVertex'es by node
+ {
+ bool operator()(const PolyVertex* a, const PolyVertex* b) const
+ {
+ return ( a->_nxyz.Node() < b->_nxyz.Node() );
+ }
+ };
+ // set of PolyVertex sorted by mesh node
+ typedef boost::container::flat_set< PolyVertex*, Compare > PVSet;
+};
+
+struct Triangulate::Data
+{
+ std::vector< PolyVertex > _pv;
+ std::vector< size_t > _nodeIndex;
+ PolyVertex::PVSet _uniqueNodePV;
+};
struct Triangulate::Optimizer
{
- std::vector< TNodeSet > _nodeUsage; // inclusions of a node in triangles
+ std::vector< TriaNodeSet > _nodeUsage; // inclusions of a node in triangles
//================================================================================
/*!
size_t i2 = iTria + ( i + 1 ) % 3;
size_t ind1 = nodeIndices[ i1 ]; // node index in points
size_t ind2 = nodeIndices[ i2 ];
- TNodeSet & usage1 = _nodeUsage[ ind1 ]; // triangles using a node
- TNodeSet & usage2 = _nodeUsage[ ind2 ];
+ TriaNodeSet & usage1 = _nodeUsage[ ind1 ]; // triangles using a node
+ TriaNodeSet & usage2 = _nodeUsage[ ind2 ];
if ( usage1.size() < 2 ||
usage2.size() < 2 )
continue;
// look for another triangle using two nodes
- TNodeSet::iterator usIt1 = usage1.begin();
+ TriaNodeSet::iterator usIt1 = usage1.begin();
for ( ; usIt1 != usage1.end(); ++usIt1 )
{
if ( usIt1->_triaIndex == iTria )
continue; // current triangle
- TNodeSet::iterator usIt2 = usage2.find( *usIt1 );
+ TriaNodeSet::iterator usIt2 = usage2.find( *usIt1 );
if ( usIt2 == usage2.end() )
continue; // no common _triaIndex in two usages
// swap edge by modifying nodeIndices
nodeIndices[ i2 ] = ind4;
- _nodeUsage[ ind2 ].erase ({ iTria, i2 - iTria });
_nodeUsage[ ind4 ].insert({ iTria, i2 - iTria });
+ _nodeUsage[ ind2 ].erase ({ iTria, i2 - iTria });
i1 = usIt1->Index();
nodeIndices[ i1 ] = ind3;
- _nodeUsage[ ind1 ].erase ( *usIt1 );
_nodeUsage[ ind3 ].insert( *usIt1 );
+ _nodeUsage[ ind1 ].erase ( *usIt1 );
--i; // to re-check a current edge
badness1 = badness3;
std::vector< PolyVertex > & points,
bool checkArea = false )
{
- //if ( checkArea )
+ if ( checkArea )
{
points[ i2 ]._prev = & points[ i1 ];
points[ i2 ]._next = & points[ i3 ];
double a = points[ i2 ].TriaArea();
- if ( a < 0 )
- return std::numeric_limits<double>::max();
- return 1. / a;
+ // if ( a < 0 )
+ // return std::numeric_limits<double>::max();
+ // return 1. / a;
- if ( points[ i2 ].TriaArea() < 0 )
+ if ( a < 0 )
return 2;
}
const gp_XY & p1 = points[ i1 ]._xy;
bool Triangulate::triangulate( std::vector< const SMDS_MeshNode*>& nodes,
const size_t nbNodes)
{
+ std::vector< PolyVertex >& _pv = _data->_pv;
+ std::vector< size_t >& _nodeIndex = _data->_nodeIndex;
+ PolyVertex::PVSet& _uniqueNodePV = _data->_uniqueNodePV;
+
// connect nodes into a ring
_pv.resize( nbNodes );
for ( size_t i = 1; i < nbNodes; ++i )
_pv[i-1].SetNodeAndNext( nodes[i-1], _pv[i], i-1 );
_pv[ nbNodes-1 ].SetNodeAndNext( nodes[ nbNodes-1 ], _pv[0], nbNodes-1 );
+ // assure correctness of PolyVertex::_index as a node can encounter more than once
+ // within a polygon boundary
+ if ( _optimizer && nbNodes > 4 )
+ {
+ _uniqueNodePV.clear();
+ for ( size_t i = 0; i < nbNodes; ++i )
+ {
+ PolyVertex::PVSet::iterator pv = _uniqueNodePV.insert( &_pv[i] ).first;
+ _pv[i]._index = (*pv)->_index;
+ }
+ }
+
// get a polygon normal
gp_XYZ normal(0,0,0), p0,v01,v02;
p0 = _pv[0]._nxyz;
_pv[i]._xy.SetY( axes.YDirection().XYZ() * p );
}
+ // compute minimal triangle area
+ double sumArea = 0;
+ for ( size_t i = 0; i < nbNodes; ++i )
+ sumArea += _pv[i].TriaArea();
+ const double minArea = 1e-6 * sumArea / ( nbNodes - 2 );
+
// in a loop, find triangles with positive area and having no vertices inside
int iN = 0, nbTria = nbNodes - 2;
nodes.resize( nbTria * 3 );
_nodeIndex.resize( nbTria * 3 );
- const double minArea = 1e-6;
PolyVertex* v = &_pv[0], *vi;
int nbVertices = nbNodes, nbBadTria = 0, isGoodTria;
while ( nbBadTria < nbVertices )
Triangulate::Triangulate( bool optimize ): _optimizer(0)
{
+ _data = new Data;
if ( optimize )
_optimizer = new Optimizer;
}
Triangulate::~Triangulate()
{
+ delete _data;
delete _optimizer;
_optimizer = 0;
}
void SMESH_Gen_i::CancelCompute( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theShapeObject )
{
- SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() );
- ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
- TopoDS_Shape myLocShape;
- if(theMesh->HasShapeToMesh())
- myLocShape = GeomObjectToShape( theShapeObject );
- else
- myLocShape = SMESH_Mesh::PseudoShape();
- myGen.CancelCompute( myLocMesh, myLocShape);
+ if ( SMESH_Mesh_i* meshServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( theMesh ).in() ))
+ {
+ ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
+ TopoDS_Shape myLocShape;
+ if(theMesh->HasShapeToMesh())
+ myLocShape = GeomObjectToShape( theShapeObject );
+ else
+ myLocShape = SMESH_Mesh::PseudoShape();
+ myGen.CancelCompute( myLocMesh, myLocShape);
+ }
}
//=============================================================================
SubMeshOrGroup = [ obj.GetMesh() ]
break
if isinstance( obj, int ):
- SubMeshOrGroup = self.GetIDSource( SubMeshOrGroup, SMESH.NODE )
+ SubMeshOrGroup = [ self.GetIDSource( SubMeshOrGroup, SMESH.NODE )]
unRegister.set( SubMeshOrGroup )
break
if ( !projDone || is1DComputed )
// ----------------------------------------------------------------
// The mapper can create distorted faces by placing nodes out of the FACE
- // boundary, also bad face can be created if EDGEs already discretized
+ // boundary, also bad faces can be created if EDGEs already discretized
// --> fix bad faces by smoothing
// ----------------------------------------------------------------
if ( helper.IsDistorted2D( tgtSubMesh, /*checkUV=*/false, &helper ))
