1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
14 // Third party copyrights are property of their respective owners.
15 //
16 // Redistribution and use in source and binary forms, with or without modification,
17 // are permitted provided that the following conditions are met:
18 //
19 // * Redistribution's of source code must retain the above copyright notice,
20 // this list of conditions and the following disclaimer.
21 //
22 // * Redistribution's in binary form must reproduce the above copyright notice,
23 // this list of conditions and the following disclaimer in the documentation
24 // and/or other materials provided with the distribution.
25 //
26 // * The name of the copyright holders may not be used to endorse or promote products
27 // derived from this software without specific prior written permission.
28 //
29 // This software is provided by the copyright holders and contributors "as is" and
30 // any express or implied warranties, including, but not limited to, the implied
31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
32 // In no event shall the Intel Corporation or contributors be liable for any direct,
33 // indirect, incidental, special, exemplary, or consequential damages
34 // (including, but not limited to, procurement of substitute goods or services;
35 // loss of use, data, or profits; or business interruption) however caused
36 // and on any theory of liability, whether in contract, strict liability,
37 // or tort (including negligence or otherwise) arising in any way out of
38 // the use of this software, even if advised of the possibility of such damage.
39 //
40 // Authors:
41 // * Ozan Tonkal, ozantonkal@gmail.com
42 // * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
43 //
44 //M*/
45
46 #include "precomp.hpp"
47
48 namespace cv { namespace viz
49 {
50 vtkStandardNewMacro(vtkVizInteractorStyle)
51 }}
52
53 //////////////////////////////////////////////////////////////////////////////////////////////
54
vtkVizInteractorStyle()55 cv::viz::vtkVizInteractorStyle::vtkVizInteractorStyle()
56 {
57 FlyMode = false;
58 MotionFactor = 10.0;
59
60 keyboardCallback_ = 0;
61 keyboard_callback_cookie_ = 0;
62
63 mouseCallback_ = 0;
64 mouse_callback_cookie_ = 0;
65
66 // Set windows size (width, height) to unknown (-1)
67 win_size_ = Vec2i(-1, -1);
68 win_pos_ = Vec2i(0, 0);
69 max_win_size_ = Vec2i(-1, -1);
70
71 stereo_anaglyph_redblue_ = true;
72
73 //from fly
74 KeysDown = 0;
75 UseTimers = 1;
76
77 DiagonalLength = 1.0;
78 MotionStepSize = 1.0/100.0;
79 MotionUserScale = 1.0; // +/- key adjustment
80 MotionAccelerationFactor = 10.0;
81 AngleStepSize = 1.0;
82 }
83
~vtkVizInteractorStyle()84 cv::viz::vtkVizInteractorStyle::~vtkVizInteractorStyle() {}
85
86 //////////////////////////////////////////////////////////////////////////////////////////////
saveScreenshot(const String & file)87 void cv::viz::vtkVizInteractorStyle::saveScreenshot(const String &file)
88 {
89 FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
90
91 vtkSmartPointer<vtkWindowToImageFilter> wif = vtkSmartPointer<vtkWindowToImageFilter>::New();
92 wif->SetInput(Interactor->GetRenderWindow());
93
94 vtkSmartPointer<vtkPNGWriter> snapshot_writer = vtkSmartPointer<vtkPNGWriter>::New();
95 snapshot_writer->SetInputConnection(wif->GetOutputPort());
96 snapshot_writer->SetFileName(file.c_str());
97 snapshot_writer->Write();
98
99 cout << "Screenshot successfully captured (" << file.c_str() << ")" << endl;
100 }
101
102 //////////////////////////////////////////////////////////////////////////////////////////////
103
exportScene(const String & file)104 void cv::viz::vtkVizInteractorStyle::exportScene(const String &file)
105 {
106 vtkSmartPointer<vtkExporter> exporter;
107 if (file.size() > 5 && file.substr(file.size() - 5) == ".vrml")
108 {
109 exporter = vtkSmartPointer<vtkVRMLExporter>::New();
110 vtkVRMLExporter::SafeDownCast(exporter)->SetFileName(file.c_str());
111 }
112 else
113 {
114 exporter = vtkSmartPointer<vtkOBJExporter>::New();
115 vtkOBJExporter::SafeDownCast(exporter)->SetFilePrefix(file.c_str());
116 }
117
118 exporter->SetInput(Interactor->GetRenderWindow());
119 exporter->Write();
120
121 cout << "Scene successfully exported (" << file.c_str() << ")" << endl;
122 }
123
exportScene()124 void cv::viz::vtkVizInteractorStyle::exportScene()
125 {
126 // Export scene as in obj or vrml format
127 String format = Interactor->GetAltKey() ? "scene-%d.vrml" : "scene-%d";
128 exportScene(cv::format(format.c_str(), (unsigned int)time(0)));
129 }
130
131 //////////////////////////////////////////////////////////////////////////////////////////////
132
changePointsSize(float delta)133 void cv::viz::vtkVizInteractorStyle::changePointsSize(float delta)
134 {
135 vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors();
136 vtkCollectionSimpleIterator ait;
137
138 for (ac->InitTraversal(ait); vtkActor* actor = ac->GetNextActor(ait); )
139 for (actor->InitPathTraversal(); vtkAssemblyPath* path = actor->GetNextPath(); )
140 {
141 vtkActor* apart = vtkActor::SafeDownCast(path->GetLastNode()->GetViewProp());
142 float psize = apart->GetProperty()->GetPointSize() + delta;
143 psize = std::max(1.f, std::min(63.f, psize));
144 apart->GetProperty()->SetPointSize(psize);
145 }
146 }
147
setRepresentationToPoints()148 void cv::viz::vtkVizInteractorStyle::setRepresentationToPoints()
149 {
150 vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors();
151 vtkCollectionSimpleIterator ait;
152 for (ac->InitTraversal(ait); vtkActor* actor = ac->GetNextActor(ait); )
153 for (actor->InitPathTraversal(); vtkAssemblyPath* path = actor->GetNextPath(); )
154 {
155 vtkActor* apart = vtkActor::SafeDownCast(path->GetLastNode()->GetViewProp());
156 apart->GetProperty()->SetRepresentationToPoints();
157 }
158 }
159
160 //////////////////////////////////////////////////////////////////////////////////////////////
161
printCameraParams()162 void cv::viz::vtkVizInteractorStyle::printCameraParams()
163 {
164 vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow()->GetRenderers()->GetFirstRenderer()->GetActiveCamera();
165
166 Vec2d clip(cam->GetClippingRange());
167 Vec3d focal(cam->GetFocalPoint()), pos(cam->GetPosition()), view(cam->GetViewUp());
168 Vec2i win_pos(Interactor->GetRenderWindow()->GetPosition());
169 Vec2i win_size(Interactor->GetRenderWindow()->GetSize());
170 double angle = cam->GetViewAngle () / 180.0 * CV_PI;
171
172 String data = cv::format("clip(%f,%f) focal(%f,%f,%f) pos(%f,%f,%f) view(%f,%f,%f) angle(%f) winsz(%d,%d) winpos(%d,%d)",
173 clip[0], clip[1], focal[0], focal[1], focal[2], pos[0], pos[1], pos[2], view[0], view[1], view[2],
174 angle, win_size[0], win_size[1], win_pos[0], win_pos[1]);
175
176 std::cout << data.c_str() << std::endl;
177 }
178
179 //////////////////////////////////////////////////////////////////////////////////////////////
180
toggleFullScreen()181 void cv::viz::vtkVizInteractorStyle::toggleFullScreen()
182 {
183 Vec2i screen_size(Interactor->GetRenderWindow()->GetScreenSize());
184 Vec2i win_size(Interactor->GetRenderWindow()->GetSize());
185
186 // Is window size = max?
187 if (win_size == max_win_size_)
188 {
189 Interactor->GetRenderWindow()->SetSize(win_size_.val);
190 Interactor->GetRenderWindow()->SetPosition(win_pos_.val);
191 Interactor->Render();
192 }
193 // Set to max
194 else
195 {
196 win_pos_ = Vec2i(Interactor->GetRenderWindow()->GetPosition());
197 win_size_ = win_size;
198
199 Interactor->GetRenderWindow()->SetSize(screen_size.val);
200 Interactor->Render();
201 max_win_size_ = Vec2i(Interactor->GetRenderWindow()->GetSize());
202 }
203 }
204
205 //////////////////////////////////////////////////////////////////////////////////////////////
206
resetViewerPose()207 void cv::viz::vtkVizInteractorStyle::resetViewerPose()
208 {
209 WidgetActorMap::iterator it = widget_actor_map_->begin();
210 // it might be that some actors don't have a valid transformation set -> we skip them to avoid a seg fault.
211 for (; it != widget_actor_map_->end(); ++it)
212 {
213 vtkProp3D * actor = vtkProp3D::SafeDownCast(it->second);
214 if (actor && actor->GetUserMatrix())
215 break;
216 }
217
218 vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera();
219
220 // if a valid transformation was found, use it otherwise fall back to default view point.
221 if (it != widget_actor_map_->end())
222 {
223 vtkMatrix4x4* m = vtkProp3D::SafeDownCast(it->second)->GetUserMatrix();
224
225 cam->SetFocalPoint(m->GetElement(0, 3) - m->GetElement(0, 2),
226 m->GetElement(1, 3) - m->GetElement(1, 2),
227 m->GetElement(2, 3) - m->GetElement(2, 2));
228
229 cam->SetViewUp (m->GetElement(0, 1), m->GetElement(1, 1), m->GetElement(2, 1));
230 cam->SetPosition(m->GetElement(0, 3), m->GetElement(1, 3), m->GetElement(2, 3));
231 }
232 else
233 {
234 cam->SetPosition(0, 0, 0);
235 cam->SetFocalPoint(0, 0, 1);
236 cam->SetViewUp(0, -1, 0);
237 }
238
239 // go to the next actor for the next key-press event.
240 if (it != widget_actor_map_->end())
241 ++it;
242 else
243 it = widget_actor_map_->begin();
244
245 CurrentRenderer->SetActiveCamera(cam);
246 CurrentRenderer->ResetCameraClippingRange();
247 Interactor->Render();
248 }
249
250 //////////////////////////////////////////////////////////////////////////////////////////////
251
toggleStereo()252 void cv::viz::vtkVizInteractorStyle::toggleStereo()
253 {
254 vtkSmartPointer<vtkRenderWindow> window = Interactor->GetRenderWindow();
255 if (!window->GetStereoRender())
256 {
257 static Vec2i red_blue(4, 3), magenta_green(2, 5);
258 window->SetAnaglyphColorMask (stereo_anaglyph_redblue_ ? red_blue.val : magenta_green.val);
259 stereo_anaglyph_redblue_ = !stereo_anaglyph_redblue_;
260 }
261 window->SetStereoRender(!window->GetStereoRender());
262 Interactor->Render();
263
264 }
265
266 //////////////////////////////////////////////////////////////////////////////////////////////
267
printHelp()268 void cv::viz::vtkVizInteractorStyle::printHelp()
269 {
270 std::cout << "| Help:\n"
271 "-------\n"
272 " p, P : switch to a point-based representation\n"
273 " w, W : switch to a wireframe-based representation (where available)\n"
274 " s, S : switch to a surface-based representation (where available)\n"
275 "\n"
276 " j, J : take a .PNG snapshot of the current window view\n"
277 " k, K : export scene to Wavefront .obj format\n"
278 " ALT + k, K : export scene to VRML format\n"
279 " c, C : display current camera/window parameters\n"
280 " F5 : enable/disable fly mode (changes control style)\n"
281 "\n"
282 " e, E : exit the interactor\n"
283 " q, Q : stop and call VTK's TerminateApp\n"
284 "\n"
285 " +/- : increment/decrement overall point size\n"
286 " +/- [+ ALT] : zoom in/out \n"
287 "\n"
288 " r, R [+ ALT] : reset camera [to viewpoint = {0, 0, 0} -> center_{x, y, z}]\n"
289 "\n"
290 " ALT + s, S : turn stereo mode on/off\n"
291 " ALT + f, F : switch between maximized window mode and original size\n"
292 "\n"
293 << std::endl;
294 }
295
296 //////////////////////////////////////////////////////////////////////////////////////////////
zoomIn()297 void cv::viz::vtkVizInteractorStyle::zoomIn()
298 {
299 FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
300 // Zoom in
301 StartDolly();
302 double factor = 10.0 * 0.2 * .5;
303 Dolly(std::pow(1.1, factor));
304 EndDolly();
305 }
306
307 //////////////////////////////////////////////////////////////////////////////////////////////
zoomOut()308 void cv::viz::vtkVizInteractorStyle::zoomOut()
309 {
310 FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
311 // Zoom out
312 StartDolly();
313 double factor = 10.0 * -0.2 * .5;
314 Dolly(std::pow(1.1, factor));
315 EndDolly();
316 }
317
318 //////////////////////////////////////////////////////////////////////////////////////////////
OnChar()319 void cv::viz::vtkVizInteractorStyle::OnChar()
320 {
321 FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
322
323 String key(Interactor->GetKeySym());
324 if (key.find("XF86ZoomIn") != String::npos)
325 zoomIn();
326 else if (key.find("XF86ZoomOut") != String::npos)
327 zoomOut();
328
329 switch (Interactor->GetKeyCode())
330 {
331 // // All of the options below simply exit
332 // case 'l': case 'L': case 'j': case 'J': case 'c': case 'C': case 'q': case 'Q':
333 // case 'f': case 'F': case 'g': case 'G': case 'o': case 'O': case 'u': case 'U':
334 case 'p': case 'P':
335 break;
336
337 case '+':
338 if (FlyMode)
339 MotionUserScale = std::min(16.0, MotionUserScale*2.0);
340 break;
341 case '-':
342 if (FlyMode)
343 MotionUserScale = std::max(MotionUserScale * 0.5, 0.0625);
344 break;
345
346 case 'r': case 'R': case 's': case 'S':
347 if (!Interactor->GetAltKey())
348 Superclass::OnChar();
349 break;
350 default:
351 Superclass::OnChar();
352 break;
353 }
354 }
355
356 //////////////////////////////////////////////////////////////////////////////////////////////
registerMouseCallback(void (* callback)(const MouseEvent &,void *),void * cookie)357 void cv::viz::vtkVizInteractorStyle::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
358 {
359 mouseCallback_ = callback;
360 mouse_callback_cookie_ = cookie;
361 }
362
registerKeyboardCallback(void (* callback)(const KeyboardEvent &,void *),void * cookie)363 void cv::viz::vtkVizInteractorStyle::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void *cookie)
364 {
365 keyboardCallback_ = callback;
366 keyboard_callback_cookie_ = cookie;
367 }
368
369 //////////////////////////////////////////////////////////////////////////////////////////////
getModifiers()370 int cv::viz::vtkVizInteractorStyle::getModifiers()
371 {
372 int modifiers = KeyboardEvent::NONE;
373
374 if (Interactor->GetAltKey())
375 modifiers |= KeyboardEvent::ALT;
376
377 if (Interactor->GetControlKey())
378 modifiers |= KeyboardEvent::CTRL;
379
380 if (Interactor->GetShiftKey())
381 modifiers |= KeyboardEvent::SHIFT;
382 return modifiers;
383 }
384
385 //////////////////////////////////////////////////////////////////////////////////////////////
OnKeyDown()386 void cv::viz::vtkVizInteractorStyle::OnKeyDown()
387 {
388 FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
389
390 String key(Interactor->GetKeySym());
391 if (key.find("XF86ZoomIn") != String::npos)
392 zoomIn();
393 else if (key.find("XF86ZoomOut") != String::npos)
394 zoomOut();
395 else if (key.find("F5") != String::npos)
396 {
397 FlyMode = !FlyMode;
398 std::cout << (FlyMode ? "Fly mode: on" : "Fly mode: off") << std::endl;
399 }
400
401 // Save the initial windows width/height
402 if (win_size_[0] == -1 || win_size_[1] == -1)
403 win_size_ = Vec2i(Interactor->GetRenderWindow()->GetSize());
404
405 switch (Interactor->GetKeyCode())
406 {
407 case 'a': case 'A' : KeysDown |=16; break;
408 case 'z': case 'Z' : KeysDown |=32; break;
409 case 'h': case 'H' : printHelp(); break;
410 case 'p': case 'P' : setRepresentationToPoints(); break;
411 case 'k': case 'K' : exportScene(); break;
412 case 'j': case 'J' : saveScreenshot(cv::format("screenshot-%d.png", (unsigned int)time(0))); break;
413 case 'c': case 'C' : printCameraParams(); break;
414 case '=': zoomIn(); break;
415 case 43: // KEY_PLUS
416 {
417 if (FlyMode)
418 break;
419 if (Interactor->GetAltKey())
420 zoomIn();
421 else
422 changePointsSize(+1.f);
423 break;
424 }
425 case 45: // KEY_MINUS
426 {
427 if (FlyMode)
428 break;
429 if (Interactor->GetAltKey())
430 zoomOut();
431 else
432 changePointsSize(-1.f);
433 break;
434 }
435 // Switch between maximize and original window size
436 case 'f': case 'F':
437 {
438 if (Interactor->GetAltKey())
439 toggleFullScreen();
440 break;
441 }
442 // 's'/'S' w/out ALT
443 case 's': case 'S':
444 {
445 if (Interactor->GetAltKey())
446 toggleStereo();
447 break;
448 }
449
450 case 'o': case 'O':
451 {
452 vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera();
453 cam->SetParallelProjection(!cam->GetParallelProjection());
454 Interactor->Render();
455 break;
456 }
457
458 // Overwrite the camera reset
459 case 'r': case 'R':
460 {
461 if (Interactor->GetAltKey())
462 resetViewerPose();
463 break;
464 }
465 case 'q': case 'Q':
466 Interactor->ExitCallback(); return;
467 default:
468 Superclass::OnKeyDown(); break;
469 }
470
471 KeyboardEvent event(KeyboardEvent::KEY_DOWN, Interactor->GetKeySym(), Interactor->GetKeyCode(), getModifiers());
472 if (keyboardCallback_)
473 keyboardCallback_(event, keyboard_callback_cookie_);
474
475 if (FlyMode && (KeysDown & (32+16)) == (32+16))
476 {
477 if (State == VTKIS_FORWARDFLY || State == VTKIS_REVERSEFLY)
478 StopState();
479 }
480 else if (FlyMode && (KeysDown & 32) == 32)
481 {
482 if (State == VTKIS_FORWARDFLY)
483 StopState();
484
485 if (State == VTKIS_NONE)
486 StartState(VTKIS_REVERSEFLY);
487 }
488 else if (FlyMode && (KeysDown & 16) == 16)
489 {
490 if (State == VTKIS_REVERSEFLY)
491 StopState();
492
493 if (State == VTKIS_NONE)
494 StartState(VTKIS_FORWARDFLY);
495 }
496
497 Interactor->Render();
498 }
499
500 //////////////////////////////////////////////////////////////////////////////////////////////
OnKeyUp()501 void cv::viz::vtkVizInteractorStyle::OnKeyUp()
502 {
503 KeyboardEvent event(KeyboardEvent::KEY_UP, Interactor->GetKeySym(), Interactor->GetKeyCode(), getModifiers());
504 if (keyboardCallback_)
505 keyboardCallback_(event, keyboard_callback_cookie_);
506
507 switch (Interactor->GetKeyCode())
508 {
509 case 'a': case 'A' : KeysDown &= ~16; break;
510 case 'z': case 'Z' : KeysDown &= ~32; break;
511 }
512
513 if (State == VTKIS_FORWARDFLY && (KeysDown & 16) == 0)
514 StopState();
515
516 if (State == VTKIS_REVERSEFLY && (KeysDown & 32) == 0)
517 StopState();
518
519 Superclass::OnKeyUp();
520 }
521
522 //////////////////////////////////////////////////////////////////////////////////////////////
OnMouseMove()523 void cv::viz::vtkVizInteractorStyle::OnMouseMove()
524 {
525 Vec2i p(Interactor->GetEventPosition());
526 MouseEvent event(MouseEvent::MouseMove, MouseEvent::NoButton, p, getModifiers());
527 if (mouseCallback_)
528 mouseCallback_(event, mouse_callback_cookie_);
529
530 FindPokedRenderer(p[0], p[1]);
531
532 if (State == VTKIS_ROTATE || State == VTKIS_PAN || State == VTKIS_DOLLY || State == VTKIS_SPIN)
533 {
534 switch (State)
535 {
536 case VTKIS_ROTATE: Rotate(); break;
537 case VTKIS_PAN: Pan(); break;
538 case VTKIS_DOLLY: Dolly(); break;
539 case VTKIS_SPIN: Spin(); break;
540 }
541
542 InvokeEvent(vtkCommand::InteractionEvent, NULL);
543 }
544
545 if (State == VTKIS_FORWARDFLY || State == VTKIS_REVERSEFLY)
546 {
547 vtkCamera *cam = CurrentRenderer->GetActiveCamera();
548 Vec2i thispos(Interactor->GetEventPosition());
549 Vec2i lastpos(Interactor->GetLastEventPosition());
550
551 // we want to steer by an amount proportional to window viewangle and size
552 // compute dx and dy increments relative to last mouse click
553 Vec2i size(Interactor->GetSize());
554 double scalefactor = 5*cam->GetViewAngle()/size[0];
555
556 double dx = - (thispos[0] - lastpos[0])*scalefactor*AngleStepSize;
557 double dy = (thispos[1] - lastpos[1])*scalefactor*AngleStepSize;
558
559 // Temporary until I get smooth flight working
560 DeltaPitch = dy;
561 DeltaYaw = dx;
562
563 InvokeEvent(vtkCommand::InteractionEvent, NULL);
564 }
565 }
566
567 //////////////////////////////////////////////////////////////////////////////////////////////
OnLeftButtonDown()568 void cv::viz::vtkVizInteractorStyle::OnLeftButtonDown()
569 {
570 Vec2i p(Interactor->GetEventPosition());
571 MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
572 MouseEvent event(type, MouseEvent::LeftButton, p, getModifiers());
573 if (mouseCallback_)
574 mouseCallback_(event, mouse_callback_cookie_);
575
576 FindPokedRenderer(p[0], p[1]);
577 if (!CurrentRenderer)
578 return;
579
580 GrabFocus(EventCallbackCommand);
581
582 if (FlyMode)
583 {
584 if(State == VTKIS_REVERSEFLY)
585 State = VTKIS_FORWARDFLY;
586 else
587 {
588 SetupMotionVars();
589 if (State == VTKIS_NONE)
590 StartState(VTKIS_FORWARDFLY);
591 }
592 }
593 else
594 {
595 if (Interactor->GetShiftKey())
596 {
597 if (Interactor->GetControlKey())
598 StartDolly();
599 else
600 StartPan();
601 }
602 else
603 {
604 if (Interactor->GetControlKey())
605 StartSpin();
606 else
607 StartRotate();
608 }
609 }
610 }
611
612 //////////////////////////////////////////////////////////////////////////////////////////////
OnLeftButtonUp()613 void cv::viz::vtkVizInteractorStyle::OnLeftButtonUp()
614 {
615 Vec2i p(Interactor->GetEventPosition());
616 MouseEvent event(MouseEvent::MouseButtonRelease, MouseEvent::LeftButton, p, getModifiers());
617 if (mouseCallback_)
618 mouseCallback_(event, mouse_callback_cookie_);
619
620 switch (State)
621 {
622 case VTKIS_DOLLY: EndDolly(); break;
623 case VTKIS_PAN: EndPan(); break;
624 case VTKIS_SPIN: EndSpin(); break;
625 case VTKIS_ROTATE: EndRotate(); break;
626 case VTKIS_FORWARDFLY: StopState(); break;
627 }
628
629 if (Interactor )
630 ReleaseFocus();
631 }
632
633 //////////////////////////////////////////////////////////////////////////////////////////////
OnMiddleButtonDown()634 void cv::viz::vtkVizInteractorStyle::OnMiddleButtonDown()
635 {
636 Vec2i p(Interactor->GetEventPosition());
637 MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
638 MouseEvent event(type, MouseEvent::MiddleButton, p, getModifiers());
639 if (mouseCallback_)
640 mouseCallback_(event, mouse_callback_cookie_);
641
642 FindPokedRenderer(p[0], p[1]);
643 if (!CurrentRenderer)
644 return;
645
646 GrabFocus(EventCallbackCommand);
647 StartPan();
648 }
649
650 //////////////////////////////////////////////////////////////////////////////////////////////
OnMiddleButtonUp()651 void cv::viz::vtkVizInteractorStyle::OnMiddleButtonUp()
652 {
653 Vec2i p(Interactor->GetEventPosition());
654 MouseEvent event(MouseEvent::MouseButtonRelease, MouseEvent::MiddleButton, p, getModifiers());
655 if (mouseCallback_)
656 mouseCallback_(event, mouse_callback_cookie_);
657
658 if (State == VTKIS_PAN)
659 {
660 EndPan();
661 if (Interactor)
662 ReleaseFocus();
663 }
664 }
665
666 //////////////////////////////////////////////////////////////////////////////////////////////
OnRightButtonDown()667 void cv::viz::vtkVizInteractorStyle::OnRightButtonDown()
668 {
669 Vec2i p(Interactor->GetEventPosition());
670 MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
671 MouseEvent event(type, MouseEvent::RightButton, p, getModifiers());
672 if (mouseCallback_)
673 mouseCallback_(event, mouse_callback_cookie_);
674
675 FindPokedRenderer(p[0], p[1]);
676 if (!CurrentRenderer)
677 return;
678
679 GrabFocus(EventCallbackCommand);
680
681 if (FlyMode)
682 {
683 if (State == VTKIS_FORWARDFLY)
684 State = VTKIS_REVERSEFLY;
685 else
686 {
687 SetupMotionVars();
688 if (State == VTKIS_NONE)
689 StartState(VTKIS_REVERSEFLY);
690 }
691
692 }
693 else
694 StartDolly();
695 }
696
697
698 //////////////////////////////////////////////////////////////////////////////////////////////
OnRightButtonUp()699 void cv::viz::vtkVizInteractorStyle::OnRightButtonUp()
700 {
701 Vec2i p(Interactor->GetEventPosition());
702 MouseEvent event(MouseEvent::MouseButtonRelease, MouseEvent::RightButton, p, getModifiers());
703 if (mouseCallback_)
704 mouseCallback_(event, mouse_callback_cookie_);
705
706 if(State == VTKIS_DOLLY)
707 {
708 EndDolly();
709 if (Interactor)
710 ReleaseFocus();
711 }
712
713 if (State == VTKIS_REVERSEFLY)
714 {
715 StopState();
716 if (Interactor)
717 ReleaseFocus();
718 }
719 }
720
721 //////////////////////////////////////////////////////////////////////////////////////////////
OnMouseWheelForward()722 void cv::viz::vtkVizInteractorStyle::OnMouseWheelForward()
723 {
724 Vec2i p(Interactor->GetEventPosition());
725 MouseEvent event(MouseEvent::MouseScrollUp, MouseEvent::VScroll, p, getModifiers());
726 if (mouseCallback_)
727 mouseCallback_(event, mouse_callback_cookie_);
728 if (Interactor->GetRepeatCount() && mouseCallback_)
729 mouseCallback_(event, mouse_callback_cookie_);
730
731 if (Interactor->GetAltKey())
732 {
733 // zoom
734 vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera();
735 double opening_angle = cam->GetViewAngle();
736 if (opening_angle > 15.0)
737 opening_angle -= 1.0;
738
739 cam->SetViewAngle(opening_angle);
740 cam->Modified();
741 CurrentRenderer->ResetCameraClippingRange();
742 CurrentRenderer->Modified();
743 Interactor->Render();
744 }
745 else
746 {
747 FindPokedRenderer(p[0], p[1]);
748 if (!CurrentRenderer)
749 return;
750
751 GrabFocus(EventCallbackCommand);
752 StartDolly();
753 Dolly(pow(1.1, MotionFactor * 0.2 * MouseWheelMotionFactor));
754 EndDolly();
755 ReleaseFocus();
756 }
757 }
758
759 //////////////////////////////////////////////////////////////////////////////////////////////
OnMouseWheelBackward()760 void cv::viz::vtkVizInteractorStyle::OnMouseWheelBackward()
761 {
762 Vec2i p(Interactor->GetEventPosition());
763 MouseEvent event(MouseEvent::MouseScrollDown, MouseEvent::VScroll, p, getModifiers());
764 if (mouseCallback_)
765 mouseCallback_(event, mouse_callback_cookie_);
766
767 if (Interactor->GetRepeatCount() && mouseCallback_)
768 mouseCallback_(event, mouse_callback_cookie_);
769
770 if (Interactor->GetAltKey())
771 {
772 // zoom
773 vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera();
774 double opening_angle = cam->GetViewAngle();
775 if (opening_angle < 170.0)
776 opening_angle += 1.0;
777
778 cam->SetViewAngle(opening_angle);
779 cam->Modified();
780 CurrentRenderer->ResetCameraClippingRange();
781 CurrentRenderer->Modified();
782 Interactor->Render();
783 }
784 else
785 {
786 FindPokedRenderer(p[0], p[1]);
787 if (!CurrentRenderer)
788 return;
789
790 GrabFocus(EventCallbackCommand);
791 StartDolly();
792 Dolly(pow(1.1, MotionFactor * -0.2 * MouseWheelMotionFactor));
793 EndDolly();
794 ReleaseFocus();
795 }
796 }
797
798 //////////////////////////////////////////////////////////////////////////////////////////////
OnTimer()799 void cv::viz::vtkVizInteractorStyle::OnTimer()
800 {
801 if (State == VTKIS_FORWARDFLY || State == VTKIS_REVERSEFLY)
802 Fly();
803
804 Interactor->Render();
805 }
806
807 //////////////////////////////////////////////////////////////////////////////////////////////
808
Rotate()809 void cv::viz::vtkVizInteractorStyle::Rotate()
810 {
811 if (!CurrentRenderer)
812 return;
813
814 Vec2i dxy = Vec2i(Interactor->GetEventPosition()) - Vec2i(Interactor->GetLastEventPosition());
815 Vec2i size(CurrentRenderer->GetRenderWindow()->GetSize());
816
817 double delta_elevation = -20.0 / size[1];
818 double delta_azimuth = -20.0 / size[0];
819
820 double rxf = dxy[0] * delta_azimuth * MotionFactor;
821 double ryf = dxy[1] * delta_elevation * MotionFactor;
822
823 vtkCamera *camera = CurrentRenderer->GetActiveCamera();
824 camera->Azimuth(rxf);
825 camera->Elevation(ryf);
826 camera->OrthogonalizeViewUp();
827
828 if (AutoAdjustCameraClippingRange)
829 CurrentRenderer->ResetCameraClippingRange();
830
831 if (Interactor->GetLightFollowCamera())
832 CurrentRenderer->UpdateLightsGeometryToFollowCamera();
833
834 Interactor->Render();
835 }
836
837 //////////////////////////////////////////////////////////////////////////////////////////////
Spin()838 void cv::viz::vtkVizInteractorStyle::Spin()
839 {
840 if (!CurrentRenderer)
841 return;
842
843 vtkRenderWindowInteractor *rwi = Interactor;
844
845 double *center = CurrentRenderer->GetCenter();
846
847 double newAngle = vtkMath::DegreesFromRadians( atan2( rwi->GetEventPosition()[1] - center[1], rwi->GetEventPosition()[0] - center[0] ) );
848 double oldAngle = vtkMath::DegreesFromRadians( atan2( rwi->GetLastEventPosition()[1] - center[1], rwi->GetLastEventPosition()[0] - center[0] ) );
849
850 vtkCamera *camera = CurrentRenderer->GetActiveCamera();
851 camera->Roll( newAngle - oldAngle );
852 camera->OrthogonalizeViewUp();
853
854 rwi->Render();
855 }
856
857 //////////////////////////////////////////////////////////////////////////////////////////////
Pan()858 void cv::viz::vtkVizInteractorStyle::Pan()
859 {
860 if (!CurrentRenderer)
861 return;
862
863 vtkRenderWindowInteractor *rwi = Interactor;
864
865 double viewFocus[4], focalDepth, viewPoint[3];
866 double newPickPoint[4], oldPickPoint[4], motionVector[3];
867
868 // Calculate the focal depth since we'll be using it a lot
869
870 vtkCamera *camera = CurrentRenderer->GetActiveCamera();
871 camera->GetFocalPoint(viewFocus);
872 ComputeWorldToDisplay(viewFocus[0], viewFocus[1], viewFocus[2], viewFocus);
873 focalDepth = viewFocus[2];
874
875 ComputeDisplayToWorld(rwi->GetEventPosition()[0], rwi->GetEventPosition()[1], focalDepth, newPickPoint);
876
877 // Has to recalc old mouse point since the viewport has moved, so can't move it outside the loop
878 ComputeDisplayToWorld(rwi->GetLastEventPosition()[0], rwi->GetLastEventPosition()[1], focalDepth, oldPickPoint);
879
880 // Camera motion is reversed
881 motionVector[0] = oldPickPoint[0] - newPickPoint[0];
882 motionVector[1] = oldPickPoint[1] - newPickPoint[1];
883 motionVector[2] = oldPickPoint[2] - newPickPoint[2];
884
885 camera->GetFocalPoint(viewFocus);
886 camera->GetPosition(viewPoint);
887 camera->SetFocalPoint(motionVector[0] + viewFocus[0], motionVector[1] + viewFocus[1], motionVector[2] + viewFocus[2]);
888 camera->SetPosition( motionVector[0] + viewPoint[0], motionVector[1] + viewPoint[1], motionVector[2] + viewPoint[2]);
889
890 if (Interactor->GetLightFollowCamera())
891 CurrentRenderer->UpdateLightsGeometryToFollowCamera();
892
893 Interactor->Render();
894 }
895
896 //////////////////////////////////////////////////////////////////////////////////////////////
897
Dolly()898 void cv::viz::vtkVizInteractorStyle::Dolly()
899 {
900 if (!CurrentRenderer)
901 return;
902
903 int dy = Interactor->GetEventPosition()[1] - Interactor->GetLastEventPosition()[1];
904 Dolly(pow(1.1, MotionFactor * dy / CurrentRenderer->GetCenter()[1]));
905 }
906
Dolly(double factor)907 void cv::viz::vtkVizInteractorStyle::Dolly(double factor)
908 {
909 if (!CurrentRenderer)
910 return;
911
912 vtkCamera *camera = CurrentRenderer->GetActiveCamera();
913 if (camera->GetParallelProjection())
914 camera->SetParallelScale(camera->GetParallelScale() / factor);
915 else
916 {
917 camera->Dolly(factor);
918 if (AutoAdjustCameraClippingRange)
919 CurrentRenderer->ResetCameraClippingRange();
920 }
921
922 if (Interactor->GetLightFollowCamera())
923 CurrentRenderer->UpdateLightsGeometryToFollowCamera();
924
925 Interactor->Render();
926 }
927 //////////////////////////////////////////////////////////////////////////////////////////////
928
Fly()929 void cv::viz::vtkVizInteractorStyle::Fly()
930 {
931 if (CurrentRenderer == NULL)
932 return;
933
934 if (KeysDown)
935 FlyByKey();
936 else
937 FlyByMouse();
938
939 CurrentRenderer->GetActiveCamera()->OrthogonalizeViewUp();
940
941 if (AutoAdjustCameraClippingRange)
942 CurrentRenderer->ResetCameraClippingRange();
943
944 if (Interactor->GetLightFollowCamera())
945 CurrentRenderer->UpdateLightsGeometryToFollowCamera();
946 }
947
SetupMotionVars()948 void cv::viz::vtkVizInteractorStyle::SetupMotionVars()
949 {
950 Vec6d bounds;
951 CurrentRenderer->ComputeVisiblePropBounds(bounds.val);
952
953 if ( !vtkMath::AreBoundsInitialized(bounds.val) )
954 DiagonalLength = 1.0;
955 else
956 DiagonalLength = norm(Vec3d(bounds[0], bounds[2], bounds[4]) - Vec3d(bounds[1], bounds[3], bounds[5]));
957 }
958
MotionAlongVector(const Vec3d & vector,double amount,vtkCamera * cam)959 void cv::viz::vtkVizInteractorStyle::MotionAlongVector(const Vec3d& vector, double amount, vtkCamera* cam)
960 {
961 // move camera and focus along DirectionOfProjection
962 Vec3d campos = Vec3d(cam->GetPosition()) - amount * vector;
963 Vec3d camfoc = Vec3d(cam->GetFocalPoint()) - amount * vector;
964
965 cam->SetPosition(campos.val);
966 cam->SetFocalPoint(camfoc.val);
967 }
968
FlyByMouse()969 void cv::viz::vtkVizInteractorStyle::FlyByMouse()
970 {
971 vtkCamera* cam = CurrentRenderer->GetActiveCamera();
972 double speed = DiagonalLength * MotionStepSize * MotionUserScale;
973 speed = speed * ( Interactor->GetShiftKey() ? MotionAccelerationFactor : 1.0);
974
975 // Sidestep
976 if (Interactor->GetAltKey())
977 {
978 if (DeltaYaw!=0.0)
979 {
980 vtkMatrix4x4 *vtm = cam->GetViewTransformMatrix();
981 Vec3d a_vector(vtm->GetElement(0,0), vtm->GetElement(0,1), vtm->GetElement(0,2));
982
983 MotionAlongVector(a_vector, -DeltaYaw*speed, cam);
984 }
985 if (DeltaPitch!=0.0)
986 {
987 Vec3d a_vector(cam->GetViewUp());
988 MotionAlongVector(a_vector, DeltaPitch*speed, cam);
989 }
990 }
991 else
992 {
993 cam->Yaw(DeltaYaw);
994 cam->Pitch(DeltaPitch);
995 DeltaYaw = 0;
996 DeltaPitch = 0;
997 }
998 //
999 if (!Interactor->GetControlKey())
1000 {
1001 Vec3d a_vector(cam->GetDirectionOfProjection()); // reversed (use -speed)
1002 switch (State)
1003 {
1004 case VTKIS_FORWARDFLY: MotionAlongVector(a_vector, -speed, cam); break;
1005 case VTKIS_REVERSEFLY: MotionAlongVector(a_vector, speed, cam); break;
1006 }
1007 }
1008 }
1009
FlyByKey()1010 void cv::viz::vtkVizInteractorStyle::FlyByKey()
1011 {
1012 vtkCamera* cam = CurrentRenderer->GetActiveCamera();
1013
1014 double speed = DiagonalLength * MotionStepSize * MotionUserScale;
1015 speed = speed * ( Interactor->GetShiftKey() ? MotionAccelerationFactor : 1.0);
1016
1017 // Left and right
1018 if (Interactor->GetAltKey())
1019 { // Sidestep
1020 vtkMatrix4x4 *vtm = cam->GetViewTransformMatrix();
1021 Vec3d a_vector(vtm->GetElement(0,0), vtm->GetElement(0,1), vtm->GetElement(0,2));
1022
1023 if (KeysDown & 1)
1024 MotionAlongVector(a_vector, -speed, cam);
1025
1026 if (KeysDown & 2)
1027 MotionAlongVector(a_vector, speed, cam);
1028 }
1029 else
1030 {
1031 if (KeysDown & 1)
1032 cam->Yaw( AngleStepSize);
1033
1034 if (KeysDown & 2)
1035 cam->Yaw(-AngleStepSize);
1036 }
1037
1038 // Up and Down
1039 if (Interactor->GetControlKey())
1040 { // Sidestep
1041 Vec3d a_vector = Vec3d(cam->GetViewUp());
1042 if (KeysDown & 4)
1043 MotionAlongVector(a_vector,-speed, cam);
1044
1045 if (KeysDown & 8)
1046 MotionAlongVector(a_vector, speed, cam);
1047 }
1048 else
1049 {
1050 if (KeysDown & 4)
1051 cam->Pitch(-AngleStepSize);
1052
1053 if (KeysDown & 8)
1054 cam->Pitch( AngleStepSize);
1055 }
1056
1057 // forward and backward
1058 Vec3d a_vector(cam->GetDirectionOfProjection());
1059 if (KeysDown & 16)
1060 MotionAlongVector(a_vector, speed, cam);
1061
1062 if (KeysDown & 32)
1063 MotionAlongVector(a_vector,-speed, cam);
1064 }
1065
1066 //////////////////////////////////////////////////////////////////////////////////////////////
1067
PrintSelf(ostream & os,vtkIndent indent)1068 void cv::viz::vtkVizInteractorStyle::PrintSelf(ostream& os, vtkIndent indent)
1069 {
1070 Superclass::PrintSelf(os, indent);
1071 os << indent << "MotionFactor: " << MotionFactor << "\n";
1072 os << indent << "MotionStepSize: " << MotionStepSize << "\n";
1073 os << indent << "MotionAccelerationFactor: "<< MotionAccelerationFactor << "\n";
1074 os << indent << "AngleStepSize: " << AngleStepSize << "\n";
1075 os << indent << "MotionUserScale: "<< MotionUserScale << "\n";
1076 }
1077