]> SALOME platform Git repositories - modules/smesh.git/blob - src/StdMeshers/StdMeshers_Propagation.cxx
Salome HOME
0020983: EDF 1569 SMESH: Numbering Display Elements with several groups selected...
[modules/smesh.git] / src / StdMeshers / StdMeshers_Propagation.cxx
1 //  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
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.
10 //
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.
15 //
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
19 //
20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22
23 //  SMESH SMESH : implementaion of SMESH idl descriptions
24 //  File   : StdMeshers_Propagation.cxx
25 //  Module : SMESH
26 //
27 #include "StdMeshers_Propagation.hxx"
28
29 #include "utilities.h"
30
31 #include "SMDS_SetIterator.hxx"
32 #include "SMESH_Algo.hxx"
33 #include "SMESH_HypoFilter.hxx"
34 #include "SMESH_Mesh.hxx"
35 #include "SMESH_subMesh.hxx"
36
37 #include <BRepTools_WireExplorer.hxx>
38 #include <TopTools_ListIteratorOfListOfShape.hxx>
39 #include <TopTools_MapOfShape.hxx>
40 #include <TopoDS.hxx>
41
42 #define DBGMSG(txt) \
43 //  cout << txt << endl;
44
45 using namespace std;
46
47 namespace {
48
49   // =======================================================================
50   /*!
51    * \brief Listener managing propagation of 1D hypotheses
52    */
53   // =======================================================================
54
55   class PropagationMgr: public SMESH_subMeshEventListener
56   {
57   public:
58     static PropagationMgr* GetListener();
59     /*!
60      * \brief Set listener on edge submesh
61      */
62     static void Set(SMESH_subMesh * submesh);
63     /*!
64      * \brief Return an edge from which hypotheses are propagated from
65      */
66     static TopoDS_Edge GetSource(SMESH_subMesh * submesh);
67     /*!
68      * \brief Does it's main job
69      */
70     void ProcessEvent(const int          event,
71                       const int          eventType,
72                       SMESH_subMesh*     subMesh,
73                       SMESH_subMeshEventListenerData* data,
74                       const SMESH_Hypothesis*         hyp = 0);
75   private:
76     PropagationMgr();
77   };
78 }
79
80 //=============================================================================
81 /*!
82  * StdMeshers_Propagation Implementation
83  */
84 //=============================================================================
85
86 StdMeshers_Propagation::StdMeshers_Propagation (int hypId, int studyId, SMESH_Gen * gen)
87   : SMESH_Hypothesis(hypId, studyId, gen)
88 {
89   _name = GetName();
90   _param_algo_dim = -1; // 1D auxiliary
91 }
92 StdMeshers_Propagation::~StdMeshers_Propagation()                      {}
93 string StdMeshers_Propagation::GetName ()                              { return "Propagation"; }
94 ostream & StdMeshers_Propagation::SaveTo (ostream & save)              { return save; }
95 istream & StdMeshers_Propagation::LoadFrom (istream & load)            { return load; }
96 ostream & operator << (ostream & save, StdMeshers_Propagation & hyp)   { return hyp.SaveTo(save); }
97 istream & operator >> (istream & load, StdMeshers_Propagation & hyp)   { return hyp.LoadFrom(load); }
98 bool StdMeshers_Propagation::SetParametersByMesh(const SMESH_Mesh*,
99                                                  const TopoDS_Shape& ) { return false; }
100 bool StdMeshers_Propagation::SetParametersByDefaults(const TDefaults&,const SMESH_Mesh*) { return false; }
101 void StdMeshers_Propagation::SetPropagationMgr(SMESH_subMesh* subMesh) { PropagationMgr::Set( subMesh ); }
102 /*!
103  * \brief Return an edge from which hypotheses are propagated from
104  */
105 TopoDS_Edge StdMeshers_Propagation::GetPropagationSource(SMESH_Mesh& theMesh,
106                                                          const TopoDS_Shape& theEdge)
107 {
108   return PropagationMgr::GetSource(theMesh.GetSubMeshContaining( theEdge ));
109 }
110
111 //=============================================================================
112 //=============================================================================
113 // PROPAGATION MANAGEMENT
114 //=============================================================================
115 //=============================================================================
116
117 namespace {
118
119   enum SubMeshState { WAIT_PROPAG_HYP, // propagation hyp or local 1D hyp is missing
120                       HAS_PROPAG_HYP,  // propag hyp on this submesh
121                       IN_CHAIN,        // submesh is in propagation chain
122                       LAST_IN_CHAIN,   // submesh with local 1D hyp breaking a chain
123                       MEANINGLESS_LAST };          // meaningless
124
125   struct PropagationMgrData : public EventListenerData
126   {
127     bool myForward; //!< true if a curve of edge in chain is codirected with one of source edge
128     PropagationMgrData( SubMeshState state=WAIT_PROPAG_HYP ): EventListenerData(true) {
129       myType = state; myForward = true;
130     }
131     void Init() {
132       myType = WAIT_PROPAG_HYP;  mySubMeshes.clear(); myForward = true;
133     }
134     SubMeshState State() const {
135       return (SubMeshState) myType;
136     }
137     void SetState(SubMeshState state) {
138       myType = state;
139     }
140     void SetSource(SMESH_subMesh* sm ) {
141       mySubMeshes.clear(); if ( sm ) mySubMeshes.push_back( sm );
142     }
143     void AddSource(SMESH_subMesh* sm ) {
144       if ( sm ) mySubMeshes.push_back( sm );
145     }
146     void SetChain(list< SMESH_subMesh* >& chain ) {
147       mySubMeshes.clear(); mySubMeshes.splice( mySubMeshes.end(), chain );
148     }
149     SMESH_subMeshIteratorPtr GetChain() const;
150     SMESH_subMesh* GetSource() const;
151   };
152
153   //=============================================================================
154   /*!
155    * \brief return static PropagationMgr
156    */
157   PropagationMgr* PropagationMgr::GetListener()
158   {
159     static PropagationMgr theListener;
160     return &theListener;
161   }
162   PropagationMgr* getListener()
163   {
164     return PropagationMgr::GetListener();
165   }
166   //=============================================================================
167   /*!
168    * \brief return PropagationMgrData found on a submesh
169    */
170   PropagationMgrData* findData(SMESH_subMesh* sm)
171   {
172     if ( sm )
173       return static_cast< PropagationMgrData* >( sm->GetEventListenerData( getListener() ));
174     return 0;
175   }
176   //=============================================================================
177   /*!
178    * \brief return PropagationMgrData found on theEdge submesh
179    */
180   PropagationMgrData* findData(SMESH_Mesh& theMesh, const TopoDS_Shape& theEdge)
181   {
182     if ( theEdge.ShapeType() == TopAbs_EDGE )
183       return findData( theMesh.GetSubMeshContaining( theEdge ) );
184     return 0;
185   }
186   //=============================================================================
187   /*!
188    * \brief return existing or a new PropagationMgrData
189    */
190   PropagationMgrData* getData(SMESH_subMesh* sm)
191   {
192     PropagationMgrData* data = findData( sm );
193     if ( !data && sm ) {
194       data = new PropagationMgrData();
195       sm->SetEventListener( getListener(), data, sm );
196     }
197     return data;
198   }
199   //=============================================================================
200   /*!
201    * \brief Returns a local 1D hypothesis used for theEdge
202    */
203   const SMESH_Hypothesis* getLocal1DHyp (SMESH_Mesh&         theMesh,
204                                          const TopoDS_Shape& theEdge)
205   {
206     static SMESH_HypoFilter hypo;
207     hypo.Init( hypo.HasDim( 1 )).
208       AndNot ( hypo.IsAlgo() ).
209       AndNot ( hypo.IsAssignedTo( theMesh.GetMeshDS()->ShapeToMesh() ));
210     return theMesh.GetHypothesis( theEdge, hypo, true );
211   }
212   //=============================================================================
213   /*!
214    * \brief Returns a propagation hypothesis assigned to theEdge
215    */
216   const SMESH_Hypothesis* getProagationHyp (SMESH_Mesh&         theMesh,
217                                             const TopoDS_Shape& theEdge)
218   {
219     static SMESH_HypoFilter propagHypFilter
220       ( SMESH_HypoFilter::HasName( StdMeshers_Propagation::GetName ()));
221     return theMesh.GetHypothesis( theEdge, propagHypFilter, true );
222   }
223   //================================================================================
224   /*!
225    * \brief Return an iterator on a list of submeshes
226    */
227   SMESH_subMeshIteratorPtr iterate( list<SMESH_subMesh*>::const_iterator from,
228                                     list<SMESH_subMesh*>::const_iterator to)
229   {
230     typedef SMESH_subMesh* TsubMesh;
231     typedef SMDS_SetIterator< TsubMesh, list< TsubMesh >::const_iterator > TIterator;
232     return SMESH_subMeshIteratorPtr ( new TIterator( from, to ));
233   }
234   //================================================================================
235   /*!
236    * \brief Build propagation chain
237     * \param theMainSubMesh - the submesh with Propagation hypothesis
238    */
239   bool buildPropagationChain ( SMESH_subMesh* theMainSubMesh )
240   {
241     DBGMSG( "buildPropagationChain from " << theMainSubMesh->GetId() );
242     const TopoDS_Shape& theMainEdge = theMainSubMesh->GetSubShape();
243     if (theMainEdge.ShapeType() != TopAbs_EDGE) return true;
244
245     SMESH_Mesh* mesh = theMainSubMesh->GetFather();
246
247     PropagationMgrData* chainData = getData( theMainSubMesh );
248     chainData->SetState( HAS_PROPAG_HYP );
249
250     // Edge submeshes, to which the 1D hypothesis will be propagated from theMainEdge
251     list<SMESH_subMesh*> & chain = chainData->mySubMeshes;
252     chain.clear();
253     chain.push_back( theMainSubMesh );
254
255     TopTools_MapOfShape checkedShapes;
256     checkedShapes.Add( theMainEdge );
257
258     list<SMESH_subMesh*>::iterator smIt = chain.begin();
259     for ( ; smIt != chain.end(); ++smIt )
260     {
261       const TopoDS_Edge& anE = TopoDS::Edge( (*smIt)->GetSubShape() );
262       PropagationMgrData* data = findData( *smIt );
263       if ( !data ) continue;
264
265       // Iterate on faces, having edge <anE>
266       TopTools_ListIteratorOfListOfShape itA (mesh->GetAncestors(anE));
267       for (; itA.More(); itA.Next())
268       {
269         // there are objects of different type among the ancestors of edge
270         if ( itA.Value().ShapeType() != TopAbs_WIRE || !checkedShapes.Add( itA.Value() ))
271           continue;
272
273         // Get ordered edges and find index of anE in a sequence
274         BRepTools_WireExplorer aWE (TopoDS::Wire(itA.Value()));
275         vector<TopoDS_Edge> edges;
276         edges.reserve(4);
277         int edgeIndex = 0;
278         for (; aWE.More(); aWE.Next()) {
279           TopoDS_Edge edge = aWE.Current();
280           edge.Orientation( aWE.Orientation() );
281           if ( edge.IsSame( anE ))
282             edgeIndex = edges.size();
283           edges.push_back( edge );
284         }
285
286         // Find an edge opposite to anE
287         TopoDS_Edge anOppE;
288         if ( edges.size() < 4 ) {
289           continue; // too few edges
290         }
291         else if ( edges.size() == 4 ) {
292           int oppIndex = edgeIndex + 2;
293           if ( oppIndex > 3 ) oppIndex -= 4;
294           anOppE = edges[ oppIndex ];
295         }
296         else {
297           // count nb sides
298           TopoDS_Edge prevEdge = anE;
299           int nbSide = 0, eIndex = edgeIndex + 1;
300           for ( int i = 0; i < edges.size(); ++i, ++eIndex )
301           {
302             if ( eIndex == edges.size() )
303               eIndex = 0;
304             if ( !SMESH_Algo::IsContinuous( prevEdge, edges[ eIndex ])) {
305               nbSide++;
306             }
307             else {
308               // check that anE is not a part of a composite side
309               if ( anE.IsSame( prevEdge ) || anE.IsSame( edges[ eIndex ])) {
310                 anOppE.Nullify(); break;
311               }
312             }
313             if ( nbSide == 2 ) { // opposite side
314               if ( !anOppE.IsNull() ) {
315                 // composite opposite side -> stop propagation
316                 anOppE.Nullify(); break;
317               }
318               anOppE = edges[ eIndex ];
319             }
320             if ( nbSide == 5 ) {
321               anOppE.Nullify(); break; // too many sides
322             }
323             prevEdge = edges[ eIndex ];
324           }
325           if ( anOppE.IsNull() )
326             continue;
327           if ( nbSide != 4 ) {
328             DBGMSG( nbSide << " sides in wire #" << mesh->GetMeshDS()->ShapeToIndex( itA.Value() ) << " - SKIP" );
329             continue;
330           }
331         }
332         if ( anOppE.IsNull() || !checkedShapes.Add( anOppE ))
333           continue;
334         SMESH_subMesh* oppSM = mesh->GetSubMesh( anOppE );
335         PropagationMgrData* oppData = getData( oppSM );
336
337         // Add anOppE to aChain if ...
338         if ( oppData->State() == WAIT_PROPAG_HYP ) // ... anOppE is not in any chain
339         {
340           oppData->SetSource( theMainSubMesh );
341           if ( !getLocal1DHyp( *mesh, anOppE )) // ... no 1d hyp on anOppE
342           {
343             oppData->myForward = data->myForward;
344             if ( edges[ edgeIndex ].Orientation() == anOppE.Orientation() )
345               oppData->myForward = !oppData->myForward;
346             chain.push_back( oppSM );
347             oppSM->ComputeStateEngine( SMESH_subMesh::CLEAN );
348             oppData->SetState( IN_CHAIN );
349             DBGMSG( "set IN_CHAIN on " << oppSM->GetId() );
350           }
351           else {
352             oppData->SetState( LAST_IN_CHAIN );
353             DBGMSG( "set LAST_IN_CHAIN on " << oppSM->GetId() );
354           }
355         }
356         else if ( oppData->State() == LAST_IN_CHAIN ) // anOppE breaks other chain
357         {
358           DBGMSG( "encounters LAST_IN_CHAIN on " << oppSM->GetId() );
359           oppData->AddSource( theMainSubMesh );
360         }
361       } // loop on face ancestors
362     } // loop on the chain
363
364     // theMainSubMesh must not be in a chain
365     chain.pop_front();
366
367     return true;
368   }
369   //================================================================================
370   /*!
371    * \brief Clear propagation chain
372    */
373   bool clearPropagationChain( SMESH_subMesh* subMesh )
374   {
375     DBGMSG( "clearPropagationChain from " << subMesh->GetId() );
376     if ( PropagationMgrData* data = findData( subMesh ))
377     {
378       switch ( data->State() ) {
379       case IN_CHAIN:
380         return clearPropagationChain( data->GetSource() );
381
382       case HAS_PROPAG_HYP: {
383         SMESH_subMeshIteratorPtr smIt = data->GetChain();
384         while ( smIt->more() ) {
385           SMESH_subMesh* sm = smIt->next();
386           getData( sm )->Init();
387           sm->ComputeStateEngine( SMESH_subMesh::CLEAN );
388         }
389         data->Init();
390         break;
391       }
392       case LAST_IN_CHAIN: {
393         SMESH_subMeshIteratorPtr smIt = iterate( data->mySubMeshes.begin(),
394                                                  data->mySubMeshes.end());
395         while ( smIt->more() )
396           clearPropagationChain( smIt->next() );
397         data->Init();
398         break;
399       }
400       default:;
401       }
402       return true;
403     }
404     return false;
405   }
406
407
408   //================================================================================
409   /*!
410    * \brief Return an iterator on chain submeshes
411    */
412   //================================================================================
413
414   SMESH_subMeshIteratorPtr PropagationMgrData::GetChain() const
415   {
416     switch ( State() ) {
417     case HAS_PROPAG_HYP:
418       return iterate( mySubMeshes.begin(), mySubMeshes.end() );
419     case IN_CHAIN:
420       if ( mySubMeshes.empty() ) break;
421       return getData( mySubMeshes.front() )->GetChain();
422     default:;
423     }
424     return iterate( mySubMeshes.end(), mySubMeshes.end() );
425   }
426   //================================================================================
427   /*!
428    * \brief Return a propagation source submesh
429    */
430   //================================================================================
431
432   SMESH_subMesh* PropagationMgrData::GetSource() const
433   {
434     if ( myType == IN_CHAIN )
435       if ( !mySubMeshes.empty() ) 
436         return mySubMeshes.front();
437     return 0;
438   }
439
440
441   //================================================================================
442   /*!
443    * \brief Constructor
444    */
445   //================================================================================
446
447   PropagationMgr::PropagationMgr()
448     : SMESH_subMeshEventListener( false ) // won't be deleted by submesh
449   {}
450   //================================================================================
451   /*!
452    * \brief Set PropagationMgr on a submesh
453    */
454   //================================================================================
455
456   void PropagationMgr::Set(SMESH_subMesh * submesh)
457   {
458     DBGMSG( "PropagationMgr::Set() on  " << submesh->GetId() );
459     EventListenerData* data = new PropagationMgrData();
460     submesh->SetEventListener( getListener(), data, submesh );
461
462     const SMESH_Hypothesis * propagHyp =
463       getProagationHyp( *submesh->GetFather(), submesh->GetSubShape() );
464     if ( propagHyp )
465       getListener()->ProcessEvent( SMESH_subMesh::ADD_HYP,
466                                    SMESH_subMesh::ALGO_EVENT,
467                                    submesh,
468                                    data,
469                                    propagHyp);
470   }
471   //================================================================================
472   /*!
473    * \brief Return an edge from which hypotheses are propagated
474    */
475   //================================================================================
476
477   TopoDS_Edge PropagationMgr::GetSource(SMESH_subMesh * submesh)
478   {
479     if ( PropagationMgrData* data = findData( submesh )) {
480       if ( data->State() == IN_CHAIN ) {
481         if ( SMESH_subMesh* sm = data->GetSource() )
482         {
483           TopoDS_Shape edge = sm->GetSubShape();
484           edge = edge.Oriented( data->myForward ? TopAbs_FORWARD : TopAbs_REVERSED );
485           DBGMSG( " GetSource() = edge " << sm->GetId() << " REV = " << (!data->myForward));
486           if ( edge.ShapeType() == TopAbs_EDGE )
487             return TopoDS::Edge( edge );
488         }
489       }
490     }
491     return TopoDS_Edge();
492   }
493   //================================================================================
494   /*!
495    * \brief React on events on 1D submeshes
496    */
497   //================================================================================
498
499   void PropagationMgr::ProcessEvent(const int          event,
500                                     const int          eventType,
501                                     SMESH_subMesh*     subMesh,
502                                     SMESH_subMeshEventListenerData* listenerData,
503                                     const SMESH_Hypothesis*         hyp)
504   {
505     if ( !listenerData )
506       return;
507     if ( !hyp || hyp->GetType() != SMESHDS_Hypothesis::PARAM_ALGO || hyp->GetDim() != 1 )
508       return;
509     if ( eventType != SMESH_subMesh::ALGO_EVENT )
510       return;
511     DBGMSG( "PropagationMgr::ProcessEvent() on  " << subMesh->GetId() );
512
513     bool isPropagHyp = ( StdMeshers_Propagation::GetName() == hyp->GetName() );
514
515     PropagationMgrData* data = static_cast<PropagationMgrData*>( listenerData );
516     switch ( data->State() ) {
517
518     case WAIT_PROPAG_HYP: { // propagation hyp or local 1D hyp is missing
519       // --------------------------------------------------------
520       bool hasPropagHyp = ( isPropagHyp ||
521                             getProagationHyp( *subMesh->GetFather(), subMesh->GetSubShape()) );
522       if ( !hasPropagHyp )
523         return;
524       bool hasLocal1DHyp =  getLocal1DHyp( *subMesh->GetFather(), subMesh->GetSubShape());
525       if ( !hasLocal1DHyp )
526         return;
527       if ( event == SMESH_subMesh::ADD_HYP ||
528            event == SMESH_subMesh::ADD_FATHER_HYP ) // add local or propagation hyp
529       {
530         DBGMSG( "ADD_HYP propagation to WAIT_PROPAG_HYP " << subMesh->GetId() );
531         // build propagation chain
532         buildPropagationChain( subMesh );
533       }
534       return;
535     }
536     case HAS_PROPAG_HYP: {  // propag hyp on this submesh
537       // --------------------------------------------------------
538       switch ( event ) {
539       case SMESH_subMesh::REMOVE_HYP:
540       case SMESH_subMesh::REMOVE_FATHER_HYP: // remove propagation hyp
541         if ( isPropagHyp && !getProagationHyp( *subMesh->GetFather(), subMesh->GetSubShape()) )
542         {
543           DBGMSG( "REMOVE_HYP propagation from HAS_PROPAG_HYP " << subMesh->GetId() );
544           // clear propagation chain
545           clearPropagationChain( subMesh );
546         }
547         // return; -- hyp is modified any way
548       default:
549         //case SMESH_subMesh::MODIF_HYP: // hyp modif
550         // clear mesh in a chain
551         DBGMSG( "MODIF_HYP on HAS_PROPAG_HYP " << subMesh->GetId() );
552         SMESH_subMeshIteratorPtr smIt = data->GetChain();
553         while ( smIt->more() ) {
554           SMESH_subMesh* smInChain = smIt->next();
555           smInChain->AlgoStateEngine( SMESH_subMesh::MODIF_HYP,
556                                       (SMESH_Hypothesis*) hyp );
557         }
558         return;
559       }
560       return;
561     }
562     case IN_CHAIN: {       // submesh is in propagation chain
563       // --------------------------------------------------------
564       if ( event == SMESH_subMesh::ADD_HYP ) { // add local hypothesis
565         if ( isPropagHyp ) { // propagation hyp added
566           DBGMSG( "ADD_HYP propagation on IN_CHAIN " << subMesh->GetId() );
567           // collision - do nothing
568         }
569         else { // 1D hyp added
570           // rebuild propagation chain
571           DBGMSG( "ADD_HYP 1D on IN_CHAIN " << subMesh->GetId() );
572           SMESH_subMesh* sourceSM = data->GetSource();
573           clearPropagationChain( sourceSM );
574           buildPropagationChain( sourceSM );
575         }
576       }
577       return;
578     }
579     case LAST_IN_CHAIN: { // submesh with local 1D hyp, breaking a chain
580       // --------------------------------------------------------
581       if ( event == SMESH_subMesh::REMOVE_HYP ) { // remove local hyp
582         // rebuild propagation chain
583         DBGMSG( "REMOVE_HYP 1D from LAST_IN_CHAIN " << subMesh->GetId() );
584         list<SMESH_subMesh*> sourceSM = data->mySubMeshes;
585         clearPropagationChain( subMesh );
586         SMESH_subMeshIteratorPtr smIt = iterate( sourceSM.begin(), sourceSM.end());
587         while ( smIt->more() )
588           buildPropagationChain( smIt->next() );
589       }
590       return;
591     }
592     } // switch by SubMeshState
593   }
594
595 } // namespace