src/HYDROData/HYDROData_Stream.cxx

   1 // Copyright (C) 2014-2015  EDF-R&D
   2 // This library is free software; you can redistribute it and/or
   3 // modify it under the terms of the GNU Lesser General Public
   4 // License as published by the Free Software Foundation; either
   5 // version 2.1 of the License, or (at your option) any later version.
   6 //
   7 // This library is distributed in the hope that it will be useful,
   8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  10 // Lesser General Public License for more details.
  11 //
  12 // You should have received a copy of the GNU Lesser General Public
  13 // License along with this library; if not, write to the Free Software
  14 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  15 //
  16 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  17 //
  18
  19 #include "HYDROData_Stream.h"
  20
  21 #include "HYDROData_Document.h"
  22 #include "HYDROData_PolylineXY.h"
  23 #include "HYDROData_Polyline3D.h"
  24 #include "HYDROData_Profile.h"
  25 #include "HYDROData_ShapesGroup.h"
  26 #include "HYDROData_ShapesTool.h"
  27 #include "HYDROData_IAltitudeObject.h"
  28 #include "HYDROData_IProfilesInterpolator.h"
  29 #include "HYDROData_Tool.h"
  30 #include "HYDROData_DTM.h"
  31 #include <HYDROData_Bathymetry.h>
  32
  33 #include <TDataStd_RealArray.hxx>
  34
  35 #include <Precision.hxx>
  36
  37 #include <NCollection_DataMap.hxx>
  38
  39 #include <TColStd_Array1OfReal.hxx>
  40 #include <TColStd_ListOfReal.hxx>
  41 #include <TColStd_ListIteratorOfListOfReal.hxx>
  42 #include <TColgp_Array1OfPnt.hxx>
  43 #include <TColgp_HArray1OfPnt.hxx>
  44
  45 #include <TopoDS.hxx>
  46 #include <TopoDS_Wire.hxx>
  47 #include <TopoDS_Shell.hxx>
  48 #include <TopoDS_Face.hxx>
  49 #include <TopoDS_Edge.hxx>
  50 #include <TopoDS_Vertex.hxx>
  51 #include <TopExp.hxx>
  52 #include <TopExp_Explorer.hxx>
  53
  54 #include <Bnd_Box.hxx>
  55
  56 #include <BRep_Builder.hxx>
  57 #include <BRepBuilderAPI_MakeEdge.hxx>
  58 #include <BRepBuilderAPI_MakeWire.hxx>
  59 #include <BRepBuilderAPI_MakeFace.hxx>
  60
  61 #include <BRepBndLib.hxx>
  62 #include <BRepProj_Projection.hxx>
  63 #include <BRepExtrema_ExtCC.hxx>
  64 #include <BRepCheck_Analyzer.hxx>
  65
  66 #include <gp.hxx>
  67 #include <gp_Ax1.hxx>
  68 #include <gp_Ax2.hxx>
  69 #include <gp_Ax3.hxx>
  70 #include <gp_Vec.hxx>
  71 #include <gp_Pnt.hxx>
  72 #include <gp_Pln.hxx>
  73
  74 #include <GeomAPI_Interpolate.hxx>
  75 #include <Geom_BSplineCurve.hxx>
  76
  77 #include <TopTools_HArray1OfShape.hxx>
  78 #include <TopTools_IndexedMapOfOrientedShape.hxx>
  79 #include <TopTools_ListIteratorOfListOfShape.hxx>
  80 #include <TopTools_SequenceOfShape.hxx>
  81 #include <TopTools_IndexedMapOfShape.hxx>
  82
  83 #include <QColor>
  84 #include <QStringList>
  85 #include <QVector>
  86
  87 //#define DEB_STREAM 1
  88 #ifdef DEB_STREAM
  89 //#define DEB_HASINT 1
  90 //#define DEB_UPDATE 1
  91 #include <BRepTools.hxx>
  92 #include <TCollection_AsciiString.hxx>
  93 #endif
  94
  95 #define _DEVDEBUG_
  96 #include "HYDRO_trace.hxx"
  97
  98 #include <assert.h>
  99
 100 typedef NCollection_DataMap<Standard_Real, Handle(HYDROData_Profile)> HYDROData_DataMapOfRealOfHDProfile;
 101
 102 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Stream,HYDROData_NaturalObject)
 103
 104
 105 HYDROData_Stream::HYDROData_Stream()
 106 : HYDROData_NaturalObject( Geom_3d )
 107 {
 108 }
 109
 110 HYDROData_Stream::~HYDROData_Stream()
 111 {
 112 }
 113
 114 QStringList HYDROData_Stream::DumpToPython( const QString&       thePyScriptPath,
 115                                             MapOfTreatedObjects& theTreatedObjects ) const
 116 {
 117   QStringList aResList = dumpObjectCreation( theTreatedObjects );
 118   QString aName = GetObjPyName();
 119
 120   Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
 121   setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aHydAxis, "SetHydraulicAxis" );
 122
 123   HYDROData_SequenceOfObjects aSeqOfProfiles = GetProfiles();
 124   for ( int i = 1, aNb = aSeqOfProfiles.Size(); i <= aNb; ++i )
 125   {
 126     const Handle(HYDROData_Entity) aProfile = aSeqOfProfiles.Value( i );
 127     setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aProfile, "AddProfile" );
 128   }
 129
 130   // Set bottom polyline if exists
 131   const Handle(HYDROData_Polyline3D) aBottomPolyline = GetBottomPolyline();
 132   if ( !aBottomPolyline.IsNull() ) {
 133     setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aBottomPolyline, "SetBottomPolyline" );
 134   }
 135
 136   QString aDDZs = QString::number( GetDDZ(), 'f', 3 );
 137   QString aSSteps = QString::number( GetSpatialStep(), 'f', 3 );
 138   aResList << QString( "%1.SetDDZ( %2 )" ).arg( aName ).arg( aDDZs );
 139   aResList << QString( "%1.SetSpatialStep( %2 )" ).arg( aName ).arg( aSSteps );
 140
 141   aResList << QString( "" );
 142   aResList << QString( "%1.Update()" ).arg( aName );
 143   aResList << QString( "" );
 144
 145   return aResList;
 146 }
 147
 148 HYDROData_SequenceOfObjects HYDROData_Stream::GetAllReferenceObjects() const
 149 {
 150   HYDROData_SequenceOfObjects aResSeq = HYDROData_Object::GetAllReferenceObjects();
 151
 152   Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
 153   if ( !aHydAxis.IsNull() )
 154     aResSeq.Append( aHydAxis );
 155
 156   HYDROData_SequenceOfObjects aSeqOfProfiles = GetProfiles();
 157   aResSeq.Append( aSeqOfProfiles );
 158
 159   return aResSeq;
 160 }
 161
 162 Handle(Geom_BSplineCurve) HYDROData_Stream::buildInterpolationCurve(
 163   const Handle(TColgp_HArray1OfPnt)& theArrayOfPnt )
 164 {
 165   Handle(Geom_BSplineCurve) aBSpline;
 166   GeomAPI_Interpolate anInterpolator (theArrayOfPnt, Standard_False, 1.0e-5);
 167   anInterpolator.Perform() ;
 168   if (anInterpolator.IsDone())
 169     aBSpline = anInterpolator.Curve();
 170   return aBSpline;
 171 }
 172
 173 void HYDROData_Stream::Update()
 174 {
 175   if (!GetHydraulicAxis().IsNull())
 176     updateProfilesOrder();
 177
 178   // Update bottom polyline if exists
 179   const Handle(HYDROData_Polyline3D) aBottomPolyline = GetBottomPolyline();
 180   if ( !aBottomPolyline.IsNull() ) {
 181     if ( GenerateBottomPolyline() ) {
 182       Handle(HYDROData_PolylineXY) aPolylineXY = aBottomPolyline->GetPolylineXY();
 183       if ( !aPolylineXY.IsNull() ) {
 184         aPolylineXY->Update();
 185       }
 186       aBottomPolyline->Update();
 187     }
 188   }
 189
 190   Handle(HYDROData_DTM) dtm = DTM();
 191   dtm->Update();
 192   UpdatePrs( dtm );
 193
 194   HYDROData_NaturalObject::Update();
 195 }
 196
 197 bool HYDROData_Stream::IsHas2dPrs() const
 198 {
 199   return true;
 200 }
 201
 202 bool HYDROData_Stream::CreatePresentations( const Handle(HYDROData_DTM)& theDTM,
 203                                             PrsDefinition&              thePrs )
 204 {
 205   if ( theDTM.IsNull() )
 206     return false;
 207
 208   HYDROData_SequenceOfObjects profiles = theDTM->GetProfiles();
 209   if( profiles.Length() < 2 )
 210     return false;
 211
 212   TopoDS_Shape Out3dPres;
 213   TopoDS_Shape Out2dPres;
 214   TopoDS_Shape OutLeftB;
 215   TopoDS_Shape OutRightB;
 216   TopoDS_Shape OutInlet;
 217   TopoDS_Shape OutOutlet;
 218
 219   theDTM->GetPresentationShapes(Out3dPres, Out2dPres, OutLeftB, OutRightB, OutInlet, OutOutlet);
 220
 221   thePrs.myInlet = OutInlet;
 222   thePrs.myOutlet = OutOutlet;
 223   thePrs.myLeftBank = OutLeftB;
 224   thePrs.myRightBank = OutRightB;
 225   thePrs.myPrs2D = Out2dPres;
 226   thePrs.myPrs3D = Out3dPres;
 227   /*std::vector<TopoDS_Wire> profiles3d;
 228   profiles3d.reserve(profiles.Length());
 229
 230   // Pre-processing
 231   HYDROData_SequenceOfObjects::Iterator anIter( profiles );
 232   for (int i=1 ; anIter.More(); anIter.Next(),i++ )
 233   {
 234     Handle(HYDROData_Profile) aProfile =
 235       Handle(HYDROData_Profile)::DownCast( anIter.Value() );
 236
 237     if ( aProfile.IsNull() )
 238       continue;
 239
 240     const TopoDS_Shape& aProfileShape = aProfile->GetShape3D();
 241     //TopExp_Explorer exp(aProfileShape, TopAbs_EDGE);
 242     profiles3d.push_back( TopoDS::Wire(aProfileShape) );
 243   }*/
 244
 245   return true;
 246 }
 247
 248 void HYDROData_Stream::UpdatePrs( const Handle(HYDROData_DTM)& theDTM )
 249 {
 250   HYDROData_NaturalObject::Update();
 251
 252   PrsDefinition aResultPrs;
 253   if ( !CreatePresentations( theDTM, aResultPrs ) )
 254     return;
 255
 256   SetShape3D( aResultPrs.myPrs3D );
 257   SetTopShape( aResultPrs.myPrs2D );
 258
 259   // Create the stream groups
 260   QString aLeftGroupName = GetName() + "_Left_Bank";
 261
 262   Handle(HYDROData_ShapesGroup) aLeftGroup = createGroupObject();
 263   aLeftGroup->SetName( aLeftGroupName );
 264   aLeftGroup->AddShape( aResultPrs.myLeftBank );
 265
 266   QString aRightGroupName = GetName() + "_Right_Bank";
 267
 268   Handle(HYDROData_ShapesGroup) aRightGroup = createGroupObject();
 269   aRightGroup->SetName( aRightGroupName );
 270   aRightGroup->AddShape( aResultPrs.myRightBank );
 271
 272   QString anInGroupName = GetName() + "_Inlet";
 273
 274   Handle(HYDROData_ShapesGroup) anInGroup = createGroupObject();
 275   anInGroup->SetName( anInGroupName );
 276   anInGroup->AddShape( aResultPrs.myInlet );
 277
 278   QString anOutGroupName = GetName() + "_Outlet";
 279
 280   Handle(HYDROData_ShapesGroup) anOutGroup = createGroupObject();
 281   anOutGroup->SetName( anOutGroupName );
 282   anOutGroup->AddShape( aResultPrs.myOutlet );
 283 }
 284
 285 QColor HYDROData_Stream::DefaultFillingColor() const
 286 {
 287   return QColor( Qt::green );
 288 }
 289
 290 QColor HYDROData_Stream::DefaultBorderColor() const
 291 {
 292   return QColor( Qt::transparent );
 293 }
 294
 295 bool HYDROData_Stream::IsValidAsAxis( const Handle(HYDROData_PolylineXY)& theHydAxis )
 296 {
 297   if ( theHydAxis.IsNull() )
 298     return true;
 299
 300   TopoDS_Shape aHydraulicShape = theHydAxis->GetShape();
 301   if ( aHydraulicShape.IsNull() ||
 302        aHydraulicShape.ShapeType() != TopAbs_WIRE ||
 303        BRep_Tool::IsClosed( aHydraulicShape ) )
 304     return false; // The polyline must be a single not closed wire
 305
 306   return true;
 307 }
 308
 309 TopoDS_Shape HYDROData_Stream::GetLeftShape() const
 310 {
 311   HYDROData_SequenceOfObjects aGroups = GetGroups();
 312   return HYDROData_Tool::getFirstShapeFromGroup( aGroups, 1);
 313 }
 314
 315 TopoDS_Shape HYDROData_Stream::GetRightShape() const
 316 {
 317   HYDROData_SequenceOfObjects aGroups = GetGroups();
 318   return HYDROData_Tool::getFirstShapeFromGroup( aGroups, 2);
 319 }
 320
 321 TopoDS_Shape HYDROData_Stream::GetInletShape() const
 322 {
 323   HYDROData_SequenceOfObjects aGroups = GetGroups();
 324   return HYDROData_Tool::getFirstShapeFromGroup( aGroups, 3);
 325 }
 326
 327 TopoDS_Shape HYDROData_Stream::GetOutletShape() const
 328 {
 329   HYDROData_SequenceOfObjects aGroups = GetGroups();
 330   return HYDROData_Tool::getFirstShapeFromGroup( aGroups, 4);
 331 }
 332
 333 Handle(HYDROData_DTM) HYDROData_Stream::DTM() const
 334 {
 335   const_cast<HYDROData_Stream*>( this )->checkAndSetAltitudeObject();
 336   return Handle(HYDROData_DTM)::DownCast( GetAltitudeObject() );
 337 }
 338
 339 double HYDROData_Stream::GetDDZ() const
 340 {
 341   return DTM()->GetDDZ();
 342 }
 343
 344 void HYDROData_Stream::SetDDZ( double theDDZ )
 345 {
 346   DTM()->SetDDZ( theDDZ );
 347   Changed( Geom_3d );
 348 }
 349
 350 double HYDROData_Stream::GetSpatialStep() const
 351 {
 352   return DTM()->GetSpatialStep();
 353 }
 354
 355 void HYDROData_Stream::SetSpatialStep( double theSpatialStep )
 356 {
 357   DTM()->SetSpatialStep( theSpatialStep );
 358   Changed( Geom_3d );
 359 }
 360
 361 bool HYDROData_Stream::SetHydraulicAxis( const Handle(HYDROData_PolylineXY)& theAxis )
 362 {
 363   if ( !IsValidAsAxis( theAxis ) )
 364     return false;
 365
 366   Handle(HYDROData_PolylineXY) aPrevAxis = GetHydraulicAxis();
 367   if ( IsEqual( aPrevAxis, theAxis ) )
 368     return true;
 369
 370   SetReferenceObject( theAxis, DataTag_HydraulicAxis );
 371
 372   // Update the order of profiles
 373   updateProfilesOrder();
 374
 375   // Indicate model of the need to update the stream presentation
 376   Changed( Geom_3d );
 377
 378   return true;
 379 }
 380
 381 Handle(HYDROData_PolylineXY) HYDROData_Stream::GetHydraulicAxis() const
 382 {
 383   return Handle(HYDROData_PolylineXY)::DownCast(
 384            GetReferenceObject( DataTag_HydraulicAxis ) );
 385 }
 386
 387 void HYDROData_Stream::RemoveHydraulicAxis()
 388 {
 389   Handle(HYDROData_PolylineXY) aPrevAxis = GetHydraulicAxis();
 390   if ( aPrevAxis.IsNull() )
 391     return;
 392
 393   ClearReferenceObjects( DataTag_HydraulicAxis );
 394
 395   // We remove the reference profiles
 396   RemoveProfiles();
 397
 398   // Indicate model of the need to update the stream presentation
 399   Changed( Geom_3d );
 400 }
 401
 402 bool HYDROData_Stream::HasIntersection( const Handle(HYDROData_Profile)& theProfile,
 403                                         const TopoDS_Face&               thePlane,
 404                                         Standard_Real&                   theOutPar ) const
 405 {
 406   Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
 407   return HasIntersection( aHydAxis, theProfile, thePlane, theOutPar );
 408 }
 409
 410 #include <BRepAlgo_NormalProjection.hxx>
 411
 412 bool HYDROData_Stream::HasIntersection( const Handle(HYDROData_PolylineXY)& theHydAxis,
 413                                         const Handle(HYDROData_Profile)&    theProfile,
 414                                         const TopoDS_Face&                  thePlane,
 415                                         Standard_Real&                      theOutPar )
 416 {
 417   if ( theProfile.IsNull() /*|| !IsValidAsAxis( theHydAxis )*/ )
 418     return false;
 419
 420   if (theHydAxis.IsNull())
 421     return true; //empty h_axis; its's OK
 422
 423   TopoDS_Wire aHydraulicWire = TopoDS::Wire( theHydAxis->GetShape() ); //guide line
 424   TopoDS_Wire aProfileWire = TopoDS::Wire( theProfile->GetTopShape() );
 425   if ( aProfileWire.IsNull() )
 426     {
 427       DEBTRACE("aProfileWire.IsNull");
 428       return false;
 429     }
 430
 431   //BRepProj_Projection aProjector (aProfileWire, thePlane, gp::OZ().Direction());
 432   BRepAlgo_NormalProjection nproj(thePlane);
 433   nproj.Add(aProfileWire);
 434   nproj.SetDefaultParams();
 435   nproj.Build();
 436   if(!nproj.IsDone())
 437     {
 438       DEBTRACE("!nproj.IsDone");
 439       return false;
 440     }
 441   TopoDS_Shape aPrjProfile = nproj.Projection();
 442   if(aPrjProfile.IsNull())
 443     {
 444       DEBTRACE("aPrjProfile.IsNull");
 445       return false;
 446     }
 447   TopoDS_Vertex aV1, aV2;
 448   if(aPrjProfile.ShapeType() == TopAbs_EDGE)
 449     TopExp::Vertices(TopoDS::Edge(aPrjProfile), aV1, aV2);
 450   else if(aPrjProfile.ShapeType() == TopAbs_WIRE)
 451     TopExp::Vertices(TopoDS::Wire(aPrjProfile), aV1, aV2);
 452   else if(aPrjProfile.ShapeType() == TopAbs_COMPOUND){
 453     TopExp_Explorer anExp(aPrjProfile, TopAbs_WIRE);
 454     if(anExp.More()) {
 455       TopExp::Vertices(TopoDS::Wire(anExp.Current()), aV1, aV2);
 456     } else {
 457       anExp.Init(aPrjProfile, TopAbs_EDGE);
 458       if(anExp.More()) {
 459         TopExp::Vertices(TopoDS::Edge(anExp.Current()), aV1, aV2);
 460       }
 461     }
 462   }
 463   if(aV1.IsNull() || aV2.IsNull())
 464     {
 465       DEBTRACE("aV1.IsNull() || aV2.IsNull()");
 466       return false;
 467     }
 468   gp_Pnt aPnt1 = BRep_Tool::Pnt(aV1);
 469   gp_Pnt aPnt2 = BRep_Tool::Pnt(aV2);
 470   aPnt1.SetZ(0.0);
 471   aPnt2.SetZ(0.0);
 472   BRepBuilderAPI_MakeEdge aMk(aPnt1, aPnt2);
 473   if(!aMk.IsDone())
 474     {
 475       DEBTRACE("!aMk.IsDone()");
 476       return false;
 477     }
 478   const TopoDS_Edge& anEdg2 = aMk.Edge();//Section edge
 479   Standard_Integer aNum(0);
 480
 481   TopExp_Explorer anExplo(aHydraulicWire, TopAbs_EDGE);
 482   for(;anExplo.More();anExplo.Next()) aNum++;
 483   // check for self-intersection
 484   const Standard_Real SquareTolerance = Precision::Confusion()*Precision::Confusion();
 485   Standard_Boolean hasInt(false);
 486   Standard_Real aSqDist(DBL_MAX);
 487   Standard_Integer anIndx(0);
 488   BRepExtrema_ExtCC aCC;
 489   aCC.Initialize(anEdg2);
 490   theOutPar = 0.0;
 491   anExplo.Init(aHydraulicWire, TopAbs_EDGE);
 492   for(Standard_Integer j=1;anExplo.More();anExplo.Next(),j++) {
 493     const TopoDS_Edge& anEdg1 = TopoDS::Edge(anExplo.Current());
 494     if(anEdg1.IsNull())
 495       continue;
 496     Standard_Boolean hasSol(false);
 497     aCC.Perform(anEdg1);
 498     if(aCC.IsDone()) {
 499     // find minimal dist
 500     for(Standard_Integer i=1; i<= aCC.NbExt();i++)
 501       if(aCC.SquareDistance(i) < aSqDist) {
 502         aSqDist = aCC.SquareDistance(i);
 503         anIndx = i;
 504         hasSol = true;
 505       }
 506     }
 507     if(hasSol) {
 508       if(aSqDist <= SquareTolerance) { // hasInt
 509         const gp_Pnt& aPnt = aCC.PointOnE1(anIndx);
 510         if(aNum > 1) {
 511           TopExp::Vertices(anEdg1, aV1, aV2, Standard_True);
 512           theOutPar += BRep_Tool::Pnt(aV1).Distance(aPnt);
 513         } else {
 514           Standard_Real aPar = aCC.ParameterOnE1(anIndx);
 515           theOutPar = aPar;
 516         }
 517         hasInt = true;
 518         break;
 519       } else {
 520           // no ints-n
 521         if(aNum > 1) {
 522           TopExp::Vertices(anEdg1, aV1, aV2);
 523           theOutPar += BRep_Tool::Pnt(aV1).Distance(BRep_Tool::Pnt(aV2));
 524         }
 525       }
 526     } else if(aNum > 1) {
 527       TopExp::Vertices(anEdg1, aV1, aV2);
 528       theOutPar += BRep_Tool::Pnt(aV1).Distance(BRep_Tool::Pnt(aV2));
 529     }
 530   }
 531   if(hasInt)
 532     return true;
 533   DEBTRACE("!hasInt " << aPnt1.X() << " " << aPnt1.Y() << " " << aPnt2.X() << " " << aPnt2.Y() << " --- " << aSqDist);
 534   return false;
 535 }
 536
 537 bool HYDROData_Stream::AddProfile( const Handle(HYDROData_Profile)& theProfile )
 538 {
 539   if ( theProfile.IsNull() )
 540     return false;
 541
 542  // Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
 543  // if ( aHydAxis.IsNull() )
 544  //   return false;
 545
 546   TopoDS_Face aPlane;
 547   BuildRefFace( aPlane );
 548
 549   Standard_Real aPar(.0);
 550   if ( HasReference( theProfile, DataTag_Profile ) || !HasIntersection( theProfile, aPlane, aPar ) )
 551     return false; // Object is already in reference list or it has no intersection
 552   //DEBTRACE("AddProfile - insertParameter " << aPar);
 553   int aProfileIndex = insertParameter( aPar );
 554   insertProfileInToOrder( theProfile, aProfileIndex );
 555
 556   DTM()->SetProfiles( GetProfiles() );
 557
 558   // Indicate model of the need to update the stream presentation
 559   Changed( Geom_3d );
 560
 561   return true;
 562 }
 563
 564 bool HYDROData_Stream::SetProfiles( const HYDROData_SequenceOfObjects& theProfiles,
 565                                     const bool&                        theIsToOrder )
 566 {
 567   DEBTRACE(" --- SetProfiles " <<theIsToOrder );
 568   if ( theIsToOrder )
 569   {
 570     for ( int i = 1; i <= theProfiles.Length(); ++i )
 571     {
 572       Handle(HYDROData_Profile) aProfile =
 573         Handle(HYDROData_Profile)::DownCast( theProfiles.Value( i ) );
 574       if ( aProfile.IsNull() )
 575         continue;
 576
 577       if ( !AddProfile( aProfile ) )
 578       {
 579         DTM()->SetProfiles( HYDROData_SequenceOfObjects() );
 580         return false;
 581       }
 582     }
 583   }
 584   else // Just store the sequence of objects as is
 585   {
 586     bool anIsToUpdate = true;
 587
 588     HYDROData_SequenceOfObjects anOldProfiles = GetProfiles();
 589     if ( anOldProfiles.Length() == theProfiles.Length() )
 590     {
 591       anIsToUpdate = false;
 592
 593       for ( int i = 1; i <= theProfiles.Length(); ++i )
 594       {
 595         Handle(HYDROData_Entity) anOldProfile = anOldProfiles.Value( i );
 596         Handle(HYDROData_Entity) aNewProfile = theProfiles.Value( i );
 597         if ( !IsEqual( anOldProfile, aNewProfile ) )
 598         {
 599           anIsToUpdate = true;
 600           break;
 601         }
 602       }
 603     }
 604
 605     SetReferenceObjects( theProfiles, DataTag_Profile );
 606
 607     if ( anIsToUpdate )
 608       Changed( Geom_3d );
 609   }
 610
 611   DTM()->SetProfiles( GetProfiles() );
 612   return true;
 613 }
 614
 615 HYDROData_SequenceOfObjects HYDROData_Stream::GetProfiles() const
 616 {
 617   return GetReferenceObjects( DataTag_Profile );
 618 }
 619
 620 bool HYDROData_Stream::RemoveProfile( const Handle(HYDROData_Profile)& theProfile )
 621 {
 622   if ( theProfile.IsNull() )
 623     return false;
 624
 625   int aProfileIndex = -1;
 626
 627   HYDROData_SequenceOfObjects aRefProfiles = GetProfiles();
 628   HYDROData_SequenceOfObjects::Iterator anIter( aRefProfiles );
 629   for ( int i = 0 ; anIter.More(); anIter.Next(), ++i )
 630   {
 631     Handle(HYDROData_Profile) aProfile =
 632       Handle(HYDROData_Profile)::DownCast( anIter.Value() );
 633     if ( aProfile.IsNull() )
 634       continue;
 635
 636     if ( IsEqual( theProfile, aProfile ) )
 637     {
 638       aProfileIndex = i;
 639       break;
 640     }
 641   }
 642
 643   if ( aProfileIndex == -1 )
 644     return false;
 645
 646   RemoveReferenceObject( theProfile->Label(), DataTag_Profile );
 647
 648   // Remove parameter for removed profile
 649   removeParameter( aProfileIndex );
 650
 651   // Indicate model of the need to update the stream presentation
 652   Changed( Geom_3d );
 653
 654   return true;
 655 }
 656
 657 void HYDROData_Stream::RemoveProfiles()
 658 {
 659   ClearReferenceObjects( DataTag_Profile );
 660
 661   // Remove the parameters array
 662   removeParametersArray();
 663
 664   // Indicate model of the need to update the stream presentation
 665   Changed( Geom_3d );
 666 }
 667
 668 void HYDROData_Stream::insertProfileInToOrder( const Handle(HYDROData_Profile)& theProfile,
 669                                                const int                        theBeforeIndex )
 670 {
 671   //Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
 672   if ( theProfile.IsNull() )
 673     return;
 674
 675   //TopoDS_Wire aHydraulicWire = TopoDS::Wire( aHydAxis->GetShape() );
 676   TopoDS_Wire aProfileWire = TopoDS::Wire( theProfile->GetTopShape() );
 677   if ( aProfileWire.IsNull() )
 678     return;
 679
 680   if ( theBeforeIndex == -1 )
 681     AddReferenceObject( theProfile, DataTag_Profile );
 682   else
 683     InsertReferenceObject( theProfile, DataTag_Profile, theBeforeIndex );
 684 }
 685
 686 void HYDROData_Stream::BuildRefFace( TopoDS_Face& thePlane )
 687 {
 688   thePlane = BRepBuilderAPI_MakeFace(gp_Pln(gp_Pnt(0,0,0),gp_Dir(0,0,1))).Face();
 689 }
 690
 691 void HYDROData_Stream::updateProfilesOrder()
 692 {
 693   HYDROData_SequenceOfObjects aRefProfiles = GetProfiles();
 694   if ( aRefProfiles.IsEmpty() )
 695     return;
 696
 697   // At first we remove all profiles from order
 698   RemoveProfiles();
 699
 700   Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
 701   if ( aHydAxis.IsNull() )
 702     return;
 703
 704   TopoDS_Face aPlane;
 705   BuildRefFace( aPlane );
 706
 707   Standard_Real aPar( .0 );
 708
 709 #ifdef DEB_HASINT
 710   BRep_Builder aBB;
 711   TopoDS_Compound aCmp;
 712   aBB.MakeCompound(aCmp);
 713 #endif
 714
 715   HYDROData_DataMapOfRealOfHDProfile aDM;
 716   TColStd_ListOfReal aList;
 717   HYDROData_SequenceOfObjects::Iterator anIter( aRefProfiles );
 718   for (int i = 1 ; anIter.More(); anIter.Next(), i++ )
 719   {
 720     Handle(HYDROData_Profile) aProfile =
 721       Handle(HYDROData_Profile)::DownCast( anIter.Value() );
 722 #ifdef DEB_HASINT
 723   TopoDS_Wire aProfileWire = TopoDS::Wire( aProfile->GetTopShape() );
 724   aBB.Add( aCmp, aProfileWire );
 725 #endif
 726     if ( aProfile.IsNull() || !HasIntersection( aProfile, aPlane, aPar ) )
 727       continue;
 728
 729     aDM.Bind( aPar, aProfile );
 730     aList.Append( aPar );
 731   }
 732
 733   if ( aList.IsEmpty() )
 734     return;
 735
 736   QVector<double> anArr( aList.Extent() );
 737
 738   TColStd_ListIteratorOfListOfReal it( aList );
 739   for ( int j = 1; it.More(); it.Next(), j++ )
 740     anArr[j-1] = it.Value();
 741
 742   // sorting
 743   if ( aList.Extent() > 1 )
 744   {
 745     //TCollection_CompareOfReal Compar;
 746     //SortTools_QuickSortOfReal::Sort( anArr, Compar );
 747     std::sort( anArr.begin(), anArr.end() );
 748
 749     for (int j = 1; j <= anArr.size(); j++) {
 750       const Standard_Real aKey =  anArr[j-1];
 751       const Handle(HYDROData_Profile)& aProfile = aDM.Find(aKey);
 752       insertProfileInToOrder( aProfile );
 753     }
 754   } else if ( aList.Extent() == 1 ) {
 755      const Standard_Real aKey = aList.Last();
 756      const Handle(HYDROData_Profile)& aProfile = aDM.Find(aKey);
 757      insertProfileInToOrder( aProfile );
 758   }
 759
 760   setParametersArray( anArr );
 761
 762 #ifdef DEB_HASINT
 763   TopoDS_Wire aHydraulicWire = TopoDS::Wire( aHydAxis->GetShape() );
 764   BRepTools::Write(aHydraulicWire, "Path.brep");
 765   BRepTools::Write(aCmp, "Prof.brep");
 766 #endif
 767 }
 768
 769 ObjectKind HYDROData_Stream::getAltitudeObjectType() const
 770 {
 771   return KIND_DTM;
 772 }
 773
 774 void HYDROData_Stream::setParametersArray( const QVector<double>& theArray )
 775 {
 776   if ( theArray.size() == 0 )
 777   {
 778     removeParametersArray();
 779     return;
 780   }
 781
 782   TDF_Label aLabel = myLab.FindChild( DataTag_ParamsArray );
 783
 784   int n = theArray.size();
 785   Handle(TDataStd_RealArray) aParamsArray =
 786     TDataStd_RealArray::Set( aLabel, 1, n );
 787   for ( int i = 0; i < n; ++i )
 788   {
 789     const Standard_Real& aParam = theArray[i];
 790     aParamsArray->SetValue( i+1, aParam );
 791   }
 792 }
 793
 794 TColStd_Array1OfReal* HYDROData_Stream::getParametersArray() const
 795 {
 796   TColStd_Array1OfReal* anArray = NULL;
 797
 798   TDF_Label aLabel = myLab.FindChild( DataTag_ParamsArray, false );
 799   if ( !aLabel.IsNull() )
 800   {
 801     Handle(TDataStd_RealArray) aParamsArray;
 802     if ( aLabel.FindAttribute( TDataStd_RealArray::GetID(), aParamsArray ) )
 803     {
 804       anArray = new TColStd_Array1OfReal( aParamsArray->Lower(), aParamsArray->Upper() );
 805       for ( int i = aParamsArray->Lower(), n = aParamsArray->Upper(); i <= n; ++i )
 806       {
 807         const Standard_Real& aParam = aParamsArray->Value( i );
 808         anArray->SetValue( i, aParam );
 809       }
 810     }
 811   }
 812
 813   return anArray;
 814 }
 815
 816 void HYDROData_Stream::removeParametersArray()
 817 {
 818   TDF_Label aLabel = myLab.FindChild( DataTag_ParamsArray, false );
 819   if ( !aLabel.IsNull() )
 820     aLabel.ForgetAllAttributes();
 821 }
 822
 823 int HYDROData_Stream::insertParameter( const Standard_Real& theParam )
 824 {
 825   int aResIndex = -1;
 826
 827   TColStd_Array1OfReal* anArr = getParametersArray();
 828   if ( anArr )
 829   {
 830     aResIndex = 0;
 831
 832     QVector<double> aNewArr( anArr->Upper() +1 );
 833     bool isInserted = false;
 834     for ( int i = anArr->Lower(), j = i, n = anArr->Upper(); i <= n; ++i, ++j )
 835     {
 836       const Standard_Real& aStoredParam = anArr->Value( i );
 837       if ( !isInserted )
 838       {
 839         if ( theParam > aStoredParam )
 840         {
 841           aResIndex++;
 842         }
 843         else
 844         {
 845           if (j<=n+1)
 846             aNewArr[j-1] = theParam;
 847           isInserted = true;
 848           ++j;
 849         }
 850       }
 851       if (j<=n+1)
 852         aNewArr[j-1] = aStoredParam;
 853     }
 854
 855     if ( !isInserted )
 856     {
 857       aResIndex = -1;
 858       aNewArr[aNewArr.size()-1] = theParam;
 859     }
 860
 861     setParametersArray( aNewArr );
 862     delete anArr;
 863   }
 864   else
 865   {
 866     QVector<double> aNewArr( 1 );
 867     aNewArr[0] = theParam;
 868     setParametersArray( aNewArr );
 869   }
 870
 871   return aResIndex;
 872 }
 873
 874 void HYDROData_Stream::removeParameter( const int& theIndex )
 875 {
 876   TDF_Label aLabel = myLab.FindChild( DataTag_ParamsArray, false );
 877   if ( aLabel.IsNull() )
 878     return;
 879
 880   Handle(TDataStd_RealArray) aParamsArray;
 881   if ( !aLabel.FindAttribute( TDataStd_RealArray::GetID(), aParamsArray ) )
 882     return;
 883
 884   if ( aParamsArray->Length() == 1 )
 885   {
 886     removeParametersArray();
 887     return;
 888   }
 889
 890   QVector<double> aNewArr( aParamsArray->Upper() - 2 );
 891
 892   for ( int i = aParamsArray->Lower(), j = i, k = 0, n = aParamsArray->Upper(); i <= n; ++i, ++k )
 893   {
 894     const Standard_Real& aStoredParam = aParamsArray->Value( i );
 895     if ( k == theIndex )
 896       continue;
 897
 898     aNewArr[j-1] = aStoredParam;
 899     ++j;
 900   }
 901
 902   setParametersArray( aNewArr );
 903 }
 904
 905 bool HYDROData_Stream::GenerateBottomPolyline()
 906 {
 907   // Get the document
 908   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
 909   if ( aDocument.IsNull() ) {
 910     return false;
 911   }
 912
 913   // Collect bottom points ( one bottom point from each profile of the stream )
 914   HYDROData_Profile::ProfilePoints aBottomPoints;
 915
 916   HYDROData_SequenceOfObjects aSeqOfProfiles = GetProfiles();
 917   for ( int i = 1, aNb = aSeqOfProfiles.Size(); i <= aNb; i++ ) {
 918     const Handle(HYDROData_Profile) aProfile =
 919       Handle(HYDROData_Profile)::DownCast( aSeqOfProfiles.Value( i ) );
 920     if ( aProfile.IsNull() ) {
 921       continue;
 922     }
 923
 924     aBottomPoints.Append( aProfile->GetBottomPoint() );
 925   }
 926
 927   int aNbBottomPoints = aBottomPoints.Size();
 928
 929   if ( aNbBottomPoints < 2 ) {
 930     return false;
 931   }
 932
 933   // Create bottom polyline object if the stream doesn't contain it yet
 934   Handle(HYDROData_Polyline3D) aBottom = GetBottomPolyline();
 935   if ( aBottom.IsNull() ) {
 936     aBottom = Handle(HYDROData_Polyline3D)::DownCast( aDocument->CreateObject( KIND_POLYLINE ) );
 937     QString aBaseName = GetName() + "_bottom";
 938     QString aName = HYDROData_Tool::GenerateObjectName( aDocument, aBaseName, QStringList(), true );
 939     aBottom->SetName( aName );
 940
 941     SetReferenceObject( aBottom, DataTag_BottomPolyline );
 942   }
 943
 944   // Create 2D polyline if the bottom polyline doesn't contain it yet
 945   Handle(HYDROData_PolylineXY) aPolylineXY = aBottom->GetPolylineXY();
 946   if ( aPolylineXY.IsNull() ) {
 947     aPolylineXY = Handle(HYDROData_PolylineXY)::DownCast( aDocument->CreateObject( KIND_POLYLINEXY ) );
 948     QString aBaseName = GetName() + "_bottom_2d";
 949     QString aName = HYDROData_Tool::GenerateObjectName( aDocument, aBaseName, QStringList(), true );
 950     aPolylineXY->SetName( aName );
 951     aBottom->SetPolylineXY( aPolylineXY, false );
 952   }
 953
 954   aPolylineXY->RemoveSections();
 955   aPolylineXY->AddSection( "", HYDROData_PolylineXY::SECTION_SPLINE, false );
 956
 957   // Create profile if the bottom polyline doesn't contain it yet
 958   Handle(HYDROData_ProfileUZ) aProfileUZ = aBottom->GetProfileUZ();
 959   if ( aProfileUZ.IsNull() ) {
 960     Handle(HYDROData_Profile) aProfile =
 961       Handle(HYDROData_Profile)::DownCast( aDocument->CreateObject( KIND_PROFILE ) );
 962     QString aBaseName = GetName() + "_bottom_profile";
 963     QString aName = HYDROData_Tool::GenerateObjectName( aDocument, aBaseName, QStringList(), true );
 964     aProfile->SetName( aName );
 965     aProfileUZ = aProfile->GetProfileUZ( true );
 966     aBottom->SetProfileUZ( aProfileUZ );
 967   }
 968
 969   aProfileUZ->RemoveSection( 0 );
 970
 971   aProfileUZ->CalculateAndAddPoints(aBottomPoints, aPolylineXY);
 972
 973   return true;
 974 }
 975
 976 Handle(HYDROData_Polyline3D) HYDROData_Stream::GetBottomPolyline() const
 977 {
 978   return Handle(HYDROData_Polyline3D)::DownCast(
 979            GetReferenceObject( DataTag_BottomPolyline ) );
 980 }
 981
 982 bool HYDROData_Stream::SetBottomPolyline( const Handle(HYDROData_Polyline3D)& theBottom )
 983 {
 984   if ( theBottom.IsNull() ) {
 985     return false;
 986   }
 987
 988   SetReferenceObject( theBottom, DataTag_BottomPolyline );
 989
 990   return true;
 991 }
 992
 993 bool HYDROData_Stream::Interpolate( HYDROData_IProfilesInterpolator* theInterpolator )
 994 {
 995   // Get the document
 996   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
 997   if ( aDocument.IsNull() ) {
 998     return false;
 999   }
1000
1001   if ( theInterpolator->GetCalculatedProfilesNumber() < 1 ) {
1002     theInterpolator->Calculate();
1003   }
1004
1005   if ( theInterpolator->GetErrorCode() != OK ) {
1006     return false;
1007   }
1008
1009   bool isOK = true;
1010
1011   for ( int aProfileInd = 0; aProfileInd < theInterpolator->GetCalculatedProfilesNumber(); aProfileInd++ ) {
1012     // Get calculated point coordinates
1013     HYDROData_Profile::ProfilePoints aResultPoints = theInterpolator->GetResultProfilePoints( aProfileInd );
1014     if ( aResultPoints.IsEmpty() ) {
1015       isOK = false;
1016       continue;
1017     }
1018
1019     // Create profile object
1020     Handle(HYDROData_Profile) aProfile =
1021       Handle(HYDROData_Profile)::DownCast( aDocument->CreateObject( KIND_PROFILE ) );
1022     QString aBaseName = GetName() + "_interp_profile";
1023     QString aName = HYDROData_Tool::GenerateObjectName( aDocument, aBaseName );
1024     aProfile->SetName( aName );
1025
1026     // Fill the profile with points
1027     aProfile->SetProfilePoints( aResultPoints );
1028
1029     // Add profile to the stream
1030     bool isAdded = AddProfile( aProfile );
1031     if ( !isAdded ) {
1032       aProfile->Remove();
1033     }
1034     else
1035       aProfile->Update();
1036   }
1037
1038   if ( isOK )
1039     Update();
1040
1041   return isOK;
1042 }
1043
1044 void HYDROData_Stream::CopyTo( const Handle(HYDROData_Entity)& theDestination,
1045                                bool isGenerateNewName ) const
1046 {
1047   // Get the document
1048   Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
1049   if ( aDocument.IsNull() ) {
1050     return;
1051   }
1052
1053   // Call base method
1054   HYDROData_Entity::CopyTo( theDestination, isGenerateNewName );
1055
1056   Handle(HYDROData_Stream) aStreamCopy =
1057     Handle(HYDROData_Stream)::DownCast( theDestination );
1058
1059   // Copy bottom polyline if exists
1060   if ( !aStreamCopy.IsNull() ) {
1061     const Handle(HYDROData_Polyline3D) aBottom = GetBottomPolyline();
1062     if ( !aBottom.IsNull() ) {
1063       aStreamCopy->ClearReferenceObjects( DataTag_BottomPolyline );
1064       aStreamCopy->GenerateBottomPolyline();
1065       const Handle(HYDROData_Polyline3D) aBottomCopy = aStreamCopy->GetBottomPolyline();
1066       if ( !aBottomCopy.IsNull() && !aBottomCopy->GetPolylineXY().IsNull() ) {
1067         aBottomCopy->GetPolylineXY()->Update();
1068         aBottomCopy->Update();
1069       }
1070     }
1071   }
1072 }
1073 void HYDROData_Stream::CreatePresentations( const Handle(TColgp_HArray1OfPnt)     theArrayOfFPnt,
1074                                             const Handle(TColgp_HArray1OfPnt)     theArrayOfLPnt,
1075                                             const Handle(TopTools_HArray1OfShape) theArrOfProfiles,
1076                                             PrsDefinition&                        thePrs )
1077 {
1078
1079   HYDROData_Bathymetry::AltitudePoints left;
1080   for (int i = theArrayOfLPnt->Lower(); i <= theArrayOfLPnt->Upper(); i++)
1081   {
1082     left.push_back(HYDROData_Bathymetry::AltitudePoint(theArrayOfLPnt->Value(i).X(),
1083       theArrayOfLPnt->Value(i).Y(),
1084       theArrayOfLPnt->Value(i).Z()));
1085   }
1086
1087   HYDROData_Bathymetry::AltitudePoints right;
1088   for (int i = theArrayOfFPnt->Lower(); i <= theArrayOfFPnt->Upper(); i++)
1089   {
1090     right.push_back(HYDROData_Bathymetry::AltitudePoint(theArrayOfFPnt->Value(i).X(),
1091       theArrayOfFPnt->Value(i).Y(),
1092       theArrayOfFPnt->Value(i).Z()));
1093   }
1094
1095   std::vector<HYDROData_Bathymetry::AltitudePoints> dummy;
1096   TopTools_IndexedMapOfOrientedShape ll = HYDROData_DTM::Create3DShape(left, right, dummy);
1097
1098   TopoDS_Shape LB, RB, IL, OL;
1099
1100   if (!ll.IsEmpty())
1101   {
1102     TopAbs_ShapeEnum ll1_sht = ll(1).ShapeType();
1103     TopAbs_ShapeEnum ll2_sht = ll(2).ShapeType();
1104     if ((ll1_sht == TopAbs_WIRE || ll1_sht == TopAbs_EDGE) &&
1105       (ll2_sht == TopAbs_WIRE || ll2_sht == TopAbs_EDGE))
1106     {
1107       LB = ll(1);
1108       RB = ll(2);
1109     }
1110   }
1111
1112   IL = TopoDS::Wire(theArrOfProfiles->Value(theArrOfProfiles->Lower())); //TODO check that
1113   OL = TopoDS::Wire(theArrOfProfiles->Value(theArrOfProfiles->Upper()));
1114
1115   //make new compound so it's shapes will be in known order to build correct projection
1116   BRep_Builder BB;
1117   TopoDS_Compound newCmp;
1118   BB.MakeCompound(newCmp);
1119   BB.Add(newCmp, LB);
1120   BB.Add(newCmp, IL);
1121   BB.Add(newCmp, OL);
1122   BB.Add(newCmp, RB);
1123
1124   thePrs.myPrs3D = newCmp;
1125
1126   TopTools_SequenceOfShape LS;
1127   //HYDROData_DTM::Get2dFaceFrom3dPres( newCmp, TopoDS::Face(thePrs.myPrs2D), &LS, ind );
1128
1129   HYDROData_DTM::GetPlanarFaceFromBanks(TopoDS::Edge(LB), TopoDS::Edge(RB), TopoDS::Face(thePrs.myPrs2D), &LS);
1130
1131 #ifndef NDEBUG
1132   TopTools_IndexedMapOfShape EE;
1133   TopExp::MapShapes(thePrs.myPrs2D, TopAbs_EDGE, EE);
1134   int noncontNb = 0;
1135   for (int i = 1; i <= 4; i++)
1136   {
1137     TopoDS_Shape W = LS(i);
1138     TopTools_IndexedMapOfShape EW;
1139     TopExp::MapShapes(W, TopAbs_EDGE, EW);
1140     for (int k = 1; k <= EW.Extent(); k++)
1141       noncontNb += !EE.Contains(EW(k));
1142   }
1143   //noncontNb > 0 => some problem with edge history
1144   assert(noncontNb == 0);
1145 #endif
1146
1147   thePrs.myLeftBank = LS(1);
1148   thePrs.myInlet = LS(2);
1149   thePrs.myOutlet = LS(3);
1150   thePrs.myRightBank = LS(4);
1151
1152 }