X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_CalculationCase.cxx;h=4fd970820e2ee2b245857897ebefa33d19837b9f;hb=58bb6b7459bebeeb089c9ed486c4683a8bae7288;hp=8498732a85d611bef94a1951a8f72e4be3652e66;hpb=093e1632a7b5ab67b164753d150489f2372238ca;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_CalculationCase.cxx b/src/HYDROData/HYDROData_CalculationCase.cxx index 8498732a..f1b7a564 100644 --- a/src/HYDROData/HYDROData_CalculationCase.cxx +++ b/src/HYDROData/HYDROData_CalculationCase.cxx @@ -1,6 +1,22 @@ +// Copyright (C) 2014-2015 EDF-R&D +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #include "HYDROData_CalculationCase.h" - #include "HYDROData_ArtificialObject.h" #include "HYDROData_IAltitudeObject.h" #include "HYDROData_Document.h" @@ -8,13 +24,24 @@ #include "HYDROData_Iterator.h" #include "HYDROData_NaturalObject.h" #include "HYDROData_PolylineXY.h" -#include "HYDROData_SplitToZonesTool.h" -#include "HYDROData_SplittedShapesGroup.h" +#include "HYDROData_StricklerTable.h" +#include "HYDROData_LandCoverMap.h" +#include "HYDROData_SplitShapesGroup.h" #include "HYDROData_Region.h" #include "HYDROData_Tool.h" -#include "HYDROData_Zone.h" +#include "HYDROData_GeomTool.h" + +#ifdef WIN32 + #pragma warning ( disable: 4251 ) +#endif +#ifndef LIGHT_MODE #include +#endif + +#ifdef WIN32 + #pragma warning ( default: 4251 ) +#endif #include @@ -33,6 +60,7 @@ #include #include #include +#include //#define DEB_CALCULATION 1 #ifdef DEB_CALCULATION @@ -42,14 +70,25 @@ #define CALCULATION_REGIONS_PREF GetName() + "_Reg" #define CALCULATION_ZONES_PREF GetName() + "_Zone" #define CALCULATION_GROUPS_PREF GetName() + "_" +//#define DEB_CLASS2D 1 +#ifdef DEB_CLASS2D +#include +#endif #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() -: HYDROData_Entity() +: HYDROData_Entity( Geom_2d_and_groups ) { } @@ -62,38 +101,17 @@ void HYDROData_CalculationCase::SetName( const QString& theName ) QString anOldCaseName = GetName(); if ( anOldCaseName != theName ) { - HYDROData_SequenceOfObjects aRegions = GetRegions(); - - HYDROData_SequenceOfObjects::Iterator anIter( aRegions ); - for ( ; anIter.More(); anIter.Next() ) - { - Handle(HYDROData_Region) aRegion = - Handle(HYDROData_Region)::DownCast( anIter.Value() ); - if ( aRegion.IsNull() ) - continue; - - HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aRegion ); - - HYDROData_SequenceOfObjects aZones = aRegion->GetZones(); - HYDROData_SequenceOfObjects::Iterator anIter( aZones ); - for ( ; anIter.More(); anIter.Next() ) - { - Handle(HYDROData_Zone) aRegZone = - Handle(HYDROData_Zone)::DownCast( anIter.Value() ); - if ( aRegZone.IsNull() ) - continue; - - HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aRegZone ); - } - } + // Update names of regions and its zones + UpdateRegionsNames( GetRegions(), anOldCaseName, theName ); - HYDROData_SequenceOfObjects aGroups = GetGeometryGroups(); + 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; @@ -104,19 +122,25 @@ void HYDROData_CalculationCase::SetName( const QString& theName ) HYDROData_Entity::SetName( theName ); } -QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const +QStringList HYDROData_CalculationCase::DumpToPython( const QString& thePyScriptPath, + MapOfTreatedObjects& theTreatedObjects ) const { QStringList aResList = dumpObjectCreation( theTreatedObjects ); + aResList.prepend( "# Calculation case" ); QString aCalculName = GetObjPyName(); + AssignmentMode aMode = GetAssignmentMode(); + QString aModeStr = aMode==MANUAL ? "HYDROData_CalculationCase.MANUAL" : "HYDROData_CalculationCase.AUTOMATIC"; + aResList << QString( "%0.SetAssignmentMode( %1 )" ).arg( aCalculName ).arg( aModeStr ); + 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( "" ); @@ -137,49 +161,97 @@ 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 ); } - aResList << QString( "" ); Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline(); - setPythonReferenceObject( theTreatedObjects, aResList, aBoundaryPolyline, "SetBoundaryPolyline" ); - aResList << QString( "" ); + setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aBoundaryPolyline, "SetBoundaryPolyline" ); - aResList << QString( "%1.Update();" ).arg( aCalculName ); - aResList << QString( "" ); + Handle(HYDROData_StricklerTable) aStricklerTable = GetStricklerTable(); + setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aStricklerTable, "SetStricklerTable" ); - // Now we restore the regions and zones order - HYDROData_SequenceOfObjects aRegions = GetRegions(); - anIter.Init( aRegions ); - for ( ; anIter.More(); anIter.Next() ) - { - Handle(HYDROData_Region) aRegion = - Handle(HYDROData_Region)::DownCast( anIter.Value() ); - if ( aRegion.IsNull() ) - continue; + Handle(HYDROData_LandCoverMap) aLandCoverMap = GetLandCoverMap(); + setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aLandCoverMap, "SetLandCoverMap" ); - QString aRegionName = aRegion->GetName(); + if( aMode==AUTOMATIC ) + DumpRulesToPython( aCalculName, aResList ); - HYDROData_SequenceOfObjects aZones = aRegion->GetZones(); - HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones ); - for ( ; aZonesIter.More(); aZonesIter.Next() ) - { - Handle(HYDROData_Zone) aRegZone = - Handle(HYDROData_Zone)::DownCast( aZonesIter.Value() ); - if ( aRegZone.IsNull() ) - continue; + aResList << QString( "" ); + aResList << "# Start the algorithm of the partition and assignment"; + aResList << QString( "%1.Update()" ).arg( aCalculName ); - // TODO - } + if( aMode==MANUAL ) + { + // Now we restore the + // - regions and zones order + DumpRegionsToPython( aResList, thePyScriptPath, theTreatedObjects, GetRegions() ); } + + // Export calculation case aResList << QString( "" ); + aResList << "# Export of the calculation case"; + QString aStudyName = "theStudy"; + QString anEntryVar = aCalculName + "_entry"; + aResList << QString( "%1 = %2.Export( %3._get_StudyId() )" ).arg( anEntryVar ).arg( aCalculName ).arg( aStudyName ); + + // Get geometry object and print debug information + aResList << ""; + aResList << "# Get geometry shape and print debug information"; + aResList << "import GEOM"; + aResList << QString( "print \"Entry:\", %1" ).arg( anEntryVar ); + QString aGeomShapeName = aCalculName + "_geom"; + 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" ); + + aResList << QString( "" ); return aResList; } +void HYDROData_CalculationCase::DumpSampleMeshing( QStringList& theResList, + const QString& theStudyName, + const QString& theGeomShapeName, + const QString& theMeshName ) const +{ + theResList << ""; + theResList << "# Meshing"; + theResList << "import SMESH, SALOMEDS"; + theResList << "from salome.smesh import smeshBuilder"; + theResList << "from salome.geom import geomBuilder"; + + theResList << QString( "smesh = smeshBuilder.New( %1 )" ).arg( theStudyName ); + theResList << QString( "%1 = smesh.Mesh( %2 )" ).arg( theMeshName ).arg( theGeomShapeName ); + theResList << QString( "MEFISTO_2D = %1.Triangle( algo=smeshBuilder.MEFISTO )" ).arg( theMeshName ); + theResList << "Max_Element_Area_1 = MEFISTO_2D.MaxElementArea( 10 )"; + theResList << QString( "Regular_1D = %1.Segment()" ).arg( theMeshName ); + theResList << "Max_Size_1 = Regular_1D.MaxSize(10)"; + theResList << QString( "isDone = %1.Compute()" ).arg( theMeshName ); + + theResList << ""; + theResList << "# Set names of Mesh objects"; + theResList << "smesh.SetName( MEFISTO_2D.GetAlgorithm(), 'MEFISTO_2D' )"; + theResList << "smesh.SetName( Regular_1D.GetAlgorithm(), 'Regular_1D' )"; + theResList << "smesh.SetName( Max_Size_1, 'Max Size_1' )"; + theResList << "smesh.SetName( Max_Element_Area_1, 'Max. Element Area_1' )"; + theResList << QString( "smesh.SetName( %1.GetMesh(), '%1' )" ).arg( theMeshName ); + + theResList << ""; + theResList << "# Greate SMESH groups"; + theResList << QString( "geompy = geomBuilder.New( %1 )" ).arg( theStudyName ); + theResList << QString( "geom_groups = geompy.GetGroups( %1 )" ).arg( theGeomShapeName ); + theResList << QString( "for group in geom_groups:" ); + theResList << QString( " smesh_group = %1.GroupOnGeom(group, group.GetName(), SMESH.EDGE)" ) + .arg( theMeshName ); + theResList << QString( " smesh.SetName(smesh_group, group.GetName())" ); + theResList << QString( " print \"SMESH group '%s': %s\" % (smesh_group.GetName(), smesh_group)" ); +} + HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetAllReferenceObjects() const { HYDROData_SequenceOfObjects aResSeq = HYDROData_Entity::GetAllReferenceObjects(); @@ -188,6 +260,10 @@ HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetAllReferenceObjects() if ( !aBoundaryPolyline.IsNull() ) aResSeq.Append( aBoundaryPolyline ); + HYDROData_SequenceOfObjects aSeqOfGeomObjs = GetGeometryObjects(); + aResSeq.Append( aSeqOfGeomObjs ); + + // Regions HYDROData_SequenceOfObjects aSeqOfRegions = GetRegions(); aResSeq.Append( aSeqOfRegions ); @@ -197,100 +273,199 @@ HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetAllReferenceObjects() void HYDROData_CalculationCase::Update() { HYDROData_Entity::Update(); + SetWarning(); // At first we remove previously created objects RemoveRegions(); - RemoveSplittedGroups(); + RemoveSplitGroups(); Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); if ( aDocument.IsNull() ) return; + // Split to zones + HYDROData_SplitToZonesTool::SplitDataList aZonesList, anEdgesList; + Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline(); + + HYDROData_SequenceOfObjects InterPolys = GetInterPolyObjects(); + HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects(); - if ( aGeomObjects.IsEmpty() ) - return; + if ( !aGeomObjects.IsEmpty() ) { + HYDROData_SequenceOfObjects aGeomGroups = GetGeometryGroups(); + + HYDROData_SplitToZonesTool::SplitDataList aSplitObjects = + HYDROData_SplitToZonesTool::Split( aGeomObjects, aGeomGroups, aBoundaryPolyline, InterPolys ); + if ( !aSplitObjects.isEmpty() ) { + HYDROData_SplitToZonesTool::SplitDataListIterator anIter( aSplitObjects ); + while( anIter.hasNext() ) { + const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); + if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Zone ) + aZonesList.append( aSplitData ); + else if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Edge || + aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_IntEdge) + anEdgesList.append( aSplitData ); + } + } + } - HYDROData_SequenceOfObjects aGeomGroups = GetGeometryGroups(); + switch( GetAssignmentMode() ) + { + case MANUAL: + CreateRegionsDef( aDocument, aZonesList ); + break; + case AUTOMATIC: + CreateRegionsAuto( aDocument, aZonesList ); + break; + } - HYDROData_SplitToZonesTool::SplitDataList aSplitedObjects = - HYDROData_SplitToZonesTool::Split( aGeomObjects, aGeomGroups, aBoundaryPolyline ); - if ( aSplitedObjects.isEmpty() ) - return; + CreateEdgeGroupsDef( aDocument, anEdgesList ); +} +void HYDROData_CalculationCase::CreateRegionsDef( const Handle(HYDROData_Document)& theDoc, + const HYDROData_SplitToZonesTool::SplitDataList& theZones ) +{ + // Create result regions for case, by default one zone for one region QString aRegsPref = CALCULATION_REGIONS_PREF; QString aZonesPref = CALCULATION_ZONES_PREF; - QMap aSplittedEdgesGroupsMap; - - // Create result regions for case, by default one zone for one region - HYDROData_SplitToZonesTool::SplitDataListIterator anIter( aSplitedObjects ); + 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 ); - if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Zone ) - { - // Create new region - Handle(HYDROData_Region) aRegion = addNewRegion(); + // Add the zone for region + Handle(HYDROData_Zone) aRegionZone = aRegion->addNewZone( theDoc, aZonesPref, aSplitData.Face(), aSplitData.ObjectNames ); + } +} - QString aRegionName = HYDROData_Tool::GenerateObjectName( aDocument, aRegsPref ); - aRegion->SetName( aRegionName ); +void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Document)& theDoc, + const HYDROData_SplitToZonesTool::SplitDataList& theZones ) +{ + DEBTRACE("HYDROData_CalculationCase::CreateRegionsAuto"); + QMap aRegionsMap; //object name to region + QMap aRegionNameToObjNameMap; + QString aZonesPref = CALCULATION_ZONES_PREF; + HYDROData_PriorityQueue aPr( this, DataTag_CustomRules ); + + // 1. First we create a default region for each object included into the calculation case + HYDROData_SequenceOfObjects anObjects = GetGeometryObjects(); + for( int i = anObjects.Lower(), n = anObjects.Upper(); i<=n; i++ ) + { + Handle(HYDROData_Entity) anObj = anObjects.Value( i ); + if( anObj.IsNull() ) + continue; + QString anObjName = anObj->GetName(); + QString aRegName = anObjName + "_reg"; + Handle(HYDROData_Region) aRegion = addNewRegion( theDoc, aRegName, false ); + aRegionsMap.insert( anObjName, aRegion ); + aRegionNameToObjNameMap.insert( aRegName, anObjName ); + } - // Add the zone for region - Handle(HYDROData_Zone) aRegionZone = aRegion->addNewZone(); + // 2. Now for each zone it is necessary to determine the most priority object + // and assign to zone to corresponding region + HYDROData_SplitToZonesTool::SplitDataListIterator anIter( theZones ); + while( anIter.hasNext() ) + { + const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); + HYDROData_Zone::MergeType aMergeType; + Handle(HYDROData_Entity) aRegObj = aPr.GetMostPriorityObject( aSplitData.ObjectNames, aMergeType ); + if( aRegObj.IsNull() ) + continue; + Handle(HYDROData_Region) aRegion = aRegionsMap[aRegObj->GetName()]; + if( aRegion.IsNull() ) + continue; + Handle(HYDROData_Zone) aRegionZone = aRegion->addNewZone( theDoc, aZonesPref, aSplitData.Face(), aSplitData.ObjectNames ); - QString aZoneName = HYDROData_Tool::GenerateObjectName( aDocument, aZonesPref ); - aRegionZone->SetName( aZoneName ); + if( aSplitData.ObjectNames.count() > 1 && aMergeType==HYDROData_Zone::Merge_UNKNOWN ) + { + qDebug( "Error in algorithm: unresolved conflicts" ); + } - aRegionZone->SetShape( aSplitData.Face() ); + 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(); + } - // Add the reference object for zone - for ( int i = 0, n = aSplitData.ObjectNames.length(); i < n; ++i ) - { - const QString& anObjName = aSplitData.ObjectNames.at( i ); - - Handle(HYDROData_Object) aRefObject = - Handle(HYDROData_Object)::DownCast( aDocument->FindObjectByName( anObjName ) ); - if ( aRefObject.IsNull() ) - continue; - - aRegionZone->AddGeometryObject( aRefObject ); - } + switch( aMergeType ) + { + case HYDROData_Zone::Merge_ZMIN: + case HYDROData_Zone::Merge_ZMAX: + aRegionZone->SetMergeType( aMergeType ); + break; + case HYDROData_Zone::Merge_Object: + aRegionZone->SetMergeType( aMergeType ); + aRegionZone->RemoveMergeObject(); + aRegionZone->SetMergeObject( aMergeEntity ); + break; } - else if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Edge ) + } + + QStringList anObjectsWithEmptyRegions; + QMap::const_iterator + anIt = aRegionsMap.begin(), aLast = aRegionsMap.end(); + for( ; anIt!=aLast; anIt++ ) + { + Handle(HYDROData_Region) aRegion = anIt.value(); + if( aRegion->GetZones().IsEmpty() ) { - // Create new edges group - if ( aSplitData.ObjectNames.isEmpty() || aSplitData.Shape.IsNull() ) - continue; + QString aRegName = aRegion->GetName(); + QString anObjName = aRegionNameToObjNameMap[aRegName]; + anObjectsWithEmptyRegions.append( anObjName ); + } + } + + if( !anObjectsWithEmptyRegions.empty() ) + { + QString aData = anObjectsWithEmptyRegions.join( ", " ); + SetWarning( WARN_EMPTY_REGIONS, aData ); + } +} - QString anObjName = aSplitData.ObjectNames.first(); - if ( anObjName.isEmpty() ) - continue; +void HYDROData_CalculationCase::CreateEdgeGroupsDef( const Handle(HYDROData_Document)& theDoc, + const HYDROData_SplitToZonesTool::SplitDataList& theEdges ) +{ + QMap aSplitEdgesGroupsMap; + + HYDROData_SplitToZonesTool::SplitDataListIterator anIter( theEdges ); + while( anIter.hasNext() ) + { + const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); + // Create new edges group + if ( aSplitData.ObjectNames.isEmpty() || aSplitData.Shape.IsNull() ) + continue; + + QString anObjName = aSplitData.ObjectNames.first(); + if ( anObjName.isEmpty() ) + continue; #ifdef DEB_CALCULATION - QString aStr = aSplitData.ObjectNames.join(" "); + QString aStr = aSplitData.ObjectNames.join(" "); cout << " CCase: Names = "<GetName().toStdString() << " Zone " << aZone->GetName().toStdString()); + Handle(HYDROData_Region) aRefRegion = Handle(HYDROData_Region)::DownCast( aZone->GetFatherObject() ); + if ( IsEqual( aRefRegion, theRegion ) ) + aResAltitude = GetAltitudeForPoint( thePoint, aZone, theMethod ); + else + { + DEBTRACE("GetAltitudeForPoint Region " << aRefRegion->GetName().toStdString() << " Zone " << aZone->GetName().toStdString() << " ---------------------------"); + aResAltitude = GetAltitudeForPoint( thePoint, aZone, theMethod ); + } + } + else + { + DEBTRACE(" --- GetAltitudeForPoint No Zone ---"); + } + + return aResAltitude; +} + double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint, - const Handle(HYDROData_Zone)& theZone ) const + const Handle(HYDROData_Zone)& theZone, + int theMethod) const { + //DEBTRACE("GetAltitudeForPoint Zone " << theZone->GetName().toStdString()); double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude(); if ( theZone.IsNull() ) + { + DEBTRACE("Zone nulle"); return aResAltitude; + } - HYDROData_Zone::MergeAltitudesType aZoneMergeType = theZone->GetMergeType(); + HYDROData_Zone::MergeType aZoneMergeType = theZone->GetMergeType(); + //DEBTRACE("aZoneMergeType " << aZoneMergeType); if ( !theZone->IsMergingNeed() ) { aZoneMergeType = HYDROData_Zone::Merge_UNKNOWN; + //DEBTRACE("---"); } else if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN ) { + DEBTRACE("GetAltitudeForPoint Zone " << theZone->GetName().toStdString() << " Merge_UNKNOWN"); return aResAltitude; } HYDROData_IInterpolator* aZoneInterpolator = theZone->GetInterpolator(); if ( aZoneMergeType == HYDROData_Zone::Merge_Object ) { - Handle(HYDROData_IAltitudeObject) aMergeAltitude = theZone->GetMergeAltitude(); + Handle(HYDROData_IAltitudeObject) aMergeAltitude = + Handle(HYDROData_IAltitudeObject)::DownCast( theZone->GetMergeObject() ); if ( !aMergeAltitude.IsNull() ) { if ( aZoneInterpolator != NULL ) { + DEBTRACE("aZoneInterpolator != NULL"); aZoneInterpolator->SetAltitudeObject( aMergeAltitude ); aResAltitude = aZoneInterpolator->GetAltitudeForPoint( thePoint ); } else + { + DEBTRACE("aZoneInterpolator == NULL"); aResAltitude = aMergeAltitude->GetAltitudeForPoint( thePoint ); + } } } else { - HYDROData_SequenceOfObjects aZoneObjects = theZone->GetGeometryObjects(); + //DEBTRACE("aZoneMergeType != HYDROData_Zone::Merge_Object"); + HYDROData_SequenceOfObjects aZoneObjects = theZone->GetObjects(); HYDROData_SequenceOfObjects::Iterator anIter( aZoneObjects ); for ( ; anIter.More(); anIter.Next() ) { @@ -573,11 +827,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; @@ -611,7 +869,27 @@ double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& NCollection_Sequence HYDROData_CalculationCase::GetAltitudesForPoints( const NCollection_Sequence& thePoints, - const Handle(HYDROData_Zone)& theZone ) 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, theMethod ); + aResSeq.Append( anAltitude ); + } + + return aResSeq; +} + +NCollection_Sequence HYDROData_CalculationCase::GetAltitudesForPoints( + const NCollection_Sequence& thePoints, + const Handle(HYDROData_Zone)& theZone, + int theMethod) const { NCollection_Sequence aResSeq; @@ -619,13 +897,51 @@ NCollection_Sequence HYDROData_CalculationCase::GetAltitudesForPoints( { const gp_XY& thePnt = thePoints.Value( i ); - double anAltitude = GetAltitudeForPoint( thePnt, theZone ); + double anAltitude = GetAltitudeForPoint( thePnt, theZone, theMethod ); aResSeq.Append( anAltitude ); } return aResSeq; } +double HYDROData_CalculationCase::GetStricklerCoefficientForPoint( const gp_XY& thePoint ) const +{ + Handle( HYDROData_LandCoverMap ) aMap = GetLandCoverMap(); + Handle( HYDROData_StricklerTable ) aTable = GetStricklerTable(); + if( aMap.IsNull() ) + return 0.0; + + QString aType; + aMap->FindByPoint( thePoint, aType ); + double aCoeff = aTable->Get( aType, 0.0 ); + return aCoeff; +} + +std::vector HYDROData_CalculationCase::GetStricklerCoefficientForPoints(const std::vector& thePoints, + double DefValue, bool UseMax ) const +{ + Handle( HYDROData_LandCoverMap ) aLCM = GetLandCoverMap(); + Handle( HYDROData_StricklerTable ) aTable = GetStricklerTable(); + std::vector theCoeffs; + if( aLCM.IsNull() || aTable.IsNull() ) + return theCoeffs; + + aLCM->ClassifyPoints(thePoints, aTable, theCoeffs, DefValue, UseMax ); + + return theCoeffs; +} + +Handle(HYDROData_Region) HYDROData_CalculationCase::GetRegionFromPoint( const gp_XY& thePoint ) const +{ + Handle(HYDROData_Region) aResRegion; + + 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 { Handle(HYDROData_Zone) aResZone; @@ -669,7 +985,16 @@ HYDROData_CalculationCase::PointClassification HYDROData_CalculationCase::GetPoi TopoDS_Face aZoneFace = TopoDS::Face( theZone->GetShape() ); if ( aZoneFace.IsNull() ) return aRes; - +#ifdef DEB_CLASS2D + TopoDS_Compound aCmp; + BRep_Builder aBB; + aBB.MakeCompound(aCmp); + aBB.Add(aCmp, aZoneFace); + gp_Pnt aPnt (thePoint.X(), thePoint.Y(), 0.); + BRepBuilderAPI_MakeVertex aMk(aPnt); + aBB.Add(aCmp, aMk.Vertex()); + BRepTools::Write(aCmp, "FCL2d.brep"); +#endif TopAbs_State State = HYDROData_Tool::ComputePointState(thePoint, aZoneFace); if (State == TopAbs_OUT) aRes = POINT_OUT; @@ -680,38 +1005,66 @@ HYDROData_CalculationCase::PointClassification HYDROData_CalculationCase::GetPoi return aRes; } -Handle(HYDROData_Region) HYDROData_CalculationCase::addNewRegion() +Handle(HYDROData_Region) HYDROData_CalculationCase::addNewRegion( const Handle(HYDROData_Document)& theDoc, + const QString& thePrefixOrName, + bool isPrefix ) { 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 ); + QString aRegionName = isPrefix ? HYDROData_Tool::GenerateObjectName( theDoc, thePrefixOrName ) : thePrefixOrName; + aNewRegion->SetName( aRegionName, true ); + return aNewRegion; } -Handle(HYDROData_SplittedShapesGroup) HYDROData_CalculationCase::addNewSplittedGroup() +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 ); return aNewGroup; } +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; + 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 ) const + SALOMEDS::Study_ptr theStudy, + QString& theGeomObjEntry, + QString& theErrorMsg, + QString& statMess) const { 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 @@ -726,30 +1079,62 @@ 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 - TopTools_ListOfShape aFaces; + bool isAllNotSubmersible = true; HYDROData_SequenceOfObjects aCaseRegions = GetRegions(); HYDROData_SequenceOfObjects::Iterator aRegionIter( aCaseRegions ); + NCollection_IndexedDataMap aShToNames; for ( ; aRegionIter.More(); aRegionIter.Next() ) { Handle(HYDROData_Region) aRegion = Handle(HYDROData_Region)::DownCast( aRegionIter.Value() ); - if( aRegion.IsNull() ) + if( aRegion.IsNull() || !aRegion->IsSubmersible() ) continue; + + 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() ); } - return Export( theGeomEngine, theStudy, aFaces, aSeqOfGroupsDefs ); + bool aRes = false; + + if ( aCaseRegions.IsEmpty() ) { + theErrorMsg = QString("the list of regions is empty."); + } else if ( isAllNotSubmersible ) { + theErrorMsg = QString("there are no submersible regions."); + } else { + aRes = Export( theGeomEngine, theStudy, 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 HYDROData_ShapesGroup::SeqOfGroupsDefs& theGroupsDefs ) const + const NCollection_IndexedDataMap& aShToName, + const HYDROData_ShapesGroup::SeqOfGroupsDefs& theGroupsDefs, + QString& theGeomObjEntry ) const { // Sew faces BRepBuilderAPI_Sewing aSewing( Precision::Confusion() * 10.0 ); @@ -758,34 +1143,32 @@ 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 ); + { + aSewing.Add( anExp.Current() ); + LM.Append(anExp.Current()); } } } // faces iterator @@ -793,6 +1176,24 @@ 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; @@ -803,7 +1204,7 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var // Publish the sewed shape QString aName = EXPORT_NAME; GEOM::GEOM_Object_ptr aMainShape = - publishShapeInGEOM( theGeomEngine, theStudy, aSewedShape, aName ); + HYDROData_GeomTool::ExplodeShapeInGEOMandPublish( theGeomEngine, theStudy, aSewedShape, aFacesToNameModif, aName, theGeomObjEntry ); if ( aMainShape->_is_nil() ) return false; @@ -899,45 +1300,173 @@ bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var return true; } +#endif -GEOM::GEOM_Object_ptr HYDROData_CalculationCase::publishShapeInGEOM( - GEOM::GEOM_Gen_var theGeomEngine, SALOMEDS::Study_ptr theStudy, - const TopoDS_Shape& theShape, const QString& theName ) const +void HYDROData_CalculationCase::ClearRules( HYDROData_CalculationCase::DataTag theDataTag, + const bool theIsSetToUpdate ) { - GEOM::GEOM_Object_var aGeomObj; + TDF_Label aRulesLab = myLab.FindChild( theDataTag ); + HYDROData_PriorityQueue::ClearRules( aRulesLab ); - if ( theGeomEngine->_is_nil() || theStudy->_is_nil() || - theShape.IsNull() ) { - return aGeomObj._retn(); + // Indicate model of the need to update splitting + if ( theIsSetToUpdate ) { + Changed( Geom_2d ); } +} - std::ostringstream aStreamShape; - // Write TopoDS_Shape in ASCII format to the stream - BRepTools::Write( theShape, aStreamShape ); - // Returns the number of bytes that have been stored in the stream's buffer. - int aSize = aStreamShape.str().size(); - // Allocate octect buffer of required size - CORBA::Octet* anOctetBuf = SALOMEDS::TMPFile::allocbuf( aSize ); - // Copy ostrstream content to the octect buffer - memcpy( anOctetBuf, aStreamShape.str().c_str(), aSize ); - // Create TMPFile - SALOMEDS::TMPFile_var aSeqFile = new SALOMEDS::TMPFile( aSize, aSize, anOctetBuf, 1 ); +void HYDROData_CalculationCase::AddRule( const Handle(HYDROData_Entity)& theObject1, + HYDROData_PriorityType thePriority, + const Handle(HYDROData_Entity)& theObject2, + HYDROData_Zone::MergeType theMergeType, + HYDROData_CalculationCase::DataTag theDataTag ) +{ + TDF_Label aRulesLab = myLab.FindChild( theDataTag ); + HYDROData_PriorityQueue::AddRule( aRulesLab, theObject1, thePriority, theObject2, theMergeType ); - // Restore shape from the stream and get the GEOM object - GEOM::GEOM_IInsertOperations_var anInsOp = theGeomEngine->GetIInsertOperations( theStudy->StudyId() ); - aGeomObj = anInsOp->RestoreShape( aSeqFile ); - - // Puplish the GEOM object - if ( !aGeomObj->_is_nil() ) { - QString aName = GEOMBase::GetDefaultName( theName ); - - SALOMEDS::SObject_var aResultSO = - theGeomEngine->PublishInStudy( theStudy, SALOMEDS::SObject::_nil(), - aGeomObj, qPrintable( aName ) ); - if ( aResultSO->_is_nil() ) { - aGeomObj = GEOM::GEOM_Object::_nil(); + // Indicate model of the need to update splitting + Changed( Geom_2d ); +} + +QString HYDROData_CalculationCase::DumpRules() const +{ + TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomRules ); + return HYDROData_PriorityQueue::DumpRules( aRulesLab ); +} + +void HYDROData_CalculationCase::SetAssignmentMode( AssignmentMode theMode ) +{ + TDF_Label aModeLab = myLab.FindChild( DataTag_AssignmentMode ); + TDataStd_Integer::Set( aModeLab, ( int ) theMode ); + + // Indicate model of the need to update splitting + Changed( Geom_2d ); +} + +HYDROData_CalculationCase::AssignmentMode HYDROData_CalculationCase::GetAssignmentMode() const +{ + Handle(TDataStd_Integer) aModeAttr; + bool isOK = myLab.FindChild( DataTag_AssignmentMode ).FindAttribute( TDataStd_Integer::GetID(), aModeAttr ); + if( isOK ) + return ( AssignmentMode ) aModeAttr->Get(); + else + return MANUAL; +} + +void HYDROData_CalculationCase::DumpRulesToPython( const QString& theCalcCaseName, + QStringList& theScript ) const +{ + TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomRules ); + HYDROData_PriorityQueue::DumpRulesToPython( aRulesLab, theCalcCaseName, theScript ); +} + +HYDROData_Warning HYDROData_CalculationCase::GetLastWarning() const +{ + return myLastWarning; +} + +void HYDROData_CalculationCase::SetWarning( HYDROData_WarningType theType, const QString& theData ) +{ + myLastWarning.Type = theType; + myLastWarning.Data = theData; +} + +void HYDROData_CalculationCase::UpdateRegionsNames( const HYDROData_SequenceOfObjects& theRegions, + const QString& theOldCaseName, + const QString& theName ) +{ + HYDROData_SequenceOfObjects::Iterator anIter( theRegions ); + for ( ; anIter.More(); anIter.Next() ) + { + Handle(HYDROData_Region) aRegion = + Handle(HYDROData_Region)::DownCast( anIter.Value() ); + if ( aRegion.IsNull() ) + continue; + + HYDROData_Tool::UpdateChildObjectName( theOldCaseName, theName, aRegion ); + + HYDROData_SequenceOfObjects aZones = aRegion->GetZones(); + HYDROData_SequenceOfObjects::Iterator anIter( aZones ); + for ( ; anIter.More(); anIter.Next() ) + { + Handle(HYDROData_Zone) aRegZone = + Handle(HYDROData_Zone)::DownCast( anIter.Value() ); + if ( aRegZone.IsNull() ) + continue; + + HYDROData_Tool::UpdateChildObjectName( theOldCaseName, theName, aRegZone ); } } +} + +void HYDROData_CalculationCase::DumpRegionsToPython( QStringList& theResList, + const QString& thePyScriptPath, + MapOfTreatedObjects& theTreatedObjects, + const HYDROData_SequenceOfObjects& theRegions ) const +{ + HYDROData_SequenceOfObjects::Iterator anIter; + anIter.Init(theRegions); + for (int ireg = 1; anIter.More(); anIter.Next(), ireg++) + { + Handle(HYDROData_Region) aRegion = Handle(HYDROData_Region)::DownCast(anIter.Value()); + if (aRegion.IsNull()) + continue; + QString defRegName = this->GetName(); + QString regSuffix = QString("_Reg_%1").arg(ireg); + defRegName += regSuffix; + theTreatedObjects.insert(aRegion->GetName(), aRegion); + QStringList aRegDump = aRegion->DumpToPython(thePyScriptPath, theTreatedObjects, defRegName); + theResList << aRegDump; + } + for (anIter.Init(theRegions); anIter.More(); anIter.Next()) + { + Handle(HYDROData_Region) aRegion = Handle(HYDROData_Region)::DownCast(anIter.Value()); + if (aRegion.IsNull()) + continue; + QStringList aRegDump; + aRegion->SetNameInDumpPython(aRegDump); + theResList << aRegDump; + } +} + +bool HYDROData_CalculationCase::GetRule( int theIndex, + Handle(HYDROData_Entity)& theObject1, + HYDROData_PriorityType& thePriority, + Handle(HYDROData_Entity)& theObject2, + HYDROData_Zone::MergeType& theMergeType, + HYDROData_CalculationCase::DataTag& theDataTag) const +{ + TDF_Label aRulesLab = myLab.FindChild( theDataTag ); + 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 ); + +} + + - return aGeomObj._retn(); - }