X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FStdMeshers%2FStdMeshers_Prism_3D.cxx;h=07666af9fbde8cfe620e684c4137b86668c60622;hp=645bad1e2fe5c47a251bef2637fe531d34f09998;hb=db6f1785f59eaa5f2d813dc89a83f9739fcf60ef;hpb=5482b99d07dd144fd5be299e722f39a81de3b5be diff --git a/src/StdMeshers/StdMeshers_Prism_3D.cxx b/src/StdMeshers/StdMeshers_Prism_3D.cxx index 645bad1e2..07666af9f 100644 --- a/src/StdMeshers/StdMeshers_Prism_3D.cxx +++ b/src/StdMeshers/StdMeshers_Prism_3D.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2019 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 @@ -33,6 +33,7 @@ #include "SMESH_Comment.hxx" #include "SMESH_Gen.hxx" #include "SMESH_HypoFilter.hxx" +#include "SMESH_MeshEditor.hxx" #include "SMESH_MesherHelper.hxx" #include "StdMeshers_FaceSide.hxx" #include "StdMeshers_ProjectionSource1D.hxx" @@ -51,6 +52,7 @@ #include #include #include +#include #include #include #include @@ -95,21 +97,21 @@ namespace { */ struct TQuadrangleAlgo : public StdMeshers_Quadrangle_2D { - TQuadrangleAlgo(int studyId, SMESH_Gen* gen) - : StdMeshers_Quadrangle_2D( gen->GetANewId(), studyId, gen) + TQuadrangleAlgo(SMESH_Gen* gen) + : StdMeshers_Quadrangle_2D( gen->GetANewId(), gen) { } static StdMeshers_Quadrangle_2D* instance( SMESH_Algo* fatherAlgo, SMESH_MesherHelper* helper=0) { - static TQuadrangleAlgo* algo = new TQuadrangleAlgo( fatherAlgo->GetStudyId(), - fatherAlgo->GetGen() ); + static TQuadrangleAlgo* algo = new TQuadrangleAlgo( fatherAlgo->GetGen() ); if ( helper && algo->myProxyMesh && algo->myProxyMesh->GetMesh() != helper->GetMesh() ) algo->myProxyMesh.reset( new SMESH_ProxyMesh( *helper->GetMesh() )); algo->myQuadList.clear(); + algo->myHelper = 0; if ( helper ) algo->_quadraticMesh = helper->GetIsQuadratic(); @@ -125,16 +127,15 @@ namespace { { StdMeshers_ProjectionSource1D myHyp; - TProjction1dAlgo(int studyId, SMESH_Gen* gen) - : StdMeshers_Projection_1D( gen->GetANewId(), studyId, gen), - myHyp( gen->GetANewId(), studyId, gen) + TProjction1dAlgo(SMESH_Gen* gen) + : StdMeshers_Projection_1D( gen->GetANewId(), gen), + myHyp( gen->GetANewId(), gen) { StdMeshers_Projection_1D::_sourceHypo = & myHyp; } static TProjction1dAlgo* instance( SMESH_Algo* fatherAlgo ) { - static TProjction1dAlgo* algo = new TProjction1dAlgo( fatherAlgo->GetStudyId(), - fatherAlgo->GetGen() ); + static TProjction1dAlgo* algo = new TProjction1dAlgo( fatherAlgo->GetGen() ); return algo; } }; @@ -146,22 +147,27 @@ namespace { { StdMeshers_ProjectionSource2D myHyp; - TProjction2dAlgo(int studyId, SMESH_Gen* gen) - : StdMeshers_Projection_1D2D( gen->GetANewId(), studyId, gen), - myHyp( gen->GetANewId(), studyId, gen) + TProjction2dAlgo(SMESH_Gen* gen) + : StdMeshers_Projection_1D2D( gen->GetANewId(), gen), + myHyp( gen->GetANewId(), gen) { StdMeshers_Projection_2D::_sourceHypo = & myHyp; } static TProjction2dAlgo* instance( SMESH_Algo* fatherAlgo ) { - static TProjction2dAlgo* algo = new TProjction2dAlgo( fatherAlgo->GetStudyId(), - fatherAlgo->GetGen() ); + static TProjction2dAlgo* algo = new TProjction2dAlgo( fatherAlgo->GetGen() ); return algo; } const NSProjUtils::TNodeNodeMap& GetNodesMap() { return _src2tgtNodes; } + void SetEventListener( SMESH_subMesh* tgtSubMesh ) + { + NSProjUtils::SetEventListener( tgtSubMesh, + _sourceHypo->GetSourceFace(), + _sourceHypo->GetSourceMesh() ); + } }; //======================================================================= /*! @@ -450,7 +456,7 @@ namespace { int nbEdges = thePrism.myNbEdgesInWires.front(); // nb outer edges int nbSides = nbEdges; - + list< TopoDS_Edge >::const_iterator edgeIt = thePrism.myBottomEdges.begin(); std::advance( edgeIt, nbEdges-1 ); TopoDS_Edge prevE = *edgeIt; @@ -518,10 +524,31 @@ namespace { // isPrevStraight = isCurStraight; // iPrev = iE; // } - + return nbSides; } + //================================================================================ + /*! + * \brief Set/get wire index to FaceQuadStruct + */ + //================================================================================ + + void setWireIndex( TFaceQuadStructPtr& quad, int iWire ) + { + quad->iSize = iWire; + } + int getWireIndex( const TFaceQuadStructPtr& quad ) + { + return quad->iSize; + } + + //================================================================================ + /*! + * \brief Print Python commands adding given points to a mesh + */ + //================================================================================ + void pointsToPython(const std::vector& p) { #ifdef _DEBUG_ @@ -536,11 +563,11 @@ namespace { //======================================================================= //function : StdMeshers_Prism_3D -//purpose : +//purpose : //======================================================================= -StdMeshers_Prism_3D::StdMeshers_Prism_3D(int hypId, int studyId, SMESH_Gen* gen) - :SMESH_3D_Algo(hypId, studyId, gen) +StdMeshers_Prism_3D::StdMeshers_Prism_3D(int hypId, SMESH_Gen* gen) + :SMESH_3D_Algo(hypId, gen) { _name = "Prism_3D"; _shapeType = (1 << TopAbs_SOLID); // 1 bit per shape type @@ -552,6 +579,7 @@ StdMeshers_Prism_3D::StdMeshers_Prism_3D(int hypId, int studyId, SMESH_Gen* gen) //myProjectTriangles = false; mySetErrorToSM = true; // to pass an error to a sub-mesh of a current solid or not + myPrevBottomSM = 0; // last treated bottom sub-mesh with a suitable algorithm } //================================================================================ @@ -561,50 +589,19 @@ StdMeshers_Prism_3D::StdMeshers_Prism_3D(int hypId, int studyId, SMESH_Gen* gen) //================================================================================ StdMeshers_Prism_3D::~StdMeshers_Prism_3D() -{} +{ + pointsToPython( std::vector() ); // avoid warning: pointsToPython defined but not used +} //======================================================================= //function : CheckHypothesis -//purpose : +//purpose : //======================================================================= bool StdMeshers_Prism_3D::CheckHypothesis(SMESH_Mesh& aMesh, const TopoDS_Shape& aShape, SMESH_Hypothesis::Hypothesis_Status& aStatus) { - // Check shape geometry -/* PAL16229 - aStatus = SMESH_Hypothesis::HYP_BAD_GEOMETRY; - - // find not quadrangle faces - list< TopoDS_Shape > notQuadFaces; - int nbEdge, nbWire, nbFace = 0; - TopExp_Explorer exp( aShape, TopAbs_FACE ); - for ( ; exp.More(); exp.Next() ) { - ++nbFace; - const TopoDS_Shape& face = exp.Current(); - nbEdge = NSProjUtils::Count( face, TopAbs_EDGE, 0 ); - nbWire = NSProjUtils::Count( face, TopAbs_WIRE, 0 ); - if ( nbEdge!= 4 || nbWire!= 1 ) { - if ( !notQuadFaces.empty() ) { - if ( NSProjUtils::Count( notQuadFaces.back(), TopAbs_EDGE, 0 ) != nbEdge || - NSProjUtils::Count( notQuadFaces.back(), TopAbs_WIRE, 0 ) != nbWire ) - RETURN_BAD_RESULT("Different not quad faces"); - } - notQuadFaces.push_back( face ); - } - } - if ( !notQuadFaces.empty() ) - { - if ( notQuadFaces.size() != 2 ) - RETURN_BAD_RESULT("Bad nb not quad faces: " << notQuadFaces.size()); - - // check total nb faces - nbEdge = NSProjUtils::Count( notQuadFaces.back(), TopAbs_EDGE, 0 ); - if ( nbFace != nbEdge + 2 ) - RETURN_BAD_RESULT("Bad nb of faces: " << nbFace << " but must be " << nbEdge + 2); - } -*/ // no hypothesis aStatus = SMESH_Hypothesis::HYP_OK; return true; @@ -619,6 +616,7 @@ bool StdMeshers_Prism_3D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape& theSh { SMESH_MesherHelper helper( theMesh ); myHelper = &helper; + myPrevBottomSM = 0; int nbSolids = helper.Count( theShape, TopAbs_SOLID, /*skipSame=*/false ); if ( nbSolids < 1 ) @@ -864,7 +862,7 @@ bool StdMeshers_Prism_3D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape& theSh // TODO. there are other ways to find out the source FACE: - // propagation, topological similarity, ect. + // propagation, topological similarity, etc... // simply try to mesh all not meshed SOLIDs if ( meshedFaces.empty() ) @@ -924,7 +922,7 @@ bool StdMeshers_Prism_3D::getWallFaces( Prism_3D::TPrismTopo & thePrism, StdMeshers_Quadrangle_2D* quadAlgo = TQuadrangleAlgo::instance( this, myHelper ); TopTools_MapOfShape faceMap; - TopTools_IndexedDataMapOfShapeListOfShape edgeToFaces; + TopTools_IndexedDataMapOfShapeListOfShape edgeToFaces; TopExp::MapShapesAndAncestors( thePrism.myShape3D, TopAbs_EDGE, TopAbs_FACE, edgeToFaces ); @@ -935,12 +933,11 @@ bool StdMeshers_Prism_3D::getWallFaces( Prism_3D::TPrismTopo & thePrism, list< TopoDS_Edge >::iterator edge = thePrism.myBottomEdges.begin(); std::list< int >::iterator nbE = thePrism.myNbEdgesInWires.begin(); std::list< int > nbQuadsPerWire; - int iE = 0; - double f,l; + int iE = 0, iWire = 0; while ( edge != thePrism.myBottomEdges.end() ) { ++iE; - if ( BRep_Tool::Curve( *edge, f,l ).IsNull() ) + if ( SMESH_Algo::isDegenerated( *edge )) { edge = thePrism.myBottomEdges.erase( edge ); --iE; @@ -948,12 +945,14 @@ bool StdMeshers_Prism_3D::getWallFaces( Prism_3D::TPrismTopo & thePrism, } else { + bool hasWallFace = false; TopTools_ListIteratorOfListOfShape faceIt( edgeToFaces.FindFromKey( *edge )); for ( ; faceIt.More(); faceIt.Next() ) { const TopoDS_Face& face = TopoDS::Face( faceIt.Value() ); if ( !thePrism.myBottom.IsSame( face )) { + hasWallFace = true; Prism_3D::TQuadList quadList( 1, quadAlgo->CheckNbEdges( *mesh, face )); if ( !quadList.back() ) return toSM( error(TCom("Side face #") << shapeID( face ) @@ -968,15 +967,28 @@ bool StdMeshers_Prism_3D::getWallFaces( Prism_3D::TPrismTopo & thePrism, return toSM( error(TCom("Composite 'horizontal' edges are not supported"))); } if ( faceMap.Add( face )) + { + setWireIndex( quadList.back(), iWire ); // for use in makeQuadsForOutInProjection() thePrism.myWallQuads.push_back( quadList ); + } break; } } - ++edge; + if ( hasWallFace ) + { + ++edge; + } + else // seam edge (IPAL53561) + { + edge = thePrism.myBottomEdges.erase( edge ); + --iE; + --(*nbE); + } } if ( iE == *nbE ) { iE = 0; + ++iWire; ++nbE; int nbQuadPrev = std::accumulate( nbQuadsPerWire.begin(), nbQuadsPerWire.end(), 0 ); nbQuadsPerWire.push_back( thePrism.myWallQuads.size() - nbQuadPrev ); @@ -1111,13 +1123,8 @@ bool StdMeshers_Prism_3D::compute(const Prism_3D::TPrismTopo& thePrism) return toSM( error( SMESH_ComputeError::New(COMPERR_CANCELED))); // Assure the bottom is meshed - SMESH_subMesh * botSM = myHelper->GetMesh()->GetSubMesh( thePrism.myBottom ); - if (( botSM->IsEmpty() ) && - ( ! botSM->GetAlgo() || - ! _gen->Compute( *botSM->GetFather(), botSM->GetSubShape(), /*shapeOnly=*/true ))) - return error( COMPERR_BAD_INPUT_MESH, - TCom( "No mesher defined to compute the face #") - << shapeID( thePrism.myBottom )); + if ( !computeBase( thePrism )) + return false; // Make all side FACEs of thePrism meshed with quads if ( !computeWalls( thePrism )) @@ -1142,7 +1149,8 @@ bool StdMeshers_Prism_3D::compute(const Prism_3D::TPrismTopo& thePrism) // else if ( !trsf.empty() ) // bottomToTopTrsf = trsf.back(); - // To compute coordinates of a node inside a block, it is necessary to know + // To compute coordinates of a node inside a block using "block approach", + // it is necessary to know // 1. normalized parameters of the node by which // 2. coordinates of node projections on all block sub-shapes are computed @@ -1155,46 +1163,72 @@ bool StdMeshers_Prism_3D::compute(const Prism_3D::TPrismTopo& thePrism) // Projections on the top and bottom faces are taken from nodes existing // on these faces; find correspondence between bottom and top nodes - myUseBlock = false; + myUseBlock = false; // is set to true if projection is done using "block approach" myBotToColumnMap.clear(); if ( !assocOrProjBottom2Top( bottomToTopTrsf, thePrism ) ) // it also fills myBotToColumnMap return false; + // If all "vertical" EDGEs are straight, then all nodes of an internal node column + // are located on a line connecting the top node and the bottom node. + bool isStrightColunm = allVerticalEdgesStraight( thePrism ); + if ( isStrightColunm ) + myUseBlock = false; // Create nodes inside the block - // use transformation (issue 0020680, IPAL0052499) - StdMeshers_Sweeper sweeper; - double tol; - bool allowHighBndError; - if ( !myUseBlock ) { + // use transformation (issue 0020680, IPAL0052499) or a "straight line" approach + StdMeshers_Sweeper sweeper; + sweeper.myHelper = myHelper; + sweeper.myBotFace = thePrism.myBottom; + sweeper.myTopFace = thePrism.myTop; + // load boundary nodes into sweeper bool dummy; + std::set< const SMDS_MeshNode* > usedEndNodes; list< TopoDS_Edge >::const_iterator edge = thePrism.myBottomEdges.begin(); for ( ; edge != thePrism.myBottomEdges.end(); ++edge ) { int edgeID = meshDS->ShapeToIndex( *edge ); TParam2ColumnMap* u2col = const_cast ( myBlock.GetParam2ColumnMap( edgeID, dummy )); - TParam2ColumnMap::iterator u2colIt = u2col->begin(); - for ( ; u2colIt != u2col->end(); ++u2colIt ) + + TParam2ColumnMap::iterator u2colIt = u2col->begin(), u2colEnd = u2col->end(); + const SMDS_MeshNode* n0 = u2colIt->second[0]; + const SMDS_MeshNode* n1 = u2col->rbegin()->second[0]; + if ( !usedEndNodes.insert ( n0 ).second ) ++u2colIt; + if ( !usedEndNodes.insert ( n1 ).second ) --u2colEnd; + + for ( ; u2colIt != u2colEnd; ++u2colIt ) sweeper.myBndColumns.push_back( & u2colIt->second ); } - // load node columns inside the bottom face + // load node columns inside the bottom FACE + sweeper.myIntColumns.reserve( myBotToColumnMap.size() ); TNode2ColumnMap::iterator bot_column = myBotToColumnMap.begin(); for ( ; bot_column != myBotToColumnMap.end(); ++bot_column ) sweeper.myIntColumns.push_back( & bot_column->second ); - tol = getSweepTolerance( thePrism ); - allowHighBndError = !isSimpleBottom( thePrism ); - } + myHelper->SetElementsOnShape( true ); - if ( !myUseBlock && sweeper.ComputeNodes( *myHelper, tol, allowHighBndError )) - { + if ( !isStrightColunm ) + { + double tol = getSweepTolerance( thePrism ); + bool allowHighBndError = !isSimpleBottom( thePrism ); + myUseBlock = !sweeper.ComputeNodesByTrsf( tol, allowHighBndError ); + } + else if ( sweeper.CheckSameZ() ) + { + myUseBlock = !sweeper.ComputeNodesOnStraightSameZ(); + } + else + { + myUseBlock = !sweeper.ComputeNodesOnStraight(); + } + myHelper->SetElementsOnShape( false ); } - else // use block approach + + if ( myUseBlock ) // use block approach { // loop on nodes inside the bottom face Prism_3D::TNode prevBNode; @@ -1202,12 +1236,21 @@ bool StdMeshers_Prism_3D::compute(const Prism_3D::TPrismTopo& thePrism) for ( ; bot_column != myBotToColumnMap.end(); ++bot_column ) { const Prism_3D::TNode& tBotNode = bot_column->first; // bottom TNode - if ( tBotNode.GetPositionType() != SMDS_TOP_FACE ) + if ( tBotNode.GetPositionType() != SMDS_TOP_FACE && + myBlock.HasNodeColumn( tBotNode.myNode )) continue; // node is not inside the FACE // column nodes; middle part of the column are zero pointers TNodeColumn& column = bot_column->second; + // check if a column is already computed using non-block approach + size_t i; + for ( i = 0; i < column.size(); ++i ) + if ( !column[ i ]) + break; + if ( i == column.size() ) + continue; // all nodes created + gp_XYZ botParams, topParams; if ( !tBotNode.HasParams() ) { @@ -1306,16 +1349,17 @@ bool StdMeshers_Prism_3D::compute(const Prism_3D::TPrismTopo& thePrism) for ( int i = 0; i < nbNodes; ++i ) { const SMDS_MeshNode* n = face->GetNode( i ); - if ( n->GetPosition()->GetTypeOfPosition() == SMDS_TOP_FACE ) { + columns[ i ] = NULL; + + if ( n->GetPosition()->GetTypeOfPosition() != SMDS_TOP_FACE ) + columns[ i ] = myBlock.GetNodeColumn( n ); + + if ( !columns[ i ] ) + { TNode2ColumnMap::iterator bot_column = myBotToColumnMap.find( n ); if ( bot_column == myBotToColumnMap.end() ) - return toSM( error(TCom("No nodes found above node ") << n->GetID() )); - columns[ i ] = & bot_column->second; - } - else { - columns[ i ] = myBlock.GetNodeColumn( n ); - if ( !columns[ i ] ) return toSM( error(TCom("No side nodes found above node ") << n->GetID() )); + columns[ i ] = & bot_column->second; } } // create prisms @@ -1330,7 +1374,7 @@ bool StdMeshers_Prism_3D::compute(const Prism_3D::TPrismTopo& thePrism) // update state of sub-meshes (mostly in order to erase improper errors) SMESH_subMesh* sm = myHelper->GetMesh()->GetSubMesh( thePrism.myShape3D ); - SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/false); + SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/true); while ( smIt->more() ) { sm = smIt->next(); @@ -1341,6 +1385,75 @@ bool StdMeshers_Prism_3D::compute(const Prism_3D::TPrismTopo& thePrism) return true; } +//======================================================================= +//function : computeBase +//purpose : Compute the base face of a prism +//======================================================================= + +bool StdMeshers_Prism_3D::computeBase(const Prism_3D::TPrismTopo& thePrism) +{ + SMESH_Mesh* mesh = myHelper->GetMesh(); + SMESH_subMesh* botSM = mesh->GetSubMesh( thePrism.myBottom ); + if (( botSM->IsEmpty() ) && + ( ! botSM->GetAlgo() || + ! _gen->Compute( *botSM->GetFather(), botSM->GetSubShape(), /*shapeOnly=*/true ))) + { + // find any applicable algorithm assigned to any FACE of the main shape + std::vector< TopoDS_Shape > faces; + if ( myPrevBottomSM && + myPrevBottomSM->GetAlgo()->IsApplicableToShape( thePrism.myBottom, /*all=*/false )) + faces.push_back( myPrevBottomSM->GetSubShape() ); + + TopExp_Explorer faceIt( mesh->GetShapeToMesh(), TopAbs_FACE ); + for ( ; faceIt.More(); faceIt.Next() ) + faces.push_back( faceIt.Current() ); + + faces.push_back( TopoDS_Shape() ); // to try quadrangle algorithm + + SMESH_Algo* algo = 0; + for ( size_t i = 0; i < faces.size() && botSM->IsEmpty(); ++i ) + { + if ( faces[i].IsNull() ) algo = TQuadrangleAlgo::instance( this, myHelper ); + else algo = mesh->GetSubMesh( faces[i] )->GetAlgo(); + if ( algo && algo->IsApplicableToShape( thePrism.myBottom, /*all=*/false )) + { + // try to compute the bottom FACE + if ( algo->NeedDiscreteBoundary() ) + { + // compute sub-shapes + SMESH_subMeshIteratorPtr smIt = botSM->getDependsOnIterator(false,false); + bool subOK = true; + while ( smIt->more() && subOK ) + { + SMESH_subMesh* sub = smIt->next(); + sub->ComputeStateEngine( SMESH_subMesh::COMPUTE ); + subOK = sub->IsMeshComputed(); + } + if ( !subOK ) + continue; + } + try { + OCC_CATCH_SIGNALS; + algo->InitComputeError(); + algo->Compute( *mesh, botSM->GetSubShape() ); + } + catch (...) { + } + } + } + } + + if ( botSM->IsEmpty() ) + return error( COMPERR_BAD_INPUT_MESH, + TCom( "No mesher defined to compute the base face #") + << shapeID( thePrism.myBottom )); + + if ( botSM->GetAlgo() ) + myPrevBottomSM = botSM; + + return true; +} + //======================================================================= //function : computeWalls //purpose : Compute 2D mesh on walls FACEs of a prism @@ -1371,6 +1484,7 @@ bool StdMeshers_Prism_3D::computeWalls(const Prism_3D::TPrismTopo& thePrism) for ( ; quad != thePrism.myWallQuads[iW].end(); ++quad ) { StdMeshers_FaceSidePtr lftSide = (*quad)->side[ QUAD_LEFT_SIDE ]; + lftSide->Reverse(); // to go up for ( int i = 0; i < lftSide->NbEdges(); ++i ) { ++wgt[ iW ]; @@ -1398,6 +1512,11 @@ bool StdMeshers_Prism_3D::computeWalls(const Prism_3D::TPrismTopo& thePrism) for ( size_t iW = 0; iW != nbWalls; ++iW ) wgt2quad.insert( make_pair( wgt[ iW ], iW )); + // artificial quads to do outer <-> inner wall projection + std::map< int, FaceQuadStruct > iW2oiQuads; + std::map< int, FaceQuadStruct >::iterator w2oiq; + makeQuadsForOutInProjection( thePrism, wgt2quad, iW2oiQuads ); + // Project 'vertical' EDGEs, from left to right multimap< int, int >::reverse_iterator w2q = wgt2quad.rbegin(); for ( ; w2q != wgt2quad.rend(); ++w2q ) @@ -1414,10 +1533,25 @@ bool StdMeshers_Prism_3D::computeWalls(const Prism_3D::TPrismTopo& thePrism) if ( swapLeftRight ) std::swap( lftSide, rgtSide ); + bool isArtificialQuad = (( w2oiq = iW2oiQuads.find( iW )) != iW2oiQuads.end() ); + if ( isArtificialQuad ) + { + // reset sides to perform the outer <-> inner projection + FaceQuadStruct& oiQuad = w2oiq->second; + rgtSide = oiQuad.side[ QUAD_RIGHT_SIDE ]; + lftSide = oiQuad.side[ QUAD_LEFT_SIDE ]; + iW2oiQuads.erase( w2oiq ); + } + // assure that all the source (left) EDGEs are meshed int nbSrcSegments = 0; for ( int i = 0; i < lftSide->NbEdges(); ++i ) { + if ( isArtificialQuad ) + { + nbSrcSegments = lftSide->NbPoints()-1; + continue; + } const TopoDS_Edge& srcE = lftSide->Edge(i); SMESH_subMesh* srcSM = mesh->GetSubMesh( srcE ); if ( !srcSM->IsMeshComputed() ) { @@ -1493,7 +1627,7 @@ bool StdMeshers_Prism_3D::computeWalls(const Prism_3D::TPrismTopo& thePrism) const UVPtStructVec& srcNodeStr = lftSide->GetUVPtStruct(); if ( srcNodeStr.size() == 0 ) return toSM( error( TCom("Invalid node positions on edge #") << - shapeID( lftSide->Edge(0) ))); + lftSide->EdgeID(0) )); vector< SMDS_MeshNode* > newNodes( srcNodeStr.size() ); for ( int is2ndV = 0; is2ndV < 2; ++is2ndV ) { @@ -1501,12 +1635,12 @@ bool StdMeshers_Prism_3D::computeWalls(const Prism_3D::TPrismTopo& thePrism) TopoDS_Vertex v = myHelper->IthVertex( is2ndV, E ); mesh->GetSubMesh( v )->ComputeStateEngine( SMESH_subMesh::COMPUTE ); const SMDS_MeshNode* n = SMESH_Algo::VertexNode( v, meshDS ); - newNodes[ is2ndV ? 0 : newNodes.size()-1 ] = (SMDS_MeshNode*) n; + newNodes[ is2ndV ? newNodes.size()-1 : 0 ] = (SMDS_MeshNode*) n; } // compute nodes on target EDGEs DBGOUT( "COMPUTE V edge (proj) " << shapeID( lftSide->Edge(0))); - rgtSide->Reverse(); // direct it same as the lftSide + //rgtSide->Reverse(); // direct it same as the lftSide myHelper->SetElementsOnShape( false ); // myHelper holds the prism shape TopoDS_Edge tgtEdge; for ( size_t iN = 1; iN < srcNodeStr.size()-1; ++iN ) // add nodes @@ -1519,7 +1653,7 @@ bool StdMeshers_Prism_3D::computeWalls(const Prism_3D::TPrismTopo& thePrism) for ( size_t iN = 1; iN < srcNodeStr.size(); ++iN ) // add segments { // find an EDGE to set a new segment - std::pair id2type = + std::pair id2type = myHelper->GetMediumPos( newNodes[ iN-1 ], newNodes[ iN ] ); if ( id2type.second != TopAbs_EDGE ) { @@ -1539,7 +1673,7 @@ bool StdMeshers_Prism_3D::computeWalls(const Prism_3D::TPrismTopo& thePrism) { SMESH_MeshEditor::TListOfListOfNodes lln( 1, list< const SMDS_MeshNode* >() ); lln.back().push_back ( vn ); - lln.back().push_front( newNodes[ iN-isPrev ] ); // to keep + lln.back().push_front( newNodes[ iN-isPrev ] ); // to keep SMESH_MeshEditor( mesh ).MergeNodes( lln ); } } @@ -1583,7 +1717,7 @@ bool StdMeshers_Prism_3D::computeWalls(const Prism_3D::TPrismTopo& thePrism) if ( ! fSM->IsMeshComputed() ) { // Top EDGEs must be projections from the bottom ones - // to compute stuctured quad mesh on wall FACEs + // to compute structured quad mesh on wall FACEs // --------------------------------------------------- const TopoDS_Edge& botE = (*quad)->side[ QUAD_BOTTOM_SIDE ].grid->Edge(0); const TopoDS_Edge& topE = (*quad)->side[ QUAD_TOP_SIDE ].grid->Edge(0); @@ -1664,9 +1798,8 @@ bool StdMeshers_Prism_3D::computeWalls(const Prism_3D::TPrismTopo& thePrism) if ( myHelper->GetIsQuadratic() ) { // fill myHelper with medium nodes built by quadAlgo - SMDS_ElemIteratorPtr fIt = fSM->GetSubMeshDS()->GetElements(); - while ( fIt->more() ) - myHelper->AddTLinks( dynamic_cast( fIt->next() )); + for ( SMDS_ElemIteratorPtr fIt = fSM->GetSubMeshDS()->GetElements(); fIt->more(); ) + myHelper->AddTLinks( SMDS_Mesh::DownCast( fIt->next() )); } } } @@ -1675,9 +1808,8 @@ bool StdMeshers_Prism_3D::computeWalls(const Prism_3D::TPrismTopo& thePrism) } //======================================================================= -/*! - * \brief Returns a source EDGE of propagation to a given EDGE - */ +//function : findPropagationSource +//purpose : Returns a source EDGE of propagation to a given EDGE //======================================================================= TopoDS_Edge StdMeshers_Prism_3D::findPropagationSource( const TopoDS_Edge& E ) @@ -1690,9 +1822,93 @@ TopoDS_Edge StdMeshers_Prism_3D::findPropagationSource( const TopoDS_Edge& E ) return TopoDS_Edge(); } +//======================================================================= +//function : makeQuadsForOutInProjection +//purpose : Create artificial wall quads for vertical projection between +// the outer and inner walls +//======================================================================= + +void StdMeshers_Prism_3D::makeQuadsForOutInProjection( const Prism_3D::TPrismTopo& thePrism, + multimap< int, int >& wgt2quad, + map< int, FaceQuadStruct >& iQ2oiQuads) +{ + if ( thePrism.NbWires() <= 1 ) + return; + + std::set< int > doneWires; // processed wires + + SMESH_Mesh* mesh = myHelper->GetMesh(); + const bool isForward = true; + const bool skipMedium = myHelper->GetIsQuadratic(); + + // make a source side for all projections + + multimap< int, int >::reverse_iterator w2q = wgt2quad.rbegin(); + const int iQuad = w2q->second; + const int iWire = getWireIndex( thePrism.myWallQuads[ iQuad ].front() ); + doneWires.insert( iWire ); + + UVPtStructVec srcNodes; + + Prism_3D::TQuadList::const_iterator quad = thePrism.myWallQuads[ iQuad ].begin(); + for ( ; quad != thePrism.myWallQuads[ iQuad ].end(); ++quad ) + { + StdMeshers_FaceSidePtr lftSide = (*quad)->side[ QUAD_LEFT_SIDE ]; + + // assure that all the source (left) EDGEs are meshed + for ( int i = 0; i < lftSide->NbEdges(); ++i ) + { + const TopoDS_Edge& srcE = lftSide->Edge(i); + SMESH_subMesh* srcSM = mesh->GetSubMesh( srcE ); + if ( !srcSM->IsMeshComputed() ) { + srcSM->ComputeSubMeshStateEngine( SMESH_subMesh::COMPUTE ); + srcSM->ComputeStateEngine ( SMESH_subMesh::COMPUTE ); + } + if ( !srcSM->IsMeshComputed() ) + return; + } + const UVPtStructVec& subNodes = lftSide->GetUVPtStruct(); + UVPtStructVec::const_iterator subBeg = subNodes.begin(), subEnd = subNodes.end(); + if ( !srcNodes.empty() ) ++subBeg; + srcNodes.insert( srcNodes.end(), subBeg, subEnd ); + } + StdMeshers_FaceSidePtr srcSide = StdMeshers_FaceSide::New( srcNodes ); + + // make the quads + + list< TopoDS_Edge > sideEdges; + TopoDS_Face face; + for ( ++w2q; w2q != wgt2quad.rend(); ++w2q ) + { + const int iQuad = w2q->second; + const Prism_3D::TQuadList& quads = thePrism.myWallQuads[ iQuad ]; + const int iWire = getWireIndex( quads.front() ); + if ( !doneWires.insert( iWire ).second ) + continue; + + sideEdges.clear(); + for ( quad = quads.begin(); quad != quads.end(); ++quad ) + { + StdMeshers_FaceSidePtr lftSide = (*quad)->side[ QUAD_LEFT_SIDE ]; + for ( int i = 0; i < lftSide->NbEdges(); ++i ) + sideEdges.push_back( lftSide->Edge( i )); + face = lftSide->Face(); + } + StdMeshers_FaceSidePtr tgtSide = + StdMeshers_FaceSide::New( face, sideEdges, mesh, isForward, skipMedium, myHelper ); + + FaceQuadStruct& newQuad = iQ2oiQuads[ iQuad ]; + newQuad.side.resize( 4 ); + newQuad.side[ QUAD_LEFT_SIDE ] = srcSide; + newQuad.side[ QUAD_RIGHT_SIDE ] = tgtSide; + + wgt2quad.insert( *w2q ); // to process this quad after processing the newQuad + } +} + //======================================================================= //function : Evaluate -//purpose : +//purpose : //======================================================================= bool StdMeshers_Prism_3D::Evaluate(SMESH_Mesh& theMesh, @@ -1782,7 +1998,7 @@ bool StdMeshers_Prism_3D::Evaluate(SMESH_Mesh& theMesh, std::vector aVec = (*anIt).second; nb2d += Max(aVec[SMDSEntity_Quadrangle],aVec[SMDSEntity_Quad_Quadrangle]); } - + MapShapeNbElemsItr anIt = aResMap.find( meshFaces[NumBase-1] ); std::vector aVec = (*anIt).second; bool IsQuadratic = (aVec[SMDSEntity_Quad_Triangle]>aVec[SMDSEntity_Triangle]) || @@ -2066,14 +2282,15 @@ bool StdMeshers_Prism_3D::assocOrProjBottom2Top( const gp_Trsf & bottomToTopTrsf { const SMDS_MeshNode* botNode = bN_tN->first; const SMDS_MeshNode* topNode = bN_tN->second; - if ( botNode->GetPosition()->GetTypeOfPosition() != SMDS_TOP_FACE ) + if ( botNode->GetPosition()->GetTypeOfPosition() != SMDS_TOP_FACE && + myBlock.HasNodeColumn( botNode )) continue; // wall columns are contained in myBlock // create node column Prism_3D::TNode bN( botNode ); TNode2ColumnMap::iterator bN_col = myBotToColumnMap.insert( make_pair ( bN, TNodeColumn() )).first; TNodeColumn & column = bN_col->second; - column.resize( zSize ); + column.resize( zSize, 0 ); column.front() = botNode; column.back() = topNode; } @@ -2094,7 +2311,7 @@ bool StdMeshers_Prism_3D::projectBottomToTop( const gp_Trsf & bottom { return true; } - NSProjUtils::TNodeNodeMap& n2nMap = + NSProjUtils::TNodeNodeMap& n2nMap = (NSProjUtils::TNodeNodeMap&) TProjction2dAlgo::instance( this )->GetNodesMap(); n2nMap.clear(); @@ -2179,7 +2396,7 @@ bool StdMeshers_Prism_3D::projectBottomToTop( const gp_Trsf & bottom meshDS->MoveNode( topNode, distXYZ[1], distXYZ[2], distXYZ[3] ); // transform can be inaccurate } // create node column - TNode2ColumnMap::iterator bN_col = + TNode2ColumnMap::iterator bN_col = myBotToColumnMap.insert( make_pair ( bN, TNodeColumn() )).first; TNodeColumn & column = bN_col->second; column.resize( zSize ); @@ -2253,7 +2470,7 @@ bool StdMeshers_Prism_3D::projectBottomToTop( const gp_Trsf & bottom // Check the projected mesh - if ( thePrism.myNbEdgesInWires.size() > 1 && // there are holes + if ( thePrism.NbWires() > 1 && // there are holes topHelper.IsDistorted2D( topSM, /*checkUV=*/false )) { SMESH_MeshEditor editor( topHelper.GetMesh() ); @@ -2263,29 +2480,39 @@ bool StdMeshers_Prism_3D::projectBottomToTop( const gp_Trsf & bottom Handle(Geom_Surface) surface = BRep_Tool::Surface( topFace, loc ); bool isPlanar = GeomLib_IsPlanarSurface( surface ).IsPlanar(); - bool isFixed = false; set fixedNodes; - for ( int iAttemp = 0; !isFixed && iAttemp < 10; ++iAttemp ) - { - TIDSortedElemSet faces; - for ( faceIt = topSMDS->GetElements(); faceIt->more(); ) - faces.insert( faces.end(), faceIt->next() ); + TIDSortedElemSet faces; + for ( faceIt = topSMDS->GetElements(); faceIt->more(); ) + faces.insert( faces.end(), faceIt->next() ); + bool isOk = false; + for ( int isCentroidal = 0; isCentroidal < 2; ++isCentroidal ) + { SMESH_MeshEditor::SmoothMethod algo = - iAttemp ? SMESH_MeshEditor::CENTROIDAL : SMESH_MeshEditor::LAPLACIAN; + isCentroidal ? SMESH_MeshEditor::CENTROIDAL : SMESH_MeshEditor::LAPLACIAN; - // smoothing - editor.Smooth( faces, fixedNodes, algo, /*nbIterations=*/ 10, - /*theTgtAspectRatio=*/1.0, /*the2D=*/!isPlanar); + int nbAttempts = isCentroidal ? 1 : 10; + for ( int iAttemp = 0; iAttemp < nbAttempts; ++iAttemp ) + { + TIDSortedElemSet workFaces = faces; + + // smoothing + editor.Smooth( workFaces, fixedNodes, algo, /*nbIterations=*/ 10, + /*theTgtAspectRatio=*/1.0, /*the2D=*/!isPlanar); - isFixed = !topHelper.IsDistorted2D( topSM, /*checkUV=*/true ); + if (( isOk = !topHelper.IsDistorted2D( topSM, /*checkUV=*/true )) && + ( !isCentroidal )) + break; + } } - if ( !isFixed ) + if ( !isOk ) return toSM( error( TCom("Projection from face #") << botSM->GetId() << " to face #" << topSM->GetId() << " failed: inverted elements created")); } + TProjction2dAlgo::instance( this )->SetEventListener( topSM ); + return true; } @@ -2317,7 +2544,7 @@ double StdMeshers_Prism_3D::getSweepTolerance( const Prism_3D::TPrismTopo& thePr for ( int iN = 0; iN < nbNodes; ++iN ) nodes[ iN ] = nIt->next(); nodes.back() = nodes[0]; - + // loop on links double dist2; for ( int iN = 0; iN < nbNodes; ++iN ) @@ -2362,13 +2589,16 @@ double StdMeshers_Prism_3D::getSweepTolerance( const Prism_3D::TPrismTopo& thePr //======================================================================= //function : isSimpleQuad -//purpose : check if the bottom FACE is meshable with nice qudrangles, -// if so the block aproach can work rather fast. +//purpose : check if the bottom FACE is meshable with nice quadrangles, +// if so the block approach can work rather fast. // This is a temporary mean caused by problems in StdMeshers_Sweeper //======================================================================= bool StdMeshers_Prism_3D::isSimpleBottom( const Prism_3D::TPrismTopo& thePrism ) { + if ( thePrism.myNbEdgesInWires.front() != 4 ) + return false; + // analyse angles between edges double nbConcaveAng = 0, nbConvexAng = 0; TopoDS_Face reverseBottom = TopoDS::Face( thePrism.myBottom.Reversed() ); // see initPrism() @@ -2398,6 +2628,43 @@ bool StdMeshers_Prism_3D::isSimpleBottom( const Prism_3D::TPrismTopo& thePrism ) return true; } +//======================================================================= +//function : allVerticalEdgesStraight +//purpose : Defines if all "vertical" EDGEs are straight +//======================================================================= + +bool StdMeshers_Prism_3D::allVerticalEdgesStraight( const Prism_3D::TPrismTopo& thePrism ) +{ + for ( size_t i = 0; i < thePrism.myWallQuads.size(); ++i ) + { + const Prism_3D::TQuadList& quads = thePrism.myWallQuads[i]; + Prism_3D::TQuadList::const_iterator quadIt = quads.begin(); + TopoDS_Edge prevQuadEdge; + for ( ; quadIt != quads.end(); ++quadIt ) + { + StdMeshers_FaceSidePtr rightSide = (*quadIt)->side[ QUAD_RIGHT_SIDE ]; + + if ( !prevQuadEdge.IsNull() && + !SMESH_Algo::IsContinuous( rightSide->Edge( 0 ), prevQuadEdge )) + return false; + + for ( int iE = 0; iE < rightSide->NbEdges(); ++iE ) + { + const TopoDS_Edge & rightE = rightSide->Edge( iE ); + if ( !SMESH_Algo::IsStraight( rightE, /*degenResult=*/true )) + return false; + + if ( iE > 0 && + !SMESH_Algo::IsContinuous( rightSide->Edge( iE-1 ), rightE )) + return false; + + prevQuadEdge = rightE; + } + } + } + return true; +} + //======================================================================= //function : project2dMesh //purpose : Project mesh faces from a source FACE of one prism (theSrcFace) @@ -2424,6 +2691,8 @@ bool StdMeshers_Prism_3D::project2dMesh(const TopoDS_Face& theSrcFace, tgtSM->ComputeStateEngine ( SMESH_subMesh::CHECK_COMPUTE_STATE ); tgtSM->ComputeSubMeshStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE ); + projector2D->SetEventListener( tgtSM ); + return ok; } @@ -2502,29 +2771,66 @@ namespace // utils used by StdMeshers_Prism_3D::IsApplicable() { struct EdgeWithNeighbors { - TopoDS_Edge _edge; - int _iL, _iR; - EdgeWithNeighbors(const TopoDS_Edge& E, int iE, int nbE, int shift = 0 ): + TopoDS_Edge _edge; + int _iBase; // index in a WIRE with non-base EDGEs excluded + int _iL, _iR; // used to connect PrismSide's + int _iE; // index in a WIRE + int _iLE, _iRE; // used to connect EdgeWithNeighbors's + bool _isBase; // is used in a base FACE + TopoDS_Vertex _vv[2]; // end VERTEXes + EdgeWithNeighbors(const TopoDS_Edge& E, + int iE, int nbE, int shift, + int iEE, int nbEE, int shiftE, + bool isBase, bool setVV ): _edge( E ), - _iL( SMESH_MesherHelper::WrapIndex( iE-1, nbE ) + shift ), - _iR( SMESH_MesherHelper::WrapIndex( iE+1, nbE ) + shift ) + _iBase( iE + shift ), + _iL ( SMESH_MesherHelper::WrapIndex( iE-1, Max( 1, nbE )) + shift ), + _iR ( SMESH_MesherHelper::WrapIndex( iE+1, Max( 1, nbE )) + shift ), + _iE ( iEE + shiftE ), + _iLE( SMESH_MesherHelper::WrapIndex( iEE-1, Max( 1, nbEE )) + shiftE ), + _iRE( SMESH_MesherHelper::WrapIndex( iEE+1, Max( 1, nbEE )) + shiftE ), + _isBase( isBase ) { + if ( setVV ) + { + Vertex( 0 ); + Vertex( 1 ); + } } EdgeWithNeighbors() {} + bool IsInternal() const { return !_edge.IsNull() && _edge.Orientation() == TopAbs_INTERNAL; } + bool IsConnected( const EdgeWithNeighbors& edge, int iEnd ) const + { + return (( _vv[ iEnd ].IsSame( edge._vv[ 1 - iEnd ])) || + ( IsInternal() && _vv[ iEnd ].IsSame( edge._vv[ iEnd ]))); + } + bool IsConnected( const std::vector< EdgeWithNeighbors > & edges, int iEnd ) const + { + int iEdge = iEnd ? _iRE : _iLE; + return iEdge == _iE ? false : IsConnected( edges[ iEdge ], iEnd ); + } + const TopoDS_Vertex& Vertex( int iEnd ) + { + if ( _vv[ iEnd ].IsNull() ) + _vv[ iEnd ] = SMESH_MesherHelper::IthVertex( iEnd, _edge ); + return _vv[ iEnd ]; + } }; + // PrismSide contains all FACEs linking a bottom EDGE with a top one. struct PrismSide { - TopoDS_Face _face; - TopTools_IndexedMapOfShape *_faces; // pointer because its copy constructor is private - TopoDS_Edge _topEdge; - vector< EdgeWithNeighbors >*_edges; - int _iBotEdge; - vector< bool > _isCheckedEdge; + TopoDS_Face _face; // a currently treated upper FACE + TopTools_IndexedMapOfShape *_faces; // all FACEs (pointer because of a private copy constructor) + TopoDS_Edge _topEdge; // a current top EDGE + vector< EdgeWithNeighbors >*_edges; // all EDGEs of _face + int _iBotEdge; // index of _topEdge within _edges + vector< bool > _isCheckedEdge; // mark EDGEs whose two owner FACEs found int _nbCheckedEdges; // nb of EDGEs whose location is defined - PrismSide *_leftSide; + PrismSide *_leftSide; // neighbor sides PrismSide *_rightSide; - void SetExcluded() { _leftSide = _rightSide = NULL; } - bool IsExcluded() const { return !_leftSide; } + bool _isInternal; // whether this side raises from an INTERNAL EDGE + //void SetExcluded() { _leftSide = _rightSide = NULL; } + //bool IsExcluded() const { return !_leftSide; } const TopoDS_Edge& Edge( int i ) const { return (*_edges)[ i ]._edge; @@ -2535,85 +2841,187 @@ namespace // utils used by StdMeshers_Prism_3D::IsApplicable() if ( E.IsSame( Edge( i ))) return i; return -1; } - bool IsSideFace( const TopoDS_Shape& face ) const + const TopoDS_Vertex& Vertex( int iE, int iEnd ) const + { + return (*_edges)[ iE ].Vertex( iEnd ); + } + bool HasVertex( const TopoDS_Vertex& V ) const + { + for ( size_t i = 0; i < _edges->size(); ++i ) + if ( V.IsSame( Vertex( i, 0 ))) return true; + return false; + } + bool IsSideFace( const TopTools_ListOfShape& faces, + const TopoDS_Face& avoidFace, + const bool checkNeighbors ) const { - if ( _faces->Contains( face )) // avoid returning true for a prism top FACE - return ( !_face.IsNull() || !( face.IsSame( _faces->FindKey( _faces->Extent() )))); + TopTools_ListIteratorOfListOfShape faceIt( faces ); + for ( ; faceIt.More(); faceIt.Next() ) + { + const TopoDS_Shape& face = faceIt.Value(); + if ( !face.IsSame( avoidFace )) + { + if ( _faces->Contains( face )) // avoid returning true for a prism top FACE + return ( !_face.IsNull() || !( face.IsSame( _faces->FindKey( _faces->Extent() )))); + } + } + if ( checkNeighbors ) + return (( _leftSide && _leftSide->IsSideFace ( faces, avoidFace, false )) || + ( _rightSide && _rightSide->IsSideFace( faces, avoidFace, false ))); + return false; } }; //-------------------------------------------------------------------------------- + /*! + * \brief Return another faces sharing an edge + */ + const TopoDS_Face & getAnotherFace( const TopoDS_Face& face, + const TopTools_ListOfShape& faces) + { + TopTools_ListIteratorOfListOfShape faceIt( faces ); + for ( ; faceIt.More(); faceIt.Next() ) + if ( !face.IsSame( faceIt.Value() )) + return TopoDS::Face( faceIt.Value() ); + return face; + } + //-------------------------------------------------------------------------------- + /*! + * \brief Return another faces sharing an edge + */ + const TopoDS_Face & getAnotherFace( const TopoDS_Face& face, + const TopoDS_Edge& edge, + TopTools_IndexedDataMapOfShapeListOfShape& facesOfEdge) + { + return getAnotherFace( face, facesOfEdge.FindFromKey( edge )); + } + + //-------------------------------------------------------------------------------- + /*! + * \brief Return ordered edges of a face + */ + //================================================================================ /*! * \brief Return ordered edges of a face + * \param [in] face - the face + * \param [out] edges - return edge (edges from which no vertical faces raise excluded) + * \param [in] facesOfEdge - faces of each edge + * \param [in] noHolesAllowed - are multiple wires allowed */ - bool getEdges( const TopoDS_Face& face, - vector< EdgeWithNeighbors > & edges, - const bool noHolesAllowed) + //================================================================================ + + bool getEdges( const TopoDS_Face& face, + vector< EdgeWithNeighbors > & edges, + TopTools_IndexedDataMapOfShapeListOfShape& facesOfEdge, + const bool noHolesAllowed) { + TopoDS_Face f = face; + if ( f.Orientation() != TopAbs_FORWARD && + f.Orientation() != TopAbs_REVERSED ) + f.Orientation( TopAbs_FORWARD ); list< TopoDS_Edge > ee; list< int > nbEdgesInWires; - int nbW = SMESH_Block::GetOrderedEdges( face, ee, nbEdgesInWires ); + int nbW = SMESH_Block::GetOrderedEdges( f, ee, nbEdgesInWires ); if ( nbW > 1 && noHolesAllowed ) return false; - int iE, nbTot = 0; - list< TopoDS_Edge >::iterator e = ee.begin(); - list< int >::iterator nbE = nbEdgesInWires.begin(); + list< TopoDS_Edge >::iterator e = ee.begin(); + list< int >::iterator nbE = nbEdgesInWires.begin(); for ( ; nbE != nbEdgesInWires.end(); ++nbE ) - for ( iE = 0; iE < *nbE; ++e, ++iE ) - if ( SMESH_Algo::isDegenerated( *e )) + for ( int iE = 0; iE < *nbE; ++e, ++iE ) + if ( SMESH_Algo::isDegenerated( *e )) // degenerated EDGE is never used { e = --ee.erase( e ); --(*nbE); --iE; } - else - { - e->Orientation( TopAbs_FORWARD ); // for operator==() to work - } + int iE, nbTot = 0, iBase, nbBase, nbTotBase = 0; + vector isBase; edges.clear(); e = ee.begin(); for ( nbE = nbEdgesInWires.begin(); nbE != nbEdgesInWires.end(); ++nbE ) { - for ( iE = 0; iE < *nbE; ++e, ++iE ) - edges.push_back( EdgeWithNeighbors( *e, iE, *nbE, nbTot )); - nbTot += *nbE; + nbBase = 0; + isBase.resize( *nbE ); + list< TopoDS_Edge >::iterator eIt = e; + for ( iE = 0; iE < *nbE; ++eIt, ++iE ) + { + isBase[ iE ] = ( getAnotherFace( face, *eIt, facesOfEdge ) != face ); + nbBase += isBase[ iE ]; + } + for ( iBase = 0, iE = 0; iE < *nbE; ++e, ++iE ) + { + edges.push_back( EdgeWithNeighbors( *e, + iBase, nbBase, nbTotBase, + iE, *nbE, nbTot, + isBase[ iE ], nbW > 1 )); + iBase += isBase[ iE ]; + } + nbTot += *nbE; + nbTotBase += nbBase; + } + if ( nbTotBase == 0 ) + return false; + + // IPAL53099, 54416. Set correct neighbors to INTERNAL EDGEs + if ( nbW > 1 ) + { + int iFirst = 0, iLast; + for ( nbE = nbEdgesInWires.begin(); nbE != nbEdgesInWires.end(); ++nbE ) + { + iLast = iFirst + *nbE - 1; + bool isConnectOk = ( edges[ iFirst ].IsConnected( edges, 0 ) && + edges[ iFirst ].IsConnected( edges, 1 )); + if ( !isConnectOk ) + { + for ( iE = iFirst; iE <= iLast; ++iE ) + { + if ( !edges[ iE ]._isBase ) + continue; + int* iNei[] = { & edges[ iE ]._iL, + & edges[ iE ]._iR }; + for ( int iV = 0; iV < 2; ++iV ) + { + if ( edges[ iE ].IsConnected( edges, iV )) + continue; // Ok - connected to a neighbor EDGE + + // look for a connected EDGE + bool found = false; + for ( int iE2 = 0, nbE = edges.size(); iE2 < nbE && !found; ++iE2 ) + if (( iE2 != iE ) && + ( found = edges[ iE ].IsConnected( edges[ iE2 ], iV ))) + { + *iNei[ iV ] = edges[ iE2 ]._iBase; + } + if ( !found ) + *iNei[ iV ] = edges[ iE ]._iBase; // connect to self + } + } + } + iFirst += *nbE; + } } return edges.size(); } - //-------------------------------------------------------------------------------- - /*! - * \brief Return another faces sharing an edge - */ - const TopoDS_Face & getAnotherFace( const TopoDS_Face& face, - const TopoDS_Edge& edge, - TopTools_IndexedDataMapOfShapeListOfShape& facesOfEdge) - { - TopTools_ListIteratorOfListOfShape faceIt( facesOfEdge.FindFromKey( edge )); - for ( ; faceIt.More(); faceIt.Next() ) - if ( !face.IsSame( faceIt.Value() )) - return TopoDS::Face( faceIt.Value() ); - return face; - } //-------------------------------------------------------------------------------- /*! * \brief Return number of faces sharing given edges */ - int nbAdjacentFaces( const std::vector< EdgeWithNeighbors >& edges, - const TopTools_IndexedDataMapOfShapeListOfShape& facesOfEdge ) - { - TopTools_MapOfShape adjFaces; - - for ( size_t i = 0; i < edges.size(); ++i ) - { - TopTools_ListIteratorOfListOfShape faceIt( facesOfEdge.FindFromKey( edges[i]._edge )); - for ( ; faceIt.More(); faceIt.Next() ) - adjFaces.Add( faceIt.Value() ); - } - return adjFaces.Extent(); - } + // int nbAdjacentFaces( const std::vector< EdgeWithNeighbors >& edges, + // const TopTools_IndexedDataMapOfShapeListOfShape& facesOfEdge ) + // { + // TopTools_MapOfShape adjFaces; + + // for ( size_t i = 0; i < edges.size(); ++i ) + // { + // TopTools_ListIteratorOfListOfShape faceIt( facesOfEdge.FindFromKey( edges[i]._edge )); + // for ( ; faceIt.More(); faceIt.Next() ) + // adjFaces.Add( faceIt.Value() ); + // } + // return adjFaces.Extent(); + // } } //================================================================================ @@ -2636,10 +3044,10 @@ bool StdMeshers_Prism_3D::IsApplicable(const TopoDS_Shape & shape, bool toCheckA // check nb shells TopoDS_Shape shell; TopExp_Explorer shExp( sExp.Current(), TopAbs_SHELL ); - if ( shExp.More() ) { + while ( shExp.More() ) { shell = shExp.Current(); shExp.Next(); - if ( shExp.More() ) + if ( shExp.More() && BRep_Tool::IsClosed( shExp.Current() )) shell.Nullify(); } if ( shell.IsNull() ) { @@ -2648,7 +3056,7 @@ bool StdMeshers_Prism_3D::IsApplicable(const TopoDS_Shape & shape, bool toCheckA } // get all faces TopTools_IndexedMapOfShape allFaces; - TopExp::MapShapes( shell, TopAbs_FACE, allFaces ); + TopExp::MapShapes( sExp.Current(), TopAbs_FACE, allFaces ); if ( allFaces.Extent() < 3 ) { if ( toCheckAll ) return false; continue; @@ -2665,7 +3073,7 @@ bool StdMeshers_Prism_3D::IsApplicable(const TopoDS_Shape & shape, bool toCheckA } } #ifdef _DEBUG_ - TopTools_IndexedMapOfShape allShapes; + TopTools_IndexedMapOfShape allShapes; // usage: allShapes.FindIndex( s ) TopExp::MapShapes( shape, allShapes ); #endif @@ -2679,7 +3087,7 @@ bool StdMeshers_Prism_3D::IsApplicable(const TopoDS_Shape & shape, bool toCheckA typedef vector< EdgeWithNeighbors > TEdgeWithNeighborsVec; vector< TEdgeWithNeighborsVec > faceEdgesVec( allFaces.Extent() + 1 ); - const size_t nbEdgesMax = facesOfEdge.Extent() * 2; // there can be seam EDGES + const size_t nbEdgesMax = facesOfEdge.Extent() * 2; // there can be seam EDGEs TopTools_IndexedMapOfShape* facesOfSide = new TopTools_IndexedMapOfShape[ nbEdgesMax ]; SMESHUtils::ArrayDeleter delFacesOfSide( facesOfSide ); @@ -2692,30 +3100,40 @@ bool StdMeshers_Prism_3D::IsApplicable(const TopoDS_Shape & shape, bool toCheckA TEdgeWithNeighborsVec& botEdges = faceEdgesVec[ iF ]; if ( botEdges.empty() ) - if ( !getEdges( botF, botEdges, /*noHoles=*/false )) + if ( !getEdges( botF, botEdges, facesOfEdge, /*noHoles=*/false )) break; - if ( allFaces.Extent()-1 <= (int) botEdges.size() ) + + int nbBase = 0; + for ( size_t iS = 0; iS < botEdges.size(); ++iS ) + nbBase += botEdges[ iS ]._isBase; + + if ( allFaces.Extent()-1 <= nbBase ) continue; // all faces are adjacent to botF - no top FACE // init data of side FACEs sides.clear(); - sides.resize( botEdges.size() ); - for ( size_t iS = 0; iS < botEdges.size(); ++iS ) + sides.resize( nbBase ); + size_t iS = 0; + for ( size_t iE = 0; iE < botEdges.size(); ++iE ) { - sides[ iS ]._topEdge = botEdges[ iS ]._edge; - sides[ iS ]._face = botF; - sides[ iS ]._leftSide = & sides[ botEdges[ iS ]._iR ]; - sides[ iS ]._rightSide = & sides[ botEdges[ iS ]._iL ]; - sides[ iS ]._faces = & facesOfSide[ iS ]; + if ( !botEdges[ iE ]._isBase ) + continue; + sides[ iS ]._topEdge = botEdges[ iE ]._edge; + sides[ iS ]._face = botF; + sides[ iS ]._leftSide = & sides[ botEdges[ iE ]._iR ]; + sides[ iS ]._rightSide = & sides[ botEdges[ iE ]._iL ]; + sides[ iS ]._isInternal = botEdges[ iE ].IsInternal(); + sides[ iS ]._faces = & facesOfSide[ iS ]; sides[ iS ]._faces->Clear(); + ++iS; } bool isOK = true; // ok for a current botF - bool isAdvanced = true; // is new data found in a current loop + bool hasAdvanced = true; // is new data found in a current loop int nbFoundSideFaces = 0; - for ( int iLoop = 0; isOK && isAdvanced; ++iLoop ) + for ( int iLoop = 0; isOK && hasAdvanced; ++iLoop ) { - isAdvanced = false; + hasAdvanced = false; for ( size_t iS = 0; iS < sides.size() && isOK; ++iS ) { PrismSide& side = sides[ iS ]; @@ -2724,21 +3142,35 @@ bool StdMeshers_Prism_3D::IsApplicable(const TopoDS_Shape & shape, bool toCheckA if ( side._topEdge.IsNull() ) { - // find vertical EDGEs --- EGDEs shared with neighbor side FACEs + // find vertical EDGEs --- EDGEs shared with neighbor side FACEs for ( int is2nd = 0; is2nd < 2 && isOK; ++is2nd ) // 2 adjacent neighbors { - int di = is2nd ? 1 : -1; const PrismSide* adjSide = is2nd ? side._rightSide : side._leftSide; + if ( side._isInternal ) + { + const TopoDS_Vertex& V = side.Vertex( side._iBotEdge, is2nd ); + bool lHasV = side._leftSide ->HasVertex( V ); + bool rHasV = side._rightSide->HasVertex( V ); + if ( lHasV == rHasV ) + adjSide = ( &side == side._leftSide ) ? side._rightSide : side._leftSide; + else + adjSide = ( rHasV ) ? side._rightSide : side._leftSide; + } + int di = is2nd ? 1 : -1; for ( size_t i = 1; i < side._edges->size(); ++i ) { int iE = SMESH_MesherHelper::WrapIndex( i*di + side._iBotEdge, side._edges->size()); if ( side._isCheckedEdge[ iE ] ) continue; - const TopoDS_Edge& vertE = side.Edge( iE ); - const TopoDS_Shape& neighborF = getAnotherFace( side._face, vertE, facesOfEdge ); - bool isEdgeShared = adjSide->IsSideFace( neighborF ); - if ( isEdgeShared ) // vertE is shared with adjSide + const TopoDS_Edge& vertE = side.Edge( iE ); + const TopTools_ListOfShape& neighborFF = facesOfEdge.FindFromKey( vertE ); + bool isEdgeShared = (( adjSide->IsSideFace( neighborFF, side._face, + side._isInternal )) || + ( adjSide == &side && + side._face.IsSame( getAnotherFace( side._face, + neighborFF )))); + if ( isEdgeShared ) // vertE is shared with adjSide { - isAdvanced = true; + hasAdvanced = true; side._isCheckedEdge[ iE ] = true; side._nbCheckedEdges++; int nbNotCheckedE = side._edges->size() - side._nbCheckedEdges; @@ -2777,20 +3209,19 @@ bool StdMeshers_Prism_3D::IsApplicable(const TopoDS_Shape & shape, bool toCheckA { stop = true; } - else if ( side._leftSide != & side ) // not closed side face + else if ( side._leftSide != & side && // not closed side face + side._leftSide->_faces->Contains( f )) { - if ( side._leftSide->_faces->Contains( f )) - { - stop = true; // probably f is the prism top face - side._leftSide->_face.Nullify(); - side._leftSide->_topEdge.Nullify(); - } - if ( side._rightSide->_faces->Contains( f )) - { - stop = true; // probably f is the prism top face - side._rightSide->_face.Nullify(); - side._rightSide->_topEdge.Nullify(); - } + stop = true; // probably f is the prism top face + side._leftSide->_face.Nullify(); + side._leftSide->_topEdge.Nullify(); + } + else if ( side._rightSide != & side && + side._rightSide->_faces->Contains( f )) + { + stop = true; // probably f is the prism top face + side._rightSide->_face.Nullify(); + side._rightSide->_topEdge.Nullify(); } if ( stop ) { @@ -2802,12 +3233,12 @@ bool StdMeshers_Prism_3D::IsApplicable(const TopoDS_Shape & shape, bool toCheckA int faceID = allFaces.FindIndex( side._face ); side._edges = & faceEdgesVec[ faceID ]; if ( side._edges->empty() ) - if ( !getEdges( side._face, * side._edges, /*noHoles=*/true )) + if ( !getEdges( side._face, * side._edges, facesOfEdge, /*noHoles=*/true )) break; const int nbE = side._edges->size(); if ( nbE >= 4 ) { - isAdvanced = true; + hasAdvanced = true; ++nbFoundSideFaces; side._iBotEdge = side.FindEdge( side._topEdge ); side._isCheckedEdge.clear(); @@ -2815,6 +3246,10 @@ bool StdMeshers_Prism_3D::IsApplicable(const TopoDS_Shape & shape, bool toCheckA side._isCheckedEdge[ side._iBotEdge ] = true; side._nbCheckedEdges = 1; // bottom EDGE is known } + else // probably a triangular top face found + { + side._face.Nullify(); + } side._topEdge.Nullify(); isOK = ( !side._edges->empty() || side._faces->Extent() > 1 ); @@ -2833,7 +3268,7 @@ bool StdMeshers_Prism_3D::IsApplicable(const TopoDS_Shape & shape, bool toCheckA cerr << "BUG: infinite loop in StdMeshers_Prism_3D::IsApplicable()" << endl; #endif } - } // while isAdvanced + } // while hasAdvanced if ( isOK && sides[0]._faces->Extent() > 1 ) { @@ -2844,12 +3279,20 @@ bool StdMeshers_Prism_3D::IsApplicable(const TopoDS_Shape & shape, bool toCheckA } else { + // check that all face columns end up at the same top face const TopoDS_Shape& topFace = sides[0]._faces->FindKey( nbFaces ); size_t iS; for ( iS = 1; iS < sides.size(); ++iS ) if ( ! sides[ iS ]._faces->Contains( topFace )) break; - prismDetected = ( iS == sides.size() ); + if (( prismDetected = ( iS == sides.size() ))) + { + // check that bottom and top faces has equal nb of edges + TEdgeWithNeighborsVec& topEdges = faceEdgesVec[ allFaces.FindIndex( topFace )]; + if ( topEdges.empty() ) + getEdges( TopoDS::Face( topFace ), topEdges, facesOfEdge, /*noHoles=*/false ); + prismDetected = ( botEdges.size() == topEdges.size() ); + } } } } // loop on allFaces @@ -2973,7 +3416,6 @@ bool StdMeshers_Prism_3D::initPrism(Prism_3D::TPrismTopo& thePrism, list< SMESH_subMesh* > meshedSubMesh; int nbFaces = 0; // - SMESH_subMesh* anyFaceSM = 0; SMESH_subMeshIteratorPtr smIt = mainSubMesh->getDependsOnIterator(false,true); while ( smIt->more() ) { @@ -2982,7 +3424,6 @@ bool StdMeshers_Prism_3D::initPrism(Prism_3D::TPrismTopo& thePrism, if ( face.ShapeType() > TopAbs_FACE ) break; else if ( face.ShapeType() < TopAbs_FACE ) continue; nbFaces++; - anyFaceSM = sm; // is quadrangle FACE? list< TopoDS_Edge > orderedEdges; @@ -3083,7 +3524,7 @@ bool StdMeshers_Prism_3D::initPrism(Prism_3D::TPrismTopo& thePrism, if ( !botSM ) // find a proper bottom { bool savedSetErrorToSM = mySetErrorToSM; - mySetErrorToSM = false; // ingore errors in initPrism() + mySetErrorToSM = false; // ignore errors in initPrism() // search among meshed FACEs list< SMESH_subMesh* >::iterator sm = meshedSubMesh.begin(); @@ -3112,7 +3553,7 @@ bool StdMeshers_Prism_3D::initPrism(Prism_3D::TPrismTopo& thePrism, // find vertex 000 - the one with smallest coordinates (for easy DEBUG :-) TopoDS_Vertex V000; - double minVal = DBL_MAX, minX, val; + double minVal = DBL_MAX, minX = 0, val; for ( TopExp_Explorer exp( botSM->GetSubShape(), TopAbs_VERTEX ); exp.More(); exp.Next() ) { @@ -3151,9 +3592,11 @@ bool StdMeshers_Prism_3D::initPrism(Prism_3D::TPrismTopo& thePrism, "Non-quadrilateral faces are not opposite")); // check that the found top and bottom FACEs are opposite + TopTools_IndexedMapOfShape topEdgesMap( thePrism.myBottomEdges.size() ); + TopExp::MapShapes( thePrism.myTop, topEdgesMap ); list< TopoDS_Edge >::iterator edge = thePrism.myBottomEdges.begin(); for ( ; edge != thePrism.myBottomEdges.end(); ++edge ) - if ( myHelper->IsSubShape( *edge, thePrism.myTop )) + if ( topEdgesMap.Contains( *edge )) return toSM( error (notQuadGeomSubMesh.empty() ? COMPERR_BAD_INPUT_MESH : COMPERR_BAD_SHAPE, "Non-quadrilateral faces are not opposite")); @@ -3195,7 +3638,7 @@ bool StdMeshers_PrismAsBlock::Init(SMESH_MesherHelper* helper, SMESH_Block::init(); myShapeIDMap.Clear(); myShapeIndex2ColumnMap.clear(); - + int wallFaceIds[ NB_WALL_FACES ] = { // to walk around a block SMESH_Block::ID_Fx0z, SMESH_Block::ID_F1yz, SMESH_Block::ID_Fx1z, SMESH_Block::ID_F0yz @@ -3256,6 +3699,9 @@ bool StdMeshers_PrismAsBlock::Init(SMESH_MesherHelper* helper, return error(COMPERR_BAD_INPUT_MESH, TCom("Can't find regular quadrangle mesh ") << "on a side face #" << MeshDS()->ShapeToIndex( (*quad)->face )); } + if ( !faceColumns.empty() && (int)faceColumns.begin()->second.size() != VerticalSize() ) + return error(COMPERR_BAD_INPUT_MESH, "Different 'vertical' discretization"); + // edge columns int id = MeshDS()->ShapeToIndex( *edgeIt ); bool isForward = true; // meaningless for intenal wires @@ -3635,7 +4081,7 @@ bool StdMeshers_PrismAsBlock::GetLayersTransformation(vector & if ( p0.SquareDistance( pz ) > tol2 ) { t = gp_Trsf(); - return ( z == zSize - 1 ); // OK if fails only botton->top trsf + return ( z == zSize - 1 ); // OK if fails only bottom->top trsf } } } @@ -3644,12 +4090,12 @@ bool StdMeshers_PrismAsBlock::GetLayersTransformation(vector & //================================================================================ /*! - * \brief Check curve orientation of a bootom edge + * \brief Check curve orientation of a bottom edge * \param meshDS - mesh DS * \param columnsMap - node columns map of side face - * \param bottomEdge - the bootom edge + * \param bottomEdge - the bottom edge * \param sideFaceID - side face in-block ID - * \retval bool - true if orientation coinside with in-block forward orientation + * \retval bool - true if orientation coincide with in-block forward orientation */ //================================================================================ @@ -3720,7 +4166,7 @@ void StdMeshers_PrismAsBlock::faceGridToPythonDump(const SMESH_Block::TShapeID f << n << ", " << n+1 << ", " << n+nb+2 << ", " << n+nb+1 << "]) " << endl; } - + #endif } @@ -3872,8 +4318,8 @@ Adaptor3d_Curve* StdMeshers_PrismAsBlock::TSideFace::VertiCurve(const bool isMax //================================================================================ /*! * \brief Return geometry of the top or bottom curve - * \param isTop - - * \retval Adaptor3d_Curve* - + * \param isTop - + * \retval Adaptor3d_Curve* - */ //================================================================================ @@ -4129,7 +4575,7 @@ gp_Pnt StdMeshers_PrismAsBlock::TSideFace::Value(const Standard_Real U, meshDS->IndexToShape( notFaceID2 ), *myHelper.GetMesh(), TopAbs_FACE ); - if ( face.IsNull() ) + if ( face.IsNull() ) throw SALOME_Exception("StdMeshers_PrismAsBlock::TSideFace::Value() face.IsNull()"); int faceID = meshDS->ShapeToIndex( face ); me->mySurface = me->myShapeID2Surf[ faceID ]; @@ -4259,7 +4705,7 @@ int StdMeshers_PrismAsBlock::TSideFace::InsertSubShapes(TBlockShapes& shapeMap) if ( v1.ShapeType() == TopAbs_VERTEX ) { nbInserted += SMESH_Block::Insert( v1, vertIdVec[ 1 ], shapeMap); } - + // from V1 column SMESH_Block::GetEdgeVertexIDs( edgeIdVec[ V1_EDGE ], vertIdVec); GetColumns(1, col1, col2 ); @@ -4307,7 +4753,7 @@ int StdMeshers_PrismAsBlock::TSideFace::InsertSubShapes(TBlockShapes& shapeMap) // if ( edgeID = edgeIdVec[ _v1 ]) edgeID = edgeIdVec[ _v0 ]; // else edgeID = edgeIdVec[ _v1 ]; // SMESH_Block::Insert( sideEdge, edgeID, shapeMap); - + // // top edge // TopoDS_Edge topEdge = GetEdge( TOP_EDGE ); // SMESH_Block::Insert( topEdge, edgeIdVec[ _u1 ], shapeMap); @@ -4345,7 +4791,7 @@ void StdMeshers_PrismAsBlock::TSideFace::dumpNodes(int nbNodes) const //================================================================================ /*! - * \brief Creates TVerticalEdgeAdaptor + * \brief Creates TVerticalEdgeAdaptor * \param columnsMap - node column map * \param parameter - normalized parameter */ @@ -4420,7 +4866,7 @@ void StdMeshers_PrismAsBlock::THorizontalEdgeAdaptor::dumpNodes(int nbNodes) con TParam2ColumnIt col, col2; TParam2ColumnMap* u2cols = side->GetColumns(); side->GetColumns( u , col, col2 ); - + int j, i = myV ? mySide->ColumnHeight()-1 : 0; const SMDS_MeshNode* n = 0; @@ -4449,7 +4895,7 @@ void StdMeshers_PrismAsBlock::THorizontalEdgeAdaptor::dumpNodes(int nbNodes) con //================================================================================ /*! - * \brief Costructor of TPCurveOnHorFaceAdaptor fills its map of + * \brief Constructor of TPCurveOnHorFaceAdaptor fills its map of * normalized parameter to node UV on a horizontal face * \param [in] sideFace - lateral prism side * \param [in] isTop - is \a horFace top or bottom of the prism @@ -4501,7 +4947,7 @@ TPCurveOnHorFaceAdaptor::TPCurveOnHorFaceAdaptor( const TSideFace* sideFace, } if ( !C2d.IsNull() ) { - double u = static_cast< const SMDS_EdgePosition* >( n->GetPosition() )->GetUParameter(); + double u = SMDS_EdgePositionPtr( n->GetPosition() )->GetUParameter(); if ( f <= u && u <= l ) { uv = C2d->Value( u ).XY(); @@ -4555,6 +5001,7 @@ bool StdMeshers_Sweeper::projectIntPoints(const vector< gp_XYZ >& fromBndPoin const vector< gp_XYZ >& toBndPoints, const vector< gp_XYZ >& fromIntPoints, vector< gp_XYZ >& toIntPoints, + const double r, NSProjUtils::TrsfFinder3D& trsf, vector< gp_XYZ > * bndError) { @@ -4579,60 +5026,40 @@ bool StdMeshers_Sweeper::projectIntPoints(const vector< gp_XYZ >& fromBndPoin (*bndError)[ iP ] = toBndPoints[ iP ] - fromTrsf; } } - return true; -} -//================================================================================ -/*! - * \brief Add boundary error to ineternal points - */ -//================================================================================ - -void StdMeshers_Sweeper::applyBoundaryError(const vector< gp_XYZ >& bndPoints, - const vector< gp_XYZ >& bndError1, - const vector< gp_XYZ >& bndError2, - const double r, - vector< gp_XYZ >& intPoints, - vector< double >& int2BndDist) -{ - // fix each internal point - const double eps = 1e-100; - for ( size_t iP = 0; iP < intPoints.size(); ++iP ) + // apply boundary error + if ( bndError && toIntPoints.size() == myTopBotTriangles.size() ) { - gp_XYZ & intPnt = intPoints[ iP ]; - - // compute distance from intPnt to each boundary node - double int2BndDistSum = 0; - for ( size_t iBnd = 0; iBnd < bndPoints.size(); ++iBnd ) - { - int2BndDist[ iBnd ] = 1 / (( intPnt - bndPoints[ iBnd ]).SquareModulus() + eps ); - int2BndDistSum += int2BndDist[ iBnd ]; - } - - // apply bndError - for ( size_t iBnd = 0; iBnd < bndPoints.size(); ++iBnd ) + for ( size_t iP = 0; iP < toIntPoints.size(); ++iP ) { - intPnt += bndError1[ iBnd ] * ( 1 - r ) * int2BndDist[ iBnd ] / int2BndDistSum; - intPnt += bndError2[ iBnd ] * r * int2BndDist[ iBnd ] / int2BndDistSum; + const TopBotTriangles& tbTrias = myTopBotTriangles[ iP ]; + for ( int i = 0; i < 3; ++i ) // boundary errors at 3 triangle nodes + { + toIntPoints[ iP ] += + ( (*bndError)[ tbTrias.myBotTriaNodes[i] ] * tbTrias.myBotBC[i] * ( 1 - r ) + + (*bndError)[ tbTrias.myTopTriaNodes[i] ] * tbTrias.myTopBC[i] * ( r )); + } } } + + return true; } //================================================================================ /*! - * \brief Creates internal nodes of the prism + * \brief Create internal nodes of the prism by computing an affine transformation + * from layer to layer */ //================================================================================ -bool StdMeshers_Sweeper::ComputeNodes( SMESH_MesherHelper& helper, - const double tol, - const bool allowHighBndError) +bool StdMeshers_Sweeper::ComputeNodesByTrsf( const double tol, + const bool allowHighBndError) { const size_t zSize = myBndColumns[0]->size(); const size_t zSrc = 0, zTgt = zSize-1; if ( zSize < 3 ) return true; - vector< vector< gp_XYZ > > intPntsOfLayer( zSize ); // node coodinates to compute + vector< vector< gp_XYZ > > intPntsOfLayer( zSize ); // node coordinates to compute // set coordinates of src and tgt nodes for ( size_t z = 0; z < intPntsOfLayer.size(); ++z ) intPntsOfLayer[ z ].resize( myIntColumns.size() ); @@ -4642,7 +5069,11 @@ bool StdMeshers_Sweeper::ComputeNodes( SMESH_MesherHelper& helper, intPntsOfLayer[ zTgt ][ iP ] = intPoint( iP, zTgt ); } - // compute coordinates of internal nodes by projecting (transfroming) src and tgt + // for each internal column find boundary nodes whose error to use for correction + prepareTopBotDelaunay(); + bool isErrorCorrectable = findDelaunayTriangles(); + + // compute coordinates of internal nodes by projecting (transforming) src and tgt // nodes towards the central layer vector< NSProjUtils::TrsfFinder3D > trsfOfLayer( zSize ); @@ -4668,10 +5099,12 @@ bool StdMeshers_Sweeper::ComputeNodes( SMESH_MesherHelper& helper, } if (! projectIntPoints( fromSrcBndPnts, toSrcBndPnts, intPntsOfLayer[ zS-1 ], intPntsOfLayer[ zS ], + zS / ( zSize - 1.), trsfOfLayer [ zS-1 ], & bndError[ zS-1 ])) return false; if (! projectIntPoints( fromTgtBndPnts, toTgtBndPnts, intPntsOfLayer[ zT+1 ], intPntsOfLayer[ zT ], + zT / ( zSize - 1.), trsfOfLayer [ zT+1 ], & bndError[ zT+1 ])) return false; @@ -4696,6 +5129,22 @@ bool StdMeshers_Sweeper::ComputeNodes( SMESH_MesherHelper& helper, fromSrcBndPnts.swap( toSrcBndPnts ); } + // Evaluate an error of boundary points + + if ( !isErrorCorrectable && !allowHighBndError ) + { + for ( size_t iP = 0; iP < myBndColumns.size(); ++iP ) + { + double sumError = 0; + for ( size_t z = 1; z < zS; ++z ) // loop on layers + sumError += ( bndError[ z-1 ][ iP ].Modulus() + + bndError[ zSize-z ][ iP ].Modulus() ); + + if ( sumError > tol ) + return false; + } + } + // Compute two projections of internal points to the central layer // in order to evaluate an error of internal points @@ -4710,10 +5159,12 @@ bool StdMeshers_Sweeper::ComputeNodes( SMESH_MesherHelper& helper, } if (! projectIntPoints( fromSrcBndPnts, toSrcBndPnts, intPntsOfLayer[ zS-1 ], centerSrcIntPnts, + zS / ( zSize - 1.), trsfOfLayer [ zS-1 ], & bndError[ zS-1 ])) return false; if (! projectIntPoints( fromTgtBndPnts, toTgtBndPnts, intPntsOfLayer[ zT+1 ], centerTgtIntPnts, + zT / ( zSize - 1.), trsfOfLayer [ zT+1 ], & bndError[ zT+1 ])) return false; @@ -4732,24 +5183,7 @@ bool StdMeshers_Sweeper::ComputeNodes( SMESH_MesherHelper& helper, (intPntsOfLayer[ zS-1 ][ iP ] - centerTgtIntPnts[ iP ]).SquareModulus() < tol*tol; } - // Evaluate an error of boundary points - - bool bndErrorIsSmall = true; - for ( size_t iP = 0; ( iP < myBndColumns.size() && bndErrorIsSmall ); ++iP ) - { - double sumError = 0; - for ( size_t z = 1; z < zS; ++z ) // loop on layers - sumError += ( bndError[ z-1 ][ iP ].Modulus() + - bndError[ zSize-z ][ iP ].Modulus() ); - - bndErrorIsSmall = ( sumError < tol ); - } - - if ( !bndErrorIsSmall && !allowHighBndError ) - return false; - // compute final points on the central layer - std::vector< double > int2BndDist( myBndColumns.size() ); // work array of applyBoundaryError() double r = zS / ( zSize - 1.); if ( zS == zT ) { @@ -4758,11 +5192,6 @@ bool StdMeshers_Sweeper::ComputeNodes( SMESH_MesherHelper& helper, intPntsOfLayer[ zS ][ iP ] = ( 1 - r ) * centerSrcIntPnts[ iP ] + r * centerTgtIntPnts[ iP ]; } - if ( !bndErrorIsSmall ) - { - applyBoundaryError( toSrcBndPnts, bndError[ zS-1 ], bndError[ zS+1 ], r, - intPntsOfLayer[ zS ], int2BndDist ); - } } else { @@ -4773,17 +5202,8 @@ bool StdMeshers_Sweeper::ComputeNodes( SMESH_MesherHelper& helper, intPntsOfLayer[ zT ][ iP ] = r * intPntsOfLayer[ zT ][ iP ] + ( 1 - r ) * centerTgtIntPnts[ iP ]; } - if ( !bndErrorIsSmall ) - { - applyBoundaryError( toSrcBndPnts, bndError[ zS-1 ], bndError[ zS+1 ], r, - intPntsOfLayer[ zS ], int2BndDist ); - applyBoundaryError( toTgtBndPnts, bndError[ zT+1 ], bndError[ zT-1 ], r, - intPntsOfLayer[ zT ], int2BndDist ); - } } - //centerIntErrorIsSmall = true; - //bndErrorIsSmall = true; if ( !centerIntErrorIsSmall ) { // Compensate the central error; continue adding projection @@ -4815,9 +5235,11 @@ bool StdMeshers_Sweeper::ComputeNodes( SMESH_MesherHelper& helper, } projectIntPoints( fromSrcBndPnts, toSrcBndPnts, fromSrcIntPnts, toSrcIntPnts, + zS / ( zSize - 1.), trsfOfLayer[ zS+1 ], & srcBndError ); projectIntPoints( fromTgtBndPnts, toTgtBndPnts, fromTgtIntPnts, toTgtIntPnts, + zT / ( zSize - 1.), trsfOfLayer[ zT-1 ], & tgtBndError ); // if ( zS == zTgt - 1 ) @@ -4848,15 +5270,6 @@ bool StdMeshers_Sweeper::ComputeNodes( SMESH_MesherHelper& helper, zTIntPnts[ iP ] = r * zTIntPnts[ iP ] + ( 1 - r ) * toTgtIntPnts[ iP ]; } - // compensate bnd error - if ( !bndErrorIsSmall ) - { - applyBoundaryError( toSrcBndPnts, srcBndError, bndError[ zS+1 ], r, - intPntsOfLayer[ zS ], int2BndDist ); - applyBoundaryError( toTgtBndPnts, tgtBndError, bndError[ zT-1 ], r, - intPntsOfLayer[ zT ], int2BndDist ); - } - fromSrcBndPnts.swap( toSrcBndPnts ); fromSrcIntPnts.swap( toSrcIntPnts ); fromTgtBndPnts.swap( toTgtBndPnts ); @@ -4864,27 +5277,8 @@ bool StdMeshers_Sweeper::ComputeNodes( SMESH_MesherHelper& helper, } } // if ( !centerIntErrorIsSmall ) - else if ( !bndErrorIsSmall ) - { - zS = zSrc + 1; - zT = zTgt - 1; - for ( ; zS < zT; ++zS, --zT ) // vertical loop on layers - { - for ( size_t iP = 0; iP < myBndColumns.size(); ++iP ) - { - toSrcBndPnts[ iP ] = bndPoint( iP, zS ); - toTgtBndPnts[ iP ] = bndPoint( iP, zT ); - } - // compensate bnd error - applyBoundaryError( toSrcBndPnts, bndError[ zS-1 ], bndError[ zS-1 ], 0.5, - intPntsOfLayer[ zS ], int2BndDist ); - applyBoundaryError( toTgtBndPnts, bndError[ zT+1 ], bndError[ zT+1 ], 0.5, - intPntsOfLayer[ zT ], int2BndDist ); - } - } - // cout << "centerIntErrorIsSmall = " << centerIntErrorIsSmall<< endl; - // cout << "bndErrorIsSmall = " << bndErrorIsSmall<< endl; + //cout << "centerIntErrorIsSmall = " << centerIntErrorIsSmall<< endl; // Create nodes for ( size_t iP = 0; iP < myIntColumns.size(); ++iP ) @@ -4893,10 +5287,323 @@ bool StdMeshers_Sweeper::ComputeNodes( SMESH_MesherHelper& helper, for ( size_t z = zSrc + 1; z < zTgt; ++z ) // vertical loop on layers { const gp_XYZ & xyz = intPntsOfLayer[ z ][ iP ]; - if ( !( nodeCol[ z ] = helper.AddNode( xyz.X(), xyz.Y(), xyz.Z() ))) + if ( !( nodeCol[ z ] = myHelper->AddNode( xyz.X(), xyz.Y(), xyz.Z() ))) return false; } } return true; } + +//================================================================================ +/*! + * \brief Check if all nodes of each layers have same logical Z + */ +//================================================================================ + +bool StdMeshers_Sweeper::CheckSameZ() +{ + myZColumns.resize( myBndColumns.size() ); + fillZColumn( myZColumns[0], *myBndColumns[0] ); + + bool sameZ = true; + const double tol = 0.1 * 1./ myBndColumns[0]->size(); + + // check columns based on VERTEXes + + vector< int > vertexIndex; + vertexIndex.push_back( 0 ); + for ( size_t iC = 1; iC < myBndColumns.size() && sameZ; ++iC ) + { + if ( myBndColumns[iC]->front()->GetPosition()->GetDim() > 0 ) + continue; // not on VERTEX + + vertexIndex.push_back( iC ); + fillZColumn( myZColumns[iC], *myBndColumns[iC] ); + + for ( size_t iZ = 0; iZ < myZColumns[0].size() && sameZ; ++iZ ) + sameZ = ( Abs( myZColumns[0][iZ] - myZColumns[iC][iZ]) < tol ); + } + + // check columns based on EDGEs, one per EDGE + + for ( size_t i = 1; i < vertexIndex.size() && sameZ; ++i ) + { + if ( vertexIndex[i] - vertexIndex[i-1] < 2 ) + continue; + + int iC = ( vertexIndex[i] + vertexIndex[i-1] ) / 2; + fillZColumn( myZColumns[iC], *myBndColumns[iC] ); + + for ( size_t iZ = 0; iZ < myZColumns[0].size() && sameZ; ++iZ ) + sameZ = ( Abs( myZColumns[0][iZ] - myZColumns[iC][iZ]) < tol ); + } + + if ( sameZ ) + { + myZColumns.resize(1); + } + else + { + for ( size_t iC = 1; iC < myBndColumns.size(); ++iC ) + fillZColumn( myZColumns[iC], *myBndColumns[iC] ); + } + + return sameZ; +} + +//================================================================================ +/*! + * \brief Create internal nodes of the prism all located on straight lines with + * the same distribution along the lines. + */ +//================================================================================ + +bool StdMeshers_Sweeper::ComputeNodesOnStraightSameZ() +{ + TZColumn& z = myZColumns[0]; + + for ( size_t i = 0; i < myIntColumns.size(); ++i ) + { + TNodeColumn& nodes = *myIntColumns[i]; + SMESH_NodeXYZ n0( nodes[0] ), n1( nodes.back() ); + + for ( size_t iZ = 0; iZ < z.size(); ++iZ ) + { + gp_XYZ p = n0 * ( 1 - z[iZ] ) + n1 * z[iZ]; + nodes[ iZ+1 ] = myHelper->AddNode( p.X(), p.Y(), p.Z() ); + } + } + + return true; +} + +//================================================================================ +/*! + * \brief Create internal nodes of the prism all located on straight lines with + * different distributions along the lines. + */ +//================================================================================ + +bool StdMeshers_Sweeper::ComputeNodesOnStraight() +{ + prepareTopBotDelaunay(); + + const SMDS_MeshNode *botNode, *topNode; + const BRepMesh_Triangle *topTria; + double botBC[3], topBC[3]; // barycentric coordinates + int botTriaNodes[3], topTriaNodes[3]; + bool checkUV = true; + + int nbInternalNodes = myIntColumns.size(); + myBotDelaunay->InitTraversal( nbInternalNodes ); + + while (( botNode = myBotDelaunay->NextNode( botBC, botTriaNodes ))) + { + TNodeColumn* column = myIntColumns[ myNodeID2ColID( botNode->GetID() )]; + + // find a Delaunay triangle containing the topNode + topNode = column->back(); + gp_XY topUV = myHelper->GetNodeUV( myTopFace, topNode, NULL, &checkUV ); + // get a starting triangle basing on that top and bot boundary nodes have same index + topTria = myTopDelaunay->GetTriangleNear( botTriaNodes[0] ); + topTria = myTopDelaunay->FindTriangle( topUV, topTria, topBC, topTriaNodes ); + if ( !topTria ) + return false; + + // create nodes along a line + SMESH_NodeXYZ botP( botNode ), topP( topNode ); + for ( size_t iZ = 0; iZ < myZColumns[0].size(); ++iZ ) + { + // use barycentric coordinates as weight of Z of boundary columns + double botZ = 0, topZ = 0; + for ( int i = 0; i < 3; ++i ) + { + botZ += botBC[i] * myZColumns[ botTriaNodes[i] ][ iZ ]; + topZ += topBC[i] * myZColumns[ topTriaNodes[i] ][ iZ ]; + } + double rZ = double( iZ + 1 ) / ( myZColumns[0].size() + 1 ); + double z = botZ * ( 1 - rZ ) + topZ * rZ; + gp_XYZ p = botP * ( 1 - z ) + topP * z; + (*column)[ iZ+1 ] = myHelper->AddNode( p.X(), p.Y(), p.Z() ); + } + } + + return myBotDelaunay->NbVisitedNodes() == nbInternalNodes; +} + +//================================================================================ +/*! + * \brief Compute Z of nodes of a straight column + */ +//================================================================================ + +void StdMeshers_Sweeper::fillZColumn( TZColumn& zColumn, + TNodeColumn& nodes ) +{ + if ( zColumn.size() == nodes.size() - 2 ) + return; + + gp_Pnt p0 = SMESH_NodeXYZ( nodes[0] ); + gp_Vec line( p0, SMESH_NodeXYZ( nodes.back() )); + double len2 = line.SquareMagnitude(); + + zColumn.resize( nodes.size() - 2 ); + for ( size_t i = 0; i < zColumn.size(); ++i ) + { + gp_Vec vec( p0, SMESH_NodeXYZ( nodes[ i+1] )); + zColumn[i] = ( line * vec ) / len2; // param [0,1] on the line + } +} + +//================================================================================ +/*! + * \brief Initialize *Delaunay members + */ +//================================================================================ + +void StdMeshers_Sweeper::prepareTopBotDelaunay() +{ + SMESH_MesherHelper* helper[2] = { myHelper, myHelper }; + SMESH_MesherHelper botHelper( *myHelper->GetMesh() ); + SMESH_MesherHelper topHelper( *myHelper->GetMesh() ); + const SMDS_MeshNode* intBotNode = 0; + const SMDS_MeshNode* intTopNode = 0; + if ( myHelper->HasSeam() || myHelper->HasDegeneratedEdges() ) // use individual helpers + { + botHelper.SetSubShape( myBotFace ); + topHelper.SetSubShape( myTopFace ); + helper[0] = & botHelper; + helper[1] = & topHelper; + if ( !myIntColumns.empty() ) + { + TNodeColumn& nodes = *myIntColumns[ myIntColumns.size()/2 ]; + intBotNode = nodes[0]; + intTopNode = nodes.back(); + } + } + + UVPtStructVec botUV( myBndColumns.size() ); + UVPtStructVec topUV( myBndColumns.size() ); + for ( size_t i = 0; i < myBndColumns.size(); ++i ) + { + TNodeColumn& nodes = *myBndColumns[i]; + botUV[i].node = nodes[0]; + botUV[i].SetUV( helper[0]->GetNodeUV( myBotFace, nodes[0], intBotNode )); + topUV[i].node = nodes.back(); + topUV[i].SetUV( helper[1]->GetNodeUV( myTopFace, nodes.back(), intTopNode )); + botUV[i].node->setIsMarked( true ); + } + TopoDS_Edge dummyE; + SMESH_Mesh* mesh = myHelper->GetMesh(); + TSideVector botWires( 1, StdMeshers_FaceSide::New( botUV, myBotFace, dummyE, mesh )); + TSideVector topWires( 1, StdMeshers_FaceSide::New( topUV, myTopFace, dummyE, mesh )); + + // Delaunay mesh on the FACEs. + bool checkUV = false; + myBotDelaunay.reset( new NSProjUtils::Delaunay( botWires, checkUV )); + myTopDelaunay.reset( new NSProjUtils::Delaunay( topWires, checkUV )); + + if ( myHelper->GetIsQuadratic() ) + { + // mark all medium nodes of faces on botFace to avoid their treating + SMESHDS_SubMesh* smDS = myHelper->GetMeshDS()->MeshElements( myBotFace ); + SMDS_ElemIteratorPtr eIt = smDS->GetElements(); + while ( eIt->more() ) + { + const SMDS_MeshElement* e = eIt->next(); + for ( int i = e->NbCornerNodes(), nb = e->NbNodes(); i < nb; ++i ) + e->GetNode( i )->setIsMarked( true ); + } + } + + // map to get a node column by a bottom node + myNodeID2ColID.Clear(/*doReleaseMemory=*/false); + myNodeID2ColID.ReSize( myIntColumns.size() ); + + // un-mark nodes to treat (internal bottom nodes) to be returned by myBotDelaunay + for ( size_t i = 0; i < myIntColumns.size(); ++i ) + { + const SMDS_MeshNode* botNode = myIntColumns[i]->front(); + botNode->setIsMarked( false ); + myNodeID2ColID.Bind( botNode->GetID(), i ); + } +} + +//================================================================================ +/*! + * \brief For each internal node column, find Delaunay triangles including it + * and Barycentric Coordinates within the triangles. Fill in myTopBotTriangles + */ +//================================================================================ + +bool StdMeshers_Sweeper::findDelaunayTriangles() +{ + const SMDS_MeshNode *botNode, *topNode; + const BRepMesh_Triangle *topTria; + TopBotTriangles tbTrias; + bool checkUV = true; + + int nbInternalNodes = myIntColumns.size(); + myTopBotTriangles.resize( nbInternalNodes ); + + myBotDelaunay->InitTraversal( nbInternalNodes ); + + while (( botNode = myBotDelaunay->NextNode( tbTrias.myBotBC, tbTrias.myBotTriaNodes ))) + { + int colID = myNodeID2ColID( botNode->GetID() ); + TNodeColumn* column = myIntColumns[ colID ]; + + // find a Delaunay triangle containing the topNode + topNode = column->back(); + gp_XY topUV = myHelper->GetNodeUV( myTopFace, topNode, NULL, &checkUV ); + // get a starting triangle basing on that top and bot boundary nodes have same index + topTria = myTopDelaunay->GetTriangleNear( tbTrias.myBotTriaNodes[0] ); + topTria = myTopDelaunay->FindTriangle( topUV, topTria, + tbTrias.myTopBC, tbTrias.myTopTriaNodes ); + if ( !topTria ) + tbTrias.SetTopByBottom(); + + myTopBotTriangles[ colID ] = tbTrias; + } + + if ( myBotDelaunay->NbVisitedNodes() < nbInternalNodes ) + { + myTopBotTriangles.clear(); + return false; + } + + myBotDelaunay.reset(); + myTopDelaunay.reset(); + myNodeID2ColID.Clear(); + + return true; +} + +//================================================================================ +/*! + * \brief Initialize fields + */ +//================================================================================ + +StdMeshers_Sweeper::TopBotTriangles::TopBotTriangles() +{ + myBotBC[0] = myBotBC[1] = myBotBC[2] = myTopBC[0] = myTopBC[1] = myTopBC[2] = 0.; + myBotTriaNodes[0] = myBotTriaNodes[1] = myBotTriaNodes[2] = 0; + myTopTriaNodes[0] = myTopTriaNodes[1] = myTopTriaNodes[2] = 0; +} + +//================================================================================ +/*! + * \brief Set top data equal to bottom data + */ +//================================================================================ + +void StdMeshers_Sweeper::TopBotTriangles::SetTopByBottom() +{ + for ( int i = 0; i < 3; ++i ) + { + myTopBC[i] = myBotBC[i]; + myTopTriaNodes[i] = myBotTriaNodes[0]; + } +}