X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_CalculationCase.cxx;h=12aca20da9df2a77b0a89344036dcfe8acc52472;hb=c16caee6b6e61dffbc739dce6639215b24a459d3;hp=6c4239054597b9bc78597bc808343bfec3061902;hpb=2b03abaf3d543206a0dd3eca896c05e22490c74e;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_CalculationCase.cxx b/src/HYDROData/HYDROData_CalculationCase.cxx index 6c423905..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,15 +25,27 @@ #include "HYDROData_NaturalObject.h" #include "HYDROData_PolylineXY.h" #include "HYDROData_StricklerTable.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 #include @@ -47,6 +55,8 @@ #include #include #include +#include +#include #include @@ -70,17 +80,20 @@ #include #endif -#ifdef WIN32 - #pragma warning ( default: 4251 ) +#define EXPORT_NAME "HYDRO_" + GetName() + +#ifndef LIGHT_MODE +#include +#include #endif -#define EXPORT_NAME "HYDRO_" + GetName() +//#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 ) { } @@ -96,14 +109,14 @@ void HYDROData_CalculationCase::SetName( const QString& theName ) // Update names of regions and its zones 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; @@ -114,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" ); @@ -131,7 +145,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( "" ); @@ -152,27 +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 ); 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() ); + DumpRegionsToPython( aResList, thePyScriptPath, theTreatedObjects, GetRegions() ); } // Export calculation case @@ -188,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; @@ -244,6 +265,9 @@ 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 ); @@ -251,6 +275,142 @@ 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) +{ + //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(); @@ -258,7 +418,7 @@ 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() ) @@ -268,35 +428,56 @@ 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 + 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 ); + 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, @@ -321,6 +502,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; @@ -363,6 +545,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(); } @@ -404,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() ) @@ -421,20 +604,26 @@ void HYDROData_CalculationCase::CreateEdgeGroupsDef( const Handle(HYDROData_Docu QString aStr = aSplitData.ObjectNames.join(" "); cout << " CCase: Names = "< 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 ) @@ -672,14 +879,14 @@ void HYDROData_CalculationCase::RemoveRegions() 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 @@ -689,35 +896,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; } @@ -730,15 +956,20 @@ double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& { if ( aZoneInterpolator != NULL ) { + DEBTRACE("aZoneInterpolator != NULL"); aZoneInterpolator->SetAltitudeObject( aMergeAltitude ); aResAltitude = aZoneInterpolator->GetAltitudeForPoint( thePoint ); } else + { + DEBTRACE("aZoneInterpolator == NULL"); aResAltitude = aMergeAltitude->GetAltitudeForPoint( thePoint ); + } } } else { + DEBTRACE("aZoneMergeType != HYDROData_Zone::Merge_Object"); HYDROData_SequenceOfObjects aZoneObjects = theZone->GetObjects(); HYDROData_SequenceOfObjects::Iterator anIter( aZoneObjects ); for ( ; anIter.More(); anIter.Next() ) @@ -755,11 +986,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; @@ -793,15 +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()); 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 ); } @@ -810,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; @@ -818,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 ); } @@ -827,8 +1065,44 @@ NCollection_Sequence HYDROData_CalculationCase::GetAltitudesForPoints( double HYDROData_CalculationCase::GetStricklerCoefficientForPoint( const gp_XY& thePoint ) const { - //TODO: #652 - return 0.0; + 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 +{ + 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; + + aLCM->ClassifyPoints(thePoints, aTable, types ); + return types; } Handle(HYDROData_Region) HYDROData_CalculationCase::GetRegionFromPoint( const gp_XY& thePoint ) const @@ -917,19 +1191,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 ); @@ -945,7 +1219,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 } @@ -954,14 +1229,17 @@ 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 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 @@ -976,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(); HYDROData_SequenceOfObjects::Iterator aRegionIter( aCaseRegions ); + NCollection_IndexedDataMap aShToNames; for ( ; aRegionIter.More(); aRegionIter.Next() ) { Handle(HYDROData_Region) aRegion = @@ -993,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; @@ -1004,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 { @@ -1023,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 @@ -1058,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; @@ -1174,7 +1485,7 @@ void HYDROData_CalculationCase::ClearRules( HYDROData_CalculationCase::DataTag t // Indicate model of the need to update splitting if ( theIsSetToUpdate ) { - SetToUpdate( true ); + Changed( Geom_2d ); } } @@ -1188,7 +1499,7 @@ void HYDROData_CalculationCase::AddRule( const Handle(HYDROData_Entity)& theO 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 @@ -1200,10 +1511,10 @@ 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 - SetToUpdate( true ); + Changed( Geom_2d ); } HYDROData_CalculationCase::AssignmentMode HYDROData_CalculationCase::GetAssignmentMode() const @@ -1263,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, @@ -1292,3 +1614,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 ); +} + + + +