]> SALOME platform Git repositories - modules/hydro.git/blob - src/HYDROData/HYDROData_PriorityQueue.cxx
Salome HOME
Merge remote-tracking branch 'origin/BR_IMPROVEMENTS' into BR_v14_rc
[modules/hydro.git] / src / HYDROData / HYDROData_PriorityQueue.cxx
1 // Copyright (C) 2014-2015  EDF-R&D
2 // This library is free software; you can redistribute it and/or
3 // modify it under the terms of the GNU Lesser General Public
4 // License as published by the Free Software Foundation; either
5 // version 2.1 of the License, or (at your option) any later version.
6 //
7 // This library is distributed in the hope that it will be useful,
8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10 // Lesser General Public License for more details.
11 //
12 // You should have received a copy of the GNU Lesser General Public
13 // License along with this library; if not, write to the Free Software
14 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
15 //
16 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
17 //
18
19 #include <HYDROData_PriorityQueue.h>
20 #include <HYDROData_CalculationCase.h>
21 #include <HYDROData_Iterator.h>
22 #include <TDataStd_ReferenceList.hxx>
23 #include <TDataStd_Integer.hxx>
24 #include <TDF_ChildIterator.hxx>
25
26 HYDROData_PriorityQueue::HYDROData_PriorityQueue( HYDROData_CalculationCase* theCalcCase )
27 {
28   myGeomObjects = theCalcCase->GetGeometryObjects();
29   for( int i=myGeomObjects.Lower(), n=myGeomObjects.Upper(); i<=n; i++ )
30   {
31     Handle(HYDROData_Object) anObj = Handle(HYDROData_Object)::DownCast( myGeomObjects.Value( i ) );
32     if( !anObj.IsNull() )
33     {
34       QString anObjName = anObj->GetName();
35       myNames[anObjName] = anObj;
36     }
37   }
38
39   myRules = GetRules( theCalcCase->Label().FindChild( HYDROData_CalculationCase::DataTag_CustomRules ) );
40 }
41
42 HYDROData_PriorityQueue::~HYDROData_PriorityQueue()
43 {
44 }
45
46 Handle(HYDROData_Object) HYDROData_PriorityQueue::GetMostPriorityObject( const QStringList& theZoneObjects,
47                                                                          HYDROData_Zone::MergeAltitudesType& theMergeType ) const
48 {
49   QStringList aSortedZoneObjects;
50   for( int i=myGeomObjects.Lower(), n=myGeomObjects.Upper(); i<=n; i++ )
51   {
52     QString aName = myGeomObjects.Value( i )->GetName();
53     if( theZoneObjects.contains( aName ) )
54       aSortedZoneObjects.append( aName );
55   }
56
57   Handle(HYDROData_Object) aMostPriorityObj;
58   theMergeType = HYDROData_Zone::Merge_UNKNOWN;
59   QStringList::const_iterator anIt = aSortedZoneObjects.begin(), aLast = aSortedZoneObjects.end();
60   for( ; anIt!=aLast; anIt++ )
61   {
62     HYDROData_Zone::MergeAltitudesType aLocalMerge = HYDROData_Zone::Merge_UNKNOWN;
63     Handle(HYDROData_Object) anObj = myNames[*anIt];
64     if( !anObj.IsNull() )
65     {
66       if( aMostPriorityObj.IsNull() )
67       {
68         aMostPriorityObj = anObj;
69         continue;
70       }
71
72       bool isMorePriority = IsMorePriority( anObj, aMostPriorityObj, aLocalMerge );
73
74       if( isMorePriority )
75         aMostPriorityObj = anObj;
76
77       if( aLocalMerge != HYDROData_Zone::Merge_UNKNOWN && 
78           ( theMergeType==HYDROData_Zone::Merge_UNKNOWN || isMorePriority ) )
79         theMergeType = aLocalMerge;
80     }
81   }
82   return aMostPriorityObj;
83 }
84
85 bool HYDROData_PriorityQueue::IsMorePriority( const Handle(HYDROData_Object)& theObj1,
86                                               const Handle(HYDROData_Object)& theObj2,
87                                               HYDROData_Zone::MergeAltitudesType& theMergeType ) const
88 {
89   // 1. First we check custom rules
90   HYDROData_ListOfRules::const_iterator anIt = myRules.begin(), aLast = myRules.end();
91   for( ; anIt!=aLast; anIt++ )
92   {
93     if( anIt->Object1->Label()==theObj1->Label() && anIt->Object2->Label()==theObj2->Label() )
94     {
95       theMergeType = anIt->MergeType;
96       return anIt->Priority==GREATER;
97     }
98     if( anIt->Object1->Label()==theObj2->Label() && anIt->Object2->Label()==theObj1->Label() )
99     {
100       theMergeType = anIt->MergeType;
101       return anIt->Priority==LESS;
102     }
103   }
104
105   // 2. If no custom rule found, the standard ordering list is applied
106   for( int i=myGeomObjects.Lower(), n=myGeomObjects.Upper(); i<=n; i++ )
107   {
108     if( myGeomObjects.Value( i )->Label() == theObj1->Label() )
109     {
110       theMergeType = HYDROData_Zone::Merge_Object;
111       return true;
112     }
113     if( myGeomObjects.Value( i )->Label() == theObj2->Label() )
114     {
115       theMergeType = HYDROData_Zone::Merge_Object;
116       return false;
117     }
118   }
119   return false;
120 }
121
122 void HYDROData_PriorityQueue::ClearRules( TDF_Label& theRulesLabel )
123 {
124   theRulesLabel.ForgetAllAttributes( true );
125 }
126
127 enum HYDROData_PriorityQueueTag
128 {
129   Object1_Tag,
130   Priority_Tag,
131   Object2_Tag,
132   Merge_Tag,
133 };
134
135 void HYDROData_PriorityQueue::AddRule( TDF_Label&                         theRulesLabel,
136                                        const Handle(HYDROData_Object)&    theObject1,
137                                        HYDROData_PriorityType             thePriority,
138                                        const Handle(HYDROData_Object)&    theObject2,
139                                        HYDROData_Zone::MergeAltitudesType theMergeType )
140 {
141   // Get the last rule index
142   Standard_Integer aRuleIndex = 0;
143   Handle(TDataStd_Integer) anIntVal;
144   if ( theRulesLabel.FindAttribute( TDataStd_Integer::GetID(), anIntVal ) ) {
145     aRuleIndex = anIntVal->Get();
146   }
147
148   TDF_Label aNewRuleLab = theRulesLabel.FindChild( aRuleIndex );
149
150   TDF_Label anObj1Lab = aNewRuleLab.FindChild( Object1_Tag );
151   Handle(TDataStd_ReferenceList) aRefs = TDataStd_ReferenceList::Set( anObj1Lab );
152   aRefs->Append( theObject1->Label() );
153   
154   TDF_Label aPriorityLab = aNewRuleLab.FindChild( Priority_Tag );
155   TDataStd_Integer::Set( aPriorityLab, thePriority );
156
157   TDF_Label anObj2Lab = aNewRuleLab.FindChild( Object2_Tag );
158   aRefs = TDataStd_ReferenceList::Set( anObj2Lab );
159   aRefs->Append( theObject2->Label() );
160
161   TDF_Label aMergeLab = aNewRuleLab.FindChild( Merge_Tag );
162   TDataStd_Integer::Set( aMergeLab, theMergeType );
163
164   // Increment the last rule index
165   TDataStd_Integer::Set( theRulesLabel, aRuleIndex + 1 );
166 }
167
168 HYDROData_ListOfRules HYDROData_PriorityQueue::GetRules( const TDF_Label& theRulesLabel )
169 {
170   HYDROData_ListOfRules aRules;
171
172   Handle(TDataStd_ReferenceList) aRefs1, aRefs2;
173   Handle(TDataStd_Integer) aPriorityAttr, aMergeAttr;
174
175   TDF_ChildIterator anIt( theRulesLabel );
176   for( ; anIt.More(); anIt.Next() )
177   {
178     TDF_Label aRuleLabel = anIt.Value();
179
180     bool isObj1OK = aRuleLabel.FindChild    ( Object1_Tag ). FindAttribute( TDataStd_ReferenceList::GetID(), aRefs1 );
181     bool isPriorityOK = aRuleLabel.FindChild( Priority_Tag ).FindAttribute( TDataStd_Integer::GetID(),       aPriorityAttr );
182     bool isObj2OK = aRuleLabel.FindChild    ( Object2_Tag ). FindAttribute( TDataStd_ReferenceList::GetID(), aRefs2 );
183     bool isMergeOK = aRuleLabel.FindChild   ( Merge_Tag ).   FindAttribute( TDataStd_Integer::GetID(),       aMergeAttr );
184
185     if( isObj1OK && isPriorityOK && isObj2OK && isMergeOK )
186     {
187       HYDROData_CustomRule aRule;
188       aRule.Object1 = Handle_HYDROData_Object::DownCast( HYDROData_Iterator::Object( aRefs1->First() ) );
189       aRule.Priority = ( HYDROData_PriorityType ) aPriorityAttr->Get();
190       aRule.Object2 = Handle_HYDROData_Object::DownCast( HYDROData_Iterator::Object( aRefs2->First() ) );
191       aRule.MergeType = ( HYDROData_Zone::MergeAltitudesType ) aMergeAttr->Get();
192       aRules.append( aRule );
193     }
194   }
195
196   return aRules;
197 }
198
199 QString HYDROData_PriorityQueue::DumpRules( const TDF_Label& theRulesLab )
200 {
201   QString aDump = "Rules:\n";
202   HYDROData_ListOfRules aRules = GetRules( theRulesLab );
203   HYDROData_ListOfRules::const_iterator anIt = aRules.begin(), aLast = aRules.end();
204   for( ; anIt!=aLast; anIt++ )
205   {
206     QString aRule = anIt->Object1->GetName() + " ";
207     aRule += ( anIt->Priority == LESS ? "<" : ">" ) + QString( " " );
208     aRule += anIt->Object2->GetName() + " ";
209
210     switch( anIt->MergeType )
211     {
212     case HYDROData_Zone::Merge_UNKNOWN:
213       aRule += "unknown";
214       break;
215     case HYDROData_Zone::Merge_ZMIN:
216       aRule += "zmin";
217       break;
218     case HYDROData_Zone::Merge_ZMAX:
219       aRule += "zmax";
220       break;
221     case HYDROData_Zone::Merge_Object:
222       aRule += "object";
223       break;
224     }
225     aDump += aRule + "\n";
226   }
227   return aDump;
228 }
229
230 void HYDROData_PriorityQueue::DumpRulesToPython( const TDF_Label& theRulesLab,
231                                                  const QString& theCalcCaseName,
232                                                  QStringList& theScript )
233 {
234   HYDROData_ListOfRules aRules = GetRules( theRulesLab );
235   HYDROData_ListOfRules::const_iterator anIt = aRules.begin(), aLast = aRules.end();
236   for( ; anIt!=aLast; anIt++ )
237   {
238     QString anObj1 = anIt->Object1->GetObjPyName();
239     QString anObj2 = anIt->Object2->GetObjPyName();
240     QString aPriority = anIt->Priority == LESS ? "LESS" : "GREATER";
241     QString aMergeType;
242
243     switch( anIt->MergeType )
244     {
245     case HYDROData_Zone::Merge_UNKNOWN:
246       aMergeType = "HYDROData_Zone.Merge_UNKNOWN";
247       break;
248     case HYDROData_Zone::Merge_ZMIN:
249       aMergeType = "HYDROData_Zone.Merge_ZMIN";
250       break;
251     case HYDROData_Zone::Merge_ZMAX:
252       aMergeType = "HYDROData_Zone.Merge_ZMAX";
253       break;
254     case HYDROData_Zone::Merge_Object:
255       aMergeType = "HYDROData_Zone.Merge_Object";
256       break;
257     }
258
259     QString aRule = QString( "%0.AddRule( %1, %2, %3, %4 )" ).
260       arg( theCalcCaseName ).arg( anObj1 ).arg( aPriority ).arg( anObj2 ).arg( aMergeType );
261
262     theScript << aRule;
263   }
264 }
265
266 bool HYDROData_PriorityQueue::GetRule( const TDF_Label& theRulesLab,
267                                        int theIndex, 
268                                        Handle(HYDROData_Object)&           theObject1,
269                                        HYDROData_PriorityType&             thePriority,
270                                        Handle(HYDROData_Object)&           theObject2,
271                                        HYDROData_Zone::MergeAltitudesType& theMergeType )
272 {
273   TDF_Label aRuleLabel = theRulesLab.FindChild( theIndex );
274
275   Handle(TDataStd_ReferenceList) aRefs1, aRefs2;
276   Handle(TDataStd_Integer) aPriorityAttr, aMergeAttr;
277
278   bool isObj1OK = aRuleLabel.FindChild    ( Object1_Tag ). FindAttribute( TDataStd_ReferenceList::GetID(), aRefs1 );
279   bool isPriorityOK = aRuleLabel.FindChild( Priority_Tag ).FindAttribute( TDataStd_Integer::GetID(),       aPriorityAttr );
280   bool isObj2OK = aRuleLabel.FindChild    ( Object2_Tag ). FindAttribute( TDataStd_ReferenceList::GetID(), aRefs2 );
281   bool isMergeOK = aRuleLabel.FindChild   ( Merge_Tag ).   FindAttribute( TDataStd_Integer::GetID(),       aMergeAttr );
282
283   bool isOK = isObj1OK && isPriorityOK && isObj2OK && isMergeOK;
284   if( isOK )
285   {
286     theObject1   = Handle_HYDROData_Object::DownCast( HYDROData_Iterator::Object( aRefs1->First() ) );
287     thePriority  = ( HYDROData_PriorityType ) aPriorityAttr->Get();
288     theObject2   = Handle_HYDROData_Object::DownCast( HYDROData_Iterator::Object( aRefs2->First() ) );
289     theMergeType = ( HYDROData_Zone::MergeAltitudesType ) aMergeAttr->Get();
290   }
291   return isOK;
292 }