1 // Copyright (C) 2007-2024 CEA, EDF, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 // File : StdMeshers_QuadFromMedialAxis_1D2D.cxx
23 // Created : Wed Jun 3 17:33:45 2015
24 // Author : Edward AGAPOV (eap)
26 #include "StdMeshers_QuadFromMedialAxis_1D2D.hxx"
28 #include "SMESHDS_Mesh.hxx"
29 #include "SMESH_Block.hxx"
30 #include "SMESH_Gen.hxx"
31 #include "SMESH_MAT2d.hxx"
32 #include "SMESH_Mesh.hxx"
33 #include "SMESH_SequentialMesh.hxx"
34 #include "SMESH_MeshEditor.hxx"
35 #include "SMESH_MesherHelper.hxx"
36 #include "SMESH_ProxyMesh.hxx"
37 #include "SMESH_subMesh.hxx"
38 #include "SMESH_subMeshEventListener.hxx"
39 #include "StdMeshers_FaceSide.hxx"
40 #include "StdMeshers_LayerDistribution.hxx"
41 #include "StdMeshers_NumberOfLayers.hxx"
42 #include "StdMeshers_Regular_1D.hxx"
43 #include "StdMeshers_ViscousLayers2D.hxx"
45 #include <BRepAdaptor_Curve.hxx>
46 #include <BRepBuilderAPI_MakeEdge.hxx>
47 #include <BRepTools.hxx>
48 #include <BRep_Tool.hxx>
49 #include <GeomAPI_Interpolate.hxx>
50 #include <Geom_Surface.hxx>
51 #include <Precision.hxx>
52 #include <TColgp_HArray1OfPnt.hxx>
54 #include <TopExp_Explorer.hxx>
55 #include <TopLoc_Location.hxx>
56 #include <TopTools_MapOfShape.hxx>
58 #include <TopoDS_Edge.hxx>
59 #include <TopoDS_Face.hxx>
60 #include <TopoDS_Vertex.hxx>
68 //================================================================================
72 class StdMeshers_QuadFromMedialAxis_1D2D::Algo1D : public StdMeshers_Regular_1D
75 Algo1D(SMESH_Gen* gen):
76 StdMeshers_Regular_1D( gen->GetANewId(), gen )
79 void SetSegmentLength( double len )
81 SMESH_Algo::_usedHypList.clear();
82 _value[ BEG_LENGTH_IND ] = len;
83 _value[ PRECISION_IND ] = 1e-7;
84 _hypType = LOCAL_LENGTH;
86 void SetRadialDistribution( const SMESHDS_Hypothesis* hyp )
88 SMESH_Algo::_usedHypList.clear();
92 if ( const StdMeshers_NumberOfLayers* nl =
93 dynamic_cast< const StdMeshers_NumberOfLayers* >( hyp ))
95 _ivalue[ NB_SEGMENTS_IND ] = nl->GetNumberOfLayers();
96 _ivalue[ DISTR_TYPE_IND ] = 0;
97 _hypType = NB_SEGMENTS;
99 if ( const StdMeshers_LayerDistribution* ld =
100 dynamic_cast< const StdMeshers_LayerDistribution* >( hyp ))
102 if ( SMESH_Hypothesis* h = ld->GetLayerDistribution() )
104 SMESH_Algo::_usedHypList.clear();
105 SMESH_Algo::_usedHypList.push_back( h );
109 void ComputeDistribution(SMESH_MesherHelper& theHelper,
110 const gp_Pnt& thePnt1,
111 const gp_Pnt& thePnt2,
112 list< double >& theParams)
114 SMESH_Mesh& mesh = *theHelper.GetMesh();
115 TopoDS_Edge edge = BRepBuilderAPI_MakeEdge( thePnt1, thePnt2 );
117 SMESH_Hypothesis::Hypothesis_Status aStatus;
118 CheckHypothesis( mesh, edge, aStatus );
121 BRepAdaptor_Curve C3D(edge);
122 double f = C3D.FirstParameter(), l = C3D.LastParameter(), len = thePnt1.Distance( thePnt2 );
123 if ( !StdMeshers_Regular_1D::computeInternalParameters( mesh, C3D, len, f, l, theParams, false))
125 for ( size_t i = 1; i < 15; ++i )
126 theParams.push_back( i/15. ); // ????
130 for (list<double>::iterator itU = theParams.begin(); itU != theParams.end(); ++itU )
134 virtual const list <const SMESHDS_Hypothesis *> &
135 GetUsedHypothesis(SMESH_Mesh &, const TopoDS_Shape &, const bool)
137 return SMESH_Algo::_usedHypList;
139 virtual bool CheckHypothesis(SMESH_Mesh& aMesh,
140 const TopoDS_Shape& aShape,
141 SMESH_Hypothesis::Hypothesis_Status& aStatus)
143 if ( !SMESH_Algo::_usedHypList.empty() )
144 return StdMeshers_Regular_1D::CheckHypothesis( aMesh, aShape, aStatus );
149 //================================================================================
151 * \brief Constructor sets algo features
153 //================================================================================
155 StdMeshers_QuadFromMedialAxis_1D2D::StdMeshers_QuadFromMedialAxis_1D2D(int hypId,
157 : StdMeshers_Quadrangle_2D(hypId, gen),
160 _name = "QuadFromMedialAxis_1D2D";
161 _shapeType = (1 << TopAbs_FACE);
162 _onlyUnaryInput = true; // FACE by FACE so far
163 _requireDiscreteBoundary = false; // make 1D by myself
164 _supportSubmeshes = true; // make 1D by myself
165 _neededLowerHyps[ 1 ] = true; // suppress warning on hiding a global 1D algo
166 _neededLowerHyps[ 2 ] = true; // suppress warning on hiding a global 2D algo
167 _compatibleHypothesis.clear();
168 _compatibleHypothesis.push_back("ViscousLayers2D");
169 _compatibleHypothesis.push_back("LayerDistribution2D");
170 _compatibleHypothesis.push_back("NumberOfLayers2D");
173 //================================================================================
177 //================================================================================
179 StdMeshers_QuadFromMedialAxis_1D2D::~StdMeshers_QuadFromMedialAxis_1D2D()
185 //================================================================================
187 * \brief Check if needed hypotheses are present
189 //================================================================================
191 bool StdMeshers_QuadFromMedialAxis_1D2D::CheckHypothesis(SMESH_Mesh& aMesh,
192 const TopoDS_Shape& aShape,
193 Hypothesis_Status& aStatus)
197 // get one main optional hypothesis
198 const list <const SMESHDS_Hypothesis * >& hyps = GetUsedHypothesis(aMesh, aShape);
199 _hyp2D = hyps.empty() ? 0 : hyps.front();
201 return true; // does not require hypothesis
206 typedef map< const SMDS_MeshNode*, list< const SMDS_MeshNode* > > TMergeMap;
208 //================================================================================
210 * \brief Sinuous face
214 FaceQuadStruct::Ptr _quad;
215 vector< TopoDS_Edge > _edges;
216 vector< TopoDS_Edge > _sinuSide[2], _shortSide[2];
217 vector< TopoDS_Edge > _sinuEdges;
218 vector< Handle(Geom_Curve) > _sinuCurves;
220 list< int > _nbEdgesInWire;
221 TMergeMap _nodesToMerge;
223 SinuousFace( const TopoDS_Face& f ): _quad( new FaceQuadStruct )
225 list< TopoDS_Edge > edges;
226 _nbWires = SMESH_Block::GetOrderedEdges (f, edges, _nbEdgesInWire);
227 _edges.assign( edges.begin(), edges.end() );
229 _quad->side.resize( 4 );
232 const TopoDS_Face& Face() const { return _quad->face; }
233 bool IsRing() const { return _shortSide[0].empty() && !_sinuSide[0].empty(); }
236 //================================================================================
238 * \brief Temporary mesh
240 struct TmpMesh : public SMESH_SequentialMesh
244 _meshDS = new SMESHDS_Mesh(/*id=*/0, /*isEmbeddedMode=*/true);
248 //================================================================================
250 * \brief Event listener which removes mesh from EDGEs when 2D hyps change
252 struct EdgeCleaner : public SMESH_subMeshEventListener
256 SMESH_subMeshEventListener( /*isDeletable=*/true,
257 "StdMeshers_QuadFromMedialAxis_1D2D::EdgeCleaner")
261 virtual void ProcessEvent(const int event,
263 SMESH_subMesh* faceSubMesh,
264 SMESH_subMeshEventListenerData* /*data*/,
265 const SMESH_Hypothesis* /*hyp*/)
267 if ( eventType == SMESH_subMesh::ALGO_EVENT )
269 _prevAlgoEvent = event;
272 // SMESH_subMesh::COMPUTE_EVENT
273 if ( _prevAlgoEvent == SMESH_subMesh::REMOVE_HYP ||
274 _prevAlgoEvent == SMESH_subMesh::REMOVE_ALGO ||
275 _prevAlgoEvent == SMESH_subMesh::MODIF_HYP )
277 SMESH_subMeshIteratorPtr smIt = faceSubMesh->getDependsOnIterator(/*includeSelf=*/false);
278 while ( smIt->more() )
279 smIt->next()->ComputeStateEngine( SMESH_subMesh::CLEAN );
285 //================================================================================
287 * \brief Return a member of a std::pair
289 //================================================================================
291 template< typename T >
292 T& get( std::pair< T, T >& thePair, bool is2nd )
294 return is2nd ? thePair.second : thePair.first;
297 //================================================================================
299 * \brief Select two EDGEs from a map, either mapped to least values or to max values
301 //================================================================================
303 // template< class TVal2EdgesMap >
304 // void getTwo( bool least,
305 // TVal2EdgesMap& map,
306 // vector<TopoDS_Edge>& twoEdges,
307 // vector<TopoDS_Edge>& otherEdges)
310 // otherEdges.clear();
313 // TVal2EdgesMap::iterator i = map.begin();
314 // twoEdges.push_back( i->second );
315 // twoEdges.push_back( ++i->second );
316 // for ( ; i != map.end(); ++i )
317 // otherEdges.push_back( i->second );
321 // TVal2EdgesMap::reverse_iterator i = map.rbegin();
322 // twoEdges.push_back( i->second );
323 // twoEdges.push_back( ++i->second );
324 // for ( ; i != map.rend(); ++i )
325 // otherEdges.push_back( i->second );
328 // if ( TopExp::CommonVertex( twoEdges[0], twoEdges[1], v ))
330 // twoEdges.clear(); // two EDGEs must not be connected
331 // otherEdges.clear();
335 //================================================================================
337 * \brief Finds out a minimal segment length given EDGEs will be divided into.
338 * This length is further used to discretize the Medial Axis
340 //================================================================================
342 double getMinSegLen(SMESH_MesherHelper& theHelper,
343 const vector<TopoDS_Edge>& theEdges)
346 SMESH_Mesh* mesh = theHelper.GetMesh();
348 vector< SMESH_Algo* > algos( theEdges.size() );
349 for ( size_t i = 0; i < theEdges.size(); ++i )
351 SMESH_subMesh* sm = mesh->GetSubMesh( theEdges[i] );
352 algos[i] = sm->GetAlgo();
355 int nbSegDflt = mesh->GetGen() ? mesh->GetGen()->GetDefaultNbSegments() : 15;
356 double minSegLen = Precision::Infinite();
358 for ( size_t i = 0; i < theEdges.size(); ++i )
360 SMESH_subMesh* sm = mesh->GetSubMesh( theEdges[i] );
361 if ( SMESH_Algo::IsStraight( theEdges[i], /*degenResult=*/true ))
364 size_t iOpp = ( theEdges.size() == 4 ? (i+2)%4 : i );
365 SMESH_Algo* algo = sm->GetAlgo();
366 if ( !algo ) algo = algos[ iOpp ];
368 SMESH_Hypothesis::Hypothesis_Status status = SMESH_Hypothesis::HYP_MISSING;
371 if ( !algo->CheckHypothesis( *mesh, theEdges[i], status ))
372 algo->CheckHypothesis( *mesh, theEdges[iOpp], status );
375 if ( status != SMESH_Hypothesis::HYP_OK )
377 minSegLen = Min( minSegLen, SMESH_Algo::EdgeLength( theEdges[i] ) / nbSegDflt );
382 tmpMesh.ShapeToMesh( TopoDS_Shape());
383 tmpMesh.ShapeToMesh( theEdges[i] );
385 if ( !mesh->GetGen() ) continue; // tmp mesh
386 mesh->GetGen()->Compute( tmpMesh, theEdges[i], SMESH_Gen::SHAPE_ONLY_UPWARD ); // make nodes on VERTEXes
387 if ( !algo->Compute( tmpMesh, theEdges[i] ))
393 SMDS_EdgeIteratorPtr segIt = tmpMesh.GetMeshDS()->edgesIterator();
394 while ( segIt->more() )
396 const SMDS_MeshElement* seg = segIt->next();
397 double len = SMESH_TNodeXYZ( seg->GetNode(0) ).Distance( seg->GetNode(1) );
398 minSegLen = Min( minSegLen, len );
402 if ( Precision::IsInfinite( minSegLen ))
403 minSegLen = mesh->GetShapeDiagonalSize() / nbSegDflt;
408 //================================================================================
410 * \brief Returns EDGEs located between two VERTEXes at which given MA branches end
411 * \param [in] br1 - one MA branch
412 * \param [in] br2 - one more MA branch
413 * \param [in] allEdges - all EDGEs of a FACE
414 * \param [out] shortEdges - the found EDGEs
415 * \return bool - is OK or not
417 //================================================================================
419 bool getConnectedEdges( const SMESH_MAT2d::Branch* br1,
420 const SMESH_MAT2d::Branch* br2,
421 const vector<TopoDS_Edge>& allEdges,
422 vector<TopoDS_Edge>& shortEdges)
424 vector< size_t > edgeIDs[4];
425 br1->getGeomEdges( edgeIDs[0], edgeIDs[1] );
426 br2->getGeomEdges( edgeIDs[2], edgeIDs[3] );
428 // EDGEs returned by a Branch form a connected chain with a VERTEX where
429 // the Branch ends at the chain middle. One of end EDGEs of the chain is common
430 // with either end EDGE of the chain of the other Branch, or the chains are connected
431 // at a common VERTEX;
433 // Get indices of end EDGEs of the branches
434 bool vAtStart1 = ( br1->getEnd(0)->_type == SMESH_MAT2d::BE_ON_VERTEX );
435 bool vAtStart2 = ( br2->getEnd(0)->_type == SMESH_MAT2d::BE_ON_VERTEX );
437 vAtStart1 ? edgeIDs[0].back() : edgeIDs[0][0],
438 vAtStart1 ? edgeIDs[1].back() : edgeIDs[1][0],
439 vAtStart2 ? edgeIDs[2].back() : edgeIDs[2][0],
440 vAtStart2 ? edgeIDs[3].back() : edgeIDs[3][0]
443 set< size_t > connectedIDs;
444 TopoDS_Vertex vCommon;
445 // look for the same EDGEs
446 for ( int i = 0; i < 2; ++i )
447 for ( int j = 2; j < 4; ++j )
448 if ( iEnd[i] == iEnd[j] )
450 connectedIDs.insert( edgeIDs[i].begin(), edgeIDs[i].end() );
451 connectedIDs.insert( edgeIDs[j].begin(), edgeIDs[j].end() );
454 if ( connectedIDs.empty() )
455 // look for connected EDGEs
456 for ( int i = 0; i < 2; ++i )
457 for ( int j = 2; j < 4; ++j )
458 if ( TopExp::CommonVertex( allEdges[ iEnd[i]], allEdges[ iEnd[j]], vCommon ))
460 connectedIDs.insert( edgeIDs[i].begin(), edgeIDs[i].end() );
461 connectedIDs.insert( edgeIDs[j].begin(), edgeIDs[j].end() );
464 if ( connectedIDs.empty() || // nothing
465 allEdges.size() - connectedIDs.size() < 2 ) // too many
468 // set shortEdges in the order as in allEdges
469 if ( connectedIDs.count( 0 ) &&
470 connectedIDs.count( allEdges.size()-1 ))
472 size_t iE = allEdges.size()-1;
473 while ( connectedIDs.count( iE-1 ))
475 for ( size_t i = 0; i < connectedIDs.size(); ++i )
477 shortEdges.push_back( allEdges[ iE ]);
478 iE = ( iE + 1 ) % allEdges.size();
483 set< size_t >::iterator i = connectedIDs.begin();
484 for ( ; i != connectedIDs.end(); ++i )
485 shortEdges.push_back( allEdges[ *i ]);
490 //================================================================================
492 * \brief Find EDGEs to discretize using projection from MA
493 * \param [in,out] theSinuFace - the FACE to be meshed
494 * \return bool - OK or not
496 * It separates all EDGEs into four sides of a quadrangle connected in the order:
497 * theSinuEdges[0], theShortEdges[0], theSinuEdges[1], theShortEdges[1]
499 //================================================================================
501 bool getSinuousEdges( SMESH_MesherHelper& theHelper,
502 SinuousFace& theSinuFace)
504 vector<TopoDS_Edge> * theSinuEdges = & theSinuFace._sinuSide [0];
505 vector<TopoDS_Edge> * theShortEdges = & theSinuFace._shortSide[0];
506 theSinuEdges[0].clear();
507 theSinuEdges[1].clear();
508 theShortEdges[0].clear();
509 theShortEdges[1].clear();
511 vector<TopoDS_Edge> & allEdges = theSinuFace._edges;
512 const size_t nbEdges = allEdges.size();
513 if ( nbEdges < 4 && theSinuFace._nbWires == 1 )
516 if ( theSinuFace._nbWires == 2 ) // ring
518 size_t nbOutEdges = theSinuFace._nbEdgesInWire.front();
519 theSinuEdges[0].assign ( allEdges.begin(), allEdges.begin() + nbOutEdges );
520 theSinuEdges[1].assign ( allEdges.begin() + nbOutEdges, allEdges.end() );
521 theSinuFace._sinuEdges = allEdges;
524 if ( theSinuFace._nbWires > 2 )
527 // create MedialAxis to find short edges by analyzing MA branches
528 double minSegLen = getMinSegLen( theHelper, allEdges );
529 SMESH_MAT2d::MedialAxis ma( theSinuFace.Face(), allEdges, minSegLen * 3 );
531 // in an initial request case, theFace represents a part of a river with almost parallel banks
532 // so there should be two branch points
533 using SMESH_MAT2d::BranchEnd;
534 using SMESH_MAT2d::Branch;
535 const vector< const BranchEnd* >& braPoints = ma.getBranchPoints();
536 if ( braPoints.size() < 2 )
538 TopTools_MapOfShape shortMap;
539 size_t nbBranchPoints = 0;
540 for ( size_t i = 0; i < braPoints.size(); ++i )
542 vector< const Branch* > vertBranches; // branches with an end on VERTEX
543 for ( size_t ib = 0; ib < braPoints[i]->_branches.size(); ++ib )
545 const Branch* branch = braPoints[i]->_branches[ ib ];
546 if ( branch->hasEndOfType( SMESH_MAT2d::BE_ON_VERTEX ))
547 vertBranches.push_back( branch );
549 if ( vertBranches.size() != 2 || braPoints[i]->_branches.size() != 3)
552 // get common EDGEs of two branches
553 if ( !getConnectedEdges( vertBranches[0], vertBranches[1],
554 allEdges, theShortEdges[ nbBranchPoints > 0 ] ))
557 for ( size_t iS = 0; iS < theShortEdges[ nbBranchPoints > 0 ].size(); ++iS )
558 shortMap.Add( theShortEdges[ nbBranchPoints > 0 ][ iS ]);
563 if ( nbBranchPoints != 2 )
566 // add to theSinuEdges all edges that are not theShortEdges
567 vector< vector<TopoDS_Edge> > sinuEdges(1);
568 TopoDS_Vertex vCommon;
569 for ( size_t i = 0; i < allEdges.size(); ++i )
571 if ( !shortMap.Contains( allEdges[i] ))
573 if ( !sinuEdges.back().empty() )
574 if ( !TopExp::CommonVertex( sinuEdges.back().back(), allEdges[ i ], vCommon ))
575 sinuEdges.resize( sinuEdges.size() + 1 );
577 sinuEdges.back().push_back( allEdges[i] );
580 if ( sinuEdges.size() == 3 )
582 if ( !TopExp::CommonVertex( sinuEdges.back().back(), sinuEdges[0][0], vCommon ))
584 vector<TopoDS_Edge>& last = sinuEdges.back();
585 last.insert( last.end(), sinuEdges[0].begin(), sinuEdges[0].end() );
586 sinuEdges[0].swap( last );
587 sinuEdges.resize( 2 );
589 if ( sinuEdges.size() != 2 )
592 theSinuEdges[0].swap( sinuEdges[0] );
593 theSinuEdges[1].swap( sinuEdges[1] );
595 if ( !TopExp::CommonVertex( theSinuEdges[0].back(), theShortEdges[0][0], vCommon ) ||
596 !vCommon.IsSame( theHelper.IthVertex( 1, theSinuEdges[0].back() )))
597 theShortEdges[0].swap( theShortEdges[1] );
599 theSinuFace._sinuEdges = theSinuEdges[0];
600 theSinuFace._sinuEdges.insert( theSinuFace._sinuEdges.end(),
601 theSinuEdges[1].begin(), theSinuEdges[1].end() );
603 return ( theShortEdges[0].size() > 0 && theShortEdges[1].size() > 0 &&
604 theSinuEdges [0].size() > 0 && theSinuEdges [1].size() > 0 );
606 // the sinuous EDGEs can be composite and C0 continuous,
607 // therefore we use a complex criterion to find TWO short non-sinuous EDGEs
608 // and the rest EDGEs will be treated as sinuous.
609 // A short edge should have the following features:
612 // c) with convex corners at ends
613 // d) far from the other short EDGE
615 // vector< double > isStraightEdge( nbEdges, 0 ); // criterion value
617 // // a0) evaluate continuity
618 // const double contiWgt = 0.5; // weight of continuity in the criterion
619 // multimap< int, TopoDS_Edge > continuity;
620 // for ( size_t i = 0; i < nbEdges; ++I )
622 // BRepAdaptor_Curve curve( allEdges[i] );
623 // GeomAbs_Shape C = GeomAbs_CN;
625 // C = curve.Continuity(); // C0, G1, C1, G2, C2, C3, CN
626 // catch ( Standard_Failure ) {}
627 // continuity.insert( make_pair( C, allEdges[i] ));
628 // isStraight[i] += double( C ) / double( CN ) * contiWgt;
631 // // try to choose by continuity
632 // int mostStraight = (int) continuity.rbegin()->first;
633 // int lessStraight = (int) continuity.begin()->first;
634 // if ( mostStraight != lessStraight )
636 // int nbStraight = continuity.count( mostStraight );
637 // if ( nbStraight == 2 )
639 // getTwo( /*least=*/false, continuity, theShortEdges, theSinuEdges );
641 // else if ( nbStraight == 3 && nbEdges == 4 )
643 // theSinuEdges.push_back( continuity.begin()->second );
644 // vector<TopoDS_Edge>::iterator it =
645 // std::find( allEdges.begin(), allEdges.end(), theSinuEdges[0] );
646 // int i = std::distance( allEdges.begin(), it );
647 // theSinuEdges .push_back( allEdges[( i+2 )%4 ]);
648 // theShortEdges.push_back( allEdges[( i+1 )%4 ]);
649 // theShortEdges.push_back( allEdges[( i+3 )%4 ]);
651 // if ( theShortEdges.size() == 2 )
655 // // a) curvature; evaluate aspect ratio
657 // const double curvWgt = 0.5;
658 // for ( size_t i = 0; i < nbEdges; ++I )
660 // BRepAdaptor_Curve curve( allEdges[i] );
661 // double curvature = 1;
662 // if ( !curve.IsClosed() )
664 // const double f = curve.FirstParameter(), l = curve.LastParameter();
665 // gp_Pnt pf = curve.Value( f ), pl = curve.Value( l );
666 // gp_Lin line( pf, pl.XYZ() - pf.XYZ() );
667 // double distMax = 0;
668 // for ( double u = f; u < l; u += (l-f)/30. )
669 // distMax = Max( distMax, line.SquareDistance( curve.Value( u )));
670 // curvature = Sqrt( distMax ) / ( pf.Distance( pl ));
672 // isStraight[i] += curvWgt / ( curvature + 1e-20 );
677 // const double lenWgt = 0.5;
678 // for ( size_t i = 0; i < nbEdges; ++I )
680 // double length = SMESH_Algo::Length( allEdges[i] );
682 // isStraight[i] += lenWgt / length;
685 // // c) with convex corners at ends
687 // const double cornerWgt = 0.25;
688 // for ( size_t i = 0; i < nbEdges; ++I )
690 // double convex = 0;
691 // int iPrev = SMESH_MesherHelper::WrapIndex( int(i)-1, nbEdges );
692 // int iNext = SMESH_MesherHelper::WrapIndex( int(i)+1, nbEdges );
693 // TopoDS_Vertex v = helper.IthVertex( 0, allEdges[i] );
694 // double angle = SMESH_MesherHelper::GetAngle( allEdges[iPrev], allEdges[i], theFace, v );
695 // if ( angle < M_PI ) // [-PI; PI]
696 // convex += ( angle + M_PI ) / M_PI / M_PI;
697 // v = helper.IthVertex( 1, allEdges[i] );
698 // angle = SMESH_MesherHelper::GetAngle( allEdges[iNext], allEdges[i], theFace, v );
699 // if ( angle < M_PI ) // [-PI; PI]
700 // convex += ( angle + M_PI ) / M_PI / M_PI;
701 // isStraight[i] += cornerWgt * convex;
706 //================================================================================
708 * \brief Creates an EDGE from a sole branch of MA
710 //================================================================================
712 TopoDS_Edge makeEdgeFromMA( SMESH_MesherHelper& theHelper,
713 const SMESH_MAT2d::MedialAxis& theMA,
714 const double theMinSegLen)
716 if ( theMA.nbBranches() != 1 )
717 return TopoDS_Edge();
720 theMA.getPoints( theMA.getBranch(0), uv );
722 return TopoDS_Edge();
724 TopoDS_Face face = TopoDS::Face( theHelper.GetSubShape() );
725 Handle(Geom_Surface) surface = BRep_Tool::Surface( face );
727 vector< gp_Pnt > pnt;
728 pnt.reserve( uv.size() * 2 );
729 pnt.push_back( surface->Value( uv[0].X(), uv[0].Y() ));
730 for ( size_t i = 1; i < uv.size(); ++i )
732 gp_Pnt p = surface->Value( uv[i].X(), uv[i].Y() );
733 int nbDiv = int( p.Distance( pnt.back() ) / theMinSegLen );
734 for ( int iD = 1; iD < nbDiv; ++iD )
736 double R = iD / double( nbDiv );
737 gp_XY uvR = uv[i-1] * (1 - R) + uv[i] * R;
738 pnt.push_back( surface->Value( uvR.X(), uvR.Y() ));
743 // cout << "from salome.geom import geomBuilder" << endl;
744 // cout << "geompy = geomBuilder.New()" << endl;
745 Handle(TColgp_HArray1OfPnt) points = new TColgp_HArray1OfPnt(1, pnt.size());
746 for ( size_t i = 0; i < pnt.size(); ++i )
749 points->SetValue( i+1, p );
750 // cout << "geompy.MakeVertex( "<< p.X()<<", " << p.Y()<<", " << p.Z()
751 // <<" theName = 'p_" << i << "')" << endl;
754 GeomAPI_Interpolate interpol( points, /*isClosed=*/false, gp::Resolution());
756 if ( !interpol.IsDone())
757 return TopoDS_Edge();
759 TopoDS_Edge branchEdge = BRepBuilderAPI_MakeEdge(interpol.Curve());
763 //================================================================================
765 * \brief Returns a type of shape, to which a hypothesis used to mesh a given edge is assigned
767 //================================================================================
769 TopAbs_ShapeEnum getHypShape( SMESH_Mesh* mesh, const TopoDS_Shape& edge )
771 TopAbs_ShapeEnum shapeType = TopAbs_SHAPE;
773 SMESH_subMesh* sm = mesh->GetSubMesh( edge );
774 SMESH_Algo* algo = sm->GetAlgo();
775 if ( !algo ) return shapeType;
777 const list <const SMESHDS_Hypothesis *> & hyps =
778 algo->GetUsedHypothesis( *mesh, edge, /*ignoreAuxiliary=*/true );
779 if ( hyps.empty() ) return shapeType;
781 TopoDS_Shape shapeOfHyp =
782 SMESH_MesherHelper::GetShapeOfHypothesis( hyps.front(), edge, mesh);
784 return SMESH_MesherHelper::GetGroupType( shapeOfHyp, /*woCompound=*/true);
787 //================================================================================
789 * \brief Discretize a sole branch of MA an returns parameters of divisions on MA
791 //================================================================================
793 bool divideMA( SMESH_MesherHelper& theHelper,
794 const SMESH_MAT2d::MedialAxis& theMA,
795 const SinuousFace& theSinuFace,
796 SMESH_Algo* the1dAlgo,
797 const double theMinSegLen,
798 vector<double>& theMAParams )
800 // Check if all EDGEs of one size are meshed, then MA discretization is not needed
801 SMESH_Mesh* mesh = theHelper.GetMesh();
802 size_t nbComputedEdges[2] = { 0, 0 };
803 for ( size_t iS = 0; iS < 2; ++iS )
804 for ( size_t i = 0; i < theSinuFace._sinuSide[iS].size(); ++i )
806 const TopoDS_Edge& sinuEdge = theSinuFace._sinuSide[iS][i];
807 SMESH_subMesh* sm = mesh->GetSubMesh( sinuEdge );
808 bool isComputed = ( !sm->IsEmpty() );
811 TopAbs_ShapeEnum shape = getHypShape( mesh, sinuEdge );
812 if ( shape == TopAbs_SHAPE || shape <= TopAbs_FACE )
814 // EDGE computed using global hypothesis -> clear it
815 bool hasComputedFace = false;
816 PShapeIteratorPtr faceIt = theHelper.GetAncestors( sinuEdge, *mesh, TopAbs_FACE );
817 while ( const TopoDS_Shape* face = faceIt->next() )
818 if (( !face->IsSame( theSinuFace.Face() )) &&
819 ( hasComputedFace = !mesh->GetSubMesh( *face )->IsEmpty() ))
821 if ( !hasComputedFace )
823 sm->ComputeStateEngine( SMESH_subMesh::CLEAN );
828 nbComputedEdges[ iS ] += isComputed;
830 if ( nbComputedEdges[0] == theSinuFace._sinuSide[0].size() ||
831 nbComputedEdges[1] == theSinuFace._sinuSide[1].size() )
832 return true; // discretization is not needed
835 TopoDS_Edge branchEdge = makeEdgeFromMA( theHelper, theMA, theMinSegLen );
836 if ( branchEdge.IsNull() )
839 // const char* file = "/misc/dn25/salome/eap/salome/misc/tmp/MAedge.brep";
840 // BRepTools::Write( branchEdge, file);
841 // cout << "Write " << file << endl;
844 // Find 1D algo to mesh branchEdge
846 // look for a most local 1D hyp assigned to the FACE
847 int mostSimpleShape = -1, maxShape = TopAbs_EDGE;
849 for ( size_t i = 0; i < theSinuFace._sinuEdges.size(); ++i )
851 TopAbs_ShapeEnum shapeType = getHypShape( mesh, theSinuFace._sinuEdges[i] );
852 if ( mostSimpleShape < shapeType && shapeType < maxShape )
854 edge = theSinuFace._sinuEdges[i];
855 mostSimpleShape = shapeType;
859 SMESH_Algo* algo = the1dAlgo;
860 if ( mostSimpleShape > -1 )
862 algo = mesh->GetSubMesh( edge )->GetAlgo();
863 SMESH_Hypothesis::Hypothesis_Status status;
864 if ( !algo->CheckHypothesis( *mesh, edge, status ))
869 tmpMesh.ShapeToMesh( branchEdge );
871 mesh->GetGen()->Compute( tmpMesh, branchEdge, SMESH_Gen::SHAPE_ONLY_UPWARD ); // make nodes on VERTEXes
872 if ( !algo->Compute( tmpMesh, branchEdge ))
878 return SMESH_Algo::GetNodeParamOnEdge( tmpMesh.GetMeshDS(), branchEdge, theMAParams );
881 //================================================================================
883 * \brief Select division parameters on MA and make them coincide at ends with
884 * projections of VERTEXes to MA for a given pair of opposite EDGEs
885 * \param [in] theEdgePairInd - index of the EDGE pair
886 * \param [in] theDivPoints - the BranchPoint's dividing MA into parts each
887 * corresponding to a unique pair of opposite EDGEs
888 * \param [in] theMAParams - the MA division parameters
889 * \param [out] theSelectedMAParams - the selected MA parameters
890 * \return bool - is OK
892 //================================================================================
894 bool getParamsForEdgePair( const size_t theEdgePairInd,
895 const vector< SMESH_MAT2d::BranchPoint >& theDivPoints,
896 const vector<double>& theMAParams,
897 vector<double>& theSelectedMAParams)
899 if ( theDivPoints.empty() )
901 theSelectedMAParams = theMAParams;
904 if ( theEdgePairInd > theDivPoints.size() || theMAParams.empty() )
907 // find a range of params to copy
911 if ( theEdgePairInd > 0 )
913 const SMESH_MAT2d::BranchPoint& bp = theDivPoints[ theEdgePairInd-1 ];
914 bp._branch->getParameter( bp, par1 );
915 while ( theMAParams[ iPar1 ] < par1 ) ++iPar1;
916 if ( par1 - theMAParams[ iPar1-1 ] < theMAParams[ iPar1 ] - par1 )
921 size_t iPar2 = theMAParams.size() - 1;
922 if ( theEdgePairInd < theDivPoints.size() )
924 const SMESH_MAT2d::BranchPoint& bp = theDivPoints[ theEdgePairInd ];
925 bp._branch->getParameter( bp, par2 );
927 while ( theMAParams[ iPar2 ] < par2 ) ++iPar2;
928 if ( par2 - theMAParams[ iPar2-1 ] < theMAParams[ iPar2 ] - par2 )
932 theSelectedMAParams.assign( theMAParams.begin() + iPar1,
933 theMAParams.begin() + iPar2 + 1 );
935 // adjust theSelectedMAParams to fit between par1 and par2
937 double d = par1 - theSelectedMAParams[0];
938 double f = ( par2 - par1 ) / ( theSelectedMAParams.back() - theSelectedMAParams[0] );
940 for ( size_t i = 0; i < theSelectedMAParams.size(); ++i )
942 theSelectedMAParams[i] += d;
943 theSelectedMAParams[i] = par1 + ( theSelectedMAParams[i] - par1 ) * f;
949 //--------------------------------------------------------------------------------
950 // node or node parameter on EDGE
953 const SMDS_MeshNode* _node;
955 size_t _edgeInd; // index in theSinuEdges vector
957 NodePoint(): _node(0), _u(0), _edgeInd(-1) {}
958 NodePoint(const SMDS_MeshNode* n, double u, size_t iEdge ): _node(n), _u(u), _edgeInd(iEdge) {}
959 NodePoint(double u, size_t iEdge) : _node(0), _u(u), _edgeInd(iEdge) {}
960 NodePoint(const SMESH_MAT2d::BoundaryPoint& p) : _node(0), _u(p._param), _edgeInd(p._edgeIndex) {}
961 gp_Pnt Point(const vector< Handle(Geom_Curve) >& curves) const
963 return _node ? SMESH_TNodeXYZ(_node) : curves[ _edgeInd ]->Value( _u );
966 typedef multimap< double, pair< NodePoint, NodePoint > > TMAPar2NPoints;
968 //================================================================================
970 * \brief Finds a VERTEX corresponding to a point on EDGE, which is also filled
971 * with a node on the VERTEX, present or created
972 * \param [in,out] theNodePnt - the node position on the EDGE
973 * \param [in] theSinuEdges - the sinuous EDGEs
974 * \param [in] theMeshDS - the mesh
975 * \return bool - true if the \a theBndPnt is on VERTEX
977 //================================================================================
979 bool findVertexAndNode( NodePoint& theNodePnt,
980 const vector<TopoDS_Edge>& theSinuEdges,
981 SMESHDS_Mesh* theMeshDS = 0,
982 size_t theEdgeIndPrev = 0,
983 size_t theEdgeIndNext = 0)
985 if ( theNodePnt._edgeInd >= theSinuEdges.size() )
989 BRep_Tool::Range( theSinuEdges[ theNodePnt._edgeInd ], f,l );
990 const double tol = 1e-3 * ( l - f );
993 if ( Abs( f - theNodePnt._u ) < tol )
994 V = SMESH_MesherHelper::IthVertex( 0, theSinuEdges[ theNodePnt._edgeInd ], /*CumOri=*/false);
995 else if ( Abs( l - theNodePnt._u ) < tol )
996 V = SMESH_MesherHelper::IthVertex( 1, theSinuEdges[ theNodePnt._edgeInd ], /*CumOri=*/false);
997 else if ( theEdgeIndPrev != theEdgeIndNext )
998 TopExp::CommonVertex( theSinuEdges[theEdgeIndPrev], theSinuEdges[theEdgeIndNext], V );
1000 if ( !V.IsNull() && theMeshDS )
1002 theNodePnt._node = SMESH_Algo::VertexNode( V, theMeshDS );
1003 if ( !theNodePnt._node )
1005 gp_Pnt p = BRep_Tool::Pnt( V );
1006 theNodePnt._node = theMeshDS->AddNode( p.X(), p.Y(), p.Z() );
1007 theMeshDS->SetNodeOnVertex( theNodePnt._node, V );
1013 //================================================================================
1015 * \brief Add to the map of NodePoint's those on VERTEXes
1016 * \param [in,out] theHelper - the helper
1017 * \param [in] theMA - Medial Axis
1018 * \param [in] theMinSegLen - minimal segment length
1019 * \param [in] theDivPoints - projections of VERTEXes to MA
1020 * \param [in] theSinuEdges - the sinuous EDGEs
1021 * \param [in] theSideEdgeIDs - indices of sinuous EDGEs per side
1022 * \param [in] theIsEdgeComputed - is sinuous EDGE is meshed
1023 * \param [in,out] thePointsOnE - the map to fill
1024 * \param [out] theNodes2Merge - the map of nodes to merge
1026 //================================================================================
1028 bool projectVertices( SMESH_MesherHelper& theHelper,
1029 const SMESH_MAT2d::MedialAxis& theMA,
1030 vector< SMESH_MAT2d::BranchPoint >& theDivPoints,
1031 const vector< std::size_t > & theEdgeIDs1,
1032 const vector< std::size_t > & theEdgeIDs2,
1033 const vector< bool >& theIsEdgeComputed,
1034 TMAPar2NPoints & thePointsOnE,
1035 SinuousFace& theSinuFace)
1037 if ( theDivPoints.empty() )
1040 SMESHDS_Mesh* meshDS = theHelper.GetMeshDS();
1041 const vector< TopoDS_Edge >& theSinuEdges = theSinuFace._sinuEdges;
1042 const vector< Handle(Geom_Curve) >& theCurves = theSinuFace._sinuCurves;
1045 SMESH_MAT2d::BoundaryPoint bp[2]; // 2 sinuous sides
1046 const SMESH_MAT2d::Branch& branch = *theMA.getBranch(0);
1048 // add to thePointsOnE NodePoint's of ends of theSinuEdges
1049 if ( !branch.getBoundaryPoints( 0., bp[0], bp[1] ) ||
1050 !theMA.getBoundary().moveToClosestEdgeEnd( bp[0] )) return false;
1051 if ( !theSinuFace.IsRing() &&
1052 !theMA.getBoundary().moveToClosestEdgeEnd( bp[1] )) return false;
1053 NodePoint np0( bp[0] ), np1( bp[1] );
1054 findVertexAndNode( np0, theSinuEdges, meshDS );
1055 findVertexAndNode( np1, theSinuEdges, meshDS );
1056 thePointsOnE.insert( make_pair( -0.1, make_pair( np0, np1 )));
1058 if ( !theSinuFace.IsRing() )
1060 if ( !branch.getBoundaryPoints( 1., bp[0], bp[1] ) ||
1061 !theMA.getBoundary().moveToClosestEdgeEnd( bp[0] ) ||
1062 !theMA.getBoundary().moveToClosestEdgeEnd( bp[1] )) return false;
1063 NodePoint np0( bp[0] ), np1( bp[1] );
1064 findVertexAndNode( np0, theSinuEdges, meshDS );
1065 findVertexAndNode( np1, theSinuEdges, meshDS );
1066 thePointsOnE.insert( make_pair( 1.1, make_pair( np0, np1)));
1070 // project a VERTEX of outer sinuous side corresponding to branch(0.)
1071 // which is not included into theDivPoints
1072 if ( ! ( theDivPoints[0]._iEdge == 0 &&
1073 theDivPoints[0]._edgeParam == 0. )) // recursive call
1075 SMESH_MAT2d::BranchPoint brp( &branch, 0, 0. );
1076 vector< SMESH_MAT2d::BranchPoint > divPoint( 1, brp );
1077 vector< std::size_t > edgeIDs1(2), edgeIDs2(2);
1078 edgeIDs1[0] = theEdgeIDs1.back();
1079 edgeIDs1[1] = theEdgeIDs1[0];
1080 edgeIDs2[0] = theEdgeIDs2.back();
1081 edgeIDs2[1] = theEdgeIDs2[0];
1082 projectVertices( theHelper, theMA, divPoint, edgeIDs1, edgeIDs2,
1083 theIsEdgeComputed, thePointsOnE, theSinuFace );
1087 // project theDivPoints and keep projections to merge
1089 TMAPar2NPoints::iterator u2NP;
1090 vector< TMAPar2NPoints::iterator > projToMerge;
1091 for ( size_t i = 0; i < theDivPoints.size(); ++i )
1093 if ( !branch.getParameter( theDivPoints[i], uMA ))
1095 if ( !branch.getBoundaryPoints( theDivPoints[i], bp[0], bp[1] ))
1102 bool isVertex[2] = {
1103 findVertexAndNode( np[0], theSinuEdges, meshDS, theEdgeIDs1[i], theEdgeIDs1[i+1] ),
1104 findVertexAndNode( np[1], theSinuEdges, meshDS, theEdgeIDs2[i], theEdgeIDs2[i+1] )
1106 const size_t iVert = isVertex[0] ? 0 : 1; // side with a VERTEX
1107 const size_t iNode = 1 - iVert; // opposite (meshed?) side
1109 if ( isVertex[0] != isVertex[1] ) // try to find an opposite VERTEX
1111 theMA.getBoundary().moveToClosestEdgeEnd( bp[iNode] ); // EDGE -> VERTEX
1112 SMESH_MAT2d::BranchPoint brp;
1113 theMA.getBoundary().getBranchPoint( bp[iNode], brp ); // WIRE -> MA
1114 SMESH_MAT2d::BoundaryPoint bp2[2];
1115 branch.getBoundaryPoints( brp, bp2[0], bp2[1] ); // MA -> WIRE
1116 NodePoint np2[2] = { NodePoint( bp2[0]), NodePoint( bp2[1]) };
1117 findVertexAndNode( np2[0], theSinuEdges, meshDS );
1118 findVertexAndNode( np2[1], theSinuEdges, meshDS );
1119 if ( np2[ iVert ]._node == np[ iVert ]._node &&
1122 np[ iNode ] = np2[ iNode ];
1123 isVertex[ iNode ] = true;
1127 u2NP = thePointsOnE.insert( make_pair( uMA, make_pair( np[0], np[1])));
1129 if ( !isVertex[0] && !isVertex[1] ) return false; // error
1130 if ( isVertex[0] && isVertex[1] )
1133 // bool isOppComputed = theIsEdgeComputed[ np[ iNode ]._edgeInd ];
1134 // if ( isOppComputed )
1135 projToMerge.push_back( u2NP );
1138 // merge projections
1140 for ( size_t i = 0; i < projToMerge.size(); ++i )
1142 u2NP = projToMerge[i];
1143 const size_t iVert = get( u2NP->second, 0 )._node ? 0 : 1; // side with a VERTEX
1144 const size_t iNode = 1 - iVert; // opposite (meshed?) side
1146 // a VERTEX is projected on a meshed EDGE; there are two options:
1147 // 1) a projected point is joined with a closet node if a strip between this and neighbor
1148 // projection is WIDE enough; joining is done by creating a node coincident with the
1149 // existing node which will be merged together after all;
1150 // 2) a neighbor projection is merged with this one if it is TOO CLOSE; a node of deleted
1151 // projection is set to the BoundaryPoint of this projection
1153 // evaluate distance to neighbor projections
1154 const double rShort = 0.33;
1155 bool isShortPrev[2], isShortNext[2], isPrevCloser[2];
1156 TMAPar2NPoints::iterator u2NPPrev = u2NP, u2NPNext = u2NP;
1157 --u2NPPrev; ++u2NPNext;
1158 if ( u2NPNext == thePointsOnE.end() )
1159 u2NPNext = thePointsOnE.begin(); // hope theSinuFace.IsRing()
1160 for ( int iS = 0; iS < 2; ++iS ) // side with Vertex and side with Nodes
1162 NodePoint np = get( u2NP->second, iS );
1163 NodePoint npPrev = get( u2NPPrev->second, iS );
1164 NodePoint npNext = get( u2NPNext->second, iS );
1165 gp_Pnt p = np .Point( theCurves );
1166 gp_Pnt pPrev = npPrev.Point( theCurves );
1167 gp_Pnt pNext = npNext.Point( theCurves );
1168 double distPrev = p.Distance( pPrev );
1169 double distNext = p.Distance( pNext );
1170 double r = distPrev / ( distPrev + distNext );
1171 isShortPrev [iS] = ( r < rShort );
1172 isShortNext [iS] = (( 1 - r ) < rShort );
1173 isPrevCloser[iS] = (( r < 0.5 ) && ( theSinuFace.IsRing() || u2NPPrev->first > 0 ));
1176 TMAPar2NPoints::iterator u2NPClose;
1178 if (( isShortPrev[0] && isShortPrev[1] ) || // option 2) -> remove a too close projection
1179 ( isShortNext[0] && isShortNext[1] ))
1181 u2NPClose = isPrevCloser[0] ? u2NPPrev : u2NPNext;
1182 NodePoint& npProj = get( u2NP->second, iNode ); // NP of VERTEX projection
1183 NodePoint& npVert = get( u2NP->second, iVert ); // NP of VERTEX
1184 NodePoint npCloseN = get( u2NPClose->second, iNode ); // NP close to npProj
1185 NodePoint npCloseV = get( u2NPClose->second, iVert ); // NP close to npVert
1186 if ( !npCloseV._node || npCloseV._node == npVert._node )
1189 if ( i+1 < projToMerge.size() && u2NPClose == projToMerge[ i+1 ])
1191 thePointsOnE.erase( u2NPClose );
1196 // can't remove the neighbor projection as it is also from VERTEX -> option 1)
1199 // else: option 1) - wide enough -> "duplicate" existing node
1201 u2NPClose = isPrevCloser[ iNode ] ? u2NPPrev : u2NPNext;
1202 NodePoint& npProj = get( u2NP->second, iNode ); // NP of VERTEX projection
1203 NodePoint& npCloseN = get( u2NPClose->second, iNode ); // NP close to npProj
1206 //npProj._edgeInd = npCloseN._edgeInd;
1207 // npProj._u = npCloseN._u + 1e-3 * Abs( get( u2NPPrev->second, iNode )._u -
1208 // get( u2NPNext->second, iNode )._u );
1209 // gp_Pnt p = npProj.Point( theCurves );
1210 // npProj._node = meshDS->AddNode( p.X(), p.Y(), p.Z() );
1211 // meshDS->SetNodeOnEdge( npProj._node, theSinuEdges[ npProj._edgeInd ], npProj._u );
1213 //theNodes2Merge[ npCloseN._node ].push_back( npProj._node );
1217 // remove auxiliary NodePoint's of ends of theSinuEdges
1218 for ( u2NP = thePointsOnE.begin(); u2NP->first < 0; )
1219 thePointsOnE.erase( u2NP++ );
1220 thePointsOnE.erase( 1.1 );
1225 double getUOnEdgeByPoint( const size_t iEdge,
1226 const NodePoint* point,
1227 SinuousFace& sinuFace )
1229 if ( point->_edgeInd == iEdge )
1232 TopoDS_Vertex V0 = TopExp::FirstVertex( sinuFace._sinuEdges[ iEdge ]);
1233 TopoDS_Vertex V1 = TopExp::LastVertex ( sinuFace._sinuEdges[ iEdge ]);
1234 gp_Pnt p0 = BRep_Tool::Pnt( V0 );
1235 gp_Pnt p1 = BRep_Tool::Pnt( V1 );
1236 gp_Pnt p = point->Point( sinuFace._sinuCurves );
1239 BRep_Tool::Range( sinuFace._sinuEdges[ iEdge ], f,l );
1240 return p.SquareDistance( p0 ) < p.SquareDistance( p1 ) ? f : l;
1243 //================================================================================
1245 * \brief Move coincident nodes to make node params on EDGE unique
1246 * \param [in] theHelper - the helper
1247 * \param [in] thePointsOnE - nodes on two opposite river sides
1248 * \param [in] theSinuFace - the sinuous FACE
1249 * \param [out] theNodes2Merge - the map of nodes to merge
1251 //================================================================================
1253 void separateNodes( SMESH_MesherHelper& theHelper,
1254 const SMESH_MAT2d::MedialAxis& /*theMA*/,
1255 TMAPar2NPoints & thePointsOnE,
1256 SinuousFace& theSinuFace,
1257 const vector< bool >& theIsComputedEdge)
1259 if ( thePointsOnE.size() < 2 )
1262 SMESHDS_Mesh* meshDS = theHelper.GetMeshDS();
1263 const vector<TopoDS_Edge>& theSinuEdges = theSinuFace._sinuEdges;
1264 const vector< Handle(Geom_Curve) >& curves = theSinuFace._sinuCurves;
1266 //SMESH_MAT2d::BoundaryPoint bp[2];
1267 //const SMESH_MAT2d::Branch& branch = *theMA.getBranch(0);
1269 typedef TMAPar2NPoints::iterator TIterator;
1271 for ( int iSide = 0; iSide < 2; ++iSide ) // loop on two sinuous sides
1273 // get a tolerance to compare points
1274 double tol = Precision::Confusion();
1275 for ( size_t i = 0; i < theSinuFace._sinuSide[ iSide ].size(); ++i )
1276 tol = Max( tol , BRep_Tool::Tolerance( theSinuFace._sinuSide[ iSide ][ i ]));
1278 // find coincident points
1279 TIterator u2NP = thePointsOnE.begin();
1280 vector< TIterator > sameU2NP( 1, u2NP++ );
1281 while ( u2NP != thePointsOnE.end() )
1283 for ( ; u2NP != thePointsOnE.end(); ++u2NP )
1285 NodePoint& np1 = get( sameU2NP.back()->second, iSide );
1286 NodePoint& np2 = get( u2NP ->second, iSide );
1288 if (( !np1._node || !np2._node ) &&
1289 ( np1.Point( curves ).SquareDistance( np2.Point( curves )) < tol*tol ))
1291 sameU2NP.push_back( u2NP );
1293 else if ( sameU2NP.size() == 1 )
1295 sameU2NP[ 0 ] = u2NP;
1303 if ( sameU2NP.size() > 1 )
1305 // find an existing node on VERTEX among sameU2NP and get underlying EDGEs
1306 const SMDS_MeshNode* existingNode = 0;
1307 set< size_t > edgeInds;
1309 for ( size_t i = 0; i < sameU2NP.size(); ++i )
1311 np = &get( sameU2NP[i]->second, iSide );
1313 if ( !existingNode || np->_node->GetPosition()->GetDim() == 0 )
1314 existingNode = np->_node;
1315 edgeInds.insert( np->_edgeInd );
1317 list< const SMDS_MeshNode* >& mergeNodes = theSinuFace._nodesToMerge[ existingNode ];
1319 TIterator u2NPprev = sameU2NP.front();
1320 TIterator u2NPnext = sameU2NP.back() ;
1321 if ( u2NPprev->first < 0. ) ++u2NPprev;
1322 if ( u2NPnext->first > 1. ) --u2NPnext;
1324 set< size_t >::iterator edgeID = edgeInds.begin();
1325 for ( ; edgeID != edgeInds.end(); ++edgeID )
1327 // get U range on iEdge within which the equal points will be distributed
1329 np = &get( u2NPprev->second, iSide );
1330 u0 = getUOnEdgeByPoint( *edgeID, np, theSinuFace );
1332 np = &get( u2NPnext->second, iSide );
1333 u1 = getUOnEdgeByPoint( *edgeID, np, theSinuFace );
1337 if ( u2NPprev != thePointsOnE.begin() ) --u2NPprev;
1338 if ( u2NPnext != --thePointsOnE.end() ) ++u2NPnext;
1339 np = &get( u2NPprev->second, iSide );
1340 u0 = getUOnEdgeByPoint( *edgeID, np, theSinuFace );
1341 np = &get( u2NPnext->second, iSide );
1342 u1 = getUOnEdgeByPoint( *edgeID, np, theSinuFace );
1345 // distribute points and create nodes
1346 double du = ( u1 - u0 ) / ( sameU2NP.size() + 1 /*!existingNode*/ );
1348 for ( size_t i = 0; i < sameU2NP.size(); ++i )
1350 np = &get( sameU2NP[i]->second, iSide );
1351 if ( !np->_node && *edgeID == np->_edgeInd )
1355 gp_Pnt p = np->Point( curves );
1356 np->_node = meshDS->AddNode( p.X(), p.Y(), p.Z() );
1357 meshDS->SetNodeOnEdge( np->_node, theSinuEdges[ *edgeID ], np->_u );
1359 if ( theIsComputedEdge[ *edgeID ])
1360 mergeNodes.push_back( np->_node );
1365 sameU2NP.resize( 1 );
1366 u2NP = ++sameU2NP.back();
1367 sameU2NP[ 0 ] = u2NP;
1369 } // if ( sameU2NP.size() > 1 )
1370 } // while ( u2NP != thePointsOnE.end() )
1371 } // for ( int iSide = 0; iSide < 2; ++iSide )
1374 } // separateNodes()
1377 //================================================================================
1379 * \brief Find association of nodes existing on the sinuous sides of a ring
1381 * TMAPar2NPoints filled here is used in setQuadSides() only if theSinuFace.IsRing()
1382 * to find most distant nodes of the inner and the outer wires
1384 //================================================================================
1386 void assocNodes( SMESH_MesherHelper& theHelper,
1387 SinuousFace& theSinuFace,
1388 const SMESH_MAT2d::MedialAxis& theMA,
1389 TMAPar2NPoints & thePointsOnE )
1391 SMESH_Mesh* mesh = theHelper.GetMesh();
1392 SMESHDS_Mesh* meshDS = theHelper.GetMeshDS();
1394 list< TopoDS_Edge > ee1( theSinuFace._sinuSide [0].begin(), theSinuFace._sinuSide [0].end() );
1395 list< TopoDS_Edge > ee2( theSinuFace._sinuSide [1].begin(), theSinuFace._sinuSide [1].end() );
1396 StdMeshers_FaceSide sideOut( theSinuFace.Face(), ee1, mesh, true, true, &theHelper );
1397 StdMeshers_FaceSide sideIn ( theSinuFace.Face(), ee2, mesh, true, true, &theHelper );
1398 const UVPtStructVec& uvsOut = sideOut.GetUVPtStruct();
1399 const UVPtStructVec& uvsIn = sideIn.GetUVPtStruct();
1400 // if ( uvs1.size() != uvs2.size() )
1403 const SMESH_MAT2d::Branch& branch = *theMA.getBranch(0);
1404 SMESH_MAT2d::BoundaryPoint bp[2];
1405 SMESH_MAT2d::BranchPoint brp;
1407 map< double, const SMDS_MeshNode* > nodeParams; // params of existing nodes
1408 map< double, const SMDS_MeshNode* >::iterator u2n;
1410 // find a node of sideOut most distant from sideIn
1412 vector< BRepAdaptor_Curve > curvesIn( theSinuFace._sinuSide[1].size() );
1413 for ( size_t iE = 0; iE < theSinuFace._sinuSide[1].size(); ++iE )
1414 curvesIn[ iE ].Initialize( theSinuFace._sinuSide[1][iE] );
1417 SMESH_MAT2d::BoundaryPoint bpIn; // closest IN point
1418 const SMDS_MeshNode* nOut = 0;
1419 const size_t nbEOut = theSinuFace._sinuSide[0].size();
1420 for ( size_t iE = 0; iE < nbEOut; ++iE )
1422 const TopoDS_Edge& E = theSinuFace._sinuSide[0][iE];
1424 if ( !SMESH_Algo::GetSortedNodesOnEdge( meshDS, E, /*skipMedium=*/true, nodeParams ))
1426 for ( u2n = nodeParams.begin(); u2n != nodeParams.end(); ++u2n )
1428 // point on EDGE (u2n) --> MA point (brp)
1429 if ( !theMA.getBoundary().getBranchPoint( iE, u2n->first, brp ) ||
1430 !branch.getBoundaryPoints( brp, bp[0], bp[1] ))
1432 gp_Pnt pOut = SMESH_TNodeXYZ( u2n->second );
1433 gp_Pnt pIn = curvesIn[ bp[1]._edgeIndex - nbEOut ].Value( bp[1]._param );
1434 double dist = pOut.SquareDistance( pIn );
1435 if ( dist > maxDist )
1443 const SMDS_MeshNode* nIn = 0;
1444 if ( !SMESH_Algo::GetSortedNodesOnEdge( meshDS,
1445 theSinuFace._sinuEdges[ bpIn._edgeIndex ],
1446 /*skipMedium=*/true,
1449 u2n = nodeParams.lower_bound( bpIn._param );
1450 if ( u2n == nodeParams.end() )
1451 nIn = nodeParams.rbegin()->second;
1455 // find position of distant nodes in uvsOut and uvsIn
1456 size_t iDistOut, iDistIn;
1457 for ( iDistOut = 0; iDistOut < uvsOut.size(); ++iDistOut )
1459 if ( uvsOut[iDistOut].node == nOut )
1462 for ( iDistIn = 0; iDistIn < uvsIn.size(); ++iDistIn )
1464 if ( uvsIn[iDistIn].node == nIn )
1467 if ( iDistOut == uvsOut.size() || iDistIn == uvsIn.size() )
1470 // store opposite nodes in thePointsOnE (param and EDGE have no sense)
1471 pair< NodePoint, NodePoint > oppNodes( NodePoint( nOut, 0, 0 ), NodePoint( nIn, 0, 0));
1472 thePointsOnE.insert( make_pair( uvsOut[ iDistOut ].normParam, oppNodes ));
1473 int iOut = iDistOut, iIn = iDistIn;
1474 int i, nbNodes = std::min( uvsOut.size(), uvsIn.size() );
1475 if ( nbNodes > 5 ) nbNodes = 5;
1476 for ( i = 0, ++iOut, --iIn; i < nbNodes; ++iOut, --iIn, ++i )
1478 iOut = theHelper.WrapIndex( iOut, uvsOut.size() );
1479 iIn = theHelper.WrapIndex( iIn, uvsIn.size() );
1480 oppNodes.first._node = uvsOut[ iOut ].node;
1481 oppNodes.second._node = uvsIn[ iIn ].node;
1482 thePointsOnE.insert( make_pair( uvsOut[ iOut ].normParam, oppNodes ));
1488 //================================================================================
1490 * \brief Setup sides of SinuousFace::_quad
1491 * \param [in] theHelper - helper
1492 * \param [in] thePointsOnEdges - NodePoint's on sinuous sides
1493 * \param [in,out] theSinuFace - the FACE
1494 * \param [in] the1dAlgo - algorithm to use for radial discretization of a ring FACE
1495 * \return bool - is OK
1497 //================================================================================
1499 bool setQuadSides(SMESH_MesherHelper& theHelper,
1500 const TMAPar2NPoints& thePointsOnEdges,
1501 SinuousFace& theFace,
1502 SMESH_Algo* the1dAlgo)
1504 SMESH_Mesh* mesh = theHelper.GetMesh();
1505 const TopoDS_Face& face = theFace._quad->face;
1506 SMESH_ProxyMesh::Ptr proxyMesh = StdMeshers_ViscousLayers2D::Compute( *mesh, face );
1510 list< TopoDS_Edge > side[4];
1511 side[0].insert( side[0].end(), theFace._shortSide[0].begin(), theFace._shortSide[0].end() );
1512 side[1].insert( side[1].end(), theFace._sinuSide [1].begin(), theFace._sinuSide [1].end() );
1513 side[2].insert( side[2].end(), theFace._shortSide[1].begin(), theFace._shortSide[1].end() );
1514 side[3].insert( side[3].end(), theFace._sinuSide [0].begin(), theFace._sinuSide [0].end() );
1516 for ( int i = 0; i < 4; ++i )
1518 theFace._quad->side[i] = StdMeshers_FaceSide::New( face, side[i], mesh, i < QUAD_TOP_SIDE,
1519 /*skipMediumNodes=*/true,
1520 &theHelper, proxyMesh );
1523 if ( theFace.IsRing() )
1525 // --------------------------------------
1526 // Discretize a ring in radial direction
1527 // --------------------------------------
1529 if ( thePointsOnEdges.size() < 4 )
1532 int nbOut = theFace._quad->side[ 1 ].GetUVPtStruct().size();
1533 int nbIn = theFace._quad->side[ 3 ].GetUVPtStruct().size();
1534 if ( nbOut == 0 || nbIn == 0 )
1537 // find most distant opposite nodes
1538 double maxDist = 0, dist;
1539 TMAPar2NPoints::const_iterator u2NPdist, u2NP = thePointsOnEdges.begin();
1540 for ( ; u2NP != thePointsOnEdges.end(); ++u2NP )
1542 SMESH_TNodeXYZ xyz( u2NP->second.first._node ); // node out
1543 dist = xyz.SquareDistance( u2NP->second.second._node );// node in
1544 if ( dist > maxDist )
1550 // compute distribution of radial nodes
1551 list< double > params; // normalized params
1552 static_cast< StdMeshers_QuadFromMedialAxis_1D2D::Algo1D* >
1553 ( the1dAlgo )->ComputeDistribution( theHelper,
1554 SMESH_TNodeXYZ( u2NPdist->second.first._node ),
1555 SMESH_TNodeXYZ( u2NPdist->second.second._node ),
1558 // add a radial quad side
1560 theHelper.SetElementsOnShape( true );
1561 u2NP = thePointsOnEdges.begin();
1562 const SMDS_MeshNode* nOut = u2NP->second.first._node;
1563 const SMDS_MeshNode* nIn = u2NP->second.second._node;
1564 nOut = proxyMesh->GetProxyNode( nOut );
1565 nIn = proxyMesh->GetProxyNode( nIn );
1566 gp_XY uvOut = theHelper.GetNodeUV( face, nOut );
1567 gp_XY uvIn = theHelper.GetNodeUV( face, nIn );
1568 Handle(Geom_Surface) surface = BRep_Tool::Surface( face );
1569 UVPtStructVec uvsNew; UVPtStruct uvPt;
1573 uvsNew.push_back( uvPt );
1574 for (list<double>::iterator itU = params.begin(); itU != params.end(); ++itU )
1576 gp_XY uv = ( 1 - *itU ) * uvOut + *itU * uvIn; // applied in direction Out -> In
1577 gp_Pnt p = surface->Value( uv.X(), uv.Y() );
1578 uvPt.node = theHelper.AddNode( p.X(), p.Y(), p.Z(), /*id=*/0, uv.X(), uv.Y() );
1581 uvsNew.push_back( uvPt );
1586 uvsNew.push_back( uvPt );
1588 theFace._quad->side[ 0 ] = StdMeshers_FaceSide::New( uvsNew );
1589 theFace._quad->side[ 2 ] = theFace._quad->side[ 0 ];
1590 if ( nbIn != nbOut )
1591 theFace._quad->side[ 2 ] = StdMeshers_FaceSide::New( uvsNew );
1593 // assure that the outer sinuous side starts at nOut
1595 const UVPtStructVec& uvsOut = theFace._quad->side[ 3 ].GetUVPtStruct(); // _sinuSide[0]
1596 size_t i; // find UVPtStruct holding nOut
1597 for ( i = 0; i < uvsOut.size(); ++i )
1598 if ( nOut == uvsOut[i].node )
1600 if ( i == uvsOut.size() )
1603 if ( i != 0 && i != uvsOut.size()-1 )
1605 // create a new OUT quad side
1607 uvsNew.reserve( uvsOut.size() );
1608 uvsNew.insert( uvsNew.end(), uvsOut.begin() + i, uvsOut.end() );
1609 uvsNew.insert( uvsNew.end(), uvsOut.begin() + 1, uvsOut.begin() + i + 1);
1610 theFace._quad->side[ 3 ] = StdMeshers_FaceSide::New( uvsNew );
1614 // rotate the IN side if opposite nodes of IN and OUT sides don't match
1616 const SMDS_MeshNode * nIn0 = theFace._quad->side[ 1 ].First().node;
1619 nIn = proxyMesh->GetProxyNode( nIn );
1620 const UVPtStructVec& uvsIn = theFace._quad->side[ 1 ].GetUVPtStruct(); // _sinuSide[1]
1621 size_t i; // find UVPtStruct holding nIn
1622 for ( i = 0; i < uvsIn.size(); ++i )
1623 if ( nIn == uvsIn[i].node )
1625 if ( i == uvsIn.size() )
1628 // create a new IN quad side
1630 uvsNew.reserve( uvsIn.size() );
1631 uvsNew.insert( uvsNew.end(), uvsIn.begin() + i, uvsIn.end() );
1632 uvsNew.insert( uvsNew.end(), uvsIn.begin() + 1, uvsIn.begin() + i + 1);
1633 theFace._quad->side[ 1 ] = StdMeshers_FaceSide::New( uvsNew );
1636 if ( theFace._quad->side[ 1 ].GetUVPtStruct().empty() ||
1637 theFace._quad->side[ 3 ].GetUVPtStruct().empty() )
1640 } // if ( theFace.IsRing() )
1646 //================================================================================
1648 * \brief Divide the sinuous EDGEs by projecting the division point of Medial
1650 * \param [in] theHelper - the helper
1651 * \param [in] theMinSegLen - minimal segment length
1652 * \param [in] theMA - the Medial Axis
1653 * \param [in] theMAParams - parameters of division points of \a theMA
1654 * \param [in] theSinuEdges - the EDGEs to make nodes on
1655 * \param [in] theSinuSide0Size - the number of EDGEs in the 1st sinuous side
1656 * \param [in] the1dAlgo - algorithm to use for radial discretization of a ring FACE
1657 * \return bool - is OK or not
1659 //================================================================================
1661 bool computeSinuEdges( SMESH_MesherHelper& theHelper,
1662 double /*theMinSegLen*/,
1663 SMESH_MAT2d::MedialAxis& theMA,
1664 vector<double>& theMAParams,
1665 SinuousFace& theSinuFace,
1666 SMESH_Algo* the1dAlgo)
1668 if ( theMA.nbBranches() != 1 )
1671 // normalize theMAParams
1672 for ( size_t i = 0; i < theMAParams.size(); ++i )
1673 theMAParams[i] /= theMAParams.back();
1676 SMESH_Mesh* mesh = theHelper.GetMesh();
1677 SMESHDS_Mesh* meshDS = theHelper.GetMeshDS();
1680 // get data of sinuous EDGEs and remove unnecessary nodes
1681 const vector< TopoDS_Edge >& theSinuEdges = theSinuFace._sinuEdges;
1682 vector< Handle(Geom_Curve) >& curves = theSinuFace._sinuCurves;
1683 vector< int > edgeIDs ( theSinuEdges.size() ); // IDs in the main shape
1684 vector< bool > isComputed( theSinuEdges.size() );
1685 curves.resize( theSinuEdges.size(), 0 );
1686 bool allComputed = true;
1687 for ( size_t i = 0; i < theSinuEdges.size(); ++i )
1689 curves[i] = BRep_Tool::Curve( theSinuEdges[i], f,l );
1692 SMESH_subMesh* sm = mesh->GetSubMesh( theSinuEdges[i] );
1693 edgeIDs [i] = sm->GetId();
1694 isComputed[i] = ( !sm->IsEmpty() );
1695 if ( !isComputed[i] )
1696 allComputed = false;
1699 const SMESH_MAT2d::Branch& branch = *theMA.getBranch(0);
1700 SMESH_MAT2d::BoundaryPoint bp[2];
1702 TMAPar2NPoints pointsOnE;
1703 // check that computed EDGEs are opposite and equally meshed
1706 // int nbNodes[2] = { 0, 0 };
1707 // for ( int iSide = 0; iSide < 2; ++iSide ) // loop on two sinuous sides
1708 // nbNodes[ iSide ] += meshDS->MeshElements( theSinuFace._sinuSide[ iSide ])->NbNodes() - 1;
1710 // if ( nbNodes[0] != nbNodes[1] )
1713 if ( theSinuFace.IsRing() )
1714 assocNodes( theHelper, theSinuFace, theMA, pointsOnE );
1718 vector< std::size_t > edgeIDs1, edgeIDs2; // indices in theSinuEdges
1719 vector< SMESH_MAT2d::BranchPoint > divPoints;
1720 branch.getOppositeGeomEdges( edgeIDs1, edgeIDs2, divPoints );
1722 for ( size_t i = 0; i < edgeIDs1.size(); ++i )
1723 if ( isComputed[ edgeIDs1[i]] &&
1724 isComputed[ edgeIDs2[i]] )
1726 smIdType nbNodes1 = meshDS->MeshElements(edgeIDs[ edgeIDs1[i]] )->NbNodes();
1727 smIdType nbNodes2 = meshDS->MeshElements(edgeIDs[ edgeIDs2[i]] )->NbNodes();
1728 if ( nbNodes1 != nbNodes2 )
1730 if (( int(i)-1 >= 0 ) &&
1731 ( edgeIDs1[i-1] == edgeIDs1[i] ||
1732 edgeIDs2[i-1] == edgeIDs2[i] ))
1734 if (( i+1 < edgeIDs1.size() ) &&
1735 ( edgeIDs1[i+1] == edgeIDs1[i] ||
1736 edgeIDs2[i+1] == edgeIDs2[i] ))
1740 // map (param on MA) to (parameters of nodes on a pair of theSinuEdges)
1741 vector<double> maParams;
1742 set<int> projectedEdges; // treated EDGEs which 'isComputed'
1744 // compute params of nodes on EDGEs by projecting division points from MA
1746 for ( size_t iEdgePair = 0; iEdgePair < edgeIDs1.size(); ++iEdgePair )
1747 // loop on pairs of opposite EDGEs
1749 if ( projectedEdges.count( edgeIDs1[ iEdgePair ]) ||
1750 projectedEdges.count( edgeIDs2[ iEdgePair ]) )
1753 // --------------------------------------------------------------------------------
1754 if ( isComputed[ edgeIDs1[ iEdgePair ]] != // one EDGE is meshed
1755 isComputed[ edgeIDs2[ iEdgePair ]])
1757 // "projection" from one side to the other
1759 size_t iEdgeComputed = edgeIDs1[iEdgePair], iSideComputed = 0;
1760 if ( !isComputed[ iEdgeComputed ])
1761 ++iSideComputed, iEdgeComputed = edgeIDs2[iEdgePair];
1763 map< double, const SMDS_MeshNode* > nodeParams; // params of existing nodes
1764 if ( !SMESH_Algo::GetSortedNodesOnEdge( meshDS, theSinuEdges[ iEdgeComputed ], /*skipMedium=*/true, nodeParams ))
1767 projectedEdges.insert( iEdgeComputed );
1769 SMESH_MAT2d::BoundaryPoint& bndPnt = bp[ 1-iSideComputed ];
1770 SMESH_MAT2d::BranchPoint brp;
1771 NodePoint npN, npB; // NodePoint's initialized by node and BoundaryPoint
1772 NodePoint& np0 = iSideComputed ? npB : npN;
1773 NodePoint& np1 = iSideComputed ? npN : npB;
1775 double maParam1st, maParamLast, maParam;
1776 if ( !theMA.getBoundary().getBranchPoint( iEdgeComputed, nodeParams.begin()->first, brp ))
1778 branch.getParameter( brp, maParam1st );
1779 if ( !theMA.getBoundary().getBranchPoint( iEdgeComputed, nodeParams.rbegin()->first, brp ))
1781 branch.getParameter( brp, maParamLast );
1783 map< double, const SMDS_MeshNode* >::iterator u2n = nodeParams.begin(), u2nEnd = nodeParams.end();
1784 TMAPar2NPoints::iterator end = pointsOnE.end(), pos = end;
1785 TMAPar2NPoints::iterator & hint = (maParamLast > maParam1st) ? end : pos;
1786 for ( ++u2n, --u2nEnd; u2n != u2nEnd; ++u2n )
1788 // point on EDGE (u2n) --> MA point (brp)
1789 if ( !theMA.getBoundary().getBranchPoint( iEdgeComputed, u2n->first, brp ))
1791 // MA point --> points on 2 EDGEs (bp)
1792 if ( !branch.getBoundaryPoints( brp, bp[0], bp[1] ) ||
1793 !branch.getParameter( brp, maParam ))
1796 npN = NodePoint( u2n->second, u2n->first, iEdgeComputed );
1797 npB = NodePoint( bndPnt );
1798 pos = pointsOnE.insert( hint, make_pair( maParam, make_pair( np0, np1 )));
1801 // --------------------------------------------------------------------------------
1802 else if ( !isComputed[ edgeIDs1[ iEdgePair ]] && // none of EDGEs is meshed
1803 !isComputed[ edgeIDs2[ iEdgePair ]])
1805 // "projection" from MA
1807 if ( !getParamsForEdgePair( iEdgePair, divPoints, theMAParams, maParams ))
1810 for ( size_t i = 1; i < maParams.size()-1; ++i )
1812 if ( !branch.getBoundaryPoints( maParams[i], bp[0], bp[1] ))
1815 pointsOnE.insert( pointsOnE.end(), make_pair( maParams[i], make_pair( NodePoint(bp[0]),
1816 NodePoint(bp[1]))));
1819 // --------------------------------------------------------------------------------
1820 else if ( isComputed[ edgeIDs1[ iEdgePair ]] && // equally meshed EDGES
1821 isComputed[ edgeIDs2[ iEdgePair ]])
1823 // add existing nodes
1825 size_t iE0 = edgeIDs1[ iEdgePair ];
1826 size_t iE1 = edgeIDs2[ iEdgePair ];
1827 map< double, const SMDS_MeshNode* > nodeParams[2]; // params of existing nodes
1828 if ( !SMESH_Algo::GetSortedNodesOnEdge( meshDS, theSinuEdges[ iE0 ],
1829 /*skipMedium=*/false, nodeParams[0] ) ||
1830 !SMESH_Algo::GetSortedNodesOnEdge( meshDS, theSinuEdges[ iE1 ],
1831 /*skipMedium=*/false, nodeParams[1] ) ||
1832 nodeParams[0].size() != nodeParams[1].size() )
1835 if ( nodeParams[0].size() <= 2 )
1836 continue; // nodes on VERTEXes only
1838 bool reverse = ( theSinuEdges[0].Orientation() == theSinuEdges[1].Orientation() );
1840 SMESH_MAT2d::BranchPoint brp;
1841 std::pair< NodePoint, NodePoint > npPair;
1843 map< double, const SMDS_MeshNode* >::iterator
1844 u2n0F = ++nodeParams[0].begin(),
1845 u2n1F = ++nodeParams[1].begin();
1846 map< double, const SMDS_MeshNode* >::reverse_iterator
1847 u2n1R = ++nodeParams[1].rbegin();
1848 for ( ; u2n0F != nodeParams[0].end(); ++u2n0F )
1850 if ( !theMA.getBoundary().getBranchPoint( iE0, u2n0F->first, brp ) ||
1851 !branch.getParameter( brp, maParam ))
1854 npPair.first = NodePoint( u2n0F->second, u2n0F->first, iE0 );
1857 npPair.second = NodePoint( u2n1R->second, u2n1R->first, iE1 );
1862 npPair.second = NodePoint( u2n1F->second, u2n1F->first, iE1 );
1865 pointsOnE.insert( make_pair( maParam, npPair ));
1868 } // loop on pairs of opposite EDGEs
1870 if ( !projectVertices( theHelper, theMA, divPoints, edgeIDs1, edgeIDs2,
1871 isComputed, pointsOnE, theSinuFace ))
1874 separateNodes( theHelper, theMA, pointsOnE, theSinuFace, isComputed );
1877 TMAPar2NPoints::iterator u2np = pointsOnE.begin();
1878 for ( ; u2np != pointsOnE.end(); ++u2np )
1880 NodePoint* np[2] = { & u2np->second.first, & u2np->second.second };
1881 for ( int iSide = 0; iSide < 2; ++iSide )
1883 if ( np[ iSide ]->_node ) continue;
1884 size_t iEdge = np[ iSide ]->_edgeInd;
1885 double u = np[ iSide ]->_u;
1886 gp_Pnt p = curves[ iEdge ]->Value( u );
1887 np[ iSide ]->_node = meshDS->AddNode( p.X(), p.Y(), p.Z() );
1888 meshDS->SetNodeOnEdge( np[ iSide ]->_node, edgeIDs[ iEdge ], u );
1892 // create mesh segments on EDGEs
1893 theHelper.SetElementsOnShape( false );
1894 TopoDS_Face face = TopoDS::Face( theHelper.GetSubShape() );
1895 for ( size_t i = 0; i < theSinuEdges.size(); ++i )
1897 SMESH_subMesh* sm = mesh->GetSubMesh( theSinuEdges[i] );
1898 if ( sm->GetSubMeshDS() && sm->GetSubMeshDS()->NbElements() > 0 )
1901 StdMeshers_FaceSide side( face, theSinuEdges[i], mesh,
1902 /*isFwd=*/true, /*skipMediumNodes=*/true, &theHelper );
1903 vector<const SMDS_MeshNode*> nodes = side.GetOrderedNodes();
1904 for ( size_t in = 1; in < nodes.size(); ++in )
1906 const SMDS_MeshElement* seg = theHelper.AddEdge( nodes[in-1], nodes[in], 0, false );
1907 meshDS->SetMeshElementOnShape( seg, edgeIDs[ i ] );
1911 // update sub-meshes on VERTEXes
1912 for ( size_t i = 0; i < theSinuEdges.size(); ++i )
1914 mesh->GetSubMesh( theHelper.IthVertex( 0, theSinuEdges[i] ))
1915 ->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
1916 mesh->GetSubMesh( theHelper.IthVertex( 1, theSinuEdges[i] ))
1917 ->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
1921 // Setup sides of a quadrangle
1922 if ( !setQuadSides( theHelper, pointsOnE, theSinuFace, the1dAlgo ))
1928 //================================================================================
1930 * \brief Mesh short EDGEs
1932 //================================================================================
1934 bool computeShortEdges( SMESH_MesherHelper& theHelper,
1935 const vector<TopoDS_Edge>& theShortEdges,
1936 SMESH_Algo* the1dAlgo,
1937 const bool theHasRadialHyp,
1938 const bool /*theIs2nd*/)
1940 SMESH_Hypothesis::Hypothesis_Status aStatus;
1941 for ( size_t i = 0; i < theShortEdges.size(); ++i )
1943 if ( !theHasRadialHyp )
1945 theHelper.GetGen()->Compute( *theHelper.GetMesh(), theShortEdges[i],
1946 SMESH_Gen::SHAPE_ONLY_UPWARD );
1948 SMESH_subMesh* sm = theHelper.GetMesh()->GetSubMesh(theShortEdges[i] );
1949 if ( sm->IsEmpty() )
1951 // use 2D hyp or minSegLen
1954 SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/false);
1955 while ( smIt->more() )
1956 smIt->next()->ComputeStateEngine( SMESH_subMesh::COMPUTE );
1959 the1dAlgo->CheckHypothesis( *theHelper.GetMesh(), theShortEdges[i], aStatus );
1960 if ( !the1dAlgo->Compute( *theHelper.GetMesh(), theShortEdges[i] ))
1966 sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
1967 if ( sm->IsEmpty() )
1974 inline double area( const UVPtStruct& p1, const UVPtStruct& p2, const UVPtStruct& p3 )
1976 gp_XY v1 = p2.UV() - p1.UV();
1977 gp_XY v2 = p3.UV() - p1.UV();
1981 bool ellipticSmooth( FaceQuadStruct::Ptr quad, int nbLoops )
1984 if ( quad->uv_grid.empty() )
1987 int nbhoriz = quad->iSize;
1988 int nbvertic = quad->jSize;
1990 const double dksi = 0.5, deta = 0.5;
1991 const double dksi2 = dksi*dksi, deta2 = deta*deta;
1992 double err = 0., g11, g22, g12;
1995 FaceQuadStruct& q = *quad;
1998 //double refArea = area( q.UVPt(0,0), q.UVPt(1,0), q.UVPt(1,1) );
2000 for ( int iLoop = 0; iLoop < nbLoops; ++iLoop )
2003 for ( int i = 1; i < nbhoriz - 1; i++ )
2004 for ( int j = 1; j < nbvertic - 1; j++ )
2006 g11 = ( (q.U(i,j+1) - q.U(i,j-1))*(q.U(i,j+1) - q.U(i,j-1))/dksi2 +
2007 (q.V(i,j+1) - q.V(i,j-1))*(q.V(i,j+1) - q.V(i,j-1))/deta2 )/4;
2009 g22 = ( (q.U(i+1,j) - q.U(i-1,j))*(q.U(i+1,j) - q.U(i-1,j))/dksi2 +
2010 (q.V(i+1,j) - q.V(i-1,j))*(q.V(i+1,j) - q.V(i-1,j))/deta2 )/4;
2012 g12 = ( (q.U(i+1,j) - q.U(i-1,j))*(q.U(i,j+1) - q.U(i,j-1))/dksi2 +
2013 (q.V(i+1,j) - q.V(i-1,j))*(q.V(i,j+1) - q.V(i,j-1))/deta2 )/(4*dksi*deta);
2015 pNew.u = dksi2/(2*(g11+g22)) * (g11*(q.U(i+1,j) + q.U(i-1,j))/dksi2 +
2016 g22*(q.U(i,j+1) + q.U(i,j-1))/dksi2
2017 - 0.5*g12*q.U(i+1,j+1) + 0.5*g12*q.U(i-1,j+1) +
2018 - 0.5*g12*q.U(i-1,j-1) + 0.5*g12*q.U(i+1,j-1));
2020 pNew.v = deta2/(2*(g11+g22)) * (g11*(q.V(i+1,j) + q.V(i-1,j))/deta2 +
2021 g22*(q.V(i,j+1) + q.V(i,j-1))/deta2
2022 - 0.5*g12*q.V(i+1,j+1) + 0.5*g12*q.V(i-1,j+1) +
2023 - 0.5*g12*q.V(i-1,j-1) + 0.5*g12*q.V(i+1,j-1));
2025 // if (( refArea * area( q.UVPt(i-1,j-1), q.UVPt(i,j-1), pNew ) > 0 ) &&
2026 // ( refArea * area( q.UVPt(i+1,j-1), q.UVPt(i+1,j), pNew ) > 0 ) &&
2027 // ( refArea * area( q.UVPt(i+1,j+1), q.UVPt(i,j+1), pNew ) > 0 ) &&
2028 // ( refArea * area( q.UVPt(i-1,j), q.UVPt(i-1,j-1), pNew ) > 0 ))
2030 err += sqrt(( q.U(i,j) - pNew.u ) * ( q.U(i,j) - pNew.u ) +
2031 ( q.V(i,j) - pNew.v ) * ( q.V(i,j) - pNew.v ));
2035 // else if ( ++nbErr < 10 )
2037 // cout << i << ", " << j << endl;
2039 // << "[ " << q.U(i-1,j-1) << ", " <<q.U(i,j-1) << ", " << q.U(i+1,j-1) << " ],"
2040 // << "[ " << q.U(i-1,j-0) << ", " <<q.U(i,j-0) << ", " << q.U(i+1,j-0) << " ],"
2041 // << "[ " << q.U(i-1,j+1) << ", " <<q.U(i,j+1) << ", " << q.U(i+1,j+1) << " ]]" << endl;
2043 // << "[ " << q.V(i-1,j-1) << ", " <<q.V(i,j-1) << ", " << q.V(i+1,j-1) << " ],"
2044 // << "[ " << q.V(i-1,j-0) << ", " <<q.V(i,j-0) << ", " << q.V(i+1,j-0) << " ],"
2045 // << "[ " << q.V(i-1,j+1) << ", " <<q.V(i,j+1) << ", " << q.V(i+1,j+1) << " ]]" << endl<<endl;
2049 if ( err / ( nbhoriz - 2 ) / ( nbvertic - 2 ) < 1e-6 )
2052 //cout << " ERR " << err / ( nbhoriz - 2 ) / ( nbvertic - 2 ) << endl;
2057 //================================================================================
2059 * \brief Remove temporary node
2061 //================================================================================
2063 void mergeNodes( SMESH_MesherHelper& theHelper,
2064 SinuousFace& theSinuFace )
2066 SMESH_MeshEditor editor( theHelper.GetMesh() );
2067 SMESH_MeshEditor::TListOfListOfNodes nodesGroups;
2069 TMergeMap::iterator n2nn = theSinuFace._nodesToMerge.begin();
2070 for ( ; n2nn != theSinuFace._nodesToMerge.end(); ++n2nn )
2072 if ( !n2nn->first ) continue;
2073 nodesGroups.push_back( list< const SMDS_MeshNode* >() );
2074 list< const SMDS_MeshNode* > & group = nodesGroups.back();
2076 group.push_back( n2nn->first );
2077 group.splice( group.end(), n2nn->second );
2079 editor.MergeNodes( nodesGroups );
2084 //================================================================================
2086 * \brief Sets event listener which removes mesh from EDGEs when 2D hyps change
2088 //================================================================================
2090 void StdMeshers_QuadFromMedialAxis_1D2D::SetEventListener(SMESH_subMesh* faceSubMesh)
2092 faceSubMesh->SetEventListener( new EdgeCleaner, 0, faceSubMesh );
2095 //================================================================================
2097 * \brief Create quadrangle elements
2098 * \param [in] theHelper - the helper
2099 * \param [in] theFace - the face to mesh
2100 * \param [in] theSinuEdges - the sinuous EDGEs
2101 * \param [in] theShortEdges - the short EDGEs
2102 * \return bool - is OK or not
2104 //================================================================================
2106 bool StdMeshers_QuadFromMedialAxis_1D2D::computeQuads( SMESH_MesherHelper& theHelper,
2107 FaceQuadStruct::Ptr theQuad)
2109 StdMeshers_Quadrangle_2D::myHelper = &theHelper;
2110 StdMeshers_Quadrangle_2D::myNeedSmooth = false;
2111 StdMeshers_Quadrangle_2D::myCheckOri = false;
2112 StdMeshers_Quadrangle_2D::myQuadList.clear();
2114 int nbNodesShort0 = theQuad->side[0].NbPoints();
2115 int nbNodesShort1 = theQuad->side[2].NbPoints();
2116 int nbNodesSinu0 = theQuad->side[1].NbPoints();
2117 int nbNodesSinu1 = theQuad->side[3].NbPoints();
2119 // compute UV of internal points
2120 myQuadList.push_back( theQuad );
2121 // if ( !StdMeshers_Quadrangle_2D::setNormalizedGrid( theQuad ))
2124 // elliptic smooth of internal points to get boundary cell normal to the boundary
2125 bool isRing = theQuad->side[0].grid->Edge(0).IsNull();
2127 if ( !StdMeshers_Quadrangle_2D::setNormalizedGrid( theQuad ))
2129 ellipticSmooth( theQuad, 1 );
2131 // create quadrangles
2133 theHelper.SetElementsOnShape( true );
2134 if ( nbNodesShort0 == nbNodesShort1 && nbNodesSinu0 == nbNodesSinu1 )
2135 ok = StdMeshers_Quadrangle_2D::computeQuadDominant( *theHelper.GetMesh(),
2136 theQuad->face, theQuad );
2138 ok = StdMeshers_Quadrangle_2D::computeTriangles( *theHelper.GetMesh(),
2139 theQuad->face, theQuad );
2141 StdMeshers_Quadrangle_2D::myHelper = 0;
2146 //================================================================================
2148 * \brief Generate quadrangle mesh
2150 //================================================================================
2152 bool StdMeshers_QuadFromMedialAxis_1D2D::Compute(SMESH_Mesh& theMesh,
2153 const TopoDS_Shape& theShape)
2155 std::cout << "helper_quad " << theMesh.IsParallel() << std::endl;
2156 SMESH_MesherHelper helper( theMesh );
2157 helper.SetSubShape( theShape );
2159 TopoDS_Face F = TopoDS::Face( theShape );
2160 if ( F.Orientation() >= TopAbs_INTERNAL ) F.Orientation( TopAbs_FORWARD );
2162 SinuousFace sinuFace( F );
2166 if ( getSinuousEdges( helper, sinuFace ))
2170 double minSegLen = getMinSegLen( helper, sinuFace._sinuEdges );
2171 SMESH_MAT2d::MedialAxis ma( F, sinuFace._sinuEdges, minSegLen, /*ignoreCorners=*/true );
2174 _regular1D = new Algo1D( _gen );
2175 _regular1D->SetSegmentLength( minSegLen );
2177 vector<double> maParams;
2178 if ( ! divideMA( helper, ma, sinuFace, _regular1D, minSegLen, maParams ))
2179 return error(COMPERR_BAD_SHAPE);
2183 _regular1D->SetRadialDistribution( _hyp2D );
2185 if ( !computeShortEdges( helper, sinuFace._shortSide[0], _regular1D, _hyp2D, 0 ) ||
2186 !computeShortEdges( helper, sinuFace._shortSide[1], _regular1D, _hyp2D, 1 ))
2187 return error("Failed to mesh short edges");
2191 if ( !computeSinuEdges( helper, minSegLen, ma, maParams, sinuFace, _regular1D ))
2192 return error("Failed to mesh sinuous edges");
2196 bool ok = computeQuads( helper, sinuFace._quad );
2199 mergeNodes( helper, sinuFace );
2206 return error(COMPERR_BAD_SHAPE, "Not implemented so far");
2209 //================================================================================
2211 * \brief Predict nb of elements
2213 //================================================================================
2215 bool StdMeshers_QuadFromMedialAxis_1D2D::Evaluate(SMESH_Mesh & theMesh,
2216 const TopoDS_Shape & theShape,
2217 MapShapeNbElems& theResMap)
2219 return StdMeshers_Quadrangle_2D::Evaluate(theMesh,theShape,theResMap);
2222 //================================================================================
2224 * \brief Return true if the algorithm can mesh this shape
2225 * \param [in] aShape - shape to check
2226 * \param [in] toCheckAll - if true, this check returns OK if all shapes are OK,
2227 * else, returns OK if at least one shape is OK
2229 //================================================================================
2231 bool StdMeshers_QuadFromMedialAxis_1D2D::IsApplicable( const TopoDS_Shape & aShape,
2235 SMESH_MesherHelper helper( tmpMesh );
2237 int nbFoundFaces = 0;
2238 for (TopExp_Explorer exp( aShape, TopAbs_FACE ); exp.More(); exp.Next(), ++nbFoundFaces )
2240 const TopoDS_Face& face = TopoDS::Face( exp.Current() );
2241 SinuousFace sinuFace( face );
2242 bool isApplicable = getSinuousEdges( helper, sinuFace );
2244 if ( toCheckAll && !isApplicable ) return false;
2245 if ( !toCheckAll && isApplicable ) return true;
2247 return ( toCheckAll && nbFoundFaces != 0 );