src/egvtkinteractorstyle.cpp

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