-// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2012 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
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File: SMESH_MesherHelper.cxx
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <Geom_Curve.hxx>
+#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_Surface.hxx>
#include <ShapeAnalysis.hxx>
#include <TopExp.hxx>
//================================================================================
SMESH_MesherHelper::SMESH_MesherHelper(SMESH_Mesh& theMesh)
- : myParIndex(0), myMesh(&theMesh), myShapeID(0), myCreateQuadratic(false)
+ : myParIndex(0), myMesh(&theMesh), myShapeID(0), myCreateQuadratic(false),
+ myFixNodeParameters(false)
{
myPar1[0] = myPar2[0] = myPar1[1] = myPar2[1] = 0;
mySetElemOnShape = ( ! myMesh->HasShapeToMesh() );
{
SMESHDS_Mesh* meshDS = GetMeshDS();
// we can create quadratic elements only if all elements
- // created on subshapes of given shape are quadratic
+ // created on sub-shapes of given shape are quadratic
// also we have to fill myTLinkNodeMap
myCreateQuadratic = true;
mySeamShapeIds.clear();
myDegenShapeIds.clear();
TopAbs_ShapeEnum subType( aSh.ShapeType()==TopAbs_FACE ? TopAbs_EDGE : TopAbs_FACE );
+ if ( aSh.ShapeType()==TopAbs_COMPOUND )
+ {
+ TopoDS_Iterator subIt( aSh );
+ if ( subIt.More() )
+ subType = ( subIt.Value().ShapeType()==TopAbs_FACE ) ? TopAbs_EDGE : TopAbs_FACE;
+ }
SMDSAbs_ElementType elemType( subType==TopAbs_FACE ? SMDSAbs_Face : SMDSAbs_Edge );
+
int nbOldLinks = myTLinkNodeMap.size();
- TopExp_Explorer exp( aSh, subType );
- for (; exp.More() && myCreateQuadratic; exp.Next()) {
- if ( SMESHDS_SubMesh * subMesh = meshDS->MeshElements( exp.Current() )) {
- if ( SMDS_ElemIteratorPtr it = subMesh->GetElements() ) {
- while(it->more()) {
- const SMDS_MeshElement* e = it->next();
- if ( e->GetType() != elemType || !e->IsQuadratic() ) {
- myCreateQuadratic = false;
- break;
- }
- else {
- // fill TLinkNodeMap
- switch ( e->NbNodes() ) {
- case 3:
- AddTLinkNode(e->GetNode(0),e->GetNode(1),e->GetNode(2)); break;
- case 6:
- AddTLinkNode(e->GetNode(0),e->GetNode(1),e->GetNode(3));
- AddTLinkNode(e->GetNode(1),e->GetNode(2),e->GetNode(4));
- AddTLinkNode(e->GetNode(2),e->GetNode(0),e->GetNode(5)); break;
- case 8:
- AddTLinkNode(e->GetNode(0),e->GetNode(1),e->GetNode(4));
- AddTLinkNode(e->GetNode(1),e->GetNode(2),e->GetNode(5));
- AddTLinkNode(e->GetNode(2),e->GetNode(3),e->GetNode(6));
- AddTLinkNode(e->GetNode(3),e->GetNode(0),e->GetNode(7));
- break;
- default:
+ if ( !myMesh->HasShapeToMesh() )
+ {
+ if (( myCreateQuadratic = myMesh->NbFaces( ORDER_QUADRATIC )))
+ {
+ SMDS_FaceIteratorPtr fIt = meshDS->facesIterator();
+ while ( fIt->more() )
+ AddTLinks( static_cast< const SMDS_MeshFace* >( fIt->next() ));
+ }
+ }
+ else
+ {
+ TopExp_Explorer exp( aSh, subType );
+ TopTools_MapOfShape checkedSubShapes;
+ for (; exp.More() && myCreateQuadratic; exp.Next()) {
+ if ( !checkedSubShapes.Add( exp.Current() ))
+ continue; // needed if aSh is compound of solids
+ if ( SMESHDS_SubMesh * subMesh = meshDS->MeshElements( exp.Current() )) {
+ if ( SMDS_ElemIteratorPtr it = subMesh->GetElements() ) {
+ while(it->more()) {
+ const SMDS_MeshElement* e = it->next();
+ if ( e->GetType() != elemType || !e->IsQuadratic() ) {
myCreateQuadratic = false;
break;
}
+ else {
+ // fill TLinkNodeMap
+ switch ( e->NbNodes() ) {
+ case 3:
+ AddTLinkNode(e->GetNode(0),e->GetNode(1),e->GetNode(2)); break;
+ case 6:
+ AddTLinkNode(e->GetNode(0),e->GetNode(1),e->GetNode(3));
+ AddTLinkNode(e->GetNode(1),e->GetNode(2),e->GetNode(4));
+ AddTLinkNode(e->GetNode(2),e->GetNode(0),e->GetNode(5)); break;
+ case 8:
+ AddTLinkNode(e->GetNode(0),e->GetNode(1),e->GetNode(4));
+ AddTLinkNode(e->GetNode(1),e->GetNode(2),e->GetNode(5));
+ AddTLinkNode(e->GetNode(2),e->GetNode(3),e->GetNode(6));
+ AddTLinkNode(e->GetNode(3),e->GetNode(0),e->GetNode(7));
+ break;
+ default:
+ myCreateQuadratic = false;
+ break;
+ }
+ }
}
}
}
{
if ( aShID == myShapeID )
return;
- if ( aShID > 1 )
+ if ( aShID > 0 )
SetSubShape( GetMeshDS()->IndexToShape( aShID ));
else
SetSubShape( TopoDS_Shape() );
for ( TopExp_Explorer eF( aSh, TopAbs_FACE ); eF.More(); eF.Next() )
{
const TopoDS_Face& face = TopoDS::Face( eF.Current() );
- BRepAdaptor_Surface surface( face );
- if ( surface.IsUPeriodic() || surface.IsVPeriodic() )
+ TopLoc_Location loc;
+ Handle(Geom_Surface) surface = BRep_Tool::Surface( face, loc );
+
+ if ( surface->IsUPeriodic() || surface->IsVPeriodic() ||
+ surface->IsUClosed() || surface->IsVClosed() )
{
+ //while ( surface->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface )))
+ //surface = Handle(Geom_RectangularTrimmedSurface)::DownCast( surface )->BasisSurface();
+ GeomAdaptor_Surface surf( surface );
+
for (TopExp_Explorer exp( face, TopAbs_EDGE ); exp.More(); exp.Next())
{
// look for a seam edge
if ( Abs( uv1.Coord(1) - uv2.Coord(1) ) < Abs( uv1.Coord(2) - uv2.Coord(2) ))
{
myParIndex |= U_periodic;
- myPar1[0] = surface.FirstUParameter();
- myPar2[0] = surface.LastUParameter();
+ myPar1[0] = surf.FirstUParameter();
+ myPar2[0] = surf.LastUParameter();
}
else {
myParIndex |= V_periodic;
- myPar1[1] = surface.FirstVParameter();
- myPar2[1] = surface.LastVParameter();
+ myPar1[1] = surf.FirstVParameter();
+ myPar2[1] = surf.LastVParameter();
}
// store seam shape indices, negative if shape encounters twice
int edgeID = meshDS->ShapeToIndex( edge );
//function : GetNodeUVneedInFaceNode
//purpose : Check if inFaceNode argument is necessary for call GetNodeUV(F,..)
// Return true if the face is periodic.
-// If F is Null, answer about subshape set through IsQuadraticSubMesh() or
+// If F is Null, answer about sub-shape set through IsQuadraticSubMesh() or
// * SetSubShape()
//=======================================================================
myTLinkNodeMap.insert( make_pair(link,n12));
}
+//================================================================================
+/*!
+ * \brief Add quadratic links of edge to own data structure
+ */
+//================================================================================
+
+void SMESH_MesherHelper::AddTLinks(const SMDS_MeshEdge* edge)
+{
+ if ( edge->IsQuadratic() )
+ AddTLinkNode(edge->GetNode(0), edge->GetNode(1), edge->GetNode(2));
+}
+
+//================================================================================
+/*!
+ * \brief Add quadratic links of face to own data structure
+ */
+//================================================================================
+
+void SMESH_MesherHelper::AddTLinks(const SMDS_MeshFace* f)
+{
+ if ( !f->IsPoly() )
+ switch ( f->NbNodes() ) {
+ case 6:
+ AddTLinkNode(f->GetNode(0),f->GetNode(1),f->GetNode(3));
+ AddTLinkNode(f->GetNode(1),f->GetNode(2),f->GetNode(4));
+ AddTLinkNode(f->GetNode(2),f->GetNode(0),f->GetNode(5)); break;
+ case 8:
+ AddTLinkNode(f->GetNode(0),f->GetNode(1),f->GetNode(4));
+ AddTLinkNode(f->GetNode(1),f->GetNode(2),f->GetNode(5));
+ AddTLinkNode(f->GetNode(2),f->GetNode(3),f->GetNode(6));
+ AddTLinkNode(f->GetNode(3),f->GetNode(0),f->GetNode(7));
+ default:;
+ }
+}
+
+//================================================================================
+/*!
+ * \brief Add quadratic links of volume to own data structure
+ */
+//================================================================================
+
+void SMESH_MesherHelper::AddTLinks(const SMDS_MeshVolume* volume)
+{
+ if ( volume->IsQuadratic() )
+ {
+ SMDS_VolumeTool vTool( volume );
+ const SMDS_MeshNode** nodes = vTool.GetNodes();
+ set<int> addedLinks;
+ for ( int iF = 1; iF < vTool.NbFaces(); ++iF )
+ {
+ const int nbN = vTool.NbFaceNodes( iF );
+ const int* iNodes = vTool.GetFaceNodesIndices( iF );
+ for ( int i = 0; i < nbN; )
+ {
+ int iN1 = iNodes[i++];
+ int iN12 = 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 );
+ if ( it_isNew.second )
+ AddTLinkNode( nodes[iN1], nodes[iN2], nodes[iN12] );
+ else
+ addedLinks.erase( it_isNew.first ); // each link encounters only twice
+ }
+ }
+ }
+}
+
//================================================================================
/*!
* \brief Return true if position of nodes on the shape hasn't yet been checked or
((SMESH_MesherHelper*)this)->myNodePosShapesValidity.insert( make_pair( shapeID, ok));
}
+//=======================================================================
+//function : ToFixNodeParameters
+//purpose : Enables fixing node parameters on EDGEs and FACEs in
+// GetNodeU(...,check=true), GetNodeUV(...,check=true), CheckNodeUV() and
+// CheckNodeU() in case if a node lies on a shape set via SetSubShape().
+// Default is False
+//=======================================================================
+
+void SMESH_MesherHelper::ToFixNodeParameters(bool toFix)
+{
+ myFixNodeParameters = toFix;
+}
+
+
//=======================================================================
//function : GetUVOnSeam
//purpose : Select UV on either of 2 pcurves of a seam edge, closest to the given UV
if ( validU )
uv = C2d->Value( u );
else
- uv.SetCoord(0.,0.);
+ uv.SetCoord( Precision::Infinite(),0.);
if ( check || !validU )
uvOK = CheckNodeUV( F, n, uv.ChangeCoord(), 10*MaxTolerance( F ),/*force=*/ !validU );
uv = GetUVOnSeam( uv, GetNodeUV( F, n2, 0 ));
}
}
+ else
+ {
+ uvOK = CheckNodeUV( F, n, uv.ChangeCoord(), 10*MaxTolerance( F ));
+ }
if ( check )
*check = uvOK;
double distXYZ[4]) const
{
int shapeID = n->getshapeId();
- if ( force || toCheckPosOnShape( shapeID ))
+ bool infinit = ( Precision::IsInfinite( uv.X() ) || Precision::IsInfinite( uv.Y() ));
+ if ( force || toCheckPosOnShape( shapeID ) || infinit )
{
- double toldis = tol;
- double tolmin = 1.e-7*myMesh->GetMeshDS()->getMaxDim(); // nodes coordinates are stored in float format
- if (toldis < tolmin) toldis = tolmin;
// check that uv is correct
TopLoc_Location loc;
Handle(Geom_Surface) surface = BRep_Tool::Surface( F,loc );
gp_Pnt nodePnt = XYZ( n ), surfPnt(0,0,0);
double dist = 0;
if ( !loc.IsIdentity() ) nodePnt.Transform( loc.Transformation().Inverted() );
- bool infinit = ( Precision::IsInfinite( uv.X() ) || Precision::IsInfinite( uv.Y() ));
if ( infinit ||
(dist = nodePnt.Distance( surfPnt = surface->Value( uv.X(), uv.Y() ))) > tol )
{
return false;
}
// store the fixed UV on the face
- if ( myShape.IsSame(F) && shapeID == myShapeID )
+ if ( myShape.IsSame(F) && shapeID == myShapeID && myFixNodeParameters )
const_cast<SMDS_MeshNode*>(n)->SetPosition
( SMDS_PositionPtr( new SMDS_FacePosition( U, V )));
}
const gp_XY& p1,
const gp_XY& p2)
{
- return applyIn2D( surface, p1, p2, & AverageUV );
+ // NOTE:
+ // the proper place of getting basic surface seems to be in applyIn2D()
+ // but we put it here to decrease a risk of regressions just before releasing a version
+ Handle(Geom_Surface) surf = surface;
+ while ( !surf.IsNull() && surf->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface )))
+ surf = Handle(Geom_RectangularTrimmedSurface)::DownCast( surf )->BasisSurface();
+
+ return applyIn2D( surf, p1, p2, & AverageUV );
}
//=======================================================================
int shapeID = n->getshapeId();
if ( force || toCheckPosOnShape( shapeID ))
{
- //double toldis = tol;
- //double tolmin = 1.e-7*myMesh->GetMeshDS()->getMaxDim(); // nodes coordinates are stored in float format
- //if (toldis < tolmin) toldis = tolmin;
- // check that u is correct
TopLoc_Location loc; double f,l;
Handle(Geom_Curve) curve = BRep_Tool::Curve( E,loc,f,l );
if ( curve.IsNull() ) // degenerated edge
}
else
{
- gp_Pnt nodePnt = SMESH_MeshEditor::TNodeXYZ( n );
+ gp_Pnt nodePnt = SMESH_TNodeXYZ( n );
if ( !loc.IsIdentity() ) nodePnt.Transform( loc.Transformation().Inverted() );
gp_Pnt curvPnt = curve->Value( u );
double dist = nodePnt.Distance( curvPnt );
distXYZ[0] = dist;
distXYZ[1] = curvPnt.X(); distXYZ[2] = curvPnt.Y(); distXYZ[3]=curvPnt.Z();
}
- if ( dist > tol /*toldis*/ )
+ if ( dist > tol )
{
setPosOnShapeValidity( shapeID, false );
// u incorrect, project the node to the curve
distXYZ[0] = dist;
distXYZ[1] = curvPnt.X(); distXYZ[2] = curvPnt.Y(); distXYZ[3]=curvPnt.Z();
}
- if ( dist > tol /*toldis*/)
+ if ( dist > tol )
{
MESSAGE( "SMESH_MesherHelper::CheckNodeU(), invalid projection" );
- MESSAGE("distance " << dist << " " << tol/*dis*/);
+ MESSAGE("distance " << dist << " " << tol );
return false;
}
// store the fixed U on the edge
- if ( myShape.IsSame(E) && shapeID == myShapeID )
+ if ( myShape.IsSame(E) && shapeID == myShapeID && myFixNodeParameters )
const_cast<SMDS_MeshNode*>(n)->SetPosition
( SMDS_PositionPtr( new SMDS_EdgePosition( U )));
}
return true;
}
+//=======================================================================
+//function : GetMediumPos
+//purpose : Return index and type of the shape (EDGE or FACE only) to
+// set a medium node on
+//=======================================================================
+
+std::pair<int, TopAbs_ShapeEnum> SMESH_MesherHelper::GetMediumPos(const SMDS_MeshNode* n1,
+ const SMDS_MeshNode* n2)
+{
+ TopAbs_ShapeEnum shapeType = TopAbs_SHAPE;
+ int shapeID = -1;
+ TopoDS_Shape shape;
+
+ if (( myShapeID == n1->getshapeId() || myShapeID == n2->getshapeId() ) && myShapeID > 0 )
+ {
+ shapeType = myShape.ShapeType();
+ shapeID = myShapeID;
+ }
+ else if ( n1->getshapeId() == n2->getshapeId() )
+ {
+ shapeID = n2->getshapeId();
+ shape = GetSubShapeByNode( n1, GetMeshDS() );
+ }
+ else
+ {
+ const SMDS_TypeOfPosition Pos1 = n1->GetPosition()->GetTypeOfPosition();
+ const SMDS_TypeOfPosition Pos2 = n2->GetPosition()->GetTypeOfPosition();
+
+ if ( Pos1 == SMDS_TOP_3DSPACE || Pos2 == SMDS_TOP_3DSPACE )
+ {
+ }
+ else if ( Pos1 == SMDS_TOP_FACE || Pos2 == SMDS_TOP_FACE )
+ {
+ if ( Pos1 != SMDS_TOP_FACE || Pos2 != SMDS_TOP_FACE )
+ {
+ if ( Pos1 != SMDS_TOP_FACE ) std::swap( n1,n2 );
+ TopoDS_Shape F = GetSubShapeByNode( n1, GetMeshDS() );
+ TopoDS_Shape S = GetSubShapeByNode( n2, GetMeshDS() );
+ if ( IsSubShape( S, F ))
+ {
+ shapeType = TopAbs_FACE;
+ shapeID = n1->getshapeId();
+ }
+ }
+ }
+ else if ( Pos1 == SMDS_TOP_EDGE && Pos2 == SMDS_TOP_EDGE )
+ {
+ TopoDS_Shape E1 = GetSubShapeByNode( n1, GetMeshDS() );
+ TopoDS_Shape E2 = GetSubShapeByNode( n2, GetMeshDS() );
+ shape = GetCommonAncestor( E1, E2, *myMesh, TopAbs_FACE );
+ }
+ else if ( Pos1 == SMDS_TOP_VERTEX && Pos2 == SMDS_TOP_VERTEX )
+ {
+ TopoDS_Shape V1 = GetSubShapeByNode( n1, GetMeshDS() );
+ TopoDS_Shape V2 = GetSubShapeByNode( n2, GetMeshDS() );
+ shape = GetCommonAncestor( V1, V2, *myMesh, TopAbs_EDGE );
+ if ( shape.IsNull() ) shape = GetCommonAncestor( V1, V2, *myMesh, TopAbs_FACE );
+ }
+ else // VERTEX and EDGE
+ {
+ if ( Pos1 != SMDS_TOP_VERTEX ) std::swap( n1,n2 );
+ TopoDS_Shape V = GetSubShapeByNode( n1, GetMeshDS() );
+ TopoDS_Shape E = GetSubShapeByNode( n2, GetMeshDS() );
+ if ( IsSubShape( V, E ))
+ shape = E;
+ else
+ shape = GetCommonAncestor( V, E, *myMesh, TopAbs_FACE );
+ }
+ }
+
+ if ( !shape.IsNull() )
+ {
+ if ( shapeID < 1 )
+ shapeID = GetMeshDS()->ShapeToIndex( shape );
+ shapeType = shape.ShapeType();
+ }
+ return make_pair( shapeID, shapeType );
+}
+
//=======================================================================
//function : GetMediumNode
//purpose : Return existing or create new medium nodes between given ones
// get type of shape for the new medium node
int faceID = -1, edgeID = -1;
- const SMDS_PositionPtr Pos1 = n1->GetPosition();
- const SMDS_PositionPtr Pos2 = n2->GetPosition();
-
TopoDS_Edge E; double u [2];
TopoDS_Face F; gp_XY uv[2];
bool uvOK[2] = { false, false };
- if( myShape.IsNull() )
- {
- if( Pos1->GetTypeOfPosition()==SMDS_TOP_FACE ) {
- faceID = n1->getshapeId();
- }
- else if( Pos2->GetTypeOfPosition()==SMDS_TOP_FACE ) {
- faceID = n2->getshapeId();
- }
+ pair<int, TopAbs_ShapeEnum> pos = GetMediumPos( n1, n2 );
- if( Pos1->GetTypeOfPosition()==SMDS_TOP_EDGE ) {
- edgeID = n1->getshapeId();
- }
- if( Pos2->GetTypeOfPosition()==SMDS_TOP_EDGE ) {
- edgeID = n2->getshapeId();
- }
- }
// get positions of the given nodes on shapes
- TopAbs_ShapeEnum shapeType = myShape.IsNull() ? TopAbs_SHAPE : myShape.ShapeType();
- if ( faceID>0 || shapeType == TopAbs_FACE)
+ if ( pos.second == TopAbs_FACE )
{
- if( myShape.IsNull() )
- F = TopoDS::Face(meshDS->IndexToShape(faceID));
- else {
- F = TopoDS::Face(myShape);
- faceID = myShapeID;
- }
+ F = TopoDS::Face(meshDS->IndexToShape( faceID = pos.first ));
uv[0] = GetNodeUV(F,n1,n2, force3d ? 0 : &uvOK[0]);
uv[1] = GetNodeUV(F,n2,n1, force3d ? 0 : &uvOK[1]);
}
- else if (edgeID>0 || shapeType == TopAbs_EDGE)
+ else if ( pos.second == TopAbs_EDGE )
{
+ const SMDS_PositionPtr Pos1 = n1->GetPosition();
+ const SMDS_PositionPtr Pos2 = n2->GetPosition();
if ( Pos1->GetTypeOfPosition()==SMDS_TOP_EDGE &&
Pos2->GetTypeOfPosition()==SMDS_TOP_EDGE &&
- n1->getshapeId() != n2->getshapeId() ) // issue 0021006
- return getMediumNodeOnComposedWire(n1,n2,force3d);
-
- if( myShape.IsNull() )
- E = TopoDS::Edge(meshDS->IndexToShape(edgeID));
- else {
- E = TopoDS::Edge(myShape);
- edgeID = myShapeID;
+ n1->getshapeId() != n2->getshapeId() )
+ {
+ // issue 0021006
+ return getMediumNodeOnComposedWire(n1,n2,force3d);
}
+ E = TopoDS::Edge(meshDS->IndexToShape( edgeID = pos.first ));
u[0] = GetNodeU(E,n1,n2, force3d ? 0 : &uvOK[0]);
u[1] = GetNodeU(E,n2,n1, force3d ? 0 : &uvOK[1]);
}
- if(!force3d)
+
+ if ( !force3d & uvOK[0] && uvOK[1] )
{
// we try to create medium node using UV parameters of
// nodes, else - medium between corresponding 3d points
if( ! F.IsNull() )
{
- if ( uvOK[0] && uvOK[1] )
+ //if ( uvOK[0] && uvOK[1] )
{
if ( IsDegenShape( n1->getshapeId() )) {
if ( myParIndex & U_periodic ) uv[0].SetCoord( 1, uv[1].Coord( 1 ));
//purpose : Creates a node
//=======================================================================
-SMDS_MeshNode* SMESH_MesherHelper::AddNode(double x, double y, double z, int ID)
+SMDS_MeshNode* SMESH_MesherHelper::AddNode(double x, double y, double z, int ID,
+ double u, double v)
{
SMESHDS_Mesh * meshDS = GetMeshDS();
SMDS_MeshNode* node = 0;
node = meshDS->AddNode( x, y, z );
if ( mySetElemOnShape && myShapeID > 0 ) {
switch ( myShape.ShapeType() ) {
- case TopAbs_SOLID: meshDS->SetNodeInVolume( node, myShapeID); break;
- case TopAbs_SHELL: meshDS->SetNodeInVolume( node, myShapeID); break;
- case TopAbs_FACE: meshDS->SetNodeOnFace( node, myShapeID); break;
- case TopAbs_EDGE: meshDS->SetNodeOnEdge( node, myShapeID); break;
- case TopAbs_VERTEX: meshDS->SetNodeOnVertex( node, myShapeID); break;
+ case TopAbs_SOLID: meshDS->SetNodeInVolume( node, myShapeID); break;
+ case TopAbs_SHELL: meshDS->SetNodeInVolume( node, myShapeID); break;
+ case TopAbs_FACE: meshDS->SetNodeOnFace( node, myShapeID, u, v); break;
+ case TopAbs_EDGE: meshDS->SetNodeOnEdge( node, myShapeID, u); break;
+ case TopAbs_VERTEX: meshDS->SetNodeOnVertex( node, myShapeID); break;
default: ;
}
}
for ( int i = 0; i < nodes.size(); ++i )
{
const SMDS_MeshNode* n1 = nodes[i];
- const SMDS_MeshNode* n2 = nodes[(i+1)/nodes.size()];
+ const SMDS_MeshNode* n2 = nodes[(i+1)%nodes.size()];
const SMDS_MeshNode* n12 = GetMediumNode(n1,n2,force3d);
newNodes.push_back( n1 );
newNodes.push_back( n12 );
return elem;
}
+//=======================================================================
+//function : AddVolume
+//purpose : Creates LINEAR!!!!!!!!! octahedron
+//=======================================================================
+
+SMDS_MeshVolume* SMESH_MesherHelper::AddVolume(const SMDS_MeshNode* n1,
+ const SMDS_MeshNode* n2,
+ const SMDS_MeshNode* n3,
+ const SMDS_MeshNode* n4,
+ const SMDS_MeshNode* n5,
+ const SMDS_MeshNode* n6,
+ const SMDS_MeshNode* n7,
+ const SMDS_MeshNode* n8,
+ const SMDS_MeshNode* n9,
+ const SMDS_MeshNode* n10,
+ const SMDS_MeshNode* n11,
+ const SMDS_MeshNode* n12,
+ const int id,
+ bool force3d)
+{
+ SMESHDS_Mesh * meshDS = GetMeshDS();
+ SMDS_MeshVolume* elem = 0;
+ if(id)
+ elem = meshDS->AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,id);
+ else
+ elem = meshDS->AddVolume(n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12);
+ if ( mySetElemOnShape && myShapeID > 0 )
+ meshDS->SetMeshElementOnShape( elem, myShapeID );
+ return elem;
+}
+
//=======================================================================
//function : AddPolyhedralVolume
//purpose : Creates polyhedron. In quadratic mesh, adds medium nodes
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 : LoadNodeColumns
//purpose : Load nodes bound to face into a map of node columns
SMESHDS_Mesh* theMesh,
SMESH_ProxyMesh* theProxyMesh)
{
+ return LoadNodeColumns(theParam2ColumnMap,
+ theFace,
+ std::list<TopoDS_Edge>(1,theBaseEdge),
+ theMesh,
+ theProxyMesh);
+}
+
+//=======================================================================
+//function : LoadNodeColumns
+//purpose : Load nodes bound to face into a map of node columns
+//=======================================================================
+
+bool SMESH_MesherHelper::LoadNodeColumns(TParam2ColumnMap & theParam2ColumnMap,
+ const TopoDS_Face& theFace,
+ const std::list<TopoDS_Edge>& theBaseSide,
+ SMESHDS_Mesh* theMesh,
+ SMESH_ProxyMesh* theProxyMesh)
+{
+ // get a right submesh of theFace
+
const SMESHDS_SubMesh* faceSubMesh = 0;
if ( theProxyMesh )
{
if ( !faceSubMesh || faceSubMesh->NbElements() == 0 )
return false;
- // get nodes on theBaseEdge sorted by param on edge and initialize theParam2ColumnMap with them
+ // get data of edges for normalization of params
- map< double, const SMDS_MeshNode*> sortedBaseNodes;
- if ( !SMESH_Algo::GetSortedNodesOnEdge( theMesh, theBaseEdge,/*noMedium=*/true, sortedBaseNodes)
- || sortedBaseNodes.size() < 2 )
- return false;
-
- int nbRows = faceSubMesh->NbElements() / ( sortedBaseNodes.size()-1 ) + 1;
- map< double, const SMDS_MeshNode*>::iterator u_n = sortedBaseNodes.begin();
- double f = u_n->first, range = sortedBaseNodes.rbegin()->first - f;
- for ( ; u_n != sortedBaseNodes.end(); u_n++ )
+ vector< double > length;
+ double fullLen = 0;
+ list<TopoDS_Edge>::const_iterator edge;
{
- double par = ( u_n->first - f ) / range;
- vector<const SMDS_MeshNode*>& nCol = theParam2ColumnMap[ par ];
- nCol.resize( nbRows );
- nCol[0] = 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 )
+
+ // 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 )
{
- for ( ; par_nVec_1 != theParam2ColumnMap.end(); ++par_nVec_1 )
+ map< double, const SMDS_MeshNode*> sortedBaseNodes;
+ SMESH_Algo::GetSortedNodesOnEdge( theMesh, *edge,/*noMedium=*/true, sortedBaseNodes);
+ if ( sortedBaseNodes.empty() ) continue;
+
+ map< double, const SMDS_MeshNode*>::iterator u_n = sortedBaseNodes.begin();
+ if ( theProxyMesh ) // from sortedBaseNodes remove nodes not shared by faces of faceSubMesh
{
- const SMDS_MeshNode* & n = par_nVec_1->second[0];
- n = theProxyMesh->GetProxyNode( n );
+ const SMDS_MeshNode* n1 = sortedBaseNodes.begin()->second;
+ const SMDS_MeshNode* n2 = sortedBaseNodes.rbegin()->second;
+ bool allNodesAreProxy = ( n1 != theProxyMesh->GetProxyNode( n1 ) &&
+ n2 != theProxyMesh->GetProxyNode( n2 ));
+ if ( allNodesAreProxy )
+ for ( u_n = sortedBaseNodes.begin(); u_n != sortedBaseNodes.end(); u_n++ )
+ u_n->second = theProxyMesh->GetProxyNode( u_n->second );
+
+ if ( u_n = sortedBaseNodes.begin(), !isNodeInSubMesh( u_n->second, faceSubMesh ))
+ {
+ while ( ++u_n != sortedBaseNodes.end() && !isNodeInSubMesh( u_n->second, faceSubMesh ));
+ sortedBaseNodes.erase( sortedBaseNodes.begin(), u_n );
+ }
+ else if ( u_n = --sortedBaseNodes.end(), !isNodeInSubMesh( u_n->second, faceSubMesh ))
+ {
+ while ( u_n != sortedBaseNodes.begin() && !isNodeInSubMesh( (--u_n)->second, faceSubMesh ));
+ sortedBaseNodes.erase( ++u_n, sortedBaseNodes.end() );
+ }
+ if ( sortedBaseNodes.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 = sortedBaseNodes.begin(); u_n != sortedBaseNodes.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 );
// 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 );
int i1, i2, iRow = 0;
const SMDS_MeshNode *n1 = nCol1[0], *n2 = nCol2[0];
}
avoidSet.insert( face );
}
- if ( iRow + 1 < nbRows ) // compact if necessary
- nCol1.resize( iRow + 1 ), nCol2.resize( iRow + 1 );
+ // set a real height
+ nCol1.resize( iRow + 1 );
+ nCol2.resize( iRow + 1 );
}
return theParam2ColumnMap.size() > 1 && theParam2ColumnMap.begin()->second.size() > 1;
}
return TopExp::FirstVertex( anEdge ).IsSame( TopExp::LastVertex( anEdge ));
}
+//================================================================================
+/*!
+ * \brief Wrapper over TopExp::FirstVertex() and TopExp::LastVertex() fixing them
+ * in the case of INTERNAL edge
+ */
+//================================================================================
+
+TopoDS_Vertex SMESH_MesherHelper::IthVertex( const bool is2nd,
+ TopoDS_Edge anEdge,
+ const bool CumOri )
+{
+ if ( anEdge.Orientation() >= TopAbs_INTERNAL )
+ anEdge.Orientation( TopAbs_FORWARD );
+
+ const TopAbs_Orientation tgtOri = is2nd ? TopAbs_REVERSED : TopAbs_FORWARD;
+ TopoDS_Iterator vIt( anEdge, CumOri );
+ while ( vIt.More() && vIt.Value().Orientation() != tgtOri )
+ vIt.Next();
+
+ return ( vIt.More() ? TopoDS::Vertex(vIt.Value()) : TopoDS_Vertex() );
+}
+
//=======================================================================
//function : IsQuadraticMesh
//purpose : Check mesh without geometry for: if all elements on this shape are quadratic,
return fabs(param-myPar1[i]) < fabs(param-myPar2[i]) ? myPar2[i] : myPar1[i];
}
+namespace {
+
+ //=======================================================================
+ /*!
+ * \brief Iterator on ancestors of the given type
+ */
+ //=======================================================================
+
+ struct TAncestorsIterator : public SMDS_Iterator<const TopoDS_Shape*>
+ {
+ TopTools_ListIteratorOfListOfShape _ancIter;
+ TopAbs_ShapeEnum _type;
+ TopTools_MapOfShape _encountered;
+ TAncestorsIterator( const TopTools_ListOfShape& ancestors, TopAbs_ShapeEnum type)
+ : _ancIter( ancestors ), _type( type )
+ {
+ if ( _ancIter.More() ) {
+ if ( _ancIter.Value().ShapeType() != _type ) next();
+ else _encountered.Add( _ancIter.Value() );
+ }
+ }
+ virtual bool more()
+ {
+ return _ancIter.More();
+ }
+ virtual const TopoDS_Shape* next()
+ {
+ const TopoDS_Shape* s = _ancIter.More() ? & _ancIter.Value() : 0;
+ if ( _ancIter.More() )
+ for ( _ancIter.Next(); _ancIter.More(); _ancIter.Next())
+ if ( _ancIter.Value().ShapeType() == _type && _encountered.Add( _ancIter.Value() ))
+ break;
+ return s;
+ }
+ };
+
+} // namespace
+
+//=======================================================================
+/*!
+ * \brief Return iterator on ancestors of the given type
+ */
+//=======================================================================
+
+PShapeIteratorPtr SMESH_MesherHelper::GetAncestors(const TopoDS_Shape& shape,
+ const SMESH_Mesh& mesh,
+ TopAbs_ShapeEnum ancestorType)
+{
+ return PShapeIteratorPtr( new TAncestorsIterator( mesh.GetAncestors(shape), ancestorType));
+}
+
+//=======================================================================
+//function : GetCommonAncestor
+//purpose : Find a common ancestors of two shapes of the given type
+//=======================================================================
+
+TopoDS_Shape SMESH_MesherHelper::GetCommonAncestor(const TopoDS_Shape& shape1,
+ const TopoDS_Shape& shape2,
+ const SMESH_Mesh& mesh,
+ TopAbs_ShapeEnum ancestorType)
+{
+ TopoDS_Shape commonAnc;
+ if ( !shape1.IsNull() && !shape2.IsNull() )
+ {
+ PShapeIteratorPtr ancIt = GetAncestors( shape1, mesh, ancestorType );
+ while ( const TopoDS_Shape* anc = ancIt->next() )
+ if ( IsSubShape( shape2, *anc ))
+ {
+ commonAnc = *anc;
+ break;
+ }
+ }
+ return commonAnc;
+}
+
//#include <Perf_Meter.hxx>
//=======================================================================
void Move(const gp_Vec& move, bool sum=false) const
{ _nodeMove += move; _nbMoves += sum ? (_nbMoves==0) : 1; }
gp_XYZ Move() const { return _nodeMove.XYZ() / _nbMoves; }
- bool IsMoved() const { return (_nbMoves > 0 && !IsStraight()); }
+ bool IsMoved() const { return (_nbMoves > 0 /*&& !IsStraight()*/); }
bool IsStraight() const
{ return isStraightLink( (XYZ(node1())-XYZ(node2())).SquareModulus(),
_nodeMove.SquareMagnitude());
const QLink* operator->() const { return _qlink; }
gp_Vec Normal() const;
+
+ bool IsStraight() const;
};
// --------------------------------------------------------------------
typedef list< TChainLink > TChain;
// chLink = chain.insert( chain.begin(), TChainLink(face->_sides[i]));
// add a face to a chained link and put a continues face in the queue
chLink->SetFace( face );
- if ( face->_sides[i]->MediumPos() >= pos )
+ if ( face->_sides[i]->MediumPos() == pos )
if ( const QFace* contFace = face->_sides[i]->GetContinuesFace( face ))
- faces.push_back( contFace );
+ if ( contFace->_sides.size() == 3 )
+ faces.push_back( contFace );
}
}
faces.pop_front();
// propagate from quadrangle to neighbour faces
if ( link->MediumPos() >= pos ) {
int nbLinkFaces = link->_faces.size();
- if ( nbLinkFaces == 4 || (nbLinkFaces < 4 && link->OnBoundary())) {
+ if ( nbLinkFaces == 4 || (/*nbLinkFaces < 4 && */link->OnBoundary())) {
// hexahedral mesh or boundary quadrangles - goto a continous face
if ( const QFace* f = link->GetContinuesFace( this ))
- return f->GetLinkChain( *chLink, chain, pos, error );
+ if ( f->_sides.size() == 4 )
+ return f->GetLinkChain( *chLink, chain, pos, error );
}
else {
TChainLink chLink(link); // side face of prismatic mesh - visit all faces of iSide
gp_Vec linkDir2(0,0,0);
try {
OCC_CATCH_SIGNALS;
- if ( f1 )
+ if ( f1 && theLink->MediumPos() <= (*link1)->MediumPos() )
len1 = f1->MoveByBoundary
( *link1, theRefVec, theLinks, theFaceHelper, len1, theStep-1, &linkDir1, theSign);
else
}
try {
OCC_CATCH_SIGNALS;
- if ( f2 )
+ if ( f2 && theLink->MediumPos() <= (*link2)->MediumPos() )
len2 = f2->MoveByBoundary
( *link2, theRefVec, theLinks, theFaceHelper, len2, theStep-1, &linkDir2, theSign);
else
if ( _faces.empty() )
return;
- int iFaceCont = -1;
+ int iFaceCont = -1, nbBoundary = 0, iBoundary[2]={-1,-1};
+ if ( _faces[0]->IsBoundary() )
+ iBoundary[ nbBoundary++ ] = 0;
for ( int iF = 1; iFaceCont < 0 && iF < _faces.size(); ++iF )
{
// look for a face bounding none of volumes bound by _faces[0]
_faces[iF]->_volumes[iV] == _faces[0]->_volumes[1]);
if ( !sameVol )
iFaceCont = iF;
+ if ( _faces[iF]->IsBoundary() )
+ iBoundary[ nbBoundary++ ] = iF;
+ }
+ // Set continues faces: arrange _faces to have
+ // _faces[0] continues to _faces[1]
+ // _faces[2] continues to _faces[3]
+ if ( nbBoundary == 2 ) // bnd faces are continues
+ {
+ if (( iBoundary[0] < 2 ) != ( iBoundary[1] < 2 ))
+ {
+ int iNear0 = iBoundary[0] < 2 ? 1-iBoundary[0] : 5-iBoundary[0];
+ std::swap( _faces[ iBoundary[1] ], _faces[iNear0] );
+ }
}
- if ( iFaceCont > 0 ) // continues faces found, set one by the other
+ else if ( iFaceCont > 0 ) // continues faces found
{
if ( iFaceCont != 1 )
std::swap( _faces[1], _faces[iFaceCont] );
if (_qfaces[1]) norm += _qfaces[1]->_normal;
return norm;
}
+ //================================================================================
+ /*!
+ * \brief Test link curvature taking into account size of faces
+ */
+ //================================================================================
+
+ bool TChainLink::IsStraight() const
+ {
+ bool isStraight = _qlink->IsStraight();
+ if ( isStraight && _qfaces[0] && !_qfaces[1] )
+ {
+ int i = _qfaces[0]->LinkIndex( _qlink );
+ int iOpp = ( i + 2 ) % _qfaces[0]->_sides.size();
+ gp_XYZ mid1 = _qlink->MiddlePnt();
+ gp_XYZ mid2 = _qfaces[0]->_sides[ iOpp ]->MiddlePnt();
+ double faceSize2 = (mid1-mid2).SquareModulus();
+ isStraight = _qlink->_nodeMove.SquareMagnitude() < 1/10./10. * faceSize2;
+ }
+ return isStraight;
+ }
+
//================================================================================
/*!
* \brief Move medium nodes of vertical links of pentahedrons adjacent by side faces
bndLinks1.insert( lnk->_qlink );
else
interLinks.insert( lnk->_qlink );
- isCurved = isCurved || !(*lnk)->IsStraight();
+ isCurved = isCurved || !lnk->IsStraight();
}
if ( !isCurved )
return; // no need to move
for ( linkIt = linkSet.begin(); linkIt != linksEnd; ++linkIt)
{
- if ( linkIt->IsBoundary() && !(*linkIt)->IsStraight() && linkIt->_qfaces[0])
+ if ( linkIt->IsBoundary() && !linkIt->IsStraight() && linkIt->_qfaces[0])
{
// move iff a boundary link is bent towards inside of a face (issue 0021084)
const QFace* face = linkIt->_qfaces[0];
void SMESH_MesherHelper::FixQuadraticElements(bool volumeOnly)
{
- // 0. Apply algorithm to solids or geom faces
+ // setenv NO_FixQuadraticElements to know if FixQuadraticElements() is guilty of bad conversion
+ if ( getenv("NO_FixQuadraticElements") )
+ return;
+
+ // 0. Apply algorithm to SOLIDs or FACEs
// ----------------------------------------------
if ( myShape.IsNull() ) {
if ( !myMesh->HasShapeToMesh() ) return;
faces.Add( f.Current() ); // in not meshed solid
}
else { // fix nodes in the solid and its faces
+#ifdef _DEBUG_
MSG("FIX SOLID " << nbSolids-- << " #" << GetMeshDS()->ShapeToIndex(s.Current()));
+#endif
SMESH_MesherHelper h(*myMesh);
h.SetSubShape( s.Current() );
h.FixQuadraticElements(false);
}
// fix nodes on geom faces
#ifdef _DEBUG_
- int nbfaces = faces.Extent();
+ int nbfaces = faces.Extent(); /*avoid "unused varianbles": */ nbfaces++, nbfaces--;
#endif
for ( TopTools_MapIteratorOfMapOfShape fIt( faces ); fIt.More(); fIt.Next() ) {
MSG("FIX FACE " << nbfaces-- << " #" << GetMeshDS()->ShapeToIndex(fIt.Key()));
SMESH_MesherHelper h(*myMesh);
h.SetSubShape( fIt.Key() );
h.FixQuadraticElements(true);
+ h.ToFixNodeParameters(true);
}
//perf_print_all_meters(1);
return;
bool isCurved = false;
//bool hasRectFaces = false;
//set<int> nbElemNodeSet;
+ SMDS_VolumeTool volTool;
+
+ TIDSortedNodeSet apexOfPyramid;
+ const int apexIndex = 4;
if ( elemType == SMDSAbs_Volume )
{
- SMDS_VolumeTool volTool;
while ( elemIt->more() ) // loop on volumes
{
const SMDS_MeshElement* vol = elemIt->next();
if ( !vol->IsQuadratic() || !volTool.Set( vol ))
- return; //continue;
+ return;
+ double volMinSize2 = -1.;
for ( int iF = 0; iF < volTool.NbFaces(); ++iF ) // loop on faces of volume
{
int nbN = volTool.NbFaceNodes( iF );
QLink link( faceNodes[iN], faceNodes[iN+2], faceNodes[iN+1] );
pLink = links.insert( link ).first;
faceLinks[ iN/2 ] = & *pLink;
- if ( !isCurved )
- isCurved = !link.IsStraight();
- if ( link.MediumPos() == SMDS_TOP_3DSPACE && !link.IsStraight() )
- return; // already fixed
+
+ if ( link.MediumPos() == SMDS_TOP_3DSPACE )
+ {
+ if ( !link.IsStraight() )
+ return; // already fixed
+ }
+ else if ( !isCurved )
+ {
+ if ( volMinSize2 < 0 ) volMinSize2 = volTool.MinLinearSize2();
+ isCurved = !isStraightLink( volMinSize2, link._nodeMove.SquareMagnitude() );
+ }
}
// store QFace
pFace = faces.insert( QFace( faceLinks )).first;
faceNodes[4],faceNodes[6] );
#endif
}
+ // collect pyramid apexes for further correction
+ if ( vol->NbCornerNodes() == 5 )
+ apexOfPyramid.insert( vol->GetNode( apexIndex ));
}
set< QLink >::iterator pLink = links.begin();
for ( ; pLink != links.end(); ++pLink )
return; // no curved edges of faces
// 3. Compute displacement of medium nodes
- // -------------------------------------
+ // ---------------------------------------
- // two loops on faces: the first is to treat boundary links, the second is for internal ones
+ // two loops on QFaces: the first is to treat boundary links, the second is for internal ones
TopLoc_Location loc;
// not treat boundary of volumic submesh
int isInside = ( elemType == SMDSAbs_Volume && volumeOnly ) ? 1 : 0;
for ( pFace = faces.begin(); pFace != faces.end(); ++pFace ) {
if ( bool(isInside) == pFace->IsBoundary() )
continue;
- for ( int dir = 0; dir < 2; ++dir ) // 2 directions of propagation from quadrangle
+ for ( int dir = 0; dir < 2; ++dir ) // 2 directions of propagation from the quadrangle
{
MSG( "CHAIN");
// make chain of links connected via continues faces
{
TChain& chain = chains[iC];
if ( chain.empty() ) continue;
- if ( chain.front()->IsStraight() && chain.back()->IsStraight() ) {
+ if ( chain.front().IsStraight() && chain.back().IsStraight() ) {
MSG("3D straight - ignore");
continue;
}
if ( chain.front()->MediumPos() > bndPos ||
- chain.back()->MediumPos() > bndPos ) {
+ chain.back() ->MediumPos() > bndPos ) {
MSG("Internal chain - ignore");
continue;
}
TopoDS_Face face;
bool checkUV = true;
- if ( !isInside ) {
- // compute node displacement of end links in parametric space of face
- const SMDS_MeshNode* nodeOnFace = (*(++chain.begin()))->_mediumNode;
+ if ( !isInside )
+ {
+ // compute node displacement of end links of chain in parametric space of face
+ TChainLink& linkOnFace = *(++chain.begin());
+ const SMDS_MeshNode* nodeOnFace = linkOnFace->_mediumNode;
TopoDS_Shape f = GetSubShapeByNode( nodeOnFace, GetMeshDS() );
if ( !f.IsNull() && f.ShapeType() == TopAbs_FACE )
{
( is1 ? move1 : move0 ).SetCoord( uvMove.X(), uvMove.Y(), 0 );
if ( !is1 ) // correct nodeOnFace for move1 (issue 0020919)
nodeOnFace = (*(++chain.rbegin()))->_mediumNode;
- isStraight[is1] = isStraightLink( (uv2-uv1).SquareModulus(),uvMove.SquareModulus());
+ isStraight[is1] = isStraightLink( (uv2-uv1).SquareModulus(),
+ 10 * uvMove.SquareModulus());
}
-// if ( move0.SquareMagnitude() < straightTol2 &&
-// move1.SquareMagnitude() < straightTol2 ) {
if ( isStraight[0] && isStraight[1] ) {
MSG("2D straight - ignore");
continue; // straight - no need to move nodes of internal links
}
+
+ // check if a chain is already fixed
+ gp_XY uvm = GetNodeUV( face, linkOnFace->_mediumNode, 0, &checkUV);
+ gp_XY uv1 = GetNodeUV( face, linkOnFace->node1(), nodeOnFace, &checkUV);
+ gp_XY uv2 = GetNodeUV( face, linkOnFace->node2(), nodeOnFace, &checkUV);
+ gp_XY uv12 = GetMiddleUV( surf, uv1, uv2);
+ if (( uvm - uv12 ).SquareModulus() > 1e-10 )
+ {
+ MSG("Already fixed - ignore");
+ continue;
+ }
}
}
gp_Trsf trsf;
}
// 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->MediumPnt() + pLink->Move();
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() );
}
}
-}
-//=======================================================================
-/*!
- * \brief Iterator on ancestors of the given type
- */
-//=======================================================================
+ //return;
-struct TAncestorsIterator : public SMDS_Iterator<const TopoDS_Shape*>
-{
- TopTools_ListIteratorOfListOfShape _ancIter;
- TopAbs_ShapeEnum _type;
- TopTools_MapOfShape _encountered;
- TAncestorsIterator( const TopTools_ListOfShape& ancestors, TopAbs_ShapeEnum type)
- : _ancIter( ancestors ), _type( type )
+ // issue 0020982
+ // Move the apex of pyramid together with the most curved link
+
+ TIDSortedNodeSet::iterator apexIt = apexOfPyramid.begin();
+ for ( ; apexIt != apexOfPyramid.end(); ++apexIt )
{
- if ( _ancIter.More() ) {
- if ( _ancIter.Value().ShapeType() != _type ) next();
- else _encountered.Add( _ancIter.Value() );
+ 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;
+ }
+ }
}
- }
- virtual bool more()
- {
- return _ancIter.More();
- }
- virtual const TopoDS_Shape* next()
- {
- const TopoDS_Shape* s = _ancIter.More() ? & _ancIter.Value() : 0;
- if ( _ancIter.More() )
- for ( _ancIter.Next(); _ancIter.More(); _ancIter.Next())
- if ( _ancIter.Value().ShapeType() == _type && _encountered.Add( _ancIter.Value() ))
- break;
- return s;
- }
-};
-//=======================================================================
-/*!
- * \brief Return iterator on ancestors of the given type
- */
-//=======================================================================
+ // move the apex
+ if ( maxMoveSize2 > 1e-20 )
+ {
+ apex += maxMove.XYZ();
+ GetMeshDS()->MoveNode( apex._node, apex.X(), apex.Y(), apex.Z());
-PShapeIteratorPtr SMESH_MesherHelper::GetAncestors(const TopoDS_Shape& shape,
- const SMESH_Mesh& mesh,
- TopAbs_ShapeEnum ancestorType)
-{
- return PShapeIteratorPtr( new TAncestorsIterator( mesh.GetAncestors(shape), ancestorType));
+ // 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());
+ }
+ }
+ }
}
+