X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_PriorityQueue.cxx;h=27427dd4c7e6f7570c254f435e9720f01125b019;hb=a95289fabbb6fbf6f32c06207422c65aafd5bd65;hp=e3c5a133a680af460763d85a3f537ea4094c1a6e;hpb=f17efc89ee19de46802d511d84cce537fcfa71a1;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_PriorityQueue.cxx b/src/HYDROData/HYDROData_PriorityQueue.cxx index e3c5a133..27427dd4 100644 --- a/src/HYDROData/HYDROData_PriorityQueue.cxx +++ b/src/HYDROData/HYDROData_PriorityQueue.cxx @@ -1,3 +1,20 @@ +// Copyright (C) 2014-2015 EDF-R&D +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #include #include @@ -6,12 +23,13 @@ #include #include -HYDROData_PriorityQueue::HYDROData_PriorityQueue( HYDROData_CalculationCase* theCalcCase ) +HYDROData_PriorityQueue::HYDROData_PriorityQueue( HYDROData_CalculationCase* theCalcCase, + Standard_Integer aTag ) { - myGeomObjects = theCalcCase->GetGeometryObjects(); - for( int i=myGeomObjects.Lower(), n=myGeomObjects.Upper(); i<=n; i++ ) + myObjects = theCalcCase->GetGeometryObjects(); + for( int i=myObjects.Lower(), n=myObjects.Upper(); i<=n; i++ ) { - Handle(HYDROData_Object) anObj = Handle(HYDROData_Object)::DownCast( myGeomObjects.Value( i ) ); + Handle(HYDROData_Entity) anObj = myObjects.Value( i ); if( !anObj.IsNull() ) { QString anObjName = anObj->GetName(); @@ -19,36 +37,55 @@ HYDROData_PriorityQueue::HYDROData_PriorityQueue( HYDROData_CalculationCase* the } } - myRules = GetRules( theCalcCase->Label().FindChild( HYDROData_CalculationCase::DataTag_CustomRules ) ); + myRules = GetRules( theCalcCase->Label().FindChild( aTag ) ); } HYDROData_PriorityQueue::~HYDROData_PriorityQueue() { } -Handle(HYDROData_Object) HYDROData_PriorityQueue::GetMostPriorityObject( const QStringList& theZoneObjects, - HYDROData_Zone::MergeAltitudesType& theMergeType ) const +Handle(HYDROData_Entity) HYDROData_PriorityQueue::GetMostPriorityObject( const QStringList& theZoneObjects, + HYDROData_Zone::MergeType& theMergeType ) const { - Handle(HYDROData_Object) aMostPriorityObj; - theMergeType = HYDROData_Zone::Merge_Object; - QStringList::const_iterator anIt = theZoneObjects.begin(), aLast = theZoneObjects.end(); + QStringList aSortedZoneObjects; + for( int i=myObjects.Lower(), n=myObjects.Upper(); i<=n; i++ ) + { + QString aName = myObjects.Value( i )->GetName(); + if( theZoneObjects.contains( aName ) ) + aSortedZoneObjects.append( aName ); + } + + Handle(HYDROData_Entity) aMostPriorityObj; + theMergeType = HYDROData_Zone::Merge_UNKNOWN; + QStringList::const_iterator anIt = aSortedZoneObjects.begin(), aLast = aSortedZoneObjects.end(); for( ; anIt!=aLast; anIt++ ) { - HYDROData_Zone::MergeAltitudesType aLocalMerge = HYDROData_Zone::Merge_UNKNOWN; - Handle(HYDROData_Object) anObj = myNames[*anIt]; + HYDROData_Zone::MergeType aLocalMerge = HYDROData_Zone::Merge_UNKNOWN; + Handle(HYDROData_Entity) anObj = myNames[*anIt]; if( !anObj.IsNull() ) - if( aMostPriorityObj.IsNull() || IsMorePriority( anObj, aMostPriorityObj, aLocalMerge ) ) + { + if( aMostPriorityObj.IsNull() ) { aMostPriorityObj = anObj; - theMergeType = aLocalMerge; + continue; } + + bool isMorePriority = IsMorePriority( anObj, aMostPriorityObj, aLocalMerge ); + + if( isMorePriority ) + aMostPriorityObj = anObj; + + if( aLocalMerge != HYDROData_Zone::Merge_UNKNOWN && + ( theMergeType==HYDROData_Zone::Merge_UNKNOWN || isMorePriority ) ) + theMergeType = aLocalMerge; + } } return aMostPriorityObj; } -bool HYDROData_PriorityQueue::IsMorePriority( const Handle(HYDROData_Object)& theObj1, - const Handle(HYDROData_Object)& theObj2, - HYDROData_Zone::MergeAltitudesType& theMergeType ) const +bool HYDROData_PriorityQueue::IsMorePriority( const Handle(HYDROData_Entity)& theObj1, + const Handle(HYDROData_Entity)& theObj2, + HYDROData_Zone::MergeType& theMergeType ) const { // 1. First we check custom rules HYDROData_ListOfRules::const_iterator anIt = myRules.begin(), aLast = myRules.end(); @@ -67,14 +104,14 @@ bool HYDROData_PriorityQueue::IsMorePriority( const Handle(HYDROData_Object)& th } // 2. If no custom rule found, the standard ordering list is applied - for( int i=myGeomObjects.Lower(), n=myGeomObjects.Upper(); i<=n; i++ ) + for( int i=myObjects.Lower(), n=myObjects.Upper(); i<=n; i++ ) { - if( myGeomObjects.Value( i )->Label() == theObj1->Label() ) + if( myObjects.Value( i )->Label() == theObj1->Label() ) { theMergeType = HYDROData_Zone::Merge_Object; return true; } - if( myGeomObjects.Value( i )->Label() == theObj2->Label() ) + if( myObjects.Value( i )->Label() == theObj2->Label() ) { theMergeType = HYDROData_Zone::Merge_Object; return false; @@ -96,13 +133,20 @@ enum HYDROData_PriorityQueueTag Merge_Tag, }; -void HYDROData_PriorityQueue::AddRule( TDF_Label& theRulesLabel, - const Handle(HYDROData_Object)& theObject1, - HYDROData_PriorityType thePriority, - const Handle(HYDROData_Object)& theObject2, - HYDROData_Zone::MergeAltitudesType theMergeType ) +void HYDROData_PriorityQueue::AddRule( TDF_Label& theRulesLabel, + const Handle(HYDROData_Entity)& theObject1, + HYDROData_PriorityType thePriority, + const Handle(HYDROData_Entity)& theObject2, + HYDROData_Zone::MergeType theMergeType ) { - TDF_Label aNewRuleLab = theRulesLabel.NewChild(); + // Get the last rule index + Standard_Integer aRuleIndex = 0; + Handle(TDataStd_Integer) anIntVal; + if ( theRulesLabel.FindAttribute( TDataStd_Integer::GetID(), anIntVal ) ) { + aRuleIndex = anIntVal->Get(); + } + + TDF_Label aNewRuleLab = theRulesLabel.FindChild( aRuleIndex ); TDF_Label anObj1Lab = aNewRuleLab.FindChild( Object1_Tag ); Handle(TDataStd_ReferenceList) aRefs = TDataStd_ReferenceList::Set( anObj1Lab ); @@ -117,6 +161,9 @@ void HYDROData_PriorityQueue::AddRule( TDF_Label& theRul TDF_Label aMergeLab = aNewRuleLab.FindChild( Merge_Tag ); TDataStd_Integer::Set( aMergeLab, theMergeType ); + + // Increment the last rule index + TDataStd_Integer::Set( theRulesLabel, aRuleIndex + 1 ); } HYDROData_ListOfRules HYDROData_PriorityQueue::GetRules( const TDF_Label& theRulesLabel ) @@ -139,10 +186,10 @@ HYDROData_ListOfRules HYDROData_PriorityQueue::GetRules( const TDF_Label& theRul if( isObj1OK && isPriorityOK && isObj2OK && isMergeOK ) { HYDROData_CustomRule aRule; - aRule.Object1 = Handle_HYDROData_Object::DownCast( HYDROData_Iterator::Object( aRefs1->First() ) ); + aRule.Object1 = HYDROData_Iterator::Object( aRefs1->First() ); aRule.Priority = ( HYDROData_PriorityType ) aPriorityAttr->Get(); - aRule.Object2 = Handle_HYDROData_Object::DownCast( HYDROData_Iterator::Object( aRefs2->First() ) ); - aRule.MergeType = ( HYDROData_Zone::MergeAltitudesType ) aMergeAttr->Get(); + aRule.Object2 = HYDROData_Iterator::Object( aRefs2->First() ); + aRule.MergeType = ( HYDROData_Zone::MergeType ) aMergeAttr->Get(); aRules.append( aRule ); } } @@ -153,6 +200,7 @@ HYDROData_ListOfRules HYDROData_PriorityQueue::GetRules( const TDF_Label& theRul QString HYDROData_PriorityQueue::DumpRules( const TDF_Label& theRulesLab ) { QString aDump = "Rules:\n"; + HYDROData_ListOfRules aRules = GetRules( theRulesLab ); HYDROData_ListOfRules::const_iterator anIt = aRules.begin(), aLast = aRules.end(); for( ; anIt!=aLast; anIt++ ) @@ -194,25 +242,55 @@ void HYDROData_PriorityQueue::DumpRulesToPython( const TDF_Label& theRulesLab, QString aPriority = anIt->Priority == LESS ? "LESS" : "GREATER"; QString aMergeType; + HYDROData_CalculationCase::DataTag aDataTag = HYDROData_CalculationCase::DataTag_CustomRules; + switch( anIt->MergeType ) { case HYDROData_Zone::Merge_UNKNOWN: - aMergeType = "Merge_UNKNOWN"; + aMergeType = "HYDROData_Zone.Merge_UNKNOWN"; break; case HYDROData_Zone::Merge_ZMIN: - aMergeType = "Merge_ZMIN"; + aMergeType = "HYDROData_Zone.Merge_ZMIN"; break; case HYDROData_Zone::Merge_ZMAX: - aMergeType = "Merge_ZMAX"; + aMergeType = "HYDROData_Zone.Merge_ZMAX"; break; case HYDROData_Zone::Merge_Object: - aMergeType = "Merge_Object"; + aMergeType = "HYDROData_Zone.Merge_Object"; break; } - QString aRule = QString( "%0.AddRule( %1, %2, %3, %4 )" ). - arg( theCalcCaseName ).arg( anObj1 ).arg( aPriority ).arg( anObj2 ).arg( aMergeType ); + QString aRule = QString( "%0.AddRule( %1, %2, %3, %4, %5 )" ). + arg( theCalcCaseName ).arg( anObj1 ).arg( aPriority ).arg( anObj2 ).arg( aMergeType ).arg( aDataTag ); theScript << aRule; } } + +bool HYDROData_PriorityQueue::GetRule( const TDF_Label& theRulesLab, + int theIndex, + Handle(HYDROData_Entity)& theObject1, + HYDROData_PriorityType& thePriority, + Handle(HYDROData_Entity)& theObject2, + HYDROData_Zone::MergeType& theMergeType ) +{ + TDF_Label aRuleLabel = theRulesLab.FindChild( theIndex ); + + Handle(TDataStd_ReferenceList) aRefs1, aRefs2; + Handle(TDataStd_Integer) aPriorityAttr, aMergeAttr; + + bool isObj1OK = aRuleLabel.FindChild ( Object1_Tag ). FindAttribute( TDataStd_ReferenceList::GetID(), aRefs1 ); + bool isPriorityOK = aRuleLabel.FindChild( Priority_Tag ).FindAttribute( TDataStd_Integer::GetID(), aPriorityAttr ); + bool isObj2OK = aRuleLabel.FindChild ( Object2_Tag ). FindAttribute( TDataStd_ReferenceList::GetID(), aRefs2 ); + bool isMergeOK = aRuleLabel.FindChild ( Merge_Tag ). FindAttribute( TDataStd_Integer::GetID(), aMergeAttr ); + + bool isOK = isObj1OK && isPriorityOK && isObj2OK && isMergeOK; + if( isOK ) + { + theObject1 = HYDROData_Iterator::Object( aRefs1->First() ); + thePriority = ( HYDROData_PriorityType ) aPriorityAttr->Get(); + theObject2 = HYDROData_Iterator::Object( aRefs2->First() ); + theMergeType = ( HYDROData_Zone::MergeType ) aMergeAttr->Get(); + } + return isOK; +}