X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_Stream.cxx;h=29b7aae65a1f1b64c81ff8b6cad78aaae1b6c208;hb=f9bd5128a1aed8c1974b1d1cfb87aff32191fa60;hp=312657aedf5f2144c7c2d00ddbb241df0cf15213;hpb=ba70cb7d5a35a6d311acc1b061fb450afe04d0f8;p=modules%2Fhydro.git

diff --git a/src/HYDROData/HYDROData_Stream.cxx b/src/HYDROData/HYDROData_Stream.cxx
index 312657ae..29b7aae6 100644
--- a/src/HYDROData/HYDROData_Stream.cxx
+++ b/src/HYDROData/HYDROData_Stream.cxx
@@ -1,12 +1,32 @@
+// Copyright (C) 2014-2015  EDF-R&D
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
 
 #include "HYDROData_Stream.h"
 
 #include "HYDROData_Document.h"
 #include "HYDROData_PolylineXY.h"
+#include "HYDROData_Polyline3D.h"
 #include "HYDROData_Profile.h"
 #include "HYDROData_ShapesGroup.h"
 #include "HYDROData_ShapesTool.h"
 #include "HYDROData_IAltitudeObject.h"
+#include "HYDROData_IProfilesInterpolator.h"
+#include "HYDROData_Tool.h"
 
 #include <TDataStd_RealArray.hxx>
 
@@ -86,9 +106,23 @@ HYDROData_Stream::~HYDROData_Stream()
 QStringList HYDROData_Stream::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
 {
   QStringList aResList = dumpObjectCreation( theTreatedObjects );
-  QString aName = GetName();
+  QString aName = GetObjPyName();
 
-  // TODO
+  Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
+  setPythonReferenceObject( theTreatedObjects, aResList, aHydAxis, "SetHydraulicAxis" );
+
+  HYDROData_SequenceOfObjects aSeqOfProfiles = GetProfiles();
+  for ( int i = 1, aNb = aSeqOfProfiles.Size(); i <= aNb; ++i )
+  {
+    const Handle(HYDROData_Entity) aProfile = aSeqOfProfiles.Value( i );
+    setPythonReferenceObject( theTreatedObjects, aResList, aProfile, "AddProfile" );
+  }
+
+  // Set bottom polyline if exists
+  const Handle(HYDROData_Polyline3D) aBottomPolyline = GetBottomPolyline();
+  if ( !aBottomPolyline.IsNull() ) {
+    setPythonReferenceObject( theTreatedObjects, aResList, aBottomPolyline, "SetBottomPolyline" );
+  }
 
   aResList << QString( "" );
   aResList << QString( "%1.Update();" ).arg( aName );
@@ -135,37 +169,54 @@ Handle(Geom_BSplineCurve) HYDROData_Stream::buildInterpolationCurve(
 void HYDROData_Stream::Update()
 {
   updateProfilesOrder();
+
+  // Update bottom polyline if exists
+  const Handle(HYDROData_Polyline3D) aBottomPolyline = GetBottomPolyline();
+  if ( !aBottomPolyline.IsNull() ) {
+    if ( GenerateBottomPolyline() ) {
+      Handle(HYDROData_PolylineXY) aPolylineXY = aBottomPolyline->GetPolylineXY();
+      if ( !aPolylineXY.IsNull() ) {
+        aPolylineXY->Update();
+      }
+      aBottomPolyline->Update();
+    }
+  }
+
   UpdatePrs();
 }
 
-void HYDROData_Stream::UpdatePrs()
+bool HYDROData_Stream::IsHas2dPrs() const
 {
-  HYDROData_NaturalObject::Update();
+  return true;
+}
+
+bool HYDROData_Stream::CreatePresentations( const Handle(HYDROData_PolylineXY)& theHydAxis,
+                                            const HYDROData_SequenceOfObjects&  theProfiles,
+                                            PrsDefinition&                      thePrs )
+{
+  if ( theHydAxis.IsNull() || theProfiles.Length() < 2 )
+    return false;
 
-  Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
-  HYDROData_SequenceOfObjects aRefProfiles = GetProfiles();
-  if ( aHydAxis.IsNull() || aRefProfiles.Length() < 2 )
-    return; 
- 
-  bool anIsFirst = true;
   gp_Pnt aPrevFirstPoint, aPrevLastPoint;
-  Handle(TColgp_HArray1OfPnt) anArrayOfFPnt    = new TColgp_HArray1OfPnt(1, aRefProfiles.Length());
-  Handle(TColgp_HArray1OfPnt) anArrayOfLPnt    = new TColgp_HArray1OfPnt(1, aRefProfiles.Length());  
-  TopTools_Array1OfShape anArrOfProfiles(1, aRefProfiles.Length());
-  TopTools_Array1OfShape anArrOf2DProfiles(1, aRefProfiles.Length());
+  Handle(TColgp_HArray1OfPnt) anArrayOfFPnt    = new TColgp_HArray1OfPnt(1, theProfiles.Length());
+  Handle(TColgp_HArray1OfPnt) anArrayOfLPnt    = new TColgp_HArray1OfPnt(1, theProfiles.Length());  
+  TopTools_Array1OfShape anArrOfProfiles(1, theProfiles.Length());
+  TopTools_Array1OfShape anArrOf2DProfiles(1, theProfiles.Length());
 
   // Pre-processing
-  HYDROData_SequenceOfObjects::Iterator anIter( aRefProfiles );
+  HYDROData_SequenceOfObjects::Iterator anIter( theProfiles );
   for (int i=1 ; anIter.More(); anIter.Next(),i++ )
   {
     Handle(HYDROData_Profile) aProfile =
       Handle(HYDROData_Profile)::DownCast( anIter.Value() );
     if ( aProfile.IsNull() )
-      continue;    
+      continue;
+
     const TopoDS_Shape& aProf3d = aProfile->GetShape3D();
     gp_XY aPnt1, aPnt2;
-    if ( !aProfile->GetLeftPoint( aPnt1 ) || !aProfile->GetRightPoint( aPnt2 ) )
+    if ( !aProfile->GetLeftPoint( aPnt1, false ) || !aProfile->GetRightPoint( aPnt2, false ) )
       continue;
+
     anArrOfProfiles.SetValue(i,aProfile->GetShape3D());//aProfile->GetTopShape();
     anArrOf2DProfiles.SetValue(i,aProfile->GetTopShape());
 
@@ -190,37 +241,45 @@ void HYDROData_Stream::UpdatePrs()
   // Construct of the 3D presentation
   Handle(Geom_BSplineCurve) aBSpline = buildInterpolationCurve (anArrayOfFPnt);
   if(aBSpline.IsNull())
-    return;
+    return false;
+
   TopoDS_Edge anEdgLeft, anEdgRight;
+  
   BRepBuilderAPI_MakeEdge aMakeEdge(aBSpline);
   if(aMakeEdge.IsDone()) 
     anEdgLeft = aMakeEdge.Edge();
+
   if(anEdgLeft.IsNull())
-    return;
+    return false;
+
   aBSpline.Nullify();
   aBSpline = buildInterpolationCurve (anArrayOfLPnt);  
   if(aBSpline.IsNull())
-    return; 
+    return false;
+
   aMakeEdge.Init(aBSpline);
   if(aMakeEdge.IsDone()) 
     anEdgRight = aMakeEdge.Edge();
+
   if(anEdgRight.IsNull())
-    return;
+    return false;
+
   BRep_Builder aBB;
   TopoDS_Compound aCmp;
   aBB.MakeCompound(aCmp);
-  anIter.Init( aRefProfiles );
+  anIter.Init( theProfiles );
   for (int i=1 ; i < anArrOfProfiles.Length() +1; i++ )  
     aBB.Add(aCmp, anArrOfProfiles.Value(i));
+
   aBB.Add(aCmp,anEdgLeft);
   aBB.Add(aCmp,anEdgRight);
   BRepCheck_Analyzer aCh(aCmp);
   if(aCh.IsValid())
-    SetShape3D(aCmp);
+    thePrs.myPrs3D = aCmp;
 #ifdef DEB_UPDATE
   else {
     BRepTools::Write(aCmp, "str3d.brep");
-    SetShape3D(aCmp);
+    thePrs.myPrs3D = aCmp;
   }
 #endif
 
@@ -233,26 +292,32 @@ void HYDROData_Stream::UpdatePrs()
       aPnt.SetZ(.0);
       anArrayOfLPnt->SetValue(i, aPnt);
   }
+
   aBSpline.Nullify();
   aBSpline = buildInterpolationCurve (anArrayOfFPnt);  
   if(aBSpline.IsNull())
-    return; 
+    return false; 
+
   aMakeEdge.Init(aBSpline);
   if(aMakeEdge.IsDone()) 
       anEdgLeft = aMakeEdge.Edge();
+
   aBSpline.Nullify();
   aBSpline = buildInterpolationCurve (anArrayOfLPnt);  
   if(aBSpline.IsNull())
-    return; 
+    return false; 
+
   aMakeEdge.Init(aBSpline);
   if(aMakeEdge.IsDone()) 
     anEdgRight = aMakeEdge.Edge();
   if(anEdgRight.IsNull())
-    return;
+    return false;
+
   BRepBuilderAPI_MakeEdge aMakeEdge2(anArrayOfFPnt->Value(1),anArrayOfLPnt->Value(1));
   TopoDS_Edge aBotEdge, aTopEdge;
   if(aMakeEdge2.IsDone()) 
     aBotEdge = aMakeEdge2.Edge();
+
   BRepBuilderAPI_MakeEdge aMakeEdge3(anArrayOfFPnt->Value(anArrayOfFPnt->Length()),anArrayOfLPnt->Value(anArrayOfLPnt->Length()));
   if(aMakeEdge3.IsDone()) 
     aTopEdge = aMakeEdge3.Edge();
@@ -261,16 +326,16 @@ void HYDROData_Stream::UpdatePrs()
   BRepBuilderAPI_MakeWire aMakeWire;
   
   aMakeWire.Add( aBotEdge );
-  aBotEdge = aMakeWire.Edge();
+  thePrs.myInlet = aMakeWire.Edge();
 
   aMakeWire.Add( anEdgLeft );
-  anEdgLeft = aMakeWire.Edge();
+  thePrs.myLeftBank = aMakeWire.Edge();
 
   aMakeWire.Add( aTopEdge );
-  aTopEdge = aMakeWire.Edge();
+  thePrs.myOutlet = aMakeWire.Edge();
 
   aMakeWire.Add( anEdgRight );
-  anEdgRight = aMakeWire.Edge();
+  thePrs.myRightBank = aMakeWire.Edge();
 
   TopoDS_Wire aSectProfileWire;
   if(aMakeWire.IsDone())
@@ -287,48 +352,58 @@ void HYDROData_Stream::UpdatePrs()
   aBB.Add(aCmp,aFace);
   for(int i=1;i <= anArrOf2DProfiles.Length(); i++)
     aBB.Add(aCmp,anArrOf2DProfiles.Value(i));
+
   aCh.Init(aCmp);
   if(aCh.IsValid())
-    SetTopShape(aCmp);
+   thePrs.myPrs2D = aCmp;
 #ifdef DEB_UPDATE
   else {
     BRepTools::Write(aCmp, "str2d.brep");
-    SetTopShape(aCmp);
+    thePrs.myPrs2D = aCmp;
   }
-#endif 
+#endif
+
+  return true;
+}
+
+void HYDROData_Stream::UpdatePrs()
+{
+  HYDROData_NaturalObject::Update();
+
+  Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
+  HYDROData_SequenceOfObjects aRefProfiles = GetProfiles();
+
+  PrsDefinition aResultPrs;
+  if ( !CreatePresentations( aHydAxis, aRefProfiles, aResultPrs ) )
+    return;
+
+  SetShape3D( aResultPrs.myPrs3D );
+  SetTopShape( aResultPrs.myPrs2D );
 
   // Create the stream groups
   QString aLeftGroupName = GetName() + "_Left_Bank";
 
   Handle(HYDROData_ShapesGroup) aLeftGroup = createGroupObject();
   aLeftGroup->SetName( aLeftGroupName );
-  aLeftGroup->AddShape( anEdgLeft );
+  aLeftGroup->AddShape( aResultPrs.myLeftBank );
 
   QString aRightGroupName = GetName() + "_Right_Bank";
 
   Handle(HYDROData_ShapesGroup) aRightGroup = createGroupObject();
   aRightGroup->SetName( aRightGroupName );
-  aRightGroup->AddShape( anEdgRight );
+  aRightGroup->AddShape( aResultPrs.myRightBank );
 
   QString anInGroupName = GetName() + "_Inlet";
 
   Handle(HYDROData_ShapesGroup) anInGroup = createGroupObject();
   anInGroup->SetName( anInGroupName );
-  anInGroup->AddShape( aBotEdge );
+  anInGroup->AddShape( aResultPrs.myInlet );
 
   QString anOutGroupName = GetName() + "_Outlet";
-
+  
   Handle(HYDROData_ShapesGroup) anOutGroup = createGroupObject();
   anOutGroup->SetName( anOutGroupName );
-  anOutGroup->AddShape( aTopEdge );
-
-  // This peace of code is for testing of functionality of altitude,
-  // will be removed by adv when testing will be finished
-  Handle(HYDROData_IAltitudeObject) anAltObj = GetAltitudeObject();
-  gp_XY aTestPnt( 5, 0 );
-  anAltObj->GetAltitudeForPoint( aTestPnt );
-  // End of test code
-
+  anOutGroup->AddShape( aResultPrs.myOutlet );
 }
 
 QColor HYDROData_Stream::DefaultFillingColor()
@@ -451,10 +526,18 @@ void HYDROData_Stream::RemoveHydraulicAxis()
   SetToUpdate( true );
 }
 
+bool HYDROData_Stream::HasIntersection( const Handle(HYDROData_Profile)& theProfile,
+                                        const TopoDS_Face&               thePlane,
+                                        Standard_Real&                   theOutPar ) const
+{
+  Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
+  return HasIntersection( aHydAxis, theProfile, thePlane, theOutPar );
+}
+
 bool HYDROData_Stream::HasIntersection( const Handle(HYDROData_PolylineXY)& theHydAxis, 
-                                        const Handle(HYDROData_Profile)& theProfile, 
-                                        const TopoDS_Face& thePlane,
-                                                              Standard_Real& outPar)
+                                        const Handle(HYDROData_Profile)&    theProfile, 
+                                        const TopoDS_Face&                  thePlane,
+                                        Standard_Real&                      theOutPar )
 {
   if ( theProfile.IsNull() || !IsValidAsAxis( theHydAxis ) )
     return false; 
@@ -507,7 +590,7 @@ bool HYDROData_Stream::HasIntersection( const Handle(HYDROData_PolylineXY)& theH
   Standard_Integer anIndx(0);
   BRepExtrema_ExtCC aCC;
   aCC.Initialize(anEdg2);
-  outPar = 0.0;
+  theOutPar = 0.0;
   anExplo.Init(aHydraulicWire, TopAbs_EDGE);
   for(Standard_Integer j=1;anExplo.More();anExplo.Next(),j++) {
     const TopoDS_Edge& anEdg1 = TopoDS::Edge(anExplo.Current());
@@ -529,10 +612,10 @@ bool HYDROData_Stream::HasIntersection( const Handle(HYDROData_PolylineXY)& theH
         const gp_Pnt& aPnt = aCC.PointOnE1(anIndx);
         if(aNum > 1) {
           TopExp::Vertices(anEdg1, aV1, aV2, Standard_True);
-          outPar += BRep_Tool::Pnt(aV1).Distance(aPnt);
+          theOutPar += BRep_Tool::Pnt(aV1).Distance(aPnt);
         } else {
           Standard_Real aPar = aCC.ParameterOnE1(anIndx);
-          outPar = aPar;
+          theOutPar = aPar;
         }
         hasInt = true;
         break;
@@ -540,12 +623,12 @@ bool HYDROData_Stream::HasIntersection( const Handle(HYDROData_PolylineXY)& theH
           // no ints-n
         if(aNum > 1) {
           TopExp::Vertices(anEdg1, aV1, aV2);
-          outPar += BRep_Tool::Pnt(aV1).Distance(BRep_Tool::Pnt(aV2));
+          theOutPar += BRep_Tool::Pnt(aV1).Distance(BRep_Tool::Pnt(aV2));
         }
       }
     } else if(aNum > 1) {
       TopExp::Vertices(anEdg1, aV1, aV2);
-      outPar += BRep_Tool::Pnt(aV1).Distance(BRep_Tool::Pnt(aV2));
+      theOutPar += BRep_Tool::Pnt(aV1).Distance(BRep_Tool::Pnt(aV2));
     }
   }
   if(hasInt)
@@ -553,15 +636,6 @@ bool HYDROData_Stream::HasIntersection( const Handle(HYDROData_PolylineXY)& theH
   return false;
 }
 
-bool HYDROData_Stream::HasIntersection( const Handle(HYDROData_Profile)& theProfile, const TopoDS_Face& thePlane,
-                                       Standard_Real& outPar ) const
-{
-  Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
-
-  return HasIntersection( aHydAxis, theProfile, thePlane, outPar );
-}
-
-
 bool HYDROData_Stream::AddProfile( const Handle(HYDROData_Profile)& theProfile )
 {
   if ( theProfile.IsNull() )
@@ -588,6 +662,52 @@ bool HYDROData_Stream::AddProfile( const Handle(HYDROData_Profile)& theProfile )
   return true;
 }
 
+bool HYDROData_Stream::SetProfiles( const HYDROData_SequenceOfObjects& theProfiles,
+                                    const bool&                        theIsToOrder )
+{
+  if ( theIsToOrder )
+  {
+    for ( int i = 1; i <= theProfiles.Length(); ++i )
+    {
+      Handle(HYDROData_Profile) aProfile = 
+        Handle(HYDROData_Profile)::DownCast( theProfiles.Value( i ) );
+      if ( aProfile.IsNull() )
+        continue;
+
+      if ( !AddProfile( aProfile ) )
+        return false;
+    }
+  }
+  else // Just store the sequence of objects as is
+  {
+    bool anIsToUpdate = true;
+
+    HYDROData_SequenceOfObjects anOldProfiles = GetProfiles();
+    if ( anOldProfiles.Length() == theProfiles.Length() )
+    {
+      anIsToUpdate = false;
+
+      for ( int i = 1; i <= theProfiles.Length(); ++i )
+      {
+        Handle(HYDROData_Entity) anOldProfile = anOldProfiles.Value( i );
+        Handle(HYDROData_Entity) aNewProfile = theProfiles.Value( i );
+        if ( !IsEqual( anOldProfile, aNewProfile ) )
+        {
+          anIsToUpdate = true;
+          break;
+        }
+      }
+    }
+    
+    SetReferenceObjects( theProfiles, DataTag_Profile );
+
+    if ( anIsToUpdate )
+      SetToUpdate( true );
+  }
+
+  return true;
+}
+
 HYDROData_SequenceOfObjects HYDROData_Stream::GetProfiles() const
 {
   return GetReferenceObjects( DataTag_Profile );
@@ -662,7 +782,7 @@ void HYDROData_Stream::insertProfileInToOrder( const Handle(HYDROData_Profile)&
 }
 
 bool HYDROData_Stream::BuildFace( const Handle(HYDROData_PolylineXY)& theHydAxis,
-                                  TopoDS_Face&                        thePlane ) const
+                                  TopoDS_Face&                        thePlane )
 {
   if ( !IsValidAsAxis( theHydAxis ) )
     return false;
@@ -722,7 +842,7 @@ void HYDROData_Stream::updateProfilesOrder()
       continue;
     
     aDM.Bind( aPar, aProfile );
-      aList.Append( aPar );
+    aList.Append( aPar );
   }
   
   if ( aList.IsEmpty() )
@@ -895,3 +1015,197 @@ void HYDROData_Stream::removeParameter( const int& theIndex )
 
   setParametersArray( aNewArr );
 }
+
+bool HYDROData_Stream::GenerateBottomPolyline()
+{
+  // Get the document
+  Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
+  if ( aDocument.IsNull() ) {
+    return false;
+  }
+
+  // Collect bottom points ( one bottom point from each profile of the stream )
+  HYDROData_Profile::ProfilePoints aBottomPoints;
+  
+  HYDROData_SequenceOfObjects aSeqOfProfiles = GetProfiles();
+  for ( int i = 1, aNb = aSeqOfProfiles.Size(); i <= aNb; i++ ) {
+    const Handle(HYDROData_Profile) aProfile = 
+      Handle(HYDROData_Profile)::DownCast( aSeqOfProfiles.Value( i ) );
+    if ( aProfile.IsNull() ) {
+      continue;
+    }
+    
+    aBottomPoints.Append( aProfile->GetBottomPoint() );
+  }
+
+  int aNbBottomPoints = aBottomPoints.Size();
+
+  if ( aNbBottomPoints < 2 ) {
+    return false;
+  }
+
+  // Create bottom polyline object if the stream doesn't contain it yet
+  Handle(HYDROData_Polyline3D) aBottom = GetBottomPolyline();
+  if ( aBottom.IsNull() ) {
+    aBottom = Handle(HYDROData_Polyline3D)::DownCast( aDocument->CreateObject( KIND_POLYLINE ) );  
+    QString aBaseName = GetName() + "_bottom";
+    QString aName = HYDROData_Tool::GenerateObjectName( aDocument, aBaseName, QStringList(), true );
+    aBottom->SetName( aName );
+
+    SetReferenceObject( aBottom, DataTag_BottomPolyline );
+  }
+  
+  // Create 2D polyline if the bottom polyline doesn't contain it yet
+  Handle(HYDROData_PolylineXY) aPolylineXY = aBottom->GetPolylineXY();
+  if ( aPolylineXY.IsNull() ) {
+    aPolylineXY = Handle(HYDROData_PolylineXY)::DownCast( aDocument->CreateObject( KIND_POLYLINEXY ) );
+    QString aBaseName = GetName() + "_bottom_2d";
+    QString aName = HYDROData_Tool::GenerateObjectName( aDocument, aBaseName, QStringList(), true );
+    aPolylineXY->SetName( aName );
+    aBottom->SetPolylineXY( aPolylineXY, false );
+  }
+
+  aPolylineXY->RemoveSections();
+  aPolylineXY->AddSection( "", HYDROData_PolylineXY::SECTION_SPLINE, false );
+  
+  // Create profile if the bottom polyline doesn't contain it yet
+  Handle(HYDROData_ProfileUZ) aProfileUZ = aBottom->GetProfileUZ();
+  if ( aProfileUZ.IsNull() ) {
+    Handle(HYDROData_Profile) aProfile = 
+      Handle(HYDROData_Profile)::DownCast( aDocument->CreateObject( KIND_PROFILE ) );
+    QString aBaseName = GetName() + "_bottom_profile";
+    QString aName = HYDROData_Tool::GenerateObjectName( aDocument, aBaseName, QStringList(), true );
+    aProfile->SetName( aName );
+    aProfileUZ = aProfile->GetProfileUZ( true );
+    aBottom->SetProfileUZ( aProfileUZ );
+  }
+  
+  aProfileUZ->RemoveSection( 0 );
+
+  // Fill 2D polyline
+  for ( int i = 1; i <= aNbBottomPoints; i++ ) {
+    const HYDROData_Profile::ProfilePoint& aBottomPoint = aBottomPoints.Value( i );
+    aPolylineXY->AddPoint( 0, HYDROData_PolylineXY::Point( aBottomPoint.X(), aBottomPoint.Y() ) );
+  }
+  
+  // Calculate profile UZ points
+
+  // First point
+  const HYDROData_Profile::ProfilePoint& aFirstBottomPoint = aBottomPoints.First();
+  aProfileUZ->AddPoint( 0, HYDROData_ProfileUZ::Point( 0, aFirstBottomPoint.Z() ) );
+
+  // Intermediate points
+  double aPolylineCommonDist = aPolylineXY->GetDistance( 0, aPolylineXY->NbPoints( 0 ) - 1 );
+
+  for ( int i = 2, aNbPoints = aBottomPoints.Size(); i < aNbPoints; i++ ) {
+    const HYDROData_Profile::ProfilePoint& aBottomPoint = aBottomPoints.Value( i );
+    
+    double aDistance = aPolylineXY->GetDistance( 0, i - 1 );
+    
+    Standard_Real anU = aDistance; // = ( aDistance / aPolylineCommonDist ) * aPolylineCommonDist;
+    aProfileUZ->AddPoint( 0, HYDROData_ProfileUZ::Point( anU, aBottomPoint.Z() ) );
+  }
+  
+  // Last point
+  const HYDROData_Profile::ProfilePoint& aLastBottomPoint = aBottomPoints.Last();
+  aProfileUZ->AddPoint( 0, HYDROData_ProfileUZ::Point( aPolylineCommonDist, aLastBottomPoint.Z() ) );
+  
+  return true;
+}
+
+Handle(HYDROData_Polyline3D) HYDROData_Stream::GetBottomPolyline() const
+{
+  return Handle(HYDROData_Polyline3D)::DownCast( 
+           GetReferenceObject( DataTag_BottomPolyline ) );
+}
+
+bool HYDROData_Stream::SetBottomPolyline( const Handle(HYDROData_Polyline3D)& theBottom )
+{
+  if ( theBottom.IsNull() ) {
+    return false;
+  }
+
+  SetReferenceObject( theBottom, DataTag_BottomPolyline );
+
+  return true;
+}
+
+bool HYDROData_Stream::Interpolate( HYDROData_IProfilesInterpolator* theInterpolator )
+{
+  // Get the document
+  Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
+  if ( aDocument.IsNull() ) {
+    return false;
+  }
+  
+  if ( theInterpolator->GetCalculatedProfilesNumber() < 1 ) {
+    theInterpolator->Calculate();
+  }
+
+  if ( theInterpolator->GetErrorCode() != OK ) {
+    return false;
+  }
+
+  bool isOK = true;
+
+  for ( int aProfileInd = 0; aProfileInd < theInterpolator->GetCalculatedProfilesNumber(); aProfileInd++ ) {
+    // Get calculated point coordinates
+    HYDROData_Profile::ProfilePoints aResultPoints = theInterpolator->GetResultProfilePoints( aProfileInd );
+    if ( aResultPoints.IsEmpty() ) {
+      isOK = false;
+      continue;
+    }
+        
+    // Create profile object
+    Handle(HYDROData_Profile) aProfile = 
+      Handle(HYDROData_Profile)::DownCast( aDocument->CreateObject( KIND_PROFILE ) );
+    QString aBaseName = GetName() + "_interp_profile";
+    QString aName = HYDROData_Tool::GenerateObjectName( aDocument, aBaseName );
+    aProfile->SetName( aName );
+
+    // Fill the profile with points
+    aProfile->SetProfilePoints( aResultPoints );
+
+    // Add profile to the stream
+    bool isAdded = AddProfile( aProfile );
+    if ( !isAdded ) {
+      aProfile->Remove();
+    }
+    else
+      aProfile->Update();
+  }
+
+  if ( isOK )
+    Update();
+
+  return isOK;
+}
+
+void HYDROData_Stream::CopyTo( const Handle(HYDROData_Entity)& theDestination ) const
+{
+  // Get the document
+  Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
+  if ( aDocument.IsNull() ) {
+    return;
+  }
+
+  // Call base method
+  HYDROData_Entity::CopyTo( theDestination );
+
+  Handle(HYDROData_Stream) aStreamCopy = 
+    Handle(HYDROData_Stream)::DownCast( theDestination );
+
+  // Copy bottom polyline if exists
+  if ( !aStreamCopy.IsNull() ) {
+    const Handle(HYDROData_Polyline3D) aBottom = GetBottomPolyline();
+    if ( !aBottom.IsNull() ) {
+      aStreamCopy->ClearReferenceObjects( DataTag_BottomPolyline );
+      aStreamCopy->GenerateBottomPolyline();
+      const Handle(HYDROData_Polyline3D) aBottomCopy = aStreamCopy->GetBottomPolyline();
+      if ( !aBottomCopy.IsNull() && !aBottomCopy->GetPolylineXY().IsNull() ) {
+        aBottomCopy->GetPolylineXY()->Update();
+        aBottomCopy->Update();
+      }
+    }
+  }
+}
\ No newline at end of file