src/HYDROData/HYDROData_CalculationCase.cxx

   1
   2 #include "HYDROData_CalculationCase.h"
   3
   4 #include "HYDROData_ArtificialObject.h"
   5 #include "HYDROData_IAltitudeObject.h"
   6 #include "HYDROData_Document.h"
   7 #include "HYDROData_ShapesGroup.h"
   8 #include "HYDROData_Iterator.h"
   9 #include "HYDROData_NaturalObject.h"
  10 #include "HYDROData_PolylineXY.h"
  11 #include "HYDROData_SplittedShapesGroup.h"
  12 #include "HYDROData_Region.h"
  13 #include "HYDROData_Tool.h"
  14
  15 #include <GEOMBase.h>
  16
  17 #include <QSet>
  18
  19 #include <TopoDS.hxx>
  20 #include <TopoDS_Shell.hxx>
  21 #include <TopoDS_Edge.hxx>
  22
  23 #include <BRep_Builder.hxx>
  24 #include <BRepBuilderAPI_Sewing.hxx>
  25 #include <BRepTopAdaptor_FClass2d.hxx>
  26
  27 #include <BRepTools.hxx>
  28
  29 #include <TopAbs.hxx>
  30 #include <TopExp_Explorer.hxx>
  31 #include <TopExp.hxx>
  32 #include <TopTools_ListOfShape.hxx>
  33 #include <TopTools_ListIteratorOfListOfShape.hxx>
  34 #include <TDataStd_Integer.hxx>
  35
  36 //#define  DEB_CALCULATION 1
  37 #ifdef DEB_CALCULATION
  38 #include <BRepTools.hxx>
  39 #include <TopLoc_Location.hxx>
  40 #endif
  41 #define CALCULATION_REGIONS_PREF GetName() + "_Reg"
  42 #define CALCULATION_ZONES_PREF GetName() + "_Zone"
  43 #define CALCULATION_GROUPS_PREF GetName() + "_"
  44 //#define DEB_CLASS2D 1
  45 #ifdef DEB_CLASS2D
  46 #include <BRepBuilderAPI_MakeVertex.hxx>
  47 #endif
  48
  49 #define EXPORT_NAME "HYDRO_" + GetName()
  50
  51 #include <SALOME_NamingService.hxx>
  52 #include <SALOME_LifeCycleCORBA.hxx>
  53
  54
  55
  56
  57
  58 IMPLEMENT_STANDARD_HANDLE(HYDROData_CalculationCase, HYDROData_Entity)
  59 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_CalculationCase, HYDROData_Entity)
  60
  61 HYDROData_CalculationCase::HYDROData_CalculationCase()
  62 : HYDROData_Entity()
  63 {
  64 }
  65
  66 HYDROData_CalculationCase::~HYDROData_CalculationCase()
  67 {
  68 }
  69
  70 void HYDROData_CalculationCase::SetName( const QString& theName )
  71 {
  72   QString anOldCaseName = GetName();
  73   if ( anOldCaseName != theName )
  74   {
  75     HYDROData_SequenceOfObjects aRegions = GetRegions();
  76
  77     HYDROData_SequenceOfObjects::Iterator anIter( aRegions );
  78     for ( ; anIter.More(); anIter.Next() )
  79     {
  80       Handle(HYDROData_Region) aRegion =
  81         Handle(HYDROData_Region)::DownCast( anIter.Value() );
  82       if ( aRegion.IsNull() )
  83         continue;
  84
  85       HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aRegion );
  86
  87       HYDROData_SequenceOfObjects aZones = aRegion->GetZones();
  88       HYDROData_SequenceOfObjects::Iterator anIter( aZones );
  89       for ( ; anIter.More(); anIter.Next() )
  90       {
  91         Handle(HYDROData_Zone) aRegZone =
  92           Handle(HYDROData_Zone)::DownCast( anIter.Value() );
  93         if ( aRegZone.IsNull() )
  94           continue;
  95
  96         HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aRegZone );
  97       }
  98     }
  99
 100     HYDROData_SequenceOfObjects aGroups = GetSplittedGroups();
 101
 102     anIter.Init( aGroups );
 103     for ( ; anIter.More(); anIter.Next() )
 104     {
 105       Handle(HYDROData_SplittedShapesGroup) aGroup =
 106         Handle(HYDROData_SplittedShapesGroup)::DownCast( anIter.Value() );
 107       if ( aGroup.IsNull() )
 108         continue;
 109
 110       HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aGroup );
 111     }
 112   }
 113
 114   HYDROData_Entity::SetName( theName );
 115 }
 116
 117 QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
 118 {
 119   QStringList aResList = dumpObjectCreation( theTreatedObjects );
 120   aResList.prepend( "# Calculation case" );
 121
 122   QString aCalculName = GetObjPyName();
 123
 124   AssignmentMode aMode = GetAssignmentMode();
 125   QString aModeStr = aMode==MANUAL ? "HYDROData_CalculationCase.MANUAL" : "HYDROData_CalculationCase.AUTOMATIC";
 126   aResList << QString( "%0.SetAssignmentMode( %1 )" ).arg( aCalculName ).arg( aModeStr );
 127
 128   HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects();
 129   HYDROData_SequenceOfObjects::Iterator anIter( aGeomObjects );
 130   for ( ; anIter.More(); anIter.Next() )
 131   {
 132     Handle(HYDROData_Object) aRefGeomObj =
 133       Handle(HYDROData_Object)::DownCast( anIter.Value() );
 134     setPythonReferenceObject( theTreatedObjects, aResList, aRefGeomObj, "AddGeometryObject" );
 135   }
 136   aResList << QString( "" );
 137
 138   QString aGroupName = HYDROData_Tool::GenerateNameForPython( theTreatedObjects, "case_geom_group" );
 139
 140   HYDROData_SequenceOfObjects aGeomGroups = GetGeometryGroups();
 141   anIter.Init( aGeomGroups );
 142   for ( ; anIter.More(); anIter.Next() )
 143   {
 144     Handle(HYDROData_ShapesGroup) aGeomGroup =
 145       Handle(HYDROData_ShapesGroup)::DownCast( anIter.Value() );
 146     if ( aGeomGroup.IsNull() )
 147       continue;
 148
 149     Handle(HYDROData_Object) aFatherGeom =
 150       Handle(HYDROData_Object)::DownCast( aGeomGroup->GetFatherObject() );
 151     if ( aFatherGeom.IsNull() )
 152       continue;
 153
 154     int aGroupId = aFatherGeom->GetGroupId( aGeomGroup );
 155     aResList << QString( "%1 = %2.GetGroup( %3 );" )
 156               .arg( aGroupName ).arg( aFatherGeom->GetObjPyName() ).arg( aGroupId );
 157
 158     aResList << QString( "%1.AddGeometryGroup( %2 );" ).arg( aCalculName ).arg( aGroupName );
 159   }
 160
 161   Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline();
 162   setPythonReferenceObject( theTreatedObjects, aResList, aBoundaryPolyline, "SetBoundaryPolyline" );
 163
 164   if( aMode==AUTOMATIC )
 165     DumpRulesToPython( aCalculName, aResList );
 166
 167   aResList << QString( "" );
 168   aResList << "# Start the algorithm of the partition and assignment";
 169   aResList << QString( "%1.Update();" ).arg( aCalculName );
 170
 171   if( aMode==MANUAL )
 172   {
 173     // Now we restore the regions and zones order
 174     HYDROData_SequenceOfObjects aRegions = GetRegions();
 175     anIter.Init( aRegions );
 176     for ( ; anIter.More(); anIter.Next() )
 177     {
 178       Handle(HYDROData_Region) aRegion =
 179         Handle(HYDROData_Region)::DownCast( anIter.Value() );
 180       if ( aRegion.IsNull() )
 181         continue;
 182
 183       QString aRegionName = aRegion->GetName();
 184
 185       HYDROData_SequenceOfObjects aZones = aRegion->GetZones();
 186       HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones );
 187       for ( ; aZonesIter.More(); aZonesIter.Next() )
 188       {
 189         Handle(HYDROData_Zone) aRegZone =
 190           Handle(HYDROData_Zone)::DownCast( aZonesIter.Value() );
 191         if ( aRegZone.IsNull() )
 192           continue;
 193
 194         // TODO
 195       }
 196     }
 197   }
 198
 199   // Export calculation case
 200   aResList << QString( "" );
 201   aResList << "# Export of the calculation case";
 202   QString aStudyName = "theStudy";
 203   QString anEntryVar = aCalculName + "_entry";
 204   aResList << QString( "%1 = %2.Export( %3._get_StudyId() )" ).arg( anEntryVar ).arg( aCalculName ).arg( aStudyName );
 205
 206   // Get geometry object and print debug information
 207   aResList << "";
 208   aResList << "# Get geometry shape and print debug information";
 209   aResList << "import GEOM";
 210   aResList << QString( "print \"Entry:\", %1" ).arg( anEntryVar );
 211   QString aGeomShapeName = aCalculName + "_geom";
 212   aResList << QString( "%1 = salome.IDToObject( str( %2 ) )" ).arg( aGeomShapeName ).arg( anEntryVar );
 213   aResList << QString( "print \"Geom shape:\", %1" ).arg( aGeomShapeName );
 214   aResList << QString( "print \"Geom shape name:\", %1.GetName()" ).arg( aGeomShapeName );
 215
 216   DumpSampleMeshing( aResList, aStudyName, aGeomShapeName, aCalculName+"_mesh" );
 217
 218   aResList << QString( "" );
 219   return aResList;
 220 }
 221
 222 void HYDROData_CalculationCase::DumpSampleMeshing( QStringList& theResList,
 223                                                    const QString& theStudyName,
 224                                                    const QString& theGeomShapeName,
 225                                                    const QString& theMeshName ) const
 226 {
 227   theResList << "";
 228   theResList << "# Meshing";
 229   theResList << "import SMESH, SALOMEDS";
 230   theResList << "from salome.smesh import smeshBuilder";
 231
 232   theResList << QString( "smesh = smeshBuilder.New( %1 )" ).arg( theStudyName );
 233   theResList << QString( "%1 = smesh.Mesh( %2 )" ).arg( theMeshName ).arg( theGeomShapeName );
 234   theResList << QString( "MEFISTO_2D = %1.Triangle( algo=smeshBuilder.MEFISTO )" ).arg( theMeshName );
 235   theResList << "Max_Element_Area_1 = MEFISTO_2D.MaxElementArea( 10 )";
 236   theResList << QString( "Regular_1D = %1.Segment()" ).arg( theMeshName );
 237   theResList << "Max_Size_1 = Regular_1D.MaxSize(10)";
 238   theResList << QString( "isDone = %1.Compute()" ).arg( theMeshName );
 239
 240   theResList << "";
 241   theResList << "# Set names of Mesh objects";
 242   theResList << "smesh.SetName( MEFISTO_2D.GetAlgorithm(), 'MEFISTO_2D' )";
 243   theResList << "smesh.SetName( Regular_1D.GetAlgorithm(), 'Regular_1D' )";
 244   theResList << "smesh.SetName( Max_Size_1, 'Max Size_1' )";
 245   theResList << "smesh.SetName( Max_Element_Area_1, 'Max. Element Area_1' )";
 246   theResList << QString( "smesh.SetName( %1.GetMesh(), '%1' )" ).arg( theMeshName );
 247 }
 248
 249 HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetAllReferenceObjects() const
 250 {
 251   HYDROData_SequenceOfObjects aResSeq = HYDROData_Entity::GetAllReferenceObjects();
 252
 253   Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline();
 254   if ( !aBoundaryPolyline.IsNull() )
 255     aResSeq.Append( aBoundaryPolyline );
 256
 257   HYDROData_SequenceOfObjects aSeqOfRegions = GetRegions();
 258   aResSeq.Append( aSeqOfRegions );
 259
 260   return aResSeq;
 261 }
 262
 263 void HYDROData_CalculationCase::Update()
 264 {
 265   HYDROData_Entity::Update();
 266   SetWarning();
 267
 268   // At first we remove previously created objects
 269   RemoveRegions();
 270   RemoveSplittedGroups();
 271
 272   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
 273   if ( aDocument.IsNull() )
 274     return;
 275
 276   Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline();
 277   HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects();
 278   if ( aGeomObjects.IsEmpty() )
 279     return;
 280
 281   HYDROData_SequenceOfObjects aGeomGroups = GetGeometryGroups();
 282
 283   HYDROData_SplitToZonesTool::SplitDataList aSplitObjects =
 284     HYDROData_SplitToZonesTool::Split( aGeomObjects, aGeomGroups, aBoundaryPolyline );
 285   if ( aSplitObjects.isEmpty() )
 286     return;
 287
 288   HYDROData_SplitToZonesTool::SplitDataList aZonesList, anEdgesList;
 289
 290   HYDROData_SplitToZonesTool::SplitDataListIterator anIter( aSplitObjects );
 291   while( anIter.hasNext() )
 292   {
 293     const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next();
 294     if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Zone )
 295       aZonesList.append( aSplitData );
 296     else if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Edge )
 297       anEdgesList.append( aSplitData );
 298   }
 299
 300   switch( GetAssignmentMode() )
 301   {
 302   case MANUAL:
 303     CreateRegionsDef( aDocument, aZonesList );
 304     break;
 305   case AUTOMATIC:
 306     CreateRegionsAuto( aDocument, aZonesList );
 307     break;
 308   }
 309   CreateEdgeGroupsDef( aDocument, anEdgesList );
 310 }
 311
 312 void HYDROData_CalculationCase::CreateRegionsDef( const Handle(HYDROData_Document)& theDoc,
 313                                                   const HYDROData_SplitToZonesTool::SplitDataList& theZones )
 314 {
 315   // Create result regions for case, by default one zone for one region
 316   QString aRegsPref = CALCULATION_REGIONS_PREF;
 317   QString aZonesPref = CALCULATION_ZONES_PREF;
 318
 319   HYDROData_SplitToZonesTool::SplitDataListIterator anIter( theZones );
 320   while( anIter.hasNext() )
 321   {
 322     const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next();
 323     // Create new region
 324     Handle(HYDROData_Region) aRegion = addNewRegion( theDoc, aRegsPref );
 325
 326     // Add the zone for region
 327     Handle(HYDROData_Zone) aRegionZone = aRegion->addNewZone( theDoc, aZonesPref, aSplitData.Face(), aSplitData.ObjectNames );
 328   }
 329 }
 330
 331 void HYDROData_CalculationCase::CreateRegionsAuto( const Handle(HYDROData_Document)& theDoc,
 332                                                    const HYDROData_SplitToZonesTool::SplitDataList& theZones )
 333 {
 334   QMap<QString, Handle(HYDROData_Region)> aRegionsMap; //object name to region
 335   QMap<QString, QString> aRegionNameToObjNameMap;
 336   QString aZonesPref = CALCULATION_ZONES_PREF;
 337   HYDROData_PriorityQueue aPr( this );
 338
 339   // 1. First we create a default region for each object included into the calculation case
 340   HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects();
 341   for( int i=aGeomObjects.Lower(), n=aGeomObjects.Upper(); i<=n; i++ )
 342   {
 343     Handle(HYDROData_Object) anObj = Handle(HYDROData_Object)::DownCast( aGeomObjects.Value( i ) );
 344     if( anObj.IsNull() )
 345       continue;
 346     QString anObjName = anObj->GetName();
 347     QString aRegName = anObjName + "_reg";
 348     Handle(HYDROData_Region) aRegion = addNewRegion( theDoc, aRegName, false );
 349     aRegionsMap.insert( anObjName, aRegion );
 350     aRegionNameToObjNameMap.insert( aRegName, anObjName );
 351   }
 352
 353   // 2. Now for each zone it is necessary to determine the most priority object
 354   //    and assign to zone to corresponding region
 355   HYDROData_SplitToZonesTool::SplitDataListIterator anIter( theZones );
 356   while( anIter.hasNext() )
 357   {
 358     const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next();
 359     HYDROData_Zone::MergeAltitudesType aMergeType;
 360     Handle(HYDROData_Object) aRegObj = aPr.GetMostPriorityObject( aSplitData.ObjectNames, aMergeType );
 361     if( aRegObj.IsNull() )
 362       continue;
 363     Handle(HYDROData_Region) aRegion = aRegionsMap[aRegObj->GetName()];
 364     if( aRegion.IsNull() )
 365       continue;
 366     Handle(HYDROData_Zone) aRegionZone = aRegion->addNewZone( theDoc, aZonesPref, aSplitData.Face(), aSplitData.ObjectNames );
 367
 368     if( aSplitData.ObjectNames.count() > 1 && aMergeType==HYDROData_Zone::Merge_UNKNOWN )
 369     {
 370       qDebug( "Error in algorithm: unresolved conflicts" );
 371     }
 372
 373     switch( aMergeType )
 374     {
 375     case HYDROData_Zone::Merge_ZMIN:
 376     case HYDROData_Zone::Merge_ZMAX:
 377       aRegionZone->SetMergeType( aMergeType );
 378       break;
 379     case HYDROData_Zone::Merge_Object:
 380       aRegionZone->SetMergeType( aMergeType );
 381       aRegionZone->RemoveMergeAltitude();
 382       aRegionZone->SetMergeAltitude( aRegObj->GetAltitudeObject() );
 383       break;
 384     }
 385   }
 386
 387   QStringList anObjectsWithEmptyRegions;
 388   QMap<QString, Handle(HYDROData_Region)>::const_iterator
 389     anIt = aRegionsMap.begin(), aLast = aRegionsMap.end();
 390   for( ; anIt!=aLast; anIt++ )
 391   {
 392     Handle(HYDROData_Region) aRegion = anIt.value();
 393     if( aRegion->GetZones().IsEmpty() )
 394     {
 395       QString aRegName = aRegion->GetName();
 396       QString anObjName = aRegionNameToObjNameMap[aRegName];
 397       anObjectsWithEmptyRegions.append( anObjName );
 398     }
 399   }
 400
 401   if( !anObjectsWithEmptyRegions.empty() )
 402   {
 403     QString aData = anObjectsWithEmptyRegions.join( ", " );
 404     SetWarning( WARN_EMPTY_REGIONS, aData );
 405   }
 406 }
 407
 408 void HYDROData_CalculationCase::CreateEdgeGroupsDef( const Handle(HYDROData_Document)& theDoc,
 409                                                      const HYDROData_SplitToZonesTool::SplitDataList& theEdges )
 410 {
 411   QMap<QString,Handle(HYDROData_SplittedShapesGroup)> aSplittedEdgesGroupsMap;
 412
 413   HYDROData_SplitToZonesTool::SplitDataListIterator anIter( theEdges );
 414   while( anIter.hasNext() )
 415   {
 416     const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next();
 417     // Create new edges group
 418     if ( aSplitData.ObjectNames.isEmpty() || aSplitData.Shape.IsNull() )
 419       continue;
 420
 421     QString anObjName = aSplitData.ObjectNames.first();
 422     if ( anObjName.isEmpty() )
 423       continue;
 424 #ifdef DEB_CALCULATION
 425     QString aStr = aSplitData.ObjectNames.join(" ");
 426           cout << " CCase: Names = "<<aStr.toStdString() << " size = " <<aSplitData.ObjectNames.size() <<endl;
 427 #endif
 428     Handle(HYDROData_SplittedShapesGroup) aSplittedGroup;
 429     if ( !aSplittedEdgesGroupsMap.contains( anObjName ) )
 430     {
 431       aSplittedGroup = addNewSplittedGroup( CALCULATION_GROUPS_PREF + anObjName );
 432       aSplittedEdgesGroupsMap.insert( anObjName, aSplittedGroup );
 433     }
 434     else
 435     {
 436       aSplittedGroup = aSplittedEdgesGroupsMap[ anObjName ];
 437     }
 438     if ( aSplittedGroup.IsNull() )
 439       continue;
 440
 441     aSplittedGroup->AddShape( aSplitData.Shape );
 442   }
 443 }
 444
 445 bool HYDROData_CalculationCase::AddGeometryObject( const Handle(HYDROData_Object)& theObject )
 446 {
 447   if ( !HYDROData_Tool::IsGeometryObject( theObject ) )
 448     return false; // Wrong type of object
 449
 450   if ( HasReference( theObject, DataTag_GeometryObject ) )
 451     return false; // Object is already in reference list
 452
 453   AddReferenceObject( theObject, DataTag_GeometryObject );
 454
 455   // Indicate model of the need to update splitting
 456   SetToUpdate( true );
 457
 458   return true;
 459 }
 460
 461 HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetGeometryObjects() const
 462 {
 463   return GetReferenceObjects( DataTag_GeometryObject );
 464 }
 465
 466 void HYDROData_CalculationCase::RemoveGeometryObject( const Handle(HYDROData_Object)& theObject )
 467 {
 468   if ( theObject.IsNull() )
 469     return;
 470
 471   RemoveReferenceObject( theObject->Label(), DataTag_GeometryObject );
 472
 473   // Indicate model of the need to update splitting
 474   SetToUpdate( true );
 475 }
 476
 477 void HYDROData_CalculationCase::RemoveGeometryObjects()
 478 {
 479   ClearReferenceObjects( DataTag_GeometryObject );
 480
 481   // Indicate model of the need to update splitting
 482   SetToUpdate( true );
 483 }
 484
 485 bool HYDROData_CalculationCase::AddGeometryGroup( const Handle(HYDROData_ShapesGroup)& theGroup )
 486 {
 487   if ( theGroup.IsNull() )
 488     return false;
 489
 490   if ( HasReference( theGroup, DataTag_GeometryGroup ) )
 491     return false; // Object is already in reference list
 492
 493   AddReferenceObject( theGroup, DataTag_GeometryGroup );
 494
 495   // Indicate model of the need to update splitting
 496   SetToUpdate( true );
 497
 498   return true;
 499 }
 500
 501 HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetGeometryGroups() const
 502 {
 503   return GetReferenceObjects( DataTag_GeometryGroup );
 504 }
 505
 506 void HYDROData_CalculationCase::RemoveGeometryGroup( const Handle(HYDROData_ShapesGroup)& theGroup )
 507 {
 508   if ( theGroup.IsNull() )
 509     return;
 510
 511   RemoveReferenceObject( theGroup->Label(), DataTag_GeometryGroup );
 512
 513   // Indicate model of the need to update splitting
 514   SetToUpdate( true );
 515 }
 516
 517 void HYDROData_CalculationCase::RemoveGeometryGroups()
 518 {
 519   ClearReferenceObjects( DataTag_GeometryGroup );
 520
 521   // Indicate model of the need to update splitting
 522   SetToUpdate( true );
 523 }
 524
 525 void HYDROData_CalculationCase::SetBoundaryPolyline( const Handle(HYDROData_PolylineXY)& thePolyline )
 526 {
 527   Handle(HYDROData_PolylineXY) aPrevPolyline = GetBoundaryPolyline();
 528
 529   SetReferenceObject( thePolyline, DataTag_Polyline );
 530
 531   // Indicate model of the need to update zones splitting
 532   SetToUpdate( !IsEqual( aPrevPolyline, thePolyline ) || IsMustBeUpdated() );
 533 }
 534
 535 Handle(HYDROData_PolylineXY) HYDROData_CalculationCase::GetBoundaryPolyline() const
 536 {
 537   return Handle(HYDROData_PolylineXY)::DownCast(
 538            GetReferenceObject( DataTag_Polyline ) );
 539 }
 540
 541 void HYDROData_CalculationCase::RemoveBoundaryPolyline()
 542 {
 543   Handle(HYDROData_PolylineXY) aPrevPolyline = GetBoundaryPolyline();
 544
 545   ClearReferenceObjects( DataTag_Polyline );
 546
 547   // Indicate model of the need to update zones splitting
 548   SetToUpdate( !aPrevPolyline.IsNull() || IsMustBeUpdated() );
 549 }
 550
 551 Handle(HYDROData_Region) HYDROData_CalculationCase::AddNewRegion( const Handle(HYDROData_Zone)& theZone )
 552 {
 553   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
 554   Handle(HYDROData_Region) aNewRegion = addNewRegion( aDocument, CALCULATION_REGIONS_PREF );
 555   if ( aNewRegion.IsNull() )
 556     return aNewRegion;
 557
 558   aNewRegion->AddZone( theZone );
 559
 560   return aNewRegion;
 561 }
 562
 563 bool HYDROData_CalculationCase::AddRegion( const Handle(HYDROData_Region)& theRegion )
 564 {
 565   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
 566
 567   if ( theRegion.IsNull() )
 568     return false;
 569
 570   if ( HasReference( theRegion, DataTag_Region ) )
 571     return false; // Object is already in reference list
 572
 573   // Move the region from other calculation
 574   Handle(HYDROData_CalculationCase) aFatherCalc =
 575     Handle(HYDROData_CalculationCase)::DownCast( theRegion->GetFatherObject() );
 576   if ( !aFatherCalc.IsNull() && aFatherCalc->Label() != myLab )
 577   {
 578     Handle(HYDROData_Region) aNewRegion = addNewRegion( aDocument, CALCULATION_REGIONS_PREF );
 579     theRegion->CopyTo( aNewRegion );
 580
 581     aFatherCalc->RemoveRegion( theRegion );
 582
 583     theRegion->SetLabel( aNewRegion->Label() );
 584   }
 585   else
 586   {
 587     AddReferenceObject( theRegion, DataTag_Region );
 588   }
 589
 590   return true;
 591 }
 592
 593 HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetRegions() const
 594 {
 595   return GetReferenceObjects( DataTag_Region );
 596 }
 597
 598 void HYDROData_CalculationCase::UpdateRegionsOrder()
 599 {
 600   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
 601   if ( aDocument.IsNull() )
 602     return;
 603
 604   HYDROData_SequenceOfObjects aRegions = GetRegions();
 605
 606   HYDROData_SequenceOfObjects::Iterator anIter( aRegions );
 607   for ( ; anIter.More(); anIter.Next() )
 608   {
 609     Handle(HYDROData_Region) aRegion =
 610       Handle(HYDROData_Region)::DownCast( anIter.Value() );
 611     if ( aRegion.IsNull() )
 612       continue;
 613
 614     aRegion->SetName( "" );
 615   }
 616
 617   QString aRegsPref = CALCULATION_REGIONS_PREF;
 618
 619   anIter.Init( aRegions );
 620   for ( ; anIter.More(); anIter.Next() )
 621   {
 622     Handle(HYDROData_Region) aRegion =
 623       Handle(HYDROData_Region)::DownCast( anIter.Value() );
 624     if ( aRegion.IsNull() )
 625       continue;
 626
 627     QString aRegionName = HYDROData_Tool::GenerateObjectName( aDocument, aRegsPref );
 628     aRegion->SetName( aRegionName );
 629   }
 630 }
 631
 632 void HYDROData_CalculationCase::RemoveRegion( const Handle(HYDROData_Region)& theRegion )
 633 {
 634   if ( theRegion.IsNull() )
 635     return;
 636
 637   RemoveReferenceObject( theRegion->Label(), DataTag_Region );
 638
 639   // Remove region from data model
 640   Handle(HYDROData_CalculationCase) aFatherCalc =
 641     Handle(HYDROData_CalculationCase)::DownCast( theRegion->GetFatherObject() );
 642   if ( !aFatherCalc.IsNull() && aFatherCalc->Label() == myLab )
 643     theRegion->Remove();
 644 }
 645
 646 void HYDROData_CalculationCase::RemoveRegions()
 647 {
 648   myLab.FindChild( DataTag_ChildRegion ).ForgetAllAttributes();
 649 }
 650
 651 HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetSplittedGroups() const
 652 {
 653   return GetReferenceObjects( DataTag_SplittedGroups );
 654 }
 655
 656 void HYDROData_CalculationCase::RemoveSplittedGroups()
 657 {
 658   myLab.FindChild( DataTag_SplittedGroups ).ForgetAllAttributes();
 659 }
 660
 661 double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint ) const
 662 {
 663   Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint );
 664   return GetAltitudeForPoint( thePoint, aZone );
 665 }
 666
 667 double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY&                    thePoint,
 668                                                        const Handle(HYDROData_Region)& theRegion ) const
 669 {
 670   double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude();
 671
 672   Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint );
 673   if ( !aZone.IsNull() )
 674   {
 675     Handle(HYDROData_Region) aRefRegion = Handle(HYDROData_Region)::DownCast( aZone->GetFatherObject() );
 676     if ( IsEqual( aRefRegion, theRegion ) )
 677       aResAltitude = GetAltitudeForPoint( thePoint, aZone );
 678   }
 679
 680   return aResAltitude;
 681 }
 682
 683 double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY&                  thePoint,
 684                                                        const Handle(HYDROData_Zone)& theZone ) const
 685 {
 686   double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude();
 687   if ( theZone.IsNull() )
 688     return aResAltitude;
 689
 690   HYDROData_Zone::MergeAltitudesType aZoneMergeType = theZone->GetMergeType();
 691   if ( !theZone->IsMergingNeed() )
 692   {
 693     aZoneMergeType = HYDROData_Zone::Merge_UNKNOWN;
 694   }
 695   else if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN )
 696   {
 697     return aResAltitude;
 698   }
 699
 700   HYDROData_IInterpolator* aZoneInterpolator = theZone->GetInterpolator();
 701   if ( aZoneMergeType == HYDROData_Zone::Merge_Object )
 702   {
 703     Handle(HYDROData_IAltitudeObject) aMergeAltitude = theZone->GetMergeAltitude();
 704     if ( !aMergeAltitude.IsNull() )
 705     {
 706       if ( aZoneInterpolator != NULL )
 707       {
 708         aZoneInterpolator->SetAltitudeObject( aMergeAltitude );
 709         aResAltitude = aZoneInterpolator->GetAltitudeForPoint( thePoint );
 710       }
 711       else
 712         aResAltitude = aMergeAltitude->GetAltitudeForPoint( thePoint );
 713     }
 714   }
 715   else
 716   {
 717     HYDROData_SequenceOfObjects aZoneObjects = theZone->GetGeometryObjects();
 718     HYDROData_SequenceOfObjects::Iterator anIter( aZoneObjects );
 719     for ( ; anIter.More(); anIter.Next() )
 720     {
 721       Handle(HYDROData_Object) aZoneObj =
 722         Handle(HYDROData_Object)::DownCast( anIter.Value() );
 723       if ( aZoneObj.IsNull() )
 724         continue;
 725
 726       Handle(HYDROData_IAltitudeObject) anObjAltitude = aZoneObj->GetAltitudeObject();
 727       if ( anObjAltitude.IsNull() )
 728         continue;
 729
 730       double aPointAltitude = 0.0;
 731       if ( aZoneInterpolator != NULL )
 732       {
 733         aZoneInterpolator->SetAltitudeObject( anObjAltitude );
 734         aPointAltitude = aZoneInterpolator->GetAltitudeForPoint( thePoint );
 735       }
 736       else
 737         aPointAltitude = anObjAltitude->GetAltitudeForPoint( thePoint );
 738
 739       if ( ValuesEquals( aPointAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) )
 740         continue;
 741
 742       if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN )
 743       {
 744         aResAltitude = aPointAltitude;
 745         break;
 746       }
 747       else if ( aZoneMergeType == HYDROData_Zone::Merge_ZMIN )
 748       {
 749         if ( ValuesEquals( aResAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) ||
 750              aResAltitude > aPointAltitude )
 751         {
 752           aResAltitude = aPointAltitude;
 753         }
 754       }
 755       else if ( aZoneMergeType == HYDROData_Zone::Merge_ZMAX )
 756       {
 757         if ( ValuesEquals( aResAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) ||
 758              aResAltitude < aPointAltitude )
 759         {
 760           aResAltitude = aPointAltitude;
 761         }
 762       }
 763     }
 764   }
 765
 766   return aResAltitude;
 767 }
 768
 769 NCollection_Sequence<double> HYDROData_CalculationCase::GetAltitudesForPoints(
 770   const NCollection_Sequence<gp_XY>& thePoints,
 771   const Handle(HYDROData_Region)&    theRegion ) const
 772 {
 773   NCollection_Sequence<double> aResSeq;
 774
 775   for ( int i = 1, n = thePoints.Length(); i <= n; ++i )
 776   {
 777     const gp_XY& thePnt = thePoints.Value( i );
 778
 779     double anAltitude = GetAltitudeForPoint( thePnt, theRegion );
 780     aResSeq.Append( anAltitude );
 781   }
 782
 783   return aResSeq;
 784 }
 785
 786 NCollection_Sequence<double> HYDROData_CalculationCase::GetAltitudesForPoints(
 787   const NCollection_Sequence<gp_XY>& thePoints,
 788   const Handle(HYDROData_Zone)&      theZone ) const
 789 {
 790   NCollection_Sequence<double> aResSeq;
 791
 792   for ( int i = 1, n = thePoints.Length(); i <= n; ++i )
 793   {
 794     const gp_XY& thePnt = thePoints.Value( i );
 795
 796     double anAltitude = GetAltitudeForPoint( thePnt, theZone );
 797     aResSeq.Append( anAltitude );
 798   }
 799
 800   return aResSeq;
 801 }
 802
 803 Handle(HYDROData_Region) HYDROData_CalculationCase::GetRegionFromPoint( const gp_XY& thePoint ) const
 804 {
 805   Handle(HYDROData_Region) aResRegion;
 806
 807   Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint );
 808   if ( !aZone.IsNull() )
 809     aResRegion = Handle(HYDROData_Region)::DownCast( aZone->GetFatherObject() );
 810
 811   return aResRegion;
 812 }
 813
 814 Handle(HYDROData_Zone) HYDROData_CalculationCase::GetZoneFromPoint( const gp_XY& thePoint ) const
 815 {
 816   Handle(HYDROData_Zone) aResZone;
 817
 818   HYDROData_SequenceOfObjects aRegions = GetRegions();
 819
 820   HYDROData_SequenceOfObjects::Iterator anIter( aRegions );
 821   for ( ; anIter.More() && aResZone.IsNull(); anIter.Next() )
 822   {
 823     Handle(HYDROData_Region) aRegion =
 824       Handle(HYDROData_Region)::DownCast( anIter.Value() );
 825     if ( aRegion.IsNull() )
 826       continue;
 827
 828     HYDROData_SequenceOfObjects aZones = aRegion->GetZones();
 829     HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones );
 830     for ( ; aZonesIter.More() && aResZone.IsNull(); aZonesIter.Next() )
 831     {
 832       Handle(HYDROData_Zone) aRegZone =
 833         Handle(HYDROData_Zone)::DownCast( aZonesIter.Value() );
 834       if ( aRegZone.IsNull() )
 835         continue;
 836
 837       PointClassification aPointRelation = GetPointClassification( thePoint, aRegZone );
 838       if ( aPointRelation != POINT_OUT )
 839         aResZone = aRegZone; // We found the desired zone
 840     }
 841   }
 842
 843   return aResZone;
 844 }
 845
 846 HYDROData_CalculationCase::PointClassification HYDROData_CalculationCase::GetPointClassification(
 847   const gp_XY&                  thePoint,
 848   const Handle(HYDROData_Zone)& theZone ) const
 849 {
 850   PointClassification aRes = POINT_OUT;
 851   if ( theZone.IsNull() )
 852     return aRes;
 853
 854   TopoDS_Face aZoneFace = TopoDS::Face( theZone->GetShape() );
 855   if ( aZoneFace.IsNull() )
 856     return aRes;
 857 #ifdef DEB_CLASS2D
 858           TopoDS_Compound aCmp;
 859       BRep_Builder aBB;
 860       aBB.MakeCompound(aCmp);
 861           aBB.Add(aCmp, aZoneFace);
 862           gp_Pnt aPnt (thePoint.X(), thePoint.Y(), 0.);
 863           BRepBuilderAPI_MakeVertex aMk(aPnt);
 864           aBB.Add(aCmp, aMk.Vertex());
 865           BRepTools::Write(aCmp, "FCL2d.brep");
 866 #endif
 867   TopAbs_State State = HYDROData_Tool::ComputePointState(thePoint, aZoneFace);
 868   if (State == TopAbs_OUT)
 869     aRes =  POINT_OUT;
 870   else if(State == TopAbs_IN)
 871     aRes =  POINT_IN;
 872   else if(State == TopAbs_ON)
 873     aRes =  POINT_ON;
 874   return aRes;
 875 }
 876
 877 Handle(HYDROData_Region) HYDROData_CalculationCase::addNewRegion( const Handle(HYDROData_Document)& theDoc,
 878                                                                   const QString& thePrefixOrName,
 879                                                                   bool isPrefix )
 880 {
 881   TDF_Label aNewLab = myLab.FindChild( DataTag_ChildRegion ).NewChild();
 882   int aTag = aNewLab.Tag();
 883
 884   Handle(HYDROData_Region) aNewRegion =
 885     Handle(HYDROData_Region)::DownCast( HYDROData_Iterator::CreateObject( aNewLab, KIND_REGION ) );
 886   AddRegion( aNewRegion );
 887
 888   QString aRegionName = isPrefix ? HYDROData_Tool::GenerateObjectName( theDoc, thePrefixOrName ) : thePrefixOrName;
 889   aNewRegion->SetName( aRegionName );
 890
 891   return aNewRegion;
 892 }
 893
 894 Handle(HYDROData_SplittedShapesGroup) HYDROData_CalculationCase::addNewSplittedGroup( const QString& theName )
 895 {
 896   TDF_Label aNewLab = myLab.FindChild( DataTag_SplittedGroups ).NewChild();
 897
 898   Handle(HYDROData_SplittedShapesGroup) aNewGroup =
 899     Handle(HYDROData_SplittedShapesGroup)::DownCast(
 900       HYDROData_Iterator::CreateObject( aNewLab, KIND_SPLITTED_GROUP ) );
 901   AddReferenceObject( aNewGroup, DataTag_SplittedGroups );
 902
 903   aNewGroup->SetName( theName );
 904
 905   return aNewGroup;
 906 }
 907
 908 QString HYDROData_CalculationCase::Export( int theStudyId ) const
 909 {
 910   int argc = 0;
 911   char** argv = 0;
 912   CORBA::ORB_var anORB = CORBA::ORB_init( argc, argv, "omniORB4"/*CORBA::ORB_ID*/ );
 913   SALOME_NamingService aNameService( anORB );
 914   SALOME_LifeCycleCORBA aLCC( &aNameService );
 915   Engines::EngineComponent_var aComponent = aLCC.FindOrLoad_Component( "FactoryServer", "GEOM" );
 916   GEOM::GEOM_Gen_var aGEOMEngine = GEOM::GEOM_Gen::_narrow( aComponent );
 917
 918   CORBA::Object_var aSMObject = aNameService.Resolve("/myStudyManager");
 919   SALOMEDS::StudyManager_var aStudyManager = SALOMEDS::StudyManager::_narrow(aSMObject);
 920   SALOMEDS::Study_var aDSStudy = aStudyManager->GetStudyByID( theStudyId );
 921
 922   QString aGeomObjEntry;
 923   bool isOK = Export( aGEOMEngine, aDSStudy, aGeomObjEntry );
 924   return isOK ? aGeomObjEntry : QString();
 925 }
 926
 927 bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var  theGeomEngine,
 928                                         SALOMEDS::Study_ptr theStudy,
 929                                         QString& theGeomObjEntry ) const
 930 {
 931   HYDROData_ShapesGroup::SeqOfGroupsDefs aSeqOfGroupsDefs;
 932
 933   // Get groups definitions
 934   HYDROData_SequenceOfObjects aSplittedGroups = GetSplittedGroups();
 935
 936   HYDROData_SequenceOfObjects::Iterator anIter( aSplittedGroups );
 937   for ( ; anIter.More(); anIter.Next() )
 938   {
 939     // Get shapes group
 940     Handle(HYDROData_ShapesGroup) aGroup =
 941       Handle(HYDROData_ShapesGroup)::DownCast( anIter.Value() );
 942     if ( aGroup.IsNull() )
 943       continue;
 944
 945     HYDROData_ShapesGroup::GroupDefinition aGroupDef;
 946
 947     aGroupDef.Name = aGroup->GetName().toLatin1().constData();
 948     aGroup->GetShapes( aGroupDef.Shapes );
 949
 950     aSeqOfGroupsDefs.Append( aGroupDef );
 951   }
 952
 953   // Get faces
 954   TopTools_ListOfShape aFaces;
 955   HYDROData_SequenceOfObjects aCaseRegions = GetRegions();
 956   HYDROData_SequenceOfObjects::Iterator aRegionIter( aCaseRegions );
 957   for ( ; aRegionIter.More(); aRegionIter.Next() )
 958   {
 959     Handle(HYDROData_Region) aRegion =
 960       Handle(HYDROData_Region)::DownCast( aRegionIter.Value() );
 961     if( aRegion.IsNull() )
 962       continue;
 963
 964     TopoDS_Shape aRegionShape = aRegion->GetShape( &aSeqOfGroupsDefs );
 965     aFaces.Append( aRegionShape );
 966   }
 967
 968   return Export( theGeomEngine, theStudy, aFaces, aSeqOfGroupsDefs, theGeomObjEntry );
 969 }
 970
 971 bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var                            theGeomEngine,
 972                                         SALOMEDS::Study_ptr                           theStudy,
 973                                         const TopTools_ListOfShape&                   theFaces,
 974                                         const HYDROData_ShapesGroup::SeqOfGroupsDefs& theGroupsDefs,
 975                                         QString& theGeomObjEntry ) const
 976 {
 977   // Sew faces
 978   BRepBuilderAPI_Sewing aSewing( Precision::Confusion() * 10.0 );
 979   aSewing.SetNonManifoldMode( Standard_False );
 980 #ifdef DEB_CALCULATION
 981   TCollection_AsciiString aNam("Sh_");
 982   int i=1;
 983 #endif
 984   TopTools_ListIteratorOfListOfShape aFaceIter( theFaces );
 985   for ( ; aFaceIter.More(); aFaceIter.Next() )
 986   {
 987     TopoDS_Shape aShape = aFaceIter.Value();
 988     if ( aShape.IsNull() )
 989       continue;
 990
 991     if ( aShape.ShapeType() == TopAbs_FACE )
 992     {
 993       aSewing.Add( aShape );
 994 #ifdef DEB_CALCULATION
 995       TCollection_AsciiString aName = aNam + ++i + ".brep";
 996       BRepTools::Write(aShape ,aName.ToCString());
 997 #endif
 998     }
 999     else
1000     {
1001 #ifdef DEB_CALCULATION
1002       int j = 1;
1003 #endif
1004       TopExp_Explorer anExp( aShape, TopAbs_FACE );
1005       for (; anExp.More(); anExp.Next() ) {
1006         aSewing.Add( anExp.Current() );
1007 #ifdef DEB_CALCULATION
1008
1009         TCollection_AsciiString aName = aNam + i + "_" + ++j + ".brep";
1010         BRepTools::Write(anExp.Current() ,aName.ToCString());
1011 #endif
1012       }
1013     }
1014   } // faces iterator
1015
1016   aSewing.Perform();
1017   TopoDS_Shape aSewedShape = aSewing.SewedShape();
1018
1019   // If the sewed shape is empty - return false
1020   if ( aSewedShape.IsNull() || !TopoDS_Iterator( aSewedShape ).More() )
1021     return false;
1022
1023 #ifdef DEB_CALCULATION
1024   BRepTools::Write(aSewedShape ,"Sew.brep");
1025 #endif
1026   // Publish the sewed shape
1027   QString aName = EXPORT_NAME;
1028   GEOM::GEOM_Object_ptr aMainShape =
1029     publishShapeInGEOM( theGeomEngine, theStudy, aSewedShape, aName, theGeomObjEntry );
1030
1031   if ( aMainShape->_is_nil() )
1032     return false;
1033
1034   if ( theGroupsDefs.IsEmpty() )
1035     return true;
1036
1037   // Create groups
1038   TopTools_IndexedMapOfShape aMapOfSubShapes;
1039   TopExp::MapShapes( aSewedShape, aMapOfSubShapes );
1040
1041   NCollection_DataMap< TCollection_AsciiString, NCollection_Sequence<int> > aGroupsData;
1042
1043   for ( int aGrId = 1, nbGroups = theGroupsDefs.Length(); aGrId <= nbGroups; ++aGrId )
1044   {
1045     const HYDROData_ShapesGroup::GroupDefinition& aGroupDef = theGroupsDefs.Value( aGrId );
1046
1047     NCollection_Sequence<int> aGroupIndexes;
1048     for( int i = 1, n = aGroupDef.Shapes.Length(); i <= n; i++ )
1049     {
1050       const TopoDS_Shape& aShape = aGroupDef.Shapes.Value( i );
1051 #ifdef DEB_CALCULATION
1052       cout << "\nOld shape(" << i << ") = " << aShape.TShape() <<endl;
1053 #endif
1054
1055       TopoDS_Shape aModifiedShape = aShape;
1056       if ( aSewing.IsModified( aShape ) )
1057         aModifiedShape = aSewing.Modified( aShape );
1058       else if ( aSewing.IsModifiedSubShape( aShape ) )
1059         aModifiedShape = aSewing.ModifiedSubShape( aShape );
1060
1061 #ifdef DEB_CALCULATION
1062       const TopLoc_Location& aL1 = aShape.Location();
1063       const TopLoc_Location& aL2 = aModifiedShape.Location();
1064       cout << "\nNew shape(" << i << ") = " << aModifiedShape.TShape() << " Location is Equal = " << aL1.IsEqual(aL2)<<endl;
1065 #endif
1066
1067       int anIndex = aMapOfSubShapes.FindIndex(aModifiedShape);
1068       if ( anIndex > 0 ) {
1069         aGroupIndexes.Append( anIndex );
1070       } else {
1071 #ifdef DEB_CALCULATION
1072         TCollection_AsciiString aNam("Lost_");
1073         if(!aMapOfSubShapes.Contains(aModifiedShape)) {
1074         for ( int anIndex = 1; anIndex <= aMapOfSubShapes.Extent(); anIndex++ )
1075         {
1076            const TopoDS_Shape& aS = aMapOfSubShapes.FindKey( anIndex );
1077            if ( aModifiedShape.IsPartner( aS ) )
1078            {
1079              cout <<"\nIndex in Map = " << anIndex << "TShape = " << aS.TShape() <<endl;
1080              TCollection_AsciiString aName = aNam + i + "_" + anIndex + ".brep";
1081              BRepTools::Write(aS ,aName.ToCString());
1082             break;
1083            }
1084          }
1085         }
1086 #endif
1087       }
1088     }
1089     if ( !aGroupIndexes.IsEmpty() )
1090       aGroupsData.Bind( aGroupDef.Name, aGroupIndexes );
1091   }
1092
1093   if ( !aGroupsData.IsEmpty() )
1094   {
1095     GEOM::GEOM_IGroupOperations_var aGroupOp =
1096       theGeomEngine->GetIGroupOperations( theStudy->StudyId() );
1097
1098     NCollection_DataMap< TCollection_AsciiString, NCollection_Sequence<int> >::Iterator aMapIt( aGroupsData );
1099     for ( ; aMapIt.More(); aMapIt.Next() )
1100     {
1101       const TCollection_AsciiString& aGroupName = aMapIt.Key();
1102       const NCollection_Sequence<int>& aGroupIndexes = aMapIt.Value();
1103
1104       GEOM::GEOM_Object_var aGeomGroup = aGroupOp->CreateGroup( aMainShape, TopAbs_EDGE );
1105       if ( CORBA::is_nil( aGeomGroup ) || !aGroupOp->IsDone() )
1106         continue;
1107
1108       GEOM::ListOfLong_var aGeomIndexes = new GEOM::ListOfLong;
1109       aGeomIndexes->length( aGroupIndexes.Length() );
1110
1111       for( int i = 1, n = aGroupIndexes.Length(); i <= n; i++ )
1112         aGeomIndexes[ i - 1 ] = aGroupIndexes.Value( i );
1113
1114       aGroupOp->UnionIDs( aGeomGroup, aGeomIndexes );
1115       if ( aGroupOp->IsDone() )
1116       {
1117         SALOMEDS::SObject_var aGroupSO =
1118           theGeomEngine->AddInStudy( theStudy, aGeomGroup, aGroupName.ToCString(), aMainShape );
1119       }
1120     }
1121   }
1122
1123   return true;
1124 }
1125
1126 GEOM::GEOM_Object_ptr HYDROData_CalculationCase::publishShapeInGEOM(
1127   GEOM::GEOM_Gen_var theGeomEngine, SALOMEDS::Study_ptr theStudy,
1128   const TopoDS_Shape& theShape, const QString& theName,
1129   QString& theGeomObjEntry ) const
1130 {
1131   theGeomObjEntry = "";
1132   GEOM::GEOM_Object_var aGeomObj;
1133
1134   if ( theGeomEngine->_is_nil() || theStudy->_is_nil() ||
1135        theShape.IsNull() ) {
1136     return aGeomObj._retn();
1137   }
1138
1139   std::ostringstream aStreamShape;
1140   // Write TopoDS_Shape in ASCII format to the stream
1141   BRepTools::Write( theShape, aStreamShape );
1142   // Returns the number of bytes that have been stored in the stream's buffer.
1143   int aSize = aStreamShape.str().size();
1144   // Allocate octect buffer of required size
1145   CORBA::Octet* anOctetBuf = SALOMEDS::TMPFile::allocbuf( aSize );
1146   // Copy ostrstream content to the octect buffer
1147   memcpy( anOctetBuf, aStreamShape.str().c_str(), aSize );
1148   // Create TMPFile
1149   SALOMEDS::TMPFile_var aSeqFile = new SALOMEDS::TMPFile( aSize, aSize, anOctetBuf, 1 );
1150
1151   // Restore shape from the stream and get the GEOM object
1152   GEOM::GEOM_IInsertOperations_var anInsOp = theGeomEngine->GetIInsertOperations( theStudy->StudyId() );
1153   aGeomObj = anInsOp->RestoreShape( aSeqFile );
1154
1155   // Puplish the GEOM object
1156   if ( !aGeomObj->_is_nil() ) {
1157     QString aName = GEOMBase::GetDefaultName( theName );
1158
1159     SALOMEDS::SObject_var aResultSO =
1160       theGeomEngine->PublishInStudy( theStudy, SALOMEDS::SObject::_nil(),
1161                                      aGeomObj, qPrintable( aName ) );
1162     if ( aResultSO->_is_nil() ) {
1163       aGeomObj = GEOM::GEOM_Object::_nil();
1164     }
1165     else
1166       theGeomObjEntry = aResultSO->GetID();
1167   }
1168
1169   return aGeomObj._retn();
1170 }
1171
1172 void HYDROData_CalculationCase::ClearRules( const bool theIsSetToUpdate )
1173 {
1174   TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomRules );
1175   HYDROData_PriorityQueue::ClearRules( aRulesLab );
1176
1177   // Indicate model of the need to update splitting
1178   if ( theIsSetToUpdate ) {
1179     SetToUpdate( true );
1180   }
1181 }
1182
1183 void HYDROData_CalculationCase::AddRule( const Handle(HYDROData_Object)&    theObject1,
1184                                          HYDROData_PriorityType             thePriority,
1185                                          const Handle(HYDROData_Object)&    theObject2,
1186                                          HYDROData_Zone::MergeAltitudesType theMergeType )
1187 {
1188   TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomRules );
1189   HYDROData_PriorityQueue::AddRule( aRulesLab, theObject1, thePriority, theObject2, theMergeType );
1190
1191   // Indicate model of the need to update splitting
1192   SetToUpdate( true );
1193 }
1194
1195 QString HYDROData_CalculationCase::DumpRules() const
1196 {
1197   TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomRules );
1198   return HYDROData_PriorityQueue::DumpRules( aRulesLab );
1199 }
1200
1201 void HYDROData_CalculationCase::SetAssignmentMode( AssignmentMode theMode )
1202 {
1203   TDF_Label aModeLab = myLab.FindChild( DataTag_AssignmentMode );
1204   TDataStd_Integer::Set( aModeLab, ( int ) theMode );
1205
1206   // Indicate model of the need to update splitting
1207   SetToUpdate( true );
1208 }
1209
1210 HYDROData_CalculationCase::AssignmentMode HYDROData_CalculationCase::GetAssignmentMode() const
1211 {
1212   Handle(TDataStd_Integer) aModeAttr;
1213   bool isOK = myLab.FindChild( DataTag_AssignmentMode ).FindAttribute( TDataStd_Integer::GetID(), aModeAttr );
1214   if( isOK )
1215     return ( AssignmentMode ) aModeAttr->Get();
1216   else
1217     return MANUAL;
1218 }
1219
1220 void HYDROData_CalculationCase::DumpRulesToPython( const QString& theCalcCaseName,
1221                                                    QStringList& theScript ) const
1222 {
1223   TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomRules );
1224   HYDROData_PriorityQueue::DumpRulesToPython( aRulesLab, theCalcCaseName, theScript );
1225 }
1226
1227 HYDROData_Warning HYDROData_CalculationCase::GetLastWarning() const
1228 {
1229   return myLastWarning;
1230 }
1231
1232 void HYDROData_CalculationCase::SetWarning( HYDROData_WarningType theType, const QString& theData )
1233 {
1234   myLastWarning.Type = theType;
1235   myLastWarning.Data = theData;
1236 }
1237
1238 bool HYDROData_CalculationCase::GetRule( int theIndex,
1239                                          Handle(HYDROData_Object)&           theObject1,
1240                                          HYDROData_PriorityType&             thePriority,
1241                                          Handle(HYDROData_Object)&           theObject2,
1242                                          HYDROData_Zone::MergeAltitudesType& theMergeType ) const
1243 {
1244   TDF_Label aRulesLab = myLab.FindChild( DataTag_CustomRules );
1245   return HYDROData_PriorityQueue::GetRule( aRulesLab, theIndex,
1246     theObject1, thePriority, theObject2, theMergeType );
1247 }