-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2014 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
// 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.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "SMESH_Gen.hxx"
#include "SMESH_HypoFilter.hxx"
#include "SMESH_Mesh.hxx"
+#include "SMESH_MeshAlgos.hxx"
#include "SMESH_TypeDefs.hxx"
#include "SMESH_subMesh.hxx"
#include <algorithm>
#include <limits>
+#include "SMESH_ProxyMesh.hxx"
+#include "SMESH_MesherHelper.hxx"
using namespace std;
SMESH_Algo::SMESH_Algo (int hypId, int studyId, SMESH_Gen * gen)
: SMESH_Hypothesis(hypId, studyId, gen)
{
- //gen->_mapAlgo[hypId] = this;
-
+ _compatibleAllHypFilter = _compatibleNoAuxHypFilter = NULL;
_onlyUnaryInput = _requireDiscreteBoundary = _requireShape = true;
_quadraticMesh = _supportSubmeshes = false;
_error = COMPERR_OK;
SMESH_Algo::~SMESH_Algo()
{
+ delete _compatibleNoAuxHypFilter;
+ // delete _compatibleAllHypFilter; -- _compatibleNoAuxHypFilter does it!!!
}
//=============================================================================
{
_shapeType = (1 << TopAbs_VERTEX);
_type = ALGO_0D;
- //gen->_map0D_Algo[hypId] = this;
}
SMESH_1D_Algo::SMESH_1D_Algo(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_Algo(hypId, studyId, gen)
{
_shapeType = (1 << TopAbs_EDGE);
_type = ALGO_1D;
- //gen->_map1D_Algo[hypId] = this;
}
SMESH_2D_Algo::SMESH_2D_Algo(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_Algo(hypId, studyId, gen)
{
_shapeType = (1 << TopAbs_FACE);
_type = ALGO_2D;
- //gen->_map2D_Algo[hypId] = this;
}
SMESH_3D_Algo::SMESH_3D_Algo(int hypId, int studyId, SMESH_Gen* gen)
: SMESH_Algo(hypId, studyId, gen)
{
_shapeType = (1 << TopAbs_SOLID);
_type = ALGO_3D;
- //gen->_map3D_Algo[hypId] = this;
}
//=============================================================================
{
SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
me->_usedHypList.clear();
- SMESH_HypoFilter filter;
- if ( InitCompatibleHypoFilter( filter, ignoreAuxiliary ))
+ if ( const SMESH_HypoFilter* filter = GetCompatibleHypoFilter( ignoreAuxiliary ))
{
- aMesh.GetHypotheses( aShape, filter, me->_usedHypList, true );
+ aMesh.GetHypotheses( aShape, *filter, me->_usedHypList, true );
if ( ignoreAuxiliary && _usedHypList.size() > 1 )
me->_usedHypList.clear(); //only one compatible hypothesis allowed
}
{
SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
me->_appliedHypList.clear();
- SMESH_HypoFilter filter;
- if ( InitCompatibleHypoFilter( filter, ignoreAuxiliary ))
- aMesh.GetHypotheses( aShape, filter, me->_appliedHypList, false );
+ if ( const SMESH_HypoFilter* filter = GetCompatibleHypoFilter( ignoreAuxiliary ))
+ aMesh.GetHypotheses( aShape, *filter, me->_appliedHypList, false );
return _appliedHypList;
}
double SMESH_Algo::EdgeLength(const TopoDS_Edge & E)
{
double UMin = 0, UMax = 0;
- if (BRep_Tool::Degenerated(E))
- return 0;
TopLoc_Location L;
Handle(Geom_Curve) C = BRep_Tool::Curve(E, L, UMin, UMax);
+ if ( C.IsNull() )
+ return 0.;
GeomAdaptor_Curve AdaptCurve(C, UMin, UMax); //range is important for periodic curves
double length = GCPnts_AbscissaPoint::Length(AdaptCurve, UMin, UMax);
return length;
return false;
SMESHDS_SubMesh * eSubMesh = theMesh->MeshElements( theEdge );
- if ( !eSubMesh || !eSubMesh->GetElements()->more() )
+ if ( !eSubMesh || ( eSubMesh->NbElements()==0 && eSubMesh->NbNodes() == 0))
return false; // edge is not meshed
int nbNodes = 0;
//================================================================================
/*!
- * \brief Make filter recognize only compatible hypotheses
- * \param theFilter - the filter to initialize
- * \param ignoreAuxiliary - make filter ignore compatible auxiliary hypotheses
+ * \brief Returns the filter recognizing only compatible hypotheses
+ * \param ignoreAuxiliary - make filter ignore auxiliary hypotheses
+ * \retval SMESH_HypoFilter* - the filter that can be NULL
*/
//================================================================================
-bool SMESH_Algo::InitCompatibleHypoFilter( SMESH_HypoFilter & theFilter,
- const bool ignoreAuxiliary) const
+const SMESH_HypoFilter*
+SMESH_Algo::GetCompatibleHypoFilter(const bool ignoreAuxiliary) const
{
if ( !_compatibleHypothesis.empty() )
{
- theFilter.Init( theFilter.HasName( _compatibleHypothesis[0] ));
- for ( int i = 1; i < _compatibleHypothesis.size(); ++i )
- theFilter.Or( theFilter.HasName( _compatibleHypothesis[ i ] ));
-
- if ( ignoreAuxiliary )
- theFilter.AndNot( theFilter.IsAuxiliary() );
-
- return true;
+ if ( !_compatibleAllHypFilter )
+ {
+ SMESH_HypoFilter* filter = new SMESH_HypoFilter();
+ filter->Init( filter->HasName( _compatibleHypothesis[0] ));
+ for ( int i = 1; i < _compatibleHypothesis.size(); ++i )
+ filter->Or( filter->HasName( _compatibleHypothesis[ i ] ));
+
+ SMESH_HypoFilter* filterNoAux = new SMESH_HypoFilter( filter );
+ filterNoAux->AndNot( filterNoAux->IsAuxiliary() );
+
+ // _compatibleNoAuxHypFilter will detele _compatibleAllHypFilter!!!
+ SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
+ me->_compatibleAllHypFilter = filter;
+ me->_compatibleNoAuxHypFilter = filterNoAux;
+ }
+ return ignoreAuxiliary ? _compatibleNoAuxHypFilter : _compatibleAllHypFilter;
}
- return false;
+ return 0;
}
//================================================================================
Standard_Real tol = BRep_Tool::Tolerance( V );
Standard_Real angTol = 2e-3;
try {
-#if OCC_VERSION_LARGE > 0x06010000
OCC_CATCH_SIGNALS;
-#endif
return BRepLProp::Continuity(C1, C2, u1, u2, tol, angTol);
}
catch (Standard_Failure) {
return GeomAbs_C0;
}
+//================================================================================
+/*!
+ * \brief Return true if an edge can be considered straight
+ */
+//================================================================================
+
+bool SMESH_Algo::IsStraight( const TopoDS_Edge & E,
+ const bool degenResult)
+{
+ {
+ double f,l;
+ if ( BRep_Tool::Curve( E, f, l ).IsNull())
+ return degenResult;
+ }
+ BRepAdaptor_Curve curve( E );
+ switch( curve.GetType() )
+ {
+ case GeomAbs_Line:
+ return true;
+ case GeomAbs_Circle:
+ case GeomAbs_Ellipse:
+ case GeomAbs_Hyperbola:
+ case GeomAbs_Parabola:
+ return false;
+ // case GeomAbs_BezierCurve:
+ // case GeomAbs_BSplineCurve:
+ // case GeomAbs_OtherCurve:
+ default:;
+ }
+ const double f = curve.FirstParameter();
+ const double l = curve.LastParameter();
+ const gp_Pnt pf = curve.Value( f );
+ const gp_Pnt pl = curve.Value( l );
+ const gp_Vec v1( pf, pl );
+ const double v1Len = v1.Magnitude();
+ if ( v1Len < std::numeric_limits< double >::min() )
+ return false; // E seems closed
+ const double tol = Min( 10 * curve.Tolerance(), v1Len * 1e-2 );
+ const int nbSamples = 7;
+ for ( int i = 0; i < nbSamples; ++i )
+ {
+ const double r = ( i + 1 ) / nbSamples;
+ const gp_Pnt pi = curve.Value( f * r + l * ( 1 - r ));
+ const gp_Vec vi( pf, pi );
+ const double h = 0.5 * v1.Crossed( vi ).Magnitude() / v1Len;
+ if ( h > tol )
+ return false;
+ }
+ return true;
+}
+
+//================================================================================
+/*!
+ * \brief Return true if an edge has no 3D curve
+ */
+//================================================================================
+
+bool SMESH_Algo::isDegenerated( const TopoDS_Edge & E )
+{
+ double f,l;
+ TopLoc_Location loc;
+ Handle(Geom_Curve) C = BRep_Tool::Curve( E, loc, f,l );
+ return C.IsNull();
+}
+
//================================================================================
/*!
* \brief Return the node built on a vertex
* \param V - the vertex
* \param meshDS - mesh
* \retval const SMDS_MeshNode* - found node or NULL
+ * \sa SMESH_MesherHelper::GetSubShapeByNode( const SMDS_MeshNode*, SMESHDS_Mesh* )
*/
//================================================================================
}
+//================================================================================
+/*!
+ * Method in which an algorithm generating a structured mesh
+ * fixes positions of in-face nodes after there movement
+ * due to insertion of viscous layers.
+ */
+//================================================================================
+
+bool SMESH_2D_Algo::FixInternalNodes(const SMESH_ProxyMesh& mesh,
+ const TopoDS_Face& face)
+{
+ const SMESHDS_SubMesh* smDS = mesh.GetSubMesh(face);
+ if ( !smDS || smDS->NbElements() < 1 )
+ return false;
+
+ SMESH_MesherHelper helper( *mesh.GetMesh() );
+
+ // get all faces from a proxy sub-mesh
+ typedef SMDS_StdIterator< const SMDS_MeshElement*, SMDS_ElemIteratorPtr > TIterator;
+ TIDSortedElemSet allFaces( TIterator( smDS->GetElements() ), TIterator() );
+ TIDSortedElemSet avoidSet, firstRowQuads;
+
+ // indices of nodes to pass to a neighbour quad using SMESH_MeshAlgos::FindFaceInSet()
+ int iN1, iN2;
+
+ // get two first rows of nodes by passing through the first row of faces
+ vector< vector< const SMDS_MeshNode* > > nodeRows;
+ int iRow1 = 0, iRow2 = 1;
+ const SMDS_MeshElement* quad;
+ {
+ // look for a corner quadrangle and it's corner node
+ const SMDS_MeshElement* cornerQuad = 0;
+ int cornerNodeInd = -1;
+ SMDS_ElemIteratorPtr fIt = smDS->GetElements();
+ while ( !cornerQuad && fIt->more() )
+ {
+ cornerQuad = fIt->next();
+ if ( cornerQuad->NbCornerNodes() != 4 )
+ return false;
+ SMDS_NodeIteratorPtr nIt = cornerQuad->nodeIterator();
+ for ( int i = 0; i < 4; ++i )
+ {
+ int nbInverseQuads = 0;
+ SMDS_ElemIteratorPtr fIt = nIt->next()->GetInverseElementIterator(SMDSAbs_Face);
+ while ( fIt->more() )
+ nbInverseQuads += allFaces.count( fIt->next() );
+ if ( nbInverseQuads == 1 )
+ cornerNodeInd = i, i = 4;
+ }
+ if ( cornerNodeInd < 0 )
+ cornerQuad = 0;
+ }
+ if ( !cornerQuad || cornerNodeInd < 0 )
+ return false;
+
+ iN1 = helper.WrapIndex( cornerNodeInd + 1, 4 );
+ iN2 = helper.WrapIndex( cornerNodeInd + 2, 4 );
+ int iN3 = helper.WrapIndex( cornerNodeInd + 3, 4 );
+ nodeRows.resize(2);
+ nodeRows[iRow1].push_back( cornerQuad->GetNode( cornerNodeInd ));
+ nodeRows[iRow1].push_back( cornerQuad->GetNode( iN1 ));
+ nodeRows[iRow2].push_back( cornerQuad->GetNode( iN3 ));
+ nodeRows[iRow2].push_back( cornerQuad->GetNode( iN2 ));
+ firstRowQuads.insert( cornerQuad );
+
+ // pass through the rest quads in a face row
+ quad = cornerQuad;
+ while ( quad )
+ {
+ avoidSet.clear();
+ avoidSet.insert( quad );
+ if (( quad = SMESH_MeshAlgos::FindFaceInSet( nodeRows[iRow1].back(),
+ nodeRows[iRow2].back(),
+ allFaces, avoidSet, &iN1, &iN2)))
+ {
+ nodeRows[iRow1].push_back( quad->GetNode( helper.WrapIndex( iN2 + 2, 4 )));
+ nodeRows[iRow2].push_back( quad->GetNode( helper.WrapIndex( iN1 + 2, 4 )));
+ if ( quad->NbCornerNodes() != 4 )
+ return false;
+ }
+ }
+ if ( nodeRows[iRow1].size() < 3 )
+ return true; // there is nothing to fix
+ }
+
+ nodeRows.reserve( smDS->NbElements() / nodeRows[iRow1].size() );
+
+ // get the rest node rows
+ while ( true )
+ {
+ ++iRow1, ++iRow2;
+
+ // get the first quad in the next face row
+ if (( quad = SMESH_MeshAlgos::FindFaceInSet( nodeRows[iRow1][0],
+ nodeRows[iRow1][1],
+ allFaces, /*avoid=*/firstRowQuads,
+ &iN1, &iN2)))
+ {
+ if ( quad->NbCornerNodes() != 4 )
+ return false;
+ nodeRows.resize( iRow2+1 );
+ nodeRows[iRow2].push_back( quad->GetNode( helper.WrapIndex( iN2 + 2, 4 )));
+ nodeRows[iRow2].push_back( quad->GetNode( helper.WrapIndex( iN1 + 2, 4 )));
+ firstRowQuads.insert( quad );
+ }
+ else
+ {
+ break; // no more rows
+ }
+
+ // pass through the rest quads in a face row
+ while ( quad )
+ {
+ avoidSet.clear();
+ avoidSet.insert( quad );
+ if (( quad = SMESH_MeshAlgos::FindFaceInSet( nodeRows[iRow1][ nodeRows[iRow2].size()-1 ],
+ nodeRows[iRow2].back(),
+ allFaces, avoidSet, &iN1, &iN2)))
+ {
+ if ( quad->NbCornerNodes() != 4 )
+ return false;
+ nodeRows[iRow2].push_back( quad->GetNode( helper.WrapIndex( iN1 + 2, 4 )));
+ }
+ }
+ if ( nodeRows[iRow1].size() != nodeRows[iRow2].size() )
+ return false;
+ }
+ if ( nodeRows.size() < 3 )
+ return true; // there is nothing to fix
+
+ // get params of the first (bottom) and last (top) node rows
+ UVPtStructVec uvB( nodeRows[0].size() ), uvT( nodeRows[0].size() );
+ for ( int isBot = 0; isBot < 2; ++isBot )
+ {
+ UVPtStructVec & uvps = isBot ? uvB : uvT;
+ vector< const SMDS_MeshNode* >& nodes = nodeRows[ isBot ? 0 : nodeRows.size()-1 ];
+ for ( size_t i = 0; i < nodes.size(); ++i )
+ {
+ uvps[i].node = nodes[i];
+ gp_XY uv = helper.GetNodeUV( face, uvps[i].node );
+ uvps[i].u = uv.Coord(1);
+ uvps[i].v = uv.Coord(2);
+ uvps[i].x = 0;
+ }
+ // calculate x (normalized param)
+ for ( size_t i = 1; i < nodes.size(); ++i )
+ uvps[i].x = uvps[i-1].x + SMESH_TNodeXYZ( uvps[i-1].node ).Distance( uvps[i].node );
+ for ( size_t i = 1; i < nodes.size(); ++i )
+ uvps[i].x /= uvps.back().x;
+ }
+
+ // get params of the left and right node rows
+ UVPtStructVec uvL( nodeRows.size() ), uvR( nodeRows.size() );
+ for ( int isLeft = 0; isLeft < 2; ++isLeft )
+ {
+ UVPtStructVec & uvps = isLeft ? uvL : uvR;
+ const int iCol = isLeft ? 0 : nodeRows[0].size() - 1;
+ for ( size_t i = 0; i < nodeRows.size(); ++i )
+ {
+ uvps[i].node = nodeRows[i][iCol];
+ gp_XY uv = helper.GetNodeUV( face, uvps[i].node );
+ uvps[i].u = uv.Coord(1);
+ uvps[i].v = uv.Coord(2);
+ uvps[i].y = 0;
+ }
+ // calculate y (normalized param)
+ for ( size_t i = 1; i < nodeRows.size(); ++i )
+ uvps[i].y = uvps[i-1].y + SMESH_TNodeXYZ( uvps[i-1].node ).Distance( uvps[i].node );
+ for ( size_t i = 1; i < nodeRows.size(); ++i )
+ uvps[i].y /= uvps.back().y;
+ }
+
+ // update node coordinates
+ SMESHDS_Mesh* meshDS = mesh.GetMeshDS();
+ Handle(Geom_Surface) S = BRep_Tool::Surface( face );
+ gp_XY a0 ( uvB.front().u, uvB.front().v );
+ gp_XY a1 ( uvB.back().u, uvB.back().v );
+ gp_XY a2 ( uvT.back().u, uvT.back().v );
+ gp_XY a3 ( uvT.front().u, uvT.front().v );
+ for ( size_t iRow = 1; iRow < nodeRows.size()-1; ++iRow )
+ {
+ gp_XY p1 ( uvR[ iRow ].u, uvR[ iRow ].v );
+ gp_XY p3 ( uvL[ iRow ].u, uvL[ iRow ].v );
+ const double y0 = uvL[ iRow ].y;
+ const double y1 = uvR[ iRow ].y;
+ for ( size_t iCol = 1; iCol < nodeRows[0].size()-1; ++iCol )
+ {
+ gp_XY p0 ( uvB[ iCol ].u, uvB[ iCol ].v );
+ gp_XY p2 ( uvT[ iCol ].u, uvT[ iCol ].v );
+ const double x0 = uvB[ iCol ].x;
+ const double x1 = uvT[ iCol ].x;
+ double x = (x0 + y0 * (x1 - x0)) / (1 - (y1 - y0) * (x1 - x0));
+ double y = y0 + x * (y1 - y0);
+ gp_XY uv = helper.calcTFI( x, y, a0,a1,a2,a3, p0,p1,p2,p3 );
+ gp_Pnt p = S->Value( uv.Coord(1), uv.Coord(2));
+ const SMDS_MeshNode* n = nodeRows[iRow][iCol];
+ meshDS->MoveNode( n, p.X(), p.Y(), p.Z() );
+ if ( SMDS_FacePosition* pos = dynamic_cast< SMDS_FacePosition*>( n->GetPosition() ))
+ pos->SetParameters( uv.Coord(1), uv.Coord(2) );
+ }
+ }
+ return true;
+}