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