X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMESH%2FSMESH_Algo.cxx;h=38e00d29f31c52ddda862fe3069f824028b35753;hb=7868270178ffe3023bfe60b6499e906b9d812cc2;hp=7398cf856ed4199cf815b9829f71293c72c0b465;hpb=0635c9fc80f67d1e5dc0e94ec85f487286a92070;p=modules%2Fsmesh.git diff --git a/src/SMESH/SMESH_Algo.cxx b/src/SMESH/SMESH_Algo.cxx index 7398cf856..38e00d29f 100644 --- a/src/SMESH/SMESH_Algo.cxx +++ b/src/SMESH/SMESH_Algo.cxx @@ -1,41 +1,47 @@ -// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2013 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 +// 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. +// 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 // + // SMESH SMESH : implementaion of SMESH idl descriptions // File : SMESH_Algo.cxx // Author : Paul RASCLE, EDF // Module : SMESH -// #include "SMESH_Algo.hxx" -#include "SMESH_Comment.hxx" -#include "SMESH_Gen.hxx" -#include "SMESH_Mesh.hxx" -#include "SMESH_HypoFilter.hxx" -#include "SMDS_FacePosition.hxx" + #include "SMDS_EdgePosition.hxx" +#include "SMDS_FacePosition.hxx" #include "SMDS_MeshElement.hxx" #include "SMDS_MeshNode.hxx" +#include "SMDS_VolumeTool.hxx" #include "SMESHDS_Mesh.hxx" #include "SMESHDS_SubMesh.hxx" +#include "SMESH_Comment.hxx" +#include "SMESH_Gen.hxx" +#include "SMESH_HypoFilter.hxx" +#include "SMESH_Mesh.hxx" +#include "SMESH_TypeDefs.hxx" +#include "SMESH_subMesh.hxx" + +#include #include #include @@ -43,7 +49,9 @@ #include #include #include +#include #include +#include #include #include #include @@ -51,6 +59,7 @@ #include #include #include +#include #include #include #include @@ -61,9 +70,102 @@ #include "utilities.h" #include +#include using namespace std; +//================================================================================ +/*! + * \brief Returns \a true if two algorithms (described by \a this and the given + * algo data) are compatible by their output and input types of elements. + */ +//================================================================================ + +bool SMESH_Algo::Features::IsCompatible( const SMESH_Algo::Features& algo2 ) const +{ + if ( _dim > algo2._dim ) return algo2.IsCompatible( *this ); + // algo2 is of highter dimension + if ( _outElemTypes.empty() || algo2._inElemTypes.empty() ) + return false; + bool compatible = true; + set::const_iterator myOutType = _outElemTypes.begin(); + for ( ; myOutType != _outElemTypes.end() && compatible; ++myOutType ) + compatible = algo2._inElemTypes.count( *myOutType ); + return compatible; +} + +//================================================================================ +/*! + * \brief Return Data of the algorithm + */ +//================================================================================ + +const SMESH_Algo::Features& SMESH_Algo::GetFeatures( const std::string& algoType ) +{ + static map< string, SMESH_Algo::Features > theFeaturesByName; + if ( theFeaturesByName.empty() ) + { + // Read Plugin.xml files + vector< string > xmlPaths = SMESH_Gen::GetPluginXMLPaths(); + LDOMParser xmlParser; + for ( size_t iXML = 0; iXML < xmlPaths.size(); ++iXML ) + { + bool error = xmlParser.parse( xmlPaths[iXML].c_str() ); + if ( error ) + { + TCollection_AsciiString data; + INFOS( xmlParser.GetError(data) ); + continue; + } + // + // + LDOM_Document xmlDoc = xmlParser.getDocument(); + LDOM_NodeList algoNodeList = xmlDoc.getElementsByTagName( "algorithm" ); + for ( int i = 0; i < algoNodeList.getLength(); ++i ) + { + LDOM_Node algoNode = algoNodeList.item( i ); + LDOM_Element& algoElem = (LDOM_Element&) algoNode; + TCollection_AsciiString algoType = algoElem.getAttribute("type"); + TCollection_AsciiString input = algoElem.getAttribute("input"); + TCollection_AsciiString output = algoElem.getAttribute("output"); + TCollection_AsciiString dim = algoElem.getAttribute("dim"); + TCollection_AsciiString label = algoElem.getAttribute("label-id"); + if ( algoType.IsEmpty() ) continue; + + Features & data = theFeaturesByName[ algoType.ToCString() ]; + data._dim = dim.IntegerValue(); + data._label = label.ToCString(); + for ( int isInput = 0; isInput < 2; ++isInput ) + { + TCollection_AsciiString& typeStr = isInput ? input : output; + set& typeSet = isInput ? data._inElemTypes : data._outElemTypes; + int beg = 1, end; + while ( beg <= typeStr.Length() ) + { + while ( beg < typeStr.Length() && !isalpha( typeStr.Value( beg ) )) + ++beg; + end = beg; + while ( end < typeStr.Length() && isalpha( typeStr.Value( end + 1 ) )) + ++end; + if ( end > beg ) + { + TCollection_AsciiString typeName = typeStr.SubString( beg, end ); + if ( typeName == "EDGE" ) typeSet.insert( SMDSGeom_EDGE ); + else if ( typeName == "TRIA" ) typeSet.insert( SMDSGeom_TRIANGLE ); + else if ( typeName == "QUAD" ) typeSet.insert( SMDSGeom_QUADRANGLE ); + } + beg = end + 1; + } + } + } + } + } + return theFeaturesByName[ algoType ]; +} + //============================================================================= /*! * @@ -75,9 +177,11 @@ SMESH_Algo::SMESH_Algo (int hypId, int studyId, SMESH_Gen * gen) { gen->_mapAlgo[hypId] = this; - _onlyUnaryInput = _requireDescretBoundary = _requireShape = true; - _quadraticMesh = false; + _onlyUnaryInput = _requireDiscreteBoundary = _requireShape = true; + _quadraticMesh = _supportSubmeshes = false; _error = COMPERR_OK; + for ( int i = 0; i < 4; ++i ) + _neededLowerHyps[ i ] = false; } //============================================================================= @@ -90,6 +194,41 @@ SMESH_Algo::~SMESH_Algo() { } +//============================================================================= +/*! + * + */ +//============================================================================= + +SMESH_0D_Algo::SMESH_0D_Algo(int hypId, int studyId, SMESH_Gen* gen) + : SMESH_Algo(hypId, studyId, gen) +{ + _shapeType = (1 << TopAbs_VERTEX); + _type = ALGO_0D; + gen->_map0D_Algo[hypId] = this; +} +SMESH_1D_Algo::SMESH_1D_Algo(int hypId, int studyId, SMESH_Gen* gen) + : SMESH_Algo(hypId, studyId, gen) +{ + _shapeType = (1 << TopAbs_EDGE); + _type = ALGO_1D; + gen->_map1D_Algo[hypId] = this; +} +SMESH_2D_Algo::SMESH_2D_Algo(int hypId, int studyId, SMESH_Gen* gen) + : SMESH_Algo(hypId, studyId, gen) +{ + _shapeType = (1 << TopAbs_FACE); + _type = ALGO_2D; + gen->_map2D_Algo[hypId] = this; +} +SMESH_3D_Algo::SMESH_3D_Algo(int hypId, int studyId, SMESH_Gen* gen) + : SMESH_Algo(hypId, studyId, gen) +{ + _shapeType = (1 << TopAbs_SOLID); + _type = ALGO_3D; + gen->_map3D_Algo[hypId] = this; +} + //============================================================================= /*! * Usually an algoritm has nothing to save @@ -170,119 +309,11 @@ double SMESH_Algo::EdgeLength(const TopoDS_Edge & E) return 0; TopLoc_Location L; Handle(Geom_Curve) C = BRep_Tool::Curve(E, L, UMin, UMax); - GeomAdaptor_Curve AdaptCurve(C); + GeomAdaptor_Curve AdaptCurve(C, UMin, UMax); //range is important for periodic curves double length = GCPnts_AbscissaPoint::Length(AdaptCurve, UMin, UMax); return length; } -//================================================================================ -/*! - * \brief Find out elements orientation on a geometrical face - * \param theFace - The face correctly oriented in the shape being meshed - * \param theMeshDS - The mesh data structure - * \retval bool - true if the face normal and the normal of first element - * in the correspoding submesh point in different directions - */ -//================================================================================ - -bool SMESH_Algo::IsReversedSubMesh (const TopoDS_Face& theFace, - SMESHDS_Mesh* theMeshDS) -{ - if ( theFace.IsNull() || !theMeshDS ) - return false; - - // find out orientation of a meshed face - int faceID = theMeshDS->ShapeToIndex( theFace ); - TopoDS_Shape aMeshedFace = theMeshDS->IndexToShape( faceID ); - bool isReversed = ( theFace.Orientation() != aMeshedFace.Orientation() ); - - const SMESHDS_SubMesh * aSubMeshDSFace = theMeshDS->MeshElements( faceID ); - if ( !aSubMeshDSFace ) - return isReversed; - - // find element with node located on face and get its normal - const SMDS_FacePosition* facePos = 0; - int vertexID = 0; - gp_Pnt nPnt[3]; - gp_Vec Ne; - bool normalOK = false; - SMDS_ElemIteratorPtr iteratorElem = aSubMeshDSFace->GetElements(); - while ( iteratorElem->more() ) // loop on elements on theFace - { - const SMDS_MeshElement* elem = iteratorElem->next(); - if ( elem && elem->NbNodes() > 2 ) { - SMDS_ElemIteratorPtr nodesIt = elem->nodesIterator(); - const SMDS_FacePosition* fPos = 0; - int i = 0, vID = 0; - while ( nodesIt->more() ) { // loop on nodes - const SMDS_MeshNode* node - = static_cast(nodesIt->next()); - if ( i == 3 ) i = 2; - nPnt[ i++ ].SetCoord( node->X(), node->Y(), node->Z() ); - // check position - const SMDS_PositionPtr& pos = node->GetPosition(); - if ( !pos ) continue; - if ( pos->GetTypeOfPosition() == SMDS_TOP_FACE ) { - fPos = dynamic_cast< const SMDS_FacePosition* >( pos.get() ); - } - else if ( pos->GetTypeOfPosition() == SMDS_TOP_VERTEX ) { - vID = pos->GetShapeId(); - } - } - if ( fPos || ( !normalOK && vID )) { - // compute normal - gp_Vec v01( nPnt[0], nPnt[1] ), v02( nPnt[0], nPnt[2] ); - if ( v01.SquareMagnitude() > RealSmall() && - v02.SquareMagnitude() > RealSmall() ) - { - Ne = v01 ^ v02; - normalOK = ( Ne.SquareMagnitude() > RealSmall() ); - } - // we need position on theFace or at least on vertex - if ( normalOK ) { - vertexID = vID; - if ((facePos = fPos)) - break; - } - } - } - } - if ( !normalOK ) - return isReversed; - - // node position on face - double u,v; - if ( facePos ) { - u = facePos->GetUParameter(); - v = facePos->GetVParameter(); - } - else if ( vertexID ) { - TopoDS_Shape V = theMeshDS->IndexToShape( vertexID ); - if ( V.IsNull() || V.ShapeType() != TopAbs_VERTEX ) - return isReversed; - gp_Pnt2d uv = BRep_Tool::Parameters( TopoDS::Vertex( V ), theFace ); - u = uv.X(); - v = uv.Y(); - } - else - { - return isReversed; - } - - // face normal at node position - TopLoc_Location loc; - Handle(Geom_Surface) surf = BRep_Tool::Surface( theFace, loc ); - if ( surf.IsNull() || surf->Continuity() < GeomAbs_C1 ) return isReversed; - gp_Vec d1u, d1v; - surf->D1( u, v, nPnt[0], d1u, d1v ); - gp_Vec Nf = (d1u ^ d1v).Transformed( loc ); - - if ( theFace.Orientation() == TopAbs_REVERSED ) - Nf.Reverse(); - - return Ne * Nf < 0.; -} - //================================================================================ /*! * \brief Just return false as the algorithm does not hold parameters values @@ -321,7 +352,7 @@ bool SMESH_Algo::GetNodeParamOnEdge(const SMESHDS_Mesh* theMesh, if ( !eSubMesh || !eSubMesh->GetElements()->more() ) return false; // edge is not meshed - int nbEdgeNodes = 0; + //int nbEdgeNodes = 0; set < double > paramSet; if ( eSubMesh ) { @@ -334,17 +365,19 @@ bool SMESH_Algo::GetNodeParamOnEdge(const SMESHDS_Mesh* theMesh, if ( pos->GetTypeOfPosition() != SMDS_TOP_EDGE ) return false; const SMDS_EdgePosition* epos = - static_cast(node->GetPosition().get()); - paramSet.insert( epos->GetUParameter() ); - ++nbEdgeNodes; + static_cast(node->GetPosition()); + if ( !paramSet.insert( epos->GetUParameter() ).second ) + return false; // equal parameters } } // add vertex nodes params - Standard_Real f, l; - BRep_Tool::Range(theEdge, f, l); - paramSet.insert( f ); - paramSet.insert( l ); - if ( paramSet.size() != nbEdgeNodes + 2 ) + 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 @@ -399,8 +432,9 @@ bool SMESH_Algo::GetSortedNodesOnEdge(const SMESHDS_Mesh* theM if ( pos->GetTypeOfPosition() != SMDS_TOP_EDGE ) return false; const SMDS_EdgePosition* epos = - static_cast(node->GetPosition().get()); - theNodes.insert( make_pair( epos->GetUParameter(), node )); + static_cast(node->GetPosition()); + theNodes.insert( theNodes.end(), make_pair( epos->GetUParameter(), node )); + //MESSAGE("U " << epos->GetUParameter() << " ID " << node->GetID()); ++nbNodes; } } @@ -409,6 +443,7 @@ bool SMESH_Algo::GetSortedNodesOnEdge(const SMESHDS_Mesh* theM TopExp::Vertices(theEdge, v1, v2); const SMDS_MeshNode* n1 = VertexNode( v1, (SMESHDS_Mesh*) theMesh ); const SMDS_MeshNode* n2 = VertexNode( v2, (SMESHDS_Mesh*) theMesh ); + //MESSAGE("Vertices ID " << n1->GetID() << " " << n2->GetID()); Standard_Real f, l; BRep_Tool::Range(theEdge, f, l); if ( v1.Orientation() != TopAbs_FORWARD ) @@ -455,20 +490,31 @@ bool SMESH_Algo::InitCompatibleHypoFilter( SMESH_HypoFilter & theFilter, */ //================================================================================ -GeomAbs_Shape SMESH_Algo::Continuity(const TopoDS_Edge & E1, - const TopoDS_Edge & E2) +GeomAbs_Shape SMESH_Algo::Continuity(TopoDS_Edge E1, + TopoDS_Edge E2) { - TopoDS_Vertex V = TopExp::LastVertex (E1, true); - if ( !V.IsSame( TopExp::FirstVertex(E2, true ))) - if ( !TopExp::CommonVertex( E1, E2, V )) - return GeomAbs_C0; + //E1.Orientation(TopAbs_FORWARD), E2.Orientation(TopAbs_FORWARD); // avoid pb with internal edges + 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 { -#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100 +#if OCC_VERSION_LARGE > 0x06010000 OCC_CATCH_SIGNALS; #endif return BRepLProp::Continuity(C1, C2, u1, u2, tol, angTol); @@ -488,7 +534,7 @@ GeomAbs_Shape SMESH_Algo::Continuity(const TopoDS_Edge & E1, //================================================================================ const SMDS_MeshNode* SMESH_Algo::VertexNode(const TopoDS_Vertex& V, - SMESHDS_Mesh* meshDS) + const SMESHDS_Mesh* meshDS) { if ( SMESHDS_SubMesh* sm = meshDS->MeshElements(V) ) { SMDS_NodeIteratorPtr nIt= sm->GetNodes(); @@ -498,6 +544,88 @@ const SMDS_MeshNode* SMESH_Algo::VertexNode(const TopoDS_Vertex& V, return 0; } +//======================================================================= +//function : GetMeshError +//purpose : Finds topological errors of a sub-mesh +//WARNING : 1D check is NOT implemented so far +//======================================================================= + +SMESH_Algo::EMeshError SMESH_Algo::GetMeshError(SMESH_subMesh* subMesh) +{ + EMeshError err = MEr_OK; + + SMESHDS_SubMesh* smDS = subMesh->GetSubMeshDS(); + if ( !smDS ) + return MEr_EMPTY; + + switch ( subMesh->GetSubShape().ShapeType() ) + { + case TopAbs_FACE: { // ====================== 2D ===================== + + SMDS_ElemIteratorPtr fIt = smDS->GetElements(); + if ( !fIt->more() ) + return MEr_EMPTY; + + // We check that olny links on EDGEs encouter once, the rest links, twice + set< SMESH_TLink > links; + while ( fIt->more() ) + { + const SMDS_MeshElement* f = fIt->next(); + int nbNodes = f->NbCornerNodes(); // ignore medium nodes + for ( int i = 0; i < nbNodes; ++i ) + { + const SMDS_MeshNode* n1 = f->GetNode( i ); + const SMDS_MeshNode* n2 = f->GetNode(( i+1 ) % nbNodes); + std::pair< set< SMESH_TLink >::iterator, bool > it_added = + links.insert( SMESH_TLink( n1, n2 )); + if ( !it_added.second ) + // As we do NOT(!) check if mesh is manifold, we believe that a link can + // encounter once or twice only (not three times), we erase a link as soon + // as it encounters twice to speed up search in the map. + links.erase( it_added.first ); + } + } + // the links remaining in the should all be on EDGE + set< SMESH_TLink >::iterator linkIt = links.begin(); + for ( ; linkIt != links.end(); ++linkIt ) + { + const SMESH_TLink& link = *linkIt; + if ( link.node1()->GetPosition()->GetTypeOfPosition() > SMDS_TOP_EDGE || + link.node2()->GetPosition()->GetTypeOfPosition() > SMDS_TOP_EDGE ) + return MEr_HOLES; + } + // TODO: to check orientation + break; + } + case TopAbs_SOLID: { // ====================== 3D ===================== + + SMDS_ElemIteratorPtr vIt = smDS->GetElements(); + if ( !vIt->more() ) + return MEr_EMPTY; + + SMDS_VolumeTool vTool; + while ( !vIt->more() ) + { + if (!vTool.Set( vIt->next() )) + continue; // strange + + for ( int iF = 0; iF < vTool.NbFaces(); ++iF ) + if ( vTool.IsFreeFace( iF )) + { + int nbN = vTool.NbFaceNodes( iF ); + const SMDS_MeshNode** nodes = vTool.GetFaceNodes( iF ); + for ( int i = 0; i < nbN; ++i ) + if ( nodes[i]->GetPosition()->GetTypeOfPosition() > SMDS_TOP_FACE ) + return MEr_HOLES; + } + } + break; + } + default:; + } + return err; +} + //================================================================================ /*! * \brief Sets event listener to submeshes if necessary @@ -539,6 +667,18 @@ bool SMESH_Algo::Compute(SMESH_Mesh & /*aMesh*/, SMESH_MesherHelper* /*aHelper*/ return error( COMPERR_BAD_INPUT_MESH, "Mesh built on shape expected"); } +//======================================================================= +//function : CancelCompute +//purpose : Sets _computeCanceled to true. It's usage depends on +// * implementation of a particular mesher. +//======================================================================= + +void SMESH_Algo::CancelCompute() +{ + _computeCanceled = true; + _error = COMPERR_CANCELED; +} + //================================================================================ /*! * \brief store error and comment and then return ( error == COMPERR_OK ) @@ -599,6 +739,8 @@ void SMESH_Algo::InitComputeError() if ( (*elem)->GetID() < 1 ) delete *elem; _badInputElements.clear(); + + _computeCanceled = false; } //================================================================================ @@ -614,3 +756,61 @@ void SMESH_Algo::addBadInputElement(const SMDS_MeshElement* elem) if ( elem ) _badInputElements.push_back( elem ); } + +//======================================================================= +//function : addBadInputElements +//purpose : store a bad input elements or nodes preventing computation +//======================================================================= + +void SMESH_Algo::addBadInputElements(const SMESHDS_SubMesh* sm, + const bool addNodes) +{ + if ( sm ) + { + if ( addNodes ) + { + SMDS_NodeIteratorPtr nIt = sm->GetNodes(); + while ( nIt->more() ) addBadInputElement( nIt->next() ); + } + else + { + SMDS_ElemIteratorPtr eIt = sm->GetElements(); + while ( eIt->more() ) addBadInputElement( eIt->next() ); + } + } +} + +//============================================================================= +/*! + * + */ +//============================================================================= + +// int SMESH_Algo::NumberOfWires(const TopoDS_Shape& S) +// { +// int i = 0; +// for (TopExp_Explorer exp(S,TopAbs_WIRE); exp.More(); exp.Next()) +// i++; +// return i; +// } + +//============================================================================= +/*! + * + */ +//============================================================================= + +int SMESH_Algo::NumberOfPoints(SMESH_Mesh& aMesh, const TopoDS_Wire& W) +{ + int nbPoints = 0; + for (TopExp_Explorer exp(W,TopAbs_EDGE); exp.More(); exp.Next()) { + const TopoDS_Edge& E = TopoDS::Edge(exp.Current()); + int nb = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes(); + if(_quadraticMesh) + nb = nb/2; + nbPoints += nb + 1; // internal points plus 1 vertex of 2 (last point ?) + } + return nbPoints; +} + +