mirror of
https://github.com/opencv/opencv.git
synced 2025-07-29 17:02:49 +08:00
686 lines
25 KiB
C++
686 lines
25 KiB
C++
#include "precomp.hpp"
|
|
|
|
#include "interactor_style.h"
|
|
|
|
//#include <q/visualization/vtk/vtkVertexBufferObjectMapper.h>
|
|
|
|
using namespace cv;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::Initialize ()
|
|
{
|
|
modifier_ = temp_viz::InteractorStyle::KB_MOD_ALT;
|
|
// Set windows size (width, height) to unknown (-1)
|
|
win_size_ = Vec2i(-1, -1);
|
|
win_pos_ = Vec2i(0, 0);
|
|
max_win_size_ = Vec2i(-1, -1);
|
|
|
|
// Create the image filter and PNG writer objects
|
|
wif_ = vtkSmartPointer<vtkWindowToImageFilter>::New ();
|
|
snapshot_writer_ = vtkSmartPointer<vtkPNGWriter>::New ();
|
|
snapshot_writer_->SetInputConnection (wif_->GetOutputPort ());
|
|
|
|
init_ = true;
|
|
stereo_anaglyph_mask_default_ = true;
|
|
|
|
// Initialize the keyboard event callback as none
|
|
keyboardCallback_ = 0;
|
|
keyboard_callback_cookie_ = 0;
|
|
|
|
// Initialize the mouse event callback as none
|
|
mouseCallback_ = 0;
|
|
mouse_callback_cookie_ = 0;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::saveScreenshot (const std::string &file)
|
|
{
|
|
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
|
|
wif_->SetInput (Interactor->GetRenderWindow ());
|
|
wif_->Modified (); // Update the WindowToImageFilter
|
|
snapshot_writer_->Modified ();
|
|
snapshot_writer_->SetFileName (file.c_str ());
|
|
snapshot_writer_->Write ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::zoomIn ()
|
|
{
|
|
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
|
|
// Zoom in
|
|
StartDolly ();
|
|
double factor = 10.0 * 0.2 * .5;
|
|
Dolly (pow (1.1, factor));
|
|
EndDolly ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::zoomOut ()
|
|
{
|
|
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
|
|
// Zoom out
|
|
StartDolly ();
|
|
double factor = 10.0 * -0.2 * .5;
|
|
Dolly (pow (1.1, factor));
|
|
EndDolly ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::OnChar ()
|
|
{
|
|
// Make sure we ignore the same events we handle in OnKeyDown to avoid calling things twice
|
|
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
|
|
if (Interactor->GetKeyCode () >= '0' && Interactor->GetKeyCode () <= '9')
|
|
return;
|
|
std::string key (Interactor->GetKeySym ());
|
|
if (key.find ("XF86ZoomIn") != std::string::npos)
|
|
zoomIn ();
|
|
else if (key.find ("XF86ZoomOut") != std::string::npos)
|
|
zoomOut ();
|
|
|
|
int keymod = false;
|
|
switch (modifier_)
|
|
{
|
|
case KB_MOD_ALT:
|
|
{
|
|
keymod = Interactor->GetAltKey ();
|
|
break;
|
|
}
|
|
case KB_MOD_CTRL:
|
|
{
|
|
keymod = Interactor->GetControlKey ();
|
|
break;
|
|
}
|
|
case KB_MOD_SHIFT:
|
|
{
|
|
keymod = Interactor->GetShiftKey ();
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (Interactor->GetKeyCode ())
|
|
{
|
|
// All of the options below simply exit
|
|
case 'h': case 'H':
|
|
case 'l': case 'L':
|
|
case 'p': case 'P':
|
|
case 'j': case 'J':
|
|
case 'c': case 'C':
|
|
case 43: // KEY_PLUS
|
|
case 45: // KEY_MINUS
|
|
case 'f': case 'F':
|
|
case 'g': case 'G':
|
|
case 'o': case 'O':
|
|
case 'u': case 'U':
|
|
case 'q': case 'Q':
|
|
{
|
|
break;
|
|
}
|
|
// S and R have a special !ALT case
|
|
case 'r': case 'R':
|
|
case 's': case 'S':
|
|
{
|
|
if (!keymod)
|
|
Superclass::OnChar ();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
Superclass::OnChar ();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
|
|
{
|
|
// Register the callback function and store the user data
|
|
mouseCallback_ = callback;
|
|
mouse_callback_cookie_ = cookie;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void *cookie)
|
|
{
|
|
// Register the callback function and store the user data
|
|
keyboardCallback_ = callback;
|
|
keyboard_callback_cookie_ = cookie;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
temp_viz::InteractorStyle::OnKeyDown ()
|
|
{
|
|
if (!init_)
|
|
{
|
|
std::cout << "Interactor style not initialized. Please call Initialize () before continuing" << std::endl;
|
|
return;
|
|
}
|
|
|
|
if (!renderer_)
|
|
{
|
|
std::cout << "No renderer given! Use SetRendererCollection () before continuing." << std::endl;
|
|
return;
|
|
}
|
|
|
|
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
|
|
|
|
if (wif_->GetInput () == NULL)
|
|
{
|
|
wif_->SetInput (Interactor->GetRenderWindow ());
|
|
wif_->Modified ();
|
|
snapshot_writer_->Modified ();
|
|
}
|
|
|
|
// Save the initial windows width/height
|
|
if (win_size_[0] == -1 || win_size_[1] == -1)
|
|
win_size_ = Vec2i(Interactor->GetRenderWindow ()->GetSize ());
|
|
|
|
|
|
// Get the status of special keys (Cltr+Alt+Shift)
|
|
bool shift = Interactor->GetShiftKey ();
|
|
bool ctrl = Interactor->GetControlKey ();
|
|
bool alt = Interactor->GetAltKey ();
|
|
|
|
bool keymod = false;
|
|
switch (modifier_)
|
|
{
|
|
case KB_MOD_ALT: keymod = alt; break;
|
|
case KB_MOD_CTRL: keymod = ctrl; break;
|
|
case KB_MOD_SHIFT: keymod = shift; break;
|
|
}
|
|
|
|
std::string key (Interactor->GetKeySym ());
|
|
if (key.find ("XF86ZoomIn") != std::string::npos)
|
|
zoomIn ();
|
|
else if (key.find ("XF86ZoomOut") != std::string::npos)
|
|
zoomOut ();
|
|
|
|
switch (Interactor->GetKeyCode ())
|
|
{
|
|
case 'h': case 'H':
|
|
{
|
|
std::cout << "| Help:\n"
|
|
"-------\n"
|
|
" p, P : switch to a point-based representation\n"
|
|
" w, W : switch to a wireframe-based representation (where available)\n"
|
|
" s, S : switch to a surface-based representation (where available)\n"
|
|
"\n"
|
|
" j, J : take a .PNG snapshot of the current window view\n"
|
|
" c, C : display current camera/window parameters\n"
|
|
" f, F : fly to point mode\n"
|
|
"\n"
|
|
" e, E : exit the interactor\n"
|
|
" q, Q : stop and call VTK's TerminateApp\n"
|
|
"\n"
|
|
" +/- : increment/decrement overall point size\n"
|
|
" +/- [+ ALT] : zoom in/out \n"
|
|
"\n"
|
|
" r, R [+ ALT] : reset camera [to viewpoint = {0, 0, 0} -> center_{x, y, z}]\n"
|
|
"\n"
|
|
" ALT + s, S : turn stereo mode on/off\n"
|
|
" ALT + f, F : switch between maximized window mode and original size\n"
|
|
"\n"
|
|
" SHIFT + left click : select a point\n"
|
|
<< std::endl;
|
|
break;
|
|
}
|
|
|
|
// Switch representation to points
|
|
case 'p': case 'P':
|
|
{
|
|
vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors ();
|
|
vtkCollectionSimpleIterator ait;
|
|
for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); )
|
|
{
|
|
for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); )
|
|
{
|
|
vtkSmartPointer<vtkActor> apart = reinterpret_cast <vtkActor*> (path->GetLastNode ()->GetViewProp ());
|
|
apart->GetProperty ()->SetRepresentationToPoints ();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
// Save a PNG snapshot with the current screen
|
|
case 'j': case 'J':
|
|
{
|
|
char cam_fn[80], snapshot_fn[80];
|
|
unsigned t = static_cast<unsigned> (time (0));
|
|
sprintf (snapshot_fn, "screenshot-%d.png" , t);
|
|
saveScreenshot (snapshot_fn);
|
|
|
|
sprintf (cam_fn, "screenshot-%d.cam", t);
|
|
ofstream ofs_cam;
|
|
ofs_cam.open (cam_fn);
|
|
vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow ()->GetRenderers ()->GetFirstRenderer ()->GetActiveCamera ();
|
|
double clip[2], focal[3], pos[3], view[3];
|
|
cam->GetClippingRange (clip);
|
|
cam->GetFocalPoint (focal);
|
|
cam->GetPosition (pos);
|
|
cam->GetViewUp (view);
|
|
#ifndef M_PI
|
|
# define M_PI 3.14159265358979323846 // pi
|
|
#endif
|
|
|
|
int *win_pos = Interactor->GetRenderWindow ()->GetPosition ();
|
|
int *win_size = Interactor->GetRenderWindow ()->GetSize ();
|
|
ofs_cam << clip[0] << "," << clip[1] << "/" << focal[0] << "," << focal[1] << "," << focal[2] << "/" <<
|
|
pos[0] << "," << pos[1] << "," << pos[2] << "/" << view[0] << "," << view[1] << "," << view[2] << "/" <<
|
|
cam->GetViewAngle () / 180.0 * M_PI << "/" << win_size[0] << "," << win_size[1] << "/" << win_pos[0] << "," << win_pos[1]
|
|
<< endl;
|
|
ofs_cam.close ();
|
|
|
|
std::cout << "Screenshot (" << snapshot_fn << ") and camera information (" << cam_fn << ") successfully captured." << std::endl;
|
|
break;
|
|
}
|
|
// display current camera settings/parameters
|
|
case 'c': case 'C':
|
|
{
|
|
vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow ()->GetRenderers ()->GetFirstRenderer ()->GetActiveCamera ();
|
|
|
|
Vec2d clip;
|
|
Vec3d focal, pose, view;
|
|
cam->GetClippingRange (clip.val);
|
|
cam->GetFocalPoint (focal.val);
|
|
cam->GetPosition (pose.val);
|
|
cam->GetViewUp (view.val);
|
|
Vec2i win_pos(Interactor->GetRenderWindow()->GetPosition());
|
|
Vec2i win_size(Interactor->GetRenderWindow()->GetSize());
|
|
|
|
std::cerr << Mat(clip, false).reshape(1, 1) << "/" << Mat(focal, false).reshape(1, 1) << "/" <<
|
|
Mat(pose, false).reshape(1, 1) << "/" << Mat(view, false).reshape(1, 1) << "/" <<
|
|
cam->GetViewAngle () / 180.0 * M_PI << "/" <<
|
|
Mat(win_size, false).reshape(1,1) << "/" << Mat(win_pos, false).reshape(1,1) << endl;
|
|
break;
|
|
}
|
|
case '=':
|
|
{
|
|
zoomIn();
|
|
break;
|
|
}
|
|
case 43: // KEY_PLUS
|
|
{
|
|
if(alt)
|
|
zoomIn ();
|
|
else
|
|
{
|
|
vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors ();
|
|
vtkCollectionSimpleIterator ait;
|
|
for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); )
|
|
{
|
|
for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); )
|
|
{
|
|
vtkSmartPointer<vtkActor> apart = reinterpret_cast <vtkActor*> (path->GetLastNode ()->GetViewProp ());
|
|
float psize = apart->GetProperty ()->GetPointSize ();
|
|
if (psize < 63.0f)
|
|
apart->GetProperty ()->SetPointSize (psize + 1.0f);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 45: // KEY_MINUS
|
|
{
|
|
if(alt)
|
|
zoomOut ();
|
|
else
|
|
{
|
|
vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors ();
|
|
vtkCollectionSimpleIterator ait;
|
|
for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); )
|
|
{
|
|
for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); )
|
|
{
|
|
vtkSmartPointer<vtkActor> apart = static_cast<vtkActor*> (path->GetLastNode ()->GetViewProp ());
|
|
float psize = apart->GetProperty ()->GetPointSize ();
|
|
if (psize > 1.0f)
|
|
apart->GetProperty ()->SetPointSize (psize - 1.0f);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
// Switch between maximize and original window size
|
|
case 'f': case 'F':
|
|
{
|
|
if (keymod)
|
|
{
|
|
Vec2i screen_size(Interactor->GetRenderWindow ()->GetScreenSize ());
|
|
Vec2i win_size(Interactor->GetRenderWindow ()->GetSize ());
|
|
|
|
// Is window size = max?
|
|
if (win_size == max_win_size_)
|
|
{
|
|
Interactor->GetRenderWindow ()->SetSize (win_size_.val);
|
|
Interactor->GetRenderWindow ()->SetPosition (win_pos_.val);
|
|
Interactor->GetRenderWindow ()->Render ();
|
|
Interactor->Render ();
|
|
}
|
|
// Set to max
|
|
else
|
|
{
|
|
win_pos_ = Vec2i(Interactor->GetRenderWindow ()->GetPosition ());
|
|
win_size_ = win_size;
|
|
|
|
Interactor->GetRenderWindow ()->SetSize (screen_size.val);
|
|
Interactor->GetRenderWindow ()->Render ();
|
|
Interactor->Render ();
|
|
max_win_size_ = Vec2i(Interactor->GetRenderWindow ()->GetSize ());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AnimState = VTKIS_ANIM_ON;
|
|
vtkAssemblyPath *path = NULL;
|
|
Interactor->GetPicker ()->Pick (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1], 0.0, CurrentRenderer);
|
|
vtkAbstractPropPicker *picker;
|
|
if ((picker = vtkAbstractPropPicker::SafeDownCast (Interactor->GetPicker ())))
|
|
path = picker->GetPath ();
|
|
if (path != NULL)
|
|
Interactor->FlyTo (CurrentRenderer, picker->GetPickPosition ());
|
|
AnimState = VTKIS_ANIM_OFF;
|
|
}
|
|
break;
|
|
}
|
|
// 's'/'S' w/out ALT
|
|
case 's': case 'S':
|
|
{
|
|
if (keymod)
|
|
{
|
|
int stereo_render = Interactor->GetRenderWindow ()->GetStereoRender ();
|
|
if (!stereo_render)
|
|
{
|
|
if (stereo_anaglyph_mask_default_)
|
|
{
|
|
Interactor->GetRenderWindow ()->SetAnaglyphColorMask (4, 3);
|
|
stereo_anaglyph_mask_default_ = false;
|
|
}
|
|
else
|
|
{
|
|
Interactor->GetRenderWindow ()->SetAnaglyphColorMask (2, 5);
|
|
stereo_anaglyph_mask_default_ = true;
|
|
}
|
|
}
|
|
Interactor->GetRenderWindow ()->SetStereoRender (!stereo_render);
|
|
Interactor->GetRenderWindow ()->Render ();
|
|
Interactor->Render ();
|
|
}
|
|
else
|
|
Superclass::OnKeyDown ();
|
|
break;
|
|
}
|
|
|
|
case 'o': case 'O':
|
|
{
|
|
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera ();
|
|
int flag = cam->GetParallelProjection ();
|
|
cam->SetParallelProjection (!flag);
|
|
|
|
CurrentRenderer->SetActiveCamera (cam);
|
|
CurrentRenderer->Render ();
|
|
break;
|
|
}
|
|
|
|
// Overwrite the camera reset
|
|
case 'r': case 'R':
|
|
{
|
|
if (!keymod)
|
|
{
|
|
Superclass::OnKeyDown ();
|
|
break;
|
|
}
|
|
|
|
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera ();
|
|
|
|
static CloudActorMap::iterator it = actors_->begin ();
|
|
// it might be that some actors don't have a valid transformation set -> we skip them to avoid a seg fault.
|
|
bool found_transformation = false;
|
|
|
|
for (size_t idx = 0; idx < actors_->size (); ++idx, ++it)
|
|
{
|
|
if (it == actors_->end ())
|
|
it = actors_->begin ();
|
|
|
|
const CloudActor& actor = it->second;
|
|
if (actor.viewpoint_transformation_.GetPointer ())
|
|
{
|
|
found_transformation = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// if a valid transformation was found, use it otherwise fall back to default view point.
|
|
if (found_transformation)
|
|
{
|
|
const CloudActor& actor = it->second;
|
|
cam->SetPosition (actor.viewpoint_transformation_->GetElement (0, 3),
|
|
actor.viewpoint_transformation_->GetElement (1, 3),
|
|
actor.viewpoint_transformation_->GetElement (2, 3));
|
|
|
|
cam->SetFocalPoint (actor.viewpoint_transformation_->GetElement (0, 3) - actor.viewpoint_transformation_->GetElement (0, 2),
|
|
actor.viewpoint_transformation_->GetElement (1, 3) - actor.viewpoint_transformation_->GetElement (1, 2),
|
|
actor.viewpoint_transformation_->GetElement (2, 3) - actor.viewpoint_transformation_->GetElement (2, 2));
|
|
|
|
cam->SetViewUp (actor.viewpoint_transformation_->GetElement (0, 1),
|
|
actor.viewpoint_transformation_->GetElement (1, 1),
|
|
actor.viewpoint_transformation_->GetElement (2, 1));
|
|
}
|
|
else
|
|
{
|
|
cam->SetPosition (0, 0, 0);
|
|
cam->SetFocalPoint (0, 0, 1);
|
|
cam->SetViewUp (0, -1, 0);
|
|
}
|
|
|
|
// go to the next actor for the next key-press event.
|
|
if (it != actors_->end ())
|
|
++it;
|
|
else
|
|
it = actors_->begin ();
|
|
|
|
CurrentRenderer->SetActiveCamera (cam);
|
|
CurrentRenderer->ResetCameraClippingRange ();
|
|
CurrentRenderer->Render ();
|
|
break;
|
|
}
|
|
|
|
case 'q': case 'Q':
|
|
{
|
|
Interactor->ExitCallback ();
|
|
return;
|
|
}
|
|
default:
|
|
{
|
|
Superclass::OnKeyDown ();
|
|
break;
|
|
}
|
|
}
|
|
|
|
KeyboardEvent event (true, Interactor->GetKeySym (), Interactor->GetKeyCode (), Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
|
|
// Check if there is a keyboard callback registered
|
|
if (keyboardCallback_)
|
|
keyboardCallback_(event, keyboard_callback_cookie_);
|
|
|
|
renderer_->Render ();
|
|
Interactor->Render ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::OnKeyUp ()
|
|
{
|
|
KeyboardEvent event (false, Interactor->GetKeySym (), Interactor->GetKeyCode (), Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
|
|
// Check if there is a keyboard callback registered
|
|
if (keyboardCallback_)
|
|
keyboardCallback_(event, keyboard_callback_cookie_);
|
|
|
|
Superclass::OnKeyUp ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::OnMouseMove ()
|
|
{
|
|
Vec2i p(Interactor->GetEventPosition());
|
|
MouseEvent event (MouseEvent::MouseMove, MouseEvent::NoButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
|
|
if (mouseCallback_)
|
|
mouseCallback_(event, mouse_callback_cookie_);
|
|
Superclass::OnMouseMove ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::OnLeftButtonDown ()
|
|
{
|
|
Vec2i p(Interactor->GetEventPosition());
|
|
MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
|
|
MouseEvent event (type, MouseEvent::LeftButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
|
|
if (mouseCallback_)
|
|
mouseCallback_(event, mouse_callback_cookie_);
|
|
Superclass::OnLeftButtonDown ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::OnLeftButtonUp ()
|
|
{
|
|
Vec2i p(Interactor->GetEventPosition());
|
|
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::LeftButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
|
|
if (mouseCallback_)
|
|
mouseCallback_(event, mouse_callback_cookie_);
|
|
Superclass::OnLeftButtonUp ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::OnMiddleButtonDown ()
|
|
{
|
|
Vec2i p(Interactor->GetEventPosition());
|
|
|
|
MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
|
|
MouseEvent event (type, MouseEvent::MiddleButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
|
|
if (mouseCallback_)
|
|
mouseCallback_(event, mouse_callback_cookie_);
|
|
Superclass::OnMiddleButtonDown ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::OnMiddleButtonUp ()
|
|
{
|
|
Vec2i p(Interactor->GetEventPosition());
|
|
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::MiddleButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
|
|
if (mouseCallback_)
|
|
mouseCallback_(event, mouse_callback_cookie_);
|
|
Superclass::OnMiddleButtonUp ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::OnRightButtonDown ()
|
|
{
|
|
Vec2i p(Interactor->GetEventPosition());
|
|
|
|
MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
|
|
MouseEvent event (type, MouseEvent::RightButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
|
|
if (mouseCallback_)
|
|
mouseCallback_(event, mouse_callback_cookie_);
|
|
Superclass::OnRightButtonDown ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::OnRightButtonUp ()
|
|
{
|
|
Vec2i p(Interactor->GetEventPosition());
|
|
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::RightButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
|
|
if (mouseCallback_)
|
|
mouseCallback_(event, mouse_callback_cookie_);
|
|
Superclass::OnRightButtonUp ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::OnMouseWheelForward ()
|
|
{
|
|
Vec2i p(Interactor->GetEventPosition());
|
|
MouseEvent event (MouseEvent::MouseScrollUp, MouseEvent::VScroll, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
|
|
// If a mouse callback registered, call it!
|
|
if (mouseCallback_)
|
|
mouseCallback_(event, mouse_callback_cookie_);
|
|
if (Interactor->GetRepeatCount () && mouseCallback_)
|
|
mouseCallback_(event, mouse_callback_cookie_);
|
|
|
|
if (Interactor->GetAltKey ())
|
|
{
|
|
// zoom
|
|
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera ();
|
|
double opening_angle = cam->GetViewAngle ();
|
|
if (opening_angle > 15.0)
|
|
opening_angle -= 1.0;
|
|
|
|
cam->SetViewAngle (opening_angle);
|
|
cam->Modified ();
|
|
CurrentRenderer->SetActiveCamera (cam);
|
|
CurrentRenderer->ResetCameraClippingRange ();
|
|
CurrentRenderer->Modified ();
|
|
CurrentRenderer->Render ();
|
|
renderer_->Render ();
|
|
Interactor->Render ();
|
|
}
|
|
else
|
|
Superclass::OnMouseWheelForward ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::OnMouseWheelBackward ()
|
|
{
|
|
Vec2i p(Interactor->GetEventPosition());
|
|
MouseEvent event (MouseEvent::MouseScrollDown, MouseEvent::VScroll, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
|
|
// If a mouse callback registered, call it!
|
|
if (mouseCallback_)
|
|
mouseCallback_(event, mouse_callback_cookie_);
|
|
|
|
if (Interactor->GetRepeatCount () && mouseCallback_)
|
|
mouseCallback_(event, mouse_callback_cookie_);
|
|
|
|
if (Interactor->GetAltKey ())
|
|
{
|
|
// zoom
|
|
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera ();
|
|
double opening_angle = cam->GetViewAngle ();
|
|
if (opening_angle < 170.0)
|
|
opening_angle += 1.0;
|
|
|
|
cam->SetViewAngle (opening_angle);
|
|
cam->Modified ();
|
|
CurrentRenderer->SetActiveCamera (cam);
|
|
CurrentRenderer->ResetCameraClippingRange ();
|
|
CurrentRenderer->Modified ();
|
|
CurrentRenderer->Render ();
|
|
renderer_->Render ();
|
|
Interactor->Render ();
|
|
}
|
|
else
|
|
Superclass::OnMouseWheelBackward ();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
void temp_viz::InteractorStyle::OnTimer ()
|
|
{
|
|
if (!init_)
|
|
{
|
|
std::cout << "[PCLVisualizerInteractorStyle] Interactor style not initialized. Please call Initialize () before continuing.\n" << std::endl;
|
|
return;
|
|
}
|
|
|
|
if (!renderer_)
|
|
{
|
|
std::cout << "[PCLVisualizerInteractorStyle] No renderer collection given! Use SetRendererCollection () before continuing." << std::endl;
|
|
return;
|
|
}
|
|
renderer_->Render ();
|
|
Interactor->Render ();
|
|
}
|
|
|
|
|
|
namespace temp_viz
|
|
{
|
|
// Standard VTK macro for *New ()
|
|
vtkStandardNewMacro (InteractorStyle);
|
|
|
|
}
|
|
|