+ // loop on nodes of an edge: sort them by param on edge
+ SMDS_NodeIteratorPtr nIt = eSubMesh->GetNodes();
+ while ( nIt->more() )
+ {
+ const SMDS_MeshNode* node = nIt->next();
+ const SMDS_PositionPtr& pos = node->GetPosition();
+ if ( pos->GetTypeOfPosition() != SMDS_TOP_EDGE )
+ return false;
+ const SMDS_EdgePosition* epos =
+ static_cast<const SMDS_EdgePosition*>(node->GetPosition());
+ if ( !paramSet.insert( epos->GetUParameter() ).second )
+ return false; // equal parameters
+ }
+ }
+ // add vertex nodes params
+ TopoDS_Vertex V1,V2;
+ TopExp::Vertices( theEdge, V1, V2);
+ if ( VertexNode( V1, theMesh ) &&
+ !paramSet.insert( BRep_Tool::Parameter(V1,theEdge) ).second )
+ return false; // there are equal parameters
+ if ( VertexNode( V2, theMesh ) &&
+ !paramSet.insert( BRep_Tool::Parameter(V2,theEdge) ).second )
+ return false; // there are equal parameters
+
+ // fill the vector
+ theParams.resize( paramSet.size() );
+ set < double >::iterator par = paramSet.begin();
+ vector< double >::iterator vecPar = theParams.begin();
+ for ( ; par != paramSet.end(); ++par, ++vecPar )
+ *vecPar = *par;
+
+ return theParams.size() > 1;
+}
+
+//================================================================================
+/*!
+ * \brief Fill vector of node parameters on geometrical edge, including vertex nodes
+ * \param theMesh - The mesh containing nodes
+ * \param theEdge - The geometrical edge of interest
+ * \param theParams - The resulting vector of sorted node parameters
+ * \retval bool - false if not all parameters are OK
+ */
+//================================================================================
+
+bool SMESH_Algo::GetSortedNodesOnEdge(const SMESHDS_Mesh* theMesh,
+ const TopoDS_Edge& theEdge,
+ const bool ignoreMediumNodes,
+ map< double, const SMDS_MeshNode* > & theNodes,
+ const SMDSAbs_ElementType typeToCheck)
+{
+ theNodes.clear();
+
+ if ( !theMesh || theEdge.IsNull() )
+ return false;
+
+ SMESHDS_SubMesh * eSubMesh = theMesh->MeshElements( theEdge );
+ if ( !eSubMesh || ( eSubMesh->NbElements() == 0 && eSubMesh->NbNodes() == 0))
+ return false; // edge is not meshed
+
+ int nbNodes = 0;
+ set < double > paramSet;
+ if ( eSubMesh )
+ {
+ // loop on nodes of an edge: sort them by param on edge
+ SMDS_NodeIteratorPtr nIt = eSubMesh->GetNodes();
+ while ( nIt->more() )
+ {
+ const SMDS_MeshNode* node = nIt->next();
+ if ( ignoreMediumNodes && SMESH_MesherHelper::IsMedium( node, typeToCheck ))
+ continue;
+ const SMDS_PositionPtr& pos = node->GetPosition();
+ if ( pos->GetTypeOfPosition() != SMDS_TOP_EDGE )
+ return false;
+ const SMDS_EdgePosition* epos =
+ static_cast<const SMDS_EdgePosition*>(node->GetPosition());
+ theNodes.insert( theNodes.end(), make_pair( epos->GetUParameter(), node ));
+ ++nbNodes;
+ }
+ }
+ // add vertex nodes
+ TopoDS_Vertex v1, v2;
+ TopExp::Vertices(theEdge, v1, v2);
+ const SMDS_MeshNode* n1 = VertexNode( v1, eSubMesh, 0 );
+ const SMDS_MeshNode* n2 = VertexNode( v2, eSubMesh, 0 );
+ const SMDS_MeshNode* nEnd[2] = { nbNodes ? theNodes.begin()->second : 0,
+ nbNodes ? theNodes.rbegin()->second : 0 };
+ Standard_Real f, l;
+ BRep_Tool::Range(theEdge, f, l);
+ if ( v1.Orientation() != TopAbs_FORWARD )
+ std::swap( f, l );
+ if ( n1 && n1 != nEnd[0] && n1 != nEnd[1] && ++nbNodes )
+ theNodes.insert( make_pair( f, n1 ));
+ if ( n2 && n2 != nEnd[0] && n2 != nEnd[1] && ++nbNodes )
+ theNodes.insert( make_pair( l, n2 ));
+
+ return (int)theNodes.size() == nbNodes;
+}
+
+//================================================================================
+/*!
+ * \brief Returns the filter recognizing only compatible hypotheses
+ * \param ignoreAuxiliary - make filter ignore auxiliary hypotheses
+ * \retval SMESH_HypoFilter* - the filter that can be NULL
+ */
+//================================================================================
+
+const SMESH_HypoFilter*
+SMESH_Algo::GetCompatibleHypoFilter(const bool ignoreAuxiliary) const
+{
+ if ( !_compatibleHypothesis.empty() )
+ {
+ if ( !_compatibleAllHypFilter )
+ {
+ SMESH_HypoFilter* filter = new SMESH_HypoFilter();
+ filter->Init( filter->HasName( _compatibleHypothesis[0] ));
+ for ( size_t i = 1; i < _compatibleHypothesis.size(); ++i )
+ filter->Or( filter->HasName( _compatibleHypothesis[ i ] ));
+
+ SMESH_HypoFilter* filterNoAux = new SMESH_HypoFilter( filter );
+ filterNoAux->AndNot( filterNoAux->IsAuxiliary() );
+
+ // _compatibleNoAuxHypFilter will detele _compatibleAllHypFilter!!!
+ SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
+ me->_compatibleAllHypFilter = filter;
+ me->_compatibleNoAuxHypFilter = filterNoAux;
+ }
+ return ignoreAuxiliary ? _compatibleNoAuxHypFilter : _compatibleAllHypFilter;
+ }
+ return 0;
+}
+
+//================================================================================
+/*!
+ * \brief Return continuity of two edges
+ * \param E1 - the 1st edge
+ * \param E2 - the 2nd edge
+ * \retval GeomAbs_Shape - regularity at the junction between E1 and E2
+ */
+//================================================================================
+
+GeomAbs_Shape SMESH_Algo::Continuity(const TopoDS_Edge& theE1,
+ const TopoDS_Edge& theE2)
+{
+ // avoid pb with internal edges
+ TopoDS_Edge E1 = theE1, E2 = theE2;
+ if (E1.Orientation() > TopAbs_REVERSED) // INTERNAL
+ E1.Orientation( TopAbs_FORWARD );
+ if (E2.Orientation() > TopAbs_REVERSED) // INTERNAL
+ E2.Orientation( TopAbs_FORWARD );
+
+ TopoDS_Vertex V, VV1[2], VV2[2];
+ TopExp::Vertices( E1, VV1[0], VV1[1], true );
+ TopExp::Vertices( E2, VV2[0], VV2[1], true );
+ if ( VV1[1].IsSame( VV2[0] )) { V = VV1[1]; }
+ else if ( VV1[0].IsSame( VV2[1] )) { V = VV1[0]; }
+ else if ( VV1[1].IsSame( VV2[1] )) { V = VV1[1]; E1.Reverse(); }
+ else if ( VV1[0].IsSame( VV2[0] )) { V = VV1[0]; E1.Reverse(); }
+ else { return GeomAbs_C0; }
+
+ Standard_Real u1 = BRep_Tool::Parameter( V, E1 );
+ Standard_Real u2 = BRep_Tool::Parameter( V, E2 );
+ BRepAdaptor_Curve C1( E1 ), C2( E2 );
+ Standard_Real tol = BRep_Tool::Tolerance( V );
+ Standard_Real angTol = 2e-3;
+ try {
+ OCC_CATCH_SIGNALS;
+ return BRepLProp::Continuity(C1, C2, u1, u2, tol, angTol);
+ }
+ catch (Standard_Failure) {
+ }
+ return GeomAbs_C0;
+}
+
+//================================================================================
+/*!
+ * \brief Return true if an edge can be considered straight
+ */
+//================================================================================
+
+bool SMESH_Algo::IsStraight( const TopoDS_Edge & E,
+ const bool degenResult)
+{
+ {
+ double f,l;
+ if ( BRep_Tool::Curve( E, f, l ).IsNull())
+ return degenResult;
+ }
+ BRepAdaptor_Curve curve( E );
+ switch( curve.GetType() )
+ {
+ case GeomAbs_Line:
+ return true;
+ case GeomAbs_Circle:
+ case GeomAbs_Ellipse:
+ case GeomAbs_Hyperbola:
+ case GeomAbs_Parabola:
+ return false;
+ // case GeomAbs_BezierCurve:
+ // case GeomAbs_BSplineCurve:
+ // case GeomAbs_OtherCurve:
+ default:;
+ }
+ const double f = curve.FirstParameter();
+ const double l = curve.LastParameter();
+ const gp_Pnt pf = curve.Value( f );
+ const gp_Pnt pl = curve.Value( l );
+ const gp_Vec v1( pf, pl );
+ const double v1Len = v1.Magnitude();
+ if ( v1Len < std::numeric_limits< double >::min() )
+ return false; // E seems closed
+ const double tol = Min( 10 * curve.Tolerance(), v1Len * 1e-2 );
+ const double nbSamples = 7;
+ for ( int i = 0; i < nbSamples; ++i )
+ {
+ const double r = ( i + 1 ) / nbSamples;
+ const gp_Pnt pi = curve.Value( f * r + l * ( 1 - r ));
+ const gp_Vec vi( pf, pi );
+ const double h = 0.5 * v1.Crossed( vi ).Magnitude() / v1Len;
+ if ( h > tol )
+ return false;
+ }
+ return true;
+}
+
+//================================================================================
+/*!
+ * \brief Return true if an edge has no 3D curve
+ */
+//================================================================================
+
+bool SMESH_Algo::isDegenerated( const TopoDS_Edge & E, const bool checkLength )
+{
+ if ( checkLength )
+ return EdgeLength( E ) == 0;
+ double f,l;
+ TopLoc_Location loc;
+ Handle(Geom_Curve) C = BRep_Tool::Curve( E, loc, f,l );
+ return C.IsNull();
+}
+
+//================================================================================
+/*!
+ * \brief Return the node built on a vertex
+ * \param V - the vertex
+ * \param meshDS - mesh
+ * \retval const SMDS_MeshNode* - found node or NULL
+ * \sa SMESH_MesherHelper::GetSubShapeByNode( const SMDS_MeshNode*, SMESHDS_Mesh* )
+ */
+//================================================================================
+
+const SMDS_MeshNode* SMESH_Algo::VertexNode(const TopoDS_Vertex& V,
+ const SMESHDS_Mesh* meshDS)
+{
+ if ( SMESHDS_SubMesh* sm = meshDS->MeshElements(V) ) {
+ SMDS_NodeIteratorPtr nIt= sm->GetNodes();
+ if (nIt->more())
+ return nIt->next();
+ }
+ return 0;
+}
+
+//=======================================================================
+/*!
+ * \brief Return the node built on a vertex.
+ * A node moved to other geometry by MergeNodes() is also returned.
+ * \param V - the vertex
+ * \param mesh - mesh
+ * \retval const SMDS_MeshNode* - found node or NULL
+ */
+//=======================================================================
+
+const SMDS_MeshNode* SMESH_Algo::VertexNode(const TopoDS_Vertex& V,
+ const SMESH_Mesh* mesh)
+{
+ const SMDS_MeshNode* node = VertexNode( V, mesh->GetMeshDS() );
+
+ if ( !node && mesh->HasModificationsToDiscard() )
+ {
+ PShapeIteratorPtr edgeIt = SMESH_MesherHelper::GetAncestors( V, *mesh, TopAbs_EDGE );
+ while ( const TopoDS_Shape* edge = edgeIt->next() )
+ if ( SMESHDS_SubMesh* edgeSM = mesh->GetMeshDS()->MeshElements( *edge ))
+ if ( edgeSM->NbElements() > 0 )
+ return VertexNode( V, edgeSM, mesh, /*checkV=*/false );
+ }
+ return node;
+}
+
+//=======================================================================
+/*!
+ * \brief Return the node built on a vertex.
+ * A node moved to other geometry by MergeNodes() is also returned.
+ * \param V - the vertex
+ * \param edgeSM - sub-mesh of a meshed EDGE sharing the vertex
+ * \param checkV - if \c true, presence of a node on the vertex is checked
+ * \retval const SMDS_MeshNode* - found node or NULL
+ */
+//=======================================================================
+
+const SMDS_MeshNode* SMESH_Algo::VertexNode(const TopoDS_Vertex& V,
+ const SMESHDS_SubMesh* edgeSM,
+ const SMESH_Mesh* mesh,
+ const bool checkV)
+{
+ const SMDS_MeshNode* node = checkV ? VertexNode( V, edgeSM->GetParent() ) : 0;
+
+ if ( !node && edgeSM )
+ {
+ // find nodes not shared by mesh segments
+ typedef set< const SMDS_MeshNode* > TNodeSet;
+ typedef map< const SMDS_MeshNode*, const SMDS_MeshNode* > TNodeMap;
+ TNodeMap notSharedNodes;
+ TNodeSet otherShapeNodes;
+ vector< const SMDS_MeshNode* > segNodes(3);
+ SMDS_ElemIteratorPtr segIt = edgeSM->GetElements();
+ while ( segIt->more() )
+ {
+ const SMDS_MeshElement* seg = segIt->next();
+ if ( seg->GetType() != SMDSAbs_Edge )
+ return node;
+ segNodes.assign( seg->begin_nodes(), seg->end_nodes() );
+ for ( int i = 0; i < 2; ++i )
+ {
+ const SMDS_MeshNode* n1 = segNodes[i];
+ const SMDS_MeshNode* n2 = segNodes[1-i];
+ pair<TNodeMap::iterator, bool> it2new = notSharedNodes.insert( make_pair( n1, n2 ));
+ if ( !it2new.second ) // n encounters twice
+ notSharedNodes.erase( it2new.first );
+ if ( n1->getshapeId() != edgeSM->GetID() )
+ otherShapeNodes.insert( n1 );
+ }
+ }
+ if ( otherShapeNodes.size() == 1 && notSharedNodes.empty() ) // a closed EDGE
+ return *otherShapeNodes.begin();
+
+ if ( notSharedNodes.size() == 2 ) // two end nodes found
+ {
+ SMESHDS_Mesh* meshDS = edgeSM->GetParent();
+ const TopoDS_Shape& E = meshDS->IndexToShape( edgeSM->GetID() );
+ if ( E.IsNull() || E.ShapeType() != TopAbs_EDGE )
+ return node;
+ const SMDS_MeshNode* n1 = notSharedNodes.begin ()->first;
+ const SMDS_MeshNode* n2 = notSharedNodes.rbegin()->first;
+ TopoDS_Shape S1 = SMESH_MesherHelper::GetSubShapeByNode( n1, meshDS );
+ if ( S1.ShapeType() == TopAbs_VERTEX && SMESH_MesherHelper::IsSubShape( S1, E ))
+ return n2;
+ TopoDS_Shape S2 = SMESH_MesherHelper::GetSubShapeByNode( n2, meshDS );
+ if ( S2.ShapeType() == TopAbs_VERTEX && SMESH_MesherHelper::IsSubShape( S2, E ))
+ return n1;
+ if ( edgeSM->NbElements() <= 2 || !mesh ) // one-two segments
+ {
+ gp_Pnt pV = BRep_Tool::Pnt( V );
+ double dist1 = pV.SquareDistance( SMESH_TNodeXYZ( n1 ));
+ double dist2 = pV.SquareDistance( SMESH_TNodeXYZ( n2 ));
+ return dist1 < dist2 ? n1 : n2;
+ }
+ if ( mesh )
+ {
+ SMESH_MesherHelper helper( const_cast<SMESH_Mesh&>( *mesh ));
+ const SMDS_MeshNode* n1i = notSharedNodes.begin ()->second;
+ const SMDS_MeshNode* n2i = notSharedNodes.rbegin()->second;
+ const TopoDS_Edge& edge = TopoDS::Edge( E );
+ bool posOK = true;
+ double pos1 = helper.GetNodeU( edge, n1i, n2i, &posOK );
+ double pos2 = helper.GetNodeU( edge, n2i, n1i, &posOK );
+ double posV = BRep_Tool::Parameter( V, edge );
+ if ( Abs( pos1 - posV ) < Abs( pos2 - posV )) return n1;
+ else return n2;