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::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; }
bool StdMeshers_Projection_3D::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape) { if ( !_sourceHypo ) return false; SMESH_Mesh * srcMesh = _sourceHypo->GetSourceMesh(); SMESH_Mesh * tgtMesh = & aMesh; if ( !srcMesh ) srcMesh = tgtMesh; SMESHDS_Mesh * srcMeshDS = srcMesh->GetMeshDS(); SMESHDS_Mesh * tgtMeshDS = tgtMesh->GetMeshDS(); // get shell from shape3D TopoDS_Shell srcShell, tgtShell; TopExp_Explorer exp( _sourceHypo->GetSource3DShape(), TopAbs_SHELL ); int nbShell; for ( nbShell = 0; exp.More(); exp.Next(), ++nbShell ) srcShell = TopoDS::Shell( exp.Current() ); if ( nbShell != 1 ) return error(COMPERR_BAD_SHAPE, SMESH_Comment("Source shape must have 1 shell but not ") << nbShell); exp.Init( aShape, TopAbs_SHELL ); for ( nbShell = 0; exp.More(); exp.Next(), ++nbShell ) tgtShell = TopoDS::Shell( exp.Current() ); if ( nbShell != 1 ) return error(COMPERR_BAD_SHAPE, SMESH_Comment("Target shape must have 1 shell but not ") << nbShell); // Check that shapes are blocks if ( TAssocTool::Count( tgtShell, TopAbs_FACE , 1 ) != 6 || TAssocTool::Count( tgtShell, TopAbs_EDGE , 1 ) != 12 || TAssocTool::Count( tgtShell, TopAbs_WIRE , 1 ) != 6 ) return error(COMPERR_BAD_SHAPE, "Target shape is not a block"); if ( TAssocTool::Count( srcShell, TopAbs_FACE , 1 ) != 6 || TAssocTool::Count( srcShell, TopAbs_EDGE , 1 ) != 12 || TAssocTool::Count( srcShell, TopAbs_WIRE , 1 ) != 6 ) return error(COMPERR_BAD_SHAPE, "Source shape is not a block"); // Assure that mesh on a source shape is computed SMESH_subMesh* srcSubMesh = srcMesh->GetSubMesh( _sourceHypo->GetSource3DShape() ); //SMESH_subMesh* tgtSubMesh = tgtMesh->GetSubMesh( aShape ); if ( tgtMesh == srcMesh && !aShape.IsSame( _sourceHypo->GetSource3DShape() )) { if ( !TAssocTool::MakeComputed( srcSubMesh )) return error(COMPERR_BAD_INPUT_MESH,"Source mesh not computed"); } else { if ( !srcSubMesh->IsMeshComputed() ) return error(COMPERR_BAD_INPUT_MESH,"Source mesh not computed"); } // Find 2 pairs of corresponding vertices TopoDS_Vertex tgtV000, tgtV100, srcV000, srcV100; TAssocTool::TShapeShapeMap shape2ShapeMap; if ( _sourceHypo->HasVertexAssociation() ) { tgtV000 = _sourceHypo->GetTargetVertex(1); tgtV100 = _sourceHypo->GetTargetVertex(2); srcV000 = _sourceHypo->GetSourceVertex(1); srcV100 = _sourceHypo->GetSourceVertex(2); } else { if ( !TAssocTool::FindSubShapeAssociation( tgtShell, tgtMesh, srcShell, srcMesh, shape2ShapeMap) ) return error(COMPERR_BAD_SHAPE,"Topology of source and target shapes seems different" ); exp.Init( tgtShell, TopAbs_EDGE ); TopExp::Vertices( TopoDS::Edge( exp.Current() ), tgtV000, tgtV100 ); if ( !shape2ShapeMap.IsBound( tgtV000 ) || !shape2ShapeMap.IsBound( tgtV100 )) return error("Association of subshapes failed" ); srcV000 = TopoDS::Vertex( shape2ShapeMap( tgtV000 )); srcV100 = TopoDS::Vertex( shape2ShapeMap( tgtV100 )); if ( !TAssocTool::IsSubShape( srcV000, srcShell ) || !TAssocTool::IsSubShape( srcV100, srcShell )) return error("Incorrect association of subshapes" ); } // Load 2 SMESH_Block's with src and tgt shells SMESH_Block srcBlock, tgtBlock; TopTools_IndexedMapOfOrientedShape scrShapes, tgtShapes; if ( !tgtBlock.LoadBlockShapes( tgtShell, tgtV000, tgtV100, tgtShapes )) return error(COMPERR_BAD_SHAPE, "Can't detect block subshapes. Not a block?"); if ( !srcBlock.LoadBlockShapes( srcShell, srcV000, srcV100, scrShapes )) return error(COMPERR_BAD_SHAPE, "Can't detect block subshapes. Not a block?"); // Find matching nodes of src and tgt shells TNodeNodeMap src2tgtNodeMap; for ( int fId = SMESH_Block::ID_FirstF; fId < SMESH_Block::ID_Shell; ++fId ) { // Corresponding subshapes TopoDS_Face srcFace = TopoDS::Face( scrShapes( fId )); TopoDS_Face tgtFace = TopoDS::Face( tgtShapes( fId )); if ( _sourceHypo->HasVertexAssociation() ) { // associate face subshapes shape2ShapeMap.Clear(); vector< int > edgeIdVec; SMESH_Block::GetFaceEdgesIDs( fId, edgeIdVec ); for ( int i = 0; i < edgeIdVec.size(); ++i ) { int eID = edgeIdVec[ i ]; shape2ShapeMap.Bind( tgtShapes( eID ), scrShapes( eID )); if ( i < 2 ) { vector< int > vertexIdVec; SMESH_Block::GetEdgeVertexIDs( eID, vertexIdVec ); shape2ShapeMap.Bind( tgtShapes( vertexIdVec[0] ), scrShapes( vertexIdVec[0] )); shape2ShapeMap.Bind( tgtShapes( vertexIdVec[1] ), scrShapes( vertexIdVec[1] )); } } } // Find matching nodes of tgt and src faces TNodeNodeMap faceMatchingNodes; if ( ! TAssocTool::FindMatchingNodesOnFaces( srcFace, srcMesh, tgtFace, tgtMesh, shape2ShapeMap, faceMatchingNodes )) return error(COMPERR_BAD_INPUT_MESH,SMESH_Comment("Mesh on faces #") << srcMeshDS->ShapeToIndex( srcFace ) << " and " << tgtMeshDS->ShapeToIndex( tgtFace ) << " seems different" ); // put found matching nodes of 2 faces to the global map src2tgtNodeMap.insert( faceMatchingNodes.begin(), faceMatchingNodes.end() ); } // ------------------ // Make mesh // ------------------ SMDS_VolumeTool volTool; SMESH_MesherHelper helper( *tgtMesh ); helper.IsQuadraticSubMesh( aShape ); SMESHDS_SubMesh* srcSMDS = srcSubMesh->GetSubMeshDS(); SMDS_ElemIteratorPtr volIt = srcSMDS->GetElements(); while ( volIt->more() ) // loop on source volumes { const SMDS_MeshElement* srcVol = volIt->next(); if ( !srcVol || srcVol->GetType() != SMDSAbs_Volume ) continue; int nbNodes = srcVol->NbNodes(); SMDS_VolumeTool::VolumeType volType = volTool.GetType( nbNodes ); if ( srcVol->IsQuadratic() ) nbNodes = volTool.NbCornerNodes( volType ); // Find or create a new tgt node for each node of a src volume vector< const SMDS_MeshNode* > nodes( nbNodes ); for ( int i = 0; i < nbNodes; ++i ) { const SMDS_MeshNode* srcNode = srcVol->GetNode( i ); const SMDS_MeshNode* tgtNode = 0; TNodeNodeMap::iterator sN_tN = src2tgtNodeMap.find( srcNode ); if ( sN_tN != src2tgtNodeMap.end() ) // found { tgtNode = sN_tN->second; } else // Create a new tgt node { // compute normalized parameters of source node in srcBlock gp_Pnt srcCoord = gpXYZ( srcNode ); gp_XYZ srcParam; if ( !srcBlock.ComputeParameters( srcCoord, srcParam )) return error(SMESH_Comment("Can't compute normalized parameters ") << "for source node " << srcNode->GetID()); // compute coordinates of target node by srcParam gp_XYZ tgtXYZ; if ( !tgtBlock.ShellPoint( srcParam, tgtXYZ )) return error("Can't compute coordinates by normalized parameters"); // add node SMDS_MeshNode* newNode = tgtMeshDS->AddNode( tgtXYZ.X(), tgtXYZ.Y(), tgtXYZ.Z() ); tgtMeshDS->SetNodeInVolume( newNode, helper.GetSubShapeID() ); tgtNode = newNode; src2tgtNodeMap.insert( make_pair( srcNode, tgtNode )); } nodes[ i ] = tgtNode; } // Create a new volume SMDS_MeshVolume * tgtVol = 0; int id = 0, force3d = false; switch ( volType ) { case SMDS_VolumeTool::TETRA : case SMDS_VolumeTool::QUAD_TETRA: tgtVol = helper.AddVolume( nodes[0], nodes[1], nodes[2], nodes[3], id, force3d); break; case SMDS_VolumeTool::PYRAM : case SMDS_VolumeTool::QUAD_PYRAM: tgtVol = helper.AddVolume( nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], id, force3d); break; case SMDS_VolumeTool::PENTA : case SMDS_VolumeTool::QUAD_PENTA: tgtVol = helper.AddVolume( nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], id, force3d); break; case SMDS_VolumeTool::HEXA : case SMDS_VolumeTool::QUAD_HEXA : tgtVol = helper.AddVolume( nodes[0], nodes[1], nodes[2], nodes[3], nodes[4], nodes[5], nodes[6], nodes[7], id, force3d); break; default: // polyhedron const SMDS_PolyhedralVolumeOfNodes * poly = dynamic_cast<const SMDS_PolyhedralVolumeOfNodes*>( srcVol ); if ( !poly ) RETURN_BAD_RESULT("Unexpected volume type"); tgtVol = tgtMeshDS->AddPolyhedralVolume( nodes, poly->GetQuanities() ); } if ( tgtVol ) { tgtMeshDS->SetMeshElementOnShape( tgtVol, helper.GetSubShapeID() ); } } // loop on volumes of src shell return true; }
bool NETGENPlugin_NETGEN_2D_ONLY::Compute(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape) { netgen::multithread.terminate = 0; //netgen::multithread.task = "Surface meshing"; SMESHDS_Mesh* meshDS = aMesh.GetMeshDS(); SMESH_MesherHelper helper(aMesh); helper.SetElementsOnShape( true ); NETGENPlugin_NetgenLibWrapper ngLib; ngLib._isComputeOk = false; netgen::Mesh ngMeshNoLocSize; #if NETGEN_VERSION < 6 netgen::Mesh * ngMeshes[2] = { (netgen::Mesh*) ngLib._ngMesh, & ngMeshNoLocSize }; #else netgen::Mesh * ngMeshes[2] = { (netgen::Mesh*) ngLib._ngMesh.get(), & ngMeshNoLocSize }; #endif netgen::OCCGeometry occgeoComm; // min / max sizes are set as follows: // if ( _hypParameters ) // min and max are defined by the user // else if ( _hypLengthFromEdges ) // min = aMesher.GetDefaultMinSize() // max = average segment len of a FACE // else if ( _hypMaxElementArea ) // min = aMesher.GetDefaultMinSize() // max = f( _hypMaxElementArea ) // else // min = aMesher.GetDefaultMinSize() // max = max segment len of a FACE NETGENPlugin_Mesher aMesher( &aMesh, aShape, /*isVolume=*/false); aMesher.SetParameters( _hypParameters ); // _hypParameters -> netgen::mparam const bool toOptimize = _hypParameters ? _hypParameters->GetOptimize() : true; if ( _hypMaxElementArea ) { netgen::mparam.maxh = sqrt( 2. * _hypMaxElementArea->GetMaxArea() / sqrt(3.0) ); } if ( _hypQuadranglePreference ) netgen::mparam.quad = true; // local size is common for all FACEs in aShape? const bool isCommonLocalSize = ( !_hypLengthFromEdges && !_hypMaxElementArea && netgen::mparam.uselocalh ); const bool isDefaultHyp = ( !_hypLengthFromEdges && !_hypMaxElementArea && !_hypParameters ); if ( isCommonLocalSize ) // compute common local size in ngMeshes[0] { //list< SMESH_subMesh* > meshedSM[4]; --> all sub-shapes are added to occgeoComm aMesher.PrepareOCCgeometry( occgeoComm, aShape, aMesh );//, meshedSM ); // local size set at MESHCONST_ANALYSE step depends on // minh, face_maxh, grading and curvaturesafety; find minh if not set by the user if ( !_hypParameters || netgen::mparam.minh < DBL_MIN ) { if ( !_hypParameters ) netgen::mparam.maxh = occgeoComm.GetBoundingBox().Diam() / 3.; netgen::mparam.minh = aMesher.GetDefaultMinSize( aShape, netgen::mparam.maxh ); } // set local size depending on curvature and NOT closeness of EDGEs netgen::occparam.resthcloseedgeenable = false; //netgen::occparam.resthcloseedgefac = 1.0 + netgen::mparam.grading; occgeoComm.face_maxh = netgen::mparam.maxh; netgen::OCCSetLocalMeshSize( occgeoComm, *ngMeshes[0] ); occgeoComm.emap.Clear(); occgeoComm.vmap.Clear(); // set local size according to size of existing segments const double factor = netgen::occparam.resthcloseedgefac; TopTools_IndexedMapOfShape edgeMap; TopExp::MapShapes( aMesh.GetShapeToMesh(), TopAbs_EDGE, edgeMap ); for ( int iE = 1; iE <= edgeMap.Extent(); ++iE ) { const TopoDS_Shape& edge = edgeMap( iE ); if ( SMESH_Algo::isDegenerated( TopoDS::Edge( edge ))/* || helper.IsSubShape( edge, aShape )*/) continue; SMESHDS_SubMesh* smDS = meshDS->MeshElements( edge ); if ( !smDS ) continue; SMDS_ElemIteratorPtr segIt = smDS->GetElements(); while ( segIt->more() ) { const SMDS_MeshElement* seg = segIt->next(); SMESH_TNodeXYZ n1 = seg->GetNode(0); SMESH_TNodeXYZ n2 = seg->GetNode(1); gp_XYZ p = 0.5 * ( n1 + n2 ); netgen::Point3d pi(p.X(), p.Y(), p.Z()); ngMeshes[0]->RestrictLocalH( pi, factor * ( n1 - n2 ).Modulus() ); } } } netgen::mparam.uselocalh = toOptimize; // restore as it is used at surface optimization // ================== // Loop on all FACEs // ================== vector< const SMDS_MeshNode* > nodeVec; TopExp_Explorer fExp( aShape, TopAbs_FACE ); for ( int iF = 0; fExp.More(); fExp.Next(), ++iF ) { TopoDS_Face F = TopoDS::Face( fExp.Current() /*.Oriented( TopAbs_FORWARD )*/); int faceID = meshDS->ShapeToIndex( F ); SMESH_ComputeErrorPtr& faceErr = aMesh.GetSubMesh( F )->GetComputeError(); _quadraticMesh = helper.IsQuadraticSubMesh( F ); const bool ignoreMediumNodes = _quadraticMesh; // build viscous layers if required if ( F.Orientation() != TopAbs_FORWARD && F.Orientation() != TopAbs_REVERSED ) F.Orientation( TopAbs_FORWARD ); // avoid pb with TopAbs_INTERNAL SMESH_ProxyMesh::Ptr proxyMesh = StdMeshers_ViscousLayers2D::Compute( aMesh, F ); if ( !proxyMesh ) continue; // ------------------------ // get all EDGEs of a FACE // ------------------------ TSideVector wires = StdMeshers_FaceSide::GetFaceWires( F, aMesh, ignoreMediumNodes, faceErr, proxyMesh ); if ( faceErr && !faceErr->IsOK() ) continue; int nbWires = wires.size(); if ( nbWires == 0 ) { faceErr.reset ( new SMESH_ComputeError ( COMPERR_ALGO_FAILED, "Problem in StdMeshers_FaceSide::GetFaceWires()" )); continue; } if ( wires[0]->NbSegments() < 3 ) // ex: a circle with 2 segments { faceErr.reset ( new SMESH_ComputeError ( COMPERR_BAD_INPUT_MESH, SMESH_Comment("Too few segments: ")<<wires[0]->NbSegments()) ); continue; } // ---------------------- // compute maxh of a FACE // ---------------------- if ( !_hypParameters ) { double edgeLength = 0; if (_hypLengthFromEdges ) { // compute edgeLength as an average segment length int nbSegments = 0; for ( int iW = 0; iW < nbWires; ++iW ) { edgeLength += wires[ iW ]->Length(); nbSegments += wires[ iW ]->NbSegments(); } if ( nbSegments ) edgeLength /= nbSegments; netgen::mparam.maxh = edgeLength; } else if ( isDefaultHyp ) { // set edgeLength by a longest segment double maxSeg2 = 0; for ( int iW = 0; iW < nbWires; ++iW ) { const UVPtStructVec& points = wires[ iW ]->GetUVPtStruct(); if ( points.empty() ) return error( COMPERR_BAD_INPUT_MESH ); gp_Pnt pPrev = SMESH_TNodeXYZ( points[0].node ); for ( size_t i = 1; i < points.size(); ++i ) { gp_Pnt p = SMESH_TNodeXYZ( points[i].node ); maxSeg2 = Max( maxSeg2, p.SquareDistance( pPrev )); pPrev = p; } } edgeLength = sqrt( maxSeg2 ) * 1.05; netgen::mparam.maxh = edgeLength; } if ( netgen::mparam.maxh < DBL_MIN ) netgen::mparam.maxh = occgeoComm.GetBoundingBox().Diam(); if ( !isCommonLocalSize ) { netgen::mparam.minh = aMesher.GetDefaultMinSize( F, netgen::mparam.maxh ); } } // prepare occgeom netgen::OCCGeometry occgeom; occgeom.shape = F; occgeom.fmap.Add( F ); occgeom.CalcBoundingBox(); occgeom.facemeshstatus.SetSize(1); occgeom.facemeshstatus = 0; occgeom.face_maxh_modified.SetSize(1); occgeom.face_maxh_modified = 0; occgeom.face_maxh.SetSize(1); occgeom.face_maxh = netgen::mparam.maxh; // ------------------------- // Fill netgen mesh // ------------------------- // MESHCONST_ANALYSE step may lead to a failure, so we make an attempt // w/o MESHCONST_ANALYSE at the second loop int err = 0; enum { LOC_SIZE, NO_LOC_SIZE }; int iLoop = isCommonLocalSize ? 0 : 1; for ( ; iLoop < 2; iLoop++ ) { //bool isMESHCONST_ANALYSE = false; InitComputeError(); netgen::Mesh * ngMesh = ngMeshes[ iLoop ]; ngMesh->DeleteMesh(); if ( iLoop == NO_LOC_SIZE ) { ngMesh->SetGlobalH ( mparam.maxh ); ngMesh->SetMinimalH( mparam.minh ); Box<3> bb = occgeom.GetBoundingBox(); bb.Increase (bb.Diam()/10); ngMesh->SetLocalH (bb.PMin(), bb.PMax(), mparam.grading); } nodeVec.clear(); faceErr = aMesher.AddSegmentsToMesh( *ngMesh, occgeom, wires, helper, nodeVec, /*overrideMinH=*/!_hypParameters); if ( faceErr && !faceErr->IsOK() ) break; //if ( !isCommonLocalSize ) //limitSize( ngMesh, mparam.maxh * 0.8); // ------------------------- // Generate surface mesh // ------------------------- const int startWith = MESHCONST_MESHSURFACE; const int endWith = toOptimize ? MESHCONST_OPTSURFACE : MESHCONST_MESHSURFACE; SMESH_Comment str; try { OCC_CATCH_SIGNALS; #if NETGEN_VERSION >=6 std::shared_ptr<netgen::Mesh> mesh_ptr(ngMesh, [](netgen::Mesh*) {}); err = netgen::OCCGenerateMesh(occgeom, mesh_ptr, netgen::mparam, startWith, endWith); #elif NETGEN_VERSION > 4 err = netgen::OCCGenerateMesh(occgeom, ngMesh, netgen::mparam, startWith, endWith); #else char *optstr = 0; err = netgen::OCCGenerateMesh(occgeom, ngMesh, startWith, endWith, optstr); #endif if ( netgen::multithread.terminate ) return false; if ( err ) str << "Error in netgen::OCCGenerateMesh() at " << netgen::multithread.task; } catch (Standard_Failure& ex) { err = 1; str << "Exception in netgen::OCCGenerateMesh()" << " at " << netgen::multithread.task << ": " << ex.DynamicType()->Name(); if ( ex.GetMessageString() && strlen( ex.GetMessageString() )) str << ": " << ex.GetMessageString(); } catch (...) { err = 1; str << "Exception in netgen::OCCGenerateMesh()" << " at " << netgen::multithread.task; } if ( err ) { if ( aMesher.FixFaceMesh( occgeom, *ngMesh, 1 )) break; if ( iLoop == LOC_SIZE ) { netgen::mparam.minh = netgen::mparam.maxh; netgen::mparam.maxh = 0; for ( int iW = 0; iW < wires.size(); ++iW ) { StdMeshers_FaceSidePtr wire = wires[ iW ]; const vector<UVPtStruct>& uvPtVec = wire->GetUVPtStruct(); for ( size_t iP = 1; iP < uvPtVec.size(); ++iP ) { SMESH_TNodeXYZ p( uvPtVec[ iP ].node ); netgen::Point3d np( p.X(),p.Y(),p.Z()); double segLen = p.Distance( uvPtVec[ iP-1 ].node ); double size = ngMesh->GetH( np ); netgen::mparam.minh = Min( netgen::mparam.minh, size ); netgen::mparam.maxh = Max( netgen::mparam.maxh, segLen ); } } //cerr << "min " << netgen::mparam.minh << " max " << netgen::mparam.maxh << endl; netgen::mparam.minh *= 0.9; netgen::mparam.maxh *= 1.1; continue; } else { faceErr.reset( new SMESH_ComputeError( COMPERR_ALGO_FAILED, str )); } } // ---------------------------------------------------- // Fill the SMESHDS with the generated nodes and faces // ---------------------------------------------------- int nbNodes = ngMesh->GetNP(); int nbFaces = ngMesh->GetNSE(); int nbInputNodes = nodeVec.size()-1; nodeVec.resize( nbNodes+1, 0 ); // add nodes for ( int ngID = nbInputNodes + 1; ngID <= nbNodes; ++ngID ) { const MeshPoint& ngPoint = ngMesh->Point( ngID ); SMDS_MeshNode * node = meshDS->AddNode(ngPoint(0), ngPoint(1), ngPoint(2)); nodeVec[ ngID ] = node; } // create faces int i,j; vector<const SMDS_MeshNode*> nodes; for ( i = 1; i <= nbFaces ; ++i ) { const Element2d& elem = ngMesh->SurfaceElement(i); nodes.resize( elem.GetNP() ); for (j=1; j <= elem.GetNP(); ++j) { int pind = elem.PNum(j); if ( pind < 1 ) break; nodes[ j-1 ] = nodeVec[ pind ]; if ( nodes[ j-1 ]->GetPosition()->GetTypeOfPosition() == SMDS_TOP_3DSPACE ) { const PointGeomInfo& pgi = elem.GeomInfoPi(j); meshDS->SetNodeOnFace( nodes[ j-1 ], faceID, pgi.u, pgi.v); } } if ( j > elem.GetNP() ) { SMDS_MeshFace* face = 0; if ( elem.GetType() == TRIG ) face = helper.AddFace(nodes[0],nodes[1],nodes[2]); else face = helper.AddFace(nodes[0],nodes[1],nodes[2],nodes[3]); } } break; } // two attempts } // loop on FACEs return true; }
bool StdMeshers_Hexa_3D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape)// throw(SALOME_Exception) { // PAL14921. Enable catching std::bad_alloc and Standard_OutOfMemory outside //Unexpect aCatch(SalomeException); MESSAGE("StdMeshers_Hexa_3D::Compute"); SMESHDS_Mesh * meshDS = aMesh.GetMeshDS(); // 0. - shape and face mesh verification // 0.1 - shape must be a solid (or a shell) with 6 faces vector < SMESH_subMesh * >meshFaces; for (TopExp_Explorer exp(aShape, TopAbs_FACE); exp.More(); exp.Next()) { SMESH_subMesh *aSubMesh = aMesh.GetSubMeshContaining(exp.Current()); ASSERT(aSubMesh); meshFaces.push_back(aSubMesh); } if (meshFaces.size() != 6) { //return error(COMPERR_BAD_SHAPE, TComm(meshFaces.size())<<" instead of 6 faces in a block"); static StdMeshers_CompositeHexa_3D compositeHexa(-10, 0, aMesh.GetGen()); if ( !compositeHexa.Compute( aMesh, aShape )) return error( compositeHexa.GetComputeError() ); return true; } // 0.2 - is each face meshed with Quadrangle_2D? (so, with a wire of 4 edges) // tool for working with quadratic elements SMESH_MesherHelper aTool (aMesh); _quadraticMesh = aTool.IsQuadraticSubMesh(aShape); // cube structure typedef struct cubeStruct { TopoDS_Vertex V000; TopoDS_Vertex V001; TopoDS_Vertex V010; TopoDS_Vertex V011; TopoDS_Vertex V100; TopoDS_Vertex V101; TopoDS_Vertex V110; TopoDS_Vertex V111; faceQuadStruct* quad_X0; faceQuadStruct* quad_X1; faceQuadStruct* quad_Y0; faceQuadStruct* quad_Y1; faceQuadStruct* quad_Z0; faceQuadStruct* quad_Z1; Point3DStruct* np; // normalised 3D coordinates } CubeStruct; CubeStruct aCube; // bounding faces FaceQuadStruct* aQuads[6]; for (int i = 0; i < 6; i++) aQuads[i] = 0; for (int i = 0; i < 6; i++) { TopoDS_Shape aFace = meshFaces[i]->GetSubShape(); SMESH_Algo *algo = _gen->GetAlgo(aMesh, aFace); string algoName = algo->GetName(); bool isAllQuad = false; if (algoName == "Quadrangle_2D") { SMESHDS_SubMesh * sm = meshDS->MeshElements( aFace ); if ( sm ) { isAllQuad = true; SMDS_ElemIteratorPtr eIt = sm->GetElements(); while ( isAllQuad && eIt->more() ) { const SMDS_MeshElement* elem = eIt->next(); isAllQuad = ( elem->NbNodes()==4 ||(_quadraticMesh && elem->NbNodes()==8) ); } } } if ( ! isAllQuad ) { SMESH_ComputeErrorPtr err = ComputePentahedralMesh(aMesh, aShape); return ClearAndReturn( aQuads, error(err)); } StdMeshers_Quadrangle_2D *quadAlgo = dynamic_cast < StdMeshers_Quadrangle_2D * >(algo); ASSERT(quadAlgo); try { aQuads[i] = quadAlgo->CheckAnd2Dcompute(aMesh, aFace, _quadraticMesh); if(!aQuads[i]) { return error( quadAlgo->GetComputeError()); } } catch(SALOME_Exception & S_ex) { return ClearAndReturn( aQuads, error(COMPERR_SLM_EXCEPTION,TComm(S_ex.what()) << " Raised by StdMeshers_Quadrangle_2D " " on face #" << meshDS->ShapeToIndex( aFace ))); } // 0.2.1 - number of points on the opposite edges must be the same if (aQuads[i]->side[0]->NbPoints() != aQuads[i]->side[2]->NbPoints() || aQuads[i]->side[1]->NbPoints() != aQuads[i]->side[3]->NbPoints() /*aQuads[i]->side[0]->NbEdges() != 1 || aQuads[i]->side[1]->NbEdges() != 1 || aQuads[i]->side[2]->NbEdges() != 1 || aQuads[i]->side[3]->NbEdges() != 1*/) { MESSAGE("different number of points on the opposite edges of face " << i); // Try to go into penta algorithm 'cause it has been improved. SMESH_ComputeErrorPtr err = ComputePentahedralMesh(aMesh, aShape); return ClearAndReturn( aQuads, error(err)); } } // 1. - identify faces and vertices of the "cube" // 1.1 - ancestor maps vertex->edges in the cube // TopTools_IndexedDataMapOfShapeListOfShape MS; // TopExp::MapShapesAndAncestors(aShape, TopAbs_VERTEX, TopAbs_EDGE, MS); // 1.2 - first face is choosen as face Y=0 of the unit cube const TopoDS_Shape & aFace = meshFaces[0]->GetSubShape(); //const TopoDS_Face & F = TopoDS::Face(aFace); // 1.3 - identify the 4 vertices of the face Y=0: V000, V100, V101, V001 aCube.V000 = aQuads[0]->side[0]->FirstVertex(); // will be (0,0,0) on the unit cube aCube.V100 = aQuads[0]->side[0]->LastVertex(); // will be (1,0,0) on the unit cube aCube.V001 = aQuads[0]->side[2]->FirstVertex(); // will be (0,0,1) on the unit cube aCube.V101 = aQuads[0]->side[2]->LastVertex(); // will be (1,0,1) on the unit cube TopTools_IndexedMapOfShape MV0; TopExp::MapShapes(aFace, TopAbs_VERTEX, MV0); aCube.V010 = OppositeVertex( aCube.V000, MV0, aQuads); aCube.V110 = OppositeVertex( aCube.V100, MV0, aQuads); aCube.V011 = OppositeVertex( aCube.V001, MV0, aQuads); aCube.V111 = OppositeVertex( aCube.V101, MV0, aQuads); // 1.6 - find remaining faces given 4 vertices int _indY0 = 0; int _indY1 = GetFaceIndex(aMesh, aShape, meshFaces, aCube.V010, aCube.V011, aCube.V110, aCube.V111); int _indZ0 = GetFaceIndex(aMesh, aShape, meshFaces, aCube.V000, aCube.V010, aCube.V100, aCube.V110); int _indZ1 = GetFaceIndex(aMesh, aShape, meshFaces, aCube.V001, aCube.V011, aCube.V101, aCube.V111); int _indX0 = GetFaceIndex(aMesh, aShape, meshFaces, aCube.V000, aCube.V001, aCube.V010, aCube.V011); int _indX1 = GetFaceIndex(aMesh, aShape, meshFaces, aCube.V100, aCube.V101, aCube.V110, aCube.V111); // IPAL21120: SIGSEGV on Meshing attached Compound with Automatic Hexadralization if ( _indY1 < 1 || _indZ0 < 1 || _indZ1 < 1 || _indX0 < 1 || _indX1 < 1 ) return error(COMPERR_BAD_SHAPE); aCube.quad_Y0 = aQuads[_indY0]; aCube.quad_Y1 = aQuads[_indY1]; aCube.quad_Z0 = aQuads[_indZ0]; aCube.quad_Z1 = aQuads[_indZ1]; aCube.quad_X0 = aQuads[_indX0]; aCube.quad_X1 = aQuads[_indX1]; // 1.7 - get convertion coefs from face 2D normalized to 3D normalized Conv2DStruct cx0; // for face X=0 Conv2DStruct cx1; // for face X=1 Conv2DStruct cy0; Conv2DStruct cy1; Conv2DStruct cz0; Conv2DStruct cz1; GetConv2DCoefs(*aCube.quad_X0, meshFaces[_indX0]->GetSubShape(), aCube.V000, aCube.V010, aCube.V011, aCube.V001, cx0); GetConv2DCoefs(*aCube.quad_X1, meshFaces[_indX1]->GetSubShape(), aCube.V100, aCube.V110, aCube.V111, aCube.V101, cx1); GetConv2DCoefs(*aCube.quad_Y0, meshFaces[_indY0]->GetSubShape(), aCube.V000, aCube.V100, aCube.V101, aCube.V001, cy0); GetConv2DCoefs(*aCube.quad_Y1, meshFaces[_indY1]->GetSubShape(), aCube.V010, aCube.V110, aCube.V111, aCube.V011, cy1); GetConv2DCoefs(*aCube.quad_Z0, meshFaces[_indZ0]->GetSubShape(), aCube.V000, aCube.V100, aCube.V110, aCube.V010, cz0); GetConv2DCoefs(*aCube.quad_Z1, meshFaces[_indZ1]->GetSubShape(), aCube.V001, aCube.V101, aCube.V111, aCube.V011, cz1); // 1.8 - create a 3D structure for normalized values int nbx = aCube.quad_Z0->side[0]->NbPoints(); if (cz0.a1 == 0.) nbx = aCube.quad_Z0->side[1]->NbPoints(); int nby = aCube.quad_X0->side[0]->NbPoints(); if (cx0.a1 == 0.) nby = aCube.quad_X0->side[1]->NbPoints(); int nbz = aCube.quad_Y0->side[0]->NbPoints(); if (cy0.a1 != 0.) nbz = aCube.quad_Y0->side[1]->NbPoints(); int i1, j1, nbxyz = nbx * nby * nbz; Point3DStruct *np = new Point3DStruct[nbxyz]; // 1.9 - store node indexes of faces { const TopoDS_Face & F = TopoDS::Face(meshFaces[_indX0]->GetSubShape()); faceQuadStruct *quad = aCube.quad_X0; int i = 0; // j = x/face , k = y/face int nbdown = quad->side[0]->NbPoints(); int nbright = quad->side[1]->NbPoints(); SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes(); while(itf->more()) { const SMDS_MeshNode * node = itf->next(); if(aTool.IsMedium(node)) continue; if ( !findIJ( node, quad, i1, j1 )) return ClearAndReturn( aQuads, false ); int ij1 = j1 * nbdown + i1; quad->uv_grid[ij1].node = node; } for (int i1 = 0; i1 < nbdown; i1++) for (int j1 = 0; j1 < nbright; j1++) { int ij1 = j1 * nbdown + i1; int j = cx0.ia * i1 + cx0.ib * j1 + cx0.ic; // j = x/face int k = cx0.ja * i1 + cx0.jb * j1 + cx0.jc; // k = y/face int ijk = k * nbx * nby + j * nbx + i; //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk); np[ijk].node = quad->uv_grid[ij1].node; //SCRUTE(np[ijk].nodeId); } } { const TopoDS_Face & F = TopoDS::Face(meshFaces[_indX1]->GetSubShape()); SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes(); faceQuadStruct *quad = aCube.quad_X1; int i = nbx - 1; // j = x/face , k = y/face int nbdown = quad->side[0]->NbPoints(); int nbright = quad->side[1]->NbPoints(); while(itf->more()) { const SMDS_MeshNode * node = itf->next(); if(aTool.IsMedium(node)) continue; if ( !findIJ( node, quad, i1, j1 )) return ClearAndReturn( aQuads, false ); int ij1 = j1 * nbdown + i1; quad->uv_grid[ij1].node = node; } for (int i1 = 0; i1 < nbdown; i1++) for (int j1 = 0; j1 < nbright; j1++) { int ij1 = j1 * nbdown + i1; int j = cx1.ia * i1 + cx1.ib * j1 + cx1.ic; // j = x/face int k = cx1.ja * i1 + cx1.jb * j1 + cx1.jc; // k = y/face int ijk = k * nbx * nby + j * nbx + i; //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk); np[ijk].node = quad->uv_grid[ij1].node; //SCRUTE(np[ijk].nodeId); } } { const TopoDS_Face & F = TopoDS::Face(meshFaces[_indY0]->GetSubShape()); SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes(); faceQuadStruct *quad = aCube.quad_Y0; int j = 0; // i = x/face , k = y/face int nbdown = quad->side[0]->NbPoints(); int nbright = quad->side[1]->NbPoints(); while(itf->more()) { const SMDS_MeshNode * node = itf->next(); if(aTool.IsMedium(node)) continue; if ( !findIJ( node, quad, i1, j1 )) return ClearAndReturn( aQuads, false ); int ij1 = j1 * nbdown + i1; quad->uv_grid[ij1].node = node; } for (int i1 = 0; i1 < nbdown; i1++) for (int j1 = 0; j1 < nbright; j1++) { int ij1 = j1 * nbdown + i1; int i = cy0.ia * i1 + cy0.ib * j1 + cy0.ic; // i = x/face int k = cy0.ja * i1 + cy0.jb * j1 + cy0.jc; // k = y/face int ijk = k * nbx * nby + j * nbx + i; //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk); np[ijk].node = quad->uv_grid[ij1].node; //SCRUTE(np[ijk].nodeId); } } { const TopoDS_Face & F = TopoDS::Face(meshFaces[_indY1]->GetSubShape()); SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes(); faceQuadStruct *quad = aCube.quad_Y1; int j = nby - 1; // i = x/face , k = y/face int nbdown = quad->side[0]->NbPoints(); int nbright = quad->side[1]->NbPoints(); while(itf->more()) { const SMDS_MeshNode * node = itf->next(); if(aTool.IsMedium(node)) continue; if ( !findIJ( node, quad, i1, j1 )) return ClearAndReturn( aQuads, false ); int ij1 = j1 * nbdown + i1; quad->uv_grid[ij1].node = node; } for (int i1 = 0; i1 < nbdown; i1++) for (int j1 = 0; j1 < nbright; j1++) { int ij1 = j1 * nbdown + i1; int i = cy1.ia * i1 + cy1.ib * j1 + cy1.ic; // i = x/face int k = cy1.ja * i1 + cy1.jb * j1 + cy1.jc; // k = y/face int ijk = k * nbx * nby + j * nbx + i; //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk); np[ijk].node = quad->uv_grid[ij1].node; //SCRUTE(np[ijk].nodeId); } } { const TopoDS_Face & F = TopoDS::Face(meshFaces[_indZ0]->GetSubShape()); SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes(); faceQuadStruct *quad = aCube.quad_Z0; int k = 0; // i = x/face , j = y/face int nbdown = quad->side[0]->NbPoints(); int nbright = quad->side[1]->NbPoints(); while(itf->more()) { const SMDS_MeshNode * node = itf->next(); if(aTool.IsMedium(node)) continue; if ( !findIJ( node, quad, i1, j1 )) return ClearAndReturn( aQuads, false ); int ij1 = j1 * nbdown + i1; quad->uv_grid[ij1].node = node; } for (int i1 = 0; i1 < nbdown; i1++) for (int j1 = 0; j1 < nbright; j1++) { int ij1 = j1 * nbdown + i1; int i = cz0.ia * i1 + cz0.ib * j1 + cz0.ic; // i = x/face int j = cz0.ja * i1 + cz0.jb * j1 + cz0.jc; // j = y/face int ijk = k * nbx * nby + j * nbx + i; //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk); np[ijk].node = quad->uv_grid[ij1].node; //SCRUTE(np[ijk].nodeId); } } { const TopoDS_Face & F = TopoDS::Face(meshFaces[_indZ1]->GetSubShape()); SMDS_NodeIteratorPtr itf= aMesh.GetSubMesh(F)->GetSubMeshDS()->GetNodes(); faceQuadStruct *quad = aCube.quad_Z1; int k = nbz - 1; // i = x/face , j = y/face int nbdown = quad->side[0]->NbPoints(); int nbright = quad->side[1]->NbPoints(); while(itf->more()) { const SMDS_MeshNode * node = itf->next(); if(aTool.IsMedium(node)) continue; if ( !findIJ( node, quad, i1, j1 )) return ClearAndReturn( aQuads, false ); int ij1 = j1 * nbdown + i1; quad->uv_grid[ij1].node = node; } for (int i1 = 0; i1 < nbdown; i1++) for (int j1 = 0; j1 < nbright; j1++) { int ij1 = j1 * nbdown + i1; int i = cz1.ia * i1 + cz1.ib * j1 + cz1.ic; // i = x/face int j = cz1.ja * i1 + cz1.jb * j1 + cz1.jc; // j = y/face int ijk = k * nbx * nby + j * nbx + i; //MESSAGE(" "<<ij1<<" "<<i<<" "<<j<<" "<<ijk); np[ijk].node = quad->uv_grid[ij1].node; //SCRUTE(np[ijk].nodeId); } } // 2.0 - for each node of the cube: // - get the 8 points 3D = 8 vertices of the cube // - get the 12 points 3D on the 12 edges of the cube // - get the 6 points 3D on the 6 faces with their ID // - compute the point 3D // - store the point 3D in SMESHDS, store its ID in 3D structure int shapeID = meshDS->ShapeToIndex( aShape ); Pt3 p000, p001, p010, p011, p100, p101, p110, p111; Pt3 px00, px01, px10, px11; Pt3 p0y0, p0y1, p1y0, p1y1; Pt3 p00z, p01z, p10z, p11z; Pt3 pxy0, pxy1, px0z, px1z, p0yz, p1yz; GetPoint(p000, 0, 0, 0, nbx, nby, nbz, np, meshDS); GetPoint(p001, 0, 0, nbz - 1, nbx, nby, nbz, np, meshDS); GetPoint(p010, 0, nby - 1, 0, nbx, nby, nbz, np, meshDS); GetPoint(p011, 0, nby - 1, nbz - 1, nbx, nby, nbz, np, meshDS); GetPoint(p100, nbx - 1, 0, 0, nbx, nby, nbz, np, meshDS); GetPoint(p101, nbx - 1, 0, nbz - 1, nbx, nby, nbz, np, meshDS); GetPoint(p110, nbx - 1, nby - 1, 0, nbx, nby, nbz, np, meshDS); GetPoint(p111, nbx - 1, nby - 1, nbz - 1, nbx, nby, nbz, np, meshDS); for (int i = 1; i < nbx - 1; i++) { for (int j = 1; j < nby - 1; j++) { for (int k = 1; k < nbz - 1; k++) { // *** seulement maillage regulier // 12 points on edges GetPoint(px00, i, 0, 0, nbx, nby, nbz, np, meshDS); GetPoint(px01, i, 0, nbz - 1, nbx, nby, nbz, np, meshDS); GetPoint(px10, i, nby - 1, 0, nbx, nby, nbz, np, meshDS); GetPoint(px11, i, nby - 1, nbz - 1, nbx, nby, nbz, np, meshDS); GetPoint(p0y0, 0, j, 0, nbx, nby, nbz, np, meshDS); GetPoint(p0y1, 0, j, nbz - 1, nbx, nby, nbz, np, meshDS); GetPoint(p1y0, nbx - 1, j, 0, nbx, nby, nbz, np, meshDS); GetPoint(p1y1, nbx - 1, j, nbz - 1, nbx, nby, nbz, np, meshDS); GetPoint(p00z, 0, 0, k, nbx, nby, nbz, np, meshDS); GetPoint(p01z, 0, nby - 1, k, nbx, nby, nbz, np, meshDS); GetPoint(p10z, nbx - 1, 0, k, nbx, nby, nbz, np, meshDS); GetPoint(p11z, nbx - 1, nby - 1, k, nbx, nby, nbz, np, meshDS); // 12 points on faces GetPoint(pxy0, i, j, 0, nbx, nby, nbz, np, meshDS); GetPoint(pxy1, i, j, nbz - 1, nbx, nby, nbz, np, meshDS); GetPoint(px0z, i, 0, k, nbx, nby, nbz, np, meshDS); GetPoint(px1z, i, nby - 1, k, nbx, nby, nbz, np, meshDS); GetPoint(p0yz, 0, j, k, nbx, nby, nbz, np, meshDS); GetPoint(p1yz, nbx - 1, j, k, nbx, nby, nbz, np, meshDS); int ijk = k * nbx * nby + j * nbx + i; double x = double (i) / double (nbx - 1); // *** seulement double y = double (j) / double (nby - 1); // *** maillage double z = double (k) / double (nbz - 1); // *** regulier Pt3 X; for (int i = 0; i < 3; i++) { X[i] = (1 - x) * p0yz[i] + x * p1yz[i] + (1 - y) * px0z[i] + y * px1z[i] + (1 - z) * pxy0[i] + z * pxy1[i] - (1 - x) * ((1 - y) * p00z[i] + y * p01z[i]) - x * ((1 - y) * p10z[i] + y * p11z[i]) - (1 - y) * ((1 - z) * px00[i] + z * px01[i]) - y * ((1 - z) * px10[i] + z * px11[i]) - (1 - z) * ((1 - x) * p0y0[i] + x * p1y0[i]) - z * ((1 - x) * p0y1[i] + x * p1y1[i]) + (1 - x) * ((1 - y) * ((1 - z) * p000[i] + z * p001[i]) + y * ((1 - z) * p010[i] + z * p011[i])) + x * ((1 - y) * ((1 - z) * p100[i] + z * p101[i]) + y * ((1 - z) * p110[i] + z * p111[i])); } SMDS_MeshNode * node = meshDS->AddNode(X[0], X[1], X[2]); np[ijk].node = node; meshDS->SetNodeInVolume(node, shapeID); } } } // find orientation of furute volumes according to MED convention vector< bool > forward( nbx * nby ); SMDS_VolumeTool vTool; for (int i = 0; i < nbx - 1; i++) { for (int j = 0; j < nby - 1; j++) { int n1 = j * nbx + i; int n2 = j * nbx + i + 1; int n3 = (j + 1) * nbx + i + 1; int n4 = (j + 1) * nbx + i; int n5 = nbx * nby + j * nbx + i; int n6 = nbx * nby + j * nbx + i + 1; int n7 = nbx * nby + (j + 1) * nbx + i + 1; int n8 = nbx * nby + (j + 1) * nbx + i; SMDS_VolumeOfNodes tmpVol (np[n1].node,np[n2].node,np[n3].node,np[n4].node, np[n5].node,np[n6].node,np[n7].node,np[n8].node); vTool.Set( &tmpVol ); forward[ n1 ] = vTool.IsForward(); } } //2.1 - for each node of the cube (less 3 *1 Faces): // - store hexahedron in SMESHDS MESSAGE("Storing hexahedron into the DS"); for (int i = 0; i < nbx - 1; i++) { for (int j = 0; j < nby - 1; j++) { bool isForw = forward.at( j * nbx + i ); for (int k = 0; k < nbz - 1; k++) { int n1 = k * nbx * nby + j * nbx + i; int n2 = k * nbx * nby + j * nbx + i + 1; int n3 = k * nbx * nby + (j + 1) * nbx + i + 1; int n4 = k * nbx * nby + (j + 1) * nbx + i; int n5 = (k + 1) * nbx * nby + j * nbx + i; int n6 = (k + 1) * nbx * nby + j * nbx + i + 1; int n7 = (k + 1) * nbx * nby + (j + 1) * nbx + i + 1; int n8 = (k + 1) * nbx * nby + (j + 1) * nbx + i; SMDS_MeshVolume * elt; if ( isForw ) { elt = aTool.AddVolume(np[n1].node, np[n2].node, np[n3].node, np[n4].node, np[n5].node, np[n6].node, np[n7].node, np[n8].node); } else { elt = aTool.AddVolume(np[n1].node, np[n4].node, np[n3].node, np[n2].node, np[n5].node, np[n8].node, np[n7].node, np[n6].node); } meshDS->SetMeshElementOnShape(elt, shapeID); } } } if ( np ) delete [] np; return ClearAndReturn( aQuads, true ); }