X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_CalculationCase.cxx;h=12aca20da9df2a77b0a89344036dcfe8acc52472;hb=c16caee6b6e61dffbc739dce6639215b24a459d3;hp=07397d1a64ee1dbee12cd9ff728e10e38106dc1c;hpb=5682ae51b2102d54e47d77446593b272e7eed867;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_CalculationCase.cxx b/src/HYDROData/HYDROData_CalculationCase.cxx index 07397d1a..12aca20d 100644 --- a/src/HYDROData/HYDROData_CalculationCase.cxx +++ b/src/HYDROData/HYDROData_CalculationCase.cxx @@ -16,10 +16,6 @@ // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // -#ifdef WIN32 - #pragma warning ( disable: 4251 ) -#endif - #include "HYDROData_CalculationCase.h" #include "HYDROData_ArtificialObject.h" #include "HYDROData_IAltitudeObject.h" @@ -29,13 +25,26 @@ #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" +#include +#include +#include + +#ifdef WIN32 + #pragma warning ( disable: 4251 ) +#endif +#ifndef LIGHT_MODE #include +#endif + +#ifdef WIN32 + #pragma warning ( default: 4251 ) +#endif #include @@ -46,6 +55,8 @@ #include #include #include +#include +#include #include @@ -63,26 +74,22 @@ #endif #define CALCULATION_REGIONS_PREF GetName() + "_Reg" #define CALCULATION_ZONES_PREF GetName() + "_Zone" -#define CALCULATION_LANDCOVER_ZONES_PREF GetName() + "_LandCoverZone" #define CALCULATION_GROUPS_PREF GetName() + "_" //#define DEB_CLASS2D 1 #ifdef DEB_CLASS2D #include #endif -#ifdef WIN32 - #pragma warning ( default: 4251 ) -#endif - #define EXPORT_NAME "HYDRO_" + GetName() +#ifndef LIGHT_MODE #include #include +#endif -#define _DEVDEBUG_ +//#define _DEVDEBUG_ #include "HYDRO_trace.hxx" -IMPLEMENT_STANDARD_HANDLE(HYDROData_CalculationCase, HYDROData_Entity) IMPLEMENT_STANDARD_RTTIEXT(HYDROData_CalculationCase, HYDROData_Entity) HYDROData_CalculationCase::HYDROData_CalculationCase() @@ -100,18 +107,16 @@ void HYDROData_CalculationCase::SetName( const QString& theName ) if ( anOldCaseName != theName ) { // Update names of regions and its zones - UpdateRegionsNames( GetRegions( false ), anOldCaseName, theName ); - // Update names of land cover regions and its zones - UpdateRegionsNames( GetRegions( true ), anOldCaseName, theName ); + UpdateRegionsNames( GetRegions(), anOldCaseName, theName ); - 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; @@ -122,7 +127,8 @@ 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" ); @@ -133,17 +139,13 @@ QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTre QString aModeStr = aMode==MANUAL ? "HYDROData_CalculationCase.MANUAL" : "HYDROData_CalculationCase.AUTOMATIC"; aResList << QString( "%0.SetAssignmentMode( %1 )" ).arg( aCalculName ).arg( aModeStr ); - AssignmentMode aModeLC = GetAssignmentLandCoverMode(); - QString aModeLCStr = aModeLC==MANUAL ? "HYDROData_CalculationCase.MANUAL" : "HYDROData_CalculationCase.AUTOMATIC"; - aResList << QString( "%0.SetAssignmentLandCoverMode( %1 )" ).arg( aCalculName ).arg( aModeLCStr ); - HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects(); HYDROData_SequenceOfObjects::Iterator anIter( aGeomObjects ); for ( ; anIter.More(); anIter.Next() ) { Handle(HYDROData_Object) aRefGeomObj = Handle(HYDROData_Object)::DownCast( anIter.Value() ); - setPythonReferenceObject( theTreatedObjects, aResList, aRefGeomObj, "AddGeometryObject" ); + setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aRefGeomObj, "AddGeometryObject" ); } aResList << QString( "" ); @@ -164,36 +166,33 @@ 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" ); + + Handle(HYDROData_StricklerTable) aStricklerTable = GetStricklerTable(); + setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aStricklerTable, "SetStricklerTable" ); + + Handle(HYDROData_LandCoverMap) aLandCoverMap = GetLandCoverMap(); + setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aLandCoverMap, "SetLandCoverMap" ); if( aMode==AUTOMATIC ) DumpRulesToPython( aCalculName, aResList ); - if( aModeLC==AUTOMATIC ) - DumpLandCoverRulesToPython( 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 - DumpRegionsToPython( aResList, theTreatedObjects, GetRegions( false ) ); - } - - if( aModeLC==MANUAL ) - { - // Now we restore the - // - land cover regions and zones order - DumpRegionsToPython( aResList, theTreatedObjects, GetRegions( true ) ); + DumpRegionsToPython( aResList, thePyScriptPath, theTreatedObjects, GetRegions() ); } // Export calculation case @@ -209,11 +208,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; @@ -265,26 +265,160 @@ HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetAllReferenceObjects() if ( !aBoundaryPolyline.IsNull() ) aResSeq.Append( aBoundaryPolyline ); + HYDROData_SequenceOfObjects aSeqOfGeomObjs = GetGeometryObjects(); + aResSeq.Append( aSeqOfGeomObjs ); + // Regions - HYDROData_SequenceOfObjects aSeqOfRegions = GetRegions( false ); + HYDROData_SequenceOfObjects aSeqOfRegions = GetRegions(); aResSeq.Append( aSeqOfRegions ); - // Land cover regions - HYDROData_SequenceOfObjects aSeqOfLandCoverRegions = GetRegions( true ); - aResSeq.Append( aSeqOfLandCoverRegions ); - return aResSeq; } +static void FilterEdgesByIncludeSelectionBoundaryPolygons( const HYDROData_SplitToZonesTool::SplitDataList& anEdgesList, + HYDROData_SequenceOfObjects aBoundaryPolygons, + HYDROData_SplitToZonesTool::SplitDataList& outEdgesList) +{ + //perform boundary condition polygons on EdgesList + TopTools_SequenceOfShape IncTools, SelectionTools; + HYDROData_SplitToZonesTool::SplitDataListIterator anIter(anEdgesList); + for (int i=1; i<=aBoundaryPolygons.Size();i++) + { + Handle(HYDROData_BCPolygon) aBCPoly = Handle(HYDROData_BCPolygon)::DownCast( aBoundaryPolygons(i)); + TopoDS_Shape aPolyTopShape = aBCPoly->GetTopShape(); + int bType = aBCPoly->GetBoundaryType(); + if (bType == 2) + IncTools.Append(aPolyTopShape); + else if (bType == 3) + SelectionTools.Append(aPolyTopShape); + } + + while( anIter.hasNext() ) + { + const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); + if ( aSplitData.ObjectNames.isEmpty() || aSplitData.Shape.IsNull() ) + continue; + if (aSplitData.Shape.ShapeType() != TopAbs_EDGE) + continue; + if (HYDROData_BoundaryPolygonTools::IncludeTool(IncTools, aSplitData.Shape) && HYDROData_BoundaryPolygonTools::SelectionTool(SelectionTools, aSplitData.Shape)) + outEdgesList.append(aSplitData); + } +} + + +static void SplitEdgesByBoundaryPolygons( const HYDROData_SplitToZonesTool::SplitDataList& anEdgesList, + const HYDROData_SequenceOfObjects& aBoundaryPolygons, + NCollection_IndexedDataMap& ObjToRes) +{ + //perform boundary condition polygons on EdgesList + TopTools_SequenceOfShape CutTools; + ObjToRes.Clear(); + HYDROData_SplitToZonesTool::SplitDataListIterator anIter(anEdgesList); + for (int i=1; i<=aBoundaryPolygons.Size();i++) + { + Handle(HYDROData_BCPolygon) aBCPoly = Handle(HYDROData_BCPolygon)::DownCast( aBoundaryPolygons(i)); + TopoDS_Shape aPolyTopShape = aBCPoly->GetTopShape(); + int bType = aBCPoly->GetBoundaryType(); + if (bType == 1) + CutTools.Append(aPolyTopShape); + } + + while( anIter.hasNext() ) + { + const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); + if ( aSplitData.ObjectNames.isEmpty() || aSplitData.Shape.IsNull() ) + continue; + if (aSplitData.Shape.ShapeType() != TopAbs_EDGE) + continue; + ObjToRes.Add(aSplitData.Shape, TopoDS_Shape()); + } + + HYDROData_BoundaryPolygonTools::CutTool(CutTools, ObjToRes); +} + + +static void PerformEdgeReplInZones(const HYDROData_SplitToZonesTool::SplitDataList& ZoneList, + const NCollection_IndexedDataMap& ObjToRes, + HYDROData_SplitToZonesTool::SplitDataList& outZoneList) +{ + HYDROData_SplitToZonesTool::SplitDataListIterator it( ZoneList ); + BRepTools_ReShape reshaper; + for (;it.hasNext();) + { + const HYDROData_SplitToZonesTool::SplitData& aSplitData = it.next(); + if ( aSplitData.ObjectNames.isEmpty() || aSplitData.Shape.IsNull() ) + continue; + + TopoDS_Shape mS = aSplitData.Shape; + for (int i=1; i<=ObjToRes.Extent();i++) + { + TopoDS_Shape K = ObjToRes.FindKey(i); + TopoDS_Shape V = ObjToRes.FindFromIndex(i); + if (V.ShapeType() != TopAbs_EDGE && V.ShapeType() != TopAbs_WIRE && V.ShapeType() != TopAbs_COMPOUND) + continue; + if (V.ShapeType() == TopAbs_COMPOUND) + { + TopExp_Explorer exp(V, TopAbs_EDGE); + TopTools_ListOfShape lE; + for (;exp.More();exp.Next()) + lE.Append(exp.Current()); + if (lE.Extent() == 1) + V = lE.First(); + else if (lE.Extent() > 1) + { + BRepLib_MakeWire MW; + MW.Add(lE); + if (MW.IsDone()) + V = MW.Wire(); + else + continue; + } + else + continue; + } + reshaper.Replace(K, V); + } + TopoDS_Shape nS = reshaper.Apply(mS); + HYDROData_SplitToZonesTool::SplitData aNS(aSplitData.Type, nS, aSplitData.ObjectNames); + outZoneList.append(aNS); + } +} + +static void CreateNewEdgeList( const HYDROData_SplitToZonesTool::SplitDataList& theEdges, + const NCollection_IndexedDataMap& ObjToRes, + HYDROData_SplitToZonesTool::SplitDataList& newEdges) +{ + HYDROData_SplitToZonesTool::SplitDataListIterator anIter( theEdges ); + while( anIter.hasNext() ) + { + const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); + if ( aSplitData.ObjectNames.isEmpty() || aSplitData.Shape.IsNull() ) + continue; + + const TopoDS_Shape* aDivShape = ObjToRes.Seek(aSplitData.Shape); + if (aDivShape) + { + TopExp_Explorer exp(*aDivShape, TopAbs_EDGE); + for (;exp.More();exp.Next()) + { + HYDROData_SplitToZonesTool::SplitData anNewSData(aSplitData.Type, exp.Current(), aSplitData.ObjectNames); + newEdges.append(anNewSData); + } + } + else + newEdges.append(aSplitData); + } +} + + void HYDROData_CalculationCase::Update() { HYDROData_Entity::Update(); SetWarning(); // At first we remove previously created objects - RemoveRegions( false ); - RemoveRegions( true ); - RemoveSplittedGroups(); + RemoveRegions(); + RemoveSplitGroups(); Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); if ( aDocument.IsNull() ) @@ -294,78 +428,71 @@ void HYDROData_CalculationCase::Update() HYDROData_SplitToZonesTool::SplitDataList aZonesList, anEdgesList; Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline(); + + HYDROData_SequenceOfObjects InterPolys = GetInterPolyObjects(); + HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects(); if ( !aGeomObjects.IsEmpty() ) { HYDROData_SequenceOfObjects aGeomGroups = GetGeometryGroups(); HYDROData_SplitToZonesTool::SplitDataList aSplitObjects = - HYDROData_SplitToZonesTool::Split( aGeomObjects, aGeomGroups, aBoundaryPolyline ); + 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 ) + else if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Edge || + aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_IntEdge) anEdgesList.append( aSplitData ); } } } - // Split to land cover zones - HYDROData_SplitToZonesTool::SplitDataList aLandCoverZonesList; - - HYDROData_SequenceOfObjects aLandCovers = GetLandCovers(); - if ( !aLandCovers.IsEmpty() ) { - HYDROData_SplitToZonesTool::SplitDataList aSplitLandCoverObjects = - HYDROData_SplitToZonesTool::Split( aLandCovers ); - if ( !aSplitLandCoverObjects.isEmpty() ) { - HYDROData_SplitToZonesTool::SplitDataListIterator anIter( aSplitLandCoverObjects ); - while( anIter.hasNext() ) { - const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); - if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Zone ) - aLandCoverZonesList.append( aSplitData ); - } - } - } - + // + //split edges by boundary polygons + HYDROData_SequenceOfObjects aBoundaryPolygons = GetBoundaryPolygons(); + //edge to splitted edge (compound of edges or original edge) + NCollection_IndexedDataMap ObjToRes; + //split edge list by BP + SplitEdgesByBoundaryPolygons(anEdgesList, aBoundaryPolygons, ObjToRes); + HYDROData_SplitToZonesTool::SplitDataList aNewZonesList; + //replace splitted edges in zone list (faces) + PerformEdgeReplInZones(aZonesList, ObjToRes, aNewZonesList); + // + //create new edges list based on splitting info from ObjToRes + HYDROData_SplitToZonesTool::SplitDataList newEdgesList1,newEdgesList2; + CreateNewEdgeList(anEdgesList, ObjToRes, newEdgesList1); + //filter out edges list by include&selection tools + FilterEdgesByIncludeSelectionBoundaryPolygons(newEdgesList1,aBoundaryPolygons,newEdgesList2); + switch( GetAssignmentMode() ) { case MANUAL: - CreateRegionsDef( aDocument, aZonesList, false ); - break; - case AUTOMATIC: - CreateRegionsAuto( aDocument, aZonesList, false ); - break; - } - - switch( GetAssignmentLandCoverMode() ) - { - case MANUAL: - CreateRegionsDef( aDocument, aLandCoverZonesList, true ); + CreateRegionsDef( aDocument,aNewZonesList ); break; case AUTOMATIC: - CreateRegionsAuto( aDocument, aLandCoverZonesList, true ); + CreateRegionsAuto( aDocument,aNewZonesList ); break; } - CreateEdgeGroupsDef( aDocument, anEdgesList ); + CreateEdgeGroupsDef( aDocument, newEdgesList2 ); } void HYDROData_CalculationCase::CreateRegionsDef( const Handle(HYDROData_Document)& theDoc, - const HYDROData_SplitToZonesTool::SplitDataList& theZones, - const bool theLandCover ) + const HYDROData_SplitToZonesTool::SplitDataList& theZones ) { // Create result regions for case, by default one zone for one region QString aRegsPref = CALCULATION_REGIONS_PREF; - QString aZonesPref = theLandCover ? CALCULATION_LANDCOVER_ZONES_PREF : CALCULATION_ZONES_PREF; + QString aZonesPref = CALCULATION_ZONES_PREF; HYDROData_SplitToZonesTool::SplitDataListIterator anIter( theZones ); while( anIter.hasNext() ) { const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); // Create new region - Handle(HYDROData_Region) aRegion = addNewRegion( theDoc, aRegsPref, theLandCover ); + Handle(HYDROData_Region) aRegion = addNewRegion( theDoc, aRegsPref ); // Add the zone for region Handle(HYDROData_Zone) aRegionZone = aRegion->addNewZone( theDoc, aZonesPref, aSplitData.Face(), aSplitData.ObjectNames ); @@ -373,17 +500,16 @@ void HYDROData_CalculationCase::CreateRegionsDef( const Handle(HYDROData_Documen } void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Document)& theDoc, - const HYDROData_SplitToZonesTool::SplitDataList& theZones, - const bool theLandCover ) + const HYDROData_SplitToZonesTool::SplitDataList& theZones ) { DEBTRACE("HYDROData_CalculationCase::CreateRegionsAuto"); QMap aRegionsMap; //object name to region QMap aRegionNameToObjNameMap; - QString aZonesPref = theLandCover ? CALCULATION_LANDCOVER_ZONES_PREF : CALCULATION_ZONES_PREF; - HYDROData_PriorityQueue aPr( this, theLandCover ? DataTag_CustomLandCoverRules : DataTag_CustomRules ); + 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 anObjects = theLandCover ? GetLandCovers() : GetGeometryObjects(); + HYDROData_SequenceOfObjects anObjects = GetGeometryObjects(); for( int i = anObjects.Lower(), n = anObjects.Upper(); i<=n; i++ ) { Handle(HYDROData_Entity) anObj = anObjects.Value( i ); @@ -391,7 +517,7 @@ void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Docume continue; QString anObjName = anObj->GetName(); QString aRegName = anObjName + "_reg"; - Handle(HYDROData_Region) aRegion = addNewRegion( theDoc, aRegName, theLandCover, false ); + Handle(HYDROData_Region) aRegion = addNewRegion( theDoc, aRegName, false ); aRegionsMap.insert( anObjName, aRegion ); aRegionNameToObjNameMap.insert( aRegName, anObjName ); } @@ -417,12 +543,10 @@ void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Docume } Handle(HYDROData_Entity) aMergeEntity = aRegObj; - if ( !theLandCover ) { - Handle(HYDROData_Object) aMergeObject = Handle(HYDROData_Object)::DownCast( aMergeEntity ); - if ( !aMergeObject.IsNull() ) { - DEBTRACE("aMergeEntity " << aMergeEntity->GetName().toStdString()); - aMergeEntity = aMergeObject->GetAltitudeObject(); - } + Handle(HYDROData_Object) aMergeObject = Handle(HYDROData_Object)::DownCast( aMergeEntity ); + if ( !aMergeObject.IsNull() ) { + DEBTRACE("aMergeEntity " << aMergeEntity->GetName().toStdString()); + aMergeEntity = aMergeObject->GetAltitudeObject(); } switch( aMergeType ) @@ -463,7 +587,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() ) @@ -480,20 +604,26 @@ void HYDROData_CalculationCase::CreateEdgeGroupsDef( const Handle(HYDROData_Docu QString aStr = aSplitData.ObjectNames.join(" "); cout << " CCase: Names = "<Label(), DataTag_LandCover ); - - // Indicate model of the need to update land cover partition Changed( Geom_No ); -} - -void HYDROData_CalculationCase::RemoveLandCovers() -{ - ClearReferenceObjects( DataTag_LandCover ); - - // Indicate model of the need to update land cover partition Changed( Geom_No ); -} - -Handle(HYDROData_Region) HYDROData_CalculationCase::AddNewRegion( const Handle(HYDROData_Zone)& theZone, - const bool theLandCover ) -{ + Changed( Geom_No ); Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); - Handle(HYDROData_Region) aNewRegion = addNewRegion( aDocument, CALCULATION_REGIONS_PREF, theLandCover ); + Handle(HYDROData_Region) aNewRegion = addNewRegion( aDocument, CALCULATION_REGIONS_PREF ); if ( aNewRegion.IsNull() ) return aNewRegion; @@ -681,16 +789,14 @@ Handle(HYDROData_Region) HYDROData_CalculationCase::AddNewRegion( const Handle(H return aNewRegion; } -bool HYDROData_CalculationCase::AddRegion( const Handle(HYDROData_Region)& theRegion, - const bool theLandCover ) +bool HYDROData_CalculationCase::AddRegion( const Handle(HYDROData_Region)& theRegion ) { Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); if ( theRegion.IsNull() ) return false; - HYDROData_CalculationCase::DataTag aDataTag = - theLandCover ? DataTag_LandCoverRegion : DataTag_Region; + HYDROData_CalculationCase::DataTag aDataTag = DataTag_Region; if ( HasReference( theRegion, aDataTag ) ) return false; // Object is already in reference list @@ -700,10 +806,10 @@ bool HYDROData_CalculationCase::AddRegion( const Handle(HYDROData_Region)& theRe Handle(HYDROData_CalculationCase)::DownCast( theRegion->GetFatherObject() ); if ( !aFatherCalc.IsNull() && aFatherCalc->Label() != myLab ) { - Handle(HYDROData_Region) aNewRegion = addNewRegion( aDocument, CALCULATION_REGIONS_PREF, theLandCover ); + Handle(HYDROData_Region) aNewRegion = addNewRegion( aDocument, CALCULATION_REGIONS_PREF ); theRegion->CopyTo( aNewRegion, true ); - aFatherCalc->RemoveRegion( theRegion, theLandCover ); + aFatherCalc->RemoveRegion( theRegion ); theRegion->SetLabel( aNewRegion->Label() ); } @@ -715,9 +821,9 @@ bool HYDROData_CalculationCase::AddRegion( const Handle(HYDROData_Region)& theRe return true; } -HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetRegions( const bool theLandCover ) const +HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetRegions() const { - return GetReferenceObjects( theLandCover ? DataTag_LandCoverRegion : DataTag_Region ); + return GetReferenceObjects( DataTag_Region ); } void HYDROData_CalculationCase::UpdateRegionsOrder() @@ -726,44 +832,39 @@ void HYDROData_CalculationCase::UpdateRegionsOrder() if ( aDocument.IsNull() ) return; - HYDROData_SequenceOfObjects aRegions = GetRegions( false ); - HYDROData_SequenceOfObjects aRegionsLC = GetRegions( true ); - aRegions.Append( aRegionsLC ); - + QString aRegsPref = CALCULATION_REGIONS_PREF; + std::map IndToRegion; //index in the name of region to region itself + HYDROData_SequenceOfObjects aRegions = GetRegions(); HYDROData_SequenceOfObjects::Iterator anIter( aRegions ); + QString aName; + int aVal; for ( ; anIter.More(); anIter.Next() ) { - Handle(HYDROData_Region) aRegion = - Handle(HYDROData_Region)::DownCast( anIter.Value() ); + Handle(HYDROData_Region) aRegion = Handle(HYDROData_Region)::DownCast( anIter.Value() ); if ( aRegion.IsNull() ) continue; - aRegion->SetName( "" ); + if (HYDROData_Tool::ExtractGeneratedObjectName(aRegion->GetName(), aVal, aName) && aName == aRegsPref) + IndToRegion[aVal] = aRegion; } - QString aRegsPref = CALCULATION_REGIONS_PREF; - - anIter.Init( aRegions ); - for ( ; anIter.More(); anIter.Next() ) - { - Handle(HYDROData_Region) aRegion = - Handle(HYDROData_Region)::DownCast( anIter.Value() ); - if ( aRegion.IsNull() ) - continue; - - QString aRegionName = HYDROData_Tool::GenerateObjectName( aDocument, aRegsPref ); - aRegion->SetName( aRegionName ); - } + int nbR = aRegions.Length(); + std::map::iterator it = IndToRegion.begin(); + for( int i = 1; it != IndToRegion.end(); ++it ) + if (it->first <= nbR + 1) + { + QString aNewName = QString("%1_%2").arg(aRegsPref).arg(QString::number(i)); + it->second->SetName(aNewName); + i++; + } } -void HYDROData_CalculationCase::RemoveRegion( const Handle(HYDROData_Region)& theRegion, - const bool theLandCover ) +void HYDROData_CalculationCase::RemoveRegion( const Handle(HYDROData_Region)& theRegion ) { if ( theRegion.IsNull() ) return; - HYDROData_CalculationCase::DataTag aDataTag = - theLandCover ? DataTag_LandCoverRegion : DataTag_Region; + HYDROData_CalculationCase::DataTag aDataTag = DataTag_Region; RemoveReferenceObject( theRegion->Label(), aDataTag ); // Remove region from data model @@ -773,43 +874,44 @@ void HYDROData_CalculationCase::RemoveRegion( const Handle(HYDROData_Region)& th theRegion->Remove(); } -void HYDROData_CalculationCase::RemoveRegions( const bool theLandCover ) +void HYDROData_CalculationCase::RemoveRegions() { - myLab.FindChild( theLandCover ? DataTag_ChildLandCoverRegion : DataTag_ChildRegion ).ForgetAllAttributes(); + myLab.FindChild( DataTag_ChildRegion ).ForgetAllAttributes(); } -HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetSplittedGroups() const +HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetSplitGroups() const { - return GetReferenceObjects( DataTag_SplittedGroups ); + return GetReferenceObjects( DataTag_SplitGroups ); } -void HYDROData_CalculationCase::RemoveSplittedGroups() +void HYDROData_CalculationCase::RemoveSplitGroups() { - myLab.FindChild( DataTag_SplittedGroups ).ForgetAllAttributes(); + myLab.FindChild( DataTag_SplitGroups ).ForgetAllAttributes(); } double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint ) const { - Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint, false ); + Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint ); return GetAltitudeForPoint( thePoint, aZone ); } double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint, - const Handle(HYDROData_Region)& theRegion ) const + const Handle(HYDROData_Region)& theRegion, + int theMethod) const { double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude(); - Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint, false ); + Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint ); if ( !aZone.IsNull() ) { - //DEBTRACE("GetAltitudeForPoint Region " << theRegion->GetName().toStdString() << " Zone " << aZone->GetName().toStdString()); + DEBTRACE("GetAltitudeForPoint Region " << theRegion->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 ); + aResAltitude = GetAltitudeForPoint( thePoint, aZone, theMethod ); } } else @@ -821,9 +923,10 @@ double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& } 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()); + DEBTRACE("GetAltitudeForPoint Zone " << theZone->GetName().toStdString()); double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude(); if ( theZone.IsNull() ) { @@ -832,11 +935,11 @@ double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& } HYDROData_Zone::MergeType aZoneMergeType = theZone->GetMergeType(); - //DEBTRACE("aZoneMergeType " << aZoneMergeType); + DEBTRACE("aZoneMergeType " << aZoneMergeType); if ( !theZone->IsMergingNeed() ) { aZoneMergeType = HYDROData_Zone::Merge_UNKNOWN; - //DEBTRACE("---"); + DEBTRACE("---"); } else if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN ) { @@ -866,7 +969,7 @@ double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& } else { - //DEBTRACE("aZoneMergeType != HYDROData_Zone::Merge_Object"); + DEBTRACE("aZoneMergeType != HYDROData_Zone::Merge_Object"); HYDROData_SequenceOfObjects aZoneObjects = theZone->GetObjects(); HYDROData_SequenceOfObjects::Iterator anIter( aZoneObjects ); for ( ; anIter.More(); anIter.Next() ) @@ -889,8 +992,8 @@ double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& } else { - //DEBTRACE("aZoneInterpolator == NULL"); - aPointAltitude = anObjAltitude->GetAltitudeForPoint( thePoint ); + DEBTRACE("aZoneInterpolator == NULL"); + aPointAltitude = anObjAltitude->GetAltitudeForPoint( thePoint, theMethod ); } if ( ValuesEquals( aPointAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) ) @@ -925,16 +1028,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()); + 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 ); } @@ -943,7 +1047,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; @@ -951,7 +1056,7 @@ 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 ); } @@ -960,54 +1065,62 @@ NCollection_Sequence HYDROData_CalculationCase::GetAltitudesForPoints( double HYDROData_CalculationCase::GetStricklerCoefficientForPoint( const gp_XY& thePoint ) const { - double aCoeff = 0; - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); - if ( !aDocument.IsNull() ) - aCoeff = aDocument->GetDefaultStricklerCoefficient(); + Handle( HYDROData_LandCoverMap ) aMap = GetLandCoverMap(); + Handle( HYDROData_StricklerTable ) aTable = GetStricklerTable(); + if( aMap.IsNull() ) + return 0.0; - Handle(HYDROData_LandCover) aLandCover; - Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint, Standard_True ); - if ( !aZone.IsNull() ) - { - HYDROData_SequenceOfObjects anObjList = aZone->GetObjects(); - if ( anObjList.Length() == 1 ) - aLandCover = Handle(HYDROData_LandCover)::DownCast( anObjList.First() ); - else - aLandCover = Handle(HYDROData_LandCover)::DownCast( aZone->GetMergeObject() ); - } + QString aType; + aMap->FindByPoint( thePoint, aType ); + double aCoeff = aTable->Get( aType, 0.0 ); + return aCoeff; +} - if ( !aLandCover.IsNull() ) - { - QString aType = aLandCover->GetStricklerType(); - Handle(HYDROData_StricklerTable) aTable = GetStricklerTable(); - if ( !aTable.IsNull() ) - { - if ( aTable->GetTypes().contains( aType ) ) - aCoeff = aTable->Get( aType, aCoeff ); - } - } +std::vector HYDROData_CalculationCase::GetStricklerCoefficientForPoints(const std::vector& thePoints, + double DefValue, bool UseMax ) const +{ + DEBTRACE("GetStricklerCoefficientForPoints"); + Handle( HYDROData_LandCoverMap ) aLCM = GetLandCoverMap(); + Handle( HYDROData_StricklerTable ) aTable = GetStricklerTable(); + std::vector theCoeffs; + DEBTRACE("aLCM.IsNull() " << aLCM.IsNull()); + DEBTRACE("aTable.IsNull() "<< aTable.IsNull()); + if( aLCM.IsNull() || aTable.IsNull() ) + return theCoeffs; + + aLCM->ClassifyPoints(thePoints, aTable, theCoeffs, DefValue, UseMax ); + + return theCoeffs; +} + +std::vector HYDROData_CalculationCase::GetStricklerTypeForPoints( const std::vector& thePoints ) const +{ + Handle( HYDROData_LandCoverMap ) aLCM = GetLandCoverMap(); + Handle( HYDROData_StricklerTable ) aTable = GetStricklerTable(); + std::vector types; + if( aLCM.IsNull() || aTable.IsNull() ) + return types; - return aCoeff; + aLCM->ClassifyPoints(thePoints, aTable, types ); + return types; } -Handle(HYDROData_Region) HYDROData_CalculationCase::GetRegionFromPoint( const gp_XY& thePoint, - const bool theLandCover ) const +Handle(HYDROData_Region) HYDROData_CalculationCase::GetRegionFromPoint( const gp_XY& thePoint ) const { Handle(HYDROData_Region) aResRegion; - Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint, theLandCover ); + Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint ); if ( !aZone.IsNull() ) aResRegion = Handle(HYDROData_Region)::DownCast( aZone->GetFatherObject() ); return aResRegion; } -Handle(HYDROData_Zone) HYDROData_CalculationCase::GetZoneFromPoint( const gp_XY& thePoint, - const bool theLandCover ) const +Handle(HYDROData_Zone) HYDROData_CalculationCase::GetZoneFromPoint( const gp_XY& thePoint ) const { Handle(HYDROData_Zone) aResZone; - HYDROData_SequenceOfObjects aRegions = GetRegions( theLandCover ); + HYDROData_SequenceOfObjects aRegions = GetRegions(); HYDROData_SequenceOfObjects::Iterator anIter( aRegions ); for ( ; anIter.More() && aResZone.IsNull(); anIter.Next() ) @@ -1068,30 +1181,29 @@ HYDROData_CalculationCase::PointClassification HYDROData_CalculationCase::GetPoi Handle(HYDROData_Region) HYDROData_CalculationCase::addNewRegion( const Handle(HYDROData_Document)& theDoc, const QString& thePrefixOrName, - const bool theLandCover, bool isPrefix ) { - TDF_Label aNewLab = myLab.FindChild( theLandCover ? DataTag_ChildLandCoverRegion : DataTag_ChildRegion ).NewChild(); + TDF_Label aNewLab = myLab.FindChild( DataTag_ChildRegion ).NewChild(); int aTag = aNewLab.Tag(); Handle(HYDROData_Region) aNewRegion = Handle(HYDROData_Region)::DownCast( HYDROData_Iterator::CreateObject( aNewLab, KIND_REGION ) ); - AddRegion( aNewRegion, theLandCover ); + 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 ); @@ -1100,25 +1212,34 @@ 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, anErrorMsg; - bool isOK = Export( aGEOMEngine, aDSStudy, aGeomObjEntry, anErrorMsg ); + QString statMess; + bool isOK = Export( aGEOMEngine, aDSStudy, aGeomObjEntry, anErrorMsg, statMess ); return isOK ? aGeomObjEntry : QString(); +#endif } +#ifndef LIGHT_MODE bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, SALOMEDS::Study_ptr theStudy, QString& theGeomObjEntry, - QString& theErrorMsg ) const + QString& theErrorMsg, + QString& statMess) const { + DEBTRACE("Export"); HYDROData_ShapesGroup::SeqOfGroupsDefs aSeqOfGroupsDefs; // Get groups definitions - HYDROData_SequenceOfObjects aSplittedGroups = GetSplittedGroups(); + HYDROData_SequenceOfObjects aSplitGroups = GetSplitGroups(); - HYDROData_SequenceOfObjects::Iterator anIter( aSplittedGroups ); + TopTools_SequenceOfShape IntSh; //internal edges + HYDROData_SequenceOfObjects::Iterator anIter( aSplitGroups ); for ( ; anIter.More(); anIter.Next() ) { // Get shapes group @@ -1133,13 +1254,23 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, aGroup->GetShapes( aGroupDef.Shapes ); aSeqOfGroupsDefs.Append( aGroupDef ); + + Handle(HYDROData_SplitShapesGroup) aSSGroup = Handle(HYDROData_SplitShapesGroup)::DownCast( anIter.Value() ); + TopTools_SequenceOfShape dummy; + if (!aSSGroup.IsNull()) + if (aSSGroup->GetInternal()) + { + aSSGroup->GetShapes(dummy); + IntSh.Append(dummy); + } + } // Get faces bool isAllNotSubmersible = true; - TopTools_ListOfShape aFaces; - HYDROData_SequenceOfObjects aCaseRegions = GetRegions( false ); + HYDROData_SequenceOfObjects aCaseRegions = GetRegions(); HYDROData_SequenceOfObjects::Iterator aRegionIter( aCaseRegions ); + NCollection_IndexedDataMap aShToNames; for ( ; aRegionIter.More(); aRegionIter.Next() ) { Handle(HYDROData_Region) aRegion = @@ -1150,8 +1281,8 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, if ( isAllNotSubmersible ) isAllNotSubmersible = false; - TopoDS_Shape aRegionShape = aRegion->GetShape( &aSeqOfGroupsDefs ); - aFaces.Append( aRegionShape ); + TopoDS_Shape aRegionShape = aRegion->GetShape( &aSeqOfGroupsDefs, &IntSh ); + aShToNames.Add( aRegionShape, aRegion->GetName() ); } bool aRes = false; @@ -1161,15 +1292,22 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, } else if ( isAllNotSubmersible ) { theErrorMsg = QString("there are no submersible regions."); } else { - aRes = Export( theGeomEngine, theStudy, aFaces, aSeqOfGroupsDefs, theGeomObjEntry );; + aRes = Export( theGeomEngine, theStudy, aShToNames, aSeqOfGroupsDefs, theGeomObjEntry );; } + if( aRes && !GetLandCoverMap().IsNull() && !GetStricklerTable().IsNull() ) + { + QString aTelemacFileName = GetName() + ".telemac"; + aRes = GetLandCoverMap()->ExportTelemac( aTelemacFileName, 1E-2, GetStricklerTable(), statMess ); + if (!aRes) + theErrorMsg = QString( "The export to TELEMAC %1 failed" ).arg( aTelemacFileName ); + } return aRes; } bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, SALOMEDS::Study_ptr theStudy, - const TopTools_ListOfShape& theFaces, + const NCollection_IndexedDataMap& aShToName, const HYDROData_ShapesGroup::SeqOfGroupsDefs& theGroupsDefs, QString& theGeomObjEntry ) const { @@ -1180,34 +1318,33 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var TCollection_AsciiString aNam("Sh_"); int i=1; #endif - TopTools_ListIteratorOfListOfShape aFaceIter( theFaces ); - for ( ; aFaceIter.More(); aFaceIter.Next() ) + TopTools_DataMapOfShapeListOfShape SH2M; + for ( int i = 1; i <= aShToName.Extent(); i++ ) { - TopoDS_Shape aShape = aFaceIter.Value(); + const TopoDS_Shape& aShape = aShToName.FindKey(i); if ( aShape.IsNull() ) continue; - if ( aShape.ShapeType() == TopAbs_FACE ) + SH2M.Bind(aShape, TopTools_ListOfShape()); + TopTools_ListOfShape& LM = SH2M.ChangeFind(aShape); + if ( aShape.ShapeType() == TopAbs_FACE || aShape.ShapeType() == TopAbs_SHELL ) { aSewing.Add( aShape ); -#ifdef DEB_CALCULATION - TCollection_AsciiString aName = aNam + ++i + ".brep"; - BRepTools::Write(aShape ,aName.ToCString()); -#endif + LM.Append(aShape); } - else + else if (aShape.ShapeType() == TopAbs_COMPOUND) { -#ifdef DEB_CALCULATION - int j = 1; -#endif - TopExp_Explorer anExp( aShape, TopAbs_FACE ); - for (; anExp.More(); anExp.Next() ) { + TopExp_Explorer anExp( aShape, TopAbs_SHELL ); + for (; anExp.More(); anExp.Next() ) + { aSewing.Add( anExp.Current() ); -#ifdef DEB_CALCULATION - - TCollection_AsciiString aName = aNam + i + "_" + ++j + ".brep"; - BRepTools::Write(anExp.Current() ,aName.ToCString()); -#endif + LM.Append(anExp.Current()); + } + anExp.Init( aShape, TopAbs_FACE, TopAbs_SHELL ); + for (; anExp.More(); anExp.Next() ) + { + aSewing.Add( anExp.Current() ); + LM.Append(anExp.Current()); } } } // faces iterator @@ -1215,17 +1352,34 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var aSewing.Perform(); TopoDS_Shape aSewedShape = aSewing.SewedShape(); + NCollection_IndexedDataMap aFacesToNameModif; + + for ( int i = 1; i <= aShToName.Extent(); i++ ) + { + const TopoDS_Shape& CurShape = aShToName.FindKey(i); + const QString& Qstr = aShToName.FindFromIndex(i); + const TopTools_ListOfShape& LM = SH2M(CurShape); + for (TopTools_ListIteratorOfListOfShape it(LM); it.More(); it.Next()) + { + const TopoDS_Shape& csh = it.Value(); + if (aSewing.IsModified(csh)) + aFacesToNameModif.Add(aSewing.Modified(csh), Qstr); + else + aFacesToNameModif.Add(csh, Qstr); + } + } + + // If the sewed shape is empty - return false if ( aSewedShape.IsNull() || !TopoDS_Iterator( aSewedShape ).More() ) return false; #ifdef DEB_CALCULATION BRepTools::Write(aSewedShape ,"Sew.brep"); -#endif - // Publish the sewed shape +#endif // Publish the sewed shape QString aName = EXPORT_NAME; GEOM::GEOM_Object_ptr aMainShape = - HYDROData_GeomTool::publishShapeInGEOM( theGeomEngine, theStudy, aSewedShape, aName, theGeomObjEntry ); + HYDROData_GeomTool::ExplodeShapeInGEOMandPublish( theGeomEngine, theStudy, aSewedShape, aFacesToNameModif, aName, theGeomObjEntry ); if ( aMainShape->_is_nil() ) return false; @@ -1321,6 +1475,7 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var return true; } +#endif void HYDROData_CalculationCase::ClearRules( HYDROData_CalculationCase::DataTag theDataTag, const bool theIsSetToUpdate ) @@ -1353,17 +1508,11 @@ QString HYDROData_CalculationCase::DumpRules() const return HYDROData_PriorityQueue::DumpRules( aRulesLab ); } -QString HYDROData_CalculationCase::DumpLandCoverRules() const -{ - TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomLandCoverRules ); - return HYDROData_PriorityQueue::DumpRules( aRulesLab ); -} - void HYDROData_CalculationCase::SetAssignmentMode( AssignmentMode theMode ) { TDF_Label aModeLab = myLab.FindChild( DataTag_AssignmentMode ); - TDataStd_Integer::Set( aModeLab, ( int ) theMode ); - + Handle(TDataStd_Integer) anAttr = TDataStd_Integer::Set( aModeLab, ( int ) theMode ); + anAttr->SetID(TDataStd_Integer::GetID()); // Indicate model of the need to update splitting Changed( Geom_2d ); } @@ -1385,13 +1534,6 @@ void HYDROData_CalculationCase::DumpRulesToPython( const QString& theCalcCaseNam HYDROData_PriorityQueue::DumpRulesToPython( aRulesLab, theCalcCaseName, theScript ); } -void HYDROData_CalculationCase::DumpLandCoverRulesToPython( const QString& theCalcCaseName, - QStringList& theScript ) const -{ - TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomLandCoverRules ); - HYDROData_PriorityQueue::DumpRulesToPython( aRulesLab, theCalcCaseName, theScript ); -} - HYDROData_Warning HYDROData_CalculationCase::GetLastWarning() const { return myLastWarning; @@ -1432,22 +1574,33 @@ void HYDROData_CalculationCase::UpdateRegionsNames( const HYDROData_SequenceOfOb } void HYDROData_CalculationCase::DumpRegionsToPython( QStringList& theResList, + const QString& thePyScriptPath, MapOfTreatedObjects& theTreatedObjects, const HYDROData_SequenceOfObjects& theRegions ) const { HYDROData_SequenceOfObjects::Iterator anIter; - anIter.Init( theRegions ); - 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 ); - theResList << aRegDump; - } + 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, @@ -1462,21 +1615,64 @@ 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 - Changed( Geom_No ); + if ( HasReference( theInterPolyline, aDataTag ) ) + return false; + + AddReferenceObject( theInterPolyline, aDataTag ); + + Changed( Geom_2d ); + + 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 ); + + Changed( Geom_2d ); } + +bool HYDROData_CalculationCase::AddBoundaryPolygon( const Handle(HYDROData_BCPolygon)& theBCPolygon ) +{ + HYDROData_CalculationCase::DataTag aDataTag = DataTag_BCPolygon; + + if ( HasReference( theBCPolygon, aDataTag ) ) + return false; + + AddReferenceObject( theBCPolygon, aDataTag ); + + Changed( Geom_2d ); + + return true; +} + +HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetBoundaryPolygons() const +{ + return GetReferenceObjects( DataTag_BCPolygon ); +} + +void HYDROData_CalculationCase::RemoveBoundaryPolygon( const Handle(HYDROData_BCPolygon)& theBCPolygon ) +{ + if ( theBCPolygon.IsNull() ) + return; + + RemoveReferenceObject( theBCPolygon->Label(), DataTag_BCPolygon ); + + Changed( Geom_2d ); +} + + + +