]> SALOME platform Git repositories - modules/hydro.git/blob - src/HYDROData/HYDROData_Channel.cxx
Salome HOME
refs #751: more dense points distribution for the channel/digue creation on spline
[modules/hydro.git] / src / HYDROData / HYDROData_Channel.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_Channel.h"
20
21 #include "HYDROData_Document.h"
22 #include "HYDROData_Polyline3D.h"
23 #include "HYDROData_Profile.h"
24 #include "HYDROData_PolylineXY.h"
25 #include "HYDROData_Projection.h"
26 #include "HYDROData_ShapesGroup.h"
27 #include "HYDROData_ShapesTool.h"
28 #include "HYDROData_Stream.h"
29 #include "HYDROData_Tool.h"
30
31 #include <BRepBuilderAPI_MakeWire.hxx>
32
33 #include <BRepOffsetAPI_MakePipeShell.hxx>
34 #include <BRepOffsetAPI_MakePipe.hxx>
35 #include <BRepCheck_Analyzer.hxx>
36
37 #include <BRep_Tool.hxx>
38
39 #include <BRepBuilderAPI_Transform.hxx>
40
41 #include <BRepLib_MakeEdge.hxx>
42 #include <BRepLib_MakeWire.hxx>
43
44 #include <GeomAPI_ProjectPointOnCurve.hxx>
45
46 #include <gp_Ax1.hxx>
47
48 #include <TopExp.hxx>
49 #include <TopExp_Explorer.hxx>
50
51 #include <TColgp_HArray1OfPnt.hxx>
52 #include <TColgp_Array1OfDir.hxx>
53
54 #include <TColStd_Array1OfReal.hxx>
55
56 #include <TopTools_HArray1OfShape.hxx>
57
58 #include <TopoDS.hxx>
59 #include <TopoDS_Wire.hxx>
60 #include <TopoDS_Vertex.hxx>
61
62 //#define DEB_CHANNEL 1
63 #ifdef DEB_CHANNEL
64 #include <BRepTools.hxx>
65 #endif
66
67 #include <QColor>
68 #include <QStringList>
69
70 IMPLEMENT_STANDARD_HANDLE(HYDROData_Channel,HYDROData_ArtificialObject)
71 IMPLEMENT_STANDARD_RTTIEXT(HYDROData_Channel,HYDROData_ArtificialObject)
72
73
74 HYDROData_Channel::HYDROData_Channel()
75 : HYDROData_ArtificialObject( Geom_3d )
76 {
77 }
78
79 HYDROData_Channel::~HYDROData_Channel()
80 {
81 }
82
83 QStringList HYDROData_Channel::DumpToPython( const QString& thePyScriptPath,
84                                              MapOfTreatedObjects& theTreatedObjects ) const
85 {
86   QStringList aResList = dumpObjectCreation( theTreatedObjects );
87   QString aName = GetObjPyName();
88
89   Handle(HYDROData_Polyline3D) aRefGideLine = GetGuideLine();
90   setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aRefGideLine, "SetGuideLine" );
91
92   Handle(HYDROData_Profile) aRefProfile = GetProfile();
93   setPythonReferenceObject( thePyScriptPath, theTreatedObjects, aResList, aRefProfile, "SetProfile" );
94
95   aResList << QString( "" );
96   aResList << QString( "%1.Update();" ).arg( aName );
97   aResList << QString( "" );
98
99   return aResList;
100 }
101
102 HYDROData_SequenceOfObjects HYDROData_Channel::GetAllReferenceObjects() const
103 {
104   HYDROData_SequenceOfObjects aResSeq = HYDROData_ArtificialObject::GetAllReferenceObjects();
105
106   Handle(HYDROData_Polyline3D) aGuideLine = GetGuideLine();
107   if ( !aGuideLine.IsNull() )
108     aResSeq.Append( aGuideLine );
109
110   Handle(HYDROData_Profile) aProfile = GetProfile();
111   if ( !aProfile.IsNull() )
112     aResSeq.Append( aProfile );
113
114   return aResSeq;
115 }
116
117 bool HYDROData_Channel::CreatePresentations( const Handle(HYDROData_Polyline3D)& theGuideLine,
118                                              const Handle(HYDROData_Profile)&    theProfile,
119                                              PrsDefinition&                      thePrs )
120 {
121   // Check input parameters
122   if ( theGuideLine.IsNull() || theProfile.IsNull() ) {
123     return false;
124   }
125
126   TopoDS_Wire aPathWire = TopoDS::Wire( theGuideLine->GetShape3D() );
127   TopoDS_Wire aProfileWire = TopoDS::Wire( theProfile->GetShape3D() );
128   if ( aPathWire.IsNull() || aProfileWire.IsNull() ) {
129     return false;
130   }
131
132 #ifdef DEB_CHANNEL
133   BRepTools::Write( aPathWire, "guideline.brep" );
134   BRepTools::Write( aProfileWire, "profile.brep" );
135 #endif
136
137   // Pre-processing
138   Handle(HYDROData_PolylineXY) aPolylineXY = theGuideLine->GetPolylineXY();
139   if ( aPolylineXY.IsNull() ) {
140     return false;
141   }
142
143   /*
144   HYDROData_IPolyline::SectionType aSectionType = aPolylineXY->GetSectionType( 0 );
145   HYDROData_IPolyline::PointsList aPolylinePoints = aPolylineXY->GetPoints( 0 );
146   int aNbPoints = aPolylinePoints.Length();
147   */
148
149   double aEqDistance = 1; // TODO: to pass via properties and OCAF
150   HYDROData_Polyline3D::Polyline3DPoints aPolylinePoints3D = theGuideLine->GetPoints( aEqDistance );
151   int aNbPoints = aPolylinePoints3D.Length();
152   if ( aNbPoints < 2 )
153     return false;
154   
155   // Get tangent in each point of the guide line ( 2D )
156   TColgp_Array1OfDir aTangents( 1, aNbPoints );
157
158   HYDROData_IPolyline::SectionType aSectionType = aPolylineXY->GetSectionType( 0 );
159   
160   if( aSectionType == HYDROData_IPolyline::SECTION_POLYLINE )
161   {
162     for ( int i = 1; i <= aNbPoints; ++i ) {
163       gp_XYZ aPnt = aPolylinePoints3D.Value( i );
164       aPnt.SetZ( 0. );
165       gp_XYZ aPrevPnt;
166       if ( i > 1 ) {
167         aPrevPnt = aPolylinePoints3D.Value( i - 1 );
168         aPrevPnt.SetZ( 0. );
169       }
170
171       gp_Vec aDir;
172       if ( i < aNbPoints ) {
173         gp_XYZ aNextPnt = aPolylinePoints3D.Value( i + 1 );
174         aNextPnt.SetZ( 0. );
175
176         gp_Vec anEdgeVec( aPnt, aNextPnt );
177
178         if ( i == 1 ) {
179           aDir = anEdgeVec;
180         } else {
181           gp_Vec aPrevVec( aPrevPnt, aPnt );
182           aDir = aPrevVec.Normalized() + anEdgeVec.Normalized();
183         }
184       } else {
185         aDir = gp_Vec( aPrevPnt, aPnt );
186       }
187             
188       aTangents.SetValue( i, aDir );
189     }
190   } else {
191     // Get curve from the first edge ( 2D )
192     TopTools_SequenceOfShape anEdges;
193     HYDROData_ShapesTool::ExploreShapeToShapes( aPolylineXY->GetShape(), TopAbs_EDGE, anEdges );
194     Standard_Real aStart, anEnd;
195
196     Handle(Geom_Curve) aCurve = BRep_Tool::Curve( TopoDS::Edge( anEdges.First() ), aStart, anEnd );
197     GeomAPI_ProjectPointOnCurve aProject;
198
199     // Get tangents
200     for ( int i = 1; i <= aNbPoints; ++i ) {
201       gp_XYZ aPointToTest = aPolylinePoints3D.Value( i );
202       aPointToTest.SetZ( 0. );
203
204       aProject.Init( aPointToTest, aCurve );
205       Quantity_Parameter aParam = aProject.LowerDistanceParameter();
206       gp_Pnt aPnt;
207       gp_Vec aDir;
208       aCurve->D1( aParam, aPnt, aDir);
209
210       aTangents.SetValue( i, aDir );
211     }
212   }
213
214   // Get the profile middle point ( 3D )
215   gp_Pnt aMiddlePoint( theProfile->GetMiddlePoint( true ) );
216
217   // Translate the profile to each point on the guide line ( 3D )
218   Handle(TColgp_HArray1OfPnt) anArrayOfFPnt = new TColgp_HArray1OfPnt(1, aNbPoints );
219   Handle(TColgp_HArray1OfPnt) anArrayOfLPnt = new TColgp_HArray1OfPnt(1, aNbPoints );  
220   Handle(TopTools_HArray1OfShape) anArrOfProfiles = new TopTools_HArray1OfShape( 1, aNbPoints );
221
222   for ( int i = 1; i <= aNbPoints; ++i ) {
223     // Get point on the guide line
224     gp_Pnt aPointOnGuide( aPolylinePoints3D.Value( i ) );
225
226     // Define translation and rotation:
227     gp_Trsf Translation, Rotation;
228
229     // Translation
230     Translation.SetTranslation( aMiddlePoint, aPointOnGuide );
231     TopoDS_Wire aTransformedProfile = 
232       TopoDS::Wire( BRepBuilderAPI_Transform( aProfileWire, Translation, Standard_True ) );
233
234     // Rotation
235     gp_Vec aVertical( 0., 0., 1. );
236     TopoDS_Vertex aLeftVertex, aRightVertex;
237     TopExp::Vertices( aTransformedProfile, aLeftVertex, aRightVertex );
238     gp_Pnt aLeftPoint  = BRep_Tool::Pnt( aLeftVertex );
239     gp_Pnt aRightPoint = BRep_Tool::Pnt( aRightVertex );
240     gp_Vec aLeftToRight( aLeftPoint, aRightPoint);
241     gp_Vec NormalToProfile = aVertical ^ aLeftToRight;
242
243     gp_Vec aDir = aTangents.Value( i );
244     gp_Vec AxisOfRotation = NormalToProfile ^ aDir;
245     if (AxisOfRotation.Magnitude() <= gp::Resolution()) {
246       if ( aVertical * aLeftToRight < 0. ) {
247         gp_Ax1 theVertical(aPointOnGuide, gp::DZ() );
248         Rotation.SetRotation(theVertical, M_PI);
249       }
250     } else {
251       gp_Ax1 theAxis(aPointOnGuide, AxisOfRotation);
252       Standard_Real theAngle = NormalToProfile.AngleWithRef(aDir, AxisOfRotation);
253       Rotation.SetRotation(theAxis, theAngle);
254     }
255
256     aTransformedProfile = TopoDS::Wire(BRepBuilderAPI_Transform( aTransformedProfile, Rotation, Standard_True) );
257
258     // Get the first and the last points of the transformed profile
259     TopoDS_Vertex V1, V2;
260     TopExp::Vertices( aTransformedProfile, V1, V2 );
261
262     // Fill the data
263     anArrayOfFPnt->SetValue( i, BRep_Tool::Pnt( V1 ) );
264     anArrayOfLPnt->SetValue( i, BRep_Tool::Pnt( V2 ) );
265        
266     anArrOfProfiles->SetValue( i, aTransformedProfile );
267   }
268
269   // Create presentation
270   HYDROData_Stream::PrsDefinition aPrs;
271   Handle(TopTools_HArray1OfShape) anArrOf2DProfiles; // we don't need 2D profiles for channel/digue presentation
272   bool aRes = HYDROData_Stream::CreatePresentations( anArrayOfFPnt, anArrayOfLPnt,
273                                                      anArrOfProfiles, anArrOf2DProfiles, aPrs );
274   if ( aRes ) {
275     thePrs.myPrs3D = aPrs.myPrs3D;
276     thePrs.myPrs2D = TopoDS::Face( aPrs.myPrs2D );
277     BRepBuilderAPI_MakeWire aMakeWire( aPrs.myLeftBank ) ;
278     thePrs.myLeftBank = aMakeWire.Wire();
279     aMakeWire = BRepBuilderAPI_MakeWire( aPrs.myRightBank );
280     thePrs.myRightBank = aMakeWire.Wire();
281     aMakeWire = BRepBuilderAPI_MakeWire( aPrs.myInlet );
282     thePrs.myInlet = aMakeWire.Wire();
283     aMakeWire = BRepBuilderAPI_MakeWire( aPrs.myOutlet );
284     thePrs.myOutlet = aMakeWire.Wire();
285   }
286
287   return aRes;
288 }
289
290 void HYDROData_Channel::Update()
291 {
292   HYDROData_ArtificialObject::Update();
293
294   Handle(HYDROData_Polyline3D) aGuideLine = GetGuideLine();
295   Handle(HYDROData_Profile) aProfile = GetProfile();
296
297   PrsDefinition aResultPrs;
298   if ( !CreatePresentations( aGuideLine, aProfile, aResultPrs ) )
299     return;
300
301   SetShape3D( aResultPrs.myPrs3D );
302   SetTopShape( aResultPrs.myPrs2D );
303
304   // Create groups for channel
305   TopTools_SequenceOfShape aLeftBankEdges;
306   HYDROData_ShapesTool::ExploreShapeToShapes( aResultPrs.myLeftBank, TopAbs_EDGE, aLeftBankEdges );
307
308   TopTools_SequenceOfShape aRightBankEdges;
309   HYDROData_ShapesTool::ExploreShapeToShapes( aResultPrs.myRightBank, TopAbs_EDGE, aRightBankEdges );
310
311   TopTools_SequenceOfShape anInletEdges;
312   HYDROData_ShapesTool::ExploreShapeToShapes( aResultPrs.myInlet, TopAbs_EDGE, anInletEdges );
313
314   TopTools_SequenceOfShape anOutletEdges;
315   HYDROData_ShapesTool::ExploreShapeToShapes( aResultPrs.myOutlet, TopAbs_EDGE, anOutletEdges );
316
317   QString aLeftGroupName = GetName() + "_Left_Bank";
318
319   Handle(HYDROData_ShapesGroup) aLeftGroup = createGroupObject();
320   aLeftGroup->SetName( aLeftGroupName );
321   aLeftGroup->SetShapes( aLeftBankEdges );
322
323   QString aRightGroupName = GetName() + "_Right_Bank";
324
325   Handle(HYDROData_ShapesGroup) aRightGroup = createGroupObject();
326   aRightGroup->SetName( aRightGroupName );
327   aRightGroup->SetShapes( aRightBankEdges );
328
329   QString anInGroupName = GetName() + "_Inlet";
330
331   Handle(HYDROData_ShapesGroup) anInGroup = createGroupObject();
332   anInGroup->SetName( anInGroupName );
333   anInGroup->SetShapes( anInletEdges );
334
335   QString anOutGroupName = GetName() + "_Outlet";
336
337   Handle(HYDROData_ShapesGroup) anOutGroup = createGroupObject();
338   anOutGroup->SetName( anOutGroupName );
339   anOutGroup->SetShapes( anOutletEdges );
340 }
341
342 bool HYDROData_Channel::IsHas2dPrs() const
343 {
344   return true;
345 }
346
347 QColor HYDROData_Channel::DefaultFillingColor() const
348 {
349   return QColor( Qt::blue );
350 }
351
352 QColor HYDROData_Channel::DefaultBorderColor() const
353 {
354   return QColor( Qt::transparent );
355 }
356
357 bool HYDROData_Channel::SetGuideLine( const Handle(HYDROData_Polyline3D)& theGuideLine )
358 {
359   Handle(HYDROData_Polyline3D) aPrevGuideLine = GetGuideLine();
360
361   if ( theGuideLine.IsNull() )
362   {
363     RemoveGuideLine();
364     return !aPrevGuideLine.IsNull();
365   }
366
367   if ( IsEqual( aPrevGuideLine, theGuideLine ) )
368     return false;
369
370   TopoDS_Wire aHydraulicWire = TopoDS::Wire( theGuideLine->GetTopShape() );
371   if ( aHydraulicWire.IsNull() )
372     return false; // The polyline must be a single wire
373
374   SetReferenceObject( theGuideLine, DataTag_GuideLine );
375
376   // Indicate model of the need to update the chanel presentation
377   Changed( Geom_3d );
378
379   return true;
380 }
381
382 Handle(HYDROData_Polyline3D) HYDROData_Channel::GetGuideLine() const
383 {
384   return Handle(HYDROData_Polyline3D)::DownCast( 
385            GetReferenceObject( DataTag_GuideLine ) );
386 }
387
388 void HYDROData_Channel::RemoveGuideLine()
389 {
390   Handle(HYDROData_Polyline3D) aPrevGuideLine = GetGuideLine();
391   if ( aPrevGuideLine.IsNull() )
392     return;
393
394   ClearReferenceObjects( DataTag_GuideLine );
395
396   // Indicate model of the need to update the chanel presentation
397   Changed( Geom_3d );
398 }
399
400 bool HYDROData_Channel::SetProfile( const Handle(HYDROData_Profile)& theProfile )
401 {
402   Handle(HYDROData_Profile) aPrevProfile = GetProfile();
403
404   if ( theProfile.IsNull() )
405   {
406     RemoveProfile();
407     return !aPrevProfile.IsNull();
408   }
409
410   if ( IsEqual( aPrevProfile, theProfile ) )
411     return false;
412
413   SetReferenceObject( theProfile, DataTag_Profile );
414
415   // Indicate model of the need to update the chanel presentation
416   Changed( Geom_3d );
417
418   return true;
419 }
420
421 Handle(HYDROData_Profile) HYDROData_Channel::GetProfile() const
422 {
423   return Handle(HYDROData_Profile)::DownCast( 
424            GetReferenceObject( DataTag_Profile ) );
425 }
426
427 void HYDROData_Channel::RemoveProfile()
428 {
429   Handle(HYDROData_Profile) aPrevProfile = GetProfile();
430   if ( aPrevProfile.IsNull() )
431     return;
432
433   ClearReferenceObjects( DataTag_Profile );
434
435   // Indicate model of the need to update the chanel presentation
436   Changed( Geom_3d );
437 }
438
439 ObjectKind HYDROData_Channel::getAltitudeObjectType() const
440 {
441   return KIND_STREAM_ALTITUDE;
442 }
443
444 TopoDS_Shape HYDROData_Channel::GetLeftShape() const
445 {
446   HYDROData_SequenceOfObjects aGroups = GetGroups();
447   return HYDROData_Tool::getFirstShapeFromGroup( aGroups, 1);
448 }
449
450 TopoDS_Shape HYDROData_Channel::GetRightShape() const
451 {
452   HYDROData_SequenceOfObjects aGroups = GetGroups();
453   return HYDROData_Tool::getFirstShapeFromGroup( aGroups, 2);
454 }