]> SALOME platform Git repositories - modules/hydro.git/blob - src/HYDROGUI/HYDROGUI_StreamOp.cxx
Salome HOME
edit of stream (show profiles after edit op)
[modules/hydro.git] / src / HYDROGUI / HYDROGUI_StreamOp.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 "HYDROGUI_StreamOp.h"
20
21 #include "HYDROGUI_Module.h"
22 #include <HYDROGUI_DataObject.h>
23 #include "HYDROGUI_Shape.h"
24 #include "HYDROGUI_StreamDlg.h"
25 #include "HYDROGUI_Tool.h"
26 #include "HYDROGUI_Tool2.h"
27 #include "HYDROGUI_UpdateFlags.h"
28
29 #include <HYDROData_Document.h>
30 #include <HYDROData_PolylineXY.h>
31 #include <HYDROData_Profile.h>
32 #include <HYDROData_DTM.h>
33
34 #include <LightApp_Application.h>
35 #include <LightApp_SelectionMgr.h>
36 #include <LightApp_UpdateFlags.h>
37
38 #include <SUIT_MessageBox.h>
39 #include <SUIT_Desktop.h>
40 #include <QColor>
41
42 #include <OCCViewer_ViewManager.h>
43 #include <OCCViewer_ViewModel.h>
44 #include <OCCViewer_ViewWindow.h>
45 #include <gp_Ax1.hxx>
46 #include <gp_Ax2.hxx>
47 #include <gp_Ax3.hxx>
48 #include <gp_Vec.hxx>
49 #include <gp_Pnt.hxx>
50 #include <gp_Pln.hxx>
51 #include <gp.hxx>
52 #include <TopoDS_Face.hxx>
53 #include <TopoDS.hxx>
54 #include <BRepBuilderAPI_MakeFace.hxx>
55
56 void insertProfileInToOrder( const QString& theProfileName,
57                              const double&  theProfilePar,
58                              QStringList&   theProfiles,
59                              QList<double>& theProfileParams )
60 {
61   bool anIsInserted = false;
62   for ( int k = 0; k < theProfileParams.length(); ++k )
63   {
64     const double& aParam = theProfileParams.value( k );
65     if ( theProfilePar < aParam )
66     {
67       theProfiles.insert( k, theProfileName );
68       theProfileParams.insert( k, theProfilePar );
69       anIsInserted = true;
70       break;
71     }
72   }
73   
74   if ( !anIsInserted )
75   {
76     theProfiles << theProfileName;
77     theProfileParams << theProfilePar;
78   }
79 }
80
81 HYDROGUI_StreamOp::HYDROGUI_StreamOp( HYDROGUI_Module* theModule, bool theIsEdit )
82 : HYDROGUI_Operation( theModule ), 
83   myIsEdit( theIsEdit ),
84   myPreviewPrs( NULL )
85 {
86   setName( theIsEdit ? tr( "EDIT_STREAM" ) : tr( "CREATE_STREAM" ) );
87 }
88
89 HYDROGUI_StreamOp::~HYDROGUI_StreamOp()
90 {
91   erasePreview();
92 }
93
94 void HYDROGUI_StreamOp::startOperation()
95 {
96   HYDROGUI_Operation::startOperation();
97
98   if ( !myIsEdit || isApplyAndClose() )
99     myEditedObject.Nullify();
100   myHydAxis.clear();
101   myProfiles.clear();
102   myProfileParams.clear();
103
104   // Get panel and reset its state
105   HYDROGUI_StreamDlg* aPanel = (HYDROGUI_StreamDlg*)inputPanel();
106   aPanel->reset();
107
108   QString anObjectName = HYDROGUI_Tool::GenerateObjectName( module(), tr( "DEFAULT_STREAM_NAME" ) );
109   if ( myIsEdit )
110   {
111     if ( isApplyAndClose() )
112       myEditedObject =
113         Handle(HYDROData_Stream)::DownCast( HYDROGUI_Tool::GetSelectedObject( module() ) );
114     if ( !myEditedObject.IsNull() )
115     {
116       anObjectName = myEditedObject->GetName();
117
118       // Hydraulic axis
119       Handle(HYDROData_PolylineXY) aHydraulicAxis = myEditedObject->GetHydraulicAxis();
120       
121       TopoDS_Face aPlane;
122       HYDROData_Stream::BuildRefFace( aPlane ) ;
123       if ( !aHydraulicAxis.IsNull() )
124         myHydAxis = aHydraulicAxis->GetName();
125
126       // Stream profiles
127       HYDROData_SequenceOfObjects aStreamProfiles = myEditedObject->GetProfiles();
128       for ( int i = 1, n = aStreamProfiles.Length(); i <= n; ++i )
129       {
130         Handle(HYDROData_Profile) aProfile = 
131           Handle(HYDROData_Profile)::DownCast( aStreamProfiles.Value( i ) );
132         if ( aProfile.IsNull() )
133           continue;
134
135         QString aProfileName = aProfile->GetName();        
136         myProfiles      << aProfileName;
137
138         if (!aHydraulicAxis.IsNull())
139         {
140           Standard_Real aProfilePar = 0.0;
141           HYDROData_Stream::HasIntersection( aHydraulicAxis, aProfile, aPlane, aProfilePar );
142           myProfileParams << aProfilePar;
143         }
144
145       }      
146
147     }
148   }
149
150   // Update the panel
151   // set the edited object name
152   aPanel->setObjectName( anObjectName );
153
154   // set the existing 2D polylines names to the panel
155   aPanel->setAxisNames( HYDROGUI_Tool::FindExistingObjectsNames( doc(), KIND_POLYLINEXY ) );
156
157   if (myIsEdit)
158   {
159     aPanel->setDDZ( myEditedObject->GetDDZ() );
160     aPanel->setSpatialStep( myEditedObject->GetSpatialStep() );
161   }
162
163   // synchronize the panel state with the edited object state
164   updatePanelData();
165
166   // Create preview
167   createPreview();
168 }
169
170 void HYDROGUI_StreamOp::abortOperation()
171 {
172   erasePreview();
173   HYDROGUI_Operation::abortOperation();
174 }
175
176 void HYDROGUI_StreamOp::commitOperation()
177 {
178   erasePreview();
179   HYDROGUI_Operation::commitOperation();
180 }
181
182 HYDROGUI_InputPanel* HYDROGUI_StreamOp::createInputPanel() const
183 {
184   HYDROGUI_StreamDlg* aPanel = new HYDROGUI_StreamDlg( module(), getName() );
185
186   connect( aPanel, SIGNAL( AddProfiles() ), this, SLOT( onAddProfiles() ) );
187   connect( aPanel, SIGNAL( RemoveProfiles( const QStringList& ) ), 
188            this, SLOT( onRemoveProfiles( const QStringList& ) ) );
189   connect( aPanel, SIGNAL( AxisChanged( const QString& ) ), 
190            this, SLOT( onAxisChanged( const QString& ) ) );
191
192   connect( aPanel, SIGNAL( DDZValueChanged( double ) ),  this, SLOT( onDDZValueChanged( double ) ) );
193   connect( aPanel, SIGNAL( SSValueChanged( double ) ),  this, SLOT( onSSValueChanged( double ) ) );
194   return aPanel;
195 }
196
197 bool HYDROGUI_StreamOp::processApply( int& theUpdateFlags,
198                                       QString& theErrorMsg,
199                                       QStringList& theBrowseObjectsEntries )
200 {
201   HYDROGUI_StreamDlg* aPanel = ::qobject_cast<HYDROGUI_StreamDlg*>( inputPanel() );
202   if ( !aPanel )
203     return false;
204
205   // Check whether the object name is not empty
206   QString anObjectName = aPanel->getObjectName().simplified();
207   if ( anObjectName.isEmpty() )
208   {
209     theErrorMsg = tr( "INCORRECT_OBJECT_NAME" );
210     return false;
211   }
212
213   // Check that there are no other objects with the same name in the document
214   if ( !myIsEdit || ( !myEditedObject.IsNull() && myEditedObject->GetName() != anObjectName ) )
215   {
216     Handle(HYDROData_Entity) anObject = HYDROGUI_Tool::FindObjectByName( module(), anObjectName );
217     if( !anObject.IsNull() )
218     {
219       theErrorMsg = tr( "OBJECT_EXISTS_IN_DOCUMENT" ).arg( anObjectName );
220       return false;
221     }
222   }
223
224   if ( myEditedObject.IsNull() ) // Create new data model object
225     myEditedObject = Handle(HYDROData_Stream)::DownCast( doc()->CreateObject( KIND_STREAM ) );
226
227   Handle(HYDROData_PolylineXY) aHydAxis = Handle(HYDROData_PolylineXY)::DownCast(
228     HYDROGUI_Tool::FindObjectByName( module(), myHydAxis, KIND_POLYLINEXY ) );
229  //if ( aHydAxis.IsNull() )
230  //{
231  //  theErrorMsg = tr( "AXIS_NOT_DEFINED" );
232  //  return false;
233  //}
234
235   // Check if at least 2 profiles is set
236   HYDROData_SequenceOfObjects aRefProfiles;
237   for ( int i = 0; i < myProfiles.length(); ++i )
238   {
239     QString aProfileName = myProfiles.value( i );
240
241     Handle(HYDROData_Profile) aProfile = Handle(HYDROData_Profile)::DownCast(
242       HYDROGUI_Tool::FindObjectByName( module(), aProfileName, KIND_PROFILE ) );
243     if ( !aProfile.IsNull() )
244       aRefProfiles.Append( aProfile );
245   }
246
247   if ( aRefProfiles.Length() < 2 )
248   {
249     theErrorMsg = tr( "PROFILES_NOT_DEFINED" );
250     return false;
251   }
252
253   bool ToOrder = true;
254
255   if (aHydAxis.IsNull())
256     ToOrder = false;
257
258   myEditedObject->SetProfiles (aRefProfiles, ToOrder) ;
259   myEditedObject->SetName( anObjectName );
260
261   if (!aHydAxis.IsNull())
262     myEditedObject->SetHydraulicAxis( aHydAxis );
263   myEditedObject->SetProfiles( aRefProfiles, false );
264   myEditedObject->SetDDZ( aPanel->getDDZ() );
265   myEditedObject->SetSpatialStep( aPanel->getSpatialStep() );
266
267   if ( myEditedObject->IsMustBeUpdated( HYDROData_Entity::Geom_2d ) )
268     myEditedObject->Update();
269
270   if ( !myIsEdit )
271   {
272     myEditedObject->SetFillingColor( myEditedObject->DefaultFillingColor() );
273     myEditedObject->SetBorderColor( myEditedObject->DefaultBorderColor() );
274   }
275
276   // Erase preview
277   erasePreview();
278
279   // Show the object in case of creation mode of the operation
280   if( !myIsEdit ) {
281     module()->setObjectVisible( HYDROGUI_Tool::GetActiveOCCViewId( module() ), myEditedObject, true );
282     QString anEntry = HYDROGUI_DataObject::dataObjectEntry( myEditedObject );
283     theBrowseObjectsEntries.append( anEntry );
284   }
285
286   module()->setIsToUpdate( myEditedObject );
287
288   // Set update flags
289   theUpdateFlags = UF_Model | UF_OCCViewer | UF_OCC_Forced | UF_VTKViewer;
290
291   return true;
292 }
293
294 void HYDROGUI_StreamOp::createPreview()
295 {
296   LightApp_Application* anApp = module()->getApp();
297   if ( !getPreviewManager() )
298   {
299     setPreviewManager( ::qobject_cast<OCCViewer_ViewManager*>( 
300                        anApp->getViewManager( OCCViewer_Viewer::Type(), true ) ) );
301   }
302
303   OCCViewer_ViewManager* aViewManager = getPreviewManager();
304   if ( aViewManager && !myPreviewPrs )
305   {
306     if ( OCCViewer_Viewer* aViewer = aViewManager->getOCCViewer() )
307     {
308       Handle(AIS_InteractiveContext) aCtx = aViewer->getAISContext();
309       if ( !aCtx.IsNull() )
310       {
311         myPreviewPrs = new HYDROGUI_Shape( aCtx, NULL, getPreviewZLayer() );
312
313         QColor aFillingColor = Qt::green;
314         QColor aBorderColor = Qt::transparent;
315         if ( !myEditedObject.IsNull() )
316         {
317           aFillingColor = myEditedObject->GetFillingColor();
318           aBorderColor = myEditedObject->GetBorderColor();
319         }
320
321         myPreviewPrs->setFillingColor( aFillingColor, false, false );
322         myPreviewPrs->setBorderColor( aBorderColor, false, false );
323       }
324     }
325   }
326
327   if ( !aViewManager || !myPreviewPrs )
328     return;
329
330   Handle(HYDROData_PolylineXY) aHydAxis = Handle(HYDROData_PolylineXY)::DownCast(
331     HYDROGUI_Tool::FindObjectByName( module(), myHydAxis, KIND_POLYLINEXY ) );
332
333   HYDROData_SequenceOfObjects aRefProfiles;
334   //std::vector<Handle_HYDROData_Profile> aRefProfiles;
335   int plen = myProfiles.length();
336   for ( int i = 0; i < plen; ++i )
337   {
338     QString aProfileName = myProfiles.value( i );
339
340     Handle(HYDROData_Profile) aProfile = Handle(HYDROData_Profile)::DownCast(
341       HYDROGUI_Tool::FindObjectByName( module(), aProfileName, KIND_PROFILE ) );
342     if ( !aProfile.IsNull() )
343       aRefProfiles.Append( aProfile );
344   }
345
346   HYDROData_Stream::PrsDefinition aPrsDef;
347
348   TopoDS_Shape Out3dPres;
349   TopoDS_Shape Out2dPres;
350   TopoDS_Shape OutLeftB;
351   TopoDS_Shape OutRightB;
352   TopoDS_Shape OutInlet;
353   TopoDS_Shape OutOutlet;
354
355   HYDROGUI_StreamDlg* aPanel = ::qobject_cast<HYDROGUI_StreamDlg*>( inputPanel() );
356   double ddz = aPanel->getDDZ();
357   double ss = aPanel->getSpatialStep();
358
359   std::set<int> InvInd;
360     
361   HYDROData_Bathymetry::AltitudePoints points;
362   HYDROData_DTM::CreateProfilesFromDTM( aRefProfiles, ddz, ss, points, Out3dPres, Out2dPres, OutLeftB, OutRightB,
363     OutInlet, OutOutlet, true, true, InvInd);
364
365   aPanel->clearAllBackgroundColorsForProfileList();
366   for (std::set<int>::const_iterator it = InvInd.begin(); it != InvInd.end(); it++)
367     aPanel->setBackgroundColorForProfileList(*it, QColor(Qt::yellow));
368
369   aPrsDef.myInlet = TopoDS::Wire(OutInlet);
370   aPrsDef.myOutlet = TopoDS::Wire(OutOutlet);
371   aPrsDef.myLeftBank = TopoDS::Wire(OutLeftB);
372   aPrsDef.myRightBank = TopoDS::Wire(OutRightB);
373   aPrsDef.myPrs2D = Out2dPres;
374   aPrsDef.myPrs3D = Out3dPres;
375
376   myPreviewPrs->setShape( aPrsDef.myPrs2D );
377 }
378
379 void HYDROGUI_StreamOp::erasePreview()
380 {
381   if( myPreviewPrs )
382   {
383     delete myPreviewPrs;
384     myPreviewPrs = 0;
385   }
386 }
387
388 void HYDROGUI_StreamOp::onAddProfiles()
389 {
390   Handle(HYDROData_PolylineXY) aHydAxis = Handle(HYDROData_PolylineXY)::DownCast(
391     HYDROGUI_Tool::FindObjectByName( module(), myHydAxis, KIND_POLYLINEXY ) );
392   //if ( aHydAxis.IsNull() )
393    // return;
394
395   TopoDS_Face aPlane;
396   HYDROData_Stream::BuildRefFace( aPlane );
397
398   // Get the current profiles list
399   QStringList aCurrentProfiles = myProfiles;
400     
401   // Get the selected profiles ( in the Object Browser )
402   QStringList anInvalidProfiles;
403   QStringList anExistingProfiles;
404   QStringList aHasNoIntersectionProfiles;
405   QStringList aVerifiedProfiles;
406
407   HYDROData_SequenceOfObjects aSelectedProfiles = HYDROGUI_Tool::GetSelectedObjects( module() ); 
408
409   for( int i = 1, n = aSelectedProfiles.Length(); i <= n; i++ )
410   {
411     Handle(HYDROData_Profile) aProfile = 
412       Handle(HYDROData_Profile)::DownCast( aSelectedProfiles.Value( i ) );
413     if ( aProfile.IsNull() )
414       continue;
415
416     QString aProfileName = aProfile->GetName();
417     Standard_Real aProfilePar = 0.0;
418
419     // Check the profile, if all is ok - add it to the list
420     if ( !aProfile->IsValid() )
421     {
422       // check whether the profile is valid
423       anInvalidProfiles << aProfileName;
424     }
425     else if ( aCurrentProfiles.contains( aProfileName ) )
426     {
427       // check whether the profile is already added
428       anExistingProfiles << aProfileName;
429     }
430     else if ( !HYDROData_Stream::HasIntersection( aHydAxis, aProfile, aPlane, aProfilePar ) )
431     {
432       // check whether the profile has intersection
433       aHasNoIntersectionProfiles << aProfileName;
434     }
435     else
436     {
437       // Insert profile in correct place
438       // if hidr axis is null => the params (myProfileParams) will be igrored. So ordering will be the same as in the aSelectedProfiles
439       insertProfileInToOrder( aProfileName, aProfilePar, myProfiles, myProfileParams );
440       aVerifiedProfiles << aProfileName;
441     }
442   }
443  
444   // Show message box with the ignored profiles
445   if ( !anInvalidProfiles.isEmpty() ||
446        !anExistingProfiles.isEmpty() ||
447        !aHasNoIntersectionProfiles.isEmpty() )
448   {
449     QString aMessage = tr( "IGNORED_PROFILES" );
450     if ( !anInvalidProfiles.isEmpty() )
451     {
452       aMessage.append( "\n\n" );
453       aMessage.append( tr("INVALID_PROFILES").arg( anInvalidProfiles.join( "\n" ) ) );
454     }
455     if ( !anExistingProfiles.isEmpty() )
456     {
457       aMessage.append( "\n\n" );
458       aMessage.append( tr("EXISTING_PROFILES").arg( anExistingProfiles.join( "\n" ) ) );
459     }
460     if ( !aHasNoIntersectionProfiles.isEmpty() )
461     {
462       aMessage.append( "\n\n" );
463       aMessage.append( tr("NOT_INTERSECTED_PROFILES").arg( aHasNoIntersectionProfiles.join( "\n" ) ) );
464     }
465
466     SUIT_MessageBox::warning( module()->getApp()->desktop(), tr( "WARNING" ), aMessage );
467   }
468
469   if ( aVerifiedProfiles.isEmpty() )
470     return;
471
472   // Update the panel
473   updatePanelData();
474
475   // Update preview
476   createPreview();
477 }
478
479 void HYDROGUI_StreamOp::onRemoveProfiles( const QStringList& theProfilesToRemove )
480 {
481   QStringList aToRemove = theProfilesToRemove;
482   
483   aToRemove.removeDuplicates();
484   if ( aToRemove.isEmpty() )
485     return;
486
487   bool isRemoved = false;
488
489   // Remove profiles
490   for ( int i = 0; i < aToRemove.length(); ++i )
491   {
492     const QString& aProfileName = aToRemove.value( i );
493
494     int aProfileId = myProfiles.indexOf( aProfileName );
495     if ( aProfileId < 0 )
496       continue;
497
498     myProfiles.removeAt( aProfileId );
499     myProfileParams.removeAt( aProfileId );
500     isRemoved = true;
501   }
502
503   if ( isRemoved )
504   {
505     // Update the panel
506     updatePanelData();
507
508     // Update preview
509     createPreview();
510   }
511 }
512
513 void HYDROGUI_StreamOp::onDDZValueChanged( double d )
514 {
515    createPreview();
516 }
517
518 void HYDROGUI_StreamOp::onSSValueChanged( double d )
519 {
520    createPreview();
521 }
522
523 void HYDROGUI_StreamOp::onAxisChanged( const QString& theNewAxis )
524 {
525   // Get axis object   
526   Handle(HYDROData_PolylineXY) aNewAxis = Handle(HYDROData_PolylineXY)::DownCast(
527     HYDROGUI_Tool::FindObjectByName( module(), theNewAxis, KIND_POLYLINEXY ) );
528
529   // Prepare data for intersection check
530   TopoDS_Face aPlane;
531   HYDROData_Stream::BuildRefFace( aPlane );
532   //{
533   //  SUIT_MessageBox::critical( module()->getApp()->desktop(), 
534   //                            tr( "BAD_SELECTED_POLYLINE_TLT" ),
535   //                            tr( "BAD_SELECTED_POLYLINE_MSG" ).arg( theNewAxis ) );
536   //  // To restore the old axis
537   //  updatePanelData();
538   //  return;
539   //}
540
541   QStringList   aNewProfiles;
542   QList<double> aNewProfileParams;
543   QStringList   aHasNoIntersectionProfiles;
544
545   // Get list of profiles which do not intersect the axis
546   for ( int i = 0; i < myProfiles.length(); ++i )
547   {
548     QString aProfileName = myProfiles.value( i );
549
550     Handle(HYDROData_Profile) aProfile = Handle(HYDROData_Profile)::DownCast(
551       HYDROGUI_Tool::FindObjectByName( module(), aProfileName, KIND_PROFILE ) );
552     if ( aProfile.IsNull() )
553       continue;
554       
555     Standard_Real aProfilePar = 0.0;
556     if ( HYDROData_Stream::HasIntersection( aNewAxis, aProfile, aPlane, aProfilePar ) )
557     {
558       // Insert profile in correct place
559       insertProfileInToOrder( aProfileName, aProfilePar, aNewProfiles, aNewProfileParams );
560     }
561     else
562     {
563       aHasNoIntersectionProfiles << aProfile->GetName();
564     }
565   }
566
567   // If there are profiles which don't intersect the new axis - show confirmation message box
568   bool isConfirmed = true;
569   if ( !aHasNoIntersectionProfiles.isEmpty() )
570   {
571     SUIT_MessageBox::StandardButtons aButtons = 
572       SUIT_MessageBox::Yes | SUIT_MessageBox::No;
573
574     QString aMsg = aHasNoIntersectionProfiles.join( "\n" );
575     isConfirmed = SUIT_MessageBox::question( module()->getApp()->desktop(),
576                                              tr( "CONFIRMATION" ),
577                                              tr( "CONFIRM_AXIS_CHANGE" ).arg( aMsg ),
578                                              aButtons, 
579                                              SUIT_MessageBox::Yes) == SUIT_MessageBox::Yes;
580   }
581
582   // Check if the user has confirmed axis change
583   if ( !isConfirmed )
584   {
585     // To restore the old axis
586     updatePanelData();
587   }
588   else
589   {
590     // Update data
591     myHydAxis = theNewAxis;
592     myProfiles = aNewProfiles;
593     myProfileParams = aNewProfileParams;
594
595     // Update the panel
596     updatePanelData();
597
598     // Update preview
599     createPreview();
600   }
601 }
602
603 void HYDROGUI_StreamOp::updatePanelData()
604 {
605   HYDROGUI_StreamDlg* aPanel = ::qobject_cast<HYDROGUI_StreamDlg*>( inputPanel() );
606   if ( !aPanel )
607     return;
608
609   aPanel->setAxisName( myHydAxis );
610   aPanel->setProfiles( myProfiles );
611 }