X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_CalculationCase.cxx;h=fef44bd1741569f6fb7ffead13ba75e45e49d84e;hb=d398a8be8e0b0259b476b358d53d234ce4c82379;hp=5ab5b3093d38276baaeb547b4f72d018c2645984;hpb=b6d13c1263fdee7ced2f70f3974bd59805ace33a;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_CalculationCase.cxx b/src/HYDROData/HYDROData_CalculationCase.cxx index 5ab5b309..fef44bd1 100644 --- a/src/HYDROData/HYDROData_CalculationCase.cxx +++ b/src/HYDROData/HYDROData_CalculationCase.cxx @@ -17,7 +17,6 @@ // #include "HYDROData_CalculationCase.h" - #include "HYDROData_ArtificialObject.h" #include "HYDROData_IAltitudeObject.h" #include "HYDROData_Document.h" @@ -26,13 +25,23 @@ #include "HYDROData_NaturalObject.h" #include "HYDROData_PolylineXY.h" #include "HYDROData_StricklerTable.h" -#include "HYDROData_LandCover.h" -#include "HYDROData_SplittedShapesGroup.h" +#include "HYDROData_LandCoverMap.h" +#include "HYDROData_SplitShapesGroup.h" #include "HYDROData_Region.h" #include "HYDROData_Tool.h" #include "HYDROData_GeomTool.h" +#ifdef WIN32 + #pragma warning ( disable: 4251 ) +#endif + +#ifndef LIGHT_MODE #include +#endif + +#ifdef WIN32 + #pragma warning ( default: 4251 ) +#endif #include @@ -68,11 +77,19 @@ #define EXPORT_NAME "HYDRO_" + GetName() +#ifndef LIGHT_MODE +#include +#include +#endif + +#define _DEVDEBUG_ +#include "HYDRO_trace.hxx" + IMPLEMENT_STANDARD_HANDLE(HYDROData_CalculationCase, HYDROData_Entity) IMPLEMENT_STANDARD_RTTIEXT(HYDROData_CalculationCase, HYDROData_Entity) HYDROData_CalculationCase::HYDROData_CalculationCase() -: HYDROData_Entity() +: HYDROData_Entity( Geom_2d_and_groups ) { } @@ -85,38 +102,17 @@ void HYDROData_CalculationCase::SetName( const QString& theName ) QString anOldCaseName = GetName(); if ( anOldCaseName != theName ) { - HYDROData_SequenceOfObjects aRegions = GetRegions(); + // Update names of regions and its zones + UpdateRegionsNames( GetRegions(), anOldCaseName, theName ); - HYDROData_SequenceOfObjects::Iterator anIter( aRegions ); - for ( ; anIter.More(); anIter.Next() ) - { - Handle(HYDROData_Region) aRegion = - Handle(HYDROData_Region)::DownCast( anIter.Value() ); - if ( aRegion.IsNull() ) - continue; - - HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aRegion ); - - HYDROData_SequenceOfObjects aZones = aRegion->GetZones(); - HYDROData_SequenceOfObjects::Iterator anIter( aZones ); - for ( ; anIter.More(); anIter.Next() ) - { - Handle(HYDROData_Zone) aRegZone = - Handle(HYDROData_Zone)::DownCast( anIter.Value() ); - if ( aRegZone.IsNull() ) - continue; - - HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aRegZone ); - } - } - - HYDROData_SequenceOfObjects aGroups = GetSplittedGroups(); + HYDROData_SequenceOfObjects aGroups = GetSplitGroups(); + HYDROData_SequenceOfObjects::Iterator anIter; anIter.Init( aGroups ); for ( ; anIter.More(); anIter.Next() ) { - Handle(HYDROData_SplittedShapesGroup) aGroup = - Handle(HYDROData_SplittedShapesGroup)::DownCast( anIter.Value() ); + Handle(HYDROData_SplitShapesGroup) aGroup = + Handle(HYDROData_SplitShapesGroup)::DownCast( anIter.Value() ); if ( aGroup.IsNull() ) continue; @@ -127,14 +123,15 @@ void HYDROData_CalculationCase::SetName( const QString& theName ) HYDROData_Entity::SetName( theName ); } -QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const +QStringList HYDROData_CalculationCase::DumpToPython( const QString& thePyScriptPath, + MapOfTreatedObjects& theTreatedObjects ) const { QStringList aResList = dumpObjectCreation( theTreatedObjects ); aResList.prepend( "# Calculation case" ); QString aCalculName = GetObjPyName(); - AssignmentMode aMode = GetAssignmentMode(); + AssignmentMode aMode = GetAssignmentMode(); QString aModeStr = aMode==MANUAL ? "HYDROData_CalculationCase.MANUAL" : "HYDROData_CalculationCase.AUTOMATIC"; aResList << QString( "%0.SetAssignmentMode( %1 )" ).arg( aCalculName ).arg( aModeStr ); @@ -144,7 +141,7 @@ QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTre { Handle(HYDROData_Object) aRefGeomObj = Handle(HYDROData_Object)::DownCast( anIter.Value() ); - setPythonReferenceObject( theTreatedObjects, aResList, aRefGeomObj, "AddGeometryObject" ); + setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aRefGeomObj, "AddGeometryObject" ); } aResList << QString( "" ); @@ -165,38 +162,27 @@ QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTre continue; int aGroupId = aFatherGeom->GetGroupId( aGeomGroup ); - aResList << QString( "%1 = %2.GetGroup( %3 );" ) + aResList << QString( "%1 = %2.GetGroup( %3 )" ) .arg( aGroupName ).arg( aFatherGeom->GetObjPyName() ).arg( aGroupId ); - aResList << QString( "%1.AddGeometryGroup( %2 );" ).arg( aCalculName ).arg( aGroupName ); + aResList << QString( "%1.AddGeometryGroup( %2 )" ).arg( aCalculName ).arg( aGroupName ); } Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline(); - setPythonReferenceObject( theTreatedObjects, aResList, aBoundaryPolyline, "SetBoundaryPolyline" ); + setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aBoundaryPolyline, "SetBoundaryPolyline" ); if( aMode==AUTOMATIC ) DumpRulesToPython( aCalculName, aResList ); aResList << QString( "" ); aResList << "# Start the algorithm of the partition and assignment"; - aResList << QString( "%1.Update();" ).arg( aCalculName ); + aResList << QString( "%1.Update()" ).arg( aCalculName ); if( aMode==MANUAL ) { - // Now we restore the regions and zones order - HYDROData_SequenceOfObjects aRegions = GetRegions(); - anIter.Init( aRegions ); - for ( ; anIter.More(); anIter.Next() ) - { - Handle(HYDROData_Region) aRegion = - Handle(HYDROData_Region)::DownCast( anIter.Value() ); - if ( aRegion.IsNull() ) - continue; - - theTreatedObjects.insert( aRegion->GetName(), aRegion ); - QStringList aRegDump = aRegion->DumpToPython( theTreatedObjects ); - aResList << aRegDump; - } + // Now we restore the + // - regions and zones order + DumpRegionsToPython( aResList, thePyScriptPath, theTreatedObjects, GetRegions() ); } // Export calculation case @@ -212,11 +198,12 @@ QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTre aResList << "import GEOM"; aResList << QString( "print \"Entry:\", %1" ).arg( anEntryVar ); QString aGeomShapeName = aCalculName + "_geom"; - aResList << QString( "%1 = salome.IDToObject( str( %2 ) )" ).arg( aGeomShapeName ).arg( anEntryVar ); - aResList << QString( "print \"Geom shape:\", %1" ).arg( aGeomShapeName ); - aResList << QString( "print \"Geom shape name:\", %1.GetName()" ).arg( aGeomShapeName ); + aResList << QString( "HYDRO_%1 = salome.IDToObject( str( %2 ) )" ).arg( GetName() ).arg( anEntryVar ); + aResList << QString( "print \"Geom shape:\", HYDRO_%1" ).arg( GetName() ); + aResList << QString( "print \"Geom shape name:\", HYDRO_%1.GetName()" ).arg( GetName() ); + - DumpSampleMeshing( aResList, aStudyName, aGeomShapeName, aCalculName+"_mesh" ); + //DumpSampleMeshing( aResList, aStudyName, aGeomShapeName, aCalculName+"_mesh" ); aResList << QString( "" ); return aResList; @@ -268,6 +255,10 @@ HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetAllReferenceObjects() if ( !aBoundaryPolyline.IsNull() ) aResSeq.Append( aBoundaryPolyline ); + HYDROData_SequenceOfObjects aSeqOfGeomObjs = GetGeometryObjects(); + aResSeq.Append( aSeqOfGeomObjs ); + + // Regions HYDROData_SequenceOfObjects aSeqOfRegions = GetRegions(); aResSeq.Append( aSeqOfRegions ); @@ -281,45 +272,47 @@ void HYDROData_CalculationCase::Update() // At first we remove previously created objects RemoveRegions(); - RemoveSplittedGroups(); + RemoveSplitGroups(); Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); if ( aDocument.IsNull() ) return; - Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline(); - HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects(); - if ( aGeomObjects.IsEmpty() ) - return; - - HYDROData_SequenceOfObjects aGeomGroups = GetGeometryGroups(); + // Split to zones + HYDROData_SplitToZonesTool::SplitDataList aZonesList, anEdgesList; - HYDROData_SplitToZonesTool::SplitDataList aSplitObjects = - HYDROData_SplitToZonesTool::Split( aGeomObjects, aGeomGroups, aBoundaryPolyline ); - if ( aSplitObjects.isEmpty() ) - return; + Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline(); - HYDROData_SplitToZonesTool::SplitDataList aZonesList, anEdgesList; + HYDROData_SequenceOfObjects InterPolys = GetInterPolyObjects(); - HYDROData_SplitToZonesTool::SplitDataListIterator anIter( aSplitObjects ); - while( anIter.hasNext() ) - { - const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); - if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Zone ) - aZonesList.append( aSplitData ); - else if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Edge ) - anEdgesList.append( aSplitData ); + HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects(); + if ( !aGeomObjects.IsEmpty() ) { + HYDROData_SequenceOfObjects aGeomGroups = GetGeometryGroups(); + + HYDROData_SplitToZonesTool::SplitDataList aSplitObjects = + HYDROData_SplitToZonesTool::Split( aGeomObjects, aGeomGroups, aBoundaryPolyline, InterPolys ); + if ( !aSplitObjects.isEmpty() ) { + HYDROData_SplitToZonesTool::SplitDataListIterator anIter( aSplitObjects ); + while( anIter.hasNext() ) { + const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); + if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Zone ) + aZonesList.append( aSplitData ); + else if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Edge ) + anEdgesList.append( aSplitData ); + } + } } switch( GetAssignmentMode() ) { case MANUAL: - CreateRegionsDef( aDocument, aZonesList ); + CreateRegionsDef( aDocument, aZonesList ); break; case AUTOMATIC: - CreateRegionsAuto( aDocument, aZonesList ); + CreateRegionsAuto( aDocument, aZonesList ); break; } + CreateEdgeGroupsDef( aDocument, anEdgesList ); } @@ -345,16 +338,17 @@ void HYDROData_CalculationCase::CreateRegionsDef( const Handle(HYDROData_Documen void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Document)& theDoc, const HYDROData_SplitToZonesTool::SplitDataList& theZones ) { + DEBTRACE("HYDROData_CalculationCase::CreateRegionsAuto"); QMap aRegionsMap; //object name to region QMap aRegionNameToObjNameMap; QString aZonesPref = CALCULATION_ZONES_PREF; HYDROData_PriorityQueue aPr( this, DataTag_CustomRules ); // 1. First we create a default region for each object included into the calculation case - HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects(); - for( int i=aGeomObjects.Lower(), n=aGeomObjects.Upper(); i<=n; i++ ) + HYDROData_SequenceOfObjects anObjects = GetGeometryObjects(); + for( int i = anObjects.Lower(), n = anObjects.Upper(); i<=n; i++ ) { - Handle(HYDROData_Object) anObj = Handle(HYDROData_Object)::DownCast( aGeomObjects.Value( i ) ); + Handle(HYDROData_Entity) anObj = anObjects.Value( i ); if( anObj.IsNull() ) continue; QString anObjName = anObj->GetName(); @@ -370,9 +364,8 @@ void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Docume while( anIter.hasNext() ) { const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); - HYDROData_Zone::MergeAltitudesType aMergeType; - Handle(HYDROData_Object) aRegObj = - Handle(HYDROData_Object)::DownCast( aPr.GetMostPriorityObject( aSplitData.ObjectNames, aMergeType ) ); + HYDROData_Zone::MergeType aMergeType; + Handle(HYDROData_Entity) aRegObj = aPr.GetMostPriorityObject( aSplitData.ObjectNames, aMergeType ); if( aRegObj.IsNull() ) continue; Handle(HYDROData_Region) aRegion = aRegionsMap[aRegObj->GetName()]; @@ -385,6 +378,13 @@ void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Docume qDebug( "Error in algorithm: unresolved conflicts" ); } + Handle(HYDROData_Entity) aMergeEntity = aRegObj; + Handle(HYDROData_Object) aMergeObject = Handle(HYDROData_Object)::DownCast( aMergeEntity ); + if ( !aMergeObject.IsNull() ) { + DEBTRACE("aMergeEntity " << aMergeEntity->GetName().toStdString()); + aMergeEntity = aMergeObject->GetAltitudeObject(); + } + switch( aMergeType ) { case HYDROData_Zone::Merge_ZMIN: @@ -393,8 +393,8 @@ void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Docume break; case HYDROData_Zone::Merge_Object: aRegionZone->SetMergeType( aMergeType ); - aRegionZone->RemoveMergeAltitude(); - aRegionZone->SetMergeAltitude( aRegObj->GetAltitudeObject() ); + aRegionZone->RemoveMergeObject(); + aRegionZone->SetMergeObject( aMergeEntity ); break; } } @@ -423,7 +423,7 @@ void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Docume void HYDROData_CalculationCase::CreateEdgeGroupsDef( const Handle(HYDROData_Document)& theDoc, const HYDROData_SplitToZonesTool::SplitDataList& theEdges ) { - QMap aSplittedEdgesGroupsMap; + QMap aSplitEdgesGroupsMap; HYDROData_SplitToZonesTool::SplitDataListIterator anIter( theEdges ); while( anIter.hasNext() ) @@ -440,20 +440,20 @@ void HYDROData_CalculationCase::CreateEdgeGroupsDef( const Handle(HYDROData_Docu QString aStr = aSplitData.ObjectNames.join(" "); cout << " CCase: Names = "<GetName().toStdString() << " Zone " << aZone->GetName().toStdString()); Handle(HYDROData_Region) aRefRegion = Handle(HYDROData_Region)::DownCast( aZone->GetFatherObject() ); if ( IsEqual( aRefRegion, theRegion ) ) - aResAltitude = GetAltitudeForPoint( thePoint, aZone ); + aResAltitude = GetAltitudeForPoint( thePoint, aZone, theMethod ); + else + { + DEBTRACE("GetAltitudeForPoint Region " << aRefRegion->GetName().toStdString() << " Zone " << aZone->GetName().toStdString() << " ---------------------------"); + aResAltitude = GetAltitudeForPoint( thePoint, aZone, theMethod ); + } } + else + { + DEBTRACE(" --- GetAltitudeForPoint No Zone ---"); + } return aResAltitude; } double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint, - const Handle(HYDROData_Zone)& theZone ) const + const Handle(HYDROData_Zone)& theZone, + int theMethod) const { + //DEBTRACE("GetAltitudeForPoint Zone " << theZone->GetName().toStdString()); double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude(); if ( theZone.IsNull() ) + { + DEBTRACE("Zone nulle"); return aResAltitude; + } - HYDROData_Zone::MergeAltitudesType aZoneMergeType = theZone->GetMergeType(); + HYDROData_Zone::MergeType aZoneMergeType = theZone->GetMergeType(); + //DEBTRACE("aZoneMergeType " << aZoneMergeType); if ( !theZone->IsMergingNeed() ) { aZoneMergeType = HYDROData_Zone::Merge_UNKNOWN; + //DEBTRACE("---"); } else if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN ) { + DEBTRACE("GetAltitudeForPoint Zone " << theZone->GetName().toStdString() << " Merge_UNKNOWN"); return aResAltitude; } HYDROData_IInterpolator* aZoneInterpolator = theZone->GetInterpolator(); if ( aZoneMergeType == HYDROData_Zone::Merge_Object ) { - Handle(HYDROData_IAltitudeObject) aMergeAltitude = theZone->GetMergeAltitude(); + Handle(HYDROData_IAltitudeObject) aMergeAltitude = + Handle(HYDROData_IAltitudeObject)::DownCast( theZone->GetMergeObject() ); if ( !aMergeAltitude.IsNull() ) { if ( aZoneInterpolator != NULL ) { + DEBTRACE("aZoneInterpolator != NULL"); aZoneInterpolator->SetAltitudeObject( aMergeAltitude ); aResAltitude = aZoneInterpolator->GetAltitudeForPoint( thePoint ); } else + { + DEBTRACE("aZoneInterpolator == NULL"); aResAltitude = aMergeAltitude->GetAltitudeForPoint( thePoint ); + } } } else { - HYDROData_SequenceOfObjects aZoneObjects = theZone->GetGeometryObjects(); + //DEBTRACE("aZoneMergeType != HYDROData_Zone::Merge_Object"); + HYDROData_SequenceOfObjects aZoneObjects = theZone->GetObjects(); HYDROData_SequenceOfObjects::Iterator anIter( aZoneObjects ); for ( ; anIter.More(); anIter.Next() ) { @@ -808,11 +815,15 @@ double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& double aPointAltitude = 0.0; if ( aZoneInterpolator != NULL ) { + DEBTRACE("aZoneInterpolator != NULL"); aZoneInterpolator->SetAltitudeObject( anObjAltitude ); aPointAltitude = aZoneInterpolator->GetAltitudeForPoint( thePoint ); } else - aPointAltitude = anObjAltitude->GetAltitudeForPoint( thePoint ); + { + //DEBTRACE("aZoneInterpolator == NULL"); + aPointAltitude = anObjAltitude->GetAltitudeForPoint( thePoint, theMethod ); + } if ( ValuesEquals( aPointAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) ) continue; @@ -846,15 +857,17 @@ double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& NCollection_Sequence HYDROData_CalculationCase::GetAltitudesForPoints( const NCollection_Sequence& thePoints, - const Handle(HYDROData_Region)& theRegion ) const + const Handle(HYDROData_Region)& theRegion, + int theMethod) const { + DEBTRACE("HYDROData_CalculationCase::GetAltitudesForPoints " << theRegion->GetName().toStdString()); NCollection_Sequence aResSeq; for ( int i = 1, n = thePoints.Length(); i <= n; ++i ) { const gp_XY& thePnt = thePoints.Value( i ); - double anAltitude = GetAltitudeForPoint( thePnt, theRegion ); + double anAltitude = GetAltitudeForPoint( thePnt, theRegion, theMethod ); aResSeq.Append( anAltitude ); } @@ -863,7 +876,8 @@ NCollection_Sequence HYDROData_CalculationCase::GetAltitudesForPoints( NCollection_Sequence HYDROData_CalculationCase::GetAltitudesForPoints( const NCollection_Sequence& thePoints, - const Handle(HYDROData_Zone)& theZone ) const + const Handle(HYDROData_Zone)& theZone, + int theMethod) const { NCollection_Sequence aResSeq; @@ -871,13 +885,40 @@ NCollection_Sequence HYDROData_CalculationCase::GetAltitudesForPoints( { const gp_XY& thePnt = thePoints.Value( i ); - double anAltitude = GetAltitudeForPoint( thePnt, theZone ); + double anAltitude = GetAltitudeForPoint( thePnt, theZone, theMethod ); aResSeq.Append( anAltitude ); } return aResSeq; } +double HYDROData_CalculationCase::GetStricklerCoefficientForPoint( const gp_XY& thePoint ) const +{ + Handle( HYDROData_LandCoverMap ) aMap = GetLandCoverMap(); + Handle( HYDROData_StricklerTable ) aTable = GetStricklerTable(); + if( aMap.IsNull() ) + return 0.0; + + QString aType; + aMap->FindByPoint( thePoint, aType ); + double aCoeff = aTable->Get( aType, 0.0 ); + return aCoeff; +} + +std::vector HYDROData_CalculationCase::GetStricklerCoefficientForPoints(const std::vector& thePoints, + double DefValue, bool UseMax ) const +{ + Handle( HYDROData_LandCoverMap ) aLCM = GetLandCoverMap(); + Handle( HYDROData_StricklerTable ) aTable = GetStricklerTable(); + std::vector theCoeffs; + if( aLCM.IsNull() || aTable.IsNull() ) + return theCoeffs; + + aLCM->ClassifyPoints(thePoints, aTable, theCoeffs, DefValue, UseMax ); + + return theCoeffs; +} + Handle(HYDROData_Region) HYDROData_CalculationCase::GetRegionFromPoint( const gp_XY& thePoint ) const { Handle(HYDROData_Region) aResRegion; @@ -964,19 +1005,19 @@ Handle(HYDROData_Region) HYDROData_CalculationCase::addNewRegion( const Handle(H AddRegion( aNewRegion ); QString aRegionName = isPrefix ? HYDROData_Tool::GenerateObjectName( theDoc, thePrefixOrName ) : thePrefixOrName; - aNewRegion->SetName( aRegionName ); + aNewRegion->SetName( aRegionName, true ); return aNewRegion; } -Handle(HYDROData_SplittedShapesGroup) HYDROData_CalculationCase::addNewSplittedGroup( const QString& theName ) +Handle(HYDROData_SplitShapesGroup) HYDROData_CalculationCase::addNewSplitGroup( const QString& theName ) { - TDF_Label aNewLab = myLab.FindChild( DataTag_SplittedGroups ).NewChild(); + TDF_Label aNewLab = myLab.FindChild( DataTag_SplitGroups ).NewChild(); - Handle(HYDROData_SplittedShapesGroup) aNewGroup = - Handle(HYDROData_SplittedShapesGroup)::DownCast( - HYDROData_Iterator::CreateObject( aNewLab, KIND_SPLITTED_GROUP ) ); - AddReferenceObject( aNewGroup, DataTag_SplittedGroups ); + Handle(HYDROData_SplitShapesGroup) aNewGroup = + Handle(HYDROData_SplitShapesGroup)::DownCast( + HYDROData_Iterator::CreateObject( aNewLab, KIND_SPLIT_GROUP ) ); + AddReferenceObject( aNewGroup, DataTag_SplitGroups ); aNewGroup->SetName( theName ); @@ -985,24 +1026,30 @@ Handle(HYDROData_SplittedShapesGroup) HYDROData_CalculationCase::addNewSplittedG QString HYDROData_CalculationCase::Export( int theStudyId ) const { +#ifdef LIGHT_MODE + return ""; +#else GEOM::GEOM_Gen_var aGEOMEngine = HYDROData_GeomTool::GetGeomGen(); SALOMEDS::Study_var aDSStudy = HYDROData_GeomTool::GetStudyByID( theStudyId ); - QString aGeomObjEntry; - bool isOK = Export( aGEOMEngine, aDSStudy, aGeomObjEntry ); + QString aGeomObjEntry, anErrorMsg; + bool isOK = Export( aGEOMEngine, aDSStudy, aGeomObjEntry, anErrorMsg ); return isOK ? aGeomObjEntry : QString(); +#endif } +#ifndef LIGHT_MODE bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, SALOMEDS::Study_ptr theStudy, - QString& theGeomObjEntry ) const + QString& theGeomObjEntry, + QString& theErrorMsg ) const { HYDROData_ShapesGroup::SeqOfGroupsDefs aSeqOfGroupsDefs; // Get groups definitions - HYDROData_SequenceOfObjects aSplittedGroups = GetSplittedGroups(); + HYDROData_SequenceOfObjects aSplitGroups = GetSplitGroups(); - HYDROData_SequenceOfObjects::Iterator anIter( aSplittedGroups ); + HYDROData_SequenceOfObjects::Iterator anIter( aSplitGroups ); for ( ; anIter.More(); anIter.Next() ) { // Get shapes group @@ -1020,6 +1067,7 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, } // Get faces + bool isAllNotSubmersible = true; TopTools_ListOfShape aFaces; HYDROData_SequenceOfObjects aCaseRegions = GetRegions(); HYDROData_SequenceOfObjects::Iterator aRegionIter( aCaseRegions ); @@ -1029,12 +1077,30 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, Handle(HYDROData_Region)::DownCast( aRegionIter.Value() ); if( aRegion.IsNull() || !aRegion->IsSubmersible() ) continue; + + if ( isAllNotSubmersible ) + isAllNotSubmersible = false; TopoDS_Shape aRegionShape = aRegion->GetShape( &aSeqOfGroupsDefs ); aFaces.Append( aRegionShape ); } - return Export( theGeomEngine, theStudy, aFaces, aSeqOfGroupsDefs, theGeomObjEntry ); + bool aRes = false; + + if ( aCaseRegions.IsEmpty() ) { + theErrorMsg = QString("the list of regions is empty."); + } else if ( isAllNotSubmersible ) { + theErrorMsg = QString("there are no submersible regions."); + } else { + aRes = Export( theGeomEngine, theStudy, aFaces, aSeqOfGroupsDefs, theGeomObjEntry );; + } + + if( aRes && !GetLandCoverMap().IsNull() && !GetStricklerTable().IsNull() ) + { + QString aTelemacFileName = GetName() + ".telemac"; + aRes = GetLandCoverMap()->ExportTelemac( aTelemacFileName, 1E-2, GetStricklerTable() ); + } + return aRes; } bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, @@ -1191,6 +1257,7 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var return true; } +#endif void HYDROData_CalculationCase::ClearRules( HYDROData_CalculationCase::DataTag theDataTag, const bool theIsSetToUpdate ) @@ -1200,21 +1267,21 @@ void HYDROData_CalculationCase::ClearRules( HYDROData_CalculationCase::DataTag t // Indicate model of the need to update splitting if ( theIsSetToUpdate ) { - SetToUpdate( true ); + Changed( Geom_2d ); } } void HYDROData_CalculationCase::AddRule( const Handle(HYDROData_Entity)& theObject1, HYDROData_PriorityType thePriority, const Handle(HYDROData_Entity)& theObject2, - HYDROData_Zone::MergeAltitudesType theMergeType, + HYDROData_Zone::MergeType theMergeType, HYDROData_CalculationCase::DataTag theDataTag ) { TDF_Label aRulesLab = myLab.FindChild( theDataTag ); HYDROData_PriorityQueue::AddRule( aRulesLab, theObject1, thePriority, theObject2, theMergeType ); // Indicate model of the need to update splitting - SetToUpdate( true ); + Changed( Geom_2d ); } QString HYDROData_CalculationCase::DumpRules() const @@ -1229,7 +1296,7 @@ void HYDROData_CalculationCase::SetAssignmentMode( AssignmentMode theMode ) TDataStd_Integer::Set( aModeLab, ( int ) theMode ); // Indicate model of the need to update splitting - SetToUpdate( true ); + Changed( Geom_2d ); } HYDROData_CalculationCase::AssignmentMode HYDROData_CalculationCase::GetAssignmentMode() const @@ -1260,11 +1327,69 @@ void HYDROData_CalculationCase::SetWarning( HYDROData_WarningType theType, const myLastWarning.Data = theData; } +void HYDROData_CalculationCase::UpdateRegionsNames( const HYDROData_SequenceOfObjects& theRegions, + const QString& theOldCaseName, + const QString& theName ) +{ + HYDROData_SequenceOfObjects::Iterator anIter( theRegions ); + for ( ; anIter.More(); anIter.Next() ) + { + Handle(HYDROData_Region) aRegion = + Handle(HYDROData_Region)::DownCast( anIter.Value() ); + if ( aRegion.IsNull() ) + continue; + + HYDROData_Tool::UpdateChildObjectName( theOldCaseName, theName, aRegion ); + + HYDROData_SequenceOfObjects aZones = aRegion->GetZones(); + HYDROData_SequenceOfObjects::Iterator anIter( aZones ); + for ( ; anIter.More(); anIter.Next() ) + { + Handle(HYDROData_Zone) aRegZone = + Handle(HYDROData_Zone)::DownCast( anIter.Value() ); + if ( aRegZone.IsNull() ) + continue; + + HYDROData_Tool::UpdateChildObjectName( theOldCaseName, theName, aRegZone ); + } + } +} + +void HYDROData_CalculationCase::DumpRegionsToPython( QStringList& theResList, + const QString& thePyScriptPath, + MapOfTreatedObjects& theTreatedObjects, + const HYDROData_SequenceOfObjects& theRegions ) const +{ + HYDROData_SequenceOfObjects::Iterator anIter; + anIter.Init(theRegions); + for (int ireg = 1; anIter.More(); anIter.Next(), ireg++) + { + Handle(HYDROData_Region) aRegion = Handle(HYDROData_Region)::DownCast(anIter.Value()); + if (aRegion.IsNull()) + continue; + QString defRegName = this->GetName(); + QString regSuffix = QString("_Reg_%1").arg(ireg); + defRegName += regSuffix; + theTreatedObjects.insert(aRegion->GetName(), aRegion); + QStringList aRegDump = aRegion->DumpToPython(thePyScriptPath, theTreatedObjects, defRegName); + theResList << aRegDump; + } + for (anIter.Init(theRegions); anIter.More(); anIter.Next()) + { + Handle(HYDROData_Region) aRegion = Handle(HYDROData_Region)::DownCast(anIter.Value()); + if (aRegion.IsNull()) + continue; + QStringList aRegDump; + aRegion->SetNameInDumpPython(aRegDump); + theResList << aRegDump; + } +} + bool HYDROData_CalculationCase::GetRule( int theIndex, Handle(HYDROData_Entity)& theObject1, HYDROData_PriorityType& thePriority, Handle(HYDROData_Entity)& theObject2, - HYDROData_Zone::MergeAltitudesType& theMergeType, + HYDROData_Zone::MergeType& theMergeType, HYDROData_CalculationCase::DataTag& theDataTag) const { TDF_Label aRulesLab = myLab.FindChild( theDataTag ); @@ -1272,21 +1397,31 @@ bool HYDROData_CalculationCase::GetRule( int theIndex, theObject1, thePriority, theObject2, theMergeType ); } -void HYDROData_CalculationCase::SetAssignmentLandCoverMode( AssignmentMode theMode ) +bool HYDROData_CalculationCase::AddInterPoly( const Handle(HYDROData_PolylineXY)& theInterPolyline ) { - TDF_Label aModeLab = myLab.FindChild( DataTag_AssignmentLandCoverMode ); - TDataStd_Integer::Set( aModeLab, ( int ) theMode ); + HYDROData_CalculationCase::DataTag aDataTag = DataTag_InterPoly; - // Indicate model of the need to update land covers partition - SetToUpdate( true ); + if ( HasReference( theInterPolyline, aDataTag ) ) + return false; + + AddReferenceObject( theInterPolyline, aDataTag ); + + return true; } -HYDROData_CalculationCase::AssignmentMode HYDROData_CalculationCase::GetAssignmentLandCoverMode() const +HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetInterPolyObjects() const { - Handle(TDataStd_Integer) aModeAttr; - bool isOK = myLab.FindChild( DataTag_AssignmentLandCoverMode ).FindAttribute( TDataStd_Integer::GetID(), aModeAttr ); - if( isOK ) - return ( AssignmentMode ) aModeAttr->Get(); - else - return MANUAL; + return GetReferenceObjects( DataTag_InterPoly ); } + +void HYDROData_CalculationCase::RemoveInterPolyObject( const Handle(HYDROData_PolylineXY)& theInterPolyline ) +{ + if ( theInterPolyline.IsNull() ) + return; + + RemoveReferenceObject( theInterPolyline->Label(), DataTag_InterPoly ); + +} + + +