src/libengrid/egvtkinteractorstyle.cpp

   1 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   2 // +                                                                      +
   3 // + This file is part of enGrid.                                         +
   4 // +                                                                      +
   5 // + Copyright 2008-2014 enGits GmbH                                      +
   6 // +                                                                      +
   7 // + enGrid is free software: you can redistribute it and/or modify       +
   8 // + it under the terms of the GNU General Public License as published by +
   9 // + the Free Software Foundation, either version 3 of the License, or    +
  10 // + (at your option) any later version.                                  +
  11 // +                                                                      +
  12 // + enGrid is distributed in the hope that it will be useful,            +
  13 // + but WITHOUT ANY WARRANTY; without even the implied warranty of       +
  14 // + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        +
  15 // + GNU General Public License for more details.                         +
  16 // +                                                                      +
  17 // + You should have received a copy of the GNU General Public License    +
  18 // + along with enGrid. If not, see <http://www.gnu.org/licenses/>.       +
  19 // +                                                                      +
  20 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  21 #include "egvtkinteractorstyle.h"
  22
  23 #include "deletepickedpoint.h"
  24 #include "egvtkobject.h"
  25 #include "operation.h"
  26
  27 #include "vtkInteractorStyleUser.h"
  28 #include "vtkMath.h"
  29 #include "vtkCellPicker.h"
  30 #include "vtkRenderWindowInteractor.h"
  31 #include "vtkObjectFactory.h"
  32 #include "vtkCommand.h"
  33
  34 vtkStandardNewMacro(egvtkInteractorStyle);
  35
  36 //----------------------------------------------------------------------------
  37 egvtkInteractorStyle::egvtkInteractorStyle()
  38 {
  39   this->MotionFactor   = 10.0;
  40 }
  41
  42 //----------------------------------------------------------------------------
  43 egvtkInteractorStyle::~egvtkInteractorStyle()
  44 {
  45 }
  46
  47 //----------------------------------------------------------------------------
  48 void egvtkInteractorStyle::OnMouseMove()
  49 {
  50   int x = this->Interactor->GetEventPosition()[0];
  51   int y = this->Interactor->GetEventPosition()[1];
  52
  53   switch (this->State)
  54   {
  55   case VTKIS_ROTATE:
  56     this->FindPokedRenderer(x, y);
  57     this->Rotate();
  58     this->InvokeEvent(vtkCommand::InteractionEvent, NULL);
  59     break;
  60
  61   case VTKIS_PAN:
  62     this->FindPokedRenderer(x, y);
  63     this->Pan();
  64     this->InvokeEvent(vtkCommand::InteractionEvent, NULL);
  65     break;
  66
  67   case VTKIS_DOLLY:
  68     this->FindPokedRenderer(x, y);
  69     this->Dolly();
  70     this->InvokeEvent(vtkCommand::InteractionEvent, NULL);
  71     break;
  72
  73   case VTKIS_SPIN:
  74     this->FindPokedRenderer(x, y);
  75     this->Spin();
  76     this->InvokeEvent(vtkCommand::InteractionEvent, NULL);
  77     break;
  78   }
  79 }
  80
  81 //----------------------------------------------------------------------------
  82 void egvtkInteractorStyle::OnLeftButtonDown()
  83 {
  84   int X = this->Interactor->GetEventPosition()[0];
  85   int Y = this->Interactor->GetEventPosition()[1];
  86   cout<<"You clicked at ("<<X<<","<<Y<<")"<<endl;
  87
  88   this->FindPokedRenderer(this->Interactor->GetEventPosition()[0],
  89                           this->Interactor->GetEventPosition()[1]);
  90   if (this->CurrentRenderer == NULL)
  91   {
  92     return;
  93   }
  94
  95   this->GrabFocus(this->EventCallbackCommand);
  96   if (this->Interactor->GetShiftKey())
  97   {
  98     if (this->Interactor->GetControlKey())
  99     {
 100       this->StartDolly();
 101     }
 102     else
 103     {
 104       this->StartPan();
 105     }
 106   }
 107   else
 108   {
 109     if (this->Interactor->GetControlKey())
 110     {
 111       this->StartSpin();
 112     }
 113     else
 114     {
 115       this->StartRotate();
 116     }
 117   }
 118 }
 119
 120 //----------------------------------------------------------------------------
 121 void egvtkInteractorStyle::OnLeftButtonUp()
 122 {
 123   switch (this->State)
 124   {
 125   case VTKIS_DOLLY:
 126     this->EndDolly();
 127     break;
 128
 129   case VTKIS_PAN:
 130     this->EndPan();
 131     break;
 132
 133   case VTKIS_SPIN:
 134     this->EndSpin();
 135     break;
 136
 137   case VTKIS_ROTATE:
 138     this->EndRotate();
 139     break;
 140   }
 141
 142   if ( this->Interactor )
 143   {
 144     this->ReleaseFocus();
 145   }
 146 }
 147
 148 //----------------------------------------------------------------------------
 149 void egvtkInteractorStyle::OnMiddleButtonDown()
 150 {
 151   this->FindPokedRenderer(this->Interactor->GetEventPosition()[0],
 152                           this->Interactor->GetEventPosition()[1]);
 153   if (this->CurrentRenderer == NULL)
 154   {
 155     return;
 156   }
 157
 158   this->GrabFocus(this->EventCallbackCommand);
 159   this->StartPan();
 160 }
 161
 162 //----------------------------------------------------------------------------
 163 void egvtkInteractorStyle::OnMiddleButtonUp()
 164 {
 165   switch (this->State)
 166   {
 167   case VTKIS_PAN:
 168     this->EndPan();
 169     if ( this->Interactor )
 170     {
 171       this->ReleaseFocus();
 172     }
 173     break;
 174   }
 175 }
 176
 177 //----------------------------------------------------------------------------
 178 void egvtkInteractorStyle::OnRightButtonDown()
 179 {
 180   int X = this->Interactor->GetEventPosition()[0];
 181   int Y = this->Interactor->GetEventPosition()[1];
 182   //cout<<"You clicked at ("<<X<<","<<Y<<")"<<endl;
 183
 184   this->FindPokedRenderer(this->Interactor->GetEventPosition()[0],
 185                           this->Interactor->GetEventPosition()[1]);
 186   if (this->CurrentRenderer == NULL)
 187   {
 188     return;
 189   }
 190
 191   this->GrabFocus(this->EventCallbackCommand);
 192   this->StartDolly();
 193 }
 194
 195 //----------------------------------------------------------------------------
 196 void egvtkInteractorStyle::OnRightButtonUp()
 197 {
 198   switch (this->State)
 199   {
 200   case VTKIS_DOLLY:
 201     this->EndDolly();
 202
 203     if ( this->Interactor )
 204     {
 205       this->ReleaseFocus();
 206     }
 207     break;
 208   }
 209 }
 210
 211 //----------------------------------------------------------------------------
 212 void egvtkInteractorStyle::OnMouseWheelForward()
 213 {
 214   this->FindPokedRenderer(this->Interactor->GetEventPosition()[0],
 215                           this->Interactor->GetEventPosition()[1]);
 216   if (this->CurrentRenderer == NULL)
 217   {
 218     return;
 219   }
 220
 221   this->GrabFocus(this->EventCallbackCommand);
 222   this->StartDolly();
 223   double factor = this->MotionFactor * 0.2 * this->MouseWheelMotionFactor;
 224   this->Dolly(pow(1.1, factor));
 225   this->EndDolly();
 226   this->ReleaseFocus();
 227 }
 228
 229 //----------------------------------------------------------------------------
 230 void egvtkInteractorStyle::OnMouseWheelBackward()
 231 {
 232   this->FindPokedRenderer(this->Interactor->GetEventPosition()[0],
 233                           this->Interactor->GetEventPosition()[1]);
 234   if (this->CurrentRenderer == NULL)
 235   {
 236     return;
 237   }
 238
 239   this->GrabFocus(this->EventCallbackCommand);
 240   this->StartDolly();
 241   double factor = this->MotionFactor * -0.2 * this->MouseWheelMotionFactor;
 242   this->Dolly(pow(1.1, factor));
 243   this->EndDolly();
 244   this->ReleaseFocus();
 245 }
 246
 247 //----------------------------------------------------------------------------
 248 void egvtkInteractorStyle::Rotate()
 249 {
 250   if (this->CurrentRenderer == NULL)
 251   {
 252     return;
 253   }
 254
 255   vtkRenderWindowInteractor *rwi = this->Interactor;
 256
 257   int dx = rwi->GetEventPosition()[0] - rwi->GetLastEventPosition()[0];
 258   int dy = rwi->GetEventPosition()[1] - rwi->GetLastEventPosition()[1];
 259
 260   int *size = this->CurrentRenderer->GetRenderWindow()->GetSize();
 261
 262   double delta_elevation = -20.0 / size[1];
 263   double delta_azimuth = -20.0 / size[0];
 264
 265   double rxf = dx * delta_azimuth * this->MotionFactor;
 266   double ryf = dy * delta_elevation * this->MotionFactor;
 267
 268   vtkCamera *camera = this->CurrentRenderer->GetActiveCamera();
 269   camera->Azimuth(rxf);
 270   camera->Elevation(ryf);
 271   camera->OrthogonalizeViewUp();
 272
 273   if (this->AutoAdjustCameraClippingRange)
 274   {
 275     this->CurrentRenderer->ResetCameraClippingRange();
 276   }
 277
 278   if (rwi->GetLightFollowCamera())
 279   {
 280     this->CurrentRenderer->UpdateLightsGeometryToFollowCamera();
 281   }
 282
 283   rwi->Render();
 284 }
 285
 286 //----------------------------------------------------------------------------
 287 void egvtkInteractorStyle::Spin()
 288 {
 289   if ( this->CurrentRenderer == NULL )
 290   {
 291     return;
 292   }
 293
 294   vtkRenderWindowInteractor *rwi = this->Interactor;
 295
 296   double *center = this->CurrentRenderer->GetCenter();
 297
 298   double newAngle = vtkMath::DegreesFromRadians( atan2( rwi->GetEventPosition()[1] - center[1], rwi->GetEventPosition()[0] - center[0] ) );
 299
 300   double oldAngle = vtkMath::DegreesFromRadians( atan2( rwi->GetLastEventPosition()[1] - center[1], rwi->GetLastEventPosition()[0] - center[0] ) );
 301
 302   vtkCamera *camera = this->CurrentRenderer->GetActiveCamera();
 303   camera->Roll( newAngle - oldAngle );
 304   camera->OrthogonalizeViewUp();
 305
 306   rwi->Render();
 307 }
 308
 309 //----------------------------------------------------------------------------
 310 void egvtkInteractorStyle::Pan()
 311 {
 312   if (this->CurrentRenderer == NULL)
 313   {
 314     return;
 315   }
 316
 317   vtkRenderWindowInteractor *rwi = this->Interactor;
 318
 319   double viewFocus[4], focalDepth, viewPoint[3];
 320   double newPickPoint[4], oldPickPoint[4], motionVector[3];
 321
 322   // Calculate the focal depth since we'll be using it a lot
 323
 324   vtkCamera *camera = this->CurrentRenderer->GetActiveCamera();
 325   camera->GetFocalPoint(viewFocus);
 326   this->ComputeWorldToDisplay(viewFocus[0], viewFocus[1], viewFocus[2],
 327                               viewFocus);
 328   focalDepth = viewFocus[2];
 329
 330   this->ComputeDisplayToWorld(rwi->GetEventPosition()[0],
 331                               rwi->GetEventPosition()[1],
 332                               focalDepth,
 333                               newPickPoint);
 334
 335   // Has to recalc old mouse point since the viewport has moved,
 336   // so can't move it outside the loop
 337
 338   this->ComputeDisplayToWorld(rwi->GetLastEventPosition()[0],
 339                               rwi->GetLastEventPosition()[1],
 340                               focalDepth,
 341                               oldPickPoint);
 342
 343   // Camera motion is reversed
 344
 345   motionVector[0] = oldPickPoint[0] - newPickPoint[0];
 346   motionVector[1] = oldPickPoint[1] - newPickPoint[1];
 347   motionVector[2] = oldPickPoint[2] - newPickPoint[2];
 348
 349   camera->GetFocalPoint(viewFocus);
 350   camera->GetPosition(viewPoint);
 351   camera->SetFocalPoint(motionVector[0] + viewFocus[0],
 352                         motionVector[1] + viewFocus[1],
 353                         motionVector[2] + viewFocus[2]);
 354
 355   camera->SetPosition(motionVector[0] + viewPoint[0],
 356                       motionVector[1] + viewPoint[1],
 357                       motionVector[2] + viewPoint[2]);
 358
 359   if (rwi->GetLightFollowCamera())
 360   {
 361     this->CurrentRenderer->UpdateLightsGeometryToFollowCamera();
 362   }
 363
 364   rwi->Render();
 365 }
 366
 367 //----------------------------------------------------------------------------
 368 void egvtkInteractorStyle::Dolly()
 369 {
 370   if (this->CurrentRenderer == NULL)
 371   {
 372     return;
 373   }
 374
 375   vtkRenderWindowInteractor *rwi = this->Interactor;
 376   double *center = this->CurrentRenderer->GetCenter();
 377   int dy = rwi->GetEventPosition()[1] - rwi->GetLastEventPosition()[1];
 378   double dyf = this->MotionFactor * dy / center[1];
 379   this->Dolly(pow(1.1, dyf));
 380 }
 381
 382 //----------------------------------------------------------------------------
 383 void egvtkInteractorStyle::Dolly(double factor)
 384 {
 385   if (this->CurrentRenderer == NULL)
 386   {
 387     return;
 388   }
 389
 390   vtkCamera *camera = this->CurrentRenderer->GetActiveCamera();
 391   if (camera->GetParallelProjection())
 392   {
 393     camera->SetParallelScale(camera->GetParallelScale() / factor);
 394   }
 395   else
 396   {
 397     camera->Dolly(factor);
 398     if (this->AutoAdjustCameraClippingRange)
 399     {
 400       this->CurrentRenderer->ResetCameraClippingRange();
 401     }
 402   }
 403
 404   if (this->Interactor->GetLightFollowCamera())
 405   {
 406     this->CurrentRenderer->UpdateLightsGeometryToFollowCamera();
 407   }
 408
 409   this->Interactor->Render();
 410 }
 411
 412 //----------------------------------------------------------------------------
 413 void egvtkInteractorStyle::PrintSelf(ostream& os, vtkIndent indent)
 414 {
 415   this->Superclass::PrintSelf(os,indent);
 416   os << indent << "MotionFactor: " << this->MotionFactor << "\n";
 417 }
 418
 419 void egvtkInteractorStyle::OnChar()
 420 {
 421   cout<<"OnChar "<<this->Interactor->GetKeyCode()<<endl;
 422   this->EventCallbackCommand->SetAbortFlag(1);
 423
 424   vtkRenderWindowInteractor *rwi = this->Interactor;
 425   char key=rwi->GetKeyCode();
 426
 427   if(key=='n') {
 428     cout<<"pick node by mouse"<<endl;
 429   }
 430 /*  else if(key=='N') {
 431     cout<<"pick node by ID"<<endl;
 432   }*/
 433
 434   else if(key=='c') {
 435     cout<<"pick cell by mouse"<<endl;
 436   }
 437 /*  else if(key=='C') {
 438     cout<<"pick cell by ID"<<endl;
 439   }*/
 440
 441 /*  else if(key=='b') {
 442     cout<<"box select"<<endl;
 443   }*/
 444
 445   /*  else if(key=='d') {
 446     cout<<"Delete picked point"<<endl;
 447 //     EG_STDINTERSLOT(DeletePickedPoint);
 448     DeletePickedPoint deletepickedpoint;
 449     deletepickedpoint();
 450     OPER *oper = new OPER(); \
 451       (*oper)(); \
 452       oper->del(); \
 453       if(grid->GetNumberOfPoints()) updateBoundaryCodes(false);
 454       updateActors();
 455
 456   }*/
 457
 458   else {
 459    // otherwise pass the OnChar to the vtkInteractorStyle.
 460     if (this->HasObserver(vtkCommand::CharEvent)) {
 461       this->ShiftKey = this->Interactor->GetShiftKey();
 462       this->ControlKey = this->Interactor->GetControlKey();
 463       this->KeyCode = this->Interactor->GetKeyCode();
 464
 465       this->InvokeEvent(vtkCommand::CharEvent,NULL);
 466     }
 467     else {
 468       this->vtkInteractorStyle::OnChar();
 469     }
 470   }
 471 }