src/HYDROData/HYDROData_PolylineXY.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_PolylineXY.h"
  20
  21 #include "HYDROData_BSplineOperation.h"
  22 #include "HYDROData_Document.h"
  23 #include "HYDROData_ShapesTool.h"
  24 #include "HYDROData_Tool.h"
  25 #include "HYDROData_PolylineOperator.h"
  26 #include "HYDROData_TopoCurve.h"
  27
  28 #include <BRep_Builder.hxx>
  29 #include <BRepBuilderAPI_MakeEdge.hxx>
  30 #include <BRepBuilderAPI_MakeWire.hxx>
  31 #include <BRepBuilderAPI_MakePolygon.hxx>
  32 #include <BRepBuilderAPI_MakeFace.hxx>
  33 #include <BRepOffsetAPI_NormalProjection.hxx>
  34 #include <BRepAdaptor_Curve.hxx>
  35
  36 #ifndef LIGHT_MODE
  37 #include <GEOMBase.h>
  38 #endif
  39
  40 #include <GeomAPI_ProjectPointOnCurve.hxx>
  41 #include <GeomAdaptor_Curve.hxx>
  42 #include <Geom_Line.hxx>
  43 #include <Geom_BSplineCurve.hxx>
  44
  45 #include <GCPnts_AbscissaPoint.hxx>
  46 #include <GCPnts_QuasiUniformDeflection.hxx>
  47 #include <GCPnts_UniformDeflection.hxx>
  48
  49 #include <ImageComposer_MetaTypes.h>
  50
  51 #include <gp_Pnt.hxx>
  52 #include <gp_XY.hxx>
  53 #include <gp_Pln.hxx>
  54
  55 #include <NCollection_Map.hxx>
  56
  57 #include <TCollection_ExtendedString.hxx>
  58
  59 #include <TDataStd_ListIteratorOfListOfByte.hxx>
  60 #include <TColStd_ListIteratorOfListOfInteger.hxx>
  61 #include <TColStd_ListIteratorOfListOfReal.hxx>
  62
  63 #include <TColStd_Array1OfReal.hxx>
  64 #include <TColgp_Array1OfPnt.hxx>
  65
  66 #include <TDataStd_AsciiString.hxx>
  67 #include <TDataStd_BooleanList.hxx>
  68 #include <TDataStd_ExtStringList.hxx>
  69 #include <TDataStd_IntegerList.hxx>
  70 #include <TDataStd_ListIteratorOfListOfExtendedString.hxx>
  71 #include <TDataStd_RealList.hxx>
  72 #include <TDataStd_UAttribute.hxx>
  73
  74 #include <TopoDS_Iterator.hxx>
  75 #include <TopTools_ListIteratorOfListOfShape.hxx>
  76 #include <TopTools_HSequenceOfShape.hxx>
  77 #include <TopExp_Explorer.hxx>
  78 #include <ShapeAnalysis_FreeBounds.hxx>
  79 #include <TopoDS.hxx>
  80
  81 #include <QColor>
  82 #include <QPainterPath>
  83 #include <QVariant>
  84
  85 #define _DEVDEBUG_
  86 #include "HYDRO_trace.hxx"
  87 #include <BRepTools.hxx>
  88 #include <sstream>
  89 #include <cmath>
  90
  91 static const Standard_GUID GUID_IS_UNEDITABLE("e5799736-9030-4051-91a4-2e58321fa153");
  92
  93 const double LOCAL_SELECTION_TOLERANCE = 0.0001;
  94
  95 TCollection_AsciiString getUniqueSectionName( const NCollection_Sequence<TCollection_AsciiString>& theNamesSeq )
  96 {
  97   NCollection_Map<TCollection_AsciiString> aNamesMap;
  98
  99   for ( int i = 1, n = theNamesSeq.Size(); i <= n; ++i )
 100   {
 101     const TCollection_AsciiString& aSectName = theNamesSeq.Value( i );
 102     aNamesMap.Add( aSectName );
 103   }
 104
 105   TCollection_AsciiString aResName;
 106
 107   int aPrefIdx = 1;
 108   do
 109   {
 110     aResName = TCollection_AsciiString( "Section_" ) + aPrefIdx;
 111     ++aPrefIdx;
 112   }
 113   while ( aNamesMap.Contains( aResName ) );
 114
 115   return aResName;
 116 }
 117
 118 TCollection_AsciiString getUniqueSectionName( const Handle(TDataStd_ExtStringList)& theNamesList )
 119 {
 120   NCollection_Sequence<TCollection_AsciiString> aNamesSeq;
 121
 122   TDataStd_ListIteratorOfListOfExtendedString aNamesIter( theNamesList->List() );
 123   for ( ; aNamesIter.More(); aNamesIter.Next() )
 124     aNamesSeq.Append( aNamesIter.Value() );
 125
 126   return getUniqueSectionName( aNamesSeq );
 127 }
 128
 129 IMPLEMENT_STANDARD_HANDLE(HYDROData_PolylineXY, HYDROData_IPolyline)
 130 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_PolylineXY, HYDROData_IPolyline)
 131
 132 HYDROData_PolylineXY::HYDROData_PolylineXY()
 133 : HYDROData_IPolyline(),
 134   myIsInCustomFlag( false )
 135 {
 136 }
 137
 138 HYDROData_PolylineXY::~HYDROData_PolylineXY()
 139 {
 140 }
 141
 142 QStringList HYDROData_PolylineXY::DumpToPython( const QString&       thePyScriptPath,
 143                                                 MapOfTreatedObjects& theTreatedObjects ) const
 144 {
 145   QStringList aResList = dumpObjectCreation( theTreatedObjects );
 146   QString aPolylineName = GetObjPyName();
 147
 148   // Set the wire color
 149   QStringList aWireColorDef;
 150
 151   QColor aWireColor = GetWireColor();
 152   setPythonObjectColor( aWireColorDef, aWireColor, DefaultWireColor(), "SetWireColor" );
 153
 154   if ( !aWireColorDef.isEmpty() )
 155   {
 156     aResList << aWireColorDef;
 157     aResList << QString( "" );
 158   }
 159
 160   bool anIsEditable = IsEditable();
 161   if ( !anIsEditable )
 162   {
 163     // If polyline is not editable we try to import the shape from geom
 164     TCollection_AsciiString aGeomObjectEntry = GetGeomObjectEntry();
 165     if ( !aGeomObjectEntry.IsEmpty() )
 166     {
 167       QString aSalomeObjName = HYDROData_Tool::GenerateNameForPython( theTreatedObjects, "polyline_sobj" );
 168       aResList << QString( "%1 = salome.myStudy.FindObjectID( \"%2\" )" )
 169                   .arg( aSalomeObjName ).arg( aGeomObjectEntry.ToCString() );
 170
 171       aResList << QString( "%1.ImportFromGeomIOR( %2.GetIOR() )" )
 172                   .arg( aPolylineName ).arg( aSalomeObjName );
 173
 174       aResList << QString( "%1.SetGeomObjectEntry( \"%2\" )" )
 175                   .arg( aPolylineName ).arg( aGeomObjectEntry.ToCString() );
 176     }
 177   }
 178   else
 179   {
 180     // Set polyline data
 181     NCollection_Sequence<TCollection_AsciiString>           aSectNames;
 182     NCollection_Sequence<HYDROData_PolylineXY::SectionType> aSectTypes;
 183     NCollection_Sequence<bool>                              aSectClosures;
 184     GetSections( aSectNames, aSectTypes, aSectClosures );
 185
 186     for ( int i = 1, n = aSectNames.Size(); i <= n; ++i )
 187     {
 188       const TCollection_AsciiString& aSectName = aSectNames.Value( i );
 189       const SectionType& aSectType = aSectTypes.Value( i );
 190       bool aSectClosure = aSectClosures.Value( i );
 191
 192       aResList << QString( "%1.AddSection( \"%2\", %3, %4 )" ).arg( aPolylineName )
 193                   .arg( aSectName.ToCString() ).arg( aSectType ).arg( aSectClosure );
 194
 195       HYDROData_IPolyline::PointsList aSectPointsList = GetPoints( i - 1 );
 196       for ( int k = 1, aNbPoints = aSectPointsList.Size(); k <= aNbPoints; ++k )
 197       {
 198         const Point& aSectPoint = aSectPointsList.Value( k );
 199
 200         QString anXStr = QString::number( aSectPoint.X(), 'f', 2 );
 201         QString anYStr = QString::number( aSectPoint.Y(), 'f', 2 );
 202         aResList << QString( "%1.AddPoint( %2, gp_XY( %3, %4 ) )" ).arg( aPolylineName )
 203           .arg( i - 1 ).arg( anXStr ).arg( anYStr );
 204       }
 205     }
 206   }
 207   aResList << QString( "" );
 208   aResList << QString( "%1.Update()" ).arg( aPolylineName );
 209   aResList << QString( "" );
 210
 211   return aResList;
 212 }
 213
 214 QVariant HYDROData_PolylineXY::GetDataVariant()
 215 {
 216   QPainterPath aPath = GetPainterPath();
 217
 218   QVariant aVarData;
 219   aVarData.setValue<QPainterPath>( aPath );
 220
 221   return aVarData;
 222 }
 223
 224 QColor HYDROData_PolylineXY::DefaultWireColor()
 225 {
 226   return QColor( Qt::black );
 227 }
 228
 229 bool HYDROData_PolylineXY::ImportFromGeomIOR( const TCollection_AsciiString& theIOR )
 230 {
 231 #ifdef LIGHT_MODE
 232   return false;
 233 #else
 234   if ( theIOR.IsEmpty() )
 235     return false;
 236
 237   TopoDS_Shape aShape = GEOMBase::GetShapeFromIOR( theIOR.ToCString() );
 238   if ( aShape.IsNull() )
 239     return false;
 240
 241   return ImportShape( aShape, false );
 242 #endif
 243 }
 244
 245 void HYDROData_PolylineXY::SetGeomObjectEntry( const TCollection_AsciiString& theEntry )
 246 {
 247   TDataStd_AsciiString::Set( myLab.FindChild( DataTag_GeomObjectEntry ), theEntry );
 248 }
 249
 250 TCollection_AsciiString HYDROData_PolylineXY::GetGeomObjectEntry() const
 251 {
 252   TCollection_AsciiString aRes;
 253
 254   TDF_Label aLabel = myLab.FindChild( DataTag_GeomObjectEntry, false );
 255   if ( !aLabel.IsNull() )
 256   {
 257     Handle(TDataStd_AsciiString) anAsciiStr;
 258     if ( aLabel.FindAttribute( TDataStd_AsciiString::GetID(), anAsciiStr ) )
 259       aRes = anAsciiStr->Get();
 260   }
 261
 262   return aRes;
 263 }
 264
 265 bool convertEdgeToSection( const TopoDS_Edge&                                       theEdge,
 266                            NCollection_Sequence<TCollection_AsciiString>&           theSectNames,
 267                            NCollection_Sequence<HYDROData_PolylineXY::SectionType>& theSectTypes,
 268                            NCollection_Sequence<bool>&                              theSectClosures,
 269                            NCollection_Sequence<HYDROData_PolylineXY::PointsList>&  theSectPoints,
 270                            bool                                                     IsCanBeClosed,
 271                            bool                                                     IsInterpolationAllowed,
 272                            double                                                   theDeflection )
 273 {
 274   Standard_Real aFirst = 0.0, aLast = 0.0;
 275   Handle(Geom_Curve) anEdgeGeomCurve = BRep_Tool::Curve( theEdge, aFirst, aLast );
 276   if ( anEdgeGeomCurve.IsNull() )
 277     return false;
 278
 279   TCollection_AsciiString aSectName = getUniqueSectionName( theSectNames );
 280   bool anIsEdgeClosed = anEdgeGeomCurve->IsClosed();
 281
 282   HYDROData_PolylineXY::SectionType aSectionType = HYDROData_PolylineXY::SECTION_POLYLINE;
 283   HYDROData_PolylineXY::PointsList aPointsList;
 284
 285   if( anEdgeGeomCurve->IsKind( STANDARD_TYPE(Geom_Line) ) )
 286   {
 287     Handle(Geom_Line) aGeomLine = Handle(Geom_Line)::DownCast( anEdgeGeomCurve );
 288
 289     gp_Pnt aFirstPoint, aLastPoint;
 290     aGeomLine->D0( aFirst, aFirstPoint );
 291     aGeomLine->D0( aLast, aLastPoint );
 292
 293     HYDROData_PolylineXY::Point aSectFirstPoint( aFirstPoint.X(), aFirstPoint.Y() );
 294     aPointsList.Append( aSectFirstPoint );
 295
 296     HYDROData_PolylineXY::Point aSectLastPoint( aLastPoint.X(), aLastPoint.Y() );
 297     aPointsList.Append( aSectLastPoint );
 298   }
 299   else if ( anEdgeGeomCurve->IsKind( STANDARD_TYPE(Geom_BSplineCurve) ) || IsInterpolationAllowed )
 300   {
 301     aSectionType = HYDROData_PolylineXY::SECTION_SPLINE;
 302
 303     BRepAdaptor_Curve anAdaptorCurve( theEdge );
 304     GCPnts_QuasiUniformDeflection aDiscrete( anAdaptorCurve, theDeflection );
 305     //GCPnts_UniformDeflection aDiscrete( anAdaptorCurve, theDeflection );
 306
 307     int aNbPoints = aDiscrete.NbPoints();
 308
 309     // Decrease the number of imported poles because of last one
 310     // pole is the closing point which are the start point
 311     if ( anIsEdgeClosed ) aNbPoints--;
 312
 313     for ( int i = 1; i <= aNbPoints; ++i )
 314     {
 315       const gp_Pnt& aPoint = aDiscrete.Value( i );
 316
 317       HYDROData_PolylineXY::Point aSectPoint( aPoint.X(), aPoint.Y() );
 318       aPointsList.Append( aSectPoint );
 319     }
 320   }
 321   else
 322   {
 323     // Other curve types are not supported
 324     return false;
 325   }
 326
 327   if ( aPointsList.IsEmpty() )
 328     return false;
 329
 330   theSectNames.Append( aSectName );
 331   theSectTypes.Append( aSectionType );
 332   theSectClosures.Append( anIsEdgeClosed );
 333   theSectPoints.Append( aPointsList );
 334
 335   return true;
 336 }
 337
 338
 339 bool convertEdgesToSections( const TopoDS_Edge&                                       theEdge,
 340                              NCollection_Sequence<TCollection_AsciiString>&           theSectNames,
 341                              NCollection_Sequence<HYDROData_PolylineXY::SectionType>& theSectTypes,
 342                              NCollection_Sequence<bool>&                              theSectClosures,
 343                              NCollection_Sequence<HYDROData_PolylineXY::PointsList>&  theSectPoints,
 344                              bool                                                     IsCanBeClosed,
 345                              bool                                                     IsInterpolationAllowed,
 346                              double                                                   theDeflection,
 347                              const Handle( HYDROData_PolylineXY )&                    theOldPolyline )
 348 {
 349   DEBTRACE("convertEdgesToSections")
 350   Standard_Real aFirst = 0.0, aLast = 0.0;
 351   Handle(Geom_Curve) anEdgeGeomCurve = BRep_Tool::Curve( theEdge, aFirst, aLast );
 352   if ( anEdgeGeomCurve.IsNull() )
 353     return false;
 354
 355   bool isPrevious = (theSectTypes.Size() > 0);
 356   DEBTRACE("nb sections: " << theSectTypes.Size());
 357   HYDROData_PolylineXY::SectionType prevSectType = HYDROData_PolylineXY::SECTION_SPLINE;;
 358   HYDROData_PolylineXY::PointsList prevPointList;
 359   bool isPrevClosed = true;
 360   if (isPrevious)
 361     {
 362        prevSectType = theSectTypes.Last();
 363        prevPointList = theSectPoints.Last();
 364        isPrevClosed = theSectClosures.Last();
 365     }
 366
 367   bool anIsEdgeClosed = anEdgeGeomCurve->IsClosed();
 368   anIsEdgeClosed &= IsCanBeClosed; // on split, resulting edges are normally not closed...
 369   HYDROData_PolylineXY::SectionType aSectionType ;
 370   if( anEdgeGeomCurve->IsKind( STANDARD_TYPE(Geom_Line) ) )
 371     {
 372       aSectionType = HYDROData_PolylineXY::SECTION_POLYLINE;
 373     }
 374   else if ( anEdgeGeomCurve->IsKind( STANDARD_TYPE(Geom_BSplineCurve) ) || IsInterpolationAllowed )
 375     {
 376       aSectionType = HYDROData_PolylineXY::SECTION_SPLINE;
 377     }
 378   else
 379     {
 380       // Other curve types are not supported
 381       return false;
 382     }
 383
 384   bool isNewSection = !isPrevious || isPrevClosed || anIsEdgeClosed || prevSectType != aSectionType;
 385   DEBTRACE(isNewSection <<": " << !isPrevious << " " << isPrevClosed << " " << anIsEdgeClosed << " " << (prevSectType != aSectionType));
 386
 387   HYDROData_PolylineXY::PointsList aPointsList;
 388   if (!isNewSection)
 389     {
 390       aPointsList = prevPointList;
 391     }
 392
 393   if( aSectionType == HYDROData_PolylineXY::SECTION_POLYLINE )
 394     {
 395       DEBTRACE("SECTION_POLYLINE");
 396       Handle(Geom_Line) aGeomLine = Handle(Geom_Line)::DownCast( anEdgeGeomCurve );
 397
 398       gp_Pnt aFirstPoint, aLastPoint;
 399       aGeomLine->D0( aFirst, aFirstPoint );
 400       aGeomLine->D0( aLast, aLastPoint );
 401       HYDROData_PolylineXY::Point aSectFirstPoint( aFirstPoint.X(), aFirstPoint.Y() );
 402       HYDROData_PolylineXY::Point aSectLastPoint( aLastPoint.X(), aLastPoint.Y() );
 403      if (!isNewSection)
 404         {
 405           if (aSectFirstPoint == prevPointList.Last())
 406             {
 407               DEBTRACE("points shared: a");//aPointsList.Append( aSectFirstPoint );
 408               aPointsList.Append( aSectLastPoint );
 409             }
 410           else if (aSectLastPoint == prevPointList.Last())
 411             {
 412               DEBTRACE("points shared: b");//aPointsList.Append( aSectLastPoint );
 413               aPointsList.Append( aSectFirstPoint );
 414             }
 415           else if (aSectFirstPoint == prevPointList.First())
 416             {
 417               DEBTRACE("points shared: c");//aPointsList.Prepend( aSectFirstPoint );
 418               aPointsList.Prepend( aSectLastPoint );
 419             }
 420           else if (aSectLastPoint == prevPointList.First())
 421             {
 422               DEBTRACE("points shared: d");//aPointsList.Prepend( aSectLastPoint );
 423               aPointsList.Prepend( aSectFirstPoint );
 424             }
 425           else
 426             {
 427               DEBTRACE("no point shared")
 428               isNewSection = true; // no point shared, new section
 429               aPointsList.Clear();
 430               aPointsList.Append( aSectFirstPoint );
 431               aPointsList.Append( aSectLastPoint );
 432             }
 433         }
 434      else
 435        {
 436          DEBTRACE("new section");
 437          aPointsList.Append( aSectFirstPoint );
 438          aPointsList.Append( aSectLastPoint );
 439        }
 440     }
 441   else // aSectionType == HYDROData_PolylineXY::SECTION_SPLINE
 442     {
 443       DEBTRACE("SECTION_SPLINE");
 444       isNewSection = true;
 445       aPointsList.Clear();
 446
 447       BRepAdaptor_Curve anAdaptorCurve(theEdge);
 448       if (theOldPolyline.IsNull()) // --- no previous polyline: build a set of points from scratch for the spline
 449         {
 450           GCPnts_QuasiUniformDeflection aDiscrete(anAdaptorCurve, theDeflection);
 451
 452           int aNbPoints = aDiscrete.NbPoints();
 453
 454           // Decrease the number of imported poles because of last one
 455           // pole is the closing point which are the start point
 456           if (anIsEdgeClosed)
 457             aNbPoints--;
 458
 459           for (int i = 1; i <= aNbPoints; ++i)
 460             {
 461               const gp_Pnt& aPoint = aDiscrete.Value(i);
 462               HYDROData_PolylineXY::Point aSectPoint(aPoint.X(), aPoint.Y());
 463               aPointsList.Append(aSectPoint);
 464             }
 465
 466           gp_Pnt endPts[] = {gp_Pnt(aPointsList.First().X(),aPointsList.First().Y(), 0),
 467                              gp_Pnt(aPointsList.Last().X(),aPointsList.Last().Y(), 0) };
 468           DEBTRACE("curve start: "<< endPts[0].X() << " " << endPts[0].Y());
 469           DEBTRACE("curve end: "<< endPts[1].X() << " " << endPts[1].Y());
 470         }
 471       else // --- split of a previous polyline: try to retrieve old sets of points and add intersection points
 472         {
 473           const gp_Pnt aEndPs[] = { anAdaptorCurve.Value(anAdaptorCurve.FirstParameter()).XYZ(),
 474                                     anAdaptorCurve.Value(anAdaptorCurve.LastParameter()).XYZ() };
 475           double midPar = (anAdaptorCurve.LastParameter() + anAdaptorCurve.FirstParameter())/2;
 476           gp_Pnt midPnt;
 477           anAdaptorCurve.D0(midPar, midPnt);
 478           DEBTRACE("curve first point: " << aEndPs[0].X() << " " << aEndPs[0].Y() << " " << aEndPs[0].Z());
 479           DEBTRACE("curve last point: " << aEndPs[1].X() << " " << aEndPs[1].Y() << " " << aEndPs[1].Z());
 480           DEBTRACE("curve mid point: " << midPnt.X() << " " << midPnt.Y() << " " << midPnt.Z());
 481
 482           std::vector<TopoDS_Wire> aCurves;
 483           HYDROData_PolylineOperator::GetWires(theOldPolyline, aCurves);
 484
 485           int nbSections = theOldPolyline->NbSections();
 486           DEBTRACE("nbSections: "<< nbSections << ", nbCurves: " << aCurves.size() );
 487           for (int isec = 0; isec < nbSections; isec++)
 488             {
 489               DEBTRACE("section: "<< isec);
 490               bool isOldSectionclosed = theOldPolyline->IsClosedSection(isec);
 491               TopoDS_Wire aWire = aCurves[isec]; // we suppose sections and wires are in the same order
 492               TopExp_Explorer anExp(aWire, TopAbs_EDGE);
 493               TopoDS_Edge anEdge = TopoDS::Edge(anExp.Current()); // the first is OK: only one normally with splines
 494               BRepAdaptor_Curve adaptorOldCurve(anEdge);
 495               double pfirst = adaptorOldCurve.FirstParameter();
 496               double plast = adaptorOldCurve.LastParameter();
 497               DEBTRACE("previous curve first last : "<< pfirst << " " << plast);
 498               double p[3] = {-1, -1};
 499               double d0= ProjectPointToCurve(aEndPs[0].XYZ(), adaptorOldCurve,p[0]);
 500               double d1= ProjectPointToCurve(aEndPs[1].XYZ(), adaptorOldCurve,p[1]);
 501               double d2= ProjectPointToCurve(midPnt.XYZ(), adaptorOldCurve, p[2]);
 502               DEBTRACE("d0: "<<d0<<" d1: "<<d1<<" d2: "<<d2<<" p0: "<<p[0]<<" p1: "<<p[1]<<" p2: "<<p[2]);
 503               if ((d0 < 1.e-3) and (d1 < 1.e-3) and (d2 < 1.e-3)) // we got the good old curve (and the good section)
 504                 {
 505                   double pmin = p[0];
 506                   double pmax = p[1];
 507                   bool forward = true;
 508                   if (! isOldSectionclosed) // no need to check first and last points on an open curve
 509                     {
 510                       pmin = p[1];
 511                       pmax = p[0];
 512                       forward = false;
 513                     }
 514                   else // old section closed: check if we use first or last points...
 515                     {
 516                       if((pmin < pmax) and((abs(pmin - pfirst)> 1.e-3) and (abs(pmax - plast) >1.e-3))) // internal points forward
 517                         forward = true;
 518                       else if ((pmin > pmax) and((abs(pmin - plast)> 1.e-3) and (abs(pmax - pfirst) >1.e-3))) // internal points reverse
 519                         {
 520                           pmin = p[1];
 521                           pmax = p[0];
 522                           forward = false;
 523                         }
 524                       else if ((abs(pmin - plast) <1.e-3) and (p[2] < pmax)) // forward, replace pmin par pfirst
 525                           pmin = pfirst;
 526                       else if ((abs(pmin - plast) <1.e-3) and (p[2] > pmax)) // reverse
 527                         {
 528                           pmin = p[1];
 529                           pmax = p[0];
 530                           forward = false;
 531                         }
 532                       else if ((abs(pmax - pfirst) <1.e-3) and (p[2] < pmin)) // reverse
 533                         {
 534                           pmin = p[1];
 535                           pmax = p[0];
 536                           forward = false;
 537                         }
 538                       else if ((abs(pmax - pfirst) <1.e-3) and (p[2] > pmin)) // forward, replace pmax par plast
 539                         pmax = plast;
 540                    }
 541                   HYDROData_PolylineXY::Point aFirstPoint, aLastPoint;
 542                   if (forward)
 543                     {
 544                       aFirstPoint = HYDROData_PolylineXY::Point(aEndPs[0].X(), aEndPs[0].Y());
 545                       aLastPoint = HYDROData_PolylineXY::Point(aEndPs[1].X(), aEndPs[1].Y());
 546                     }
 547                   else
 548                     {
 549                       aFirstPoint = HYDROData_PolylineXY::Point(aEndPs[1].X(), aEndPs[1].Y());
 550                       aLastPoint = HYDROData_PolylineXY::Point(aEndPs[0].X(), aEndPs[0].Y());
 551                     }
 552                   aPointsList.Append(aFirstPoint);
 553
 554                   HYDROData_PolylineXY::PointsList aSectPoints = theOldPolyline->GetPoints(isec, false);
 555                   int nbPoints = aSectPoints.Length();
 556                   if (forward)
 557                     for (int i=1; i<nbPoints; i++)
 558                       {
 559                         HYDROData_PolylineXY::Point aPoint = aSectPoints.Value(i);
 560                         gp_XYZ p(aPoint.X(), aPoint.Y(), 0);
 561                         double param =-1;
 562                         double d = ProjectPointToCurve(p, adaptorOldCurve, param);
 563                         if ((param > pmin) and (param < pmax))
 564                           {
 565                             DEBTRACE("param: " << param);
 566                             aPointsList.Append(aPoint);
 567                           }
 568                       }
 569                   else
 570                     for (int i=nbPoints -1; i>0; i--)
 571                       {
 572                         HYDROData_PolylineXY::Point aPoint = aSectPoints.Value(i);
 573                         gp_XYZ p(aPoint.X(), aPoint.Y(), 0);
 574                         double param =-1;
 575                         double d = ProjectPointToCurve(p, adaptorOldCurve, param);
 576                         if ((param > pmin) and (param < pmax))
 577                           {
 578                             DEBTRACE("param: " << param);
 579                             aPointsList.Append(aPoint);
 580                           }
 581                       }
 582
 583                   aPointsList.Append(aLastPoint);
 584                 }
 585
 586             }
 587         }
 588     }
 589
 590   if ( aPointsList.IsEmpty() )
 591     return false;
 592
 593   TCollection_AsciiString aSectName = getUniqueSectionName( theSectNames );
 594   if (isNewSection)
 595     {
 596       DEBTRACE("isNewSection");
 597       theSectNames.Append( aSectName );
 598       theSectTypes.Append( aSectionType );
 599       theSectClosures.Append( anIsEdgeClosed );
 600       theSectPoints.Append( aPointsList );
 601     }
 602   else
 603     {
 604       DEBTRACE("sameSection");
 605       theSectPoints.SetValue(theSectPoints.Length(), aPointsList);
 606     }
 607
 608   return true;
 609 }
 610
 611 bool HYDROData_PolylineXY::ImportShape( const TopoDS_Shape& theShape,
 612                                         bool IsInterpolationAllowed,
 613                                         const Handle( HYDROData_PolylineXY )& theOldPolyline,
 614                                         bool IsClosureAllowed,
 615                                         double theDeviation )
 616 {
 617   DEBTRACE("ImportShape");
 618   if ( theShape.IsNull() )
 619     return false;
 620
 621   RemoveSections();
 622
 623   bool anIsCanBeImported = false;
 624
 625   NCollection_Sequence<TCollection_AsciiString> aSectNames;
 626   NCollection_Sequence<SectionType>             aSectTypes;
 627   NCollection_Sequence<bool>                    aSectClosures;
 628   NCollection_Sequence<PointsList>              aSectPoints;
 629
 630   if ( theShape.ShapeType() == TopAbs_EDGE )
 631   {
 632       DEBTRACE("TopAbs_EDGE");
 633     TopoDS_Edge anEdge = TopoDS::Edge( theShape );
 634 //    anIsCanBeImported = convertEdgeToSection( anEdge, aSectNames, aSectTypes,
 635 //      aSectClosures, aSectPoints, true, IsInterpolationAllowed, theDeviation );
 636     anIsCanBeImported = convertEdgesToSections( anEdge, aSectNames, aSectTypes, aSectClosures,
 637                                                 aSectPoints, IsClosureAllowed, IsInterpolationAllowed,
 638                                                 theDeviation, theOldPolyline );
 639   }
 640   else if ( theShape.ShapeType() == TopAbs_WIRE )
 641   {
 642       DEBTRACE("TopAbs_WIRE");
 643     TopTools_SequenceOfShape anEdges;
 644     HYDROData_ShapesTool::ExploreShapeToShapes( theShape, TopAbs_EDGE, anEdges );
 645
 646     anIsCanBeImported = !anEdges.IsEmpty();
 647     for ( int i = 1, n = anEdges.Length(); i <= n && anIsCanBeImported; ++i )
 648     {
 649       TopoDS_Edge aWireEdge = TopoDS::Edge( anEdges.Value( i ) );
 650       anIsCanBeImported = convertEdgesToSections( aWireEdge, aSectNames, aSectTypes, aSectClosures,
 651                                                   aSectPoints, IsClosureAllowed, IsInterpolationAllowed,
 652                                                   theDeviation, theOldPolyline );
 653     }
 654   }
 655
 656   if ( anIsCanBeImported )
 657   {
 658     for ( int i = 1, n = aSectNames.Length(); i <= n; ++i )
 659     {
 660       const TCollection_AsciiString& aSectName = aSectNames.Value( i );
 661       const SectionType& aSectType = aSectTypes.Value( i );
 662       bool anIsSectionClosed = aSectClosures.Value( i );
 663       const PointsList& aSectPointsList = aSectPoints( i );
 664
 665       AddSection( aSectName, aSectType, anIsSectionClosed );
 666       SetPoints( i - 1, aSectPointsList );
 667     }
 668   }
 669   else
 670   {
 671     TopoDS_Shape aShape = theShape;
 672
 673     if ( theShape.ShapeType() == TopAbs_EDGE )
 674     {
 675       // We make the wire from incoming edge because of other algorithms
 676       // are waiting at least the wire from polyline
 677       TopoDS_Edge anEdge = TopoDS::Edge( theShape );
 678       BRepBuilderAPI_MakeWire aMakeWire( anEdge );
 679       aMakeWire.Build();
 680       if ( aMakeWire.IsDone() )
 681         aShape = aMakeWire.Wire();
 682     }
 683
 684     gp_Pln aPlane( gp_Pnt( 0, 0, 0 ), gp_Dir( 0, 0, 1 ) );
 685     BRepBuilderAPI_MakeFace aMakeFace( aPlane );
 686     aMakeFace.Build();
 687     BRepOffsetAPI_NormalProjection aProj( aMakeFace.Face() );
 688     aProj.Add( aShape );
 689     aProj.Build();
 690     TopoDS_Shape aResult;
 691     if( aProj.IsDone() )
 692       aResult = aProj.Shape();
 693
 694     SetShape( aResult );
 695   }
 696
 697   setEditable( anIsCanBeImported );
 698
 699   return true;
 700 }
 701
 702 TopoDS_Wire HYDROData_PolylineXY::BuildWire( const SectionType&                  theType,
 703                                              const bool&                         theIsClosed,
 704                                              const NCollection_Sequence<gp_XYZ>& thePoints )
 705 {
 706   TopoDS_Wire aWire;
 707   if( theType == SECTION_POLYLINE )
 708   {
 709     int aNbPoints = thePoints.Length();
 710     BRepBuilderAPI_MakePolygon aMakeWire;
 711     for ( int i = 1, n = aNbPoints; i <= n ; ++i )
 712     {
 713       gp_XYZ aPoint = thePoints.Value( i );
 714       gp_Pnt aPnt( aPoint.X(), aPoint.Y(), aPoint.Z() );
 715       aMakeWire.Add( aPnt );
 716     }
 717     if( theIsClosed && ( aNbPoints > 2 ) )
 718       aMakeWire.Close();
 719
 720     if ( aMakeWire.IsDone() )
 721       aWire = aMakeWire.Wire();
 722   }
 723   else //if( theType == PolylineSection::SECTION_SPLINE )
 724   {
 725     BRepBuilderAPI_MakeWire aMakeWire;
 726
 727     if ( thePoints.Size() > 1 )
 728     {
 729       Handle(Geom_BSplineCurve) aCurve =
 730         HYDROData_BSplineOperation::ComputeCurve( thePoints, theIsClosed, LOCAL_SELECTION_TOLERANCE );
 731
 732       TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge( aCurve ).Edge();
 733       aMakeWire.Add( anEdge );
 734     }
 735     aMakeWire.Build();
 736     if ( aMakeWire.IsDone() )
 737       aWire = aMakeWire;
 738   }
 739
 740   return aWire;
 741 }
 742
 743 void HYDROData_PolylineXY::BuildPainterPath( QPainterPath&                       thePath,
 744                                              const SectionType&                  theType,
 745                                              const bool&                         theIsClosed,
 746                                              const NCollection_Sequence<gp_XYZ>& thePoints )
 747 {
 748   if ( thePoints.IsEmpty() )
 749     return;
 750
 751   if ( theType == SECTION_POLYLINE )
 752   {
 753     const gp_XYZ& aFirstPoint = thePoints.Value( 1 );
 754     thePath.moveTo( aFirstPoint.X(), aFirstPoint.Y() );
 755
 756     for( int i = 2, n = thePoints.Size(); i <= n; ++i )
 757     {
 758       const gp_XYZ& aSectPoint = thePoints.Value( i );
 759
 760       thePath.lineTo( aSectPoint.X(), aSectPoint.Y() );
 761     }
 762
 763     if( theIsClosed )
 764       thePath.closeSubpath();
 765   }
 766   else
 767   {
 768     Handle(Geom_BSplineCurve) aCurve =
 769       HYDROData_BSplineOperation::ComputeCurve( thePoints, theIsClosed, LOCAL_SELECTION_TOLERANCE );
 770     HYDROData_BSplineOperation::ComputePath( aCurve, thePath );
 771   }
 772 }
 773
 774 void HYDROData_PolylineXY::Update()
 775 {
 776   if ( !IsEditable() )
 777   {
 778     // If polyline is not editable we no need to update it wire
 779     ClearChanged();
 780     return;
 781   }
 782
 783   HYDROData_IPolyline::Update();
 784
 785   NCollection_Sequence<TCollection_AsciiString>           aSectNames;
 786   NCollection_Sequence<HYDROData_PolylineXY::SectionType> aSectTypes;
 787   NCollection_Sequence<bool>                              aSectClosures;
 788   GetSections( aSectNames, aSectTypes, aSectClosures );
 789
 790   //BRepBuilderAPI_MakeWire aMakeWire;
 791
 792   TopTools_ListOfShape aSectionWiresList;
 793
 794   for ( int aSectionId = 1, aNbSects = aSectNames.Size(); aSectionId <= aNbSects; aSectionId++ )
 795   {
 796     TCollection_AsciiString aSectName = aSectNames.Value( aSectionId );
 797     SectionType aSectionType = aSectTypes.Value( aSectionId );
 798     bool anIsSectionClosed = aSectClosures.Value( aSectionId );
 799
 800     PointsList aSectPointsList = GetPoints( aSectionId - 1 );
 801     if ( aSectPointsList.IsEmpty() )
 802       continue;
 803
 804     NCollection_Sequence<gp_XYZ> aPoints;
 805     for( int i = 1, n = aSectPointsList.Size(); i <= n; ++i )
 806     {
 807       const Point& aSectPoint = aSectPointsList.Value( i );
 808
 809       gp_XYZ aPoint( aSectPoint.X(), aSectPoint.Y(), 0.0 );
 810       aPoints.Append( aPoint );
 811     }
 812
 813     TopoDS_Wire aSectionWire = BuildWire( aSectionType, anIsSectionClosed, aPoints );
 814     if ( !aSectionWire.IsNull() ) {
 815       aSectionWiresList.Append( aSectionWire );
 816       //aMakeWire.Add( aSectionWire );
 817     }
 818   }
 819 // all input wires in the <aSectionWiresList>
 820   Handle(TopTools_HSequenceOfShape) aSeqWires = new TopTools_HSequenceOfShape;
 821   Handle(TopTools_HSequenceOfShape) aSeqEdges = new TopTools_HSequenceOfShape;
 822   TopTools_ListIteratorOfListOfShape it(aSectionWiresList);
 823   for(;it.More();it.Next())
 824   {
 825     TopExp_Explorer it2(it.Value(), TopAbs_EDGE);
 826     for(;it2.More();it2.Next())
 827       aSeqEdges->Append(it2.Current());
 828   }
 829
 830   BRep_Builder aBB;
 831   TopoDS_Compound aCmp;
 832   TopoDS_Shape aResult;
 833   aBB.MakeCompound(aCmp);
 834   if(aSeqEdges->Length() >1)
 835   {
 836     ShapeAnalysis_FreeBounds::ConnectEdgesToWires( aSeqEdges, 1E-5, Standard_True, aSeqWires );
 837
 838     if( aSeqWires->Length()==1 )
 839       aResult = aSeqWires->Value( 1 );
 840     else
 841     {
 842       for (Standard_Integer i = 1; i <= aSeqWires->Length();i++)
 843       {
 844         const TopoDS_Shape& aS1 = aSeqWires->Value(i);
 845         aBB.Add(aCmp, aS1);
 846       }
 847       aResult = aCmp;
 848     }
 849   }
 850   else if (aSeqEdges->Length() == 1)
 851   {
 852     BRepBuilderAPI_MakeWire mkWire (TopoDS::Edge(aSeqEdges->Value(1)));
 853     if (mkWire.IsDone())
 854       aResult = mkWire.Wire();
 855   }
 856
 857   SetShape( aResult );
 858 }
 859
 860 bool HYDROData_PolylineXY::IsHas2dPrs() const
 861 {
 862   return true;
 863 }
 864
 865 bool HYDROData_PolylineXY::IsEditable() const
 866 {
 867   return !myLab.IsAttribute( GUID_IS_UNEDITABLE );
 868 }
 869
 870 void HYDROData_PolylineXY::setEditable( const bool theIsEditable )
 871 {
 872   if ( !theIsEditable )
 873     TDataStd_UAttribute::Set( myLab, GUID_IS_UNEDITABLE );
 874   else
 875     myLab.ForgetAttribute( GUID_IS_UNEDITABLE );
 876 }
 877
 878 /**
 879  * Returns true if polyline is closed
 880  */
 881 bool HYDROData_PolylineXY::IsClosed( const bool theIsSimpleCheck ) const
 882 {
 883   bool anIsClosed = false;
 884
 885   TopoDS_Shape aShape = GetShape();
 886   if ( aShape.IsNull() )
 887     return anIsClosed;
 888
 889   TopTools_SequenceOfShape aWires;
 890   HYDROData_ShapesTool::ExploreShapeToShapes( aShape, TopAbs_WIRE, aWires );
 891
 892   int aNbWires = aWires.Length();
 893   if ( theIsSimpleCheck )
 894   {
 895     anIsClosed = aNbWires > 0;
 896     for ( int i = 1; i <= aNbWires && anIsClosed; ++i )
 897     {
 898       const TopoDS_Shape& aWire = aWires.Value( i );
 899       anIsClosed = BRep_Tool::IsClosed( aWire );
 900     }
 901   }
 902   else
 903   {
 904     anIsClosed = aNbWires == 1 && BRep_Tool::IsClosed( aWires.First() );
 905   }
 906
 907   return anIsClosed;
 908 }
 909
 910 double HYDROData_PolylineXY::GetDistance( const int theSectionIndex,
 911                                           const int thePointIndex ) const
 912 {
 913   double aResDistance = -1;
 914   if ( theSectionIndex < 0 || theSectionIndex >= NbSections() )
 915     return aResDistance;
 916
 917   if ( thePointIndex == 0 )
 918     return 0.0;
 919
 920   SectionType aSectionType = GetSectionType( theSectionIndex );
 921   bool anIsSectionClosed = IsClosedSection( theSectionIndex );
 922   PointsList aSectPointsList = GetPoints( theSectionIndex );
 923   if ( thePointIndex < 0 || thePointIndex >= aSectPointsList.Size()  )
 924     return aResDistance;
 925
 926   if ( aSectionType == SECTION_POLYLINE )
 927   {
 928     aResDistance = 0.0;
 929
 930     Point aPrevPoint = aSectPointsList.Value( 1 );
 931     for ( int i = 2, aNbPoints = aSectPointsList.Size(); i <= aNbPoints; ++i )
 932     {
 933       const Point& aSectPoint = aSectPointsList.Value( i );
 934       aResDistance += gp_Pnt2d( aPrevPoint ).Distance( aSectPoint );
 935       aPrevPoint = aSectPoint;
 936
 937       if ( thePointIndex == i - 1 )
 938         break;
 939     }
 940   }
 941   else
 942   {
 943     gp_XYZ aPointToTest;
 944
 945     int aSectNbPoints = aSectPointsList.Size();
 946     NCollection_Sequence<gp_XYZ> aPoints;
 947     for( int i = 1 ; i <= aSectNbPoints; ++i )
 948     {
 949       const Point& aSectPoint = aSectPointsList.Value( i );
 950
 951       gp_XYZ aPoint( aSectPoint.X(), aSectPoint.Y(), 0.0 );
 952       aPoints.Append( aPoint );
 953
 954       if ( thePointIndex == i - 1 )
 955         aPointToTest = aPoint;
 956     }
 957
 958     Handle(Geom_BSplineCurve) aCurve =
 959       HYDROData_BSplineOperation::ComputeCurve( aPoints, anIsSectionClosed, LOCAL_SELECTION_TOLERANCE );
 960
 961     Quantity_Parameter aFirstParam = aCurve->FirstParameter();
 962     Quantity_Parameter aSecondParam = aCurve->LastParameter();
 963
 964     if ( thePointIndex != aSectNbPoints - 1 )
 965     {
 966       GeomAPI_ProjectPointOnCurve aProject( aPointToTest, aCurve );
 967       aSecondParam = aProject.LowerDistanceParameter();
 968     }
 969
 970     GeomAdaptor_Curve anAdap( aCurve );
 971
 972     aResDistance = GCPnts_AbscissaPoint::Length( anAdap, aFirstParam, aSecondParam );
 973   }
 974
 975   return aResDistance;
 976 }
 977
 978 //double HYDROData_PolylineXY::GetMinDistance( const int theSectionIndex,
 979 //                                             const Point& thePoint ) const
 980 //{
 981 //  double aResDistance = -1;
 982 //  if ( theSectionIndex < 0 || theSectionIndex >= NbSections() )
 983 //    return aResDistance;
 984 //
 985 //  std::vector<TopoDS_Wire> aCurves;
 986 //  HYDROData_PolylineOperator::GetWires(this, aCurves);
 987 //  if (aCurves.size() != NbSections())
 988 //    {
 989 //      DEBTRACE("nbCurves != nbSections " << aCurves.size() << " " << NbSections());
 990 //      return aResDistance;
 991 //    }
 992 //  TopoDS_Wire aWire = aCurves[theSectionIndex];
 993 //  TopTools_SequenceOfShape anEdges;
 994 //  HYDROData_ShapesTool::ExploreShapeToShapes( aWire, TopAbs_EDGE, anEdges );
 995 //  for ( int i = 1, n = anEdges.Length(); i <= n; ++i )
 996 //    {
 997 //      DEBTRACE("i: "<< i);
 998 //      TopoDS_Edge aWireEdge = TopoDS::Edge( anEdges.Value( i ) );
 999 //      gp_XYZ aPointz = gp_XYZ(thePoint.X(), thePoint.Y(), 0);
1000 //      Adaptor3d_Curve theCurve = BRepAdaptor_Curve(aWireEdge);
1001 //      double theParameter = -1;
1002 //      double d = ProjectPointToCurve(aPointz, theCurve, theParameter);
1003 //      if (d<aResDistance) aResDistance = d;
1004 //      DEBTRACE("d[" << i <<"]=" << d);
1005 //    }
1006 //  DEBTRACE("distance section "<<theSectionIndex<<" point="<<aResDistance<<" ("<<thePoint.X()<<", "<< thePoint.Y()<<")");
1007 //  return aResDistance;
1008 //}
1009
1010 int HYDROData_PolylineXY::NbSections() const
1011 {
1012   Handle(TDataStd_ExtStringList) aNamesList;
1013   Handle(TDataStd_IntegerList)   aTypesList;
1014   Handle(TDataStd_BooleanList)   aClosuresList;
1015   getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
1016
1017   return !aClosuresList.IsNull() ? aClosuresList->Extent() : 0;
1018 }
1019
1020 void HYDROData_PolylineXY::AddSection( const TCollection_AsciiString& theSectName,
1021                                        const SectionType              theSectionType,
1022                                        const bool                     theIsClosed )
1023 {
1024   Handle(TDataStd_ExtStringList) aNamesList;
1025   Handle(TDataStd_IntegerList)   aTypesList;
1026   Handle(TDataStd_BooleanList)   aClosuresList;
1027   getSectionsLists( aNamesList, aTypesList, aClosuresList );
1028
1029   TCollection_ExtendedString aSectName( theSectName );
1030   if ( aSectName.Length() <= 0 )
1031     aSectName = getUniqueSectionName( aNamesList );
1032
1033   aNamesList->Append( aSectName );
1034   aTypesList->Append( theSectionType );
1035   aClosuresList->Append( theIsClosed );
1036
1037   Changed( Geom_2d );
1038 }
1039
1040 TCollection_AsciiString HYDROData_PolylineXY::GetSectionName( const int theSectionIndex ) const
1041 {
1042   TCollection_AsciiString aResName;
1043
1044   Handle(TDataStd_ExtStringList) aNamesList;
1045   Handle(TDataStd_IntegerList) aTypesList;
1046   Handle(TDataStd_BooleanList) aClosuresList;
1047   getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
1048   if ( aNamesList.IsNull() || theSectionIndex >= aNamesList->Extent() )
1049     return aResName;
1050
1051   TDataStd_ListIteratorOfListOfExtendedString aNamesIter( aNamesList->List() );
1052   for ( int i = 0; aNamesIter.More() && i != theSectionIndex; aNamesIter.Next(), ++i );
1053
1054   if ( aNamesIter.More() )
1055     aResName = aNamesIter.Value();
1056
1057   return aResName;
1058 }
1059
1060 void HYDROData_PolylineXY::SetSectionName( const int                      theSectionIndex,
1061                                            const TCollection_AsciiString& theSectionName )
1062 {
1063   Handle(TDataStd_ExtStringList) aNamesList;
1064   Handle(TDataStd_IntegerList) aTypesList;
1065   Handle(TDataStd_BooleanList) aClosuresList;
1066   getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
1067   if ( aNamesList.IsNull() || theSectionIndex >= aNamesList->Extent() )
1068     return;
1069
1070   TDataStd_ListOfExtendedString anOldNamesList;
1071   anOldNamesList = aNamesList->List();
1072
1073   // Refill the existing list
1074   aNamesList->Clear();
1075
1076   TCollection_ExtendedString aNewSectName = theSectionName;
1077
1078   TDataStd_ListIteratorOfListOfExtendedString aNamesIter( anOldNamesList );
1079   for ( int i = 0; aNamesIter.More(); aNamesIter.Next(), ++i )
1080     aNamesList->Append( i == theSectionIndex ? aNewSectName : aNamesIter.Value() );
1081 }
1082
1083 HYDROData_PolylineXY::SectionType HYDROData_PolylineXY::GetSectionType( const int theSectionIndex ) const
1084 {
1085   Handle(TDataStd_ExtStringList) aNamesList;
1086   Handle(TDataStd_IntegerList) aTypesList;
1087   Handle(TDataStd_BooleanList) aClosuresList;
1088   getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
1089   if ( aTypesList.IsNull() || theSectionIndex >= aTypesList->Extent() )
1090     return SECTION_POLYLINE;
1091
1092   TColStd_ListIteratorOfListOfInteger aTypesIter( aTypesList->List() );
1093   for ( int i = 0; aTypesIter.More() && i != theSectionIndex; aTypesIter.Next(), ++i );
1094
1095   return aTypesIter.More() ? (SectionType)aTypesIter.Value() : SECTION_POLYLINE;
1096 }
1097
1098 void HYDROData_PolylineXY::SetSectionType( const int         theSectionIndex,
1099                                            const SectionType theSectionType )
1100 {
1101   Handle(TDataStd_ExtStringList) aNamesList;
1102   Handle(TDataStd_IntegerList) aTypesList;
1103   Handle(TDataStd_BooleanList) aClosuresList;
1104   getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
1105   if ( aTypesList.IsNull() || theSectionIndex >= aTypesList->Extent() )
1106     return;
1107
1108   TColStd_ListOfInteger anOldTypesList;
1109   anOldTypesList = aTypesList->List();
1110
1111   // Refill the existing list
1112   aTypesList->Clear();
1113
1114   TColStd_ListIteratorOfListOfInteger aTypesIter( anOldTypesList );
1115   for ( int i = 0; aTypesIter.More(); aTypesIter.Next(), ++i )
1116     aTypesList->Append( i == theSectionIndex ? theSectionType : aTypesIter.Value() );
1117
1118   Changed( Geom_2d );
1119 }
1120
1121 bool HYDROData_PolylineXY::IsClosedSection( const int theSectionIndex ) const
1122 {
1123   Handle(TDataStd_ExtStringList) aNamesList;
1124   Handle(TDataStd_IntegerList) aTypesList;
1125   Handle(TDataStd_BooleanList) aClosuresList;
1126   getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
1127   if ( aClosuresList.IsNull() || theSectionIndex >= aClosuresList->Extent() )
1128     return false;
1129
1130   TDataStd_ListIteratorOfListOfByte aClosuresIter( aClosuresList->List() );
1131   for ( int i = 0; aClosuresIter.More() && i != theSectionIndex; aClosuresIter.Next(), ++i );
1132
1133   return aClosuresIter.More() ? (bool)aClosuresIter.Value() : false;
1134 }
1135
1136 void HYDROData_PolylineXY::SetSectionClosed( const int  theSectionIndex,
1137                                              const bool theIsClosed )
1138 {
1139   Handle(TDataStd_ExtStringList) aNamesList;
1140   Handle(TDataStd_IntegerList) aTypesList;
1141   Handle(TDataStd_BooleanList) aClosuresList;
1142   getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
1143   if ( aClosuresList.IsNull() || theSectionIndex >= aClosuresList->Extent() )
1144     return;
1145
1146   TDataStd_ListOfByte anOldClosuresList;
1147   anOldClosuresList = aClosuresList->List();
1148
1149   // Refill the existing list
1150   aClosuresList->Clear();
1151
1152   TDataStd_ListIteratorOfListOfByte aClosuresIter( anOldClosuresList );
1153   for ( int i = 0; aClosuresIter.More(); aClosuresIter.Next(), ++i )
1154     aClosuresList->Append( i == theSectionIndex ? theIsClosed : (bool)aClosuresIter.Value() );
1155
1156   Changed( Geom_2d );
1157 }
1158
1159 void HYDROData_PolylineXY::GetSections( NCollection_Sequence<TCollection_AsciiString>& theSectNames,
1160                                         NCollection_Sequence<SectionType>&             theSectTypes,
1161                                         NCollection_Sequence<bool>&                    theSectClosures ) const
1162 {
1163   theSectNames.Clear();
1164   theSectTypes.Clear();
1165   theSectClosures.Clear();
1166
1167   if( IsCustom() )
1168   {
1169     const_cast<HYDROData_PolylineXY*>( this )->Interpolate();
1170   }
1171
1172   Handle(TDataStd_ExtStringList) aNamesList;
1173   Handle(TDataStd_IntegerList) aTypesList;
1174   Handle(TDataStd_BooleanList) aClosuresList;
1175   getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
1176   if ( aNamesList.IsNull() || aTypesList.IsNull() || aClosuresList.IsNull() )
1177     return;
1178
1179   TDataStd_ListIteratorOfListOfExtendedString aNamesIter( aNamesList->List() );
1180   TColStd_ListIteratorOfListOfInteger aTypesIter( aTypesList->List() );
1181   TDataStd_ListIteratorOfListOfByte aClosuresIter( aClosuresList->List() );
1182   for ( ; aNamesIter.More() && aTypesIter.More() && aClosuresIter.More();
1183           aNamesIter.Next(), aTypesIter.Next(), aClosuresIter.Next() )
1184   {
1185     const TCollection_ExtendedString& aSectName = aNamesIter.Value();
1186     SectionType aSectType = (SectionType)aTypesIter.Value();
1187     bool aSectClosures = aClosuresIter.Value();
1188
1189     theSectNames.Append( aSectName );
1190     theSectTypes.Append( aSectType );
1191     theSectClosures.Append( aSectClosures );
1192   }
1193 }
1194
1195 void HYDROData_PolylineXY::RemoveSection( const int theSectionIndex )
1196 {
1197   Handle(TDataStd_ExtStringList) aNamesList;
1198   Handle(TDataStd_IntegerList)   aTypesList;
1199   Handle(TDataStd_BooleanList)   aClosuresList;
1200   getSectionsLists( aNamesList, aTypesList, aClosuresList, false );
1201   if ( aNamesList.IsNull() || theSectionIndex >= aNamesList->Extent() )
1202     return;
1203
1204   if ( aNamesList->Extent() == 1 )
1205   {
1206     removeSectionsLists();
1207     removePointsLists();
1208   }
1209   else
1210   {
1211     TDataStd_ListOfExtendedString anOldNamesList;
1212     anOldNamesList = aNamesList->List();
1213
1214     TColStd_ListOfInteger anOldTypesList;
1215     anOldTypesList = aTypesList->List();
1216
1217     TDataStd_ListOfByte anOldClosuresList;
1218     anOldClosuresList = aClosuresList->List();
1219
1220     // Refill the existing lists
1221     aNamesList->Clear();
1222     aTypesList->Clear();
1223     aClosuresList->Clear();
1224
1225     TDataStd_ListIteratorOfListOfExtendedString aNamesIter( anOldNamesList );
1226     TColStd_ListIteratorOfListOfInteger aTypesIter( anOldTypesList );
1227     TDataStd_ListIteratorOfListOfByte aClosuresIter( anOldClosuresList );
1228     for ( int i = 0; aNamesIter.More() && aTypesIter.More() && aClosuresIter.More();
1229                      aNamesIter.Next(), aTypesIter.Next(), aClosuresIter.Next(), ++i )
1230     {
1231       if ( i == theSectionIndex )
1232         continue; // skip index to remove
1233
1234       aNamesList->Append( aNamesIter.Value() );
1235       aTypesList->Append( aTypesIter.Value() );
1236       aClosuresList->Append( (bool)aClosuresIter.Value() );
1237     }
1238
1239     // Remove points that belongs to removed section
1240     removePointsLists( theSectionIndex );
1241   }
1242
1243   Changed( Geom_2d );
1244 }
1245
1246 void HYDROData_PolylineXY::RemoveSections()
1247 {
1248   removeSectionsLists();
1249   removePointsLists();
1250   Changed( Geom_2d );
1251 }
1252
1253 void HYDROData_PolylineXY::AddPoint( const int    theSectionIndex,
1254                                      const Point& thePoint,
1255                                      const int    thePointIndex )
1256 {
1257   Handle(TDataStd_RealList) aListX, aListY;
1258   getPointsLists( theSectionIndex, aListX, aListY );
1259
1260   if ( thePointIndex < 0 || thePointIndex >= aListX->Extent() )
1261   {
1262     aListX->Append( thePoint.X() );
1263     aListY->Append( thePoint.Y() );
1264   }
1265   else
1266   {
1267     TColStd_ListOfReal anOldListX;
1268     anOldListX = aListX->List();
1269
1270     TColStd_ListOfReal anOldListY;
1271     anOldListY = aListY->List();
1272
1273     // Refill the existing lists
1274     aListX->Clear();
1275     aListY->Clear();
1276
1277     TColStd_ListIteratorOfListOfReal anIterX( anOldListX );
1278     TColStd_ListIteratorOfListOfReal anIterY( anOldListY );
1279     for ( int i = 0; anIterX.More() && anIterY.More(); anIterX.Next(), anIterY.Next(), ++i )
1280     {
1281       double aCoordX = anIterX.Value();
1282       double aCoordY = anIterY.Value();
1283
1284       if ( i == thePointIndex )
1285       {
1286         // Insert our new point
1287         aListX->Append( thePoint.X() );
1288         aListY->Append( thePoint.Y() );
1289       }
1290
1291       aListX->Append( aCoordX );
1292       aListY->Append( aCoordY );
1293     }
1294   }
1295
1296   Changed( Geom_2d );
1297 }
1298
1299 void HYDROData_PolylineXY::SetPoint( const int    theSectionIndex,
1300                                      const Point& thePoint,
1301                                      const int    thePointIndex )
1302 {
1303   Handle(TDataStd_RealList) aListX, aListY;
1304   getPointsLists( theSectionIndex, aListX, aListY );
1305
1306   if ( thePointIndex < 0 )
1307   {
1308     aListX->Prepend( thePoint.X() );
1309     aListY->Prepend( thePoint.Y() );
1310   }
1311   else if ( thePointIndex >= aListX->Extent() )
1312   {
1313     aListX->Append( thePoint.X() );
1314     aListY->Append( thePoint.Y() );
1315   }
1316   else
1317   {
1318     TColStd_ListOfReal anOldListX;
1319     anOldListX = aListX->List();
1320
1321     TColStd_ListOfReal anOldListY;
1322     anOldListY = aListY->List();
1323
1324     // Refill the existing lists
1325     aListX->Clear();
1326     aListY->Clear();
1327
1328     TColStd_ListIteratorOfListOfReal anIterX( anOldListX );
1329     TColStd_ListIteratorOfListOfReal anIterY( anOldListY );
1330     for ( int i = 0; anIterX.More() && anIterY.More(); anIterX.Next(), anIterY.Next(), ++i )
1331     {
1332       double aCoordX = anIterX.Value();
1333       double aCoordY = anIterY.Value();
1334
1335       if ( i == thePointIndex )
1336       {
1337         // Insert our new point instead of old one
1338         aCoordX = thePoint.X();
1339         aCoordY = thePoint.Y();
1340       }
1341
1342       aListX->Append( aCoordX );
1343       aListY->Append( aCoordY );
1344     }
1345   }
1346
1347   Changed( Geom_2d );
1348 }
1349
1350 void HYDROData_PolylineXY::SetPoints( const int         theSectionIndex,
1351                                       const PointsList& thePoints )
1352 {
1353   Handle(TDataStd_RealList) aListX, aListY;
1354   getPointsLists( theSectionIndex, aListX, aListY );
1355
1356   aListX->Clear();
1357   aListY->Clear();
1358
1359   for ( int i = 1, n = thePoints.Length(); i <= n; ++i )
1360   {
1361     const Point& aPoint = thePoints.Value( i );
1362     aListX->Append( aPoint.X() );
1363     aListY->Append( aPoint.Y() );
1364   }
1365 }
1366
1367 void HYDROData_PolylineXY::RemovePoint( const int theSectionIndex,
1368                                         const int thePointIndex )
1369 {
1370   Handle(TDataStd_RealList) aListX, aListY;
1371   getPointsLists( theSectionIndex, aListX, aListY, false );
1372   if ( aListX.IsNull() || aListY.IsNull() || aListX->IsEmpty() )
1373     return;
1374
1375   if ( aListX->Extent() == 1 )
1376   {
1377     removePointsLists( theSectionIndex );
1378   }
1379   else
1380   {
1381     TColStd_ListOfReal anOldListX;
1382     anOldListX = aListX->List();
1383
1384     TColStd_ListOfReal anOldListY;
1385     anOldListY = aListY->List();
1386
1387     // Refill the existing lists
1388     aListX->Clear();
1389     aListY->Clear();
1390
1391     TColStd_ListIteratorOfListOfReal anIterX( anOldListX );
1392     TColStd_ListIteratorOfListOfReal anIterY( anOldListY );
1393     for ( int i = 0; anIterX.More() && anIterY.More(); anIterX.Next(), anIterY.Next(), ++i )
1394     {
1395       if ( i == thePointIndex )
1396         continue; // skip index to remove
1397
1398       aListX->Append( anIterX.Value() );
1399       aListY->Append( anIterY.Value() );
1400     }
1401   }
1402
1403   Changed( Geom_2d );
1404 }
1405
1406 HYDROData_PolylineXY::PointsList HYDROData_PolylineXY::GetPoints( const int theSectionIndex, bool IsConvertToGlobal ) const
1407 {
1408   PointsList aResList;
1409
1410   if( IsCustom() )
1411   {
1412     const_cast<HYDROData_PolylineXY*>( this )->Interpolate();
1413   }
1414
1415   Handle(TDataStd_RealList) aListX, aListY;
1416   getPointsLists( theSectionIndex, aListX, aListY, false );
1417   if ( aListX.IsNull() || aListY.IsNull() || aListX->IsEmpty() )
1418     return aResList;
1419
1420   TColStd_ListIteratorOfListOfReal anIterX( aListX->List() );
1421   TColStd_ListIteratorOfListOfReal anIterY( aListY->List() );
1422   Handle(HYDROData_Document) aDoc = HYDROData_Document::Document( myLab );
1423   for ( ; anIterX.More() && anIterY.More(); anIterX.Next(), anIterY.Next() )
1424   {
1425     Point aPoint( anIterX.Value(), anIterY.Value() );
1426     if (IsConvertToGlobal)
1427       aDoc->Transform( aPoint, false );
1428     aResList.Append( aPoint );
1429   }
1430
1431   return aResList;
1432 }
1433
1434 QPainterPath HYDROData_PolylineXY::GetPainterPath() const
1435 {
1436   QPainterPath aPath;
1437
1438   NCollection_Sequence<TCollection_AsciiString>           aSectNames;
1439   NCollection_Sequence<HYDROData_PolylineXY::SectionType> aSectTypes;
1440   NCollection_Sequence<bool>                              aSectClosures;
1441   GetSections( aSectNames, aSectTypes, aSectClosures );
1442
1443   for ( int aSectionId = 1, aNbSects = aSectNames.Size(); aSectionId <= aNbSects; aSectionId++ )
1444   {
1445     TCollection_AsciiString aSectName = aSectNames.Value( aSectionId );
1446     SectionType aSectionType = aSectTypes.Value( aSectionId );
1447     bool anIsSectionClosed = aSectClosures.Value( aSectionId );
1448
1449     PointsList aSectPointsList = GetPoints( aSectionId - 1 );
1450     if ( aSectPointsList.IsEmpty() )
1451       continue;
1452
1453     NCollection_Sequence<gp_XYZ> aPoints;
1454     for( int i = 1, n = aSectPointsList.Size(); i <= n; ++i )
1455     {
1456       const Point& aSectPoint = aSectPointsList.Value( i );
1457
1458       gp_XYZ aPoint( aSectPoint.X(), aSectPoint.Y(), 0.0 );
1459       aPoints.Append( aPoint );
1460     }
1461
1462     BuildPainterPath( aPath, aSectionType, anIsSectionClosed, aPoints );
1463   }
1464
1465   return aPath;
1466 }
1467
1468 void HYDROData_PolylineXY::UpdateLocalCS( double theDx, double theDy )
1469 {
1470   NCollection_Sequence<TCollection_AsciiString>           aSectNames;
1471   NCollection_Sequence<HYDROData_PolylineXY::SectionType> aSectTypes;
1472   NCollection_Sequence<bool>                              aSectClosures;
1473   GetSections( aSectNames, aSectTypes, aSectClosures );
1474
1475   gp_XY aDelta( theDx, theDy );
1476   for ( int i = 0, aNbSects = aSectNames.Size(); i < aNbSects; i++ )
1477   {
1478     PointsList aPoints = GetPoints( i );
1479     for( int j = 1, n = aPoints.Size(); j <= n; ++j )
1480     {
1481       Point& aPoint = aPoints.ChangeValue( j );
1482       aPoint += aDelta;
1483     }
1484     SetPoints( i, aPoints );
1485   }
1486   Changed( Geom_2d );
1487 }
1488
1489 void HYDROData_PolylineXY::Transform( const QTransform& theTrsf )
1490 {
1491   NCollection_Sequence<TCollection_AsciiString>           aSectNames;
1492   NCollection_Sequence<HYDROData_PolylineXY::SectionType> aSectTypes;
1493   NCollection_Sequence<bool>                              aSectClosures;
1494   GetSections( aSectNames, aSectTypes, aSectClosures );
1495
1496   for ( int i = 0, aNbSects = aSectNames.Size(); i < aNbSects; i++ ) {
1497     PointsList aPoints = GetPoints( i );
1498     for( int j = 1, n = aPoints.Size(); j <= n; ++j ) {
1499       Point& aPoint = aPoints.ChangeValue( j );
1500
1501       QPointF aTrsfPoint = theTrsf.map( QPointF( aPoint.X(), aPoint.Y() ) );
1502
1503       aPoint.SetX( aTrsfPoint.x() );
1504       aPoint.SetY( aTrsfPoint.y() );
1505     }
1506     SetPoints( i, aPoints );
1507   }
1508
1509   Update();
1510 }
1511
1512 bool HYDROData_PolylineXY::IsCustom() const
1513 {
1514   if( myIsInCustomFlag )
1515     return false;
1516
1517   bool isNull = GetShape().IsNull();
1518   int aNbPoints = 0;
1519
1520   HYDROData_PolylineXY* aThat = const_cast<HYDROData_PolylineXY*>( this );
1521   aThat->myIsInCustomFlag = true;
1522   for( int i=0, n=NbSections(); i<n; i++ )
1523     aNbPoints += NbPoints( i );
1524   aThat->myIsInCustomFlag = false;
1525
1526   return !isNull && aNbPoints == 0;
1527 }
1528
1529 bool HYDROData_PolylineXY::GetIsInCustomFlag() const
1530 {
1531   return myIsInCustomFlag;
1532 }
1533
1534 void HYDROData_PolylineXY::SetIsInCustomFlag( bool theValue )
1535 {
1536   myIsInCustomFlag = theValue;
1537 }
1538
1539 void HYDROData_PolylineXY::Interpolate()
1540 {
1541   ImportShape( GetShape(), true );
1542 }