bool SMESH_Algo::GetSortedNodesOnEdge(const SMESHDS_Mesh* theMesh, const TopoDS_Edge& theEdge, const bool ignoreMediumNodes, map< double, const SMDS_MeshNode* > & theNodes) { theNodes.clear(); if ( !theMesh || theEdge.IsNull() ) return false; SMESHDS_SubMesh * eSubMesh = theMesh->MeshElements( theEdge ); if ( !eSubMesh || !eSubMesh->GetElements()->more() ) 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 ) { SMDS_ElemIteratorPtr elemIt = node->GetInverseElementIterator(); if ( elemIt->more() && elemIt->next()->IsMediumNode( node )) 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().get()); theNodes.insert( make_pair( epos->GetUParameter(), node )); ++nbNodes; } } // add vertex nodes TopoDS_Vertex v1, v2; TopExp::Vertices(theEdge, v1, v2); const SMDS_MeshNode* n1 = VertexNode( v1, (SMESHDS_Mesh*) theMesh ); const SMDS_MeshNode* n2 = VertexNode( v2, (SMESHDS_Mesh*) theMesh ); Standard_Real f, l; BRep_Tool::Range(theEdge, f, l); if ( v1.Orientation() != TopAbs_FORWARD ) std::swap( f, l ); if ( n1 && ++nbNodes ) theNodes.insert( make_pair( f, n1 )); if ( n2 && ++nbNodes ) theNodes.insert( make_pair( l, n2 )); return theNodes.size() == nbNodes; }
bool SMESH_Algo::GetNodeParamOnEdge(const SMESHDS_Mesh* theMesh, const TopoDS_Edge& theEdge, vector< double > & theParams) { theParams.clear(); if ( !theMesh || theEdge.IsNull() ) return false; SMESHDS_SubMesh * eSubMesh = theMesh->MeshElements( theEdge ); if ( !eSubMesh || !eSubMesh->GetElements()->more() ) return false; // edge is not meshed //int nbEdgeNodes = 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(); 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().get()); 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; }
//============================================================================= bool NETGENPlugin_Mesher::Compute() { #ifdef WNT netgen::MeshingParameters& mparams = netgen::GlobalMeshingParameters(); #else netgen::MeshingParameters& mparams = netgen::mparam; #endif MESSAGE("Compute with:\n" " max size = " << mparams.maxh << "\n" " segments per edge = " << mparams.segmentsperedge); MESSAGE("\n" " growth rate = " << mparams.grading << "\n" " elements per radius = " << mparams.curvaturesafety << "\n" " second order = " << mparams.secondorder << "\n" " quad allowed = " << mparams.quad); SMESH_ComputeErrorPtr error = SMESH_ComputeError::New(); nglib::Ng_Init(); // ------------------------- // Prepare OCC geometry // ------------------------- netgen::OCCGeometry occgeo; list< SMESH_subMesh* > meshedSM; PrepareOCCgeometry( occgeo, _shape, *_mesh, &meshedSM ); // ------------------------- // Generate the mesh // ------------------------- netgen::Mesh *ngMesh = NULL; SMESH_Comment comment; int err = 0; int nbInitNod = 0; int nbInitSeg = 0; int nbInitFac = 0; // vector of nodes in which node index == netgen ID vector< SMDS_MeshNode* > nodeVec; try { // ---------------- // compute 1D mesh // ---------------- // pass 1D simple parameters to NETGEN if ( _simpleHyp ) { if ( int nbSeg = _simpleHyp->GetNumberOfSegments() ) { // nb of segments mparams.segmentsperedge = nbSeg + 0.1; mparams.maxh = occgeo.boundingbox.Diam(); mparams.grading = 0.01; } else { // segment length mparams.segmentsperedge = 1; mparams.maxh = _simpleHyp->GetLocalLength(); } } // let netgen create ngMesh and calculate element size on not meshed shapes char *optstr = 0; int startWith = netgen::MESHCONST_ANALYSE; int endWith = netgen::MESHCONST_ANALYSE; err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr); if (err) comment << "Error in netgen::OCCGenerateMesh() at MESHCONST_ANALYSE step"; // fill ngMesh with nodes and elements of computed submeshes err = ! fillNgMesh(occgeo, *ngMesh, nodeVec, meshedSM); nbInitNod = ngMesh->GetNP(); nbInitSeg = ngMesh->GetNSeg(); nbInitFac = ngMesh->GetNSE(); // compute mesh if (!err) { startWith = endWith = netgen::MESHCONST_MESHEDGES; err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr); if (err) comment << "Error in netgen::OCCGenerateMesh() at 1D mesh generation"; } // --------------------- // compute surface mesh // --------------------- if (!err) { // pass 2D simple parameters to NETGEN if ( _simpleHyp ) { if ( double area = _simpleHyp->GetMaxElementArea() ) { // face area mparams.maxh = sqrt(2. * area/sqrt(3.0)); mparams.grading = 0.4; // moderate size growth } else { // length from edges double length = 0; TopTools_MapOfShape tmpMap; for ( TopExp_Explorer exp( _shape, TopAbs_EDGE ); exp.More(); exp.Next() ) if( tmpMap.Add(exp.Current()) ) length += SMESH_Algo::EdgeLength( TopoDS::Edge( exp.Current() )); if ( ngMesh->GetNSeg() ) { // we have to multiply length by 2 since for each TopoDS_Edge there // are double set of NETGEN edges or, in other words, we have to // divide ngMesh->GetNSeg() on 2. mparams.maxh = 2*length / ngMesh->GetNSeg(); } else mparams.maxh = 1000; mparams.grading = 0.2; // slow size growth } mparams.maxh = min( mparams.maxh, occgeo.boundingbox.Diam()/2 ); ngMesh->SetGlobalH (mparams.maxh); netgen::Box<3> bb = occgeo.GetBoundingBox(); bb.Increase (bb.Diam()/20); ngMesh->SetLocalH (bb.PMin(), bb.PMax(), mparams.grading); } // let netgen compute 2D mesh startWith = netgen::MESHCONST_MESHSURFACE; endWith = _optimize ? netgen::MESHCONST_OPTSURFACE : netgen::MESHCONST_MESHSURFACE; err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr); if (err) comment << "Error in netgen::OCCGenerateMesh() at surface mesh generation"; } // --------------------- // generate volume mesh // --------------------- if (!err && _isVolume) { // add ng face descriptors of meshed faces std::map< int, std::pair<int,int> >::iterator fId_soIds = _faceDescriptors.begin(); for ( ; fId_soIds != _faceDescriptors.end(); ++fId_soIds ) { int faceID = fId_soIds->first; int solidID1 = fId_soIds->second.first; int solidID2 = fId_soIds->second.second; ngMesh->AddFaceDescriptor (netgen::FaceDescriptor(faceID, solidID1, solidID2, 0)); } // pass 3D simple parameters to NETGEN const NETGENPlugin_SimpleHypothesis_3D* simple3d = dynamic_cast< const NETGENPlugin_SimpleHypothesis_3D* > ( _simpleHyp ); if ( simple3d ) { if ( double vol = simple3d->GetMaxElementVolume() ) { // max volume mparams.maxh = pow( 72, 1/6. ) * pow( vol, 1/3. ); mparams.maxh = min( mparams.maxh, occgeo.boundingbox.Diam()/2 ); } else { // length from faces mparams.maxh = ngMesh->AverageH(); } // netgen::ARRAY<double> maxhdom; // maxhdom.SetSize (occgeo.NrSolids()); // maxhdom = mparams.maxh; // ngMesh->SetMaxHDomain (maxhdom); ngMesh->SetGlobalH (mparams.maxh); mparams.grading = 0.4; ngMesh->CalcLocalH(); } // let netgen compute 3D mesh startWith = netgen::MESHCONST_MESHVOLUME; endWith = _optimize ? netgen::MESHCONST_OPTVOLUME : netgen::MESHCONST_MESHVOLUME; err = netgen::OCCGenerateMesh(occgeo, ngMesh, startWith, endWith, optstr); if (err) comment << "Error in netgen::OCCGenerateMesh()"; } if (!err && mparams.secondorder > 0) { netgen::OCCRefinementSurfaces ref (occgeo); ref.MakeSecondOrder (*ngMesh); } } catch (netgen::NgException exc) { error->myName = err = COMPERR_ALGO_FAILED; comment << exc.What(); } int nbNod = ngMesh->GetNP(); int nbSeg = ngMesh->GetNSeg(); int nbFac = ngMesh->GetNSE(); int nbVol = ngMesh->GetNE(); MESSAGE((err ? "Mesh Generation failure" : "End of Mesh Generation") << ", nb nodes: " << nbNod << ", nb segments: " << nbSeg << ", nb faces: " << nbFac << ", nb volumes: " << nbVol); // ----------------------------------------------------------- // Feed back the SMESHDS with the generated Nodes and Elements // ----------------------------------------------------------- SMESHDS_Mesh* meshDS = _mesh->GetMeshDS(); bool isOK = ( !err && (_isVolume ? (nbVol > 0) : (nbFac > 0)) ); if ( true /*isOK*/ ) // get whatever built { // map of nodes assigned to submeshes NCollection_Map<int> pindMap; // create and insert nodes into nodeVec nodeVec.resize( nbNod + 1 ); int i; for (i = nbInitNod+1; i <= nbNod /*&& isOK*/; ++i ) { const netgen::MeshPoint& ngPoint = ngMesh->Point(i); SMDS_MeshNode* node = NULL; bool newNodeOnVertex = false; TopoDS_Vertex aVert; if (i-nbInitNod <= occgeo.vmap.Extent()) { // point on vertex aVert = TopoDS::Vertex(occgeo.vmap(i-nbInitNod)); SMESHDS_SubMesh * submesh = meshDS->MeshElements(aVert); if (submesh) { SMDS_NodeIteratorPtr it = submesh->GetNodes(); if (it->more()) { node = const_cast<SMDS_MeshNode*> (it->next()); pindMap.Add(i); } } if (!node) newNodeOnVertex = true; } if (!node) node = meshDS->AddNode(ngPoint.X(), ngPoint.Y(), ngPoint.Z()); if (!node) { MESSAGE("Cannot create a mesh node"); if ( !comment.size() ) comment << "Cannot create a mesh node"; nbSeg = nbFac = nbVol = isOK = 0; break; } nodeVec.at(i) = node; if (newNodeOnVertex) { // point on vertex meshDS->SetNodeOnVertex(node, aVert); pindMap.Add(i); } } // create mesh segments along geometric edges NCollection_Map<Link> linkMap; for (i = nbInitSeg+1; i <= nbSeg/* && isOK*/; ++i ) { const netgen::Segment& seg = ngMesh->LineSegment(i); Link link(seg.p1, seg.p2); if (linkMap.Contains(link)) continue; linkMap.Add(link); TopoDS_Edge aEdge; int pinds[3] = { seg.p1, seg.p2, seg.pmid }; int nbp = 0; double param2 = 0; for (int j=0; j < 3; ++j) { int pind = pinds[j]; if (pind <= 0) continue; ++nbp; double param; if (j < 2) { if (aEdge.IsNull()) { int aGeomEdgeInd = seg.epgeominfo[j].edgenr; if (aGeomEdgeInd > 0 && aGeomEdgeInd <= occgeo.emap.Extent()) aEdge = TopoDS::Edge(occgeo.emap(aGeomEdgeInd)); } param = seg.epgeominfo[j].dist; param2 += param; } else param = param2 * 0.5; if (pind <= nbInitNod || pindMap.Contains(pind)) continue; if (!aEdge.IsNull()) { meshDS->SetNodeOnEdge(nodeVec.at(pind), aEdge, param); pindMap.Add(pind); } } SMDS_MeshEdge* edge; if (nbp < 3) // second order ? edge = meshDS->AddEdge(nodeVec.at(pinds[0]), nodeVec.at(pinds[1])); else edge = meshDS->AddEdge(nodeVec.at(pinds[0]), nodeVec.at(pinds[1]), nodeVec.at(pinds[2])); if (!edge) { if ( !comment.size() ) comment << "Cannot create a mesh edge"; MESSAGE("Cannot create a mesh edge"); nbSeg = nbFac = nbVol = isOK = 0; break; } if (!aEdge.IsNull()) meshDS->SetMeshElementOnShape(edge, aEdge); } // create mesh faces along geometric faces for (i = nbInitFac+1; i <= nbFac/* && isOK*/; ++i ) { const netgen::Element2d& elem = ngMesh->SurfaceElement(i); int aGeomFaceInd = elem.GetIndex(); TopoDS_Face aFace; if (aGeomFaceInd > 0 && aGeomFaceInd <= occgeo.fmap.Extent()) aFace = TopoDS::Face(occgeo.fmap(aGeomFaceInd)); vector<SMDS_MeshNode*> nodes; for (int j=1; j <= elem.GetNP(); ++j) { int pind = elem.PNum(j); SMDS_MeshNode* node = nodeVec.at(pind); nodes.push_back(node); if (pind <= nbInitNod || pindMap.Contains(pind)) continue; if (!aFace.IsNull()) { const netgen::PointGeomInfo& pgi = elem.GeomInfoPi(j); meshDS->SetNodeOnFace(node, aFace, pgi.u, pgi.v); pindMap.Add(pind); } } SMDS_MeshFace* face = NULL; switch (elem.GetType()) { case netgen::TRIG: face = meshDS->AddFace(nodes[0],nodes[1],nodes[2]); break; case netgen::QUAD: face = meshDS->AddFace(nodes[0],nodes[1],nodes[2],nodes[3]); break; case netgen::TRIG6: face = meshDS->AddFace(nodes[0],nodes[1],nodes[2],nodes[5],nodes[3],nodes[4]); break; case netgen::QUAD8: face = meshDS->AddFace(nodes[0],nodes[1],nodes[2],nodes[3], nodes[4],nodes[7],nodes[5],nodes[6]); break; default: MESSAGE("NETGEN created a face of unexpected type, ignoring"); continue; } if (!face) { if ( !comment.size() ) comment << "Cannot create a mesh face"; MESSAGE("Cannot create a mesh face"); nbSeg = nbFac = nbVol = isOK = 0; break; } if (!aFace.IsNull()) meshDS->SetMeshElementOnShape(face, aFace); } // create tetrahedra for (i = 1; i <= nbVol/* && isOK*/; ++i) { const netgen::Element& elem = ngMesh->VolumeElement(i); int aSolidInd = elem.GetIndex(); TopoDS_Solid aSolid; if (aSolidInd > 0 && aSolidInd <= occgeo.somap.Extent()) aSolid = TopoDS::Solid(occgeo.somap(aSolidInd)); vector<SMDS_MeshNode*> nodes; for (int j=1; j <= elem.GetNP(); ++j) { int pind = elem.PNum(j); SMDS_MeshNode* node = nodeVec.at(pind); nodes.push_back(node); if (pind <= nbInitNod || pindMap.Contains(pind)) continue; if (!aSolid.IsNull()) { // point in solid meshDS->SetNodeInVolume(node, aSolid); pindMap.Add(pind); } } SMDS_MeshVolume* vol = NULL; switch (elem.GetType()) { case netgen::TET: vol = meshDS->AddVolume(nodes[0],nodes[1],nodes[2],nodes[3]); break; case netgen::TET10: vol = meshDS->AddVolume(nodes[0],nodes[1],nodes[2],nodes[3], nodes[4],nodes[7],nodes[5],nodes[6],nodes[8],nodes[9]); break; default: MESSAGE("NETGEN created a volume of unexpected type, ignoring"); continue; } if (!vol) { if ( !comment.size() ) comment << "Cannot create a mesh volume"; MESSAGE("Cannot create a mesh volume"); nbSeg = nbFac = nbVol = isOK = 0; break; } if (!aSolid.IsNull()) meshDS->SetMeshElementOnShape(vol, aSolid); } } if ( error->IsOK() && ( !isOK || comment.size() > 0 )) error->myName = COMPERR_ALGO_FAILED; if ( !comment.empty() ) error->myComment = comment; // set bad compute error to subshapes of all failed subshapes shapes if ( !error->IsOK() && err ) { for (int i = 1; i <= occgeo.fmap.Extent(); i++) { int status = occgeo.facemeshstatus[i-1]; if (status == 1 ) continue; if ( SMESH_subMesh* sm = _mesh->GetSubMeshContaining( occgeo.fmap( i ))) { SMESH_ComputeErrorPtr& smError = sm->GetComputeError(); if ( !smError || smError->IsOK() ) { if ( status == -1 ) smError.reset( new SMESH_ComputeError( error->myName, error->myComment )); else smError.reset( new SMESH_ComputeError( COMPERR_ALGO_FAILED, "Ignored" )); } } } } nglib::Ng_DeleteMesh((nglib::Ng_Mesh*)ngMesh); nglib::Ng_Exit(); RemoveTmpFiles(); return error->IsOK(); }
bool NETGENPlugin_Mesher::fillNgMesh(netgen::OCCGeometry& occgeom, netgen::Mesh& ngMesh, vector<SMDS_MeshNode*>& nodeVec, const list< SMESH_subMesh* > & meshedSM) { TNode2IdMap nodeNgIdMap; TopTools_MapOfShape visitedShapes; SMESH_MesherHelper helper (*_mesh); int faceID = occgeom.fmap.Extent(); _faceDescriptors.clear(); list< SMESH_subMesh* >::const_iterator smIt, smEnd = meshedSM.end(); for ( smIt = meshedSM.begin(); smIt != smEnd; ++smIt ) { SMESH_subMesh* sm = *smIt; if ( !visitedShapes.Add( sm->GetSubShape() )) continue; SMESHDS_SubMesh * smDS = sm->GetSubMeshDS(); switch ( sm->GetSubShape().ShapeType() ) { case TopAbs_EDGE: { // EDGE // ---------------------- const TopoDS_Edge& geomEdge = TopoDS::Edge( sm->GetSubShape() ); // Add ng segments for each not meshed face the edge bounds TopTools_MapOfShape visitedAncestors; const TopTools_ListOfShape& ancestors = _mesh->GetAncestors( geomEdge ); TopTools_ListIteratorOfListOfShape ancestorIt ( ancestors ); for ( ; ancestorIt.More(); ancestorIt.Next() ) { const TopoDS_Shape & ans = ancestorIt.Value(); if ( ans.ShapeType() != TopAbs_FACE || !visitedAncestors.Add( ans )) continue; const TopoDS_Face& face = TopoDS::Face( ans ); int faceID = occgeom.fmap.FindIndex( face ); if ( faceID < 1 ) continue; // meshed face // find out orientation of geomEdge within face bool isForwad = false; for ( TopExp_Explorer exp( face, TopAbs_EDGE ); exp.More(); exp.Next() ) { if ( geomEdge.IsSame( exp.Current() )) { isForwad = ( exp.Current().Orientation() == geomEdge.Orientation() ); break; } } bool isQuad = smDS->GetElements()->next()->IsQuadratic(); // get all nodes from geomEdge StdMeshers_FaceSide fSide( face, geomEdge, _mesh, isForwad, isQuad ); const vector<UVPtStruct>& points = fSide.GetUVPtStruct(); int i, nbSeg = fSide.NbSegments(); double otherSeamParam = 0; helper.SetSubShape( face ); bool isSeam = helper.IsRealSeam( geomEdge ); if ( isSeam ) otherSeamParam = helper.GetOtherParam( helper.GetPeriodicIndex() == 1 ? points[0].u : points[0].v ); // add segments int prevNgId = ngNodeId( points[0].node, ngMesh, nodeNgIdMap ); for ( i = 0; i < nbSeg; ++i ) { const UVPtStruct& p1 = points[ i ]; const UVPtStruct& p2 = points[ i+1 ]; netgen::Segment seg; // ng node ids seg.p1 = prevNgId; seg.p2 = prevNgId = ngNodeId( p2.node, ngMesh, nodeNgIdMap ); // node param on curve seg.epgeominfo[ 0 ].dist = p1.param; seg.epgeominfo[ 1 ].dist = p2.param; // uv on face seg.epgeominfo[ 0 ].u = p1.u; seg.epgeominfo[ 0 ].v = p1.v; seg.epgeominfo[ 1 ].u = p2.u; seg.epgeominfo[ 1 ].v = p2.v; //seg.epgeominfo[ iEnd ].edgenr = edgeID; // = geom.emap.FindIndex(edge); seg.si = faceID; // = geom.fmap.FindIndex (face); seg.edgenr = ngMesh.GetNSeg() + 1; // segment id ngMesh.AddSegment (seg); if ( isSeam ) { if ( helper.GetPeriodicIndex() == 1 ) { seg.epgeominfo[ 0 ].u = otherSeamParam; seg.epgeominfo[ 1 ].u = otherSeamParam; swap (seg.epgeominfo[0].v, seg.epgeominfo[1].v); } else { seg.epgeominfo[ 0 ].v = otherSeamParam; seg.epgeominfo[ 1 ].v = otherSeamParam; swap (seg.epgeominfo[0].u, seg.epgeominfo[1].u); } swap (seg.p1, seg.p2); swap (seg.epgeominfo[0].dist, seg.epgeominfo[1].dist); seg.edgenr = ngMesh.GetNSeg() + 1; // segment id ngMesh.AddSegment (seg); } } } // loop on geomEdge ancestors break; } // case TopAbs_EDGE case TopAbs_FACE: { // FACE // ---------------------- const TopoDS_Face& geomFace = TopoDS::Face( sm->GetSubShape() ); helper.SetSubShape( geomFace ); // Find solids the geomFace bounds int solidID1 = 0, solidID2 = 0; const TopTools_ListOfShape& ancestors = _mesh->GetAncestors( geomFace ); TopTools_ListIteratorOfListOfShape ancestorIt ( ancestors ); for ( ; ancestorIt.More(); ancestorIt.Next() ) { const TopoDS_Shape & solid = ancestorIt.Value(); if ( solid.ShapeType() == TopAbs_SOLID ) { int id = occgeom.somap.FindIndex ( solid ); if ( solidID1 && id != solidID1 ) solidID2 = id; else solidID1 = id; } } faceID++; _faceDescriptors[ faceID ].first = solidID1; _faceDescriptors[ faceID ].second = solidID2; // Orient the face correctly in solidID1 (issue 0020206) bool reverse = false; if ( solidID1 ) { TopoDS_Shape solid = occgeom.somap( solidID1 ); for ( TopExp_Explorer f( solid, TopAbs_FACE ); f.More(); f.Next() ) { if ( geomFace.IsSame( f.Current() )) { reverse = SMESH_Algo::IsReversedSubMesh( TopoDS::Face( f.Current()), helper.GetMeshDS() ); break; } } } // Add surface elements SMDS_ElemIteratorPtr faces = smDS->GetElements(); while ( faces->more() ) { const SMDS_MeshElement* f = faces->next(); if ( f->NbNodes() % 3 != 0 ) { // not triangle for ( ancestorIt.Initialize(ancestors); ancestorIt.More(); ancestorIt.Next() ) if ( ancestorIt.Value().ShapeType() == TopAbs_SOLID ) { sm = _mesh->GetSubMesh( ancestorIt.Value() ); break; } SMESH_ComputeErrorPtr& smError = sm->GetComputeError(); smError.reset( new SMESH_ComputeError(COMPERR_BAD_INPUT_MESH,"Not triangle submesh")); smError->myBadElements.push_back( f ); return false; } netgen::Element2d tri(3); tri.SetIndex ( faceID ); for ( int i = 0; i < 3; ++i ) { const SMDS_MeshNode* node = f->GetNode( i ), * inFaceNode=0; if ( helper.IsSeamShape( node->GetPosition()->GetShapeId() )) if ( helper.IsSeamShape( f->GetNodeWrap( i+1 )->GetPosition()->GetShapeId() )) inFaceNode = f->GetNodeWrap( i-1 ); else inFaceNode = f->GetNodeWrap( i+1 ); gp_XY uv = helper.GetNodeUV( geomFace, node, inFaceNode ); if ( reverse ) { tri.GeomInfoPi(3-i).u = uv.X(); tri.GeomInfoPi(3-i).v = uv.Y(); tri.PNum (3-i) = ngNodeId( node, ngMesh, nodeNgIdMap ); } else { tri.GeomInfoPi(i+1).u = uv.X(); tri.GeomInfoPi(i+1).v = uv.Y(); tri.PNum (i+1) = ngNodeId( node, ngMesh, nodeNgIdMap ); } } ngMesh.AddSurfaceElement (tri); } break; } // case TopAbs_VERTEX: { // VERTEX // -------------------------- SMDS_NodeIteratorPtr nodeIt = smDS->GetNodes(); if ( nodeIt->more() ) ngNodeId( nodeIt->next(), ngMesh, nodeNgIdMap ); break; } default:; } // switch } // loop on submeshes // fill nodeVec nodeVec.resize( ngMesh.GetNP() + 1 ); TNode2IdMap::iterator node_NgId, nodeNgIdEnd = nodeNgIdMap.end(); for ( node_NgId = nodeNgIdMap.begin(); node_NgId != nodeNgIdEnd; ++node_NgId) nodeVec[ node_NgId->second ] = (SMDS_MeshNode*) node_NgId->first; return true; }
bool SMESH_MesherHelper::LoadNodeColumns(TParam2ColumnMap & theParam2ColumnMap, const TopoDS_Face& theFace, const TopoDS_Edge& theBaseEdge, SMESHDS_Mesh* theMesh) { // get vertices of theBaseEdge TopoDS_Vertex vfb, vlb, vft; // first and last, bottom and top vertices TopoDS_Edge eFrw = TopoDS::Edge( theBaseEdge.Oriented( TopAbs_FORWARD )); TopExp::Vertices( eFrw, vfb, vlb ); // find the other edges of theFace and orientation of e1 TopoDS_Edge e1, e2, eTop; bool rev1, CumOri = false; TopExp_Explorer exp( theFace, TopAbs_EDGE ); int nbEdges = 0; for ( ; exp.More(); exp.Next() ) { if ( ++nbEdges > 4 ) { return false; // more than 4 edges in theFace } TopoDS_Edge e = TopoDS::Edge( exp.Current() ); if ( theBaseEdge.IsSame( e )) continue; TopoDS_Vertex vCommon; if ( !TopExp::CommonVertex( theBaseEdge, e, vCommon )) eTop = e; else if ( vCommon.IsSame( vfb )) { e1 = e; vft = TopExp::LastVertex( e1, CumOri ); rev1 = vfb.IsSame( vft ); if ( rev1 ) vft = TopExp::FirstVertex( e1, CumOri ); } else e2 = e; } if ( nbEdges < 4 ) { return false; // less than 4 edges in theFace } if ( e2.IsNull() && vfb.IsSame( vlb )) e2 = e1; // submeshes corresponding to shapes SMESHDS_SubMesh* smFace = theMesh->MeshElements( theFace ); SMESHDS_SubMesh* smb = theMesh->MeshElements( theBaseEdge ); SMESHDS_SubMesh* smt = theMesh->MeshElements( eTop ); SMESHDS_SubMesh* sm1 = theMesh->MeshElements( e1 ); SMESHDS_SubMesh* sm2 = theMesh->MeshElements( e2 ); SMESHDS_SubMesh* smVfb = theMesh->MeshElements( vfb ); SMESHDS_SubMesh* smVlb = theMesh->MeshElements( vlb ); SMESHDS_SubMesh* smVft = theMesh->MeshElements( vft ); if (!smFace || !smb || !smt || !sm1 || !sm2 || !smVfb || !smVlb || !smVft ) { RETURN_BAD_RESULT( "NULL submesh " <<smFace<<" "<<smb<<" "<<smt<<" "<< sm1<<" "<<sm2<<" "<<smVfb<<" "<<smVlb<<" "<<smVft); } if ( smb->NbNodes() != smt->NbNodes() || sm1->NbNodes() != sm2->NbNodes() ) { RETURN_BAD_RESULT(" Diff nb of nodes on opposite edges" ); } if (smVfb->NbNodes() != 1 || smVlb->NbNodes() != 1 || smVft->NbNodes() != 1) { RETURN_BAD_RESULT("Empty submesh of vertex"); } // define whether mesh is quadratic bool isQuadraticMesh = false; SMDS_ElemIteratorPtr eIt = smFace->GetElements(); if ( !eIt->more() ) { RETURN_BAD_RESULT("No elements on the face"); } const SMDS_MeshElement* e = eIt->next(); isQuadraticMesh = e->IsQuadratic(); if ( sm1->NbNodes() * smb->NbNodes() != smFace->NbNodes() ) { // check quadratic case if ( isQuadraticMesh ) { // what if there are quadrangles and triangles mixed? // int n1 = sm1->NbNodes()/2; // int n2 = smb->NbNodes()/2; // int n3 = sm1->NbNodes() - n1; // int n4 = smb->NbNodes() - n2; // int nf = sm1->NbNodes()*smb->NbNodes() - n3*n4; // if( nf != smFace->NbNodes() ) { // MESSAGE( "Wrong nb face nodes: " << // sm1->NbNodes()<<" "<<smb->NbNodes()<<" "<<smFace->NbNodes()); // return false; // } } else { RETURN_BAD_RESULT( "Wrong nb face nodes: " << sm1->NbNodes()<<" "<<smb->NbNodes()<<" "<<smFace->NbNodes()); } } // IJ size int vsize = sm1->NbNodes() + 2; int hsize = smb->NbNodes() + 2; if(isQuadraticMesh) { vsize = vsize - sm1->NbNodes()/2 -1; hsize = hsize - smb->NbNodes()/2 -1; } // load nodes from theBaseEdge std::set<const SMDS_MeshNode*> loadedNodes; const SMDS_MeshNode* nullNode = 0; std::vector<const SMDS_MeshNode*> & nVecf = theParam2ColumnMap[ 0.]; nVecf.resize( vsize, nullNode ); loadedNodes.insert( nVecf[ 0 ] = smVfb->GetNodes()->next() ); std::vector<const SMDS_MeshNode*> & nVecl = theParam2ColumnMap[ 1.]; nVecl.resize( vsize, nullNode ); loadedNodes.insert( nVecl[ 0 ] = smVlb->GetNodes()->next() ); double f, l; BRep_Tool::Range( eFrw, f, l ); double range = l - f; SMDS_NodeIteratorPtr nIt = smb->GetNodes(); const SMDS_MeshNode* node; while ( nIt->more() ) { node = nIt->next(); if(IsMedium(node, SMDSAbs_Edge)) continue; const SMDS_EdgePosition* pos = dynamic_cast<const SMDS_EdgePosition*>( node->GetPosition().get() ); if ( !pos ) { return false; } double u = ( pos->GetUParameter() - f ) / range; std::vector<const SMDS_MeshNode*> & nVec = theParam2ColumnMap[ u ]; nVec.resize( vsize, nullNode ); loadedNodes.insert( nVec[ 0 ] = node ); } if ( theParam2ColumnMap.size() != hsize ) { RETURN_BAD_RESULT( "Wrong node positions on theBaseEdge" ); } // load nodes from e1 std::map< double, const SMDS_MeshNode*> sortedNodes; // sort by param on edge nIt = sm1->GetNodes(); while ( nIt->more() ) { node = nIt->next(); if(IsMedium(node)) continue; const SMDS_EdgePosition* pos = dynamic_cast<const SMDS_EdgePosition*>( node->GetPosition().get() ); if ( !pos ) { return false; } sortedNodes.insert( std::make_pair( pos->GetUParameter(), node )); } loadedNodes.insert( nVecf[ vsize - 1 ] = smVft->GetNodes()->next() ); std::map< double, const SMDS_MeshNode*>::iterator u_n = sortedNodes.begin(); int row = rev1 ? vsize - 1 : 0; int dRow = rev1 ? -1 : +1; for ( ; u_n != sortedNodes.end(); u_n++ ) { row += dRow; loadedNodes.insert( nVecf[ row ] = u_n->second ); } // try to load the rest nodes // get all faces from theFace TIDSortedElemSet allFaces, foundFaces; eIt = smFace->GetElements(); while ( eIt->more() ) { const SMDS_MeshElement* e = eIt->next(); if ( e->GetType() == SMDSAbs_Face ) allFaces.insert( e ); } // Starting from 2 neighbour nodes on theBaseEdge, look for a face // the nodes belong to, and between the nodes of the found face, // look for a not loaded node considering this node to be the next // in a column of the starting second node. Repeat, starting // from nodes next to the previous starting nodes in their columns, // and so on while a face can be found. Then go the the next pair // of nodes on theBaseEdge. TParam2ColumnMap::iterator par_nVec_1 = theParam2ColumnMap.begin(); TParam2ColumnMap::iterator par_nVec_2 = par_nVec_1; // loop on columns int col = 0; for ( par_nVec_2++; par_nVec_2 != theParam2ColumnMap.end(); par_nVec_1++, par_nVec_2++ ) { col++; row = 0; const SMDS_MeshNode* n1 = par_nVec_1->second[ row ]; const SMDS_MeshNode* n2 = par_nVec_2->second[ row ]; const SMDS_MeshElement* face = 0; bool lastColOnClosedFace = ( nVecf[ row ] == n2 ); do { // look for a face by 2 nodes face = SMESH_MeshEditor::FindFaceInSet( n1, n2, allFaces, foundFaces ); if ( face ) { int nbFaceNodes = face->NbNodes(); if ( face->IsQuadratic() ) nbFaceNodes /= 2; if ( nbFaceNodes>4 ) { RETURN_BAD_RESULT(" Too many nodes in a face: " << nbFaceNodes ); } // look for a not loaded node of the <face> bool found = false; const SMDS_MeshNode* n3 = 0; // a node defferent from n1 and n2 for ( int i = 0; i < nbFaceNodes && !found; ++i ) { node = face->GetNode( i ); found = loadedNodes.insert( node ).second; if ( !found && node != n1 && node != n2 ) n3 = node; } if ( lastColOnClosedFace && row + 1 < vsize ) { node = nVecf[ row + 1 ]; found = ( face->GetNodeIndex( node ) >= 0 ); } if ( found ) { if ( ++row > vsize - 1 ) { RETURN_BAD_RESULT( "Too many nodes in column "<< col <<": "<< row+1); } par_nVec_2->second[ row ] = node; foundFaces.insert( face ); n2 = node; if ( nbFaceNodes==4 ) { n1 = par_nVec_1->second[ row ]; } } else if ( nbFaceNodes==3 && n3 == par_nVec_1->second[ row + 1 ] ) { n1 = n3; } else { RETURN_BAD_RESULT( "Not quad mesh, column "<< col ); } } } while ( face && n1 && n2 ); if ( row < vsize - 1 ) { MESSAGE( "Too few nodes in column "<< col <<": "<< row+1); MESSAGE( "Base node 1: "<< par_nVec_1->second[0]); MESSAGE( "Base node 2: "<< par_nVec_2->second[0]); if ( n1 ) { MESSAGE( "Current node 1: "<< n1); } else { MESSAGE( "Current node 1: NULL"); } if ( n2 ) { MESSAGE( "Current node 2: "<< n2); } else { MESSAGE( "Current node 2: NULL"); } MESSAGE( "first base node: "<< theParam2ColumnMap.begin()->second[0]); MESSAGE( "last base node: "<< theParam2ColumnMap.rbegin()->second[0]); return false; } } // loop on columns return true; }
const vector<UVPtStruct>& StdMeshers_FaceSide::GetUVPtStruct(bool isXConst, double constValue) const { if ( myPoints.empty() ) { if ( NbEdges() == 0 ) return myPoints; SMESHDS_Mesh* meshDS = myMesh->GetMeshDS(); // sort nodes of all edges putting them into a map map< double, const SMDS_MeshNode*> u2node; //int nbOnDegen = 0; for ( int i = 0; i < myEdge.size(); ++i ) { // put 1st vertex node TopoDS_Vertex VFirst, VLast; TopExp::Vertices( myEdge[i], VFirst, VLast, true); const SMDS_MeshNode* node = SMESH_Algo::VertexNode( VFirst, meshDS ); double prevNormPar = ( i == 0 ? 0 : myNormPar[ i-1 ]); // normalized param if ( node ) { // internal nodes may be missing u2node.insert( make_pair( prevNormPar, node )); } else if ( i == 0 ) { MESSAGE(" NO NODE on VERTEX" ); return myPoints; } // put 2nd vertex node for a last edge if ( i+1 == myEdge.size() ) { node = SMESH_Algo::VertexNode( VLast, meshDS ); if ( !node ) { MESSAGE(" NO NODE on VERTEX" ); return myPoints; } u2node.insert( make_pair( 1., node )); } // put internal nodes SMESHDS_SubMesh* sm = meshDS->MeshElements( myEdge[i] ); if ( !sm ) continue; SMDS_NodeIteratorPtr nItr = sm->GetNodes(); double paramSize = myLast[i] - myFirst[i], r = myNormPar[i] - prevNormPar; while ( nItr->more() ) { const SMDS_MeshNode* node = nItr->next(); if ( myIgnoreMediumNodes && SMESH_MeshEditor::IsMedium( node, SMDSAbs_Edge )) continue; const SMDS_EdgePosition* epos = static_cast<const SMDS_EdgePosition*>(node->GetPosition().get()); double u = epos->GetUParameter(); // paramSize is signed so orientation is taken into account double normPar = prevNormPar + r * ( u - myFirst[i] ) / paramSize; #ifdef _DEBUG_ if ( normPar > 1 || normPar < 0) { dump("DEBUG"); MESSAGE ( "WRONG normPar: "<<normPar<< " prevNormPar="<<prevNormPar << " u="<<u << " myFirst[i]="<<myFirst[i]<< " myLast[i]="<<myLast[i] << " paramSize="<<paramSize ); } #endif u2node.insert( make_pair( normPar, node )); } } if ( u2node.size() != myNbPonits ) { MESSAGE("Wrong node parameters on edges, u2node.size():" <<u2node.size()<<" != myNbPonits:"<<myNbPonits); return myPoints; } // fill array of UVPtStruct vector<uvPtStruct>* points = const_cast<vector<uvPtStruct>*>( &myPoints ); points->resize( myNbPonits ); int EdgeIndex = 0; double prevNormPar = 0, paramSize = myNormPar[ EdgeIndex ]; map< double, const SMDS_MeshNode*>::iterator u_node = u2node.begin(); for (int i = 0 ; u_node != u2node.end(); ++u_node, ++i ) { UVPtStruct & uvPt = (*points)[i]; uvPt.node = u_node->second; uvPt.x = uvPt.y = uvPt.normParam = u_node->first; if ( isXConst ) uvPt.x = constValue; else uvPt.y = constValue; if ( myNormPar[ EdgeIndex ] < uvPt.normParam ) { prevNormPar = myNormPar[ EdgeIndex ]; ++EdgeIndex; #ifdef _DEBUG_ if ( EdgeIndex >= myEdge.size() ) { dump("DEBUG"); MESSAGE ( "WRONg EdgeIndex " << 1+EdgeIndex << " myNormPar.size()="<<myNormPar.size() << " myNormPar["<< EdgeIndex<<"]="<< myNormPar[ EdgeIndex ] << " uvPt.normParam="<<uvPt.normParam ); } #endif paramSize = myNormPar[ EdgeIndex ] - prevNormPar; } const SMDS_EdgePosition* epos = dynamic_cast<const SMDS_EdgePosition*>(uvPt.node->GetPosition().get()); if ( epos ) { uvPt.param = epos->GetUParameter(); } else { double r = ( uvPt.normParam - prevNormPar )/ paramSize; // uvPt.param = myFirst[EdgeIndex] * ( 1 - r ) + myLast[EdgeIndex] * r; uvPt.param = ( r > 0.5 ? myLast[EdgeIndex] : myFirst[EdgeIndex] ); } if ( !myC2d[ EdgeIndex ].IsNull() ) { gp_Pnt2d p = myC2d[ EdgeIndex ]->Value( uvPt.param ); uvPt.u = p.X(); uvPt.v = p.Y(); } else { uvPt.u = uvPt.v = 1e+100; } } } return myPoints; }