]> SALOME platform Git repositories - modules/hydro.git/blob - src/HYDROData/HYDROData_Stream.cxx
Salome HOME
Stream dump is implemented.
[modules/hydro.git] / src / HYDROData / HYDROData_Stream.cxx
1
2 #include "HYDROData_Stream.h"
3
4 #include "HYDROData_Document.h"
5 #include "HYDROData_PolylineXY.h"
6 #include "HYDROData_Profile.h"
7 #include "HYDROData_ShapesGroup.h"
8 #include "HYDROData_ShapesTool.h"
9 #include "HYDROData_IAltitudeObject.h"
10
11 #include <TDataStd_RealArray.hxx>
12
13 #include <Precision.hxx>
14
15 #include <NCollection_DataMap.hxx>
16
17 #include <TColStd_Array1OfReal.hxx>
18 #include <TColStd_ListOfReal.hxx>
19 #include <TColStd_ListIteratorOfListOfReal.hxx>
20 #include <TCollection_CompareOfReal.hxx>
21 #include <TColgp_Array1OfPnt.hxx>
22 #include <TColgp_HArray1OfPnt.hxx>
23
24 #include <TopoDS.hxx>
25 #include <TopoDS_Wire.hxx>
26 #include <TopoDS_Shell.hxx>
27 #include <TopoDS_Face.hxx>
28 #include <TopoDS_Edge.hxx>
29 #include <TopoDS_Vertex.hxx>
30 #include <TopExp.hxx>
31 #include <TopExp_Explorer.hxx>
32
33 #include <Bnd_Box.hxx>
34
35 #include <BRep_Builder.hxx>
36 #include <BRepBuilderAPI_MakeEdge.hxx>
37 #include <BRepBuilderAPI_MakeWire.hxx>
38 #include <BRepBuilderAPI_MakeFace.hxx>
39
40 #include <BRepBndLib.hxx>
41 #include <BRepProj_Projection.hxx>
42 #include <BRepExtrema_ExtCC.hxx>
43 #include <BRepCheck_Analyzer.hxx>
44
45 #include <gp.hxx>
46 #include <gp_Ax1.hxx>
47 #include <gp_Ax2.hxx>
48 #include <gp_Ax3.hxx>
49 #include <gp_Vec.hxx>
50 #include <gp_Pnt.hxx>
51 #include <gp_Pln.hxx>
52
53 #include <GeomAPI_Interpolate.hxx>
54 #include <Geom_BSplineCurve.hxx>
55
56 #include <TopTools_Array1OfShape.hxx>
57
58 #include <SortTools_QuickSortOfReal.hxx>
59
60 #include <QColor>
61 #include <QStringList>
62
63 //#define DEB_STREAM 1
64 #ifdef DEB_STREAM
65 //#define DEB_HASINT 1
66 //#define DEB_UPDATE 1
67 #include <BRepTools.hxx>
68 #include <TCollection_AsciiString.hxx>
69 #endif
70
71 typedef NCollection_DataMap<Standard_Real, Handle(HYDROData_Profile)> HYDROData_DataMapOfRealOfHDProfile;
72
73 IMPLEMENT_STANDARD_HANDLE(HYDROData_Stream,HYDROData_NaturalObject)
74 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Stream,HYDROData_NaturalObject)
75
76
77 HYDROData_Stream::HYDROData_Stream()
78 : HYDROData_NaturalObject()
79 {
80 }
81
82 HYDROData_Stream::~HYDROData_Stream()
83 {
84 }
85
86 QStringList HYDROData_Stream::DumpToPython( MapOfTreatedObjects& theTreatedObjects ) const
87 {
88   QStringList aResList = dumpObjectCreation( theTreatedObjects );
89   QString aName = GetObjPyName();
90
91   Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
92   setPythonReferenceObject( theTreatedObjects, aResList, aHydAxis, "SetHydraulicAxis" );
93
94   HYDROData_SequenceOfObjects aSeqOfProfiles = GetProfiles();
95   for ( int i = 1, aNb = aSeqOfProfiles.Size(); i <= aNb; ++i )
96   {
97     const Handle(HYDROData_Entity) aProfile = aSeqOfProfiles.Value( i );
98     setPythonReferenceObject( theTreatedObjects, aResList, aProfile, "AddProfile" );
99   }
100
101   aResList << QString( "" );
102   aResList << QString( "%1.Update();" ).arg( aName );
103   aResList << QString( "" );
104
105   return aResList;
106 }
107
108 HYDROData_SequenceOfObjects HYDROData_Stream::GetAllReferenceObjects() const
109 {
110   HYDROData_SequenceOfObjects aResSeq = HYDROData_Object::GetAllReferenceObjects();
111
112   Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
113   if ( !aHydAxis.IsNull() )
114     aResSeq.Append( aHydAxis );
115
116   HYDROData_SequenceOfObjects aSeqOfProfiles = GetProfiles();
117   aResSeq.Append( aSeqOfProfiles );
118
119   return aResSeq;
120 }
121
122 TopoDS_Shape HYDROData_Stream::GetTopShape() const
123 {
124   return getTopShape();
125 }
126
127 TopoDS_Shape HYDROData_Stream::GetShape3D() const
128 {
129   return getShape3D();
130 }
131
132 Handle(Geom_BSplineCurve) HYDROData_Stream::buildInterpolationCurve( 
133   const Handle(TColgp_HArray1OfPnt)& theArrayOfPnt )
134 {
135   Handle(Geom_BSplineCurve) aBSpline;
136   GeomAPI_Interpolate anInterpolator (theArrayOfPnt, Standard_False, 1.0e-5); 
137   anInterpolator.Perform() ;
138   if (anInterpolator.IsDone()) 
139     aBSpline = anInterpolator.Curve();
140   return aBSpline; 
141 }
142
143 void HYDROData_Stream::Update()
144 {
145   updateProfilesOrder();
146   UpdatePrs();
147 }
148
149 void HYDROData_Stream::UpdatePrs()
150 {
151   HYDROData_NaturalObject::Update();
152
153   Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
154   HYDROData_SequenceOfObjects aRefProfiles = GetProfiles();
155   if ( aHydAxis.IsNull() || aRefProfiles.Length() < 2 )
156     return; 
157  
158   bool anIsFirst = true;
159   gp_Pnt aPrevFirstPoint, aPrevLastPoint;
160   Handle(TColgp_HArray1OfPnt) anArrayOfFPnt    = new TColgp_HArray1OfPnt(1, aRefProfiles.Length());
161   Handle(TColgp_HArray1OfPnt) anArrayOfLPnt    = new TColgp_HArray1OfPnt(1, aRefProfiles.Length());  
162   TopTools_Array1OfShape anArrOfProfiles(1, aRefProfiles.Length());
163   TopTools_Array1OfShape anArrOf2DProfiles(1, aRefProfiles.Length());
164
165   // Pre-processing
166   HYDROData_SequenceOfObjects::Iterator anIter( aRefProfiles );
167   for (int i=1 ; anIter.More(); anIter.Next(),i++ )
168   {
169     Handle(HYDROData_Profile) aProfile =
170       Handle(HYDROData_Profile)::DownCast( anIter.Value() );
171     if ( aProfile.IsNull() )
172       continue;    
173     const TopoDS_Shape& aProf3d = aProfile->GetShape3D();
174     gp_XY aPnt1, aPnt2;
175     if ( !aProfile->GetLeftPoint( aPnt1 ) || !aProfile->GetRightPoint( aPnt2 ) )
176       continue;
177     anArrOfProfiles.SetValue(i,aProfile->GetShape3D());//aProfile->GetTopShape();
178     anArrOf2DProfiles.SetValue(i,aProfile->GetTopShape());
179
180     gp_Pnt aCurFirstPoint( aPnt1.X(), aPnt1.Y(), 0 ), aCurFP;
181     gp_Pnt aCurLastPoint(  aPnt2.X(), aPnt2.Y(), 0 ), aCurLP;
182     TopoDS_Vertex aV1, aV2;
183     TopExp::Vertices(TopoDS::Wire(aProf3d), aV1, aV2);
184        gp_Pnt aP1 = BRep_Tool::Pnt(aV1);
185     if(aP1.X() == aPnt1.X() && aP1.Y() == aPnt1.Y())
186       aCurFP = aP1;
187     else
188       aCurLP = aP1;
189     aP1 = BRep_Tool::Pnt(aV2);
190     if(aP1.X() == aPnt2.X() && aP1.Y() == aPnt2.Y())
191       aCurLP = aP1;
192     else
193       aCurFP = aP1;
194     anArrayOfFPnt->SetValue(i,aCurFP);
195     anArrayOfLPnt->SetValue(i,aCurLP);
196   }
197
198   // Construct of the 3D presentation
199   Handle(Geom_BSplineCurve) aBSpline = buildInterpolationCurve (anArrayOfFPnt);
200   if(aBSpline.IsNull())
201     return;
202   TopoDS_Edge anEdgLeft, anEdgRight;
203   BRepBuilderAPI_MakeEdge aMakeEdge(aBSpline);
204   if(aMakeEdge.IsDone()) 
205     anEdgLeft = aMakeEdge.Edge();
206   if(anEdgLeft.IsNull())
207     return;
208   aBSpline.Nullify();
209   aBSpline = buildInterpolationCurve (anArrayOfLPnt);  
210   if(aBSpline.IsNull())
211     return; 
212   aMakeEdge.Init(aBSpline);
213   if(aMakeEdge.IsDone()) 
214     anEdgRight = aMakeEdge.Edge();
215   if(anEdgRight.IsNull())
216     return;
217   BRep_Builder aBB;
218   TopoDS_Compound aCmp;
219   aBB.MakeCompound(aCmp);
220   anIter.Init( aRefProfiles );
221   for (int i=1 ; i < anArrOfProfiles.Length() +1; i++ )  
222     aBB.Add(aCmp, anArrOfProfiles.Value(i));
223   aBB.Add(aCmp,anEdgLeft);
224   aBB.Add(aCmp,anEdgRight);
225   BRepCheck_Analyzer aCh(aCmp);
226   if(aCh.IsValid())
227     SetShape3D(aCmp);
228 #ifdef DEB_UPDATE
229   else {
230     BRepTools::Write(aCmp, "str3d.brep");
231     SetShape3D(aCmp);
232   }
233 #endif
234
235   // Construct the top presentation
236   for(int i=1;i<= anArrayOfLPnt->Length();i++) {
237       gp_Pnt aPnt = anArrayOfFPnt->Value(i);
238       aPnt.SetZ(.0); // make 2d
239       anArrayOfFPnt->SetValue(i, aPnt);
240       aPnt = anArrayOfLPnt->Value(i);
241       aPnt.SetZ(.0);
242       anArrayOfLPnt->SetValue(i, aPnt);
243   }
244   aBSpline.Nullify();
245   aBSpline = buildInterpolationCurve (anArrayOfFPnt);  
246   if(aBSpline.IsNull())
247     return; 
248   aMakeEdge.Init(aBSpline);
249   if(aMakeEdge.IsDone()) 
250       anEdgLeft = aMakeEdge.Edge();
251   aBSpline.Nullify();
252   aBSpline = buildInterpolationCurve (anArrayOfLPnt);  
253   if(aBSpline.IsNull())
254     return; 
255   aMakeEdge.Init(aBSpline);
256   if(aMakeEdge.IsDone()) 
257     anEdgRight = aMakeEdge.Edge();
258   if(anEdgRight.IsNull())
259     return;
260   BRepBuilderAPI_MakeEdge aMakeEdge2(anArrayOfFPnt->Value(1),anArrayOfLPnt->Value(1));
261   TopoDS_Edge aBotEdge, aTopEdge;
262   if(aMakeEdge2.IsDone()) 
263     aBotEdge = aMakeEdge2.Edge();
264   BRepBuilderAPI_MakeEdge aMakeEdge3(anArrayOfFPnt->Value(anArrayOfFPnt->Length()),anArrayOfLPnt->Value(anArrayOfLPnt->Length()));
265   if(aMakeEdge3.IsDone()) 
266     aTopEdge = aMakeEdge3.Edge();
267
268   // Make wire for 2D presentation with updating of corresponding edges
269   BRepBuilderAPI_MakeWire aMakeWire;
270   
271   aMakeWire.Add( aBotEdge );
272   aBotEdge = aMakeWire.Edge();
273
274   aMakeWire.Add( anEdgLeft );
275   anEdgLeft = aMakeWire.Edge();
276
277   aMakeWire.Add( aTopEdge );
278   aTopEdge = aMakeWire.Edge();
279
280   aMakeWire.Add( anEdgRight );
281   anEdgRight = aMakeWire.Edge();
282
283   TopoDS_Wire aSectProfileWire;
284   if(aMakeWire.IsDone())
285     aSectProfileWire = aMakeWire.Wire();
286
287   BRepBuilderAPI_MakeFace aMakeFace( aSectProfileWire, Standard_True );
288   TopoDS_Face aFace;
289   aMakeFace.Build();
290   if( aMakeFace.IsDone() )
291     aFace = aMakeFace.Face();
292
293   aCmp.Nullify();
294   aBB.MakeCompound(aCmp);
295   aBB.Add(aCmp,aFace);
296   for(int i=1;i <= anArrOf2DProfiles.Length(); i++)
297     aBB.Add(aCmp,anArrOf2DProfiles.Value(i));
298   aCh.Init(aCmp);
299   if(aCh.IsValid())
300     SetTopShape(aCmp);
301 #ifdef DEB_UPDATE
302   else {
303     BRepTools::Write(aCmp, "str2d.brep");
304     SetTopShape(aCmp);
305   }
306 #endif 
307
308   // Create the stream groups
309   QString aLeftGroupName = GetName() + "_Left_Bank";
310
311   Handle(HYDROData_ShapesGroup) aLeftGroup = createGroupObject();
312   aLeftGroup->SetName( aLeftGroupName );
313   aLeftGroup->AddShape( anEdgLeft );
314
315   QString aRightGroupName = GetName() + "_Right_Bank";
316
317   Handle(HYDROData_ShapesGroup) aRightGroup = createGroupObject();
318   aRightGroup->SetName( aRightGroupName );
319   aRightGroup->AddShape( anEdgRight );
320
321   QString anInGroupName = GetName() + "_Inlet";
322
323   Handle(HYDROData_ShapesGroup) anInGroup = createGroupObject();
324   anInGroup->SetName( anInGroupName );
325   anInGroup->AddShape( aBotEdge );
326
327   QString anOutGroupName = GetName() + "_Outlet";
328
329   Handle(HYDROData_ShapesGroup) anOutGroup = createGroupObject();
330   anOutGroup->SetName( anOutGroupName );
331   anOutGroup->AddShape( aTopEdge );
332
333   // This peace of code is for testing of functionality of altitude,
334   // will be removed by adv when testing will be finished
335   Handle(HYDROData_IAltitudeObject) anAltObj = GetAltitudeObject();
336   gp_XY aTestPnt( 5, 0 );
337   anAltObj->GetAltitudeForPoint( aTestPnt );
338   // End of test code
339
340 }
341
342 QColor HYDROData_Stream::DefaultFillingColor()
343 {
344   return QColor( Qt::green );
345 }
346
347 QColor HYDROData_Stream::DefaultBorderColor()
348 {
349   return QColor( Qt::transparent );
350 }
351
352 bool HYDROData_Stream::IsValidAsAxis( const Handle(HYDROData_PolylineXY)& theHydAxis )
353 {
354   if ( theHydAxis.IsNull() )
355     return false;
356
357   TopoDS_Shape aHydraulicShape = theHydAxis->GetShape();
358   if ( aHydraulicShape.IsNull() || 
359        aHydraulicShape.ShapeType() != TopAbs_WIRE ||
360        BRep_Tool::IsClosed( aHydraulicShape ) )
361     return false; // The polyline must be a single not closed wire
362
363   return true;
364 }
365
366 TopoDS_Shape getShapeFromGroup( const HYDROData_SequenceOfObjects& theGroups,
367                                 const int                          theGroupId )
368 {
369   TopoDS_Shape aResShape;
370   if ( theGroups.Length() != 4 )
371     return aResShape;
372
373   Handle(HYDROData_ShapesGroup) aGroup =
374     Handle(HYDROData_ShapesGroup)::DownCast( theGroups.Value( theGroupId ) );
375   if ( aGroup.IsNull() )
376     return aResShape;
377
378   TopTools_SequenceOfShape aGroupShapes;
379   aGroup->GetShapes( aGroupShapes );
380
381   if ( !aGroupShapes.IsEmpty() )
382     aResShape = aGroupShapes.First();
383
384   return aResShape;
385 }
386
387 TopoDS_Shape HYDROData_Stream::GetLeftShape() const
388 {
389   HYDROData_SequenceOfObjects aGroups = GetGroups();
390   return getShapeFromGroup( aGroups, 1 );
391 }
392
393 TopoDS_Shape HYDROData_Stream::GetRightShape() const
394 {
395   HYDROData_SequenceOfObjects aGroups = GetGroups();
396   return getShapeFromGroup( aGroups, 2 );
397 }
398
399 TopoDS_Shape HYDROData_Stream::GetInletShape() const
400 {
401   HYDROData_SequenceOfObjects aGroups = GetGroups();
402   return getShapeFromGroup( aGroups, 3 );
403 }
404
405 TopoDS_Shape HYDROData_Stream::GetOutletShape() const
406 {
407   HYDROData_SequenceOfObjects aGroups = GetGroups();
408   return getShapeFromGroup( aGroups, 4 );
409 }
410
411 QColor HYDROData_Stream::getDefaultFillingColor() const
412 {
413   return DefaultFillingColor();
414 }
415
416 QColor HYDROData_Stream::getDefaultBorderColor() const
417 {
418   return DefaultBorderColor();
419 }
420
421 bool HYDROData_Stream::SetHydraulicAxis( const Handle(HYDROData_PolylineXY)& theAxis )
422 {
423   if ( !IsValidAsAxis( theAxis ) )
424     return false;
425
426   Handle(HYDROData_PolylineXY) aPrevAxis = GetHydraulicAxis();
427   if ( IsEqual( aPrevAxis, theAxis ) )
428     return true;
429
430   SetReferenceObject( theAxis, DataTag_HydraulicAxis );
431
432   // Update the order of profiles
433   updateProfilesOrder();
434
435   // Indicate model of the need to update the stream presentation
436   SetToUpdate( true );
437
438   return true;
439 }
440
441 Handle(HYDROData_PolylineXY) HYDROData_Stream::GetHydraulicAxis() const
442 {
443   return Handle(HYDROData_PolylineXY)::DownCast( 
444            GetReferenceObject( DataTag_HydraulicAxis ) );
445 }
446
447 void HYDROData_Stream::RemoveHydraulicAxis()
448 {
449   Handle(HYDROData_PolylineXY) aPrevAxis = GetHydraulicAxis();
450   if ( aPrevAxis.IsNull() )
451     return;
452
453   ClearReferenceObjects( DataTag_HydraulicAxis );
454
455   // We remove the reference profiles
456   RemoveProfiles();
457
458   // Indicate model of the need to update the stream presentation
459   SetToUpdate( true );
460 }
461
462 bool HYDROData_Stream::HasIntersection( const Handle(HYDROData_PolylineXY)& theHydAxis, 
463                                         const Handle(HYDROData_Profile)& theProfile, 
464                                         const TopoDS_Face& thePlane,
465                                                               Standard_Real& outPar)
466 {
467   if ( theProfile.IsNull() || !IsValidAsAxis( theHydAxis ) )
468     return false; 
469
470   TopoDS_Wire aHydraulicWire = TopoDS::Wire( theHydAxis->GetShape() ); //guide line
471   TopoDS_Wire aProfileWire = TopoDS::Wire( theProfile->GetTopShape() );
472   if ( aHydraulicWire.IsNull() || aProfileWire.IsNull() )
473     return false;
474
475   BRepProj_Projection aProjector (aProfileWire, thePlane, gp::OZ().Direction());
476   if(!aProjector.IsDone())
477     return false;
478   TopoDS_Shape aPrjProfile = aProjector.Shape();
479   if(aPrjProfile.IsNull())
480     return false;
481   TopoDS_Vertex aV1, aV2;
482   if(aPrjProfile.ShapeType() == TopAbs_EDGE)
483     TopExp::Vertices(TopoDS::Edge(aPrjProfile), aV1, aV2);
484   else if(aPrjProfile.ShapeType() == TopAbs_WIRE)  
485     TopExp::Vertices(TopoDS::Wire(aPrjProfile), aV1, aV2);
486   else if(aPrjProfile.ShapeType() == TopAbs_COMPOUND){
487     TopExp_Explorer anExp(aPrjProfile, TopAbs_WIRE);
488     if(anExp.More()) {
489       TopExp::Vertices(TopoDS::Wire(anExp.Current()), aV1, aV2);
490     } else {
491       anExp.Init(aPrjProfile, TopAbs_EDGE);
492       if(anExp.More()) {
493         TopExp::Vertices(TopoDS::Edge(anExp.Current()), aV1, aV2);
494       }
495     }
496   }
497   if(aV1.IsNull() || aV2.IsNull())
498     return false;
499   gp_Pnt aPnt1 = BRep_Tool::Pnt(aV1);
500   gp_Pnt aPnt2 = BRep_Tool::Pnt(aV2);
501   aPnt1.SetZ(0.0);
502   aPnt2.SetZ(0.0);
503   BRepBuilderAPI_MakeEdge aMk(aPnt1, aPnt2); 
504   if(!aMk.IsDone())
505     return false;
506   const TopoDS_Edge& anEdg2 = aMk.Edge();//Section edge
507   Standard_Integer aNum(0);
508   
509   TopExp_Explorer anExplo(aHydraulicWire, TopAbs_EDGE);
510   for(;anExplo.More();anExplo.Next()) aNum++;
511   // check for self-intersection
512   const Standard_Real SquareTolerance = Precision::Confusion()*Precision::Confusion();
513   Standard_Boolean hasInt(false);
514   Standard_Real aSqDist(DBL_MAX);
515   Standard_Integer anIndx(0);
516   BRepExtrema_ExtCC aCC;
517   aCC.Initialize(anEdg2);
518   outPar = 0.0;
519   anExplo.Init(aHydraulicWire, TopAbs_EDGE);
520   for(Standard_Integer j=1;anExplo.More();anExplo.Next(),j++) {
521     const TopoDS_Edge& anEdg1 = TopoDS::Edge(anExplo.Current());
522     if(anEdg1.IsNull())
523       continue;
524     Standard_Boolean hasSol(false);
525     aCC.Perform(anEdg1);
526     if(aCC.IsDone()) {
527     // find minimal dist
528     for(Standard_Integer i=1; i<= aCC.NbExt();i++)
529       if(aCC.SquareDistance(i) < aSqDist) {
530         aSqDist = aCC.SquareDistance(i);
531         anIndx = i;
532         hasSol = true;
533       }  
534     }
535     if(hasSol) {
536       if(aSqDist <= SquareTolerance) { // hasInt
537         const gp_Pnt& aPnt = aCC.PointOnE1(anIndx);
538         if(aNum > 1) {
539           TopExp::Vertices(anEdg1, aV1, aV2, Standard_True);
540           outPar += BRep_Tool::Pnt(aV1).Distance(aPnt);
541         } else {
542           Standard_Real aPar = aCC.ParameterOnE1(anIndx);
543           outPar = aPar;
544         }
545         hasInt = true;
546         break;
547       } else {
548           // no ints-n
549         if(aNum > 1) {
550           TopExp::Vertices(anEdg1, aV1, aV2);
551           outPar += BRep_Tool::Pnt(aV1).Distance(BRep_Tool::Pnt(aV2));
552         }
553       }
554     } else if(aNum > 1) {
555       TopExp::Vertices(anEdg1, aV1, aV2);
556       outPar += BRep_Tool::Pnt(aV1).Distance(BRep_Tool::Pnt(aV2));
557     }
558   }
559   if(hasInt)
560     return true;
561   return false;
562 }
563
564 bool HYDROData_Stream::HasIntersection( const Handle(HYDROData_Profile)& theProfile, const TopoDS_Face& thePlane,
565                                        Standard_Real& outPar ) const
566 {
567   Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
568
569   return HasIntersection( aHydAxis, theProfile, thePlane, outPar );
570 }
571
572
573 bool HYDROData_Stream::AddProfile( const Handle(HYDROData_Profile)& theProfile )
574 {
575   if ( theProfile.IsNull() )
576     return false;
577
578   Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
579   if ( aHydAxis.IsNull() )
580     return false;
581
582   TopoDS_Face aPlane;
583   if(!BuildFace(aHydAxis, aPlane))
584     return false;
585
586   Standard_Real aPar(.0);
587   if ( HasReference( theProfile, DataTag_Profile ) || !HasIntersection( theProfile, aPlane, aPar ) )
588     return false; // Object is already in reference list or it has no intersection
589   
590   int aProfileIndex = insertParameter( aPar );
591   insertProfileInToOrder( theProfile, aProfileIndex );
592   
593   // Indicate model of the need to update the stream presentation
594   SetToUpdate( true );
595
596   return true;
597 }
598
599 HYDROData_SequenceOfObjects HYDROData_Stream::GetProfiles() const
600 {
601   return GetReferenceObjects( DataTag_Profile );
602 }
603
604 bool HYDROData_Stream::RemoveProfile( const Handle(HYDROData_Profile)& theProfile )
605 {
606   if ( theProfile.IsNull() )
607     return false;
608
609   int aProfileIndex = -1;
610
611   HYDROData_SequenceOfObjects aRefProfiles = GetProfiles();
612   HYDROData_SequenceOfObjects::Iterator anIter( aRefProfiles );
613   for ( int i = 0 ; anIter.More(); anIter.Next(), ++i )
614   {
615     Handle(HYDROData_Profile) aProfile =
616       Handle(HYDROData_Profile)::DownCast( anIter.Value() );
617     if ( aProfile.IsNull() )
618       continue;
619
620     if ( IsEqual( theProfile, aProfile ) )
621     {
622       aProfileIndex = i;
623       break;
624     }
625   }
626
627   if ( aProfileIndex == -1 )
628     return false;
629
630   RemoveReferenceObject( theProfile->Label(), DataTag_Profile );
631
632   // Remove parameter for removed profile
633   removeParameter( aProfileIndex );
634
635   // Indicate model of the need to update the stream presentation
636   SetToUpdate( true );
637
638   return true;
639 }
640
641 void HYDROData_Stream::RemoveProfiles()
642 {
643   bool anIsToUpdate = IsMustBeUpdated() || NbReferenceObjects( DataTag_Profile ) > 0;
644
645   ClearReferenceObjects( DataTag_Profile );
646
647   // Remove the parameters array
648   removeParametersArray();
649
650   // Indicate model of the need to update the stream presentation
651   SetToUpdate( anIsToUpdate );
652 }
653
654 void HYDROData_Stream::insertProfileInToOrder( const Handle(HYDROData_Profile)& theProfile,
655                                                const int                        theBeforeIndex )
656 {
657   Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
658   if ( theProfile.IsNull() || aHydAxis.IsNull() )
659     return; 
660
661   TopoDS_Wire aHydraulicWire = TopoDS::Wire( aHydAxis->GetShape() );
662   TopoDS_Wire aProfileWire = TopoDS::Wire( theProfile->GetTopShape() );
663   if ( aHydraulicWire.IsNull() || aProfileWire.IsNull() )
664     return;
665
666   if ( theBeforeIndex == -1 )
667     AddReferenceObject( theProfile, DataTag_Profile );
668   else
669     InsertReferenceObject( theProfile, DataTag_Profile, theBeforeIndex );
670 }
671
672 bool HYDROData_Stream::BuildFace( const Handle(HYDROData_PolylineXY)& theHydAxis,
673                                   TopoDS_Face&                        thePlane ) const
674 {
675   if ( !IsValidAsAxis( theHydAxis ) )
676     return false;
677
678   TopoDS_Wire aHydraulicWire = TopoDS::Wire( theHydAxis->GetShape() );
679
680   gp_Ax2 aX2(gp::XOY());
681   gp_Ax3 aX3(aX2);
682   gp_Pln aPln(aX3);   
683   Bnd_Box B;
684   BRepBndLib::Add(aHydraulicWire,B);
685   Standard_Real axmin,aymin,azmin,axmax,aymax,azmax;
686   B.Get(axmin,aymin,azmin,axmax,aymax,azmax);
687   BRepBuilderAPI_MakeFace aMkr(aPln, axmin-500., axmax+500., aymin-500., aymax+500.); // to be tuned later according max/ Profile deviation
688   if(!aMkr.IsDone() || aMkr.Shape().IsNull()) return false;
689   thePlane = TopoDS::Face(aMkr.Shape());
690   return true;
691 }
692
693 void HYDROData_Stream::updateProfilesOrder()
694 {
695   HYDROData_SequenceOfObjects aRefProfiles = GetProfiles();
696   if ( aRefProfiles.IsEmpty() )
697     return;
698
699   // At first we remove all profiles from order
700   RemoveProfiles();
701
702   Handle(HYDROData_PolylineXY) aHydAxis = GetHydraulicAxis();
703   if ( aHydAxis.IsNull() )
704     return; 
705
706   TopoDS_Face aPlane;
707   if ( !BuildFace( aHydAxis, aPlane ) )
708     return;
709
710   Standard_Real aPar( .0 );
711
712 #ifdef DEB_HASINT
713   BRep_Builder aBB;
714   TopoDS_Compound aCmp;
715   aBB.MakeCompound(aCmp);
716 #endif
717
718   HYDROData_DataMapOfRealOfHDProfile aDM;  
719   TColStd_ListOfReal aList;
720   HYDROData_SequenceOfObjects::Iterator anIter( aRefProfiles );
721   for (int i = 1 ; anIter.More(); anIter.Next(), i++ )
722   {
723     Handle(HYDROData_Profile) aProfile =
724       Handle(HYDROData_Profile)::DownCast( anIter.Value() );
725 #ifdef DEB_HASINT
726   TopoDS_Wire aProfileWire = TopoDS::Wire( aProfile->GetTopShape() );
727   aBB.Add( aCmp, aProfileWire ); 
728 #endif
729     if ( aProfile.IsNull() || !HasIntersection( aProfile, aPlane, aPar ) )
730       continue;
731     
732     aDM.Bind( aPar, aProfile );
733       aList.Append( aPar );
734   }
735   
736   if ( aList.IsEmpty() )
737     return;
738
739   TColStd_Array1OfReal anArr( 1, aList.Extent() );
740
741   TColStd_ListIteratorOfListOfReal it( aList );
742   for ( int j = 1; it.More(); it.Next(), j++ )
743     anArr( j ) = it.Value();
744
745   // sorting
746   if ( aList.Extent() > 1 )
747   {
748     TCollection_CompareOfReal Compar;
749     SortTools_QuickSortOfReal::Sort( anArr, Compar );
750
751     for (int j = 1; j <= anArr.Length(); j++) {
752       const Standard_Real aKey =  anArr(j);
753       const Handle(HYDROData_Profile)& aProfile = aDM.Find(aKey);
754       insertProfileInToOrder( aProfile );
755     }
756   } else if ( aList.Extent() == 1 ) {
757      const Standard_Real aKey = aList.Last();
758      const Handle(HYDROData_Profile)& aProfile = aDM.Find(aKey);
759      insertProfileInToOrder( aProfile );
760   } 
761
762   setParametersArray( anArr );
763
764 #ifdef DEB_HASINT
765   TopoDS_Wire aHydraulicWire = TopoDS::Wire( aHydAxis->GetShape() );
766   BRepTools::Write(aHydraulicWire, "Path.brep");
767   BRepTools::Write(aCmp, "Prof.brep");
768 #endif
769 }
770
771 ObjectKind HYDROData_Stream::getAltitudeObjectType() const
772 {
773   return KIND_STREAM_ALTITUDE;
774 }
775
776 void HYDROData_Stream::setParametersArray( const TColStd_Array1OfReal& theArray )
777 {
778   if ( theArray.Length() == 0 )
779   {
780     removeParametersArray();
781     return;
782   }
783
784   TDF_Label aLabel = myLab.FindChild( DataTag_ParamsArray );
785   
786   Handle(TDataStd_RealArray) aParamsArray = 
787     TDataStd_RealArray::Set( aLabel, theArray.Lower(), theArray.Upper() );
788
789   for ( int i = theArray.Lower(), n = theArray.Upper(); i <= n; ++i )
790   {
791     const Standard_Real& aParam = theArray( i );
792     aParamsArray->SetValue( i, aParam );
793   }
794 }
795
796 TColStd_Array1OfReal* HYDROData_Stream::getParametersArray() const
797 {
798   TColStd_Array1OfReal* anArray = NULL;
799
800   TDF_Label aLabel = myLab.FindChild( DataTag_ParamsArray, false );
801   if ( !aLabel.IsNull() )
802   {
803     Handle(TDataStd_RealArray) aParamsArray;
804     if ( aLabel.FindAttribute( TDataStd_RealArray::GetID(), aParamsArray ) )
805     {
806       anArray = new TColStd_Array1OfReal( aParamsArray->Lower(), aParamsArray->Upper() );
807       for ( int i = aParamsArray->Lower(), n = aParamsArray->Upper(); i <= n; ++i )
808       {
809         const Standard_Real& aParam = aParamsArray->Value( i );
810         anArray->SetValue( i, aParam );
811       }
812     }
813   }
814
815   return anArray;
816 }
817
818 void HYDROData_Stream::removeParametersArray()
819 {
820   TDF_Label aLabel = myLab.FindChild( DataTag_ParamsArray, false );
821   if ( !aLabel.IsNull() )
822     aLabel.ForgetAllAttributes();
823 }
824
825 int HYDROData_Stream::insertParameter( const Standard_Real& theParam )
826 {
827   int aResIndex = -1;
828
829   TColStd_Array1OfReal* anArr = getParametersArray();
830   if ( anArr )
831   {
832     aResIndex = 0;
833
834     TColStd_Array1OfReal aNewArr( anArr->Lower(), anArr->Upper() + 1 );
835
836     bool isInserted = false;
837     for ( int i = anArr->Lower(), j = i, n = anArr->Upper(); i <= n; ++i, ++j )
838     {
839       const Standard_Real& aStoredParam = anArr->Value( i );
840       if ( !isInserted )
841       {
842         if ( theParam > aStoredParam )
843         {
844           aResIndex++;
845         }
846         else
847         {
848           aNewArr( j ) = theParam;
849           isInserted = true;
850           ++j;
851         }
852       }
853
854       aNewArr( j ) = aStoredParam;
855     }
856
857     if ( !isInserted )
858     {
859       aResIndex = -1;
860       aNewArr( aNewArr.Upper() ) = theParam;
861     }
862     
863     setParametersArray( aNewArr );
864     delete anArr;
865   }
866   else
867   {
868     TColStd_Array1OfReal aNewArr( 1, 1 );
869     aNewArr.SetValue( 1, theParam );
870     setParametersArray( aNewArr );
871   }
872
873   return aResIndex;
874 }
875
876 void HYDROData_Stream::removeParameter( const int& theIndex )
877 {
878   TDF_Label aLabel = myLab.FindChild( DataTag_ParamsArray, false );
879   if ( aLabel.IsNull() )
880     return;
881
882   Handle(TDataStd_RealArray) aParamsArray;
883   if ( !aLabel.FindAttribute( TDataStd_RealArray::GetID(), aParamsArray ) )
884     return;
885
886   if ( aParamsArray->Length() == 1 )
887   {
888     removeParametersArray();
889     return;
890   }
891
892   TColStd_Array1OfReal aNewArr( aParamsArray->Lower(), aParamsArray->Upper() - 1 );
893
894   for ( int i = aParamsArray->Lower(), j = i, k = 0, n = aParamsArray->Upper(); i <= n; ++i, ++k )
895   {
896     const Standard_Real& aStoredParam = aParamsArray->Value( i );
897     if ( k == theIndex )
898       continue;
899
900     aNewArr.SetValue( j, aStoredParam );
901     ++j;
902   }
903
904   setParametersArray( aNewArr );
905 }