renderwindowinteractor.cpp

Go to the documentation of this file.

#include "renderwindowinteractor.h"

#include "vtkMath.h"
#include "vtkLightCollection.h"
#include "vtkSphereSource.h"
#include "vtkPolyDataMapper.h"
#include "vtkMath.h"

RenderWindowInteractor::RenderWindowInteractor( QWidget *parent,
               const char *name )
   : RenderWindow( parent, name ) {
   this->InitRenderWindowInteractor();
}

RenderWindowInteractor::RenderWindowInteractor(
      QGLFormat glf, QWidget *parent, const char *name )
   : RenderWindow( glf, parent, name ) {
   this->InitRenderWindowInteractor();
}


RenderWindowInteractor::~RenderWindowInteractor() {
   delete this->stepTimer;
}


void RenderWindowInteractor::InitRenderWindowInteractor() {
   this->SetLeftButtonFunction( SLOT(CameraRotate()) );
   this->SetMiddleButtonFunction( SLOT(CameraTranslate()) );
   this->SetRightButtonFunction( SLOT(CameraZoom()) );
   this->SetShiftLeftButtonFunction( SLOT(CameraRoll()) );

   this->mouseEventActive = false;
   this->SetInteractionTime( 50 );
   this->SetSensitivity( 10.0 );

   this->stepTimer = new QTimer();
   CHECK_PTR( this->stepTimer );

   this->currentCamera = this->GetRenderer()->GetActiveCamera();
   CHECK_PTR( this->currentCamera );

   // get the light we are using
   vtkLightCollection *lightCollection = this->GetRenderer()->GetLights();
   lightCollection->InitTraversal();
   this->currentLight = lightCollection->GetNextItem();
   CHECK_PTR( this->currentLight );

   this->interactionActor = NULL;
   this->collisionActor = NULL;
}


const char *RenderWindowInteractor::GetClassName() {
   return( "RenderWindowInteractor" );
}


void RenderWindowInteractor::SetPlane(float *ebene) {

   this->normale[0]     = ebene[0];
   this->normale[1]     = ebene[1];
   this->normale[2]     = ebene[2];
   this->ebenekonstante = ebene[3];

}

void RenderWindowInteractor::SetSensitivity( float t ) {
   this->trackballFactor = t;
}

float RenderWindowInteractor::GetSensitivity() {
   return this->trackballFactor;
}


void RenderWindowInteractor::SetLeftButtonFunction( const char* function ) {
   if( function == NULL ) {
      strncpy( this->leftButtonFunction, SLOT(DoNothing()), 100 );
   }
   else {
      strncpy( this->leftButtonFunction, function, 100 );
   }
}


void RenderWindowInteractor::SetMiddleButtonFunction( const char* function ) {
   if( function == NULL ) {
      strncpy( this->middleButtonFunction, SLOT(DoNothing()), 100 );
   }
   else {
      strncpy( this->middleButtonFunction, function, 100 );
   }
}


void RenderWindowInteractor::SetRightButtonFunction( const char* function ) {
   if( function == NULL ) {
      strncpy( this->rightButtonFunction, SLOT(DoNothing()), 100 );
   }
   else {
      strncpy( this->rightButtonFunction, function, 100 );
   }
}


void RenderWindowInteractor::SetShiftLeftButtonFunction(
            const char* function ) {
   if( function == NULL ) {
      strncpy( this->shiftLeftButtonFunction, SLOT(DoNothing()), 100 );
   }
   else {
      strncpy( this->shiftLeftButtonFunction, function, 100 );
   }
}


void RenderWindowInteractor::SetInteractionActor( vtkActor* actor ) {
   this->interactionActor = actor;
}


vtkActor *RenderWindowInteractor::GetInteractionActor( void ) {
   return this->interactionActor;
}

void RenderWindowInteractor::SetActorRotation( float x, float y, float z ) {
   ASSERT( this->interactionActor != NULL );

   // set it to the interactionActor
   this->interactionActor->SetOrigin( x, y, z );
}


void RenderWindowInteractor::mousePressEvent( QMouseEvent *event ) {
   if( this->mouseEventActive ) {
      return;
   }

   if( event->button() & LeftButton ) {
      if( event->state() & ShiftButton ) {
         // left mouse mouse and shift button
         this->mouseEventActive = true;
         QObject::connect( this->stepTimer, SIGNAL(timeout()),
                           this->shiftLeftButtonFunction );
      }
      else {
         // left mouse button without shift button
         this->mouseEventActive = true;
         QObject::connect( this->stepTimer, SIGNAL(timeout()),
                           this->leftButtonFunction );
      }
   }
   else if( event->button() & MidButton ) {
      // middle mouse button
      this->mouseEventActive = true;
      QObject::connect( this->stepTimer, SIGNAL(timeout()),
                        this->middleButtonFunction );
   }
   else if( event->button() & RightButton ) {
      // right mouse button
      this->mouseEventActive = true;
      QObject::connect( this->stepTimer, SIGNAL(timeout()),
                        this, this->rightButtonFunction );
   }

   if( this->mouseEventActive ) {
      this->currentMousePos[0] = event->x();
      this->currentMousePos[1] = event->y();
      this->lastMousePos[0] = event->x();
      this->lastMousePos[1] = event->y();
      this->firstCall = true;
      this->stepTimer->start( this->interactionTime );
   }
}


void RenderWindowInteractor::mouseReleaseEvent( QMouseEvent *event ) {
   if( this->mouseEventActive ) {
      this->stepTimer->stop();
      this->mouseEventActive = false;
      QObject::disconnect( this->stepTimer, 0, this, 0 );
   }

   emit( Released(event->x(), this->height() - event->y()) );

}


void RenderWindowInteractor::mouseMoveEvent( QMouseEvent *event ) {
   this->currentMousePos[0] = event->x();
   this->currentMousePos[1] = event->y();
}


void RenderWindowInteractor::SetInteractionTime( int time ) {
   this->interactionTime = time;
}

int RenderWindowInteractor::GetInteractionTime( void ) {
   return this->interactionTime;
}


void RenderWindowInteractor::ActorRotate() {
   float xf;
   float yf;

   // do nothing if mouse is still on the same pos
   if( (this->currentMousePos[0] == this->lastMousePos[0]) &&
       (this->currentMousePos[1] == this->lastMousePos[1]) ) {
      return;
   }

   // basic idea: the change in x of the mouse is used to rotate around the
   // view-up vector. the change in y of the mouse is used to rotate around the
   // cross of the viewplane-normal and the view-up vector,

   // first time we do some preprocessing
   if( firstCall ) {
      int *size = this->GetRenderWindow()->GetSize();
      float *vp = this->GetRenderer()->GetViewport();

      this->deltaAzimuth = -20.0/((vp[2] - vp[0])*size[0]);
      this->deltaElevation = -20.0/((vp[3] - vp[1])*size[1]);

      // get the rotation axis: cross of view-up and the normal in the viewplane
      this->currentCamera->GetViewUp( this->viewUp );
      this->currentCamera->GetViewPlaneNormal( this->vpNormal );
      vtkMath::Cross( this->vpNormal, this->viewUp, this->rotateY );

      this->firstCall = false;
   }

   // how much to rotate
   xf = (this->currentMousePos[0] - this->lastMousePos[0])
            * this->trackballFactor * deltaAzimuth * (-1);
   yf = (this->currentMousePos[1] - this->lastMousePos[1])
            * this->trackballFactor * deltaElevation;

   this->interactionActor->RotateWXYZ( xf, this->viewUp[0], this->viewUp[1],
                                           this->viewUp[2] );
   this->interactionActor->RotateWXYZ( yf, this->rotateY[0], this->rotateY[1],
                                           this->rotateY[2] );

   emit ActorRotated( xf, yf );

   // update
   this->updateGL();

   // save mouse pos
   this->lastMousePos[0] = this->currentMousePos[0];
   this->lastMousePos[1] = this->currentMousePos[1];
}


void RenderWindowInteractor::ActorTranslate() {
   float *center;
   float dispCenter[4];
   float newP[4];
   float oldP[4];

   // do nothing if mouse is still on the same pos
   if( (this->currentMousePos[0] == this->lastMousePos[0]) &&
       (this->currentMousePos[1] == this->lastMousePos[1]) ) {
      return;
   }

   center = this->interactionActor->GetCenter();
   this->WorldToDisplay( center[0], center[1], center[2], dispCenter );

   this->DisplayToWorld( float(this->currentMousePos[0]),
                         float(this->height() - this->currentMousePos[1]),
                         dispCenter[2],
                         newP );

   this->DisplayToWorld( float(this->lastMousePos[0]),
                         float(this->height() - this->lastMousePos[1]),
                         dispCenter[2],
                         oldP);

   this->interactionActor->AddPosition( newP[0]-oldP[0],
                                        newP[1]-oldP[1],
                                        newP[2]-oldP[2] );
   // update
   this->updateGL();

   // save mouse pos
   this->lastMousePos[0] = this->currentMousePos[0];
   this->lastMousePos[1] = this->currentMousePos[1];
}


void RenderWindowInteractor::ActorZoom() {
   float yf;

   // do nothing if mouse is still on the same pos
   if( (this->currentMousePos[0] == this->lastMousePos[0]) &&
       (this->currentMousePos[1] == this->lastMousePos[1]) ) {
      return;
   }

   // first time we do some preprocessing
   if( firstCall ) {
      this->currentCamera->GetViewPlaneNormal( this->vpNormal );
      firstCall = false;
   }

   yf = float(this->lastMousePos[1] - this->currentMousePos[1]) /
              float(this->height()) * this->trackballFactor * -10.0;

   this->interactionActor->AddPosition( this->vpNormal[0] * yf,
                                        this->vpNormal[1] * yf,
                                        this->vpNormal[2] * yf );

   // update
   this->updateGL();

   // save mouse pos
   this->lastMousePos[0] = this->currentMousePos[0];
   this->lastMousePos[1] = this->currentMousePos[1];
}


void RenderWindowInteractor::ActorRoll() {
   float angle;

   // do nothing if mouse is still on the same pos
   if( (this->currentMousePos[0] == this->lastMousePos[0]) &&
       (this->currentMousePos[1] == this->lastMousePos[1]) ) {
      return;
   }

   // first time we do some preprocessing
   if( firstCall ) {
      this->currentCamera->GetViewPlaneNormal( this->vpNormal );
      this->renCenter[0] = this->GetRenderer()->GetCenter()[0];
      this->renCenter[1] = this->GetRenderer()->GetCenter()[1];
      this->renCenter[2] = this->GetRenderer()->GetCenter()[2];
      firstCall = false;
   }

   int diffX1 = this->currentMousePos[0] - int(this->renCenter[0]);
   int diffY1 = this->currentMousePos[1] - int(this->renCenter[1]);
   int diffX2 = this->lastMousePos[0] - int(this->renCenter[0]);
   int diffY2 = this->lastMousePos[1] - int(this->renCenter[1]);

   double a1 = atan2( double(diffY1), double(diffX1) );
   double a2 = atan2( double(diffY2), double(diffX2) );
   angle = (a2 - a1) / (2.0 * 3.1415926535) * 360.0 / 10.0 *
           this->trackballFactor;
   this->interactionActor->RotateWXYZ( angle, this->vpNormal[0],
                                              this->vpNormal[1],
                                              this->vpNormal[2] );

   emit ActorRolled( angle );

   // update
   this->updateGL();

   // save mouse pos
   this->lastMousePos[0] = this->currentMousePos[0];
   this->lastMousePos[1] = this->currentMousePos[1];
}


void RenderWindowInteractor::CameraRotate() {
   float xf;
   float yf;

   // do nothing if mouse is still on the same pos
   if( (this->currentMousePos[0] == this->lastMousePos[0]) &&
       (this->currentMousePos[1] == this->lastMousePos[1]) ) {
      return;
   }

   // first time we do some preprocessing
   if( firstCall ) {
      int *size = this->GetRenderWindow()->GetSize();
      float *vp = this->GetRenderer()->GetViewport();

      this->deltaAzimuth = -20.0/((vp[2] - vp[0])*size[0]);
      this->deltaElevation = -20.0/((vp[3] - vp[1])*size[1]);
      firstCall = false;
   }

   xf = (this->currentMousePos[0] - this->lastMousePos[0]) * this->deltaAzimuth
            * this->trackballFactor;
   yf = (this->lastMousePos[1] - this->currentMousePos[1]) * this->deltaElevation
            * this->trackballFactor;

   this->currentCamera->Azimuth( xf );
   this->currentCamera->Elevation( yf );
   this->currentCamera->OrthogonalizeViewUp();
   this->GetRenderer()->ResetCameraClippingRange();

   // light follows the camera
   this->currentLight->SetPosition( this->currentCamera->GetPosition() );
   this->currentLight->SetFocalPoint( this->currentCamera->GetFocalPoint() );

   // update
   this->updateGL();

   // save mouse pos
   this->lastMousePos[0] = this->currentMousePos[0];
   this->lastMousePos[1] = this->currentMousePos[1];
}


void RenderWindowInteractor::CameraTranslate() {
   float newP[4];
   float viewFocus[4];
   float viewPoint[3];
   double motionVector[3];

   // do nothing if mouse is still on the same pos
   if( (this->currentMousePos[0] == this->lastMousePos[0]) &&
       (this->currentMousePos[1] == this->lastMousePos[1]) ) {
      return;
   }

   this->currentCamera->GetFocalPoint( viewFocus );
   this->WorldToDisplay( viewFocus[0], viewFocus[1], viewFocus[2],
                         viewFocus );
   double focalDepth = viewFocus[2];

   this->DisplayToWorld( float(this->width()/2.0 + (this->currentMousePos[0]
                                 - this->lastMousePos[0])),
                         float(this->height()/2.0 - (this->currentMousePos[1]
                                 - this->lastMousePos[1])),
                         focalDepth,
                         newP );

   this->currentCamera->GetFocalPoint( viewFocus );
   this->currentCamera->GetPosition( viewPoint );

   motionVector[0] = this->trackballFactor / 10.0 * ( viewFocus[0] - newP[0] );
   motionVector[1] = this->trackballFactor / 10.0 * ( viewFocus[1] - newP[1] );
   motionVector[2] = this->trackballFactor / 10.0 * ( viewFocus[2] - newP[2] );

   this->currentCamera->SetFocalPoint( motionVector[0] + viewFocus[0],
                                       motionVector[1] + viewFocus[1],
                                       motionVector[2] + viewFocus[2]);
   this->currentCamera->SetPosition( motionVector[0] + viewPoint[0],
                                     motionVector[1] + viewPoint[1],
                                     motionVector[2] + viewPoint[2]);

   // light follows the camera
   this->currentLight->SetPosition( this->currentCamera->GetPosition() );
   this->currentLight->SetFocalPoint( this->currentCamera->GetFocalPoint() );

   // update
   this->updateGL();

   // save mouse pos
   this->lastMousePos[0] = this->currentMousePos[0];
   this->lastMousePos[1] = this->currentMousePos[1];
}


void RenderWindowInteractor::CameraZoom() {
   float yf;

   // do nothing if mouse is still on the same y position
   if( this->currentMousePos[1] == this->lastMousePos[1] ) {
      return;
   }

   yf = float(this->currentMousePos[1]-this->lastMousePos[1]) /
              float(this->height()) * this->trackballFactor;
   // if yf < 0, we need to be between 0..1
   yf = pow( 1.1, yf );

   this->currentCamera->Dolly( yf );
   this->GetRenderer()->ResetCameraClippingRange();

   // update
   this->updateGL();

   // save mouse pos
   this->lastMousePos[0] = this->currentMousePos[0];
   this->lastMousePos[1] = this->currentMousePos[1];
}

   
void RenderWindowInteractor::CameraRoll() {
   float angle;

   // do nothing if mouse is still on the same pos
   if( (this->currentMousePos[0] == this->lastMousePos[0]) &&
       (this->currentMousePos[1] == this->lastMousePos[1]) ) {
      return;
   }

   // first time we do some preprocessing
   if( firstCall ) {
      this->renCenter[0] = this->GetRenderer()->GetCenter()[0];
      this->renCenter[1] = this->GetRenderer()->GetCenter()[1];
      this->renCenter[2] = this->GetRenderer()->GetCenter()[2];
      firstCall = false;
   }

   // calculate the angle in radians and roll the camera
   int diffX1 = this->currentMousePos[0] - int(this->renCenter[0]);
   int diffY1 = this->currentMousePos[1] - int(this->renCenter[1]);
   int diffX2 = this->lastMousePos[0] - int(this->renCenter[0]);
   int diffY2 = this->lastMousePos[1] - int(this->renCenter[1]);

   double a1 = atan2( double(diffY1), double(diffX1) );
   double a2 = atan2( double(diffY2), double(diffX2) );
   angle = (a2 - a1) / (2.0 * 3.1415926535) * 360.0 / 10.0 *
           this->trackballFactor;
   this->currentCamera->Roll( angle );

   // light follows the camera
   this->currentLight->SetPosition( this->currentCamera->GetPosition() );
   this->currentLight->SetFocalPoint( this->currentCamera->GetFocalPoint() );

   // update
   this->updateGL();

   // save mouse pos
   this->lastMousePos[0] = this->currentMousePos[0];
   this->lastMousePos[1] = this->currentMousePos[1];
}


void RenderWindowInteractor::ActorPlaneMove() {

   float *center;
   float dispCenter[4];
   float newP[4];
   float oldP[4];
   float p0[3],p1[3],t;
   float tkonstante = (this->normale[0])*(this->normale[0]) +
                      (this->normale[1])*(this->normale[1]) +
                      (this->normale[2])*(this->normale[2]) ;

   if( (this->currentMousePos[0] == this->lastMousePos[0]) &&
       (this->currentMousePos[1] == this->lastMousePos[1]) ) {
      return;
   }

   center = this->interactionActor->GetCenter();
   this->WorldToDisplay( center[0], center[1], center[2], dispCenter );

   this->DisplayToWorld( float(this->currentMousePos[0]),
                         float(this->height() - this->currentMousePos[1]),
                         dispCenter[2],
                         newP );

   this->DisplayToWorld( float(this->lastMousePos[0]),
                         float(this->height() - this->lastMousePos[1]),
                         dispCenter[2],
                         oldP);

   oldP[3] = oldP[0]*(this->normale[0]) +
             oldP[1]*(this->normale[1]) +
             oldP[2]*(this->normale[2]) ;

   t = (this->ebenekonstante - oldP[3])/tkonstante;

   p0[0] = oldP[0] + t*(this->normale[0]);
   p0[1] = oldP[1] + t*(this->normale[1]);
   p0[2] = oldP[2] + t*(this->normale[2]);

   newP[3] = newP[0]*(this->normale[0]) +
             newP[1]*(this->normale[1]) +
             newP[2]*(this->normale[2]);

   t = (this->ebenekonstante - newP[3])/tkonstante;

   p1[0] = newP[0] + t*(this->normale[0]);
   p1[1] = newP[1] + t*(this->normale[1]);
   p1[2] = newP[2] + t*(this->normale[2]);

   this->interactionActor->AddPosition( p1[0]-p0[0],
                                        p1[1]-p0[1],
                                        p1[2]-p0[2] );
   // update
   this->updateGL();

   // save mouse pos
   this->lastMousePos[0] = this->currentMousePos[0];
   this->lastMousePos[1] = this->currentMousePos[1];
}


void RenderWindowInteractor::ActorPlaneRoll() {

   float angle;

   // do nothing if mouse is still on the same pos
   if( (this->currentMousePos[0] == this->lastMousePos[0]) &&
       (this->currentMousePos[1] == this->lastMousePos[1]) ) {
      return;
   }

   // first time we do some preprocessing
   if( firstCall ) {
      this->renCenter[0] = this->GetRenderer()->GetCenter()[0];
      this->renCenter[1] = this->GetRenderer()->GetCenter()[1];
      this->renCenter[2] = this->GetRenderer()->GetCenter()[2];
      firstCall = false;
   }

   int diffX1 = this->currentMousePos[0] - int(this->renCenter[0]);
   int diffY1 = this->currentMousePos[1] - int(this->renCenter[1]);
   int diffX2 = this->lastMousePos[0] - int(this->renCenter[0]);
   int diffY2 = this->lastMousePos[1] - int(this->renCenter[1]);

   double a1 = atan2( double(diffY1), double(diffX1) );
   double a2 = atan2( double(diffY2), double(diffX2) );
   angle = (a2 - a1) / (2.0 * 3.1415926535) * 360.0 / 10.0 *
           this->trackballFactor;
   this->interactionActor->RotateWXYZ( -angle, this->normale[0],
                                              this->normale[1],
                                              this->normale[2] );

   // update
   this->updateGL();

   // save mouse pos
   this->lastMousePos[0] = this->currentMousePos[0];
   this->lastMousePos[1] = this->currentMousePos[1];

}


void RenderWindowInteractor::DoNothing() {
}


void RenderWindowInteractor::DisplayToWorld( float x, float y, float z,
                                             float *worldPoint ) {
   this->GetRenderer()->SetDisplayPoint( x, y, z );
   this->GetRenderer()->DisplayToWorld();
   this->GetRenderer()->GetWorldPoint( worldPoint );

   // normalize
   if (worldPoint[3]) {
      worldPoint[0] = worldPoint[0] / worldPoint[3];
      worldPoint[1] = worldPoint[1] / worldPoint[3];
      worldPoint[2] = worldPoint[2] / worldPoint[3];
      worldPoint[3] = 1.0;
   }
}


void RenderWindowInteractor::WorldToDisplay( float x, float y, float z,
                                             float *displayPoint ) {
  this->GetRenderer()->SetWorldPoint(x, y, z, 1.0 );
  this->GetRenderer()->WorldToDisplay();
  this->GetRenderer()->GetDisplayPoint( displayPoint );
}

---