//
#include "SMESH_MesherHelper.hxx"
-#include "SMDS_FacePosition.hxx"
#include "SMDS_EdgePosition.hxx"
+#include "SMDS_FaceOfNodes.hxx"
+#include "SMDS_FacePosition.hxx"
+#include "SMDS_IteratorOnIterators.hxx"
#include "SMDS_VolumeTool.hxx"
-#include "SMESH_subMesh.hxx"
+#include "SMESH_Block.hxx"
#include "SMESH_ProxyMesh.hxx"
+#include "SMESH_subMesh.hxx"
+#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepTools.hxx>
-#include <BRepTools_WireExplorer.hxx>
#include <BRep_Tool.hxx>
#include <Geom2d_Curve.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
//=======================================================================
//function : SetSubShape
-//purpose : Set geomerty to make elements on
+//purpose : Set geometry to make elements on
//=======================================================================
void SMESH_MesherHelper::SetSubShape(const int aShID)
//=======================================================================
//function : SetSubShape
-//purpose : Set geomerty to create elements on
+//purpose : Set geometry to create elements on
//=======================================================================
void SMESH_MesherHelper::SetSubShape(const TopoDS_Shape& aSh)
myDegenShapeIds.insert( meshDS->ShapeToIndex( v.Current() ));
}
}
+ if ( !myDegenShapeIds.empty() && !myParIndex ) {
+ if ( surface->IsUPeriodic() || surface->IsUClosed() ) {
+ myParIndex |= U_periodic;
+ myPar1[0] = surf.FirstUParameter();
+ myPar2[0] = surf.LastUParameter();
+ }
+ else if ( surface->IsVPeriodic() || surface->IsVClosed() ) {
+ myParIndex |= V_periodic;
+ myPar1[1] = surf.FirstVParameter();
+ myPar2[1] = surf.LastVParameter();
+ }
+ }
}
}
}
TopoDS_Shape SMESH_MesherHelper::GetSubShapeByNode(const SMDS_MeshNode* node,
const SMESHDS_Mesh* meshDS)
{
- int shapeID = node->getshapeId();
+ int shapeID = node ? node->getshapeId() : 0;
if ( 0 < shapeID && shapeID <= meshDS->MaxShapeIndex() )
return meshDS->IndexToShape( shapeID );
else
{
int iN1 = iNodes[i++];
int iN12 = iNodes[i++];
- int iN2 = iNodes[i++];
+ int iN2 = iNodes[i];
if ( iN1 > iN2 ) std::swap( iN1, iN2 );
int linkID = iN1 * vTool.NbNodes() + iN2;
pair< set<int>::iterator, bool > it_isNew = addedLinks.insert( linkID );
return elem;
}
+namespace
+{
+ //================================================================================
+ /*!
+ * \brief Check if a node belongs to any face of sub-mesh
+ */
+ //================================================================================
+
+ bool isNodeInSubMesh( const SMDS_MeshNode* n, const SMESHDS_SubMesh* sm )
+ {
+ SMDS_ElemIteratorPtr fIt = n->GetInverseElementIterator( SMDSAbs_Face );
+ while ( fIt->more() )
+ if ( sm->Contains( fIt->next() ))
+ return true;
+ return false;
+ }
+}
+
+//=======================================================================
+//function : IsSameElemGeometry
+//purpose : Returns true if all elements of a sub-mesh are of same shape
+//=======================================================================
+
+bool SMESH_MesherHelper::IsSameElemGeometry(const SMESHDS_SubMesh* smDS,
+ SMDSAbs_GeometryType shape,
+ const bool nullSubMeshRes)
+{
+ if ( !smDS ) return nullSubMeshRes;
+
+ SMDS_ElemIteratorPtr elemIt = smDS->GetElements();
+ while ( elemIt->more() )
+ if ( elemIt->next()->GetGeomType() != shape )
+ return false;
+
+ return true;
+}
+
//=======================================================================
//function : LoadNodeColumns
//purpose : Load nodes bound to face into a map of node columns
SMESHDS_Mesh* theMesh,
SMESH_ProxyMesh* theProxyMesh)
{
- // get a right submesh of theFace
+ // get a right sub-mesh of theFace
const SMESHDS_SubMesh* faceSubMesh = 0;
if ( theProxyMesh )
if ( !faceSubMesh || faceSubMesh->NbElements() == 0 )
return false;
- // get data of edges for normalization of params
-
- vector< double > length;
- double fullLen = 0;
- list<TopoDS_Edge>::const_iterator edge;
+ if ( theParam2ColumnMap.empty() )
{
- for ( edge = theBaseSide.begin(); edge != theBaseSide.end(); ++edge )
- {
- double len = std::max( 1e-10, SMESH_Algo::EdgeLength( *edge ));
- fullLen += len;
- length.push_back( len );
- }
- }
-
- // get nodes on theBaseEdge sorted by param on edge and initialize theParam2ColumnMap with them
- edge = theBaseSide.begin();
- for ( int iE = 0; edge != theBaseSide.end(); ++edge, ++iE )
- {
- map< double, const SMDS_MeshNode*> sortedBaseNodes;
- SMESH_Algo::GetSortedNodesOnEdge( theMesh, *edge,/*noMedium=*/true, sortedBaseNodes);
- if ( sortedBaseNodes.empty() ) continue;
+ // get data of edges for normalization of params
- double f, l;
- BRep_Tool::Range( *edge, f, l );
- if ( edge->Orientation() == TopAbs_REVERSED ) std::swap( f, l );
- const double coeff = 1. / ( l - f ) * length[iE] / fullLen;
- const double prevPar = theParam2ColumnMap.empty() ? 0 : theParam2ColumnMap.rbegin()->first;
- map< double, const SMDS_MeshNode*>::iterator u_n = sortedBaseNodes.begin();
- for ( ; u_n != sortedBaseNodes.end(); u_n++ )
+ vector< double > length;
+ double fullLen = 0;
+ list<TopoDS_Edge>::const_iterator edge;
{
- double par = prevPar + coeff * ( u_n->first - f );
- TParam2ColumnMap::iterator u2nn =
- theParam2ColumnMap.insert( theParam2ColumnMap.end(), make_pair( par, TNodeColumn()));
- u2nn->second.push_back( u_n->second );
+ for ( edge = theBaseSide.begin(); edge != theBaseSide.end(); ++edge )
+ {
+ double len = std::max( 1e-10, SMESH_Algo::EdgeLength( *edge ));
+ fullLen += len;
+ length.push_back( len );
+ }
}
- }
- TParam2ColumnMap::iterator par_nVec_2, par_nVec_1 = theParam2ColumnMap.begin();
- if ( theProxyMesh )
- {
- for ( ; par_nVec_1 != theParam2ColumnMap.end(); ++par_nVec_1 )
+
+ // get nodes on theBaseEdge sorted by param on edge and initialize theParam2ColumnMap with them
+ edge = theBaseSide.begin();
+ for ( int iE = 0; edge != theBaseSide.end(); ++edge, ++iE )
{
- const SMDS_MeshNode* & n = par_nVec_1->second[0];
- n = theProxyMesh->GetProxyNode( n );
+ map< double, const SMDS_MeshNode*> sortedBaseNN;
+ SMESH_Algo::GetSortedNodesOnEdge( theMesh, *edge,/*noMedium=*/true, sortedBaseNN);
+ if ( sortedBaseNN.empty() ) continue;
+
+ map< double, const SMDS_MeshNode*>::iterator u_n = sortedBaseNN.begin();
+ if ( theProxyMesh ) // from sortedBaseNN remove nodes not shared by faces of faceSubMesh
+ {
+ const SMDS_MeshNode* n1 = sortedBaseNN.begin()->second;
+ const SMDS_MeshNode* n2 = sortedBaseNN.rbegin()->second;
+ bool allNodesAreProxy = ( n1 != theProxyMesh->GetProxyNode( n1 ) &&
+ n2 != theProxyMesh->GetProxyNode( n2 ));
+ if ( allNodesAreProxy )
+ for ( u_n = sortedBaseNN.begin(); u_n != sortedBaseNN.end(); u_n++ )
+ u_n->second = theProxyMesh->GetProxyNode( u_n->second );
+
+ if ( u_n = sortedBaseNN.begin(), !isNodeInSubMesh( u_n->second, faceSubMesh ))
+ {
+ while ( ++u_n != sortedBaseNN.end() && !isNodeInSubMesh( u_n->second, faceSubMesh ));
+ sortedBaseNN.erase( sortedBaseNN.begin(), u_n );
+ }
+ else if ( u_n = --sortedBaseNN.end(), !isNodeInSubMesh( u_n->second, faceSubMesh ))
+ {
+ while ( u_n != sortedBaseNN.begin() && !isNodeInSubMesh( (--u_n)->second, faceSubMesh ));
+ sortedBaseNN.erase( ++u_n, sortedBaseNN.end() );
+ }
+ if ( sortedBaseNN.empty() ) continue;
+ }
+
+ double f, l;
+ BRep_Tool::Range( *edge, f, l );
+ if ( edge->Orientation() == TopAbs_REVERSED ) std::swap( f, l );
+ const double coeff = 1. / ( l - f ) * length[iE] / fullLen;
+ const double prevPar = theParam2ColumnMap.empty() ? 0 : theParam2ColumnMap.rbegin()->first;
+ for ( u_n = sortedBaseNN.begin(); u_n != sortedBaseNN.end(); u_n++ )
+ {
+ double par = prevPar + coeff * ( u_n->first - f );
+ TParam2ColumnMap::iterator u2nn =
+ theParam2ColumnMap.insert( theParam2ColumnMap.end(), make_pair( par, TNodeColumn()));
+ u2nn->second.push_back( u_n->second );
+ }
}
+ if ( theParam2ColumnMap.empty() )
+ return false;
}
- int nbRows = 1 + faceSubMesh->NbElements() / ( theParam2ColumnMap.size()-1 );
+ // nb rows of nodes
+ int prevNbRows = theParam2ColumnMap.begin()->second.size(); // current, at least 1 here
+ int expectedNbRows = faceSubMesh->NbElements() / ( theParam2ColumnMap.size()-1 ); // to be added
// fill theParam2ColumnMap column by column by passing from nodes on
// theBaseEdge up via mesh faces on theFace
+ TParam2ColumnMap::iterator par_nVec_1, par_nVec_2;
par_nVec_2 = theParam2ColumnMap.begin();
par_nVec_1 = par_nVec_2++;
TIDSortedElemSet emptySet, avoidSet;
{
vector<const SMDS_MeshNode*>& nCol1 = par_nVec_1->second;
vector<const SMDS_MeshNode*>& nCol2 = par_nVec_2->second;
- nCol1.resize( nbRows );
- nCol2.resize( nbRows );
+ nCol1.resize( prevNbRows + expectedNbRows );
+ nCol2.resize( prevNbRows + expectedNbRows );
- int i1, i2, iRow = 0;
- const SMDS_MeshNode *n1 = nCol1[0], *n2 = nCol2[0];
+ int i1, i2, foundNbRows = 0;
+ const SMDS_MeshNode *n1 = nCol1[ prevNbRows-1 ];
+ const SMDS_MeshNode *n2 = nCol2[ prevNbRows-1 ];
// find face sharing node n1 and n2 and belonging to faceSubMesh
while ( const SMDS_MeshElement* face =
SMESH_MeshEditor::FindFaceInSet( n1, n2, emptySet, avoidSet, &i1, &i2))
{
if ( faceSubMesh->Contains( face ))
{
- int nbNodes = face->IsQuadratic() ? face->NbNodes()/2 : face->NbNodes();
+ int nbNodes = face->NbCornerNodes();
if ( nbNodes != 4 )
return false;
+ if ( foundNbRows + 1 > expectedNbRows )
+ return false;
n1 = face->GetNode( (i2+2) % 4 ); // opposite corner of quadrangle face
n2 = face->GetNode( (i1+2) % 4 );
- if ( ++iRow >= nbRows )
- return false;
- nCol1[ iRow ] = n1;
- nCol2[ iRow ] = n2;
- avoidSet.clear();
+ nCol1[ prevNbRows + foundNbRows] = n1;
+ nCol2[ prevNbRows + foundNbRows] = n2;
+ ++foundNbRows;
}
avoidSet.insert( face );
}
- // set a real height
- nCol1.resize( iRow + 1 );
- nCol2.resize( iRow + 1 );
+ if ( foundNbRows != expectedNbRows )
+ return false;
+ avoidSet.clear();
+ }
+ return ( theParam2ColumnMap.size() > 1 &&
+ theParam2ColumnMap.begin()->second.size() == prevNbRows + expectedNbRows );
+}
+
+namespace
+{
+ //================================================================================
+ /*!
+ * \brief Return true if a node is at a corner of a 2D structured mesh of FACE
+ */
+ //================================================================================
+
+ bool isCornerOfStructure( const SMDS_MeshNode* n,
+ const SMESHDS_SubMesh* faceSM )
+ {
+ int nbFacesInSM = 0;
+ if ( n ) {
+ SMDS_ElemIteratorPtr fIt = n->GetInverseElementIterator( SMDSAbs_Face );
+ while ( fIt->more() )
+ nbFacesInSM += faceSM->Contains( fIt->next() );
+ }
+ return ( nbFacesInSM == 1 );
+ }
+}
+
+//=======================================================================
+//function : IsStructured
+//purpose : Return true if 2D mesh on FACE is structured
+//=======================================================================
+
+bool SMESH_MesherHelper::IsStructured( SMESH_subMesh* faceSM )
+{
+ SMESHDS_SubMesh* fSM = faceSM->GetSubMeshDS();
+ if ( !fSM || fSM->NbElements() == 0 )
+ return false;
+
+ list< TopoDS_Edge > edges;
+ list< int > nbEdgesInWires;
+ int nbWires = SMESH_Block::GetOrderedEdges( TopoDS::Face( faceSM->GetSubShape() ),
+ edges, nbEdgesInWires );
+ if ( nbWires != 1 )
+ return false;
+
+ // algo: find corners of a structure and then analyze nb of faces and
+ // length of structure sides
+
+ SMESHDS_Mesh* meshDS = faceSM->GetFather()->GetMeshDS();
+
+ // rotate edges to get the first node being at corner
+ // (in principle it's not necessary but so far none SALOME algo can make
+ // such a structured mesh that all corner nodes are not on VERTEXes)
+ bool isCorner = false;
+ int nbRemainEdges = nbEdgesInWires.front();
+ do {
+ TopoDS_Vertex V = IthVertex( 0, edges.front() );
+ isCorner = isCornerOfStructure( SMESH_Algo::VertexNode( V, meshDS ), fSM);
+ if ( !isCorner ) {
+ edges.splice( edges.end(), edges, edges.begin() );
+ --nbRemainEdges;
+ }
+ }
+ while ( !isCorner && nbRemainEdges > 0 );
+
+ if ( !isCorner )
+ return false;
+
+ // get all nodes from EDGEs
+ list< const SMDS_MeshNode* > nodes;
+ list< TopoDS_Edge >::iterator edge = edges.begin();
+ for ( ; edge != edges.end(); ++edge )
+ {
+ map< double, const SMDS_MeshNode* > u2Nodes;
+ if ( !SMESH_Algo::GetSortedNodesOnEdge( meshDS, *edge,
+ /*skipMedium=*/true, u2Nodes ))
+ return false;
+
+ list< const SMDS_MeshNode* > edgeNodes;
+ map< double, const SMDS_MeshNode* >::iterator u2n = u2Nodes.begin();
+ if ( !nodes.empty() && nodes.back() == u2n->second )
+ ++u2n;
+ map< double, const SMDS_MeshNode* >::iterator u2nEnd = --u2Nodes.end();
+ if ( nodes.empty() || nodes.back() != u2nEnd->second )
+ ++u2nEnd;
+ for ( ; u2n != u2nEnd; ++u2n )
+ edgeNodes.push_back( u2n->second );
+
+ if ( edge->Orientation() == TopAbs_REVERSED )
+ edgeNodes.reverse();
+ nodes.splice( nodes.end(), edgeNodes, edgeNodes.begin(), edgeNodes.end() );
+ }
+
+ // get length of structured sides
+ vector<int> nbEdgesInSide;
+ int nbEdges = 0;
+ list< const SMDS_MeshNode* >::iterator n = ++nodes.begin();
+ for ( ; n != nodes.end(); ++n )
+ {
+ ++nbEdges;
+ if ( isCornerOfStructure( *n, fSM )) {
+ nbEdgesInSide.push_back( nbEdges );
+ nbEdges = 0;
+ }
+ }
+
+ // checks
+ if ( nbEdgesInSide.size() != 4 )
+ return false;
+ if ( nbEdgesInSide[0] != nbEdgesInSide[2] )
+ return false;
+ if ( nbEdgesInSide[1] != nbEdgesInSide[3] )
+ return false;
+ if ( nbEdgesInSide[0] * nbEdgesInSide[1] != fSM->NbElements() )
+ return false;
+
+ return true;
+}
+
+//================================================================================
+/*!
+ * \brief Find out elements orientation on a geometrical face
+ * \param theFace - The face correctly oriented in the shape being meshed
+ * \retval bool - true if the face normal and the normal of first element
+ * in the correspoding submesh point in different directions
+ */
+//================================================================================
+
+bool SMESH_MesherHelper::IsReversedSubMesh (const TopoDS_Face& theFace)
+{
+ if ( theFace.IsNull() )
+ return false;
+
+ // find out orientation of a meshed face
+ int faceID = GetMeshDS()->ShapeToIndex( theFace );
+ TopoDS_Shape aMeshedFace = GetMeshDS()->IndexToShape( faceID );
+ bool isReversed = ( theFace.Orientation() != aMeshedFace.Orientation() );
+
+ const SMESHDS_SubMesh * aSubMeshDSFace = GetMeshDS()->MeshElements( faceID );
+ if ( !aSubMeshDSFace )
+ return isReversed;
+
+ // find an element with a good normal
+ gp_Vec Ne;
+ bool normalOK = false;
+ gp_XY uv;
+ SMDS_ElemIteratorPtr iteratorElem = aSubMeshDSFace->GetElements();
+ while ( !normalOK && iteratorElem->more() ) // loop on elements on theFace
+ {
+ const SMDS_MeshElement* elem = iteratorElem->next();
+ if ( elem && elem->NbCornerNodes() > 2 )
+ {
+ SMESH_TNodeXYZ nPnt[3];
+ SMDS_ElemIteratorPtr nodesIt = elem->nodesIterator();
+ for ( int iN = 0; nodesIt->more() && iN < 3; ++iN) // loop on nodes
+ nPnt[ iN ] = nodesIt->next();
+
+ // compute normal
+ gp_Vec v01( nPnt[0], nPnt[1] ), v02( nPnt[0], nPnt[2] );
+ if ( v01.SquareMagnitude() > RealSmall() &&
+ v02.SquareMagnitude() > RealSmall() )
+ {
+ Ne = v01 ^ v02;
+ if (( normalOK = ( Ne.SquareMagnitude() > RealSmall() )))
+ uv = GetNodeUV( theFace, nPnt[0]._node, nPnt[2]._node, &normalOK );
+ }
+ }
+ }
+ if ( !normalOK )
+ return isReversed;
+
+ // face normal at node position
+ TopLoc_Location loc;
+ Handle(Geom_Surface) surf = BRep_Tool::Surface( theFace, loc );
+ // if ( surf.IsNull() || surf->Continuity() < GeomAbs_C1 )
+ // some surfaces not detected as GeomAbs_C1 are nevertheless correct for meshing
+ if ( surf.IsNull() || surf->Continuity() < GeomAbs_C0 )
+ {
+ if (!surf.IsNull())
+ MESSAGE("surf->Continuity() < GeomAbs_C1 " << (surf->Continuity() < GeomAbs_C1));
+ return isReversed;
+ }
+ gp_Vec d1u, d1v; gp_Pnt p;
+ surf->D1( uv.X(), uv.Y(), p, d1u, d1v );
+ gp_Vec Nf = (d1u ^ d1v).Transformed( loc );
+
+ if ( theFace.Orientation() == TopAbs_REVERSED )
+ Nf.Reverse();
+
+ return Ne * Nf < 0.;
+}
+
+//=======================================================================
+//function : Count
+//purpose : Count nb of sub-shapes
+//=======================================================================
+
+int SMESH_MesherHelper::Count(const TopoDS_Shape& shape,
+ const TopAbs_ShapeEnum type,
+ const bool ignoreSame)
+{
+ if ( ignoreSame ) {
+ TopTools_IndexedMapOfShape map;
+ TopExp::MapShapes( shape, type, map );
+ return map.Extent();
+ }
+ else {
+ int nb = 0;
+ for ( TopExp_Explorer exp( shape, type ); exp.More(); exp.Next() )
+ ++nb;
+ return nb;
}
- return theParam2ColumnMap.size() > 1 && theParam2ColumnMap.begin()->second.size() > 1;
}
//=======================================================================
return ( vIt.More() ? TopoDS::Vertex(vIt.Value()) : TopoDS_Vertex() );
}
+//================================================================================
+/*!
+ * \brief Return type of shape contained in a group
+ * \param group - a shape of type TopAbs_COMPOUND
+ * \param avoidCompound - not to return TopAbs_COMPOUND
+ */
+//================================================================================
+
+TopAbs_ShapeEnum SMESH_MesherHelper::GetGroupType(const TopoDS_Shape& group,
+ const bool avoidCompound)
+{
+ if ( !group.IsNull() )
+ {
+ if ( group.ShapeType() != TopAbs_COMPOUND )
+ return group.ShapeType();
+
+ // iterate on a compound
+ TopoDS_Iterator it( group );
+ if ( it.More() )
+ return avoidCompound ? GetGroupType( it.Value() ) : it.Value().ShapeType();
+ }
+ return TopAbs_SHAPE;
+}
+
//=======================================================================
//function : IsQuadraticMesh
//purpose : Check mesh without geometry for: if all elements on this shape are quadratic,
int NbFacesAndEdges=0;
//All faces and edges
NbAllEdgsAndFaces = myMesh->NbEdges() + myMesh->NbFaces();
+ if ( NbAllEdgsAndFaces == 0 )
+ return SMESH_MesherHelper::LINEAR;
//Quadratic faces and edges
NbQuadFacesAndEdgs = myMesh->NbEdges(ORDER_QUADRATIC) + myMesh->NbFaces(ORDER_QUADRATIC);
return _OK;
}
+
+ //================================================================================
+ /*!
+ * \brief Place medium nodes at the link middle for elements whose corner nodes
+ * are out of geometrical boundary to prevent distorting elements.
+ * Issue 0020982, note 0013990
+ */
+ //================================================================================
+
+ void force3DOutOfBoundary( SMESH_MesherHelper& theHelper,
+ SMESH_ComputeErrorPtr& theError)
+ {
+ SMESHDS_Mesh* meshDS = theHelper.GetMeshDS();
+ TopoDS_Shape shape = theHelper.GetSubShape().Oriented( TopAbs_FORWARD );
+ if ( shape.IsNull() ) return;
+
+ if ( !theError ) theError = SMESH_ComputeError::New();
+
+ gp_XYZ faceNorm;
+
+ if ( shape.ShapeType() == TopAbs_FACE ) // 2D
+ {
+ if ( theHelper.GetMesh()->NbTriangles( ORDER_QUADRATIC ) < 1 ) return;
+
+ SMESHDS_SubMesh* faceSM = meshDS->MeshElements( shape );
+ if ( !faceSM ) return;
+
+ const TopoDS_Face& face = TopoDS::Face( shape );
+ Handle(Geom_Surface) surface = BRep_Tool::Surface( face );
+
+ TopExp_Explorer edgeIt( face, TopAbs_EDGE );
+ for ( ; edgeIt.More(); edgeIt.Next() ) // loop on EDGEs of a FACE
+ {
+ // check if the EDGE needs checking
+ const TopoDS_Edge& edge = TopoDS::Edge( edgeIt.Current() );
+ if ( BRep_Tool::Degenerated( edge ) )
+ continue;
+ if ( theHelper.IsRealSeam( edge ) &&
+ edge.Orientation() == TopAbs_REVERSED )
+ continue;
+
+ SMESHDS_SubMesh* edgeSM = meshDS->MeshElements( edge );
+ if ( !edgeSM ) continue;
+
+ double f,l;
+ Handle(Geom2d_Curve) pcurve = BRep_Tool::CurveOnSurface( edge, face, f, l );
+ BRepAdaptor_Curve curve3D( edge );
+ switch ( curve3D.GetType() ) {
+ case GeomAbs_Line: continue;
+ case GeomAbs_Circle:
+ case GeomAbs_Ellipse:
+ case GeomAbs_Hyperbola:
+ case GeomAbs_Parabola:
+ try
+ {
+ gp_Vec D1, D2, Du1, Dv1; gp_Pnt p;
+ curve3D.D2( 0.5 * ( f + l ), p, D1, D2 );
+ gp_Pnt2d uv = pcurve->Value( 0.5 * ( f + l ) );
+ surface->D1( uv.X(), uv.Y(), p, Du1, Dv1 );
+ gp_Vec fNorm = Du1 ^ Dv1;
+ if ( fNorm.IsParallel( D2, M_PI * 25./180. ))
+ continue; // face is normal to the curve3D
+
+ gp_Vec curvNorm = fNorm ^ D1;
+ if ( edge.Orientation() == TopAbs_REVERSED ) curvNorm.Reverse();
+ if ( curvNorm * D2 > 0 )
+ continue; // convex edge
+ }
+ catch ( Standard_Failure )
+ {
+ continue;
+ }
+ }
+ // get nodes shared by faces that may be distorted
+ SMDS_NodeIteratorPtr nodeIt;
+ if ( edgeSM->NbNodes() > 0 ) {
+ nodeIt = edgeSM->GetNodes();
+ }
+ else {
+ SMESHDS_SubMesh* vertexSM = meshDS->MeshElements( theHelper.IthVertex( 0, edge ));
+ if ( !vertexSM )
+ vertexSM = meshDS->MeshElements( theHelper.IthVertex( 1, edge ));
+ if ( !vertexSM ) continue;
+ nodeIt = vertexSM->GetNodes();
+ }
+
+ // find suspicious faces
+ TIDSortedElemSet checkedFaces;
+ vector< const SMDS_MeshNode* > nOnEdge( 2 );
+ const SMDS_MeshNode* nOnFace;
+ while ( nodeIt->more() )
+ {
+ const SMDS_MeshNode* n = nodeIt->next();
+ SMDS_ElemIteratorPtr faceIt = n->GetInverseElementIterator( SMDSAbs_Face );
+ while ( faceIt->more() )
+ {
+ const SMDS_MeshElement* f = faceIt->next();
+ if ( !faceSM->Contains( f ) ||
+ f->NbNodes() != 6 || // check quadratic triangles only
+ !checkedFaces.insert( f ).second )
+ continue;
+
+ // get nodes on EDGE and on FACE of a suspicious face
+ nOnEdge.clear(); nOnFace = 0;
+ SMDS_MeshElement::iterator triNode = f->begin_nodes();
+ for ( int nbN = 0; nbN < 3; ++triNode, ++nbN )
+ {
+ n = *triNode;
+ if ( n->GetPosition()->GetDim() == 2 )
+ nOnFace = n;
+ else
+ nOnEdge.push_back( n );
+ }
+
+ // check if nOnFace is inside the FACE
+ if ( nOnFace && nOnEdge.size() == 2 )
+ {
+ theHelper.AddTLinks( static_cast< const SMDS_MeshFace* > ( f ));
+ if ( !SMESH_Algo::FaceNormal( f, faceNorm, /*normalized=*/false ))
+ continue;
+ gp_XYZ edgeDir = SMESH_TNodeXYZ( nOnEdge[0] ) - SMESH_TNodeXYZ( nOnEdge[1] );
+ gp_XYZ edgeNorm = faceNorm ^ edgeDir;
+ n = theHelper.GetMediumNode( nOnEdge[0], nOnEdge[1], true );
+ gp_XYZ pN0 = SMESH_TNodeXYZ( nOnEdge[0] );
+ gp_XYZ pMedium = SMESH_TNodeXYZ( n ); // on-edge node location
+ gp_XYZ pFaceN = SMESH_TNodeXYZ( nOnFace ); // on-face node location
+ double hMedium = edgeNorm * gp_Vec( pN0, pMedium ).XYZ();
+ double hFace = edgeNorm * gp_Vec( pN0, pFaceN ).XYZ();
+ if ( Abs( hMedium ) > Abs( hFace * 0.6 ))
+ {
+ // nOnFace is out of FACE, move a medium on-edge node to the middle
+ gp_XYZ pMid3D = 0.5 * ( pN0 + SMESH_TNodeXYZ( nOnEdge[1] ));
+ meshDS->MoveNode( n, pMid3D.X(), pMid3D.Y(), pMid3D.Z() );
+ MSG( "move OUT of face " << n );
+ theError->myBadElements.push_back( f );
+ }
+ }
+ }
+ }
+ }
+ if ( !theError->myBadElements.empty() )
+ theError->myName = EDITERR_NO_MEDIUM_ON_GEOM;
+ return;
+
+ } // 2D ==============================================================================
+
+ if ( shape.ShapeType() == TopAbs_SOLID ) // 3D
+ {
+ if ( theHelper.GetMesh()->NbTetras ( ORDER_QUADRATIC ) < 1 &&
+ theHelper.GetMesh()->NbPyramids( ORDER_QUADRATIC ) < 1 ) return;
+
+ SMESHDS_SubMesh* solidSM = meshDS->MeshElements( shape );
+ if ( !solidSM ) return;
+
+ // check if the SOLID is bound by concave FACEs
+ vector< TopoDS_Face > concaveFaces;
+ TopExp_Explorer faceIt( shape, TopAbs_FACE );
+ for ( ; faceIt.More(); faceIt.Next() ) // loop on FACEs of a SOLID
+ {
+ const TopoDS_Face& face = TopoDS::Face( faceIt.Current() );
+ if ( !meshDS->MeshElements( face )) continue;
+
+ BRepAdaptor_Surface surface( face );
+ switch ( surface.GetType() ) {
+ case GeomAbs_Plane: continue;
+ case GeomAbs_Cylinder:
+ case GeomAbs_Cone:
+ case GeomAbs_Sphere:
+ try
+ {
+ double u = 0.5 * ( surface.FirstUParameter() + surface.LastUParameter() );
+ double v = 0.5 * ( surface.FirstVParameter() + surface.LastVParameter() );
+ gp_Vec Du1, Dv1, Du2, Dv2, Duv2; gp_Pnt p;
+ surface.D2( u,v, p, Du1, Dv1, Du2, Dv2, Duv2 );
+ gp_Vec fNorm = Du1 ^ Dv1;
+ if ( face.Orientation() == TopAbs_REVERSED ) fNorm.Reverse();
+ bool concaveU = ( fNorm * Du2 > 1e-100 );
+ bool concaveV = ( fNorm * Dv2 > 1e-100 );
+ if ( concaveU || concaveV )
+ concaveFaces.push_back( face );
+ }
+ catch ( Standard_Failure )
+ {
+ concaveFaces.push_back( face );
+ }
+ }
+ }
+ if ( concaveFaces.empty() )
+ return;
+
+ // fix 2D mesh on the SOLID
+ for ( faceIt.ReInit(); faceIt.More(); faceIt.Next() ) // loop on FACEs of a SOLID
+ {
+ SMESH_MesherHelper faceHelper( *theHelper.GetMesh() );
+ faceHelper.SetSubShape( faceIt.Current() );
+ force3DOutOfBoundary( faceHelper, theError );
+ }
+
+ // get an iterator over faces on concaveFaces
+ vector< SMDS_ElemIteratorPtr > faceIterVec( concaveFaces.size() );
+ for ( size_t i = 0; i < concaveFaces.size(); ++i )
+ faceIterVec[i] = meshDS->MeshElements( concaveFaces[i] )->GetElements();
+ typedef SMDS_IteratorOnIterators
+ < const SMDS_MeshElement*, vector< SMDS_ElemIteratorPtr > > TIterOnIter;
+ SMDS_ElemIteratorPtr faceIter( new TIterOnIter( faceIterVec ));
+
+ // a seacher to check if a volume is close to a concave face
+ std::auto_ptr< SMESH_ElementSearcher > faceSearcher
+ ( SMESH_MeshEditor( theHelper.GetMesh() ).GetElementSearcher( faceIter ));
+
+ // classifier
+ //BRepClass3d_SolidClassifier solidClassifier( shape );
+
+ TIDSortedElemSet checkedVols, movedNodes;
+ for ( faceIt.ReInit(); faceIt.More(); faceIt.Next() ) // loop on FACEs of a SOLID
+ {
+ const TopoDS_Shape& face = faceIt.Current();
+ SMESHDS_SubMesh* faceSM = meshDS->MeshElements( face );
+ if ( !faceSM ) continue;
+
+ // get nodes shared by volumes (tet and pyra) on the FACE that may be distorted
+ SMDS_NodeIteratorPtr nodeIt;
+ if ( faceSM->NbNodes() > 0 ) {
+ nodeIt = faceSM->GetNodes();
+ }
+ else {
+ TopExp_Explorer vertex( face, TopAbs_VERTEX );
+ SMESHDS_SubMesh* vertexSM = meshDS->MeshElements( vertex.Current() );
+ if ( !vertexSM ) continue;
+ nodeIt = vertexSM->GetNodes();
+ }
+
+ // find suspicious volumes adjacent to the FACE
+ vector< const SMDS_MeshNode* > nOnFace( 4 );
+ const SMDS_MeshNode* nInSolid;
+ //vector< const SMDS_MeshElement* > intersectedFaces;
+ while ( nodeIt->more() )
+ {
+ const SMDS_MeshNode* n = nodeIt->next();
+ SMDS_ElemIteratorPtr volIt = n->GetInverseElementIterator( SMDSAbs_Volume );
+ while ( volIt->more() )
+ {
+ const SMDS_MeshElement* vol = volIt->next();
+ int nbN = vol->NbCornerNodes();
+ if ( ( nbN != 4 && nbN != 5 ) ||
+ !solidSM->Contains( vol ) ||
+ !checkedVols.insert( vol ).second )
+ continue;
+
+ // get nodes on FACE and in SOLID of a suspicious volume
+ nOnFace.clear(); nInSolid = 0;
+ SMDS_MeshElement::iterator volNode = vol->begin_nodes();
+ for ( int nb = nbN; nb > 0; ++volNode, --nb )
+ {
+ n = *volNode;
+ if ( n->GetPosition()->GetDim() == 3 )
+ nInSolid = n;
+ else
+ nOnFace.push_back( n );
+ }
+ if ( !nInSolid || nOnFace.size() != nbN - 1 )
+ continue;
+
+ // get size of the vol
+ SMESH_TNodeXYZ pInSolid( nInSolid ), pOnFace0( nOnFace[0] );
+ double volLength = pInSolid.SquareDistance( nOnFace[0] );
+ for ( size_t i = 1; i < nOnFace.size(); ++i )
+ {
+ volLength = Max( volLength, pOnFace0.SquareDistance( nOnFace[i] ));
+ }
+
+ // check if vol is close to concaveFaces
+ const SMDS_MeshElement* closeFace =
+ faceSearcher->FindClosestTo( pInSolid, SMDSAbs_Face );
+ if ( !closeFace ||
+ pInSolid.SquareDistance( closeFace->GetNode(0) ) > 4 * volLength )
+ continue;
+
+ // check if vol is distorted, i.e. a medium node is much closer
+ // to nInSolid than the link middle
+ bool isDistorted = false;
+ SMDS_FaceOfNodes onFaceTria( nOnFace[0], nOnFace[1], nOnFace[2] );
+ if ( !SMESH_Algo::FaceNormal( &onFaceTria, faceNorm, /*normalized=*/false ))
+ continue;
+ theHelper.AddTLinks( static_cast< const SMDS_MeshVolume* > ( vol ));
+ vector< pair< SMESH_TLink, const SMDS_MeshNode* > > links;
+ for ( size_t i = 0; i < nOnFace.size(); ++i ) // loop on links between nOnFace
+ for ( size_t j = i+1; j < nOnFace.size(); ++j )
+ {
+ SMESH_TLink link( nOnFace[i], nOnFace[j] );
+ TLinkNodeMap::const_iterator linkIt =
+ theHelper.GetTLinkNodeMap().find( link );
+ if ( linkIt != theHelper.GetTLinkNodeMap().end() )
+ {
+ links.push_back( make_pair( linkIt->first, linkIt->second ));
+ if ( !isDistorted ) {
+ // compare projections of nInSolid and nMedium to face normal
+ gp_Pnt pMedium = SMESH_TNodeXYZ( linkIt->second );
+ double hMedium = faceNorm * gp_Vec( pOnFace0, pMedium ).XYZ();
+ double hVol = faceNorm * gp_Vec( pOnFace0, pInSolid ).XYZ();
+ isDistorted = ( Abs( hMedium ) > Abs( hVol * 0.5 ));
+ }
+ }
+ }
+ // move medium nodes to link middle
+ if ( isDistorted )
+ {
+ for ( size_t i = 0; i < links.size(); ++i )
+ {
+ const SMDS_MeshNode* nMedium = links[i].second;
+ if ( movedNodes.insert( nMedium ).second )
+ {
+ gp_Pnt pMid3D = 0.5 * ( SMESH_TNodeXYZ( links[i].first.node1() ) +
+ SMESH_TNodeXYZ( links[i].first.node2() ));
+ meshDS->MoveNode( nMedium, pMid3D.X(), pMid3D.Y(), pMid3D.Z() );
+ MSG( "move OUT of solid " << nMedium );
+ }
+ }
+ theError->myBadElements.push_back( vol );
+ }
+ } // loop on volumes sharing a node on FACE
+ } // loop on nodes on FACE
+ } // loop on FACEs of a SOLID
+
+ if ( !theError->myBadElements.empty() )
+ theError->myName = EDITERR_NO_MEDIUM_ON_GEOM;
+ } // 3D case
+ }
+
} //namespace
//=======================================================================
/*!
* \brief Move medium nodes of faces and volumes to fix distorted elements
+ * \param error - container of fixed distorted elements
* \param volumeOnly - to fix nodes on faces or not, if the shape is solid
*
* Issue 0020307: EDF 992 SMESH : Linea/Quadratic with Medium Node on Geometry
*/
//=======================================================================
-void SMESH_MesherHelper::FixQuadraticElements(bool volumeOnly)
+void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
+ bool volumeOnly)
{
// setenv NO_FixQuadraticElements to know if FixQuadraticElements() is guilty of bad conversion
if ( getenv("NO_FixQuadraticElements") )
#endif
SMESH_MesherHelper h(*myMesh);
h.SetSubShape( s.Current() );
- h.FixQuadraticElements(false);
+ h.ToFixNodeParameters(true);
+ h.FixQuadraticElements( compError, false );
}
}
// fix nodes on geom faces
MSG("FIX FACE " << nbfaces-- << " #" << GetMeshDS()->ShapeToIndex(fIt.Key()));
SMESH_MesherHelper h(*myMesh);
h.SetSubShape( fIt.Key() );
- h.FixQuadraticElements(true);
h.ToFixNodeParameters(true);
+ h.FixQuadraticElements( compError, true);
}
//perf_print_all_meters(1);
+ if ( compError && compError->myName == EDITERR_NO_MEDIUM_ON_GEOM )
+ compError->myComment = "during conversion to quadratic, "
+ "some medium nodes were not placed on geometry to avoid distorting elements";
return;
}
TIDSortedNodeSet apexOfPyramid;
const int apexIndex = 4;
+ // Issue 0020982
+ // Move medium nodes to the link middle for elements whose corner nodes
+ // are out of geometrical boundary to fix distorted elements.
+ force3DOutOfBoundary( *this, compError );
+
if ( elemType == SMDSAbs_Volume )
{
while ( elemIt->more() ) // loop on volumes
QLink link( face->GetNode(iN), face->GetNode((iN+1)%nbN), face->GetNode(iN+nbN) );
pLink = links.insert( link ).first;
faceLinks[ iN ] = & *pLink;
- if ( !isCurved )
+ if ( !isCurved &&
+ link.node1()->GetPosition()->GetTypeOfPosition() < 2 &&
+ link.node2()->GetPosition()->GetTypeOfPosition() < 2 )
isCurved = !link.IsStraight();
}
// store QFace
} // loop on chains of links
} // loop on 2 directions of propagation from quadrangle
} // loop on faces
- }
+ } // fix faces and/or volumes
// 4. Move nodes
// -------------
-// vector<const SMDS_MeshElement*> vols( 100 );
-// vector<double> volSize( 100 );
-// int nbVols;
-// bool ok;
for ( pLink = links.begin(); pLink != links.end(); ++pLink ) {
if ( pLink->IsMoved() ) {
gp_Pnt p = pLink->MiddlePnt() + pLink->Move();
GetMeshDS()->MoveNode( pLink->_mediumNode, p.X(), p.Y(), p.Z());
- //
-// gp_Pnt pNew = pLink->MiddlePnt() + pLink->Move();
-// if ( pLink->MediumPos() != SMDS_TOP_3DSPACE )
-// {
-// // avoid making distorted volumes near boundary
-// SMDS_ElemIteratorPtr volIt =
-// (*pLink)._mediumNode->GetInverseElementIterator( SMDSAbs_Volume );
-// for ( nbVols = 0; volIt->more() && volTool.Set( volIt->next() ); ++nbVols )
-// {
-// vols [ nbVols ] = volTool.Element();
-// volSize[ nbVols ] = volTool.GetSize();
-// }
-// gp_Pnt pOld = pLink->MediumPnt();
-// const_cast<SMDS_MeshNode*>( pLink->_mediumNode )->setXYZ( pNew.X(), pNew.Y(), pNew.Z() );
-// ok = true;
-// while ( nbVols-- && ok )
-// {
-// volTool.Set( vols[ nbVols ]);
-// ok = ( volSize[ nbVols ] * volTool.GetSize() > 1e-20 );
-// }
-// if ( !ok )
-// {
-// const_cast<SMDS_MeshNode*>( pLink->_mediumNode )->setXYZ( pOld.X(), pOld.Y(), pOld.Z() );
-// MSG( "Do NOT move \t" << pLink->_mediumNode->GetID()
-// << " because of distortion of volume " << vols[ nbVols+1 ]->GetID());
-// continue;
-// }
-// }
-// GetMeshDS()->MoveNode( pLink->_mediumNode, pNew.X(), pNew.Y(), pNew.Z() );
- }
- }
-
- //return;
-
- // issue 0020982
- // Move the apex of pyramid together with the most curved link
-
- TIDSortedNodeSet::iterator apexIt = apexOfPyramid.begin();
- for ( ; apexIt != apexOfPyramid.end(); ++apexIt )
- {
- SMESH_TNodeXYZ apex = *apexIt;
-
- gp_Vec maxMove( 0,0,0 );
- double maxMoveSize2 = 0;
-
- // shift of node index to get medium nodes between the base nodes
- const int base2MediumShift = 5;
-
- // find maximal movement of medium node
- SMDS_ElemIteratorPtr volIt = apex._node->GetInverseElementIterator( SMDSAbs_Volume );
- vector< const SMDS_MeshElement* > pyramids;
- while ( volIt->more() )
- {
- const SMDS_MeshElement* pyram = volIt->next();
- if ( pyram->GetEntityType() != SMDSEntity_Quad_Pyramid ) continue;
- pyramids.push_back( pyram );
-
- for ( int iBase = 0; iBase < apexIndex; ++iBase )
- {
- SMESH_TNodeXYZ medium = pyram->GetNode( iBase + base2MediumShift );
- if ( medium._node->GetPosition()->GetTypeOfPosition() != SMDS_TOP_3DSPACE )
- {
- SMESH_TNodeXYZ n1 = pyram->GetNode( iBase );
- SMESH_TNodeXYZ n2 = pyram->GetNode( ( iBase+1 ) % 4 );
- gp_Pnt middle = 0.5 * ( n1 + n2 );
- gp_Vec move( middle, medium );
- double moveSize2 = move.SquareMagnitude();
- if ( moveSize2 > maxMoveSize2 )
- maxMove = move, maxMoveSize2 = moveSize2;
- }
- }
- }
-
- // move the apex
- if ( maxMoveSize2 > 1e-20 )
- {
- apex += maxMove.XYZ();
- GetMeshDS()->MoveNode( apex._node, apex.X(), apex.Y(), apex.Z());
-
- // move medium nodes neighboring the apex to the middle
- const int base2MediumShift_2 = 9;
- for ( unsigned i = 0; i < pyramids.size(); ++i )
- for ( int iBase = 0; iBase < apexIndex; ++iBase )
- {
- SMESH_TNodeXYZ base = pyramids[i]->GetNode( iBase );
- const SMDS_MeshNode* medium = pyramids[i]->GetNode( iBase + base2MediumShift_2 );
- gp_XYZ middle = 0.5 * ( apex + base );
- GetMeshDS()->MoveNode( medium, middle.X(), middle.Y(), middle.Z());
- }
}
}
+
+ // Issue 0020982
+ // Move the apex of pyramid together with the most curved link.
+ // TIDSortedNodeSet::iterator apexIt = apexOfPyramid.begin();
+ // for ( ; apexIt != apexOfPyramid.end(); ++apexIt )
+ // {
+ // SMESH_TNodeXYZ apex = *apexIt;
+
+ // gp_Vec maxMove( 0,0,0 );
+ // double maxMoveSize2 = 0;
+
+ // // shift of node index to get medium nodes between the base nodes
+ // const int base2MediumShift = 5;
+
+ // // find maximal movement of medium node
+ // SMDS_ElemIteratorPtr volIt = apex._node->GetInverseElementIterator( SMDSAbs_Volume );
+ // vector< const SMDS_MeshElement* > pyramids;
+ // while ( volIt->more() )
+ // {
+ // const SMDS_MeshElement* pyram = volIt->next();
+ // if ( pyram->GetEntityType() != SMDSEntity_Quad_Pyramid ) continue;
+ // pyramids.push_back( pyram );
+
+ // for ( int iBase = 0; iBase < apexIndex; ++iBase )
+ // {
+ // SMESH_TNodeXYZ medium = pyram->GetNode( iBase + base2MediumShift );
+ // if ( medium._node->GetPosition()->GetTypeOfPosition() != SMDS_TOP_3DSPACE )
+ // {
+ // SMESH_TNodeXYZ n1 = pyram->GetNode( iBase );
+ // SMESH_TNodeXYZ n2 = pyram->GetNode( ( iBase+1 ) % 4 );
+ // gp_Pnt middle = 0.5 * ( n1 + n2 );
+ // gp_Vec move( middle, medium );
+ // double moveSize2 = move.SquareMagnitude();
+ // if ( moveSize2 > maxMoveSize2 )
+ // maxMove = move, maxMoveSize2 = moveSize2;
+ // }
+ // }
+ // }
+
+ // // move the apex
+ // if ( maxMoveSize2 > 1e-20 )
+ // {
+ // apex += maxMove.XYZ();
+ // GetMeshDS()->MoveNode( apex._node, apex.X(), apex.Y(), apex.Z());
+
+ // // move medium nodes neighboring the apex to the middle
+ // const int base2MediumShift_2 = 9;
+ // for ( unsigned i = 0; i < pyramids.size(); ++i )
+ // for ( int iBase = 0; iBase < apexIndex; ++iBase )
+ // {
+ // SMESH_TNodeXYZ base = pyramids[i]->GetNode( iBase );
+ // const SMDS_MeshNode* medium = pyramids[i]->GetNode( iBase + base2MediumShift_2 );
+ // gp_XYZ middle = 0.5 * ( apex + base );
+ // GetMeshDS()->MoveNode( medium, middle.X(), middle.Y(), middle.Z());
+ // }
+ // }
+ // }
}
