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 =
 254           Handle(HYDROData_Object)::DownCast( aDocument->FindObjectByName( 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   Handle(HYDROData_Zone) aZone = GetZoneFromPoint( thePoint );
 520   return GetAltitudeForPoint( thePoint, aZone );
 521 }
 522
 523 double HYDROData_CalculationCase::GetAltitudeForPoint( const gp_XY&                  thePoint,
 524                                                        const Handle(HYDROData_Zone)& theZone ) const
 525 {
 526   double aResAltitude = HYDROData_IAltitudeObject::GetInvalidAltitude();
 527   if ( theZone.IsNull() )
 528     return aResAltitude;
 529
 530   HYDROData_Zone::MergeAltitudesType aZoneMergeType = theZone->GetMergeType();
 531   if ( !theZone->IsMergingNeed() )
 532   {
 533     aZoneMergeType = HYDROData_Zone::Merge_UNKNOWN;
 534   }
 535   else if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN )
 536   {
 537     return aResAltitude;
 538   }
 539
 540   if ( aZoneMergeType == HYDROData_Zone::Merge_Object )
 541   {
 542     Handle(HYDROData_IAltitudeObject) aMergeAltitude = theZone->GetMergeAltitude();
 543     if ( !aMergeAltitude.IsNull() )
 544       aResAltitude = aMergeAltitude->GetAltitudeForPoint( thePoint );
 545   }
 546   else
 547   {
 548     HYDROData_SequenceOfObjects aZoneObjects = theZone->GetGeometryObjects();
 549     HYDROData_SequenceOfObjects::Iterator anIter( aZoneObjects );
 550     for ( ; anIter.More(); anIter.Next() )
 551     {
 552       Handle(HYDROData_Object) aZoneObj =
 553         Handle(HYDROData_Object)::DownCast( anIter.Value() );
 554       if ( aZoneObj.IsNull() )
 555         continue;
 556
 557       Handle(HYDROData_IAltitudeObject) anObjAltitude = aZoneObj->GetAltitudeObject();
 558       if ( anObjAltitude.IsNull() )
 559         continue;
 560
 561       double aPointAltitude = anObjAltitude->GetAltitudeForPoint( thePoint );
 562       if ( ValuesEquals( aPointAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) )
 563         continue;
 564
 565       if ( aZoneMergeType == HYDROData_Zone::Merge_UNKNOWN )
 566       {
 567         aResAltitude = aPointAltitude;
 568         break;
 569       }
 570       else if ( aZoneMergeType == HYDROData_Zone::Merge_ZMIN )
 571       {
 572         if ( ValuesEquals( aResAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) ||
 573              aResAltitude > aPointAltitude )
 574         {
 575           aResAltitude = aPointAltitude;
 576         }
 577       }
 578       else if ( aZoneMergeType == HYDROData_Zone::Merge_ZMAX )
 579       {
 580         if ( ValuesEquals( aResAltitude, HYDROData_IAltitudeObject::GetInvalidAltitude() ) ||
 581              aResAltitude < aPointAltitude )
 582         {
 583           aResAltitude = aPointAltitude;
 584         }
 585       }
 586     }
 587   }
 588
 589   return aResAltitude;
 590 }
 591
 592 NCollection_Sequence<double> HYDROData_CalculationCase::GetAltitudesForPoints(
 593   const NCollection_Sequence<gp_XY>& thePoints,
 594   const Handle(HYDROData_Zone)&      theZone ) const
 595 {
 596   NCollection_Sequence<double> aResSeq;
 597
 598   for ( int i = 1, n = thePoints.Length(); i <= n; ++i )
 599   {
 600     const gp_XY& thePnt = thePoints.Value( i );
 601
 602     double anAltitude = GetAltitudeForPoint( thePnt, theZone );
 603     aResSeq.Append( anAltitude );
 604   }
 605
 606   return aResSeq;
 607 }
 608
 609 Handle(HYDROData_Zone) HYDROData_CalculationCase::GetZoneFromPoint( const gp_XY& thePoint ) const
 610 {
 611   Handle(HYDROData_Zone) aResZone;
 612
 613   HYDROData_SequenceOfObjects aRegions = GetRegions();
 614
 615   HYDROData_SequenceOfObjects::Iterator anIter( aRegions );
 616   for ( ; anIter.More() && aResZone.IsNull(); anIter.Next() )
 617   {
 618     Handle(HYDROData_Region) aRegion =
 619       Handle(HYDROData_Region)::DownCast( anIter.Value() );
 620     if ( aRegion.IsNull() )
 621       continue;
 622
 623     HYDROData_SequenceOfObjects aZones = aRegion->GetZones();
 624     HYDROData_SequenceOfObjects::Iterator aZonesIter( aZones );
 625     for ( ; aZonesIter.More() && aResZone.IsNull(); aZonesIter.Next() )
 626     {
 627       Handle(HYDROData_Zone) aRegZone =
 628         Handle(HYDROData_Zone)::DownCast( aZonesIter.Value() );
 629       if ( aRegZone.IsNull() )
 630         continue;
 631
 632       PointClassification aPointRelation = GetPointClassification( thePoint, aRegZone );
 633       if ( aPointRelation != POINT_OUT )
 634         aResZone = aRegZone; // We found the desired zone
 635     }
 636   }
 637
 638   return aResZone;
 639 }
 640
 641 HYDROData_CalculationCase::PointClassification HYDROData_CalculationCase::GetPointClassification(
 642   const gp_XY&                  thePoint,
 643   const Handle(HYDROData_Zone)& theZone ) const
 644 {
 645   PointClassification aRes = POINT_OUT;
 646   if ( theZone.IsNull() )
 647     return aRes;
 648
 649   TopoDS_Face aZoneFace = TopoDS::Face( theZone->GetShape() );
 650   if ( aZoneFace.IsNull() )
 651     return aRes;
 652
 653   TopAbs_State State = HYDROData_Tool::ComputePointState(thePoint, aZoneFace);
 654   if (State == TopAbs_OUT)
 655     aRes =  POINT_OUT;
 656   else if(State == TopAbs_IN)
 657     aRes =  POINT_IN;
 658   else if(State == TopAbs_ON)
 659     aRes =  POINT_ON;
 660   return aRes;
 661 }
 662
 663 Handle(HYDROData_Region) HYDROData_CalculationCase::addNewRegion()
 664 {
 665   TDF_Label aNewLab = myLab.FindChild( DataTag_ChildRegion ).NewChild();
 666
 667   Handle(HYDROData_Region) aNewRegion =
 668     Handle(HYDROData_Region)::DownCast( HYDROData_Iterator::CreateObject( aNewLab, KIND_REGION ) );
 669   AddRegion( aNewRegion );
 670
 671   return aNewRegion;
 672 }
 673
 674 Handle(HYDROData_SplittedShapesGroup) HYDROData_CalculationCase::addNewSplittedGroup()
 675 {
 676   TDF_Label aNewLab = myLab.FindChild( DataTag_SplittedGroups ).NewChild();
 677
 678   Handle(HYDROData_SplittedShapesGroup) aNewGroup =
 679     Handle(HYDROData_SplittedShapesGroup)::DownCast(
 680       HYDROData_Iterator::CreateObject( aNewLab, KIND_SPLITTED_GROUP ) );
 681   AddReferenceObject( aNewGroup, DataTag_SplittedGroups );
 682
 683   return aNewGroup;
 684 }
 685
 686 bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var  theGeomEngine,
 687                                         SALOMEDS::Study_ptr theStudy ) const
 688 {
 689   HYDROData_ShapesGroup::SeqOfGroupsDefs aSeqOfGroupsDefs;
 690
 691   // Get groups definitions
 692   HYDROData_SequenceOfObjects aSplittedGroups = GetSplittedGroups();
 693
 694   HYDROData_SequenceOfObjects::Iterator anIter( aSplittedGroups );
 695   for ( ; anIter.More(); anIter.Next() )
 696   {
 697     // Get shapes group
 698     Handle(HYDROData_ShapesGroup) aGroup =
 699       Handle(HYDROData_ShapesGroup)::DownCast( anIter.Value() );
 700     if ( aGroup.IsNull() )
 701       continue;
 702
 703     HYDROData_ShapesGroup::GroupDefinition aGroupDef;
 704
 705     aGroupDef.Name = aGroup->GetName().toLatin1().constData();
 706     aGroup->GetShapes( aGroupDef.Shapes );
 707
 708     aSeqOfGroupsDefs.Append( aGroupDef );
 709   }
 710
 711   // Get faces
 712   TopTools_ListOfShape aFaces;
 713   HYDROData_SequenceOfObjects aCaseRegions = GetRegions();
 714   HYDROData_SequenceOfObjects::Iterator aRegionIter( aCaseRegions );
 715   for ( ; aRegionIter.More(); aRegionIter.Next() )
 716   {
 717     Handle(HYDROData_Region) aRegion =
 718       Handle(HYDROData_Region)::DownCast( aRegionIter.Value() );
 719     if( aRegion.IsNull() )
 720       continue;
 721
 722     TopoDS_Shape aRegionShape = aRegion->GetShape( &aSeqOfGroupsDefs );
 723     aFaces.Append( aRegionShape );
 724   }
 725
 726   return Export( theGeomEngine, theStudy, aFaces, aSeqOfGroupsDefs );
 727 }
 728
 729 bool HYDROData_CalculationCase::Export( GEOM::GEOM_Gen_var                            theGeomEngine,
 730                                         SALOMEDS::Study_ptr                           theStudy,
 731                                         const TopTools_ListOfShape&                   theFaces,
 732                                         const HYDROData_ShapesGroup::SeqOfGroupsDefs& theGroupsDefs ) const
 733 {
 734   // Sew faces
 735   BRepBuilderAPI_Sewing aSewing( Precision::Confusion() * 10.0 );
 736   aSewing.SetNonManifoldMode( Standard_False );
 737 #ifdef DEB_CALCULATION
 738   TCollection_AsciiString aNam("Sh_");
 739   int i=1;
 740 #endif
 741   TopTools_ListIteratorOfListOfShape aFaceIter( theFaces );
 742   for ( ; aFaceIter.More(); aFaceIter.Next() )
 743   {
 744     TopoDS_Shape aShape = aFaceIter.Value();
 745     if ( aShape.IsNull() )
 746       continue;
 747
 748     if ( aShape.ShapeType() == TopAbs_FACE )
 749     {
 750       aSewing.Add( aShape );
 751 #ifdef DEB_CALCULATION
 752       TCollection_AsciiString aName = aNam + ++i + ".brep";
 753       BRepTools::Write(aShape ,aName.ToCString());
 754 #endif
 755     }
 756     else
 757     {
 758 #ifdef DEB_CALCULATION
 759       int j = 1;
 760 #endif
 761       TopExp_Explorer anExp( aShape, TopAbs_FACE );
 762       for (; anExp.More(); anExp.Next() ) {
 763         aSewing.Add( anExp.Current() );
 764 #ifdef DEB_CALCULATION
 765
 766         TCollection_AsciiString aName = aNam + i + "_" + ++j + ".brep";
 767         BRepTools::Write(anExp.Current() ,aName.ToCString());
 768 #endif
 769       }
 770     }
 771   } // faces iterator
 772
 773   aSewing.Perform();
 774   TopoDS_Shape aSewedShape = aSewing.SewedShape();
 775
 776   // If the sewed shape is empty - return false
 777   if ( aSewedShape.IsNull() || !TopoDS_Iterator( aSewedShape ).More() )
 778     return false;
 779
 780 #ifdef DEB_CALCULATION
 781   BRepTools::Write(aSewedShape ,"Sew.brep");
 782 #endif
 783   // Publish the sewed shape
 784   QString aName = EXPORT_NAME;
 785   GEOM::GEOM_Object_ptr aMainShape =
 786     publishShapeInGEOM( theGeomEngine, theStudy, aSewedShape, aName );
 787
 788   if ( aMainShape->_is_nil() )
 789     return false;
 790
 791   if ( theGroupsDefs.IsEmpty() )
 792     return true;
 793
 794   // Create groups
 795   TopTools_IndexedMapOfShape aMapOfSubShapes;
 796   TopExp::MapShapes( aSewedShape, aMapOfSubShapes );
 797
 798   NCollection_DataMap< TCollection_AsciiString, NCollection_Sequence<int> > aGroupsData;
 799
 800   for ( int aGrId = 1, nbGroups = theGroupsDefs.Length(); aGrId <= nbGroups; ++aGrId )
 801   {
 802     const HYDROData_ShapesGroup::GroupDefinition& aGroupDef = theGroupsDefs.Value( aGrId );
 803
 804     NCollection_Sequence<int> aGroupIndexes;
 805     for( int i = 1, n = aGroupDef.Shapes.Length(); i <= n; i++ )
 806     {
 807       const TopoDS_Shape& aShape = aGroupDef.Shapes.Value( i );
 808 #ifdef DEB_CALCULATION
 809       cout << "\nOld shape(" << i << ") = " << aShape.TShape() <<endl;
 810 #endif
 811       const TopoDS_Shape& aModifiedShape = aSewing.Modified( aShape );
 812       if ( aModifiedShape.IsNull() )
 813         continue;
 814
 815 #ifdef DEB_CALCULATION
 816       const TopLoc_Location& aL1 = aShape.Location();
 817       const TopLoc_Location& aL2 = aModifiedShape.Location();
 818       cout << "\nNew shape(" << i << ") = " << aModifiedShape.TShape() << " Location is Equal = " << aL1.IsEqual(aL2)<<endl;
 819 #endif
 820
 821       int anIndex = aMapOfSubShapes.FindIndex(aModifiedShape);
 822       if ( anIndex > 0 ) {
 823         aGroupIndexes.Append( anIndex );
 824       } else {
 825 #ifdef DEB_CALCULATION
 826         TCollection_AsciiString aNam("Lost_");
 827         if(!aMapOfSubShapes.Contains(aModifiedShape)) {
 828         for ( int anIndex = 1; anIndex <= aMapOfSubShapes.Extent(); anIndex++ )
 829         {
 830            const TopoDS_Shape& aS = aMapOfSubShapes.FindKey( anIndex );
 831            if ( aModifiedShape.IsPartner( aS ) )
 832            {
 833              cout <<"\nIndex in Map = " << anIndex << "TShape = " << aS.TShape() <<endl;
 834              TCollection_AsciiString aName = aNam + i + "_" + anIndex + ".brep";
 835              BRepTools::Write(aS ,aName.ToCString());
 836             break;
 837            }
 838          }
 839         }
 840 #endif
 841       }
 842     }
 843     if ( !aGroupIndexes.IsEmpty() )
 844       aGroupsData.Bind( aGroupDef.Name, aGroupIndexes );
 845   }
 846
 847   if ( !aGroupsData.IsEmpty() )
 848   {
 849     GEOM::GEOM_IGroupOperations_var aGroupOp =
 850       theGeomEngine->GetIGroupOperations( theStudy->StudyId() );
 851
 852     NCollection_DataMap< TCollection_AsciiString, NCollection_Sequence<int> >::Iterator aMapIt( aGroupsData );
 853     for ( ; aMapIt.More(); aMapIt.Next() )
 854     {
 855       const TCollection_AsciiString& aGroupName = aMapIt.Key();
 856       const NCollection_Sequence<int>& aGroupIndexes = aMapIt.Value();
 857
 858       GEOM::GEOM_Object_var aGeomGroup = aGroupOp->CreateGroup( aMainShape, TopAbs_EDGE );
 859       if ( CORBA::is_nil( aGeomGroup ) || !aGroupOp->IsDone() )
 860         continue;
 861
 862       GEOM::ListOfLong_var aGeomIndexes = new GEOM::ListOfLong;
 863       aGeomIndexes->length( aGroupIndexes.Length() );
 864
 865       for( int i = 1, n = aGroupIndexes.Length(); i <= n; i++ )
 866         aGeomIndexes[ i - 1 ] = aGroupIndexes.Value( i );
 867
 868       aGroupOp->UnionIDs( aGeomGroup, aGeomIndexes );
 869       if ( aGroupOp->IsDone() )
 870       {
 871         SALOMEDS::SObject_var aGroupSO =
 872           theGeomEngine->AddInStudy( theStudy, aGeomGroup, aGroupName.ToCString(), aMainShape );
 873       }
 874     }
 875   }
 876
 877   return true;
 878 }
 879
 880 GEOM::GEOM_Object_ptr HYDROData_CalculationCase::publishShapeInGEOM(
 881   GEOM::GEOM_Gen_var theGeomEngine, SALOMEDS::Study_ptr theStudy,
 882   const TopoDS_Shape& theShape, const QString& theName ) const
 883 {
 884   GEOM::GEOM_Object_var aGeomObj;
 885
 886   if ( theGeomEngine->_is_nil() || theStudy->_is_nil() ||
 887        theShape.IsNull() ) {
 888     return aGeomObj._retn();
 889   }
 890
 891   std::ostringstream aStreamShape;
 892   // Write TopoDS_Shape in ASCII format to the stream
 893   BRepTools::Write( theShape, aStreamShape );
 894   // Returns the number of bytes that have been stored in the stream's buffer.
 895   int aSize = aStreamShape.str().size();
 896   // Allocate octect buffer of required size
 897   CORBA::Octet* anOctetBuf = SALOMEDS::TMPFile::allocbuf( aSize );
 898   // Copy ostrstream content to the octect buffer
 899   memcpy( anOctetBuf, aStreamShape.str().c_str(), aSize );
 900   // Create TMPFile
 901   SALOMEDS::TMPFile_var aSeqFile = new SALOMEDS::TMPFile( aSize, aSize, anOctetBuf, 1 );
 902
 903   // Restore shape from the stream and get the GEOM object
 904   GEOM::GEOM_IInsertOperations_var anInsOp = theGeomEngine->GetIInsertOperations( theStudy->StudyId() );
 905   aGeomObj = anInsOp->RestoreShape( aSeqFile );
 906
 907   // Puplish the GEOM object
 908   if ( !aGeomObj->_is_nil() ) {
 909     QString aName = GEOMBase::GetDefaultName( theName );
 910
 911     SALOMEDS::SObject_var aResultSO =
 912       theGeomEngine->PublishInStudy( theStudy, SALOMEDS::SObject::_nil(),
 913                                      aGeomObj, qPrintable( aName ) );
 914     if ( aResultSO->_is_nil() ) {
 915       aGeomObj = GEOM::GEOM_Object::_nil();
 916     }
 917   }
 918
 919   return aGeomObj._retn();
 920  }