]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
Salome HOME
ff76c1beeccb6e004ff83fcc0be6935d2da7263e
[modules/smesh.git] / src / SMESHGUI / SMESHGUI_ClippingDlg.cxx
1 // SMESH SMESHGUI : GUI for SMESH component
2 //
3 // Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS 
5 // 
6 // This library is free software; you can redistribute it and/or 
7 // modify it under the terms of the GNU Lesser General Public 
8 // License as published by the Free Software Foundation; either 
9 // version 2.1 of the License. 
10 // 
11 // This library is distributed in the hope that it will be useful, 
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
14 // Lesser General Public License for more details. 
15 // 
16 // You should have received a copy of the GNU Lesser General Public 
17 // License along with this library; if not, write to the Free Software 
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
19 // 
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22 // File   : SMESHGUI_ClippingDlg.cxx
23 // Author : Nicolas REJNERI, Open CASCADE S.A.S.
24 //
25
26 // SMESH includes
27 #include "SMESHGUI_ClippingDlg.h"
28
29 #include "SMESHGUI.h"
30 #include "SMESHGUI_Utils.h"
31 #include "SMESHGUI_VTKUtils.h"
32 #include "SMESHGUI_SpinBox.h"
33
34 #include <SMESH_Actor.h>
35 #include <SMESH_ActorUtils.h>
36
37 // SALOME GUI includes
38 #include <SUIT_Desktop.h>
39 #include <SUIT_Session.h>
40 #include <SUIT_OverrideCursor.h>
41 #include <SUIT_MessageBox.h>
42 #include <SUIT_ResourceMgr.h>
43
44 #include <SALOME_ListIO.hxx>
45
46 #include <LightApp_Application.h>
47 #include <LightApp_SelectionMgr.h>
48
49 #include <SVTK_ViewWindow.h>
50
51 // Qt includes
52 #include <QLabel>
53 #include <QPushButton>
54 #include <QComboBox>
55 #include <QCheckBox>
56 #include <QVBoxLayout>
57 #include <QHBoxLayout>
58 #include <QGridLayout>
59 #include <QGroupBox>
60 #include <QKeyEvent>
61
62 // VTK includes
63 #include <vtkMath.h>
64 #include <vtkPlane.h>
65 #include <vtkDataSet.h>
66 #include <vtkDataSetMapper.h>
67 #include <vtkPlaneSource.h>
68 #include <vtkProperty.h>
69
70 #define SPACING 6
71 #define MARGIN  11
72
73 class OrientedPlane: public vtkPlane
74 {
75   SVTK_ViewWindow* myViewWindow;
76
77   vtkDataSetMapper* myMapper;
78
79 public:
80   static OrientedPlane *New()
81   {
82     return new OrientedPlane();
83   }
84   static OrientedPlane *New(SVTK_ViewWindow* theViewWindow)
85   {
86     return new OrientedPlane(theViewWindow);
87   }
88   vtkTypeMacro (OrientedPlane, vtkPlane);
89
90   SMESH::Orientation myOrientation;
91   float myDistance;
92   double myAngle[2];
93
94   vtkPlaneSource* myPlaneSource;
95   SALOME_Actor *myActor;
96
97   void SetOrientation (SMESH::Orientation theOrientation) { myOrientation = theOrientation; }
98   SMESH::Orientation GetOrientation() { return myOrientation; }
99
100   void SetDistance (float theDistance) { myDistance = theDistance; }
101   float GetDistance() { return myDistance; }
102
103   void ShallowCopy (OrientedPlane* theOrientedPlane)
104   {
105     SetNormal(theOrientedPlane->GetNormal());
106     SetOrigin(theOrientedPlane->GetOrigin());
107
108     myOrientation = theOrientedPlane->GetOrientation();
109     myDistance = theOrientedPlane->GetDistance();
110
111     myAngle[0] = theOrientedPlane->myAngle[0];
112     myAngle[1] = theOrientedPlane->myAngle[1];
113
114     myPlaneSource->SetNormal(theOrientedPlane->myPlaneSource->GetNormal());
115     myPlaneSource->SetOrigin(theOrientedPlane->myPlaneSource->GetOrigin());
116     myPlaneSource->SetPoint1(theOrientedPlane->myPlaneSource->GetPoint1());
117     myPlaneSource->SetPoint2(theOrientedPlane->myPlaneSource->GetPoint2());
118   }
119
120 protected:
121   OrientedPlane(SVTK_ViewWindow* theViewWindow):
122     myViewWindow(theViewWindow),
123     myOrientation(SMESH::XY),
124     myDistance(0.5)
125   {
126     Init();
127     myViewWindow->AddActor(myActor);
128   }
129
130   OrientedPlane():
131     myOrientation(SMESH::XY),
132     myViewWindow(NULL),
133     myDistance(0.5)
134   {
135     Init();
136   }
137
138   void Init()
139   {
140     myPlaneSource = vtkPlaneSource::New();
141
142     myAngle[0] = myAngle[1] = 0.0;
143
144     // Create and display actor
145     myMapper = vtkDataSetMapper::New();
146     myMapper->SetInput(myPlaneSource->GetOutput());
147
148     myActor = SALOME_Actor::New();
149     myActor->VisibilityOff();
150     myActor->PickableOff();
151     myActor->SetInfinitive(true);
152     myActor->SetMapper(myMapper);
153
154     vtkFloatingPointType anRGB[3];
155     vtkProperty* aProp = vtkProperty::New();
156     SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
157     aProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
158     aProp->SetOpacity(0.75);
159     myActor->SetProperty(aProp);
160     aProp->Delete();
161
162     vtkProperty* aBackProp = vtkProperty::New();
163     SMESH::GetColor( "SMESH", "backface_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 0, 255 ) );
164     aBackProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
165     aBackProp->SetOpacity(0.75);
166     myActor->SetBackfaceProperty(aBackProp);
167     aBackProp->Delete();
168   }
169
170   ~OrientedPlane(){
171     myViewWindow->RemoveActor(myActor);
172     myActor->Delete();
173     
174     myMapper->RemoveAllInputs();
175     myMapper->Delete();
176
177     // commented: porting to vtk 5.0
178     //    myPlaneSource->UnRegisterAllOutputs();
179     myPlaneSource->Delete();
180   };
181
182 private:
183   // Not implemented.
184   OrientedPlane (const OrientedPlane&);
185   void operator= (const OrientedPlane&);
186
187 };
188
189 struct TSetVisiblity {
190   TSetVisiblity(int theIsVisible): myIsVisible(theIsVisible){}
191   void operator()(SMESH::TVTKPlane& theOrientedPlane){
192     theOrientedPlane->myActor->SetVisibility(myIsVisible);
193   }
194   int myIsVisible;
195 };
196
197 //=================================================================================
198 // used in SMESHGUI::restoreVisualParameters() to avoid
199 // declaration of OrientedPlane outside of SMESHGUI_ClippingDlg.cxx
200 //=================================================================================
201 void SMESHGUI_ClippingDlg::AddPlane (SMESH_Actor*         theActor,
202                                      SVTK_ViewWindow*     theViewWindow,
203                                      SMESH::Orientation   theOrientation,
204                                      double               theDistance,
205                                      vtkFloatingPointType theAngle[2])
206 {
207   OrientedPlane* aPlane = OrientedPlane::New(theViewWindow);
208
209   aPlane->myAngle[0] = theAngle[0];
210   aPlane->myAngle[1] = theAngle[1];
211
212   aPlane->SetOrientation(theOrientation);
213   aPlane->SetDistance(theDistance);
214
215   vtkFloatingPointType aNormal[3];
216   vtkFloatingPointType aDir[2][3] = {{0, 0, 0}, {0, 0, 0}};
217   {
218     static double aCoeff = vtkMath::Pi()/180.0;
219
220     vtkFloatingPointType anU[2] = {cos(aCoeff * theAngle[0]), cos(aCoeff * theAngle[1])};
221     vtkFloatingPointType aV[2] = {sqrt(1.0 - anU[0]*anU[0]), sqrt(1.0 - anU[1]*anU[1])};
222     aV[0] = theAngle[0] > 0? aV[0]: -aV[0];
223     aV[1] = theAngle[1] > 0? aV[1]: -aV[1];
224
225     switch (theOrientation) {
226     case SMESH::XY:
227       aDir[0][1] = anU[0];
228       aDir[0][2] = aV[0];
229
230       aDir[1][0] = anU[1];
231       aDir[1][2] = aV[1];
232
233       break;
234     case SMESH::YZ:
235       aDir[0][2] = anU[0];
236       aDir[0][0] = aV[0];
237
238       aDir[1][1] = anU[1];
239       aDir[1][0] = aV[1];
240
241       break;
242     case SMESH::ZX:
243       aDir[0][0] = anU[0];
244       aDir[0][1] = aV[0];
245
246       aDir[1][2] = anU[1];
247       aDir[1][1] = aV[1];
248
249       break;
250     }
251
252     vtkMath::Cross(aDir[1],aDir[0],aNormal);
253     vtkMath::Normalize(aNormal);
254     vtkMath::Cross(aNormal,aDir[1],aDir[0]);
255   }
256
257   // ???
258   theActor->SetPlaneParam(aNormal, theDistance, aPlane);
259
260   vtkDataSet* aDataSet = theActor->GetInput();
261   vtkFloatingPointType *aPnt = aDataSet->GetCenter();
262
263   vtkFloatingPointType* anOrigin = aPlane->GetOrigin();
264   vtkFloatingPointType aDel = aDataSet->GetLength()/2.0;
265
266   vtkFloatingPointType aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
267                                        {aDir[1][0]*aDel, aDir[1][1]*aDel, aDir[1][2]*aDel}};
268   vtkFloatingPointType aParam, aPnt0[3], aPnt1[3], aPnt2[3];
269
270   vtkFloatingPointType aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
271                                     aPnt[1] - aDelta[0][1] - aDelta[1][1],
272                                     aPnt[2] - aDelta[0][2] - aDelta[1][2]};
273   vtkFloatingPointType aPnt02[3] = {aPnt01[0] + aNormal[0],
274                                     aPnt01[1] + aNormal[1],
275                                     aPnt01[2] + aNormal[2]};
276   vtkPlane::IntersectWithLine(aPnt01,aPnt02,aNormal,anOrigin,aParam,aPnt0);
277
278   vtkFloatingPointType aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
279                                     aPnt[1] - aDelta[0][1] + aDelta[1][1],
280                                     aPnt[2] - aDelta[0][2] + aDelta[1][2]};
281   vtkFloatingPointType aPnt12[3] = {aPnt11[0] + aNormal[0],
282                                     aPnt11[1] + aNormal[1],
283                                     aPnt11[2] + aNormal[2]};
284   vtkPlane::IntersectWithLine(aPnt11,aPnt12,aNormal,anOrigin,aParam,aPnt1);
285
286   vtkFloatingPointType aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
287                                     aPnt[1] + aDelta[0][1] - aDelta[1][1],
288                                     aPnt[2] + aDelta[0][2] - aDelta[1][2]};
289   vtkFloatingPointType aPnt22[3] = {aPnt21[0] + aNormal[0],
290                                     aPnt21[1] + aNormal[1],
291                                     aPnt21[2] + aNormal[2]};
292   vtkPlane::IntersectWithLine(aPnt21,aPnt22,aNormal,anOrigin,aParam,aPnt2);
293
294   vtkPlaneSource* aPlaneSource = aPlane->myPlaneSource;
295   aPlaneSource->SetNormal(aNormal[0],aNormal[1],aNormal[2]);
296   aPlaneSource->SetOrigin(aPnt0[0],aPnt0[1],aPnt0[2]);
297   aPlaneSource->SetPoint1(aPnt1[0],aPnt1[1],aPnt1[2]);
298   aPlaneSource->SetPoint2(aPnt2[0],aPnt2[1],aPnt2[2]);
299
300   theActor->AddClippingPlane(aPlane);
301   aPlane->Delete();
302 }
303
304 //=================================================================================
305 // used in SMESHGUI::restoreVisualParameters() to avoid
306 // declaration of OrientedPlane outside of SMESHGUI_ClippingDlg.cxx
307 //=================================================================================
308 void SMESHGUI_ClippingDlg::GetPlaneParam (SMESH_Actor*          theActor,
309                                           int                   thePlaneIndex,
310                                           SMESH::Orientation&   theOrientation,
311                                           double&               theDistance,
312                                           vtkFloatingPointType* theAngle)
313 {
314   if (vtkPlane* aPln = theActor->GetClippingPlane(thePlaneIndex)) {
315     if (OrientedPlane* aPlane = OrientedPlane::SafeDownCast(aPln)) {
316       theOrientation = aPlane->GetOrientation();
317       theDistance = aPlane->GetDistance();
318       theAngle[0] = aPlane->myAngle[0];
319       theAngle[1] = aPlane->myAngle[1];
320     }
321   }
322 }
323
324 //=================================================================================
325 // class    : SMESHGUI_ClippingDlg()
326 // purpose  :
327 //
328 //=================================================================================
329 SMESHGUI_ClippingDlg::SMESHGUI_ClippingDlg( SMESHGUI* theModule ):
330   QDialog( SMESH::GetDesktop(theModule) ),
331   mySelector(SMESH::GetViewWindow(theModule)->GetSelector()),
332   mySelectionMgr(SMESH::GetSelectionMgr(theModule)),
333   mySMESHGUI(theModule)
334 {
335   setModal( false );
336   setAttribute( Qt::WA_DeleteOnClose, true );
337   setWindowTitle(tr("SMESH_CLIPPING_TITLE"));
338   setSizeGripEnabled(true);
339
340   QVBoxLayout* SMESHGUI_ClippingDlgLayout = new QVBoxLayout(this);
341   SMESHGUI_ClippingDlgLayout->setSpacing(SPACING);
342   SMESHGUI_ClippingDlgLayout->setMargin(MARGIN);
343
344   // Controls for selecting, creating, deleting planes
345   QGroupBox* GroupPlanes = new QGroupBox(tr("Clipping planes"), this);
346   QHBoxLayout* GroupPlanesLayout = new QHBoxLayout(GroupPlanes);
347   GroupPlanesLayout->setSpacing(SPACING);
348   GroupPlanesLayout->setMargin(MARGIN);
349
350   ComboBoxPlanes = new QComboBox(GroupPlanes);
351
352   buttonNew = new QPushButton(tr("SMESH_BUT_NEW"), GroupPlanes);
353
354   buttonDelete = new QPushButton(tr("SMESH_BUT_DELETE"), GroupPlanes);
355
356   GroupPlanesLayout->addWidget(ComboBoxPlanes);
357   GroupPlanesLayout->addStretch();
358   GroupPlanesLayout->addWidget(buttonNew);
359   GroupPlanesLayout->addWidget(buttonDelete);
360
361   // Controls for defining plane parameters
362   QGroupBox* GroupParameters = new QGroupBox(tr("SMESH_PARAMETERS"), this);
363   QGridLayout* GroupParametersLayout = new QGridLayout(GroupParameters);
364   GroupParametersLayout->setSpacing(SPACING);
365   GroupParametersLayout->setMargin(MARGIN);
366
367   TextLabelOrientation = new QLabel(tr("SMESH_ORIENTATION"), GroupParameters);
368
369   ComboBoxOrientation = new QComboBox(GroupParameters);
370
371   TextLabelDistance = new QLabel(tr("SMESH_DISTANCE"), GroupParameters);
372
373   SpinBoxDistance = new SMESHGUI_SpinBox(GroupParameters);
374
375   TextLabelRot1 = new QLabel(tr("Rotation around X (Y to Z):"), GroupParameters);
376
377   SpinBoxRot1 = new SMESHGUI_SpinBox(GroupParameters);
378
379   TextLabelRot2 = new QLabel(tr("Rotation around Y (X to Z):"), GroupParameters);
380
381   SpinBoxRot2 = new SMESHGUI_SpinBox(GroupParameters);
382
383   PreviewCheckBox = new QCheckBox(tr("Show preview"), GroupParameters);
384   PreviewCheckBox->setChecked(true);
385
386   AutoApplyCheckBox = new QCheckBox(tr("Auto Apply"), GroupParameters);
387   AutoApplyCheckBox->setChecked(false);
388
389   GroupParametersLayout->addWidget(TextLabelOrientation, 0, 0);
390   GroupParametersLayout->addWidget(ComboBoxOrientation,  0, 1);
391   GroupParametersLayout->addWidget(TextLabelDistance,    1, 0);
392   GroupParametersLayout->addWidget(SpinBoxDistance,      1, 1);
393   GroupParametersLayout->addWidget(TextLabelRot1,        2, 0);
394   GroupParametersLayout->addWidget(SpinBoxRot1,          2, 1);
395   GroupParametersLayout->addWidget(TextLabelRot2,        3, 0);
396   GroupParametersLayout->addWidget(SpinBoxRot2,          3, 1);
397   GroupParametersLayout->addWidget(PreviewCheckBox,      4, 0);
398   GroupParametersLayout->addWidget(AutoApplyCheckBox,    4, 1);
399
400   // Controls for "Ok", "Apply" and "Close" button
401   QGroupBox* GroupButtons = new QGroupBox(this);
402   QHBoxLayout* GroupButtonsLayout = new QHBoxLayout(GroupButtons);
403   GroupButtonsLayout->setSpacing(SPACING);
404   GroupButtonsLayout->setMargin(MARGIN);
405   
406   buttonOk = new QPushButton(tr("SMESH_BUT_APPLY_AND_CLOSE"), GroupButtons);
407   buttonOk->setAutoDefault(true);
408   buttonOk->setDefault(true);
409   buttonApply = new QPushButton(tr("SMESH_BUT_APPLY"), GroupButtons);
410   buttonApply->setAutoDefault(true);
411   buttonCancel = new QPushButton(tr("SMESH_BUT_CLOSE"), GroupButtons);
412   buttonCancel->setAutoDefault(true);
413   buttonHelp = new QPushButton(tr("SMESH_BUT_HELP"), GroupButtons);
414   buttonHelp->setAutoDefault(true);
415   GroupButtonsLayout->addWidget(buttonOk);
416   GroupButtonsLayout->addSpacing(10);
417   GroupButtonsLayout->addWidget(buttonApply);
418   GroupButtonsLayout->addSpacing(10);
419   GroupButtonsLayout->addStretch();
420   GroupButtonsLayout->addWidget(buttonCancel);
421   GroupButtonsLayout->addWidget(buttonHelp);
422
423   SMESHGUI_ClippingDlgLayout->addWidget(GroupPlanes);
424   SMESHGUI_ClippingDlgLayout->addWidget(GroupParameters);
425   SMESHGUI_ClippingDlgLayout->addWidget(GroupButtons);
426
427   // Initial state
428   SpinBoxDistance->RangeStepAndValidator(0.0, 1.0, 0.01, 3);
429   SpinBoxRot1->RangeStepAndValidator(-180.0, 180.0, 1, 3);
430   SpinBoxRot2->RangeStepAndValidator(-180.0, 180.0, 1, 3);
431
432   ComboBoxOrientation->addItem(tr("|| X-Y"));
433   ComboBoxOrientation->addItem(tr("|| Y-Z"));
434   ComboBoxOrientation->addItem(tr("|| Z-X"));
435
436   SpinBoxDistance->SetValue(0.5);
437
438   myActor = 0;
439   myIsSelectPlane = false;
440   onSelectionChanged();
441
442   myHelpFileName = "clipping_page.html";
443
444   // signals and slots connections :
445   connect(ComboBoxPlanes, SIGNAL(activated(int)), this, SLOT(onSelectPlane(int)));
446   connect(buttonNew, SIGNAL(clicked()), this, SLOT(ClickOnNew()));
447   connect(buttonDelete, SIGNAL(clicked()), this, SLOT(ClickOnDelete()));
448   connect(ComboBoxOrientation, SIGNAL(activated(int)), this, SLOT(onSelectOrientation(int)));
449   connect(SpinBoxDistance, SIGNAL(valueChanged(double)), this, SLOT(SetCurrentPlaneParam()));
450   connect(SpinBoxRot1, SIGNAL(valueChanged(double)), this, SLOT(SetCurrentPlaneParam()));
451   connect(SpinBoxRot2, SIGNAL(valueChanged(double)), this, SLOT(SetCurrentPlaneParam()));
452   connect(PreviewCheckBox, SIGNAL(toggled(bool)), this, SLOT(OnPreviewToggle(bool)));
453   connect(AutoApplyCheckBox, SIGNAL(toggled(bool)), this, SLOT(ClickOnApply()));
454   connect(buttonOk, SIGNAL(clicked()), this, SLOT(ClickOnOk()));
455   connect(buttonCancel, SIGNAL(clicked()), this, SLOT(ClickOnCancel()));
456   connect(buttonApply, SIGNAL(clicked()), this, SLOT(ClickOnApply()));
457   connect(buttonHelp, SIGNAL(clicked()), this, SLOT(ClickOnHelp()));
458   connect(mySMESHGUI, SIGNAL (SignalCloseAllDialogs()), this, SLOT(ClickOnCancel()));
459   connect(mySelectionMgr,  SIGNAL(currentSelectionChanged()), this, SLOT(onSelectionChanged()));
460   /* to close dialog if study frame change */
461   connect(mySMESHGUI, SIGNAL (SignalStudyFrameChanged()), this, SLOT(ClickOnCancel()));
462
463   this->show();
464 }
465
466 //=================================================================================
467 // function : ~SMESHGUI_ClippingDlg()
468 // purpose  :
469 //=================================================================================
470 SMESHGUI_ClippingDlg::~SMESHGUI_ClippingDlg()
471 {
472   // no need to delete child widgets, Qt does it all for us
473   std::for_each(myPlanes.begin(),myPlanes.end(),TSetVisiblity(false));
474   
475   if (SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow(mySMESHGUI))
476     SMESH::RenderViewWindow(aViewWindow);
477 }
478
479 double SMESHGUI_ClippingDlg::getDistance() const
480 {
481   return SpinBoxDistance->GetValue();
482 }
483
484 void SMESHGUI_ClippingDlg::setDistance( const double theDistance )
485 {
486   SpinBoxDistance->SetValue( theDistance );
487 }
488
489 double SMESHGUI_ClippingDlg::getRotation1() const
490 {
491   return SpinBoxRot1->GetValue();
492 }
493
494 double SMESHGUI_ClippingDlg::getRotation2() const
495 {
496   return SpinBoxRot2->GetValue();
497 }
498
499 //=======================================================================
500 // function : ClickOnApply()
501 // purpose  :
502 //=======================================================================
503 void SMESHGUI_ClippingDlg::ClickOnApply()
504 {
505   if (!myActor)
506     return;
507
508   if (SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow(mySMESHGUI)) {
509     SUIT_OverrideCursor wc;
510     
511     QWidget *aCurrWid = this->focusWidget();
512     aCurrWid->clearFocus();
513     aCurrWid->setFocus();
514
515     myActor->RemoveAllClippingPlanes();
516
517     SMESH::TPlanes::iterator anIter = myPlanes.begin();
518     for ( ; anIter != myPlanes.end(); anIter++) {
519       OrientedPlane* anOrientedPlane = OrientedPlane::New(aViewWindow);
520       anOrientedPlane->ShallowCopy(anIter->GetPointer());
521       myActor->AddClippingPlane(anOrientedPlane);
522       anOrientedPlane->Delete();
523     }
524
525     SMESH::RenderViewWindow(aViewWindow);
526   }
527 }
528
529 //=======================================================================
530 // function : ClickOnOk()
531 // purpose  :
532 //=======================================================================
533 void SMESHGUI_ClippingDlg::ClickOnOk()
534 {
535   ClickOnApply();
536   ClickOnCancel();
537 }
538
539 //=======================================================================
540 // function : ClickOnCancel()
541 // purpose  :
542 //=======================================================================
543 void SMESHGUI_ClippingDlg::ClickOnCancel()
544 {
545   close();
546 }
547
548 //=================================================================================
549 // function : ClickOnHelp()
550 // purpose  :
551 //=================================================================================
552 void SMESHGUI_ClippingDlg::ClickOnHelp()
553 {
554   LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication());
555   if (app) 
556     app->onHelpContextModule(mySMESHGUI ? app->moduleName(mySMESHGUI->moduleName()) : QString(""), myHelpFileName);
557   else {
558                 QString platform;
559 #ifdef WIN32
560                 platform = "winapplication";
561 #else
562                 platform = "application";
563 #endif
564     SUIT_MessageBox::warning(this, tr("WRN_WARNING"),
565                              tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE").
566                              arg(app->resourceMgr()->stringValue("ExternalBrowser", 
567                                                                  platform)).
568                              arg(myHelpFileName));
569   }
570 }
571
572 //=================================================================================
573 // function : onSelectionChanged()
574 // purpose  : Called when selection is changed
575 //=================================================================================
576 void SMESHGUI_ClippingDlg::onSelectionChanged()
577 {
578   if (SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow(mySMESHGUI)) {
579     const SALOME_ListIO& aList = mySelector->StoredIObjects();
580     if (aList.Extent() > 0) {
581       Handle(SALOME_InteractiveObject) IOS = aList.First();
582       myActor = SMESH::FindActorByEntry(IOS->getEntry());
583       if (myActor) {
584         std::for_each(myPlanes.begin(),myPlanes.end(),TSetVisiblity(false));
585         myPlanes.clear();
586
587         vtkIdType anId = 0, anEnd = myActor->GetNumberOfClippingPlanes();
588         for ( ; anId < anEnd; anId++) {
589           if (vtkImplicitFunction* aFunction = myActor->GetClippingPlane(anId)) {
590             if(OrientedPlane* aPlane = OrientedPlane::SafeDownCast(aFunction)){
591               OrientedPlane* anOrientedPlane = OrientedPlane::New(aViewWindow);
592               SMESH::TVTKPlane aTVTKPlane(anOrientedPlane);
593               anOrientedPlane->Delete();
594               aTVTKPlane->ShallowCopy(aPlane);
595               myPlanes.push_back(aTVTKPlane);
596             }
597           }
598         }
599
600         std::for_each(myPlanes.begin(),myPlanes.end(),
601                       TSetVisiblity(PreviewCheckBox->isChecked()));
602       }
603     }
604     SMESH::RenderViewWindow(aViewWindow);
605   }
606   Sinchronize();
607 }
608
609 //=======================================================================
610 // function : onSelectPlane()
611 // purpose  :
612 //=======================================================================
613 void SMESHGUI_ClippingDlg::onSelectPlane (int theIndex)
614 {
615   if (!myActor || myPlanes.empty())
616     return;
617
618   OrientedPlane* aPlane = myPlanes[theIndex].GetPointer();
619
620   // Orientation
621   SMESH::Orientation anOrientation = aPlane->GetOrientation();
622
623   // Rotations
624   double aRot[2] = {aPlane->myAngle[0], aPlane->myAngle[1]};
625
626   // Set plane parameters in the dialog
627   myIsSelectPlane = true;
628   setDistance(aPlane->GetDistance());
629   setRotation(aRot[0], aRot[1]);
630   switch (anOrientation) {
631   case SMESH::XY:
632     ComboBoxOrientation->setCurrentIndex(0);
633     onSelectOrientation(0);
634     break;
635   case SMESH::YZ:
636     ComboBoxOrientation->setCurrentIndex(1);
637     onSelectOrientation(1);
638     break;
639   case SMESH::ZX:
640     ComboBoxOrientation->setCurrentIndex(2);
641     onSelectOrientation(2);
642     break;
643   }
644   myIsSelectPlane = false;
645 }
646
647 //=======================================================================
648 // function : ClickOnNew()
649 // purpose  :
650 //=======================================================================
651 void SMESHGUI_ClippingDlg::ClickOnNew()
652 {
653   if (!myActor)
654     return;
655
656   if(SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow(mySMESHGUI)){
657     OrientedPlane* aPlane = OrientedPlane::New(aViewWindow);
658     SMESH::TVTKPlane aTVTKPlane(aPlane);
659     myPlanes.push_back(aTVTKPlane);
660
661     if (PreviewCheckBox->isChecked())
662       aTVTKPlane->myActor->VisibilityOn();
663     
664     Sinchronize();
665     SetCurrentPlaneParam();
666   }
667 }
668
669 //=======================================================================
670 // function : ClickOnDelete()
671 // purpose  :
672 //=======================================================================
673 void SMESHGUI_ClippingDlg::ClickOnDelete()
674 {
675   if (!myActor || myPlanes.empty())
676     return;
677
678   int aPlaneIndex = ComboBoxPlanes->currentIndex();
679
680   SMESH::TPlanes::iterator anIter = myPlanes.begin() + aPlaneIndex;
681   anIter->GetPointer()->myActor->SetVisibility(false);
682   myPlanes.erase(anIter);
683
684   if(AutoApplyCheckBox->isChecked())
685     ClickOnApply();
686
687   Sinchronize();
688   SMESH::RenderViewWindow(SMESH::GetCurrentVtkView());
689 }
690
691 //=======================================================================
692 // function : onSelectOrientation()
693 // purpose  :
694 //=======================================================================
695 void SMESHGUI_ClippingDlg::onSelectOrientation (int theItem)
696 {
697   if (myPlanes.empty())
698     return;
699
700   if      (theItem == 0) {
701     TextLabelRot1->setText(tr("Rotation around X (Y to Z):"));
702     TextLabelRot2->setText(tr("Rotation around Y (X to Z):"));
703   }
704   else if (theItem == 1) {
705     TextLabelRot1->setText(tr("Rotation around Y (Z to X):"));
706     TextLabelRot2->setText(tr("Rotation around Z (Y to X):"));
707   }
708   else if (theItem == 2) {
709     TextLabelRot1->setText(tr("Rotation around Z (X to Y):"));
710     TextLabelRot2->setText(tr("Rotation around X (Z to Y):"));
711   }
712
713   if((QComboBox*)sender() == ComboBoxOrientation)
714     SetCurrentPlaneParam();
715 }
716
717 //=======================================================================
718 // function : Sinchronize()
719 // purpose  :
720 //=======================================================================
721 void SMESHGUI_ClippingDlg::Sinchronize()
722 {
723   int aNbPlanes = myPlanes.size();
724   ComboBoxPlanes->clear();
725
726   QString aName;
727   for(int i = 1; i<=aNbPlanes; i++) {
728     aName = QString(tr("Plane# %1")).arg(i);
729     ComboBoxPlanes->addItem(aName);
730   }
731
732   int aPos = ComboBoxPlanes->count() - 1;
733   ComboBoxPlanes->setCurrentIndex(aPos);
734
735   bool anIsControlsEnable = (aPos >= 0);
736   if (anIsControlsEnable) {
737     onSelectPlane(aPos);
738   } else {
739     ComboBoxPlanes->addItem(tr("No planes"));
740     SpinBoxRot1->SetValue(0.0);
741     SpinBoxRot2->SetValue(0.0);
742     SpinBoxDistance->SetValue(0.5);
743   }
744
745   buttonDelete->setEnabled(anIsControlsEnable);
746   buttonApply->setEnabled(anIsControlsEnable);
747   PreviewCheckBox->setEnabled(anIsControlsEnable);
748   AutoApplyCheckBox->setEnabled(anIsControlsEnable);
749   ComboBoxOrientation->setEnabled(anIsControlsEnable);
750   SpinBoxDistance->setEnabled(anIsControlsEnable);
751   SpinBoxRot1->setEnabled(anIsControlsEnable);
752   SpinBoxRot2->setEnabled(anIsControlsEnable);
753 }
754
755 //=======================================================================
756 // function : setRotation()
757 // purpose  :
758 //=======================================================================
759 void SMESHGUI_ClippingDlg::setRotation (const double theRot1, const double theRot2)
760 {
761   SpinBoxRot1->SetValue(theRot1);
762   SpinBoxRot2->SetValue(theRot2);
763 }
764
765 //=======================================================================
766 // function : SetCurrentPlaneParam()
767 // purpose  :
768 //=======================================================================
769 void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
770 {
771   if (myPlanes.empty() || myIsSelectPlane)
772     return;
773
774   int aCurPlaneIndex = ComboBoxPlanes->currentIndex();
775
776   OrientedPlane* aPlane = myPlanes[aCurPlaneIndex].GetPointer();
777
778   vtkFloatingPointType aNormal[3];
779   SMESH::Orientation anOrientation;
780   vtkFloatingPointType aDir[3][3] = {{0, 0, 0}, {0, 0, 0}};
781   {
782     static double aCoeff = vtkMath::Pi()/180.0;
783
784     vtkFloatingPointType aRot[2] = {getRotation1(), getRotation2()};
785     aPlane->myAngle[0] = aRot[0];
786     aPlane->myAngle[1] = aRot[1];
787
788     vtkFloatingPointType anU[2] = {cos(aCoeff*aRot[0]), cos(aCoeff*aRot[1])};
789     vtkFloatingPointType aV[2] = {sqrt(1.0-anU[0]*anU[0]), sqrt(1.0-anU[1]*anU[1])};
790     aV[0] = aRot[0] > 0? aV[0]: -aV[0];
791     aV[1] = aRot[1] > 0? aV[1]: -aV[1];
792
793     switch (ComboBoxOrientation->currentIndex()) {
794     case 0:
795       anOrientation = SMESH::XY;
796
797       aDir[0][1] = anU[0];
798       aDir[0][2] = aV[0];
799
800       aDir[1][0] = anU[1];
801       aDir[1][2] = aV[1];
802
803       break;
804     case 1:
805       anOrientation = SMESH::YZ;
806
807       aDir[0][2] = anU[0];
808       aDir[0][0] = aV[0];
809
810       aDir[1][1] = anU[1];
811       aDir[1][0] = aV[1];
812
813       break;
814     case 2:
815       anOrientation = SMESH::ZX;
816
817       aDir[0][0] = anU[0];
818       aDir[0][1] = aV[0];
819
820       aDir[1][2] = anU[1];
821       aDir[1][1] = aV[1];
822
823       break;
824     }
825
826     vtkMath::Cross(aDir[1],aDir[0],aNormal);
827     vtkMath::Normalize(aNormal);
828     vtkMath::Cross(aNormal,aDir[1],aDir[0]);
829   }
830
831   aPlane->SetOrientation(anOrientation);
832   aPlane->SetDistance(getDistance());
833
834   myActor->SetPlaneParam(aNormal, getDistance(), aPlane);
835
836   vtkDataSet* aDataSet = myActor->GetInput();
837   vtkFloatingPointType *aPnt = aDataSet->GetCenter();
838
839   vtkFloatingPointType* anOrigin = aPlane->GetOrigin();
840   vtkFloatingPointType aDel = aDataSet->GetLength()/2.0;
841
842   vtkFloatingPointType aDelta[2][3] = {{aDir[0][0]*aDel, aDir[0][1]*aDel, aDir[0][2]*aDel},
843                                        {aDir[1][0]*aDel, aDir[1][1]*aDel, aDir[1][2]*aDel}};
844   vtkFloatingPointType aParam, aPnt0[3], aPnt1[3], aPnt2[3];
845
846   vtkFloatingPointType aPnt01[3] = {aPnt[0] - aDelta[0][0] - aDelta[1][0],
847                                     aPnt[1] - aDelta[0][1] - aDelta[1][1],
848                                     aPnt[2] - aDelta[0][2] - aDelta[1][2]};
849   vtkFloatingPointType aPnt02[3] = {aPnt01[0] + aNormal[0],
850                                     aPnt01[1] + aNormal[1],
851                                     aPnt01[2] + aNormal[2]};
852   vtkPlane::IntersectWithLine(aPnt01,aPnt02,aNormal,anOrigin,aParam,aPnt0);
853
854   vtkFloatingPointType aPnt11[3] = {aPnt[0] - aDelta[0][0] + aDelta[1][0],
855                                     aPnt[1] - aDelta[0][1] + aDelta[1][1],
856                                     aPnt[2] - aDelta[0][2] + aDelta[1][2]};
857   vtkFloatingPointType aPnt12[3] = {aPnt11[0] + aNormal[0],
858                                     aPnt11[1] + aNormal[1],
859                                     aPnt11[2] + aNormal[2]};
860   vtkPlane::IntersectWithLine(aPnt11,aPnt12,aNormal,anOrigin,aParam,aPnt1);
861
862   vtkFloatingPointType aPnt21[3] = {aPnt[0] + aDelta[0][0] - aDelta[1][0],
863                                     aPnt[1] + aDelta[0][1] - aDelta[1][1],
864                                     aPnt[2] + aDelta[0][2] - aDelta[1][2]};
865   vtkFloatingPointType aPnt22[3] = {aPnt21[0] + aNormal[0],
866                                     aPnt21[1] + aNormal[1],
867                                     aPnt21[2] + aNormal[2]};
868   vtkPlane::IntersectWithLine(aPnt21,aPnt22,aNormal,anOrigin,aParam,aPnt2);
869
870   vtkPlaneSource* aPlaneSource = aPlane->myPlaneSource;
871   aPlaneSource->SetNormal(aNormal[0],aNormal[1],aNormal[2]);
872   aPlaneSource->SetOrigin(aPnt0[0],aPnt0[1],aPnt0[2]);
873   aPlaneSource->SetPoint1(aPnt1[0],aPnt1[1],aPnt1[2]);
874   aPlaneSource->SetPoint2(aPnt2[0],aPnt2[1],aPnt2[2]);
875
876   if(AutoApplyCheckBox->isChecked())
877     ClickOnApply();
878
879   SMESH::RenderViewWindow(SMESH::GetCurrentVtkView());
880 }
881
882 //=======================================================================
883 // function : OnPreviewToggle()
884 // purpose  :
885 //=======================================================================
886 void SMESHGUI_ClippingDlg::OnPreviewToggle (bool theIsToggled)
887 {
888   std::for_each(myPlanes.begin(),myPlanes.end(),TSetVisiblity(theIsToggled));
889   SMESH::RenderViewWindow(SMESH::GetCurrentVtkView());
890 }
891
892 //=================================================================================
893 // function : keyPressEvent()
894 // purpose  :
895 //=================================================================================
896 void SMESHGUI_ClippingDlg::keyPressEvent( QKeyEvent* e )
897 {
898   QDialog::keyPressEvent( e );
899   if ( e->isAccepted() )
900     return;
901
902   if ( e->key() == Qt::Key_F1 ) {
903     e->accept();
904     ClickOnHelp();
905   }
906 }