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