ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-11 16:19:16 +05:00
Code Issues Packages Projects Releases Wiki Activity

23462: [CEA 2142] Import12D fails

Browse Source 
Fix node classification on periodic FACEs and wrong propagation on IN node state
This commit is contained in:
eap 2017-07-26 18:33:09 +03:00
parent 4fa5fdbd44
commit 4a591503f8
3 changed files with 118 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
src/Controls/SMESH_Controls.cxx
View File

@ -4287,6 +4287,7 @@ void ElementsOnShape::SetShape (const TopoDS_Shape& theShape,
if ( shapeChanges )
{
// find most complex shapes
TopTools_IndexedMapOfShape shapesMap;
TopAbs_ShapeEnum shapeTypes[4] = { TopAbs_SOLID, TopAbs_FACE, TopAbs_EDGE, TopAbs_VERTEX };
TopExp_Explorer sub;
@ -4329,10 +4330,18 @@ void ElementsOnShape::clearClassifiers()
bool ElementsOnShape::IsSatisfy( long elemId )
{
if ( myClassifiers.empty() )
return false;
const SMDS_Mesh* mesh = myMeshModifTracer.GetMesh();
const SMDS_MeshElement* elem =
( myType == SMDSAbs_Node ? mesh->FindNode( elemId ) : mesh->FindElement( elemId ));
if ( !elem || myClassifiers.empty() )
if ( myType == SMDSAbs_Node )
return IsSatisfy( mesh->FindNode( elemId ));
return IsSatisfy( mesh->FindElement( elemId ));
}
bool ElementsOnShape::IsSatisfy (const SMDS_MeshElement* elem)
{
if ( !elem )
return false;
bool isSatisfy = myAllNodesFlag, isNodeOut;
@ -4396,6 +4405,60 @@ bool ElementsOnShape::IsSatisfy( long elemId )
return isSatisfy;
}
bool ElementsOnShape::IsSatisfy (const SMDS_MeshNode* node,
TopoDS_Shape* okShape)
{
if ( !node )
return false;
if ( !myOctree && myClassifiers.size() > 5 )
{
myWorkClassifiers.resize( myClassifiers.size() );
for ( size_t i = 0; i < myClassifiers.size(); ++i )
myWorkClassifiers[ i ] = & myClassifiers[ i ];
myOctree = new OctreeClassifier( myWorkClassifiers );
}
bool isNodeOut = true;
if ( okShape || !getNodeIsOut( node, isNodeOut ))
{
SMESH_NodeXYZ aPnt = node;
if ( myOctree )
{
myWorkClassifiers.clear();
myOctree->GetClassifiersAtPoint( aPnt, myWorkClassifiers );
for ( size_t i = 0; i < myWorkClassifiers.size(); ++i )
myWorkClassifiers[i]->SetChecked( false );
for ( size_t i = 0; i < myWorkClassifiers.size(); ++i )
if ( !myWorkClassifiers[i]->IsChecked() &&
!myWorkClassifiers[i]->IsOut( aPnt ))
{
isNodeOut = false;
if ( okShape )
*okShape = myWorkClassifiers[i]->Shape();
break;
}
}
else
{
for ( size_t i = 0; i < myClassifiers.size(); ++i )
if ( !myClassifiers[i].IsOut( aPnt ))
{
isNodeOut = false;
if ( okShape )
*okShape = myWorkClassifiers[i]->Shape();
break;
}
}
setNodeIsOut( node, isNodeOut );
}
return !isNodeOut;
}
void ElementsOnShape::Classifier::Init( const TopoDS_Shape& theShape,
double theTol,
const Bnd_B3d* theBox )

2
src/Controls/SMESH_ControlsDef.hxx
View File

@ -902,6 +902,8 @@ namespace SMESH{
bool GetAllNodes() const { return myAllNodesFlag; }
void SetShape (const TopoDS_Shape& theShape,
const SMDSAbs_ElementType theType);
bool IsSatisfy (const SMDS_MeshElement* elem);
bool IsSatisfy (const SMDS_MeshNode* node, TopoDS_Shape* okShape=0);
private:

60
src/StdMeshers/StdMeshers_Import_1D2D.cxx
View File

@ -34,6 +34,7 @@
#include "SMESHDS_Group.hxx"
#include "SMESHDS_Mesh.hxx"
#include "SMESH_Comment.hxx"
#include "SMESH_ControlsDef.hxx"
#include "SMESH_Gen.hxx"
#include "SMESH_Group.hxx"
#include "SMESH_Mesh.hxx"
@ -269,12 +270,25 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape &
map<TLink, int>::iterator link2Nb;
double minGroupTol = Precision::Infinite();
SMESH::Controls::ElementsOnShape onEdgeClassifier;
if ( helper.HasSeam() )
{
TopoDS_Compound edgesCompound;
BRep_Builder builder;
builder.MakeCompound( edgesCompound );
for ( size_t iE = 0; iE < edges.size(); ++iE )
builder.Add( edgesCompound, edges[ iE ]);
onEdgeClassifier.SetShape( edgesCompound, SMDSAbs_Node );
}
// =========================
// Import faces from groups
// =========================
StdMeshers_Import_1D::TNodeNodeMap* n2n;
StdMeshers_Import_1D::TElemElemMap* e2e;
StdMeshers_Import_1D::TNodeNodeMap::iterator n2nIt;
pair< StdMeshers_Import_1D::TNodeNodeMap::iterator, bool > it_isnew;
vector<TopAbs_State> nodeState;
vector<const SMDS_MeshNode*> newNodes; // of a face
set <const SMDS_MeshNode*> bndNodes; // nodes classified ON
@ -297,8 +311,8 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape &
// S.VResolution( 0.1 * groupTol ));
const double clsfTol = BRep_Tool::Tolerance( geomFace );
StdMeshers_Import_1D::TNodeNodeMap::iterator n2nIt;
pair< StdMeshers_Import_1D::TNodeNodeMap::iterator, bool > it_isnew;
if ( helper.HasSeam() )
onEdgeClassifier.SetMesh( srcMesh->GetMeshDS() );
SMDS_ElemIteratorPtr srcElems = srcGroup->GetElements();
while ( srcElems->more() ) // loop on group contents
@ -356,11 +370,21 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape &
gp_XY uv( Precision::Infinite(), 0 );
isOut = ( !helper.CheckNodeUV( geomFace, *node, uv, groupTol, /*force=*/true ) ||
bndBox2d.IsOut( uv ));
//int iCoo;
if ( !isOut && !isIn ) // classify
{
classifier.Perform( geomFace, uv, clsfTol );
nodeState[i] = classifier.State();
isOut = ( nodeState[i] == TopAbs_OUT );
if ( isOut && helper.IsOnSeam( uv ) && onEdgeClassifier.IsSatisfy( (*node)->GetID() ))
{
// uv.SetCoord( iCoo, helper.GetOtherParam( uv.Coord( iCoo )));
// classifier.Perform( geomFace, uv, clsfTol );
// nodeState[i] = classifier.State();
// isOut = ( nodeState[i] == TopAbs_OUT );
nodeState[i] = TopAbs_ON;
isOut = false;
}
}
if ( !isOut ) // create a new node
{
@ -374,13 +398,14 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape &
}
if ( nodeState[i] == TopAbs_ON )
bndNodes.insert( *node );
else
else if ( nodeState[i] != TopAbs_UNKNOWN )
isNodeIn[ newNode->GetID() ] = isIn = true;
}
}
if ( !(newNodes[i] = newNode ) || isOut )
break;
}
} // loop on face nodes
if ( !newNodes.back() )
continue; // not all nodes of the face lie on theShape
@ -491,23 +516,32 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape &
medium = newNodes[i+nbCorners];
link2Nb = linkCount.insert( make_pair( TLink( n1, n2, medium ), 0)).first;
++link2Nb->second;
// if ( link2Nb->second == 1 )
// {
// // measure link length
// double len2 = SMESH_TNodeXYZ( n1 ).SquareDistance( n2 );
// if ( len2 < minGroupTol )
// minGroupTol = len2;
// }
}
}
} // loop on group contents
// Remove OUT nodes from n2n map
for ( n2nIt = n2n->begin(); n2nIt != n2n->end(); )
if ( !n2nIt->second )
n2n->erase( n2nIt++ );
else
++n2nIt;
}
} // loop on src groups
// remove free nodes created on EDGEs
{
set<const SMDS_MeshNode*>::iterator node = bndNodes.begin();
for ( ; node != bndNodes.end(); ++node )
{
n2nIt = n2n->find( *node );
const SMDS_MeshNode* newNode = n2nIt->second;
if ( newNode && newNode->NbInverseElements() == 0 )
{
tgtMesh->RemoveFreeNode( newNode, 0, false );
n2n->erase( n2nIt );
}
}
}
// ==========================================================
// Put nodes on geom edges and create edges on them;