X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH%2FSMESH_Algo.cxx;h=5ec1240b00bdcb9c8fd007e413b47c2d9b18a589;hp=9f3ed80532907460f7c3078a881b8ecf339a59bf;hb=52d825495306f72048c8754aa5c86c6a390f8262;hpb=88b3dbe23b236bd1746405155ae33a76aaf59ecd;ds=sidebyside diff --git a/src/SMESH/SMESH_Algo.cxx b/src/SMESH/SMESH_Algo.cxx index 9f3ed8053..5ec1240b0 100644 --- a/src/SMESH/SMESH_Algo.cxx +++ b/src/SMESH/SMESH_Algo.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2012 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 @@ -6,7 +6,7 @@ // 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 @@ -38,6 +38,7 @@ #include "SMESH_Gen.hxx" #include "SMESH_HypoFilter.hxx" #include "SMESH_Mesh.hxx" +#include "SMESH_MeshAlgos.hxx" #include "SMESH_TypeDefs.hxx" #include "SMESH_subMesh.hxx" @@ -71,6 +72,8 @@ #include #include +#include "SMESH_ProxyMesh.hxx" +#include "SMESH_MesherHelper.hxx" using namespace std; @@ -175,8 +178,7 @@ const SMESH_Algo::Features& SMESH_Algo::GetFeatures( const std::string& algoType 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; @@ -192,6 +194,8 @@ SMESH_Algo::SMESH_Algo (int hypId, int studyId, SMESH_Gen * gen) SMESH_Algo::~SMESH_Algo() { + delete _compatibleNoAuxHypFilter; + // delete _compatibleAllHypFilter; -- _compatibleNoAuxHypFilter does it!!! } //============================================================================= @@ -205,28 +209,24 @@ SMESH_0D_Algo::SMESH_0D_Algo(int hypId, int studyId, SMESH_Gen* gen) { _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; } //============================================================================= @@ -262,15 +262,15 @@ const vector < string > &SMESH_Algo::GetCompatibleHypothesis() const list & SMESH_Algo::GetUsedHypothesis(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, - const bool ignoreAuxiliary) + const bool ignoreAuxiliary) const { - _usedHypList.clear(); - SMESH_HypoFilter filter; - if ( InitCompatibleHypoFilter( filter, ignoreAuxiliary )) + SMESH_Algo* me = const_cast< SMESH_Algo* >( this ); + me->_usedHypList.clear(); + if ( const SMESH_HypoFilter* filter = GetCompatibleHypoFilter( ignoreAuxiliary )) { - aMesh.GetHypotheses( aShape, filter, _usedHypList, true ); + aMesh.GetHypotheses( aShape, *filter, me->_usedHypList, true ); if ( ignoreAuxiliary && _usedHypList.size() > 1 ) - _usedHypList.clear(); //only one compatible hypothesis allowed + me->_usedHypList.clear(); //only one compatible hypothesis allowed } return _usedHypList; } @@ -286,12 +286,12 @@ SMESH_Algo::GetUsedHypothesis(SMESH_Mesh & aMesh, const list & SMESH_Algo::GetAppliedHypothesis(SMESH_Mesh & aMesh, const TopoDS_Shape & aShape, - const bool ignoreAuxiliary) + const bool ignoreAuxiliary) const { - _appliedHypList.clear(); - SMESH_HypoFilter filter; - if ( InitCompatibleHypoFilter( filter, ignoreAuxiliary )) - aMesh.GetHypotheses( aShape, filter, _appliedHypList, false ); + 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; } @@ -305,54 +305,15 @@ SMESH_Algo::GetAppliedHypothesis(SMESH_Mesh & aMesh, 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; } -//================================================================================ -/*! - * \brief Calculate normal of a mesh face - */ -//================================================================================ - -bool SMESH_Algo::FaceNormal(const SMDS_MeshElement* F, gp_XYZ& normal, bool normalized) -{ - if ( !F || F->GetType() != SMDSAbs_Face ) - return false; - - normal.SetCoord(0,0,0); - int nbNodes = F->IsQuadratic() ? F->NbNodes()/2 : F->NbNodes(); - for ( int i = 0; i < nbNodes-2; ++i ) - { - gp_XYZ p[3]; - for ( int n = 0; n < 3; ++n ) - { - const SMDS_MeshNode* node = F->GetNode( i + n ); - p[n].SetCoord( node->X(), node->Y(), node->Z() ); - } - normal += ( p[2] - p[1] ) ^ ( p[0] - p[1] ); - } - double size2 = normal.SquareModulus(); - bool ok = ( size2 > numeric_limits::min() * numeric_limits::min()); - if ( normalized && ok ) - normal /= sqrt( size2 ); - - return ok; -} - -/* - * Moved to SMESH_MesherHelper - */ -// bool SMESH_Algo::IsReversedSubMesh (const TopoDS_Face& theFace, -// SMESHDS_Mesh* theMeshDS) -// { -// } - //================================================================================ /*! * \brief Just return false as the algorithm does not hold parameters values @@ -450,7 +411,7 @@ bool SMESH_Algo::GetSortedNodesOnEdge(const SMESHDS_Mesh* theM 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; @@ -497,27 +458,35 @@ bool SMESH_Algo::GetSortedNodesOnEdge(const SMESHDS_Mesh* theM //================================================================================ /*! - * \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; } //================================================================================ @@ -553,9 +522,7 @@ GeomAbs_Shape SMESH_Algo::Continuity(TopoDS_Edge E1, 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) { @@ -563,12 +530,78 @@ GeomAbs_Shape SMESH_Algo::Continuity(TopoDS_Edge E1, 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* ) */ //================================================================================ @@ -583,21 +616,6 @@ const SMDS_MeshNode* SMESH_Algo::VertexNode(const TopoDS_Vertex& V, return 0; } -//======================================================================= -//function : GetCommonNodes -//purpose : Return nodes common to two elements -//======================================================================= - -vector< const SMDS_MeshNode*> SMESH_Algo::GetCommonNodes(const SMDS_MeshElement* e1, - const SMDS_MeshElement* e2) -{ - vector< const SMDS_MeshNode*> common; - for ( int i = 0 ; i < e1->NbNodes(); ++i ) - if ( e2->GetNodeIndex( e1->GetNode( i )) >= 0 ) - common.push_back( e1->GetNode( i )); - return common; -} - //======================================================================= //function : GetMeshError //purpose : Finds topological errors of a sub-mesh @@ -733,6 +751,17 @@ void SMESH_Algo::CancelCompute() _error = COMPERR_CANCELED; } +//================================================================================ +/* + * If possible, returns progress of computation [0.,1.] + */ +//================================================================================ + +double SMESH_Algo::GetProgress() const +{ + return _progress; +} + //================================================================================ /*! * \brief store error and comment and then return ( error == COMPERR_OK ) @@ -780,7 +809,7 @@ SMESH_ComputeErrorPtr SMESH_Algo::GetComputeError() const //================================================================================ /*! - * \brief initialize compute error + * \brief initialize compute error before call of Compute() */ //================================================================================ @@ -795,6 +824,27 @@ void SMESH_Algo::InitComputeError() _badInputElements.clear(); _computeCanceled = false; + _progressTic = 0; + _progress = 0.; +} + +//================================================================================ +/*! + * \brief Return compute progress by nb of calls of this method + */ +//================================================================================ + +double SMESH_Algo::GetProgressByTic() const +{ + int computeCost = 0; + for ( size_t i = 0; i < _smToCompute.size(); ++i ) + computeCost += _smToCompute[i]->GetComputeCost(); + + const_cast( this )->_progressTic++; + + double x = 5 * _progressTic; + x = ( x < computeCost ) ? ( x / computeCost ) : 1.; + return 0.9 * sin( x * M_PI / 2 ); } //================================================================================ @@ -868,3 +918,206 @@ int SMESH_Algo::NumberOfPoints(SMESH_Mesh& aMesh, const TopoDS_Wire& W) } +//================================================================================ +/*! + * 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; +}