X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROData%2FHYDROData_PolylineXY.cxx;h=04039c96a9f4a9591437404d3247bae5f60824f4;hb=1bbabb6a4145a459a6655a3bc18b71ec135bf814;hp=f651ac2a4c33e3cce6c7bbca930023c275cd9a96;hpb=deed826b2d6c39ba2ed410108cdf54d64cded321;p=modules%2Fhydro.git

diff --git a/src/HYDROData/HYDROData_PolylineXY.cxx b/src/HYDROData/HYDROData_PolylineXY.cxx
index f651ac2a..04039c96 100755
--- a/src/HYDROData/HYDROData_PolylineXY.cxx
+++ b/src/HYDROData/HYDROData_PolylineXY.cxx
@@ -1,16 +1,39 @@
 
 #include "HYDROData_PolylineXY.h"
 
+#include "HYDROData_BSplineOperation.h"
+#include "HYDROData_Document.h"
 #include "HYDROData_Tool.h"
 
+#include <BRep_Builder.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+
+#include <ImageComposer_MetaTypes.h>
+
+#include <gp_Pnt.hxx>
 #include <gp_XY.hxx>
 
+#include <NCollection_Map.hxx>
+
+#include <TCollection_ExtendedString.hxx>
+
+#include <TDataStd_ListIteratorOfListOfByte.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
 #include <TColStd_ListIteratorOfListOfReal.hxx>
 
+#include <TDataStd_BooleanList.hxx>
+#include <TDataStd_ExtStringList.hxx>
+#include <TDataStd_IntegerList.hxx>
+#include <TDataStd_ListIteratorOfListOfExtendedString.hxx>
 #include <TDataStd_RealList.hxx>
 
-#include <TopoDS_Wire.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+
+#include <QPainterPath>
+#include <QVariant>
 
+#define PYTHON_POLYLINEXY_ID "KIND_POLYLINEXY"
 
 IMPLEMENT_STANDARD_HANDLE(HYDROData_PolylineXY, HYDROData_IPolyline)
 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_PolylineXY, HYDROData_IPolyline)
@@ -24,155 +47,621 @@ HYDROData_PolylineXY::~HYDROData_PolylineXY()
 {
 }
 
-TopoDS_Wire HYDROData_PolylineXY::GetWire() const
+QStringList HYDROData_PolylineXY::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
 {
-  // TODO
-  return TopoDS_Wire();
+  QStringList aResList;
+
+  Handle(HYDROData_Document) aDocument = HYDROData_Document::Document( myLab );
+  if ( aDocument.IsNull() )
+    return aResList;
+                             
+  QString aDocName = aDocument->GetDocPyName();
+  QString aPolylineName = GetName();
+
+  aResList << QString( "%1 = %2.CreateObject( %3 );" )
+              .arg( aPolylineName ).arg( aDocName ).arg( PYTHON_POLYLINEXY_ID );
+  aResList << QString( "%1.SetName( \"%1\" );" ).arg( aPolylineName );
+
+  // Set polilyne data
+  NCollection_Sequence<TCollection_AsciiString>           aSectNames;
+  NCollection_Sequence<HYDROData_PolylineXY::SectionType> aSectTypes;
+  NCollection_Sequence<bool>                              aSectClosures;
+  GetSections( aSectNames, aSectTypes, aSectClosures );
+
+  for ( int i = 1, n = aSectNames.Size(); i <= n; ++i )
+  {
+    const TCollection_AsciiString& aSectName = aSectNames.Value( i );
+    const SectionType& aSectType = aSectTypes.Value( i );
+    bool aSectClosure = aSectClosures.Value( i );
+
+    aResList << QString( "%1.AddSection( \"%2\", %3, %4 );" ).arg( aPolylineName )
+                .arg( aSectName.ToCString() ).arg( aSectType ).arg( aSectClosure );
+
+    HYDROData_PolylineXY::PointsList aSectPointsList = GetPoints( i );
+    for ( int k = 1, aNbPoints = aSectPointsList.Size(); k <= aNbPoints; ++k )
+    {
+      const HYDROData_PolylineXY::Point& aSectPoint = aSectPointsList.Value( k );
+
+      aResList << QString( "%1.AddPoint( %2, QPointF( %3, %4 ) );" ).arg( aPolylineName )
+        .arg( i - 1 ).arg( aSectPoint.X() ).arg( aSectPoint.Y() );
+    }
+  }
+
+  return aResList;
 }
 
-int HYDROData_PolylineXY::NbSections() const
+QVariant HYDROData_PolylineXY::GetDataVariant()
 {
-  return 1;
+  QPainterPath aPath = GetPainterPath();
+
+  QVariant aVarData;
+  aVarData.setValue<QPainterPath>( aPath );
+  
+  return aVarData;
 }
 
-void HYDROData_PolylineXY::AddSection( const bool /*theIsClosed*/ )
+TopoDS_Shape HYDROData_PolylineXY::GetShape()
 {
+  return getPolylineShape();
 }
 
-bool HYDROData_PolylineXY::IsClosedSection( const int /*theSectionIndex*/ ) const
+void HYDROData_PolylineXY::Update()
 {
-  return false;
+  NCollection_Sequence<TCollection_AsciiString>           aSectNames;
+  NCollection_Sequence<HYDROData_PolylineXY::SectionType> aSectTypes;
+  NCollection_Sequence<bool>                              aSectClosures;
+  GetSections( aSectNames, aSectTypes, aSectClosures );
+
+  BRepBuilderAPI_MakeWire aMakeWire;
+
+  TopTools_ListOfShape aSectionWiresList;
+
+  for ( int aSectionId = 1, aNbSects = aSectNames.Size(); aSectionId <= aNbSects; aSectionId++ )
+  {
+    TCollection_AsciiString aSectName = aSectNames.Value( aSectionId );
+    SectionType aSectionType = aSectTypes.Value( aSectionId );
+    bool anIsSectionClosed = aSectClosures.Value( aSectionId );
+
+    PointsList aSectPointsList = GetPoints( aSectionId - 1 );
+    if ( aSectPointsList.IsEmpty() )
+      continue;
+
+    BRepBuilderAPI_MakeWire aMakeSectionWire;
+    if( aSectionType == SECTION_POLYLINE )
+    {
+      for( int i = 1, n = aSectPointsList.Size(); i <= n; ++i )
+      {
+        const Point& aFirstPoint = aSectPointsList.Value( i );
+
+        Point aLastPoint;
+        if ( i == n )
+        {
+          if( anIsSectionClosed )
+            aLastPoint = aSectPointsList.Value( 1 );
+          else
+            break;
+        }
+        else
+        {
+          aLastPoint = aSectPointsList.Value( i + 1 );
+        }
+
+        gp_Pnt aPnt1( aFirstPoint.X(), aFirstPoint.Y(), 0.0 );
+        gp_Pnt aPnt2( aLastPoint.X(), aLastPoint.Y(), 0.0 );
+
+        TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge( aPnt1, aPnt2 ).Edge();
+        aMakeSectionWire.Add( anEdge );
+      }
+    }
+    else //if( aSectionType == PolylineSection::SECTION_SPLINE )
+    {
+      QList<double> aPoints;
+      for( int i = 1, n = aSectPointsList.Size(); i <= n; ++i )
+      {
+        const Point& aSectPoint = aSectPointsList.Value( i );
+        aPoints << aSectPoint.X() << aSectPoint.Y();
+      }
+
+      HYDROData_BSplineOperation aBSpline( aPoints, 0.0, anIsSectionClosed );
+
+      TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge( aBSpline.Curve() ).Edge();
+      aMakeSectionWire.Add( anEdge );
+    }
+   
+    TopoDS_Wire aSectionWire = aMakeSectionWire.Wire();
+    aSectionWiresList.Append( aSectionWire );
+    aMakeWire.Add( aSectionWire );
+  }
+
+  TopoDS_Shape aShape;
+
+  if ( aMakeWire.IsDone() )
+  {
+    aShape = aMakeWire.Shape();
+  }
+  else if ( !aSectionWiresList.IsEmpty() )
+  {
+    // build compound
+    TopoDS_Compound aCompound;
+    
+    BRep_Builder aBuilder;
+    aBuilder.MakeCompound( aCompound );
+    
+    TopTools_ListIteratorOfListOfShape anIter( aSectionWiresList );
+    for ( ; anIter.More(); anIter.Next() )
+    {
+      aBuilder.Add( aCompound, anIter.Value() );
+    }
+    
+    aShape = aCompound;
+  }
+
+  setPolylineShape( aShape );
 }
 
-void HYDROData_PolylineXY::RemoveSection( const int /*theSectionIndex*/ )
+/**
+ * Returns true if polyline is closed
+ */
+bool HYDROData_PolylineXY::IsClosed() const
 {
-  RemoveSections();
+  NCollection_Sequence<TCollection_AsciiString>           aSectNames;
+  NCollection_Sequence<HYDROData_PolylineXY::SectionType> aSectTypes;
+  NCollection_Sequence<bool>                              aSectClosures;
+  GetSections( aSectNames, aSectTypes, aSectClosures );
+  if( aSectNames.IsEmpty() )
+    return false;
+
+  bool anIsClosed = true;
+  for( int i = 1, n = aSectClosures.Size(); i <= n && anIsClosed; ++i )
+    anIsClosed = anIsClosed && aSectClosures.Value( i );
+
+  return anIsClosed;
 }
 
-void HYDROData_PolylineXY::RemoveSections()
+int HYDROData_PolylineXY::NbSections() const
 {
-  removePointsLists( 0 );
+  Handle(TDataStd_ExtStringList) aNamesList;
+  Handle(TDataStd_IntegerList)   aTypesList;
+  Handle(TDataStd_BooleanList)   aClosuresList;
+  getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
+
+  return !aClosuresList.IsNull() ? aClosuresList->Extent() : 0;
 }
 
-void HYDROData_PolylineXY::AddPoint( const int    /*theSectionIndex*/,
-                                    const Point& thePoint,
-                                    const int    thePointIndex )
+TCollection_ExtendedString getUniqueSectionName( const Handle(TDataStd_ExtStringList)& theNamesList )
 {
-  double aNewCoordU = thePoint.X();
-  double aNewCoordZ = thePoint.Y();
+  NCollection_Map<TCollection_ExtendedString> aNamesMap;
+
+  TDataStd_ListIteratorOfListOfExtendedString aNamesIter( theNamesList->List() );
+  for ( ; aNamesIter.More(); aNamesIter.Next() )
+    aNamesMap.Add( aNamesIter.Value() );
 
-  Handle(TDataStd_RealList) aListU, aListZ;
-  getPointsLists( 0, aListU, aListZ );
+  TCollection_ExtendedString aResName;
 
-  if ( aListU->IsEmpty() || aNewCoordU > aListU->Last() )
+  int aPrefIdx = 1;
+  do
   {
-    aListU->Append( aNewCoordU );
-    aListZ->Append( aNewCoordZ );
-    return;
+    aResName = "Section_" + aPrefIdx;
+    ++aPrefIdx;
   }
-  else if ( aNewCoordU < aListU->First() )
+  while ( aNamesMap.Contains( aResName ) );
+
+  return aResName;
+}
+
+void HYDROData_PolylineXY::AddSection( const TCollection_AsciiString& theSectName,
+                                       const SectionType              theSectionType,
+                                       const bool                     theIsClosed )
+{
+  Handle(TDataStd_ExtStringList) aNamesList;
+  Handle(TDataStd_IntegerList)   aTypesList;
+  Handle(TDataStd_BooleanList)   aClosuresList;
+  getSectionsLists( aNamesList, aTypesList, aClosuresList );
+
+  TCollection_ExtendedString aSectName( theSectName );
+  if ( aSectName.Length() <= 0 )
+    aSectName = getUniqueSectionName( aNamesList );
+
+  aNamesList->Append( aSectName );
+  aTypesList->Append( theSectionType );
+  aClosuresList->Append( theIsClosed );
+}
+
+TCollection_AsciiString HYDROData_PolylineXY::GetSectionName( const int theSectionIndex ) const
+{
+  TCollection_AsciiString aResName;
+
+  Handle(TDataStd_ExtStringList) aNamesList;
+  Handle(TDataStd_IntegerList) aTypesList;
+  Handle(TDataStd_BooleanList) aClosuresList;
+  getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
+  if ( aNamesList.IsNull() || theSectionIndex >= aNamesList->Extent() )
+    return aResName;
+
+  TDataStd_ListIteratorOfListOfExtendedString aNamesIter( aNamesList->List() );
+  for ( int i = 0; aNamesIter.More() && i != theSectionIndex; aNamesIter.Next(), ++i );
+
+  if ( aNamesIter.More() )
+    aResName = aNamesIter.Value();
+
+  return aResName;
+}
+
+void HYDROData_PolylineXY::SetSectionName( const int                      theSectionIndex, 
+                                           const TCollection_AsciiString& theSectionName )
+{
+  Handle(TDataStd_ExtStringList) aNamesList;
+  Handle(TDataStd_IntegerList) aTypesList;
+  Handle(TDataStd_BooleanList) aClosuresList;
+  getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
+  if ( aNamesList.IsNull() || theSectionIndex >= aNamesList->Extent() )
+    return;
+
+  TDataStd_ListOfExtendedString anOldNamesList;
+  anOldNamesList = aNamesList->List();
+
+  // Refill the existing list
+  aNamesList->Clear();
+
+  TDataStd_ListIteratorOfListOfExtendedString aNamesIter( aNamesList->List() );
+  for ( int i = 0; aNamesIter.More(); aNamesIter.Next(), ++i )
+    aNamesList->Append( i == theSectionIndex ? theSectionName : aNamesIter.Value() );
+}
+
+HYDROData_PolylineXY::SectionType HYDROData_PolylineXY::GetSectionType( const int theSectionIndex ) const
+{
+  Handle(TDataStd_ExtStringList) aNamesList;
+  Handle(TDataStd_IntegerList) aTypesList;
+  Handle(TDataStd_BooleanList) aClosuresList;
+  getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
+  if ( aTypesList.IsNull() || theSectionIndex >= aTypesList->Extent() )
+    return SECTION_POLYLINE;
+
+  TColStd_ListIteratorOfListOfInteger aTypesIter( aTypesList->List() );
+  for ( int i = 0; aTypesIter.More() && i != theSectionIndex; aTypesIter.Next(), ++i );
+
+  return aTypesIter.More() ? (SectionType)aTypesIter.Value() : SECTION_POLYLINE;
+}
+
+void HYDROData_PolylineXY::SetSectionType( const int         theSectionIndex, 
+                                           const SectionType theSectionType )
+{
+  Handle(TDataStd_ExtStringList) aNamesList;
+  Handle(TDataStd_IntegerList) aTypesList;
+  Handle(TDataStd_BooleanList) aClosuresList;
+  getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
+  if ( aTypesList.IsNull() || theSectionIndex >= aTypesList->Extent() )
+    return;
+
+  TColStd_ListOfInteger anOldTypesList;
+  anOldTypesList = aTypesList->List();
+
+  // Refill the existing list
+  aTypesList->Clear();
+
+  TColStd_ListIteratorOfListOfInteger aTypesIter( anOldTypesList );
+  for ( int i = 0; aTypesIter.More(); aTypesIter.Next(), ++i )
+    aTypesList->Append( i == theSectionIndex ? theSectionType : aTypesIter.Value() );
+}
+
+bool HYDROData_PolylineXY::IsClosedSection( const int theSectionIndex ) const
+{
+  Handle(TDataStd_ExtStringList) aNamesList;
+  Handle(TDataStd_IntegerList) aTypesList;
+  Handle(TDataStd_BooleanList) aClosuresList;
+  getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
+  if ( aClosuresList.IsNull() || theSectionIndex >= aClosuresList->Extent() )
+    return false;
+
+  TDataStd_ListIteratorOfListOfByte aClosuresIter( aClosuresList->List() );
+  for ( int i = 0; aClosuresIter.More() && i != theSectionIndex; aClosuresIter.Next(), ++i );
+
+  return aClosuresIter.More() ? (bool)aClosuresIter.Value() : false;
+}
+
+void HYDROData_PolylineXY::SetSectionClosed( const int  theSectionIndex, 
+                                             const bool theIsClosed )
+{
+  Handle(TDataStd_ExtStringList) aNamesList;
+  Handle(TDataStd_IntegerList) aTypesList;
+  Handle(TDataStd_BooleanList) aClosuresList;
+  getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
+  if ( aClosuresList.IsNull() || theSectionIndex >= aClosuresList->Extent() )
+    return;
+
+  TDataStd_ListOfByte anOldClosuresList;
+  anOldClosuresList = aClosuresList->List();
+
+  // Refill the existing list
+  aClosuresList->Clear();
+
+  TDataStd_ListIteratorOfListOfByte aClosuresIter( anOldClosuresList );
+  for ( int i = 0; aClosuresIter.More(); aClosuresIter.Next(), ++i )
+    aClosuresList->Append( i == theSectionIndex ? theIsClosed : (bool)aClosuresIter.Value() );
+}
+
+void HYDROData_PolylineXY::GetSections( NCollection_Sequence<TCollection_AsciiString>& theSectNames,
+                                        NCollection_Sequence<SectionType>&             theSectTypes,
+                                        NCollection_Sequence<bool>&                    theSectClosures ) const
+{
+  theSectNames.Clear();
+  theSectTypes.Clear();
+  theSectClosures.Clear();
+
+  Handle(TDataStd_ExtStringList) aNamesList;
+  Handle(TDataStd_IntegerList) aTypesList;
+  Handle(TDataStd_BooleanList) aClosuresList;
+  getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
+  if ( aNamesList.IsNull() || aTypesList.IsNull() || aClosuresList.IsNull() )
+    return;
+
+  TDataStd_ListIteratorOfListOfExtendedString aNamesIter( aNamesList->List() );
+  TColStd_ListIteratorOfListOfInteger aTypesIter( aTypesList->List() );
+  TDataStd_ListIteratorOfListOfByte aClosuresIter( aClosuresList->List() );
+  for ( ; aNamesIter.More() && aTypesIter.More() && aClosuresIter.More();
+          aNamesIter.Next(), aTypesIter.Next(), aClosuresIter.Next() )
   {
-    aListU->Prepend( aNewCoordU );
-    aListZ->Prepend( aNewCoordZ );
+    const TCollection_ExtendedString& aSectName = aNamesIter.Value();
+    SectionType aSectType = (SectionType)aTypesIter.Value();
+    bool aSectClosures = aClosuresIter.Value();
+
+    theSectNames.Append( aSectName );
+    theSectTypes.Append( aSectType );
+    theSectClosures.Append( aSectClosures );
+  }
+}
+
+void HYDROData_PolylineXY::RemoveSection( const int theSectionIndex )
+{
+  Handle(TDataStd_ExtStringList) aNamesList;
+  Handle(TDataStd_IntegerList)   aTypesList;
+  Handle(TDataStd_BooleanList)   aClosuresList;
+  getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
+  if ( aNamesList.IsNull() || theSectionIndex >= aNamesList->Extent() )
     return;
+
+  if ( aNamesList->Extent() == 1 )
+  {
+    removeSectionsLists();
+    removePointsLists();
   }
+  else
+  {
+    TDataStd_ListOfExtendedString anOldNamesList;
+    anOldNamesList = aNamesList->List();
 
-  TColStd_ListOfReal anOldListU;
-  anOldListU = aListU->List();
+    TColStd_ListOfInteger anOldTypesList;
+    anOldTypesList = aTypesList->List();
 
-  TColStd_ListOfReal anOldListZ;
-  anOldListZ = aListZ->List();
+    TDataStd_ListOfByte anOldClosuresList;
+    anOldClosuresList = aClosuresList->List();
 
-  // Crsat new lists
-  removePointsLists( 0 );
-  getPointsLists( 0, aListU, aListZ );
+    // Refill the existing lists
+    aNamesList->Clear();
+    aTypesList->Clear();
+    aClosuresList->Clear();
 
-  bool anIsInserted = false;
-  TColStd_ListIteratorOfListOfReal anIterU( anOldListU );
-  TColStd_ListIteratorOfListOfReal anIterZ( anOldListZ );
-  for ( ; anIterU.More() && anIterZ.More(); anIterU.Next(), anIterZ.Next() )
+    TDataStd_ListIteratorOfListOfExtendedString aNamesIter( anOldNamesList );
+    TColStd_ListIteratorOfListOfInteger aTypesIter( anOldTypesList );
+    TDataStd_ListIteratorOfListOfByte aClosuresIter( anOldClosuresList );
+    for ( int i = 0; aNamesIter.More() && aTypesIter.More() && aClosuresIter.More();
+                     aNamesIter.Next(), aTypesIter.Next(), aClosuresIter.Next(), ++i )
+    {
+      if ( i == theSectionIndex )
+        continue; // skip index to remove
+
+      aNamesList->Append( aNamesIter.Value() );
+      aTypesList->Append( aTypesIter.Value() );
+      aClosuresList->Append( (bool)aClosuresIter.Value() );
+    }
+
+    // Remove points that belongs to removed section
+    removePointsLists( theSectionIndex );
+  }
+}
+
+void HYDROData_PolylineXY::RemoveSections()
+{
+  removeSectionsLists();
+  removePointsLists();
+}
+
+void HYDROData_PolylineXY::AddPoint( const int    theSectionIndex,
+                                     const Point& thePoint,
+                                     const int    thePointIndex )
+{
+  Handle(TDataStd_RealList) aListX, aListY;
+  getPointsLists( theSectionIndex, aListX, aListY );
+
+  if ( thePointIndex < 0 || thePointIndex >= aListX->Extent() )
+  {
+    aListX->Append( thePoint.X() );
+    aListY->Append( thePoint.Y() );
+  }
+  else
   {
-    double aCoordU = anIterU.Value();
-    double aCoordZ = anIterZ.Value();
+    TColStd_ListOfReal anOldListX;
+    anOldListX = aListX->List();
+
+    TColStd_ListOfReal anOldListY;
+    anOldListY = aListY->List();
+
+    // Refill the existing lists
+    aListX->Clear();
+    aListY->Clear();
 
-    if ( !anIsInserted )
+    TColStd_ListIteratorOfListOfReal anIterX( anOldListX );
+    TColStd_ListIteratorOfListOfReal anIterY( anOldListY );
+    for ( int i = 0; anIterX.More() && anIterY.More(); anIterX.Next(), anIterY.Next(), ++i )
     {
-      if ( ValuesEquals( aNewCoordU, aCoordU ) )
-      {
-        // Just update Z value
-        aCoordZ = aNewCoordZ;
-        anIsInserted = true;
-      }
-      else if ( aNewCoordU < aCoordU )
+      double aCoordX = anIterX.Value();
+      double aCoordY = anIterY.Value();
+
+      if ( i == thePointIndex )
       {
-        // Insert new point
-        aListU->Append( aNewCoordU );
-        aListZ->Append( aNewCoordZ );
-        anIsInserted = true;
+        // Insert our new point
+        aListX->Append( thePoint.X() );
+        aListY->Append( thePoint.Y() );
       }
-    }
 
-    aListU->Append( aCoordU );
-    aListZ->Append( aCoordZ );
+      aListX->Append( aCoordX );
+      aListY->Append( aCoordY );
+    }
   }
 }
 
 void HYDROData_PolylineXY::SetPoint( const int    theSectionIndex,
-                                    const int    /*thePointIndex*/,
-                                    const Point& thePoint )
+                                     const Point& thePoint,
+                                     const int    thePointIndex )
 {
-  AddPoint( theSectionIndex, thePoint );
+  Handle(TDataStd_RealList) aListX, aListY;
+  getPointsLists( theSectionIndex, aListX, aListY );
+
+  if ( thePointIndex < 0 )
+  {
+    aListX->Prepend( thePoint.X() );
+    aListY->Prepend( thePoint.Y() );
+  }
+  else if ( thePointIndex >= aListX->Extent() )
+  {
+    aListX->Append( thePoint.X() );
+    aListY->Append( thePoint.Y() );
+  }
+  else
+  {
+    TColStd_ListOfReal anOldListX;
+    anOldListX = aListX->List();
+
+    TColStd_ListOfReal anOldListY;
+    anOldListY = aListY->List();
+
+    // Refill the existing lists
+    aListX->Clear();
+    aListY->Clear();
+
+    TColStd_ListIteratorOfListOfReal anIterX( anOldListX );
+    TColStd_ListIteratorOfListOfReal anIterY( anOldListY );
+    for ( int i = 0; anIterX.More() && anIterY.More(); anIterX.Next(), anIterY.Next(), ++i )
+    {
+      double aCoordX = anIterX.Value();
+      double aCoordY = anIterY.Value();
+
+      if ( i == thePointIndex )
+      {
+        // Insert our new point instead of old one
+        aCoordX = thePoint.X();
+        aCoordY = thePoint.Y();
+      }
+
+      aListX->Append( aCoordX );
+      aListY->Append( aCoordY );
+    }
+  }
 }
 
-void HYDROData_PolylineXY::RemovePoint( const int /*theSectionIndex*/,
-                                       const int thePointIndex )
+void HYDROData_PolylineXY::RemovePoint( const int theSectionIndex,
+                                        const int thePointIndex )
 {
-  Handle(TDataStd_RealList) aListU, aListZ;
-  getPointsLists( 0, aListU, aListZ, false );
-  if ( aListU.IsNull() || aListZ.IsNull() || aListU->IsEmpty() )
+  Handle(TDataStd_RealList) aListX, aListY;
+  getPointsLists( theSectionIndex, aListX, aListY, false );
+  if ( aListX.IsNull() || aListY.IsNull() || aListX->IsEmpty() )
     return;
 
-  TColStd_ListOfReal anOldListU;
-  anOldListU = aListU->List();
+  if ( aListX->Extent() == 1 )
+  {
+    removePointsLists( theSectionIndex );
+  }
+  else
+  {
+    TColStd_ListOfReal anOldListX;
+    anOldListX = aListX->List();
 
-  TColStd_ListOfReal anOldListZ;
-  anOldListZ = aListZ->List();
+    TColStd_ListOfReal anOldListY;
+    anOldListY = aListY->List();
 
-  // Creat new lists
-  removePointsLists( 0 );
-  getPointsLists( 0, aListU, aListZ );
+    // Refill the existing lists
+    aListX->Clear();
+    aListY->Clear();
 
-  bool anIsInserted = false;
-  TColStd_ListIteratorOfListOfReal anIterU( anOldListU );
-  TColStd_ListIteratorOfListOfReal anIterZ( anOldListZ );
-  for ( int i = 0; anIterU.More() && anIterZ.More(); anIterU.Next(), anIterZ.Next(), ++i )
-  {
-    if ( i == thePointIndex )
-      continue; // skip index to remove
+    TColStd_ListIteratorOfListOfReal anIterX( anOldListX );
+    TColStd_ListIteratorOfListOfReal anIterY( anOldListY );
+    for ( int i = 0; anIterX.More() && anIterY.More(); anIterX.Next(), anIterY.Next(), ++i )
+    {
+      if ( i == thePointIndex )
+        continue; // skip index to remove
 
-    aListU->Append( anIterU.Value() );
-    aListZ->Append( anIterZ.Value() );
+      aListX->Append( anIterX.Value() );
+      aListY->Append( anIterY.Value() );
+    }
   }
 }
 
-HYDROData_PolylineXY::PointsList HYDROData_PolylineXY::GetPoints( const int /*theSectionIndex*/ ) const
+HYDROData_PolylineXY::PointsList HYDROData_PolylineXY::GetPoints( const int theSectionIndex ) const
 {
   PointsList aResList;
 
-  Handle(TDataStd_RealList) aListU, aListZ;
-  getPointsLists( 0, aListU, aListZ, false );
-  if ( aListU.IsNull() || aListZ.IsNull() )
+  Handle(TDataStd_RealList) aListX, aListY;
+  getPointsLists( theSectionIndex, aListX, aListY, false );
+  if ( aListX.IsNull() || aListY.IsNull() || aListX->IsEmpty() )
     return aResList;
 
-  TColStd_ListIteratorOfListOfReal anIterU( aListU->List() );
-  TColStd_ListIteratorOfListOfReal anIterZ( aListZ->List() );
-  for ( ; anIterU.More() && anIterZ.More(); anIterU.Next(), anIterZ.Next() )
+  TColStd_ListIteratorOfListOfReal anIterX( aListX->List() );
+  TColStd_ListIteratorOfListOfReal anIterY( aListY->List() );
+  for ( ; anIterX.More() && anIterY.More(); anIterX.Next(), anIterY.Next() )
   {
-    Point aPoint( anIterU.Value(), anIterZ.Value() );
+    Point aPoint( anIterX.Value(), anIterY.Value() );
     aResList.Append( aPoint );
   }
 
   return aResList;
 }
 
+QPainterPath HYDROData_PolylineXY::GetPainterPath() const
+{
+  QPainterPath aPath;
+
+  NCollection_Sequence<TCollection_AsciiString>           aSectNames;
+  NCollection_Sequence<HYDROData_PolylineXY::SectionType> aSectTypes;
+  NCollection_Sequence<bool>                              aSectClosures;
+  GetSections( aSectNames, aSectTypes, aSectClosures );
+  if( aSectNames.IsEmpty() )
+    return aPath;
+
+  PointsList aSectPointsList = GetPoints( 0 );
+  if( aSectPointsList.IsEmpty() )
+    return aPath;
+
+  SectionType aSectionType = aSectTypes.Value( 1 );
+  bool anIsSectionClosed = aSectClosures.Value( 1 );
+
+  if ( aSectionType == SECTION_POLYLINE )
+  {
+    aPath.moveTo( aSectPointsList.Value( 1 ).X(), aSectPointsList.Value( 1 ).Y() );
+
+    for( int i = 2, n = aSectPointsList.Size(); i <= n; ++i )
+    {
+      const Point& aSectPoint = aSectPointsList.Value( i );
+
+      aPath.lineTo( aSectPoint.X(), aSectPoint.Y() );
+    }
+
+    if( anIsSectionClosed )
+      aPath.closeSubpath();
+  }
+  else
+  {
+    QList<double> aPoints;
+    for( int i = 1, n = aSectPointsList.Size(); i <= n; ++i )
+    {
+      const Point& aSectPoint = aSectPointsList.Value( i );
+      aPoints << aSectPoint.X() << aSectPoint.Y();
+    }
+
+    HYDROData_BSplineOperation aBSpline( aPoints, 0, anIsSectionClosed );
+    aPath = aBSpline.ComputePath();
+  }
+
+  return aPath;
+}
+