-// Copyright (C) 2007-2016 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
#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"
#include <Geom2d_Line.hxx>
#include <GeomLib_IsPlanarSurface.hxx>
#include <Geom_Curve.hxx>
+#include <Standard_ErrorHandler.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
*/
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();
{
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;
}
};
{
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()
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;
// 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<gp_XYZ>& p)
{
#ifdef _DEBUG_
//=======================================================================
//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
//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
}
//================================================================================
//=======================================================================
//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;
{
SMESH_MesherHelper helper( theMesh );
myHelper = &helper;
+ myPrevBottomSM = 0;
int nbSolids = helper.Count( theShape, TopAbs_SOLID, /*skipSame=*/false );
if ( nbSolids < 1 )
// 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() )
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 );
list< TopoDS_Edge >::iterator edge = thePrism.myBottomEdges.begin();
std::list< int >::iterator nbE = thePrism.myNbEdgesInWires.begin();
std::list< int > nbQuadsPerWire;
- int iE = 0;
+ int iE = 0, iWire = 0;
while ( edge != thePrism.myBottomEdges.end() )
{
++iE;
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;
}
}
if ( iE == *nbE )
{
iE = 0;
+ ++iWire;
++nbE;
int nbQuadPrev = std::accumulate( nbQuadsPerWire.begin(), nbQuadsPerWire.end(), 0 );
nbQuadsPerWire.push_back( thePrism.myWallQuads.size() - nbQuadPrev );
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 base face #")
- << shapeID( thePrism.myBottom ));
+ if ( !computeBase( thePrism ))
+ return false;
// Make all side FACEs of thePrism meshed with quads
if ( !computeWalls( 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
// 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<TParam2ColumnMap*>
( 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;
// 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() )
{
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
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 ];
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 )
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() ) {
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 )
{
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
for ( size_t iN = 1; iN < srcNodeStr.size(); ++iN ) // add segments
{
// find an EDGE to set a new segment
- std::pair<int, TopAbs_ShapeEnum> id2type =
+ std::pair<int, TopAbs_ShapeEnum> id2type =
myHelper->GetMediumPos( newNodes[ iN-1 ], newNodes[ iN ] );
if ( id2type.second != TopAbs_EDGE )
{
{
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 );
}
}
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);
if ( myHelper->GetIsQuadratic() )
{
// fill myHelper with medium nodes built by quadAlgo
- SMDS_ElemIteratorPtr fIt = fSM->GetSubMeshDS()->GetElements();
- while ( fIt->more() )
- myHelper->AddTLinks( dynamic_cast<const SMDS_MeshFace*>( fIt->next() ));
+ for ( SMDS_ElemIteratorPtr fIt = fSM->GetSubMeshDS()->GetElements(); fIt->more(); )
+ myHelper->AddTLinks( SMDS_Mesh::DownCast<SMDS_MeshFace>( fIt->next() ));
}
}
}
}
//=======================================================================
-/*!
- * \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 )
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,
std::vector<int> aVec = (*anIt).second;
nb2d += Max(aVec[SMDSEntity_Quadrangle],aVec[SMDSEntity_Quad_Quadrangle]);
}
-
+
MapShapeNbElemsItr anIt = aResMap.find( meshFaces[NumBase-1] );
std::vector<int> aVec = (*anIt).second;
bool IsQuadratic = (aVec[SMDSEntity_Quad_Triangle]>aVec[SMDSEntity_Triangle]) ||
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;
}
{
return true;
}
- NSProjUtils::TNodeNodeMap& n2nMap =
+ NSProjUtils::TNodeNodeMap& n2nMap =
(NSProjUtils::TNodeNodeMap&) TProjction2dAlgo::instance( this )->GetNodesMap();
n2nMap.clear();
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 );
// 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() );
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 )
//=======================================================================
//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.myBottomEdges.size() != 4 )
+ if ( thePrism.myNbEdgesInWires.front() != 4 )
return false;
// analyse angles between edges
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)
{
struct EdgeWithNeighbors
{
- TopoDS_Edge _edge;
- int _iBase; /* index in a WIRE with non-base EDGEs excluded */
- int _iL, _iR; /* used to connect edges in a base FACE */
- bool _isBase; /* is used in a base FACE */
- EdgeWithNeighbors(const TopoDS_Edge& E, int iE, int nbE, int shift, bool isBase ):
- _edge( E ), _iBase( iE + shift ),
- _iL( SMESH_MesherHelper::WrapIndex( iE-1, Max( 1, nbE )) + shift ),
- _iR( SMESH_MesherHelper::WrapIndex( iE+1, Max( 1, nbE )) + shift ),
+ 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 ),
+ _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
+ // PrismSide contains all FACEs linking a bottom EDGE with a top one.
+ struct PrismSide
{
TopoDS_Face _face; // a currently treated upper FACE
TopTools_IndexedMapOfShape *_faces; // all FACEs (pointer because of a private copy constructor)
PrismSide *_leftSide; // neighbor sides
PrismSide *_rightSide;
bool _isInternal; // whether this side raises from an INTERNAL EDGE
- void SetExcluded() { _leftSide = _rightSide = NULL; }
- bool IsExcluded() const { return !_leftSide; }
+ //void SetExcluded() { _leftSide = _rightSide = NULL; }
+ //bool IsExcluded() const { return !_leftSide; }
const TopoDS_Edge& Edge( int i ) const
{
return (*_edges)[ i ]._edge;
if ( E.IsSame( Edge( i ))) return i;
return -1;
}
- bool IsSideFace( const TopoDS_Shape& face, const bool checkNeighbors ) const
+ const TopoDS_Vertex& Vertex( int iE, int iEnd ) const
{
- if ( _faces->Contains( face )) // avoid returning true for a prism top FACE
- return ( !_face.IsNull() || !( face.IsSame( _faces->FindKey( _faces->Extent() ))));
-
+ 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
+ {
+ 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 ( face, false )) ||
- ( _rightSide && _rightSide->IsSideFace( face, false )));
+ 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 TopoDS_Edge& edge,
- TopTools_IndexedDataMapOfShapeListOfShape& facesOfEdge)
+ const TopTools_ListOfShape& faces)
{
- TopTools_ListIteratorOfListOfShape faceIt( facesOfEdge.FindFromKey( edge ));
+ 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,
TopTools_IndexedDataMapOfShapeListOfShape& facesOfEdge,
if ( nbW > 1 && noHolesAllowed )
return false;
- int iE, nbTot = 0, nbBase, iBase;
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 )
+ for ( int iE = 0; iE < *nbE; ++e, ++iE )
if ( SMESH_Algo::isDegenerated( *e )) // degenerated EDGE is never used
{
e = --ee.erase( e );
--iE;
}
+ int iE, nbTot = 0, iBase, nbBase, nbTotBase = 0;
vector<int> isBase;
edges.clear();
e = ee.begin();
}
for ( iBase = 0, iE = 0; iE < *nbE; ++e, ++iE )
{
- edges.push_back( EdgeWithNeighbors( *e, iBase, nbBase, nbTot, isBase[ iE ] ));
+ edges.push_back( EdgeWithNeighbors( *e,
+ iBase, nbBase, nbTotBase,
+ iE, *nbE, nbTot,
+ isBase[ iE ], nbW > 1 ));
iBase += isBase[ iE ];
}
- nbTot += nbBase;
+ nbTot += *nbE;
+ nbTotBase += nbBase;
}
- if ( nbTot == 0 )
+ if ( nbTotBase == 0 )
return false;
- // IPAL53099. Set correct neighbors to INTERNAL EDGEs, which can be connected to
- // EDGEs of the outer WIRE but this fact can't be detected by their order.
+ // 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;
- TopoDS_Vertex vv[2] = { SMESH_MesherHelper::IthVertex( 0, edges[ iFirst ]._edge ),
- SMESH_MesherHelper::IthVertex( 1, edges[ iLast ]._edge ) };
- bool isConnectOk = ( vv[0].IsSame( vv[1] ));
+ bool isConnectOk = ( edges[ iFirst ].IsConnected( edges, 0 ) &&
+ edges[ iFirst ].IsConnected( edges, 1 ));
if ( !isConnectOk )
{
- edges[ iFirst ]._iL = edges[ iFirst ]._iBase; // connect to self
- edges[ iLast ]._iR = edges[ iLast ]._iBase;
-
- // look for an EDGE of the outer WIREs connected to vv
- TopoDS_Vertex v0, v1;
- for ( iE = 0; iE < iFirst; ++iE )
+ for ( iE = iFirst; iE <= iLast; ++iE )
{
- v0 = SMESH_MesherHelper::IthVertex( 0, edges[ iE ]._edge );
- v1 = SMESH_MesherHelper::IthVertex( 1, edges[ iE ]._edge );
- if ( vv[0].IsSame( v0 ) || vv[0].IsSame( v1 ))
- edges[ iFirst ]._iL = edges[ iE ]._iBase;
- if ( vv[1].IsSame( v0 ) || vv[1].IsSame( v1 ))
- edges[ iLast ]._iR = edges[ iE ]._iBase;
+ 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 number of faces sharing given edges
}
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 ];
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, side._isInternal )) ||
- ( adjSide == &side && neighborF.IsSame( side._face )) );
+ 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;
const int nbE = side._edges->size();
if ( nbE >= 4 )
{
- isAdvanced = true;
+ hasAdvanced = true;
++nbFoundSideFaces;
side._iBotEdge = side.FindEdge( side._topEdge );
side._isCheckedEdge.clear();
cerr << "BUG: infinite loop in StdMeshers_Prism_3D::IsApplicable()" << endl;
#endif
}
- } // while isAdvanced
+ } // while hasAdvanced
if ( isOK && sides[0]._faces->Extent() > 1 )
{
}
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
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();
"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"));
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
if ( !myHelper->LoadNodeColumns( faceColumns, (*quad)->face, quadBot, meshDS ))
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");
}
+ 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
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
}
}
}
//================================================================================
/*!
- * \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
*/
//================================================================================
<< n << ", " << n+1 << ", "
<< n+nb+2 << ", " << n+nb+1 << "]) " << endl;
}
-
+
#endif
}
//================================================================================
/*!
* \brief Return geometry of the top or bottom curve
- * \param isTop -
- * \retval Adaptor3d_Curve* -
+ * \param isTop -
+ * \retval Adaptor3d_Curve* -
*/
//================================================================================
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 ];
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 );
// 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);
//================================================================================
/*!
- * \brief Creates TVerticalEdgeAdaptor
+ * \brief Creates TVerticalEdgeAdaptor
* \param columnsMap - node column map
* \param parameter - normalized parameter
*/
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;
//================================================================================
/*!
- * \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
}
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();
const vector< gp_XYZ >& toBndPoints,
const vector< gp_XYZ >& fromIntPoints,
vector< gp_XYZ >& toIntPoints,
+ const double r,
NSProjUtils::TrsfFinder3D& trsf,
vector< gp_XYZ > * bndError)
{
(*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() );
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 );
}
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;
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
}
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;
(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 )
{
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
{
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; // 3D_mesh_Extrusion_00/A3
- bndErrorIsSmall = true;
if ( !centerIntErrorIsSmall )
{
// Compensate the central error; continue adding projection
}
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 )
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 );
}
} // 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 )
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];
+ }
+}
