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_SplitToZonesTool.h"
  12 #include "HYDROData_SplittedShapesGroup.h"
  13 #include "HYDROData_Region.h"
  14 #include "HYDROData_Tool.h"
  15 #include "HYDROData_Zone.h"
  16
  17 #include <GEOMBase.h>
  18
  19 #include <QSet>
  20
  21 #include <TopoDS.hxx>
  22 #include <TopoDS_Shell.hxx>
  23 #include <TopoDS_Edge.hxx>
  24
  25 #include <BRep_Builder.hxx>
  26 #include <BRepBuilderAPI_Sewing.hxx>
  27 #include <BRepTopAdaptor_FClass2d.hxx>
  28
  29 #include <BRepTools.hxx>
  30
  31 #include <TopAbs.hxx>
  32 #include <TopExp_Explorer.hxx>
  33 #include <TopExp.hxx>
  34 #include <TopTools_ListOfShape.hxx>
  35 #include <TopTools_ListIteratorOfListOfShape.hxx>
  36
  37 //#define  DEB_CALCULATION 1
  38 #ifdef DEB_CALCULATION
  39 #include <BRepTools.hxx>
  40 #include <TopLoc_Location.hxx>
  41 #endif
  42 #define CALCULATION_REGIONS_PREF GetName() + "_Reg"
  43 #define CALCULATION_ZONES_PREF GetName() + "_Zone"
  44 #define CALCULATION_GROUPS_PREF GetName() + "_"
  45
  46 #define EXPORT_NAME "HYDRO_" + GetName()
  47
  48 IMPLEMENT_STANDARD_HANDLE(HYDROData_CalculationCase, HYDROData_Entity)
  49 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_CalculationCase, HYDROData_Entity)
  50
  51 HYDROData_CalculationCase::HYDROData_CalculationCase()
  52 : HYDROData_Entity()
  53 {
  54 }
  55
  56 HYDROData_CalculationCase::~HYDROData_CalculationCase()
  57 {
  58 }
  59
  60 void HYDROData_CalculationCase::SetName( const QString& theName )
  61 {
  62   QString anOldCaseName = GetName();
  63   if ( anOldCaseName != theName )
  64   {
  65     HYDROData_SequenceOfObjects aRegions = GetRegions();
  66
  67     HYDROData_SequenceOfObjects::Iterator anIter( aRegions );
  68     for ( ; anIter.More(); anIter.Next() )
  69     {
  70       Handle(HYDROData_Region) aRegion =
  71         Handle(HYDROData_Region)::DownCast( anIter.Value() );
  72       if ( aRegion.IsNull() )
  73         continue;
  74
  75       HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aRegion );
  76
  77       HYDROData_SequenceOfObjects aZones = aRegion->GetZones();
  78       HYDROData_SequenceOfObjects::Iterator anIter( aZones );
  79       for ( ; anIter.More(); anIter.Next() )
  80       {
  81         Handle(HYDROData_Zone) aRegZone =
  82           Handle(HYDROData_Zone)::DownCast( anIter.Value() );
  83         if ( aRegZone.IsNull() )
  84           continue;
  85
  86         HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aRegZone );
  87       }
  88     }
  89
  90     HYDROData_SequenceOfObjects aGroups = GetGeometryGroups();
  91
  92     anIter.Init( aGroups );
  93     for ( ; anIter.More(); anIter.Next() )
  94     {
  95       Handle(HYDROData_SplittedShapesGroup) aGroup =
  96         Handle(HYDROData_SplittedShapesGroup)::DownCast( anIter.Value() );
  97       if ( aGroup.IsNull() )
  98         continue;
  99
 100       HYDROData_Tool::UpdateChildObjectName( anOldCaseName, theName, aGroup );
 101     }
 102   }
 103
 104   HYDROData_Entity::SetName( theName );
 105 }
 106
 107 QStringList HYDROData_CalculationCase::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
 108 {
 109   QStringList aResList = dumpObjectCreation( theTreatedObjects );
 110
 111   QString aCalculName = GetObjPyName();
 112
 113   HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects();
 114   HYDROData_SequenceOfObjects::Iterator anIter( aGeomObjects );
 115   for ( ; anIter.More(); anIter.Next() )
 116   {
 117     Handle(HYDROData_Object) aRefGeomObj =
 118       Handle(HYDROData_Object)::DownCast( anIter.Value() );
 119     setPythonReferenceObject( theTreatedObjects, aResList, aRefGeomObj, "AddGeometryObject" );
 120   }
 121   aResList << QString( "" );
 122
 123   QString aGroupName = HYDROData_Tool::GenerateNameForPython( theTreatedObjects, "case_geom_group" );
 124
 125   HYDROData_SequenceOfObjects aGeomGroups = GetGeometryGroups();
 126   anIter.Init( aGeomGroups );
 127   for ( ; anIter.More(); anIter.Next() )
 128   {
 129     Handle(HYDROData_ShapesGroup) aGeomGroup =
 130       Handle(HYDROData_ShapesGroup)::DownCast( anIter.Value() );
 131     if ( aGeomGroup.IsNull() )
 132       continue;
 133
 134     Handle(HYDROData_Object) aFatherGeom =
 135       Handle(HYDROData_Object)::DownCast( aGeomGroup->GetFatherObject() );
 136     if ( aFatherGeom.IsNull() )
 137       continue;
 138
 139     int aGroupId = aFatherGeom->GetGroupId( aGeomGroup );
 140     aResList << QString( "%1 = %2.GetGroup( %3 );" )
 141               .arg( aGroupName ).arg( aFatherGeom->GetObjPyName() ).arg( aGroupId );
 142
 143     aResList << QString( "%1.AddGeometryGroup( %2 );" ).arg( aCalculName ).arg( aGroupName );
 144   }
 145   aResList << QString( "" );
 146
 147   Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline();
 148   setPythonReferenceObject( theTreatedObjects, aResList, aBoundaryPolyline, "SetBoundaryPolyline" );
 149   aResList << QString( "" );
 150
 151   aResList << QString( "%1.Update();" ).arg( aCalculName );
 152   aResList << QString( "" );
 153
 154   // Now we restore the regions and zones order
 155   HYDROData_SequenceOfObjects aRegions = GetRegions();
 156   anIter.Init( aRegions );
 157   for ( ; anIter.More(); anIter.Next() )
 158   {
 159     Handle(HYDROData_Region) aRegion =
 160       Handle(HYDROData_Region)::DownCast( anIter.Value() );
 161     if ( aRegion.IsNull() )
 162       continue;
 163
 164     QString aRegionName = aRegion->GetName();
 165
 166     HYDROData_SequenceOfObjects aZones = aRegion->GetZones();
 167     HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones );
 168     for ( ; aZonesIter.More(); aZonesIter.Next() )
 169     {
 170       Handle(HYDROData_Zone) aRegZone =
 171         Handle(HYDROData_Zone)::DownCast( aZonesIter.Value() );
 172       if ( aRegZone.IsNull() )
 173         continue;
 174
 175       // TODO
 176     }
 177   }
 178   aResList << QString( "" );
 179
 180   return aResList;
 181 }
 182
 183 HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetAllReferenceObjects() const
 184 {
 185   HYDROData_SequenceOfObjects aResSeq = HYDROData_Entity::GetAllReferenceObjects();
 186
 187   Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline();
 188   if ( !aBoundaryPolyline.IsNull() )
 189     aResSeq.Append( aBoundaryPolyline );
 190
 191   HYDROData_SequenceOfObjects aSeqOfRegions = GetRegions();
 192   aResSeq.Append( aSeqOfRegions );
 193
 194   return aResSeq;
 195 }
 196
 197 void HYDROData_CalculationCase::Update()
 198 {
 199   HYDROData_Entity::Update();
 200
 201   // At first we remove previously created objects
 202   RemoveRegions();
 203   RemoveSplittedGroups();
 204
 205   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
 206   if ( aDocument.IsNull() )
 207     return;
 208
 209   Handle(HYDROData_PolylineXY) aBoundaryPolyline = GetBoundaryPolyline();
 210   HYDROData_SequenceOfObjects aGeomObjects = GetGeometryObjects();
 211   if ( aGeomObjects.IsEmpty() )
 212     return;
 213
 214   HYDROData_SequenceOfObjects aGeomGroups = GetGeometryGroups();
 215
 216   HYDROData_SplitToZonesTool::SplitDataList aSplitedObjects =
 217     HYDROData_SplitToZonesTool::Split( aGeomObjects, aGeomGroups, aBoundaryPolyline );
 218   if ( aSplitedObjects.isEmpty() )
 219     return;
 220
 221   QString aRegsPref = CALCULATION_REGIONS_PREF;
 222   QString aZonesPref = CALCULATION_ZONES_PREF;
 223
 224   QMap<QString,Handle(HYDROData_SplittedShapesGroup)> aSplittedEdgesGroupsMap;
 225
 226   // Create result regions for case, by default one zone for one region
 227   HYDROData_SplitToZonesTool::SplitDataListIterator anIter( aSplitedObjects );
 228   while( anIter.hasNext() )
 229   {
 230     const HYDROData_SplitToZonesTool::SplitData& aSplitData = anIter.next();
 231
 232     if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Zone )
 233     {
 234       // Create new region
 235       Handle(HYDROData_Region) aRegion = addNewRegion();
 236
 237       QString aRegionName = HYDROData_Tool::GenerateObjectName( aDocument, aRegsPref );
 238       aRegion->SetName( aRegionName );
 239
 240       // Add the zone for region
 241       Handle(HYDROData_Zone) aRegionZone = aRegion->addNewZone();
 242
 243       QString aZoneName = HYDROData_Tool::GenerateObjectName( aDocument, aZonesPref );
 244       aRegionZone->SetName( aZoneName );
 245
 246       aRegionZone->SetShape( aSplitData.Face() );
 247
 248       // Add the reference object for zone
 249       for ( int i = 0, n = aSplitData.ObjectNames.length(); i < n; ++i )
 250       {
 251         const QString& anObjName = aSplitData.ObjectNames.at( i );
 252
 253         Handle(HYDROData_Object) aRefObject = Handle(HYDROData_Object)::DownCast(
 254           HYDROData_Tool::FindObjectByName( aDocument, anObjName ) );
 255         if ( aRefObject.IsNull() )
 256           continue;
 257
 258         aRegionZone->AddGeometryObject( aRefObject );
 259       }
 260     }
 261     else if ( aSplitData.Type == HYDROData_SplitToZonesTool::SplitData::Data_Edge )
 262     {
 263       // Create new edges group
 264       if ( aSplitData.ObjectNames.isEmpty() || aSplitData.Shape.IsNull() )
 265         continue;
 266
 267       QString anObjName = aSplitData.ObjectNames.first();
 268       if ( anObjName.isEmpty() )
 269         continue;
 270
 271       Handle(HYDROData_SplittedShapesGroup) aSplittedGroup;
 272       if ( !aSplittedEdgesGroupsMap.contains( anObjName ) )
 273       {
 274         aSplittedGroup = addNewSplittedGroup();
 275
 276         QString aCalcGroupName = CALCULATION_GROUPS_PREF + anObjName;
 277         aSplittedGroup->SetName( aCalcGroupName );
 278
 279         aSplittedEdgesGroupsMap.insert( anObjName, aSplittedGroup );
 280       }
 281       else
 282       {
 283         aSplittedGroup = aSplittedEdgesGroupsMap[ anObjName ];
 284       }
 285
 286       if ( aSplittedGroup.IsNull() )
 287         continue;
 288
 289       aSplittedGroup->AddShape( aSplitData.Shape );
 290     }
 291   }
 292 }
 293
 294 bool HYDROData_CalculationCase::AddGeometryObject( const Handle(HYDROData_Object)& theObject )
 295 {
 296   if ( !HYDROData_Tool::IsGeometryObject( theObject ) )
 297     return false; // Wrong type of object
 298
 299   if ( HasReference( theObject, DataTag_GeometryObject ) )
 300     return false; // Object is already in reference list
 301
 302   AddReferenceObject( theObject, DataTag_GeometryObject );
 303
 304   // Indicate model of the need to update splitting
 305   SetToUpdate( true );
 306
 307   return true;
 308 }
 309
 310 HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetGeometryObjects() const
 311 {
 312   return GetReferenceObjects( DataTag_GeometryObject );
 313 }
 314
 315 void HYDROData_CalculationCase::RemoveGeometryObject( const Handle(HYDROData_Object)& theObject )
 316 {
 317   if ( theObject.IsNull() )
 318     return;
 319
 320   RemoveReferenceObject( theObject->Label(), DataTag_GeometryObject );
 321
 322   // Indicate model of the need to update splitting
 323   SetToUpdate( true );
 324 }
 325
 326 void HYDROData_CalculationCase::RemoveGeometryObjects()
 327 {
 328   ClearReferenceObjects( DataTag_GeometryObject );
 329
 330   // Indicate model of the need to update splitting
 331   SetToUpdate( true );
 332 }
 333
 334 bool HYDROData_CalculationCase::AddGeometryGroup( const Handle(HYDROData_ShapesGroup)& theGroup )
 335 {
 336   if ( theGroup.IsNull() )
 337     return false;
 338
 339   if ( HasReference( theGroup, DataTag_GeometryGroup ) )
 340     return false; // Object is already in reference list
 341
 342   AddReferenceObject( theGroup, DataTag_GeometryGroup );
 343
 344   // Indicate model of the need to update splitting
 345   SetToUpdate( true );
 346
 347   return true;
 348 }
 349
 350 HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetGeometryGroups() const
 351 {
 352   return GetReferenceObjects( DataTag_GeometryGroup );
 353 }
 354
 355 void HYDROData_CalculationCase::RemoveGeometryGroup( const Handle(HYDROData_ShapesGroup)& theGroup )
 356 {
 357   if ( theGroup.IsNull() )
 358     return;
 359
 360   RemoveReferenceObject( theGroup->Label(), DataTag_GeometryGroup );
 361
 362   // Indicate model of the need to update splitting
 363   SetToUpdate( true );
 364 }
 365
 366 void HYDROData_CalculationCase::RemoveGeometryGroups()
 367 {
 368   ClearReferenceObjects( DataTag_GeometryGroup );
 369
 370   // Indicate model of the need to update splitting
 371   SetToUpdate( true );
 372 }
 373
 374 void HYDROData_CalculationCase::SetBoundaryPolyline( const Handle(HYDROData_PolylineXY)& thePolyline )
 375 {
 376   Handle(HYDROData_PolylineXY) aPrevPolyline = GetBoundaryPolyline();
 377
 378   SetReferenceObject( thePolyline, DataTag_Polyline );
 379
 380   // Indicate model of the need to update zones splitting
 381   SetToUpdate( !IsEqual( aPrevPolyline, thePolyline ) || IsMustBeUpdated() );
 382 }
 383
 384 Handle(HYDROData_PolylineXY) HYDROData_CalculationCase::GetBoundaryPolyline() const
 385 {
 386   return Handle(HYDROData_PolylineXY)::DownCast(
 387            GetReferenceObject( DataTag_Polyline ) );
 388 }
 389
 390 void HYDROData_CalculationCase::RemoveBoundaryPolyline()
 391 {
 392   Handle(HYDROData_PolylineXY) aPrevPolyline = GetBoundaryPolyline();
 393
 394   ClearReferenceObjects( DataTag_Polyline );
 395
 396   // Indicate model of the need to update zones splitting
 397   SetToUpdate( !aPrevPolyline.IsNull() || IsMustBeUpdated() );
 398 }
 399
 400 Handle(HYDROData_Region) HYDROData_CalculationCase::AddNewRegion( const Handle(HYDROData_Zone)& theZone )
 401 {
 402   Handle(HYDROData_Region) aNewRegion = addNewRegion();
 403   if ( aNewRegion.IsNull() )
 404     return aNewRegion;
 405
 406   // Generate new name for new region
 407   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
 408   if ( !aDocument.IsNull() )
 409   {
 410     QString aRegsPref = CALCULATION_REGIONS_PREF;
 411
 412     QString aNewRegionName = HYDROData_Tool::GenerateObjectName( aDocument, aRegsPref );
 413     aNewRegion->SetName( aNewRegionName );
 414   }
 415
 416   aNewRegion->AddZone( theZone );
 417
 418   return aNewRegion;
 419 }
 420
 421 bool HYDROData_CalculationCase::AddRegion( const Handle(HYDROData_Region)& theRegion )
 422 {
 423   if ( theRegion.IsNull() )
 424     return false;
 425
 426   if ( HasReference( theRegion, DataTag_Region ) )
 427     return false; // Object is already in reference list
 428
 429   // Move the region from other calculation
 430   Handle(HYDROData_CalculationCase) aFatherCalc =
 431     Handle(HYDROData_CalculationCase)::DownCast( theRegion->GetFatherObject() );
 432   if ( !aFatherCalc.IsNull() && aFatherCalc->Label() != myLab )
 433   {
 434     Handle(HYDROData_Region) aNewRegion = addNewRegion();
 435     theRegion->CopyTo( aNewRegion );
 436
 437     aFatherCalc->RemoveRegion( theRegion );
 438
 439     theRegion->SetLabel( aNewRegion->Label() );
 440   }
 441   else
 442   {
 443     AddReferenceObject( theRegion, DataTag_Region );
 444   }
 445
 446   return true;
 447 }
 448
 449 HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetRegions() const
 450 {
 451   return GetReferenceObjects( DataTag_Region );
 452 }
 453
 454 void HYDROData_CalculationCase::UpdateRegionsOrder()
 455 {
 456   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
 457   if ( aDocument.IsNull() )
 458     return;
 459
 460   HYDROData_SequenceOfObjects aRegions = GetRegions();
 461
 462   HYDROData_SequenceOfObjects::Iterator anIter( aRegions );
 463   for ( ; anIter.More(); anIter.Next() )
 464   {
 465     Handle(HYDROData_Region) aRegion =
 466       Handle(HYDROData_Region)::DownCast( anIter.Value() );
 467     if ( aRegion.IsNull() )
 468       continue;
 469
 470     aRegion->SetName( "" );
 471   }
 472
 473   QString aRegsPref = CALCULATION_REGIONS_PREF;
 474
 475   anIter.Init( aRegions );
 476   for ( ; anIter.More(); anIter.Next() )
 477   {
 478     Handle(HYDROData_Region) aRegion =
 479       Handle(HYDROData_Region)::DownCast( anIter.Value() );
 480     if ( aRegion.IsNull() )
 481       continue;
 482
 483     QString aRegionName = HYDROData_Tool::GenerateObjectName( aDocument, aRegsPref );
 484     aRegion->SetName( aRegionName );
 485   }
 486 }
 487
 488 void HYDROData_CalculationCase::RemoveRegion( const Handle(HYDROData_Region)& theRegion )
 489 {
 490   if ( theRegion.IsNull() )
 491     return;
 492
 493   RemoveReferenceObject( theRegion->Label(), DataTag_Region );
 494
 495   // Remove region from data model
 496   Handle(HYDROData_CalculationCase) aFatherCalc =
 497     Handle(HYDROData_CalculationCase)::DownCast( theRegion->GetFatherObject() );
 498   if ( !aFatherCalc.IsNull() && aFatherCalc->Label() == myLab )
 499     theRegion->Remove();
 500 }
 501
 502 void HYDROData_CalculationCase::RemoveRegions()
 503 {
 504   myLab.FindChild( DataTag_ChildRegion ).ForgetAllAttributes();
 505 }
 506
 507 HYDROData_SequenceOfObjects HYDROData_CalculationCase::GetSplittedGroups() const
 508 {
 509   return GetReferenceObjects( DataTag_SplittedGroups );
 510 }
 511
 512 void HYDROData_CalculationCase::RemoveSplittedGroups()
 513 {
 514   myLab.FindChild( DataTag_SplittedGroups ).ForgetAllAttributes();
 515 }
 516
 517 double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY& thePoint ) const
 518 {
 519   double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude();
 520
 521   Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint );
 522   if ( aZone.IsNull() )
 523     return aResAltitude;
 524
 525   HYDROData_Zone::MergeAltitudesType aZoneMergeType = aZone->GetMergeType();
 526   if ( !aZone->IsMergingNeed() )
 527   {
 528     aZoneMergeType = HYDROData_Zone::Merge_UNKNOWN;
 529   }
 530   else if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN )
 531   {
 532     return aResAltitude;
 533   }
 534
 535   if ( aZoneMergeType == HYDROData_Zone::Merge_Object )
 536   {
 537     Handle(HYDROData_IAltitudeObject) aMergeAltitude = aZone->GetMergeAltitude();
 538     if ( !aMergeAltitude.IsNull() )
 539       aResAltitude = aMergeAltitude->GetAltitudeForPoint( thePoint );
 540   }
 541   else
 542   {
 543     HYDROData_SequenceOfObjects aZoneObjects = aZone->GetGeometryObjects();
 544     HYDROData_SequenceOfObjects::Iterator anIter( aZoneObjects );
 545     for ( ; anIter.More(); anIter.Next() )
 546     {
 547       Handle(HYDROData_Object) aZoneObj =
 548         Handle(HYDROData_Object)::DownCast( anIter.Value() );
 549       if ( aZoneObj.IsNull() )
 550         continue;
 551
 552       Handle(HYDROData_IAltitudeObject) anObjAltitude = aZoneObj->GetAltitudeObject();
 553       if ( anObjAltitude.IsNull() )
 554         continue;
 555
 556       double aPointAltitude = anObjAltitude->GetAltitudeForPoint( thePoint );
 557       if ( ValuesEquals( aPointAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) )
 558         continue;
 559
 560       if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN )
 561       {
 562         aResAltitude = aPointAltitude;
 563         break;
 564       }
 565       else if ( aZoneMergeType == HYDROData_Zone::Merge_ZMIN )
 566       {
 567         if ( ValuesEquals( aResAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) ||
 568              aResAltitude > aPointAltitude )
 569         {
 570           aResAltitude = aPointAltitude;
 571         }
 572       }
 573       else if ( aZoneMergeType == HYDROData_Zone::Merge_ZMAX )
 574       {
 575         if ( ValuesEquals( aResAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) ||
 576              aResAltitude < aPointAltitude )
 577         {
 578           aResAltitude = aPointAltitude;
 579         }
 580       }
 581     }
 582   }
 583
 584   return aResAltitude;
 585 }
 586
 587 Handle(HYDROData_Zone) HYDROData_CalculationCase::GetZoneFromPoint( const gp_XY& thePoint ) const
 588 {
 589   Handle(HYDROData_Zone) aResZone;
 590
 591   HYDROData_SequenceOfObjects aRegions = GetRegions();
 592
 593   HYDROData_SequenceOfObjects::Iterator anIter( aRegions );
 594   for ( ; anIter.More() && aResZone.IsNull(); anIter.Next() )
 595   {
 596     Handle(HYDROData_Region) aRegion =
 597       Handle(HYDROData_Region)::DownCast( anIter.Value() );
 598     if ( aRegion.IsNull() )
 599       continue;
 600
 601     HYDROData_SequenceOfObjects aZones = aRegion->GetZones();
 602     HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones );
 603     for ( ; aZonesIter.More() && aResZone.IsNull(); aZonesIter.Next() )
 604     {
 605       Handle(HYDROData_Zone) aRegZone =
 606         Handle(HYDROData_Zone)::DownCast( aZonesIter.Value() );
 607       if ( aRegZone.IsNull() )
 608         continue;
 609
 610       PointClassification aPointRelation = GetPointClassification( thePoint, aRegZone );
 611       if ( aPointRelation != POINT_OUT )
 612         aResZone = aRegZone; // We found the desired zone
 613     }
 614   }
 615
 616   return aResZone;
 617 }
 618
 619 HYDROData_CalculationCase::PointClassification HYDROData_CalculationCase::GetPointClassification(
 620   const gp_XY&                  thePoint,
 621   const Handle(HYDROData_Zone)& theZone ) const
 622 {
 623   PointClassification aRes = POINT_OUT;
 624   if ( theZone.IsNull() )
 625     return aRes;
 626
 627   TopoDS_Face aZoneFace = TopoDS::Face( theZone->GetShape() );
 628   if ( aZoneFace.IsNull() )
 629     return aRes;
 630
 631   TopAbs_State State = HYDROData_Tool::ComputePointState(thePoint, aZoneFace);
 632   if (State == TopAbs_OUT)
 633     aRes =  POINT_OUT;
 634   else if(State == TopAbs_IN)
 635     aRes =  POINT_IN;
 636   else if(State == TopAbs_ON)
 637     aRes =  POINT_ON;
 638   return aRes;
 639 }
 640
 641 Handle(HYDROData_Region) HYDROData_CalculationCase::addNewRegion()
 642 {
 643   TDF_Label aNewLab = myLab.FindChild( DataTag_ChildRegion ).NewChild();
 644
 645   Handle(HYDROData_Region) aNewRegion =
 646     Handle(HYDROData_Region)::DownCast( HYDROData_Iterator::CreateObject( aNewLab, KIND_REGION ) );
 647   AddRegion( aNewRegion );
 648
 649   return aNewRegion;
 650 }
 651
 652 Handle(HYDROData_SplittedShapesGroup) HYDROData_CalculationCase::addNewSplittedGroup()
 653 {
 654   TDF_Label aNewLab = myLab.FindChild( DataTag_SplittedGroups ).NewChild();
 655
 656   Handle(HYDROData_SplittedShapesGroup) aNewGroup =
 657     Handle(HYDROData_SplittedShapesGroup)::DownCast(
 658       HYDROData_Iterator::CreateObject( aNewLab, KIND_SPLITTED_GROUP ) );
 659   AddReferenceObject( aNewGroup, DataTag_SplittedGroups );
 660
 661   return aNewGroup;
 662 }
 663
 664 bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var  theGeomEngine,
 665                                         SALOMEDS::Study_ptr theStudy ) const
 666 {
 667   HYDROData_ShapesGroup::SeqOfGroupsDefs aSeqOfGroupsDefs;
 668
 669   // Get groups definitions
 670   HYDROData_SequenceOfObjects aSplittedGroups = GetSplittedGroups();
 671
 672   HYDROData_SequenceOfObjects::Iterator anIter( aSplittedGroups );
 673   for ( ; anIter.More(); anIter.Next() )
 674   {
 675     // Get shapes group
 676     Handle(HYDROData_ShapesGroup) aGroup =
 677       Handle(HYDROData_ShapesGroup)::DownCast( anIter.Value() );
 678     if ( aGroup.IsNull() )
 679       continue;
 680
 681     HYDROData_ShapesGroup::GroupDefinition aGroupDef;
 682
 683     aGroupDef.Name = aGroup->GetName().toLatin1().constData();
 684     aGroup->GetShapes( aGroupDef.Shapes );
 685
 686     aSeqOfGroupsDefs.Append( aGroupDef );
 687   }
 688
 689   // Get faces
 690   TopTools_ListOfShape aFaces;
 691   HYDROData_SequenceOfObjects aCaseRegions = GetRegions();
 692   HYDROData_SequenceOfObjects::Iterator aRegionIter( aCaseRegions );
 693   for ( ; aRegionIter.More(); aRegionIter.Next() )
 694   {
 695     Handle(HYDROData_Region) aRegion =
 696       Handle(HYDROData_Region)::DownCast( aRegionIter.Value() );
 697     if( aRegion.IsNull() )
 698       continue;
 699
 700     TopoDS_Shape aRegionShape = aRegion->GetShape( &aSeqOfGroupsDefs );
 701     aFaces.Append( aRegionShape );
 702   }
 703
 704   return Export( theGeomEngine, theStudy, aFaces, aSeqOfGroupsDefs );
 705 }
 706
 707 bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var                            theGeomEngine,
 708                                         SALOMEDS::Study_ptr                           theStudy,
 709                                         const TopTools_ListOfShape&                   theFaces,
 710                                         const HYDROData_ShapesGroup::SeqOfGroupsDefs& theGroupsDefs ) const
 711 {
 712   // Sew faces
 713   BRepBuilderAPI_Sewing aSewing( Precision::Confusion() * 10.0 );
 714   aSewing.SetNonManifoldMode( Standard_False );
 715 #ifdef DEB_CALCULATION
 716   TCollection_AsciiString aNam("Sh_");
 717   int i=1;
 718 #endif
 719   TopTools_ListIteratorOfListOfShape aFaceIter( theFaces );
 720   for ( ; aFaceIter.More(); aFaceIter.Next() )
 721   {
 722     TopoDS_Shape aShape = aFaceIter.Value();
 723     if ( aShape.IsNull() )
 724       continue;
 725
 726     if ( aShape.ShapeType() == TopAbs_FACE )
 727     {
 728       aSewing.Add( aShape );
 729 #ifdef DEB_CALCULATION
 730       TCollection_AsciiString aName = aNam + ++i + ".brep";
 731       BRepTools::Write(aShape ,aName.ToCString());
 732 #endif
 733     }
 734     else
 735     {
 736 #ifdef DEB_CALCULATION
 737       int j = 1;
 738 #endif
 739       TopExp_Explorer anExp( aShape, TopAbs_FACE );
 740       for (; anExp.More(); anExp.Next() ) {
 741         aSewing.Add( anExp.Current() );
 742 #ifdef DEB_CALCULATION
 743
 744         TCollection_AsciiString aName = aNam + i + "_" + ++j + ".brep";
 745         BRepTools::Write(anExp.Current() ,aName.ToCString());
 746 #endif
 747       }
 748     }
 749   } // faces iterator
 750
 751   aSewing.Perform();
 752   TopoDS_Shape aSewedShape = aSewing.SewedShape();
 753
 754   // If the sewed shape is empty - return false
 755   if ( aSewedShape.IsNull() || !TopoDS_Iterator( aSewedShape ).More() )
 756     return false;
 757
 758 #ifdef DEB_CALCULATION
 759   BRepTools::Write(aSewedShape ,"Sew.brep");
 760 #endif
 761   // Publish the sewed shape
 762   QString aName = EXPORT_NAME;
 763   GEOM::GEOM_Object_ptr aMainShape =
 764     publishShapeInGEOM( theGeomEngine, theStudy, aSewedShape, aName );
 765
 766   if ( aMainShape->_is_nil() )
 767     return false;
 768
 769   if ( theGroupsDefs.IsEmpty() )
 770     return true;
 771
 772   // Create groups
 773   TopTools_IndexedMapOfShape aMapOfSubShapes;
 774   TopExp::MapShapes( aSewedShape, aMapOfSubShapes );
 775
 776   NCollection_DataMap< TCollection_AsciiString, NCollection_Sequence<int> > aGroupsData;
 777
 778   for ( int aGrId = 1, nbGroups = theGroupsDefs.Length(); aGrId <= nbGroups; ++aGrId )
 779   {
 780     const HYDROData_ShapesGroup::GroupDefinition& aGroupDef = theGroupsDefs.Value( aGrId );
 781
 782     NCollection_Sequence<int> aGroupIndexes;
 783     for( int i = 1, n = aGroupDef.Shapes.Length(); i <= n; i++ )
 784     {
 785       const TopoDS_Shape& aShape = aGroupDef.Shapes.Value( i );
 786 #ifdef DEB_CALCULATION
 787       cout << "\nOld shape(" << i << ") = " << aShape.TShape() <<endl;
 788 #endif
 789       const TopoDS_Shape& aModifiedShape = aSewing.Modified( aShape );
 790       if ( aModifiedShape.IsNull() )
 791         continue;
 792
 793 #ifdef DEB_CALCULATION
 794       const TopLoc_Location& aL1 = aShape.Location();
 795       const TopLoc_Location& aL2 = aModifiedShape.Location();
 796       cout << "\nNew shape(" << i << ") = " << aModifiedShape.TShape() << " Location is Equal = " << aL1.IsEqual(aL2)<<endl;
 797 #endif
 798
 799       int anIndex = aMapOfSubShapes.FindIndex(aModifiedShape);
 800       if ( anIndex > 0 ) {
 801         aGroupIndexes.Append( anIndex );
 802       } else {
 803 #ifdef DEB_CALCULATION
 804         TCollection_AsciiString aNam("Lost_");
 805         if(!aMapOfSubShapes.Contains(aModifiedShape)) {
 806         for ( int anIndex = 1; anIndex <= aMapOfSubShapes.Extent(); anIndex++ )
 807         {
 808            const TopoDS_Shape& aS = aMapOfSubShapes.FindKey( anIndex );
 809            if ( aModifiedShape.IsPartner( aS ) )
 810            {
 811              cout <<"\nIndex in Map = " << anIndex << "TShape = " << aS.TShape() <<endl;
 812              TCollection_AsciiString aName = aNam + i + "_" + anIndex + ".brep";
 813              BRepTools::Write(aS ,aName.ToCString());
 814             break;
 815            }
 816          }
 817         }
 818 #endif
 819       }
 820     }
 821     if ( !aGroupIndexes.IsEmpty() )
 822       aGroupsData.Bind( aGroupDef.Name, aGroupIndexes );
 823   }
 824
 825   if ( !aGroupsData.IsEmpty() )
 826   {
 827     GEOM::GEOM_IGroupOperations_var aGroupOp =
 828       theGeomEngine->GetIGroupOperations( theStudy->StudyId() );
 829
 830     NCollection_DataMap< TCollection_AsciiString, NCollection_Sequence<int> >::Iterator aMapIt( aGroupsData );
 831     for ( ; aMapIt.More(); aMapIt.Next() )
 832     {
 833       const TCollection_AsciiString& aGroupName = aMapIt.Key();
 834       const NCollection_Sequence<int>& aGroupIndexes = aMapIt.Value();
 835
 836       GEOM::GEOM_Object_var aGeomGroup = aGroupOp->CreateGroup( aMainShape, TopAbs_EDGE );
 837       if ( CORBA::is_nil( aGeomGroup ) || !aGroupOp->IsDone() )
 838         continue;
 839
 840       GEOM::ListOfLong_var aGeomIndexes = new GEOM::ListOfLong;
 841       aGeomIndexes->length( aGroupIndexes.Length() );
 842
 843       for( int i = 1, n = aGroupIndexes.Length(); i <= n; i++ )
 844         aGeomIndexes[ i - 1 ] = aGroupIndexes.Value( i );
 845
 846       aGroupOp->UnionIDs( aGeomGroup, aGeomIndexes );
 847       if ( aGroupOp->IsDone() )
 848       {
 849         SALOMEDS::SObject_var aGroupSO =
 850           theGeomEngine->AddInStudy( theStudy, aGeomGroup, aGroupName.ToCString(), aMainShape );
 851       }
 852     }
 853   }
 854
 855   return true;
 856 }
 857
 858 GEOM::GEOM_Object_ptr HYDROData_CalculationCase::publishShapeInGEOM(
 859   GEOM::GEOM_Gen_var theGeomEngine, SALOMEDS::Study_ptr theStudy,
 860   const TopoDS_Shape& theShape, const QString& theName ) const
 861 {
 862   GEOM::GEOM_Object_var aGeomObj;
 863
 864   if ( theGeomEngine->_is_nil() || theStudy->_is_nil() ||
 865        theShape.IsNull() ) {
 866     return aGeomObj._retn();
 867   }
 868
 869   std::ostringstream aStreamShape;
 870   // Write TopoDS_Shape in ASCII format to the stream
 871   BRepTools::Write( theShape, aStreamShape );
 872   // Returns the number of bytes that have been stored in the stream's buffer.
 873   int aSize = aStreamShape.str().size();
 874   // Allocate octect buffer of required size
 875   CORBA::Octet* anOctetBuf = SALOMEDS::TMPFile::allocbuf( aSize );
 876   // Copy ostrstream content to the octect buffer
 877   memcpy( anOctetBuf, aStreamShape.str().c_str(), aSize );
 878   // Create TMPFile
 879   SALOMEDS::TMPFile_var aSeqFile = new SALOMEDS::TMPFile( aSize, aSize, anOctetBuf, 1 );
 880
 881   // Restore shape from the stream and get the GEOM object
 882   GEOM::GEOM_IInsertOperations_var anInsOp = theGeomEngine->GetIInsertOperations( theStudy->StudyId() );
 883   aGeomObj = anInsOp->RestoreShape( aSeqFile );
 884
 885   // Puplish the GEOM object
 886   if ( !aGeomObj->_is_nil() ) {
 887     QString aName = GEOMBase::GetDefaultName( theName );
 888
 889     SALOMEDS::SObject_var aResultSO =
 890       theGeomEngine->PublishInStudy( theStudy, SALOMEDS::SObject::_nil(),
 891                                      aGeomObj, qPrintable( aName ) );
 892     if ( aResultSO->_is_nil() ) {
 893       aGeomObj = GEOM::GEOM_Object::_nil();
 894     }
 895   }
 896
 897   return aGeomObj._retn();
 898  }