X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FHYDROData%2FHYDROData_CalculationCase.cxx;h=56f5259ac9eb0f9b9e817026cd5804f27af0b224;hb=fdd7dcde36312e41d8ffb63ec58a77567e8592ef;hp=af132d34c4fc6c8469451f726f33791b7d8d9a69;hpb=1947d881e6cc89c04ad9463ecd57c48a379f38bb;p=modules%2Fhydro.git diff --git a/src/HYDROData/HYDROData_CalculationCase.cxx b/src/HYDROData/HYDROData_CalculationCase.cxx index af132d34..56f5259a 100644 --- a/src/HYDROData/HYDROData_CalculationCase.cxx +++ b/src/HYDROData/HYDROData_CalculationCase.cxx @@ -1,16 +1,70 @@ +// 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" +#include "HYDROData_ShapesGroup.h" #include "HYDROData_Iterator.h" #include "HYDROData_NaturalObject.h" -#include "HYDROData_SplitToZonesTool.h" +#include "HYDROData_PolylineXY.h" +#include "HYDROData_SplittedShapesGroup.h" #include "HYDROData_Region.h" #include "HYDROData_Tool.h" -#include "HYDROData_Zone.h" +#include "HYDROData_GeomTool.h" -#define PYTHON_CALCULATION_ID "KIND_CALCULATION" +#include + +#include + +#include +#include +#include + +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include + +//#define DEB_CALCULATION 1 +#ifdef DEB_CALCULATION +#include +#include +#endif +#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) IMPLEMENT_STANDARD_RTTIEXT(HYDROData_CalculationCase, HYDROData_Entity) @@ -24,22 +78,63 @@ HYDROData_CalculationCase::~HYDROData_CalculationCase() { } +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 ); + } + } + + HYDROData_SequenceOfObjects aGroups = GetSplittedGroups(); + + anIter.Init( aGroups ); + for ( ; anIter.More(); anIter.Next() ) + { + Handle(HYDROData_SplittedShapesGroup) aGroup = + Handle(HYDROData_SplittedShapesGroup)::DownCast( anIter.Value() ); + if ( aGroup.IsNull() ) + continue; + + HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aGroup ); + } + } + + HYDROData_Entity::SetName( theName ); +} + QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const { - QStringList aResList; + QStringList aResList = dumpObjectCreation( theTreatedObjects ); + aResList.prepend( "# Calculation case" ); - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( this ); - if ( aDocument.IsNull() ) - return aResList; - - QString aDocName = aDocument->GetDocPyName(); - QString aCalculName = GetName(); - - aResList << QString( "%1 = %2.CreateObject( %3 );" ) - .arg( aCalculName ).arg( aDocName ).arg( PYTHON_CALCULATION_ID ); - aResList << QString( "%1.SetName( \"%2\" );" ) - .arg( aCalculName ).arg( aCalculName ); - aResList << QString( "" ); + 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 ); @@ -47,97 +142,331 @@ QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTre { Handle(HYDROData_Object) aRefGeomObj = Handle(HYDROData_Object)::DownCast( anIter.Value() ); - if ( !aRefGeomObj.IsNull() ) - setPythonReferenceObject( theTreatedObjects, aResList, aRefGeomObj, "AddGeometryObject" ); + setPythonReferenceObject( theTreatedObjects, aResList, aRefGeomObj, "AddGeometryObject" ); } aResList << QString( "" ); - aResList << QString( "%1.SplitGeometryObjects();" ).arg( aCalculName ); - aResList << QString( "" ); + QString aGroupName = HYDROData_Tool::GenerateNameForPython( theTreatedObjects, "case_geom_group" ); - // Now we restore the regions and zones order - HYDROData_SequenceOfObjects aRegions = GetRegions(); - anIter.Init( aRegions ); + HYDROData_SequenceOfObjects aGeomGroups = GetGeometryGroups(); + anIter.Init( aGeomGroups ); for ( ; anIter.More(); anIter.Next() ) { - Handle(HYDROData_Region) aRegion = - Handle(HYDROData_Region)::DownCast( anIter.Value() ); - if ( aRegion.IsNull() ) + Handle(HYDROData_ShapesGroup) aGeomGroup = + Handle(HYDROData_ShapesGroup)::DownCast( anIter.Value() ); + if ( aGeomGroup.IsNull() ) + continue; + + Handle(HYDROData_Object) aFatherGeom = + Handle(HYDROData_Object)::DownCast( aGeomGroup->GetFatherObject() ); + if ( aFatherGeom.IsNull() ) continue; - QString aRegionName = aRegion->GetName(); - // TODO + int aGroupId = aFatherGeom->GetGroupId( aGeomGroup ); + aResList << QString( "%1 = %2.GetGroup( %3 );" ) + .arg( aGroupName ).arg( aFatherGeom->GetObjPyName() ).arg( aGroupId ); + + aResList << QString( "%1.AddGeometryGroup( %2 );" ).arg( aCalculName ).arg( aGroupName ); + } + + Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline(); + setPythonReferenceObject( theTreatedObjects, aResList, aBoundaryPolyline, "SetBoundaryPolyline" ); + + if( aMode==AUTOMATIC ) + DumpRulesToPython( aCalculName, aResList ); + + aResList << QString( "" ); + aResList << "# Start the algorithm of the partition and assignment"; + aResList << QString( "%1.Update();" ).arg( aCalculName ); + + if( aMode==MANUAL ) + { + // Now we restore the regions and zones order + HYDROData_SequenceOfObjects aRegions = GetRegions(); + anIter.Init( aRegions ); + for ( ; anIter.More(); anIter.Next() ) + { + Handle(HYDROData_Region) aRegion = + Handle(HYDROData_Region)::DownCast( anIter.Value() ); + if ( aRegion.IsNull() ) + continue; + + theTreatedObjects.insert( aRegion->GetName(), aRegion ); + QStringList aRegDump = aRegion->DumpToPython( theTreatedObjects ); + aResList << aRegDump; + } } + // 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( "%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 ); + + DumpSampleMeshing( aResList, aStudyName, aGeomShapeName, aCalculName+"_mesh" ); + + aResList << QString( "" ); return aResList; } -void HYDROData_CalculationCase::SplitGeometryObjects() +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(); + + Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline(); + if ( !aBoundaryPolyline.IsNull() ) + aResSeq.Append( aBoundaryPolyline ); + + HYDROData_SequenceOfObjects aSeqOfRegions = GetRegions(); + aResSeq.Append( aSeqOfRegions ); + + return aResSeq; +} + +void HYDROData_CalculationCase::Update() { - // At first we remove previously created regions + HYDROData_Entity::Update(); + SetWarning(); + + // At first we remove previously created objects RemoveRegions(); + RemoveSplittedGroups(); - Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( this ); + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); if ( aDocument.IsNull() ) return; + Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline(); HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects(); if ( aGeomObjects.IsEmpty() ) return; - HYDROData_SplitToZonesTool::SplitDataList aSplitedZones = - HYDROData_SplitToZonesTool::SplitToZones( aGeomObjects ); - if ( aSplitedZones.isEmpty() ) + HYDROData_SequenceOfObjects aGeomGroups = GetGeometryGroups(); + + HYDROData_SplitToZonesTool::SplitDataList aSplitObjects = + HYDROData_SplitToZonesTool::Split( aGeomObjects, aGeomGroups, aBoundaryPolyline ); + if ( aSplitObjects.isEmpty() ) return; - // Create result regions for case, by default one zone for one region - HYDROData_SplitToZonesTool::SplitDataListIterator anIter( aSplitedZones ); + HYDROData_SplitToZonesTool::SplitDataList aZonesList, anEdgesList; + + HYDROData_SplitToZonesTool::SplitDataListIterator anIter( aSplitObjects ); while( anIter.hasNext() ) { const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next(); + if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Zone ) + aZonesList.append( aSplitData ); + else if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Edge ) + anEdgesList.append( aSplitData ); + } - // Create new region - Handle(HYDROData_Region) aRegion = addNewRegion(); + switch( GetAssignmentMode() ) + { + case MANUAL: + CreateRegionsDef( aDocument, aZonesList ); + break; + case AUTOMATIC: + CreateRegionsAuto( aDocument, aZonesList ); + break; + } + CreateEdgeGroupsDef( aDocument, anEdgesList ); +} - QString aRegionName = HYDROData_Tool::GenerateObjectName( aDocument, "Region" ); - aRegion->SetName( aRegionName ); +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; + + 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 ); // Add the zone for region - Handle(HYDROData_Zone) aRegionZone = aRegion->addNewZone(); + Handle(HYDROData_Zone) aRegionZone = aRegion->addNewZone( theDoc, aZonesPref, aSplitData.Face(), aSplitData.ObjectNames ); + } +} - QString aZoneName = HYDROData_Tool::GenerateObjectName( aDocument, "Zone" ); - aRegionZone->SetName( aZoneName ); +void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Document)& theDoc, + const HYDROData_SplitToZonesTool::SplitDataList& theZones ) +{ + QMap aRegionsMap; //object name to region + QMap aRegionNameToObjNameMap; + QString aZonesPref = CALCULATION_ZONES_PREF; + HYDROData_PriorityQueue aPr( this ); + + // 1. First we create a default region for each object included into the calculation case + HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects(); + for( int i=aGeomObjects.Lower(), n=aGeomObjects.Upper(); i<=n; i++ ) + { + Handle(HYDROData_Object) anObj = Handle(HYDROData_Object)::DownCast( aGeomObjects.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 ); + } - aRegionZone->SetShape( aSplitData.Face() ); + // 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::MergeAltitudesType aMergeType; + Handle(HYDROData_Object) 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 ); - // Add the reference object for zone - for ( int i = 0, n = aSplitData.ObjectNames.length(); i < n; ++i ) + if( aSplitData.ObjectNames.count() > 1 && aMergeType==HYDROData_Zone::Merge_UNKNOWN ) { - const QString& anObjName = aSplitData.ObjectNames.at( i ); - - Handle(HYDROData_Object) aRefObject = Handle(HYDROData_Object)::DownCast( - HYDROData_Tool::FindObjectByName( aDocument, anObjName ) ); - if ( aRefObject.IsNull() ) - continue; + qDebug( "Error in algorithm: unresolved conflicts" ); + } + + 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->RemoveMergeAltitude(); + aRegionZone->SetMergeAltitude( aRegObj->GetAltitudeObject() ); + break; + } + } + + 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() ) + { + QString aRegName = aRegion->GetName(); + QString anObjName = aRegionNameToObjNameMap[aRegName]; + anObjectsWithEmptyRegions.append( anObjName ); + } + } + + if( !anObjectsWithEmptyRegions.empty() ) + { + QString aData = anObjectsWithEmptyRegions.join( ", " ); + SetWarning( WARN_EMPTY_REGIONS, aData ); + } +} + +void HYDROData_CalculationCase::CreateEdgeGroupsDef( const Handle(HYDROData_Document)& theDoc, + const HYDROData_SplitToZonesTool::SplitDataList& theEdges ) +{ + QMap aSplittedEdgesGroupsMap; + + 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; - aRegionZone->AddGeometryObject( aRefObject ); + QString anObjName = aSplitData.ObjectNames.first(); + if ( anObjName.isEmpty() ) + continue; +#ifdef DEB_CALCULATION + QString aStr = aSplitData.ObjectNames.join(" "); + cout << " CCase: Names = "<SetName( aNewRegionName ); - } - aNewRegion->AddZone( theZone ); return aNewRegion; @@ -180,6 +574,8 @@ Handle(HYDROData_Region) HYDROData_CalculationCase::AddNewRegion( const Handle(H bool HYDROData_CalculationCase::AddRegion( const Handle(HYDROData_Region)& theRegion ) { + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); + if ( theRegion.IsNull() ) return false; @@ -191,15 +587,18 @@ bool HYDROData_CalculationCase::AddRegion( const Handle(HYDROData_Region)& theRe Handle(HYDROData_CalculationCase)::DownCast( theRegion->GetFatherObject() ); if ( !aFatherCalc.IsNull() && aFatherCalc->Label() != myLab ) { - Handle(HYDROData_Region) aNewRegion = addNewRegion(); + Handle(HYDROData_Region) aNewRegion = addNewRegion( aDocument, CALCULATION_REGIONS_PREF ); theRegion->CopyTo( aNewRegion ); aFatherCalc->RemoveRegion( theRegion ); theRegion->SetLabel( aNewRegion->Label() ); } + else + { + AddReferenceObject( theRegion, DataTag_Region ); + } - AddReferenceObject( theRegion, DataTag_Region ); return true; } @@ -208,6 +607,40 @@ HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetRegions() const return GetReferenceObjects( DataTag_Region ); } +void HYDROData_CalculationCase::UpdateRegionsOrder() +{ + Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab ); + if ( aDocument.IsNull() ) + return; + + 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; + + aRegion->SetName( "" ); + } + + 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 ); + } +} + void HYDROData_CalculationCase::RemoveRegion( const Handle(HYDROData_Region)& theRegion ) { if ( theRegion.IsNull() ) @@ -224,18 +657,548 @@ void HYDROData_CalculationCase::RemoveRegion( const Handle(HYDROData_Region)& th void HYDROData_CalculationCase::RemoveRegions() { - ClearReferenceObjects( DataTag_Region ); - myLab.FindChild( DataTag_ChildRegion ).ForgetAllAttributes( true ); + myLab.FindChild( DataTag_ChildRegion ).ForgetAllAttributes(); +} + +HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetSplittedGroups() const +{ + return GetReferenceObjects( DataTag_SplittedGroups ); +} + +void HYDROData_CalculationCase::RemoveSplittedGroups() +{ + myLab.FindChild( DataTag_SplittedGroups ).ForgetAllAttributes(); +} + +double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint ) const +{ + Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint ); + return GetAltitudeForPoint( thePoint, aZone ); +} + +double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint, + const Handle(HYDROData_Region)& theRegion ) const +{ + double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude(); + + Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint ); + if ( !aZone.IsNull() ) + { + Handle(HYDROData_Region) aRefRegion = Handle(HYDROData_Region)::DownCast( aZone->GetFatherObject() ); + if ( IsEqual( aRefRegion, theRegion ) ) + aResAltitude = GetAltitudeForPoint( thePoint, aZone ); + } + + return aResAltitude; +} + +double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint, + const Handle(HYDROData_Zone)& theZone ) const +{ + double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude(); + if ( theZone.IsNull() ) + return aResAltitude; + + HYDROData_Zone::MergeAltitudesType aZoneMergeType = theZone->GetMergeType(); + if ( !theZone->IsMergingNeed() ) + { + aZoneMergeType = HYDROData_Zone::Merge_UNKNOWN; + } + else if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN ) + { + return aResAltitude; + } + + HYDROData_IInterpolator* aZoneInterpolator = theZone->GetInterpolator(); + if ( aZoneMergeType == HYDROData_Zone::Merge_Object ) + { + Handle(HYDROData_IAltitudeObject) aMergeAltitude = theZone->GetMergeAltitude(); + if ( !aMergeAltitude.IsNull() ) + { + if ( aZoneInterpolator != NULL ) + { + aZoneInterpolator->SetAltitudeObject( aMergeAltitude ); + aResAltitude = aZoneInterpolator->GetAltitudeForPoint( thePoint ); + } + else + aResAltitude = aMergeAltitude->GetAltitudeForPoint( thePoint ); + } + } + else + { + HYDROData_SequenceOfObjects aZoneObjects = theZone->GetGeometryObjects(); + HYDROData_SequenceOfObjects::Iterator anIter( aZoneObjects ); + for ( ; anIter.More(); anIter.Next() ) + { + Handle(HYDROData_Object) aZoneObj = + Handle(HYDROData_Object)::DownCast( anIter.Value() ); + if ( aZoneObj.IsNull() ) + continue; + + Handle(HYDROData_IAltitudeObject) anObjAltitude = aZoneObj->GetAltitudeObject(); + if ( anObjAltitude.IsNull() ) + continue; + + double aPointAltitude = 0.0; + if ( aZoneInterpolator != NULL ) + { + aZoneInterpolator->SetAltitudeObject( anObjAltitude ); + aPointAltitude = aZoneInterpolator->GetAltitudeForPoint( thePoint ); + } + else + aPointAltitude = anObjAltitude->GetAltitudeForPoint( thePoint ); + + if ( ValuesEquals( aPointAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) ) + continue; + + if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN ) + { + aResAltitude = aPointAltitude; + break; + } + else if ( aZoneMergeType == HYDROData_Zone::Merge_ZMIN ) + { + if ( ValuesEquals( aResAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) || + aResAltitude > aPointAltitude ) + { + aResAltitude = aPointAltitude; + } + } + else if ( aZoneMergeType == HYDROData_Zone::Merge_ZMAX ) + { + if ( ValuesEquals( aResAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) || + aResAltitude < aPointAltitude ) + { + aResAltitude = aPointAltitude; + } + } + } + } + + return aResAltitude; +} + +NCollection_Sequence HYDROData_CalculationCase::GetAltitudesForPoints( + const NCollection_Sequence& thePoints, + const Handle(HYDROData_Region)& theRegion ) const +{ + 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 ); + aResSeq.Append( anAltitude ); + } + + return aResSeq; +} + +NCollection_Sequence HYDROData_CalculationCase::GetAltitudesForPoints( + const NCollection_Sequence& thePoints, + const Handle(HYDROData_Zone)& theZone ) const +{ + NCollection_Sequence aResSeq; + + for ( int i = 1, n = thePoints.Length(); i <= n; ++i ) + { + const gp_XY& thePnt = thePoints.Value( i ); + + double anAltitude = GetAltitudeForPoint( thePnt, theZone ); + aResSeq.Append( anAltitude ); + } + + return aResSeq; +} + +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; + + HYDROData_SequenceOfObjects aRegions = GetRegions(); + + HYDROData_SequenceOfObjects::Iterator anIter( aRegions ); + for ( ; anIter.More() && aResZone.IsNull(); anIter.Next() ) + { + Handle(HYDROData_Region) aRegion = + Handle(HYDROData_Region)::DownCast( anIter.Value() ); + if ( aRegion.IsNull() ) + continue; + + HYDROData_SequenceOfObjects aZones = aRegion->GetZones(); + HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones ); + for ( ; aZonesIter.More() && aResZone.IsNull(); aZonesIter.Next() ) + { + Handle(HYDROData_Zone) aRegZone = + Handle(HYDROData_Zone)::DownCast( aZonesIter.Value() ); + if ( aRegZone.IsNull() ) + continue; + + PointClassification aPointRelation = GetPointClassification( thePoint, aRegZone ); + if ( aPointRelation != POINT_OUT ) + aResZone = aRegZone; // We found the desired zone + } + } + + return aResZone; +} + +HYDROData_CalculationCase::PointClassification HYDROData_CalculationCase::GetPointClassification( + const gp_XY& thePoint, + const Handle(HYDROData_Zone)& theZone ) const +{ + PointClassification aRes = POINT_OUT; + if ( theZone.IsNull() ) + return aRes; + + 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; + else if(State == TopAbs_IN) + aRes = POINT_IN; + else if(State == TopAbs_ON) + aRes = POINT_ON; + 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 ); + return aNewRegion; } +Handle(HYDROData_SplittedShapesGroup) HYDROData_CalculationCase::addNewSplittedGroup( const QString& theName ) +{ + TDF_Label aNewLab = myLab.FindChild( DataTag_SplittedGroups ).NewChild(); + + Handle(HYDROData_SplittedShapesGroup) aNewGroup = + Handle(HYDROData_SplittedShapesGroup)::DownCast( + HYDROData_Iterator::CreateObject( aNewLab, KIND_SPLITTED_GROUP ) ); + AddReferenceObject( aNewGroup, DataTag_SplittedGroups ); + + aNewGroup->SetName( theName ); + + return aNewGroup; +} + +QString HYDROData_CalculationCase::Export( int theStudyId ) const +{ + GEOM::GEOM_Gen_var aGEOMEngine = HYDROData_GeomTool::GetGeomGen(); + SALOMEDS::Study_var aDSStudy = HYDROData_GeomTool::GetStudyByID( theStudyId ); + + QString aGeomObjEntry; + bool isOK = Export( aGEOMEngine, aDSStudy, aGeomObjEntry ); + return isOK ? aGeomObjEntry : QString(); +} + +bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, + SALOMEDS::Study_ptr theStudy, + QString& theGeomObjEntry ) const +{ + HYDROData_ShapesGroup::SeqOfGroupsDefs aSeqOfGroupsDefs; + + // Get groups definitions + HYDROData_SequenceOfObjects aSplittedGroups = GetSplittedGroups(); + + HYDROData_SequenceOfObjects::Iterator anIter( aSplittedGroups ); + for ( ; anIter.More(); anIter.Next() ) + { + // Get shapes group + Handle(HYDROData_ShapesGroup) aGroup = + Handle(HYDROData_ShapesGroup)::DownCast( anIter.Value() ); + if ( aGroup.IsNull() ) + continue; + + HYDROData_ShapesGroup::GroupDefinition aGroupDef; + + aGroupDef.Name = aGroup->GetName().toLatin1().constData(); + aGroup->GetShapes( aGroupDef.Shapes ); + + aSeqOfGroupsDefs.Append( aGroupDef ); + } + + // Get faces + TopTools_ListOfShape aFaces; + HYDROData_SequenceOfObjects aCaseRegions = GetRegions(); + HYDROData_SequenceOfObjects::Iterator aRegionIter( aCaseRegions ); + for ( ; aRegionIter.More(); aRegionIter.Next() ) + { + Handle(HYDROData_Region) aRegion = + Handle(HYDROData_Region)::DownCast( aRegionIter.Value() ); + if( aRegion.IsNull() || !aRegion->IsSubmersible() ) + continue; + + TopoDS_Shape aRegionShape = aRegion->GetShape( &aSeqOfGroupsDefs ); + aFaces.Append( aRegionShape ); + } + + return Export( theGeomEngine, theStudy, aFaces, aSeqOfGroupsDefs, theGeomObjEntry ); +} + +bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var theGeomEngine, + SALOMEDS::Study_ptr theStudy, + const TopTools_ListOfShape& theFaces, + const HYDROData_ShapesGroup::SeqOfGroupsDefs& theGroupsDefs, + QString& theGeomObjEntry ) const +{ + // Sew faces + BRepBuilderAPI_Sewing aSewing( Precision::Confusion() * 10.0 ); + aSewing.SetNonManifoldMode( Standard_False ); +#ifdef DEB_CALCULATION + TCollection_AsciiString aNam("Sh_"); + int i=1; +#endif + TopTools_ListIteratorOfListOfShape aFaceIter( theFaces ); + for ( ; aFaceIter.More(); aFaceIter.Next() ) + { + TopoDS_Shape aShape = aFaceIter.Value(); + if ( aShape.IsNull() ) + continue; + + if ( aShape.ShapeType() == TopAbs_FACE ) + { + aSewing.Add( aShape ); +#ifdef DEB_CALCULATION + TCollection_AsciiString aName = aNam + ++i + ".brep"; + BRepTools::Write(aShape ,aName.ToCString()); +#endif + } + else + { +#ifdef DEB_CALCULATION + int j = 1; +#endif + TopExp_Explorer anExp( aShape, TopAbs_FACE ); + 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 + } + } + } // faces iterator + + aSewing.Perform(); + TopoDS_Shape aSewedShape = aSewing.SewedShape(); + + // 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 + QString aName = EXPORT_NAME; + GEOM::GEOM_Object_ptr aMainShape = + HYDROData_GeomTool::publishShapeInGEOM( theGeomEngine, theStudy, aSewedShape, aName, theGeomObjEntry ); + + if ( aMainShape->_is_nil() ) + return false; + + if ( theGroupsDefs.IsEmpty() ) + return true; + + // Create groups + TopTools_IndexedMapOfShape aMapOfSubShapes; + TopExp::MapShapes( aSewedShape, aMapOfSubShapes ); + + NCollection_DataMap< TCollection_AsciiString, NCollection_Sequence > aGroupsData; + + for ( int aGrId = 1, nbGroups = theGroupsDefs.Length(); aGrId <= nbGroups; ++aGrId ) + { + const HYDROData_ShapesGroup::GroupDefinition& aGroupDef = theGroupsDefs.Value( aGrId ); + + NCollection_Sequence aGroupIndexes; + for( int i = 1, n = aGroupDef.Shapes.Length(); i <= n; i++ ) + { + const TopoDS_Shape& aShape = aGroupDef.Shapes.Value( i ); +#ifdef DEB_CALCULATION + cout << "\nOld shape(" << i << ") = " << aShape.TShape() <GetIGroupOperations( theStudy->StudyId() ); + + NCollection_DataMap< TCollection_AsciiString, NCollection_Sequence >::Iterator aMapIt( aGroupsData ); + for ( ; aMapIt.More(); aMapIt.Next() ) + { + const TCollection_AsciiString& aGroupName = aMapIt.Key(); + const NCollection_Sequence& aGroupIndexes = aMapIt.Value(); + + GEOM::GEOM_Object_var aGeomGroup = aGroupOp->CreateGroup( aMainShape, TopAbs_EDGE ); + if ( CORBA::is_nil( aGeomGroup ) || !aGroupOp->IsDone() ) + continue; + + GEOM::ListOfLong_var aGeomIndexes = new GEOM::ListOfLong; + aGeomIndexes->length( aGroupIndexes.Length() ); + + for( int i = 1, n = aGroupIndexes.Length(); i <= n; i++ ) + aGeomIndexes[ i - 1 ] = aGroupIndexes.Value( i ); + + aGroupOp->UnionIDs( aGeomGroup, aGeomIndexes ); + if ( aGroupOp->IsDone() ) + { + SALOMEDS::SObject_var aGroupSO = + theGeomEngine->AddInStudy( theStudy, aGeomGroup, aGroupName.ToCString(), aMainShape ); + } + } + } + + return true; +} + +void HYDROData_CalculationCase::ClearRules( const bool theIsSetToUpdate ) +{ + TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomRules ); + HYDROData_PriorityQueue::ClearRules( aRulesLab ); + + // Indicate model of the need to update splitting + if ( theIsSetToUpdate ) { + SetToUpdate( true ); + } +} + +void HYDROData_CalculationCase::AddRule( const Handle(HYDROData_Object)& theObject1, + HYDROData_PriorityType thePriority, + const Handle(HYDROData_Object)& theObject2, + HYDROData_Zone::MergeAltitudesType theMergeType ) +{ + TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomRules ); + HYDROData_PriorityQueue::AddRule( aRulesLab, theObject1, thePriority, theObject2, theMergeType ); + + // Indicate model of the need to update splitting + SetToUpdate( true ); +} + +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 + SetToUpdate( true ); +} + +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; +} + +bool HYDROData_CalculationCase::GetRule( int theIndex, + Handle(HYDROData_Object)& theObject1, + HYDROData_PriorityType& thePriority, + Handle(HYDROData_Object)& theObject2, + HYDROData_Zone::MergeAltitudesType& theMergeType ) const +{ + TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomRules ); + return HYDROData_PriorityQueue::GetRule( aRulesLab, theIndex, + theObject1, thePriority, theObject2, theMergeType ); +}