-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2021 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
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Algo.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH
#include "SMESH_TypeDefs.hxx"
#include "SMESH_subMesh.hxx"
-#include <Basics_OCCTVersion.hxx>
-
#include <BRepAdaptor_Curve.hxx>
#include <BRepLProp.hxx>
#include <BRep_Tool.hxx>
bool SMESH_Algo::Features::IsCompatible( const SMESH_Algo::Features& algo2 ) const
{
if ( _dim > algo2._dim ) return algo2.IsCompatible( *this );
- // algo2 is of highter dimension
+ // algo2 is of higher dimension
if ( _outElemTypes.empty() || algo2._inElemTypes.empty() )
return false;
bool compatible = true;
*/
//=============================================================================
-SMESH_Algo::SMESH_Algo (int hypId, int studyId, SMESH_Gen * gen)
- : SMESH_Hypothesis(hypId, studyId, gen)
+SMESH_Algo::SMESH_Algo (int hypId, SMESH_Gen * gen)
+ : SMESH_Hypothesis(hypId, gen)
{
_compatibleAllHypFilter = _compatibleNoAuxHypFilter = NULL;
_onlyUnaryInput = _requireDiscreteBoundary = _requireShape = true;
*/
//=============================================================================
-SMESH_0D_Algo::SMESH_0D_Algo(int hypId, int studyId, SMESH_Gen* gen)
- : SMESH_Algo(hypId, studyId, gen)
+SMESH_0D_Algo::SMESH_0D_Algo(int hypId, SMESH_Gen* gen)
+ : SMESH_Algo(hypId, gen)
{
_shapeType = (1 << TopAbs_VERTEX);
_type = ALGO_0D;
}
-SMESH_1D_Algo::SMESH_1D_Algo(int hypId, int studyId, SMESH_Gen* gen)
- : SMESH_Algo(hypId, studyId, gen)
+SMESH_1D_Algo::SMESH_1D_Algo(int hypId, SMESH_Gen* gen)
+ : SMESH_Algo(hypId, gen)
{
_shapeType = (1 << TopAbs_EDGE);
_type = ALGO_1D;
}
-SMESH_2D_Algo::SMESH_2D_Algo(int hypId, int studyId, SMESH_Gen* gen)
- : SMESH_Algo(hypId, studyId, gen)
+SMESH_2D_Algo::SMESH_2D_Algo(int hypId, SMESH_Gen* gen)
+ : SMESH_Algo(hypId, gen)
{
_shapeType = (1 << TopAbs_FACE);
_type = ALGO_2D;
}
-SMESH_3D_Algo::SMESH_3D_Algo(int hypId, int studyId, SMESH_Gen* gen)
- : SMESH_Algo(hypId, studyId, gen)
+SMESH_3D_Algo::SMESH_3D_Algo(int hypId, SMESH_Gen* gen)
+ : SMESH_Algo(hypId, gen)
{
_shapeType = (1 << TopAbs_SOLID);
_type = ALGO_3D;
//=============================================================================
/*!
- * Usually an algoritm has nothing to save
+ * Usually an algorithm has nothing to save
*/
//=============================================================================
const bool ignoreAuxiliary) const
{
SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
+
+ std::list<const SMESHDS_Hypothesis *> savedHyps; // don't delete the list if
+ savedHyps.swap( me->_usedHypList ); // it does not change (#16578)
+
me->_usedHypList.clear();
+ me->_assigedShapeList.clear();
if ( const SMESH_HypoFilter* filter = GetCompatibleHypoFilter( ignoreAuxiliary ))
{
- aMesh.GetHypotheses( aShape, *filter, me->_usedHypList, true );
+ aMesh.GetHypotheses( aShape, *filter, me->_usedHypList, true, & me->_assigedShapeList );
if ( ignoreAuxiliary && _usedHypList.size() > 1 )
+ {
me->_usedHypList.clear(); //only one compatible hypothesis allowed
+ me->_assigedShapeList.clear();
+ }
}
+ if ( _usedHypList == savedHyps )
+ savedHyps.swap( me->_usedHypList );
+
return _usedHypList;
}
-//=============================================================================
+//================================================================================
/*!
- * List the relevant hypothesis associated to the shape. Relevant hypothesis
- * have a name (type) listed in the algorithm. Hypothesis associated to
- * father shape -are not- taken into account (see GetUsedHypothesis)
+ * Return sub-shape to which hypotheses returned by GetUsedHypothesis() are assigned
*/
-//=============================================================================
+//================================================================================
-const list<const SMESHDS_Hypothesis *> &
-SMESH_Algo::GetAppliedHypothesis(SMESH_Mesh & aMesh,
- const TopoDS_Shape & aShape,
- const bool ignoreAuxiliary) const
+const std::list < TopoDS_Shape > & SMESH_Algo::GetAssignedShapes() const
{
- SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
- me->_appliedHypList.clear();
- if ( const SMESH_HypoFilter* filter = GetCompatibleHypoFilter( ignoreAuxiliary ))
- aMesh.GetHypotheses( aShape, *filter, me->_appliedHypList, false );
-
- return _appliedHypList;
+ return _assigedShapeList;
}
//=============================================================================
SMDS_NodeIteratorPtr nIt = eSubMesh->GetNodes();
while ( nIt->more() )
{
- const SMDS_MeshNode* node = nIt->next();
- const SMDS_PositionPtr& pos = node->GetPosition();
- if ( pos->GetTypeOfPosition() != SMDS_TOP_EDGE )
+ SMDS_EdgePositionPtr epos = nIt->next()->GetPosition();
+ if ( !epos )
return false;
- const SMDS_EdgePosition* epos =
- static_cast<const SMDS_EdgePosition*>(node->GetPosition());
if ( !paramSet.insert( epos->GetUParameter() ).second )
return false; // equal parameters
}
bool SMESH_Algo::GetSortedNodesOnEdge(const SMESHDS_Mesh* theMesh,
const TopoDS_Edge& theEdge,
const bool ignoreMediumNodes,
- map< double, const SMDS_MeshNode* > & theNodes)
+ map< double, const SMDS_MeshNode* > & theNodes,
+ const SMDSAbs_ElementType typeToCheck)
{
theNodes.clear();
return false;
SMESHDS_SubMesh * eSubMesh = theMesh->MeshElements( theEdge );
- if ( !eSubMesh || ( eSubMesh->NbElements()==0 && eSubMesh->NbNodes() == 0))
+ if ( !eSubMesh || ( eSubMesh->NbElements() == 0 && eSubMesh->NbNodes() == 0))
return false; // edge is not meshed
int nbNodes = 0;
while ( nIt->more() )
{
const SMDS_MeshNode* node = nIt->next();
- if ( ignoreMediumNodes ) {
- SMDS_ElemIteratorPtr elemIt = node->GetInverseElementIterator();
- if ( elemIt->more() && elemIt->next()->IsMediumNode( node ))
- continue;
- }
- const SMDS_PositionPtr& pos = node->GetPosition();
- if ( pos->GetTypeOfPosition() != SMDS_TOP_EDGE )
+ if ( ignoreMediumNodes && SMESH_MesherHelper::IsMedium( node, typeToCheck ))
+ continue;
+ SMDS_EdgePositionPtr epos = node->GetPosition();
+ if ( ! epos )
return false;
- const SMDS_EdgePosition* epos =
- static_cast<const SMDS_EdgePosition*>(node->GetPosition());
theNodes.insert( theNodes.end(), make_pair( epos->GetUParameter(), node ));
- //MESSAGE("U " << epos->GetUParameter() << " ID " << node->GetID());
++nbNodes;
}
}
// add vertex nodes
TopoDS_Vertex v1, v2;
TopExp::Vertices(theEdge, v1, v2);
- const SMDS_MeshNode* n1 = VertexNode( v1, (SMESHDS_Mesh*) theMesh );
- const SMDS_MeshNode* n2 = VertexNode( v2, (SMESHDS_Mesh*) theMesh );
- //MESSAGE("Vertices ID " << n1->GetID() << " " << n2->GetID());
+ const SMDS_MeshNode* n1 = VertexNode( v1, eSubMesh, 0 );
+ const SMDS_MeshNode* n2 = VertexNode( v2, eSubMesh, 0 );
+ const SMDS_MeshNode* nEnd[2] = { nbNodes ? theNodes.begin()->second : 0,
+ nbNodes ? theNodes.rbegin()->second : 0 };
Standard_Real f, l;
BRep_Tool::Range(theEdge, f, l);
if ( v1.Orientation() != TopAbs_FORWARD )
std::swap( f, l );
- if ( n1 && ++nbNodes )
+ if ( n1 && n1 != nEnd[0] && n1 != nEnd[1] && ++nbNodes )
theNodes.insert( make_pair( f, n1 ));
- if ( n2 && ++nbNodes )
+ if ( n2 && n2 != nEnd[0] && n2 != nEnd[1] && ++nbNodes )
theNodes.insert( make_pair( l, n2 ));
- return theNodes.size() == nbNodes;
+ return (int)theNodes.size() == nbNodes;
}
//================================================================================
{
SMESH_HypoFilter* filter = new SMESH_HypoFilter();
filter->Init( filter->HasName( _compatibleHypothesis[0] ));
- for ( int i = 1; i < _compatibleHypothesis.size(); ++i )
+ for ( size_t i = 1; i < _compatibleHypothesis.size(); ++i )
filter->Or( filter->HasName( _compatibleHypothesis[ i ] ));
SMESH_HypoFilter* filterNoAux = new SMESH_HypoFilter( filter );
*/
//================================================================================
-GeomAbs_Shape SMESH_Algo::Continuity(TopoDS_Edge E1,
- TopoDS_Edge E2)
+GeomAbs_Shape SMESH_Algo::Continuity(const TopoDS_Edge& theE1,
+ const TopoDS_Edge& theE2)
{
- //E1.Orientation(TopAbs_FORWARD), E2.Orientation(TopAbs_FORWARD); // avoid pb with internal edges
+ // avoid pb with internal edges
+ TopoDS_Edge E1 = theE1, E2 = theE2;
if (E1.Orientation() > TopAbs_REVERSED) // INTERNAL
E1.Orientation( TopAbs_FORWARD );
if (E2.Orientation() > TopAbs_REVERSED) // INTERNAL
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) {
+ catch (Standard_Failure&) {
}
return GeomAbs_C0;
}
case GeomAbs_Hyperbola:
case GeomAbs_Parabola:
return false;
- // case GeomAbs_BezierCurve:
- // case GeomAbs_BSplineCurve:
- // case GeomAbs_OtherCurve:
+ // 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() )
+
+ // evaluate how far from a straight line connecting the curve ends
+ // stand internal points of the curve
+ double f = curve.FirstParameter();
+ double l = curve.LastParameter();
+ gp_Pnt pf = curve.Value( f );
+ gp_Pnt pl = curve.Value( l );
+ gp_Vec lineVec( pf, pl );
+ double lineLen2 = lineVec.SquareMagnitude();
+ if ( lineLen2 < std::numeric_limits< double >::min() )
return false; // E seems closed
- const double tol = Min( 10 * curve.Tolerance(), v1Len * 1e-2 );
- const int nbSamples = 7;
+
+ double edgeTol = 10 * curve.Tolerance();
+ double lenTol2 = lineLen2 * 1e-4;
+ double tol2 = Min( edgeTol * edgeTol, lenTol2 );
+
+ const double 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 )
+ double r = ( i + 1 ) / nbSamples;
+ gp_Pnt pi = curve.Value( f * r + l * ( 1 - r ));
+ gp_Vec vi( pf, pi );
+ double h2 = lineVec.Crossed( vi ).SquareMagnitude() / lineLen2;
+ if ( h2 > tol2 )
return false;
}
return true;
*/
//================================================================================
-bool SMESH_Algo::isDegenerated( const TopoDS_Edge & E )
+bool SMESH_Algo::isDegenerated( const TopoDS_Edge & E, const bool checkLength )
{
+ if ( checkLength )
+ return EdgeLength( E ) == 0;
double f,l;
TopLoc_Location loc;
Handle(Geom_Curve) C = BRep_Tool::Curve( E, loc, f,l );
return 0;
}
+//=======================================================================
+/*!
+ * \brief Return the node built on a vertex.
+ * A node moved to other geometry by MergeNodes() is also returned.
+ * \param V - the vertex
+ * \param mesh - mesh
+ * \retval const SMDS_MeshNode* - found node or NULL
+ */
+//=======================================================================
+
+const SMDS_MeshNode* SMESH_Algo::VertexNode(const TopoDS_Vertex& V,
+ const SMESH_Mesh* mesh)
+{
+ const SMDS_MeshNode* node = VertexNode( V, mesh->GetMeshDS() );
+
+ if ( !node && mesh->HasModificationsToDiscard() )
+ {
+ PShapeIteratorPtr edgeIt = SMESH_MesherHelper::GetAncestors( V, *mesh, TopAbs_EDGE );
+ while ( const TopoDS_Shape* edge = edgeIt->next() )
+ if ( SMESHDS_SubMesh* edgeSM = mesh->GetMeshDS()->MeshElements( *edge ))
+ if ( edgeSM->NbElements() > 0 )
+ return VertexNode( V, edgeSM, mesh, /*checkV=*/false );
+ }
+ return node;
+}
+
+//=======================================================================
+/*!
+ * \brief Return the node built on a vertex.
+ * A node moved to other geometry by MergeNodes() is also returned.
+ * \param V - the vertex
+ * \param edgeSM - sub-mesh of a meshed EDGE sharing the vertex
+ * \param checkV - if \c true, presence of a node on the vertex is checked
+ * \retval const SMDS_MeshNode* - found node or NULL
+ */
+//=======================================================================
+
+const SMDS_MeshNode* SMESH_Algo::VertexNode(const TopoDS_Vertex& V,
+ const SMESHDS_SubMesh* edgeSM,
+ const SMESH_Mesh* mesh,
+ const bool checkV)
+{
+ const SMDS_MeshNode* node = checkV ? VertexNode( V, edgeSM->GetParent() ) : 0;
+
+ if ( !node && edgeSM )
+ {
+ // find nodes not shared by mesh segments
+ typedef set< const SMDS_MeshNode* > TNodeSet;
+ typedef map< const SMDS_MeshNode*, const SMDS_MeshNode* > TNodeMap;
+ TNodeMap notSharedNodes;
+ TNodeSet otherShapeNodes;
+ vector< const SMDS_MeshNode* > segNodes(3);
+ SMDS_ElemIteratorPtr segIt = edgeSM->GetElements();
+ while ( segIt->more() )
+ {
+ const SMDS_MeshElement* seg = segIt->next();
+ if ( seg->GetType() != SMDSAbs_Edge )
+ return node;
+ segNodes.assign( seg->begin_nodes(), seg->end_nodes() );
+ for ( int i = 0; i < 2; ++i )
+ {
+ const SMDS_MeshNode* n1 = segNodes[i];
+ const SMDS_MeshNode* n2 = segNodes[1-i];
+ pair<TNodeMap::iterator, bool> it2new = notSharedNodes.insert( make_pair( n1, n2 ));
+ if ( !it2new.second ) // n encounters twice
+ notSharedNodes.erase( it2new.first );
+ if ( n1->getshapeId() != edgeSM->GetID() )
+ otherShapeNodes.insert( n1 );
+ }
+ }
+ if ( otherShapeNodes.size() == 1 && notSharedNodes.empty() ) // a closed EDGE
+ return *otherShapeNodes.begin();
+
+ if ( notSharedNodes.size() == 2 ) // two end nodes found
+ {
+ SMESHDS_Mesh* meshDS = edgeSM->GetParent();
+ const TopoDS_Shape& E = meshDS->IndexToShape( edgeSM->GetID() );
+ if ( E.IsNull() || E.ShapeType() != TopAbs_EDGE )
+ return node;
+ const SMDS_MeshNode* n1 = notSharedNodes.begin ()->first;
+ const SMDS_MeshNode* n2 = notSharedNodes.rbegin()->first;
+ TopoDS_Shape S1 = SMESH_MesherHelper::GetSubShapeByNode( n1, meshDS );
+ if ( S1.ShapeType() == TopAbs_VERTEX && SMESH_MesherHelper::IsSubShape( S1, E ))
+ return n2;
+ TopoDS_Shape S2 = SMESH_MesherHelper::GetSubShapeByNode( n2, meshDS );
+ if ( S2.ShapeType() == TopAbs_VERTEX && SMESH_MesherHelper::IsSubShape( S2, E ))
+ return n1;
+ if ( edgeSM->NbElements() <= 2 || !mesh ) // one-two segments
+ {
+ gp_Pnt pV = BRep_Tool::Pnt( V );
+ double dist1 = pV.SquareDistance( SMESH_TNodeXYZ( n1 ));
+ double dist2 = pV.SquareDistance( SMESH_TNodeXYZ( n2 ));
+ return dist1 < dist2 ? n1 : n2;
+ }
+ if ( mesh )
+ {
+ SMESH_MesherHelper helper( const_cast<SMESH_Mesh&>( *mesh ));
+ const SMDS_MeshNode* n1i = notSharedNodes.begin ()->second;
+ const SMDS_MeshNode* n2i = notSharedNodes.rbegin()->second;
+ const TopoDS_Edge& edge = TopoDS::Edge( E );
+ bool posOK = true;
+ double pos1 = helper.GetNodeU( edge, n1i, n2i, &posOK );
+ double pos2 = helper.GetNodeU( edge, n2i, n1i, &posOK );
+ double posV = BRep_Tool::Parameter( V, edge );
+ if ( Abs( pos1 - posV ) < Abs( pos2 - posV )) return n1;
+ else return n2;
+ }
+ }
+ }
+ return node;
+}
+
//=======================================================================
//function : GetMeshError
//purpose : Finds topological errors of a sub-mesh
if ( !fIt->more() )
return MEr_EMPTY;
- // We check that olny links on EDGEs encouter once, the rest links, twice
+ // We check that only links on EDGEs encounter once, the rest links, twice
set< SMESH_TLink > links;
while ( fIt->more() )
{
return error( COMPERR_BAD_INPUT_MESH, "Mesh built on shape expected");
}
+//=======================================================================
+//function : IsApplicableToShape
+//purpose : Return true if the algorithm can mesh a given shape
+//=======================================================================
+
+bool SMESH_Algo::IsApplicableToShape(const TopoDS_Shape & /*shape*/, bool /*toCheckAll*/) const
+{
+ return true;
+}
+
//=======================================================================
//function : CancelCompute
//purpose : Sets _computeCanceled to true. It's usage depends on
if ( error ) {
_error = error->myName;
_comment = error->myComment;
- _badInputElements = error->myBadElements;
+ if ( error->HasBadElems() )
+ {
+ SMESH_BadInputElements* badElems = static_cast<SMESH_BadInputElements*>( error.get() );
+ _badInputElements = badElems->GetElements();
+ _mesh = badElems->GetMesh();
+ }
return error->IsOK();
}
return true;
SMESH_ComputeErrorPtr SMESH_Algo::GetComputeError() const
{
- SMESH_ComputeErrorPtr err = SMESH_ComputeError::New( _error, _comment, this );
- // hope this method is called by only SMESH_subMesh after this->Compute()
- err->myBadElements.splice( err->myBadElements.end(),
- (list<const SMDS_MeshElement*>&) _badInputElements );
- return err;
+ if ( !_badInputElements.empty() && _mesh )
+ {
+ SMESH_BadInputElements* err = new SMESH_BadInputElements( _mesh, _error, _comment, this );
+ // hope this method is called by only SMESH_subMesh after this->Compute()
+ err->myBadElements.splice( err->myBadElements.end(),
+ (list<const SMDS_MeshElement*>&) _badInputElements );
+ return SMESH_ComputeErrorPtr( err );
+ }
+ return SMESH_ComputeError::New( _error, _comment, this );
}
//================================================================================
{
_error = COMPERR_OK;
_comment.clear();
- list<const SMDS_MeshElement*>::iterator elem = _badInputElements.begin();
- for ( ; elem != _badInputElements.end(); ++elem )
- if ( (*elem)->GetID() < 1 )
- delete *elem;
+ for ( const SMDS_MeshElement* & elem : _badInputElements )
+ if ( !elem->IsNull() && elem->GetID() < 1 )
+ delete elem;
_badInputElements.clear();
+ _mesh = 0;
_computeCanceled = false;
_progressTic = 0;
SMDS_ElemIteratorPtr eIt = sm->GetElements();
while ( eIt->more() ) addBadInputElement( eIt->next() );
}
+ _mesh = sm->GetParent();
}
}
*/
//=============================================================================
-int SMESH_Algo::NumberOfPoints(SMESH_Mesh& aMesh, const TopoDS_Wire& W)
+smIdType SMESH_Algo::NumberOfPoints(SMESH_Mesh& aMesh, const TopoDS_Wire& W)
{
- int nbPoints = 0;
+ smIdType nbPoints = 0;
for (TopExp_Explorer exp(W,TopAbs_EDGE); exp.More(); exp.Next()) {
const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
- int nb = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
+ smIdType nb = aMesh.GetSubMesh(E)->GetSubMeshDS()->NbNodes();
if(_quadraticMesh)
nb = nb/2;
nbPoints += nb + 1; // internal points plus 1 vertex of 2 (last point ?)
return false;
SMESH_MesherHelper helper( *mesh.GetMesh() );
+ helper.SetSubShape( face );
// get all faces from a proxy sub-mesh
typedef SMDS_StdIterator< const SMDS_MeshElement*, SMDS_ElemIteratorPtr > TIterator;
{
++iRow1, ++iRow2;
- // get the first quad in the next face row
+ // get the first quad in the next face row
if (( quad = SMESH_MeshAlgos::FindFaceInSet( nodeRows[iRow1][0],
nodeRows[iRow1][1],
allFaces, /*avoid=*/firstRowQuads,
// get params of the first (bottom) and last (top) node rows
UVPtStructVec uvB( nodeRows[0].size() ), uvT( nodeRows[0].size() );
+ bool uvOk = false, *toCheck = helper.GetPeriodicIndex() ? &uvOk : nullptr;
+ const bool isFix3D = helper.HasDegeneratedEdges();
for ( int isBot = 0; isBot < 2; ++isBot )
{
+ iRow1 = isBot ? 0 : nodeRows.size()-1;
+ iRow2 = isBot ? 1 : nodeRows.size()-2;
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 )
+ vector< const SMDS_MeshNode* >& nodes = nodeRows[ iRow1 ];
+ const size_t rowLen = nodes.size();
+ for ( size_t i = 0; i < rowLen; ++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;
+ if ( !isFix3D )
+ {
+ size_t i2 = i;
+ if ( i == 0 ) i2 = 1;
+ if ( i == rowLen - 1 ) i2 = rowLen - 2;
+ gp_XY uv = helper.GetNodeUV( face, uvps[i].node, nodeRows[iRow2][i2], toCheck );
+ uvps[i].u = uv.Coord(1);
+ uvps[i].v = uv.Coord(2);
+ }
}
// calculate x (normalized param)
for ( size_t i = 1; i < nodes.size(); ++i )
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 )
+ UVPtStructVec & uvps = isLeft ? uvL : uvR;
+ const int iCol1 = isLeft ? 0 : nodeRows[0].size() - 1;
+ const int iCol2 = isLeft ? 1 : nodeRows[0].size() - 2;
+ const size_t nbRows = nodeRows.size();
+ for ( size_t i = 0; i < nbRows; ++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].node = nodeRows[i][iCol1];
uvps[i].y = 0;
+ if ( !isFix3D )
+ {
+ size_t i2 = i;
+ if ( i == 0 ) i2 = 1;
+ if ( i == nbRows - 1 ) i2 = nbRows - 2;
+ gp_XY uv = helper.GetNodeUV( face, uvps[i].node, nodeRows[i2][iCol2], toCheck );
+ uvps[i].u = uv.Coord(1);
+ uvps[i].v = uv.Coord(2);
+ }
}
// calculate y (normalized param)
for ( size_t i = 1; i < nodeRows.size(); ++i )
// 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 )
+ if ( !isFix3D )
{
- 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 )
+ 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 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) );
+ 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_FacePositionPtr pos = n->GetPosition() )
+ pos->SetParameters( uv.Coord(1), uv.Coord(2) );
+ }
+ }
+ }
+ else
+ {
+ Handle(ShapeAnalysis_Surface) S = helper.GetSurface( face );
+ SMESH_NodeXYZ a0 ( uvB.front().node );
+ SMESH_NodeXYZ a1 ( uvB.back().node );
+ SMESH_NodeXYZ a2 ( uvT.back().node );
+ SMESH_NodeXYZ a3 ( uvT.front().node );
+ for ( size_t iRow = 1; iRow < nodeRows.size()-1; ++iRow )
+ {
+ SMESH_NodeXYZ p1 ( uvR[ iRow ].node );
+ SMESH_NodeXYZ p3 ( uvL[ iRow ].node );
+ const double y0 = uvL[ iRow ].y;
+ const double y1 = uvR[ iRow ].y;
+ for ( size_t iCol = 1; iCol < nodeRows[0].size()-1; ++iCol )
+ {
+ SMESH_NodeXYZ p0 ( uvB[ iCol ].node );
+ SMESH_NodeXYZ p2 ( uvT[ iCol ].node );
+ 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_Pnt p = helper.calcTFI( x, y, a0,a1,a2,a3, p0,p1,p2,p3 );
+ gp_Pnt2d uv = S->ValueOfUV( p, Precision::Confusion() );
+ p = S->Value( uv );
+ const SMDS_MeshNode* n = nodeRows[iRow][iCol];
+ meshDS->MoveNode( n, p.X(), p.Y(), p.Z() );
+ if ( SMDS_FacePositionPtr pos = n->GetPosition() )
+ pos->SetParameters( uv.Coord(1), uv.Coord(2) );
+ }
}
}
return true;
}
+
+//=======================================================================
+//function : IsApplicableToShape
+//purpose : Return true if the algorithm can mesh a given shape
+//=======================================================================
+
+bool SMESH_1D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
+{
+ return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_EDGE ).More() );
+}
+
+//=======================================================================
+//function : IsApplicableToShape
+//purpose : Return true if the algorithm can mesh a given shape
+//=======================================================================
+
+bool SMESH_2D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
+{
+ return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_FACE ).More() );
+}
+
+//=======================================================================
+//function : IsApplicableToShape
+//purpose : Return true if the algorithm can mesh a given shape
+//=======================================================================
+
+bool SMESH_3D_Algo::IsApplicableToShape(const TopoDS_Shape & shape, bool /*toCheckAll*/) const
+{
+ return ( !shape.IsNull() && TopExp_Explorer( shape, TopAbs_SOLID ).More() );
+}