X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_CalculationCase.cxx;h=8dcedb1ed41d7cff19150374a8901ab9fd233ac2;hb=6120f6f24e5568ffa69e959689789e1fbe59d58a;hp=3919019f0adcfac78e69d3c05c67502bdba55647;hpb=21456a609299f2ab340ea325a17c508c0748e45b;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_CalculationCase.cxx b/src/HYDROData/HYDROData_CalculationCase.cxx old mode 100644 new mode 100755 index 3919019f..8dcedb1e --- a/src/HYDROData/HYDROData_CalculationCase.cxx +++ b/src/HYDROData/HYDROData_CalculationCase.cxx @@ -30,6 +30,10 @@ #include "HYDROData_Region.h" #include "HYDROData_Tool.h" #include "HYDROData_GeomTool.h" +#include +#include +#include +#include #ifdef WIN32 #pragma warning ( disable: 4251 ) @@ -44,6 +48,9 @@ #endif #include +#include +#include +#include #include #include @@ -52,6 +59,8 @@ #include #include #include +#include +#include #include @@ -62,6 +71,8 @@ #include #include +#include + //#define DEB_CALCULATION 1 #ifdef DEB_CALCULATION #include @@ -77,7 +88,14 @@ #define EXPORT_NAME "HYDRO_" + GetName() -IMPLEMENT_STANDARD_HANDLE(HYDROData_CalculationCase, HYDROData_Entity) +#ifndef LIGHT_MODE +#include +#include +#endif + +//#define _DEVDEBUG_ +#include "HYDRO_trace.hxx" + IMPLEMENT_STANDARD_RTTIEXT(HYDROData_CalculationCase, HYDROData_Entity) HYDROData_CalculationCase::HYDROData_CalculationCase() @@ -154,21 +172,35 @@ QStringList HYDROData_CalculationCase::DumpToPython( const QString& thePyS 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 ); } + HYDROData_SequenceOfObjects aBPolygons = GetBoundaryPolygons(); + for (int i = 1; i <= aBPolygons.Size(); i++ ) + { + Handle(HYDROData_BCPolygon) aBCPoly = Handle(HYDROData_BCPolygon)::DownCast( aBPolygons(i) ); + setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aBCPoly, "AddBoundaryPolygon" ); + } + aResList << QString( "" ); + Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline(); 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 ); 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 ) { @@ -190,11 +222,12 @@ QStringList HYDROData_CalculationCase::DumpToPython( const QString& thePyS 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; @@ -256,6 +289,172 @@ HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetAllReferenceObjects() 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, + HYDROData_SplitToZonesTool::SplitDataList& outBoundaryPolygonEdgesList) +{ + //perform boundary condition polygons on EdgesList + TopTools_SequenceOfShape CutTools; + NCollection_DataMap BPolyToName; + + 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); + QString bp_name = aBCPoly->GetName(); + BPolyToName.Bind(aPolyTopShape, bp_name); + } + } + + 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()); + } + + NCollection_IndexedDataMap BPFaceToCutEdges; + HYDROData_BoundaryPolygonTools::CutTool(CutTools, ObjToRes, BPFaceToCutEdges); + // + for (int i = 1; i <= CutTools.Length(); i++ ) + { + TopoDS_Shape F = CutTools(i); + const QString* name = BPolyToName.Seek(F); + const TopTools_MapOfShape* EdgesIn = BPFaceToCutEdges.Seek(F); // EdgesIn : edges inside boudnary polygon F + if (name && EdgesIn) + { + TopTools_MapIteratorOfMapOfShape it(*EdgesIn); + for (;it.More();it.Next()) + { + TopoDS_Edge E = TopoDS::Edge(it.Value()); + if (!E.IsNull()) + { + HYDROData_SplitToZonesTool::SplitData SD(HYDROData_SplitToZonesTool::SplitData::Data_Edge, E, *name); + outBoundaryPolygonEdgesList.append(SD); + } + } + } + } +} + + +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.IsNull()) + continue; + 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(); @@ -273,35 +472,59 @@ 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 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 + HYDROData_SplitToZonesTool::SplitDataList outBoundaryPolygonEdgesList; //new groups - for each BP of type 1 (cut) create a group of edges which are inside of this BP + SplitEdgesByBoundaryPolygons(anEdgesList, aBoundaryPolygons, ObjToRes, outBoundaryPolygonEdgesList); + 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); + // + newEdgesList1.append(outBoundaryPolygonEdgesList); //append new list of groups + //filter out edges list by include&selection tools + FilterEdgesByIncludeSelectionBoundaryPolygons(newEdgesList1,aBoundaryPolygons,newEdgesList2); + switch( GetAssignmentMode() ) { case MANUAL: - CreateRegionsDef( aDocument, aZonesList ); + CreateRegionsDef( aDocument,aNewZonesList ); break; case AUTOMATIC: - CreateRegionsAuto( aDocument, aZonesList ); + CreateRegionsAuto( aDocument,aNewZonesList ); break; } - CreateEdgeGroupsDef( aDocument, anEdgesList ); + CreateEdgeGroupsDef( aDocument, newEdgesList2 ); } void HYDROData_CalculationCase::CreateRegionsDef( const Handle(HYDROData_Document)& theDoc, @@ -326,6 +549,7 @@ 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; @@ -368,6 +592,7 @@ void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Docume 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(); } @@ -439,7 +664,13 @@ void HYDROData_CalculationCase::CreateEdgeGroupsDef( const Handle(HYDROData_Docu if ( aSplitGroup.IsNull() ) continue; - aSplitGroup->AddShape( aSplitData.Shape ); + aSplitGroup->AddShape( aSplitData.Shape ); + + TopTools_SequenceOfShape theShapes; + aSplitGroup->GetShapes(theShapes); + + if (aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_IntEdge) + aSplitGroup->SetInternal(true); } } @@ -581,6 +812,7 @@ Handle(HYDROData_LandCoverMap) HYDROData_CalculationCase::GetLandCoverMap() cons { Handle(HYDROData_LandCoverMap) aMap = Handle(HYDROData_LandCoverMap)::DownCast( GetReferenceObject( DataTag_LandCoverMap ) ); + DEBTRACE("GetLandCoverMap " << aMap.IsNull()); return aMap; } @@ -647,31 +879,31 @@ void HYDROData_CalculationCase::UpdateRegionsOrder() if ( aDocument.IsNull() ) return; + 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 ) @@ -711,35 +943,54 @@ double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint ) c } 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 ); if ( !aZone.IsNull() ) { + 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, 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::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; } @@ -752,15 +1003,20 @@ double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& { if ( aZoneInterpolator != NULL ) { + DEBTRACE("aZoneInterpolator != NULL"); aZoneInterpolator->SetAltitudeObject( aMergeAltitude ); aResAltitude = aZoneInterpolator->GetAltitudeForPoint( thePoint ); } else - aResAltitude = aMergeAltitude->GetAltitudeForPoint( thePoint ); + { + DEBTRACE("aZoneInterpolator == NULL"); + aResAltitude = aMergeAltitude->GetAltitudeForPoint( thePoint, theMethod ); + } } } else { + DEBTRACE("aZoneMergeType != HYDROData_Zone::Merge_Object"); HYDROData_SequenceOfObjects aZoneObjects = theZone->GetObjects(); HYDROData_SequenceOfObjects::Iterator anIter( aZoneObjects ); for ( ; anIter.More(); anIter.Next() ) @@ -777,11 +1033,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; @@ -815,24 +1075,48 @@ 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 ); + Handle(Message_ProgressIndicator) aZIProgress = HYDROData_Tool::GetZIProgress(); + //DEBTRACE("aZIProgress=" << aZIProgress); + if ( aZIProgress ) { + aZIProgress->Reset(); + } + + QFuture aFuture = QtConcurrent::run([&]() { + int aNbPoints = thePoints.Length(); + + Message_ProgressSentry aPSentry(HYDROData_Tool::GetZIProgress(), "GetAltitudesForPoints", 0, aNbPoints, 1); + for ( int i = 1, n = aNbPoints; i <= n && aPSentry.More(); ++i, aPSentry.Next() ) + { + const gp_XY& thePnt = thePoints.Value( i ); - double anAltitude = GetAltitudeForPoint( thePnt, theRegion ); - aResSeq.Append( anAltitude ); + double anAltitude = GetAltitudeForPoint( thePnt, theRegion, theMethod ); + aResSeq.Append( anAltitude ); + } + }); + + while( aFuture.isRunning() ) { + if ( aZIProgress ) { + aZIProgress->Show( Standard_True ); + QThread::usleep(500); + } } + //DEBTRACE("aZIProgress=" << aZIProgress); + if ( aZIProgress ) + aZIProgress->Show( Standard_True ); return aResSeq; } 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; @@ -840,7 +1124,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 ); } @@ -860,6 +1144,49 @@ double HYDROData_CalculationCase::GetStricklerCoefficientForPoint( const gp_XY& return 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; + + Handle(Message_ProgressIndicator) aSIProgress = HYDROData_Tool::GetSIProgress(); + if ( aSIProgress ) { + aSIProgress->Reset(); + } + + QFuture aFuture = QtConcurrent::run([&]() { + aLCM->ClassifyPoints(thePoints, aTable, theCoeffs, DefValue, UseMax ); + }); + + while( aFuture.isRunning() ) { + if ( aSIProgress ) { + aSIProgress->Show( Standard_True ); + QThread::usleep(500); + } + } + + 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; + + aLCM->ClassifyPoints(thePoints, aTable, types ); + return types; +} + Handle(HYDROData_Region) HYDROData_CalculationCase::GetRegionFromPoint( const gp_XY& thePoint ) const { Handle(HYDROData_Region) aResRegion; @@ -946,7 +1273,7 @@ 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; } @@ -974,7 +1301,8 @@ QString HYDROData_CalculationCase::Export( int theStudyId ) const 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 } @@ -983,13 +1311,16 @@ QString HYDROData_CalculationCase::Export( int theStudyId ) const 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 aSplitGroups = GetSplitGroups(); + TopTools_SequenceOfShape IntSh; //internal edges HYDROData_SequenceOfObjects::Iterator anIter( aSplitGroups ); for ( ; anIter.More(); anIter.Next() ) { @@ -1005,13 +1336,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(); HYDROData_SequenceOfObjects::Iterator aRegionIter( aCaseRegions ); + NCollection_IndexedDataMap aShToNames; for ( ; aRegionIter.More(); aRegionIter.Next() ) { Handle(HYDROData_Region) aRegion = @@ -1022,8 +1363,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; @@ -1033,15 +1374,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 { @@ -1052,34 +1400,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 @@ -1087,17 +1434,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; @@ -1229,8 +1593,8 @@ QString HYDROData_CalculationCase::DumpRules() const 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 ); } @@ -1297,18 +1661,28 @@ void HYDROData_CalculationCase::DumpRegionsToPython( QStringList& theResList, 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( thePyScriptPath, 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, @@ -1322,3 +1696,65 @@ bool HYDROData_CalculationCase::GetRule( int theIndex, return HYDROData_PriorityQueue::GetRule( aRulesLab, theIndex, theObject1, thePriority, theObject2, theMergeType ); } + +bool HYDROData_CalculationCase::AddInterPoly( const Handle(HYDROData_PolylineXY)& theInterPolyline ) +{ + HYDROData_CalculationCase::DataTag aDataTag = DataTag_InterPoly; + + if ( HasReference( theInterPolyline, aDataTag ) ) + return false; + + AddReferenceObject( theInterPolyline, aDataTag ); + + Changed( Geom_2d ); + + return true; +} + +HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetInterPolyObjects() const +{ + 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 ); +} + + + +