if ( !_edge || !seg2._edge )
return true;
+ if ( _edge->twin() == seg2._edge )
+ return true;
+
const TVDCell* cell1 = this->_edge->twin()->cell();
const TVDCell* cell2 = seg2. _edge->twin()->cell();
if ( cell1 == cell2 )
else if ( edgeMedium1->is_primary() && edgeMedium2->is_primary() )
{
if ( edgeMedium1->twin() == edgeMedium2 &&
- SMESH_MAT2d::Branch::getBndSegment( edgeMedium1 ) ==
- SMESH_MAT2d::Branch::getBndSegment( edgeMedium2 ))
+ SMESH_MAT2d::Branch::getGeomEdge( edgeMedium1 ) ==
+ SMESH_MAT2d::Branch::getGeomEdge( edgeMedium2 ))
// this is an ignored MA edge between inSegment's on one EDGE forming a convex corner
return true;
}
BranchIterator(const std::vector<const TVDEdge*> & edges, int i )
:_i( i ), _size( edges.size() ), _edges( edges )
{
- _closed = ( edges[0]->vertex1() == edges.back()->vertex0() ); // closed branch
+ _closed = ( edges[0]->vertex1() == edges.back()->vertex0() || // closed branch
+ edges[0]->vertex0() == edges.back()->vertex1() );
}
const TVDEdge* operator++() { ++_i; return edge(); }
const TVDEdge* operator--() { --_i; return edge(); }
*/
//================================================================================
- void bndSegsToMesh( const vector< BndSeg >& bndSegs )
+ void bndSegsToMesh( const vector< vector< BndSeg > >& bndSegsPerEdge )
{
#ifdef _MYDEBUG_
if ( !getenv("bndSegsToMesh")) return;
text << "from salome.smesh import smeshBuilder\n";
text << "smesh = smeshBuilder.New(salome.myStudy)\n";
text << "m=smesh.Mesh()\n";
- for ( size_t i = 0; i < bndSegs.size(); ++i )
+ for ( size_t iE = 0; iE < bndSegsPerEdge.size(); ++iE )
{
- if ( !bndSegs[i]._edge )
- text << "# " << i << " NULL edge\n";
- else if ( !bndSegs[i]._edge->vertex0() ||
- !bndSegs[i]._edge->vertex1() )
- text << "# " << i << " INFINITE edge\n";
- else if ( addedEdges.insert( bndSegs[i]._edge ).second &&
- addedEdges.insert( bndSegs[i]._edge->twin() ).second )
+ const vector< BndSeg >& bndSegs = bndSegsPerEdge[ iE ];
+ for ( size_t i = 0; i < bndSegs.size(); ++i )
{
- v2n = v2Node.insert( make_pair( bndSegs[i]._edge->vertex0(), v2Node.size() + 1 )).first;
- int n0 = v2n->second;
- if ( n0 == v2Node.size() )
- text << "n" << n0 << " = m.AddNode( "
- << bndSegs[i]._edge->vertex0()->x() / theScale[0] << ", "
- << bndSegs[i]._edge->vertex0()->y() / theScale[1] << ", 0 )\n";
-
- v2n = v2Node.insert( make_pair( bndSegs[i]._edge->vertex1(), v2Node.size() + 1 )).first;
- int n1 = v2n->second;
- if ( n1 == v2Node.size() )
- text << "n" << n1 << " = m.AddNode( "
- << bndSegs[i]._edge->vertex1()->x() / theScale[0] << ", "
- << bndSegs[i]._edge->vertex1()->y() / theScale[1] << ", 0 )\n";
-
- text << "e" << i << " = m.AddEdge([ n" << n0 << ", n" << n1 << " ])\n";
+ if ( !bndSegs[i]._edge )
+ text << "# E=" << iE << " i=" << i << " NULL edge\n";
+ else if ( !bndSegs[i]._edge->vertex0() ||
+ !bndSegs[i]._edge->vertex1() )
+ text << "# E=" << iE << " i=" << i << " INFINITE edge\n";
+ else if ( addedEdges.insert( bndSegs[i]._edge ).second &&
+ addedEdges.insert( bndSegs[i]._edge->twin() ).second )
+ {
+ v2n = v2Node.insert( make_pair( bndSegs[i]._edge->vertex0(), v2Node.size() + 1 )).first;
+ size_t n0 = v2n->second;
+ if ( n0 == v2Node.size() )
+ text << "n" << n0 << " = m.AddNode( "
+ << bndSegs[i]._edge->vertex0()->x() / theScale[0] << ", "
+ << bndSegs[i]._edge->vertex0()->y() / theScale[1] << ", 0 )\n";
+
+ v2n = v2Node.insert( make_pair( bndSegs[i]._edge->vertex1(), v2Node.size() + 1 )).first;
+ size_t n1 = v2n->second;
+ if ( n1 == v2Node.size() )
+ text << "n" << n1 << " = m.AddNode( "
+ << bndSegs[i]._edge->vertex1()->x() / theScale[0] << ", "
+ << bndSegs[i]._edge->vertex1()->y() / theScale[1] << ", 0 )\n";
+
+ text << "e" << i << " = m.AddEdge([ n" << n0 << ", n" << n1 << " ])\n";
+ }
}
}
text << "\n";
bndSegs[0].setIndexToEdge( 0 );
}
- //bndSegsToMesh( bndSegsPerEdge ); // debug: visually check found MA edges
+ bndSegsToMesh( bndSegsPerEdge ); // debug: visually check found MA edges
// Find TVDEdge's of Branches and associate them with bndSegs
{
branchID = bndSegs[i]._prev->_branchID; // with sign
}
- else if ( bndSegs[i]._edge && // 1st bndSeg of a WIRE
- bndSegs[i]._inSeg->isConnected( bndSegs[i]._edge ))
+ else if ( bndSegs[i]._edge ) // 1st bndSeg of a WIRE
{
branchEdges.resize(( branchID = branchEdges.size()) + 1 );
- if ( bndSegs[i]._inSeg->point0() == bndSegs[i]._edge->vertex1() )
- endType.insert( make_pair( bndSegs[i]._edge->vertex1(), SMESH_MAT2d::BE_ON_VERTEX ));
- else
- endType.insert( make_pair( bndSegs[i]._edge->vertex0(), SMESH_MAT2d::BE_ON_VERTEX ));
+ if ( bndSegs[i]._inSeg->isConnected( bndSegs[i]._edge ))
+ {
+ if ( bndSegs[i]._inSeg->point0() == bndSegs[i]._edge->vertex1() )
+ endType.insert( make_pair( bndSegs[i]._edge->vertex1(), SMESH_MAT2d::BE_ON_VERTEX ));
+ else
+ endType.insert( make_pair( bndSegs[i]._edge->vertex0(), SMESH_MAT2d::BE_ON_VERTEX ));
+ }
}
bndSegs[i].setBranch( branchID, bndSegsPerEdge ); // set to i-th and to the opposite bndSeg
else // bndSegs[ i ]._branchID > 0
{
dInd = +1;
- for ( edgeInd = 0; edgeInd < branchEdges[ brID ].size(); ++edgeInd )
+ for ( edgeInd = 0; edgeInd < (int)branchEdges[ brID ].size(); ++edgeInd )
if ( branchEdges[ brID ][ edgeInd ] == bndSegs[ i ]._edge )
break;
}
while ( points._params[i+1] < u ) ++i;
}
+ if ( points._params[i] == points._params[i+1] ) // coincident points at some end
+ {
+ int di = ( points._params[0] == points._params[i] ) ? +1 : -1;
+ while ( points._params[i] == points._params[i+1] )
+ i += di;
+ if ( i < 0 || i+1 >= (int)points._params.size() )
+ i = 0;
+ }
+
double edgeParam = ( u - points._params[i] ) / ( points._params[i+1] - points._params[i] );
if ( !points._maEdges[ i ].second ) // no branch at the EDGE end, look for a closest branch
{
- if ( i < points._maEdges.size() / 2 ) // near 1st point
+ if ( i < (int)points._maEdges.size() / 2 ) // near 1st point
{
- while ( i < points._maEdges.size()-1 && !points._maEdges[ i ].second )
+ while ( i < (int)points._maEdges.size()-1 && !points._maEdges[ i ].second )
++i;
edgeParam = edgeReverse;
}
return true;
}
+//================================================================================
+/*!
+ * \brief Returns a BranchPoint corresponding to a given BoundaryPoint on a geom EDGE
+ * \param [in] bp - the BoundaryPoint
+ * \param [out] p - the found BranchPoint
+ * \return bool - is OK
+ */
+//================================================================================
+
+bool SMESH_MAT2d::Boundary::getBranchPoint( const BoundaryPoint& bp,
+ BranchPoint& p ) const
+{
+ return getBranchPoint( bp._edgeIndex, bp._param, p );
+}
+
//================================================================================
/*!
* \brief Check if a given boundary segment is a null-length segment on a concave
if ( p._iEdge > _params.size()-1 )
return false;
if ( p._iEdge == _params.size()-1 )
- return u = 1.;
+ return ( u = 1. );
u = ( _params[ p._iEdge ] * ( 1 - p._edgeParam ) +
_params[ p._iEdge+1 ] * p._edgeParam );
{
// look for a VERTEX of the opposite EDGE
// iNext - next after all null-length segments
- while ( maE = ++iNext )
+ while (( maE = ++iNext ))
{
iSeg2 = getBndSegment( maE );
if ( !_boundary->isConcaveSegment( ie1, iSeg2 ))
else if ( isConcaPrev )
{
// all null-length segments passed, find their beginning
- while ( maE = iPrev.edgePrev() )
+ while (( maE = iPrev.edgePrev() ))
{
iSeg1 = getBndSegment( maE );
if ( _boundary->isConcaveSegment( edgeIDs1.back(), iSeg1 ))
BranchPoint divisionPnt;
divisionPnt._branch = this;
- for ( ++maIter, ++twIter; maIter.index() < _maEdges.size(); ++maIter, ++twIter )
+ for ( ++maIter, ++twIter; maIter.index() < (int)_maEdges.size(); ++maIter, ++twIter )
{
size_t ie1 = getGeomEdge( maIter.edge() );
size_t ie2 = getGeomEdge( twIter.edge() );