MRPT  2.0.3
CDisplayWindow3D.cpp
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | https://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2020, Individual contributors, see AUTHORS file |
6  | See: https://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See: https://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 
10 #include "gui-precomp.h" // Precompiled headers
11 
12 #include <mrpt/config.h>
13 
15 #include <mrpt/img/CImage.h>
16 #include <mrpt/system/CTicTac.h>
17 
18 #include <mrpt/gui/WxSubsystem.h>
19 #include <mrpt/gui/WxUtils.h>
20 
21 #if MRPT_HAS_OPENGL_GLUT
22 #ifdef _WIN32
23 // Windows:
24 #include <windows.h>
25 #endif
26 
27 #ifdef __APPLE__
28 #include <GLUT/glut.h>
29 #include <OpenGL/gl.h>
30 #include <OpenGL/glu.h>
31 #else
32 #include <GL/gl.h>
33 #include <GL/glu.h>
34 #include <GL/glut.h>
35 #ifdef HAVE_FREEGLUT_EXT_H
36 #include <GL/freeglut_ext.h>
37 #endif
38 #endif
39 #endif
40 
41 using namespace mrpt;
42 using namespace mrpt::gui;
43 using namespace mrpt::opengl;
44 using namespace mrpt::math;
45 using namespace mrpt::img;
46 using namespace std;
47 
48 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
49 
50 #if !wxUSE_GLCANVAS
51 #error "OpenGL required: set wxUSE_GLCANVAS to 1 and rebuild wxWidgets"
52 #endif
53 
55 
56 namespace mrpt::gui
57 {
58 class CMyGLCanvas_DisplayWindow3D : public mrpt::gui::CWxGLCanvasBase
59 {
60  public:
61  CMyGLCanvas_DisplayWindow3D(
62  CDisplayWindow3D* win3D, wxWindow* parent, wxWindowID id = wxID_ANY,
63  const wxPoint& pos = wxDefaultPosition,
64  const wxSize& size = wxDefaultSize, long style = 0,
65  const wxString& name = _T("CMyGLCanvas_DisplayWindow3D"));
66 
67  ~CMyGLCanvas_DisplayWindow3D() override;
68 
69  CDisplayWindow3D* m_win3D = nullptr;
70 
71  void OnCharCustom(wxKeyEvent& event) override;
72  void OnMouseDown(wxMouseEvent& event);
73  void OnMouseMove(wxMouseEvent& event);
74 
75  void OnPreRender() override;
76  void OnPostRender() override;
77  void OnPostRenderSwapBuffers(double At, wxPaintDC& dc) override;
78 
79  static void display3D_processKeyEvent(
80  CDisplayWindow3D* m_win3D, wxKeyEvent& ev);
81 };
82 } // namespace mrpt::gui
83 
84 CMyGLCanvas_DisplayWindow3D::CMyGLCanvas_DisplayWindow3D(
85  CDisplayWindow3D* win3D, wxWindow* parent, wxWindowID id,
86  const wxPoint& pos, const wxSize& size, long style, const wxString& name)
87  : CWxGLCanvasBase(parent, id, pos, size, style, name), m_win3D(win3D)
88 {
89  this->Bind(wxEVT_CHAR, &CMyGLCanvas_DisplayWindow3D::OnCharCustom, this);
90  this->Bind(
91  wxEVT_CHAR_HOOK, &CMyGLCanvas_DisplayWindow3D::OnCharCustom, this);
92  this->Bind(
93  wxEVT_LEFT_DOWN, &CMyGLCanvas_DisplayWindow3D::OnMouseDown, this);
94  this->Bind(
95  wxEVT_RIGHT_DOWN, &CMyGLCanvas_DisplayWindow3D::OnMouseDown, this);
96  this->Bind(wxEVT_MOTION, &CMyGLCanvas_DisplayWindow3D::OnMouseMove, this);
97 }
98 
99 void CMyGLCanvas_DisplayWindow3D::display3D_processKeyEvent(
100  CDisplayWindow3D* m_win3D, wxKeyEvent& ev)
101 {
102  if (m_win3D)
103  {
104  if (ev.AltDown() && ev.GetKeyCode() == MRPTK_RETURN)
105  {
107  m_win3D->m_lastFullScreen, mrpt::system::now()) > 0.2)
108  {
109  m_win3D->m_lastFullScreen = mrpt::system::now();
110  cout << "[CDisplayWindow3D] Switching fullscreen...\n";
111  auto* win = (C3DWindowDialog*)m_win3D->m_hwnd.get();
112  if (win)
113  {
114  win->ShowFullScreen(!win->IsFullScreen());
115  }
116  }
117  // Alt+Enter: Don't notify on this key stroke, since if we're
118  // switching to fullscreen
119  // and the user is waiting for a key to close the window, a runtime
120  // crash will occur,
121  // so return now:
122  return;
123  }
124 
125  const int code = ev.GetKeyCode();
127 
128  m_win3D->m_keyPushedCode = code;
129  m_win3D->m_keyPushedModifier = mod;
130  m_win3D->m_keyPushed = true;
131 
132  // Send the event:
133  try
134  {
135  m_win3D->publishEvent(mrptEventWindowChar(m_win3D, code, mod));
136  }
137  catch (...)
138  {
139  }
140  }
141  // ev.Skip(); // Pass the event to whoever else.
142 }
143 
144 void CMyGLCanvas_DisplayWindow3D::OnCharCustom(wxKeyEvent& ev)
145 {
146  CMyGLCanvas_DisplayWindow3D::display3D_processKeyEvent(m_win3D, ev);
147 }
148 
149 void CMyGLCanvas_DisplayWindow3D::OnMouseDown(wxMouseEvent& event)
150 {
151  // Send the event:
152  if (m_win3D && m_win3D->hasSubscribers())
153  {
154  try
155  {
157  m_win3D, TPixelCoord(event.GetX(), event.GetY()),
158  event.LeftDown(), event.RightDown()));
159  }
160  catch (...)
161  {
162  }
163  }
164 
165  event.Skip(); // so it's processed by the wx system!
166 }
167 
168 void CMyGLCanvas_DisplayWindow3D::OnMouseMove(wxMouseEvent& event)
169 {
170  // Send the event:
171  if (m_win3D && m_win3D->hasSubscribers())
172  {
173  try
174  {
176  m_win3D, TPixelCoord(event.GetX(), event.GetY()),
177  event.LeftDown(), event.RightDown()));
178  }
179  catch (...)
180  {
181  }
182  }
183 
184  event.Skip(); // so it's processed by the wx system!
185 }
186 
187 CMyGLCanvas_DisplayWindow3D::~CMyGLCanvas_DisplayWindow3D()
188 {
189  // Ensure all OpenGL resources are freed before the opengl context is gone:
190  if (getOpenGLSceneRef()) getOpenGLSceneRef()->unloadShaders();
191 
192  // Unbind all objects, free all buffers:
193  auto& scene = getOpenGLSceneRef();
194  if (scene) scene->freeOpenGLResources();
195 }
196 
197 void CMyGLCanvas_DisplayWindow3D::OnPreRender()
198 {
199  auto& openGLSceneRef = getOpenGLSceneRef();
200  if (openGLSceneRef) openGLSceneRef.reset();
201 
202  COpenGLScene::Ptr& ptrScene = m_win3D->get3DSceneAndLock();
203  if (ptrScene) openGLSceneRef = ptrScene;
204 }
205 
206 void CMyGLCanvas_DisplayWindow3D::OnPostRender()
207 {
208  m_win3D->unlockAccess3DScene();
209 }
210 
211 void CMyGLCanvas_DisplayWindow3D::OnPostRenderSwapBuffers(
212  double At, wxPaintDC& dc)
213 {
214  if (m_win3D) m_win3D->internal_setRenderingFPS(At > 0 ? 1.0 / At : 1e9);
215 
216  // If we are requested to do so, grab images to disk as they are rendered:
217  string grabFile;
218  if (m_win3D) grabFile = m_win3D->grabImageGetNextFile();
219  if (m_win3D && (!grabFile.empty() || m_win3D->isCapturingImgs()))
220  {
221  int w, h;
222  dc.GetSize(&w, &h);
223 
224  // Save image directly from OpenGL - It could also use 4 channels and
225  // save with GL_BGRA_EXT
226  auto frame = CImage::Create(w, h, mrpt::img::CH_RGB);
227 
228  glPixelStorei(GL_PACK_ALIGNMENT, 1);
229  glPixelStorei(GL_PACK_ROW_LENGTH, 0);
230 
231  glReadBuffer(GL_FRONT);
232  glReadPixels(0, 0, w, h, GL_BGR_EXT, GL_UNSIGNED_BYTE, (*frame)(0, 0));
233  frame->flipVertical();
234 
235  if (!grabFile.empty())
236  {
237  frame->saveToFile(grabFile);
238  m_win3D->internal_emitGrabImageEvent(grabFile);
239  }
240 
241  if (m_win3D->isCapturingImgs())
242  {
243  {
244  std::lock_guard<std::mutex> lock(
245  m_win3D->m_last_captured_img_cs);
246  m_win3D->m_last_captured_img = frame;
247  frame.reset();
248  }
249  }
250  }
251 }
252 
253 #endif // Wx + OpenGL
254 
255 #if MRPT_HAS_WXWIDGETS
256 
257 BEGIN_EVENT_TABLE(C3DWindowDialog, wxFrame)
258 
259 END_EVENT_TABLE()
260 
261 const long C3DWindowDialog::ID_MENUITEM1 = wxNewId();
262 const long C3DWindowDialog::ID_MENUITEM2 = wxNewId();
263 
265  CDisplayWindow3D* win3D, WxSubsystem::CWXMainFrame* parent, wxWindowID id,
266  const std::string& caption, wxSize initialSize)
267  : m_win3D(win3D), m_mainFrame(parent)
268 {
269 #if MRPT_HAS_OPENGL_GLUT
270 
271  Create(
272  parent, id, caption.c_str(), wxDefaultPosition, initialSize,
273  wxDEFAULT_FRAME_STYLE, _T("id"));
274 
275  wxIcon FrameIcon;
276  FrameIcon.CopyFromBitmap(mrpt::gui::WxSubsystem::getMRPTDefaultIcon());
277  SetIcon(FrameIcon);
278 
279  // Create the wxCanvas object:
280  m_canvas = new CMyGLCanvas_DisplayWindow3D(
281  win3D, this, wxID_ANY, wxDefaultPosition, wxDefaultSize);
282 
283  // Events:
284  this->Bind(wxEVT_CLOSE_WINDOW, &C3DWindowDialog::OnClose, this);
285  this->Bind(wxEVT_MENU, &C3DWindowDialog::OnMenuClose, this, ID_MENUITEM1);
286  this->Bind(wxEVT_MENU, &C3DWindowDialog::OnMenuAbout, this, ID_MENUITEM2);
287  this->Bind(wxEVT_CHAR, &C3DWindowDialog::OnChar, this);
288  this->Bind(wxEVT_SIZE, &C3DWindowDialog::OnResize, this);
289 
290  // Increment number of windows:
291  // int winCount =
293 // cout << "[C3DWindowDialog] Notifying new window: " << winCount << endl;
294 #else
295  THROW_EXCEPTION("MRPT was compiled without OpenGL support");
296 #endif
297  // this->Iconize(false);
298 }
299 
300 // Destructor
302 {
303  // cout << "[C3DWindowDialog::~C3DWindowDialog]" << endl;
304 }
305 
306 // OnClose event:
307 void C3DWindowDialog::OnClose(wxCloseEvent& event)
308 {
309  // Send the event:
310  bool allow_close = true;
311  try
312  {
313  mrptEventWindowClosed ev(m_win3D, true /* allow close */);
314  m_win3D->publishEvent(ev);
315  allow_close = ev.allow_close;
316  }
317  catch (...)
318  {
319  }
320  if (!allow_close) return; // Don't process this close event.
321 
322  // cout << "[C3DWindowDialog::OnClose]" << endl;
323  // Set the m_hwnd=nullptr in our parent object.
325 
326  // Decrement number of windows:
328 
329  // Signal we are destroyed:
330  m_win3D->m_windowDestroyed.set_value();
331 
332  event.Skip(); // keep processing by parent classes.
333 }
334 
335 // Menu: Close
336 void C3DWindowDialog::OnMenuClose(wxCommandEvent& event) { Close(); }
337 // Menu: About
338 void C3DWindowDialog::OnMenuAbout(wxCommandEvent& event)
339 {
340  ::wxMessageBox(
341  _("3D Scene viewer\n Class gui::CDisplayWindow3D\n MRPT C++ library"),
342  _("About..."));
343 }
344 
345 void C3DWindowDialog::OnChar(wxKeyEvent& ev)
346 {
347 #if MRPT_HAS_OPENGL_GLUT
348  CMyGLCanvas_DisplayWindow3D::display3D_processKeyEvent(m_win3D, ev);
349 #endif
350 }
351 
352 void C3DWindowDialog::OnResize(wxSizeEvent& event)
353 {
354 #if MRPT_HAS_OPENGL_GLUT
355  // Send the event:
356  if (m_win3D)
357  {
358  try
359  {
361  m_win3D, event.GetSize().GetWidth(),
362  event.GetSize().GetHeight()));
363  }
364  catch (...)
365  {
366  }
367  }
368  event.Skip(); // so it's processed by the wx system!
369 #endif
370 }
371 
372 #endif // MRPT_HAS_WXWIDGETS
373 
374 /*---------------------------------------------------------------
375  Constructor
376  ---------------------------------------------------------------*/
378  const std::string& windowCaption, unsigned int initialWindowWidth,
379  unsigned int initialWindowHeight)
380  : CBaseGUIWindow(static_cast<void*>(this), 300, 399, windowCaption),
381  m_lastFullScreen(mrpt::system::now())
382 {
383  m_3Dscene = COpenGLScene::Create();
384  CBaseGUIWindow::createWxWindow(initialWindowWidth, initialWindowHeight);
385 }
386 
388  const std::string& windowCaption, unsigned int initialWindowWidth,
389  unsigned int initialWindowHeight)
390 {
391  return std::make_shared<CDisplayWindow3D>(
392  windowCaption, initialWindowWidth, initialWindowHeight);
393 }
394 /*---------------------------------------------------------------
395  Destructor
396  ---------------------------------------------------------------*/
398 {
399  // get lock so we make sure nobody else is touching the window right now.
400  bool lock_ok = m_csAccess3DScene.try_lock_for(std::chrono::seconds(2));
401  m_csAccess3DScene.unlock();
402 
404 
405  if (!lock_ok)
406  std::cerr
407  << "[~CDisplayWindow3D] Warning: Timeout acquiring mutex lock.\n";
408 }
409 
410 /*---------------------------------------------------------------
411  resize
412  ---------------------------------------------------------------*/
414  [[maybe_unused]] unsigned int width, [[maybe_unused]] unsigned int height)
415 {
416 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
417  if (!isOpen())
418  {
419  cerr << "[CDisplayWindow3D::setPos] Window closed!: " << m_caption
420  << endl;
421  return;
422  }
423 
424  // Send a request to destroy this object:
425  auto* REQ = new WxSubsystem::TRequestToWxMainThread[1];
426  REQ->source3D = this;
427  REQ->OPCODE = 303;
428  REQ->x = width;
429  REQ->y = height;
431 #endif
432 }
433 
434 /*---------------------------------------------------------------
435  setPos
436  ---------------------------------------------------------------*/
437 void CDisplayWindow3D::setPos([[maybe_unused]] int x, [[maybe_unused]] int y)
438 {
439 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
440  if (!isOpen())
441  {
442  cerr << "[CDisplayWindow3D::setPos] Window closed!: " << m_caption
443  << endl;
444  return;
445  }
446 
447  // Send a request to destroy this object:
448  auto* REQ = new WxSubsystem::TRequestToWxMainThread[1];
449  REQ->source3D = this;
450  REQ->OPCODE = 302;
451  REQ->x = x;
452  REQ->y = y;
454 #endif
455 }
456 
457 /*---------------------------------------------------------------
458  setWindowTitle
459  ---------------------------------------------------------------*/
460 void CDisplayWindow3D::setWindowTitle([[maybe_unused]] const std::string& str)
461 {
462 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
463  if (!isOpen())
464  {
465  cerr << "[CDisplayWindow3D::setWindowTitle] Window closed!: "
466  << m_caption << endl;
467  return;
468  }
469 
470  // Send a request to destroy this object:
471  auto* REQ = new WxSubsystem::TRequestToWxMainThread[1];
472  REQ->source3D = this;
473  REQ->OPCODE = 304;
474  REQ->str = str;
476 #endif
477 }
478 
480 {
481  m_csAccess3DScene.lock();
482  return m_3Dscene;
483 }
484 
486 
488 {
489 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
490  auto* win = (C3DWindowDialog*)m_hwnd.get();
491  if (win)
492  {
493  // win->Refresh(false); // Do not erase background
494  // We must do this from the wx thread!
495 
496  // Send refresh request:
497  auto* REQ = new WxSubsystem::TRequestToWxMainThread[1];
498  REQ->source3D = this;
499  REQ->OPCODE = 350;
501  }
502 #endif
503 }
504 
505 /*---------------------------------------------------------------
506  setCameraElevationDeg
507  ---------------------------------------------------------------*/
508 void CDisplayWindow3D::setCameraElevationDeg([[maybe_unused]] float deg)
509 {
510 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
511  auto* win = (C3DWindowDialog*)m_hwnd.get();
512  if (win) win->m_canvas->setElevationDegrees(deg);
513 #endif
514 }
515 
516 void CDisplayWindow3D::useCameraFromScene([[maybe_unused]] bool useIt)
517 {
518 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
519  auto* win = (C3DWindowDialog*)m_hwnd.get();
520  if (win) win->m_canvas->setUseCameraFromScene(useIt);
521 #endif
522 }
523 
524 /*---------------------------------------------------------------
525  setCameraAzimuthDeg
526  ---------------------------------------------------------------*/
527 void CDisplayWindow3D::setCameraAzimuthDeg([[maybe_unused]] float deg)
528 {
529 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
530  auto* win = (C3DWindowDialog*)m_hwnd.get();
531  if (win) win->m_canvas->setAzimuthDegrees(deg);
532 #endif
533 }
534 
535 /*---------------------------------------------------------------
536  setCameraPointingToPoint
537  ---------------------------------------------------------------*/
539  [[maybe_unused]] float x, [[maybe_unused]] float y,
540  [[maybe_unused]] float z)
541 {
542 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
543  auto* win = (C3DWindowDialog*)m_hwnd.get();
544  if (win)
545  {
546  win->m_canvas->setCameraPointing(x, y, z);
547  }
548 #endif
549 }
550 
551 /*---------------------------------------------------------------
552  setCameraZoom
553  ---------------------------------------------------------------*/
554 void CDisplayWindow3D::setCameraZoom([[maybe_unused]] float zoom)
555 {
556 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
557  auto* win = (C3DWindowDialog*)m_hwnd.get();
558  if (win) win->m_canvas->setZoomDistance(zoom);
559 #endif
560 }
561 
562 /*---------------------------------------------------------------
563  setCameraProjective
564  ---------------------------------------------------------------*/
565 void CDisplayWindow3D::setCameraProjective([[maybe_unused]] bool isProjective)
566 {
567 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
568  auto* win = (C3DWindowDialog*)m_hwnd.get();
569  if (win) win->m_canvas->setCameraProjective(isProjective);
570 #endif
571 }
572 
573 void CDisplayWindow3D::setMinRange(float new_min)
574 {
575  if (m_3Dscene)
576  {
578  m_3Dscene->getViewport("main");
579  if (gl_view)
580  {
581  float m, M;
582  gl_view->getViewportClipDistances(m, M);
583  gl_view->setViewportClipDistances(new_min, M);
584  }
585  }
586 }
587 void CDisplayWindow3D::setMaxRange(float new_max)
588 {
589  if (m_3Dscene)
590  {
592  m_3Dscene->getViewport("main");
593  if (gl_view)
594  {
595  float m, M;
596  gl_view->getViewportClipDistances(m, M);
597  gl_view->setViewportClipDistances(m, new_max);
598  }
599  }
600 }
601 
603 {
604 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
605  auto* win = (C3DWindowDialog*)m_hwnd.get();
606  if (win) return win->m_canvas->cameraFOV();
607 #endif
608  return .0f;
609 }
610 
612 {
613 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
614  auto* win = (C3DWindowDialog*)m_hwnd.get();
615  if (win) win->m_canvas->setCameraFOV(v);
616 #endif
617 }
618 
619 /*---------------------------------------------------------------
620  getCameraElevationDeg
621  ---------------------------------------------------------------*/
623 {
624 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
625  const auto* win = (const C3DWindowDialog*)m_hwnd.get();
626  return win ? win->m_canvas->getElevationDegrees() : 0;
627 #else
628  return 0;
629 #endif
630 }
631 
632 /*---------------------------------------------------------------
633  getCameraAzimuthDeg
634  ---------------------------------------------------------------*/
636 {
637 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
638  const auto* win = (const C3DWindowDialog*)m_hwnd.get();
639  return win ? win->m_canvas->getAzimuthDegrees() : 0;
640 #else
641  return 0;
642 #endif
643 }
644 
645 /*---------------------------------------------------------------
646  getCameraPointingToPoint
647  ---------------------------------------------------------------*/
649  [[maybe_unused]] float& x, [[maybe_unused]] float& y,
650  [[maybe_unused]] float& z) const
651 {
652 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
653  const auto* win = (const C3DWindowDialog*)m_hwnd.get();
654  if (win)
655  {
656  x = win->m_canvas->getCameraPointingX();
657  y = win->m_canvas->getCameraPointingY();
658  z = win->m_canvas->getCameraPointingZ();
659  }
660  else
661  x = y = z = 0;
662 #endif
663 }
664 
665 /*---------------------------------------------------------------
666  getCameraZoom
667  ---------------------------------------------------------------*/
669 {
670 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
671  const auto* win = (const C3DWindowDialog*)m_hwnd.get();
672  return win ? win->m_canvas->getZoomDistance() : 0;
673 #else
674  return 0;
675 #endif
676 }
677 
678 /*---------------------------------------------------------------
679  isCameraProjective
680  ---------------------------------------------------------------*/
682 {
683 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
684  const auto* win = (const C3DWindowDialog*)m_hwnd.get();
685  return win ? win->m_canvas->isCameraProjective() : true;
686 #else
687  return true;
688 #endif
689 }
690 
691 /*---------------------------------------------------------------
692  getLastMousePosition
693  ---------------------------------------------------------------*/
695  [[maybe_unused]] int& x, [[maybe_unused]] int& y) const
696 {
697 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
698  const auto* win = (const C3DWindowDialog*)m_hwnd.get();
699  if (!win) return false;
700  win->m_canvas->getLastMousePosition(x, y);
701  return true;
702 #else
703  return false;
704 #endif
705 }
706 
707 /*---------------------------------------------------------------
708  getLastMousePositionRay
709  ---------------------------------------------------------------*/
711 {
712  int x, y;
713  if (getLastMousePosition(x, y))
714  {
715  std::lock_guard<std::recursive_timed_mutex> lck(m_csAccess3DScene);
716  m_3Dscene->getViewport("main")->get3DRayForPixelCoord(x, y, ray);
717  return true;
718  }
719  else
720  return false;
721 }
722 
723 /*---------------------------------------------------------------
724  setCursorCross
725  ---------------------------------------------------------------*/
726 void CDisplayWindow3D::setCursorCross([[maybe_unused]] bool cursorIsCross)
727 {
728 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
729  const auto* win = (const C3DWindowDialog*)m_hwnd.get();
730  if (!win) return;
731  win->m_canvas->SetCursor(
732  *(cursorIsCross ? wxCROSS_CURSOR : wxSTANDARD_CURSOR));
733 #endif
734 }
735 
736 /*---------------------------------------------------------------
737  grabImagesStart
738  ---------------------------------------------------------------*/
739 void CDisplayWindow3D::grabImagesStart(const std::string& grab_imgs_prefix)
740 {
741  m_grab_imgs_prefix = grab_imgs_prefix;
742  m_grab_imgs_idx = 0;
743 }
744 
745 /*---------------------------------------------------------------
746  grabImagesStop
747  ---------------------------------------------------------------*/
749 /*---------------------------------------------------------------
750  grabImageGetNextFile
751  ---------------------------------------------------------------*/
753 {
754  if (m_grab_imgs_prefix.empty())
755  return string();
756  else
757  return format(
758  "%s%06u.png", m_grab_imgs_prefix.c_str(), m_grab_imgs_idx++);
759 }
760 
761 /*---------------------------------------------------------------
762  captureImagesStart
763  ---------------------------------------------------------------*/
765 /*---------------------------------------------------------------
766  captureImagesStop
767  ---------------------------------------------------------------*/
769 /*---------------------------------------------------------------
770  getLastWindowImage
771  ---------------------------------------------------------------*/
773 {
774  bool ret;
775 
776  {
777  std::lock_guard<std::mutex> lock(m_last_captured_img_cs);
779  {
780  out_img = *m_last_captured_img; // Copy the full image
781  ret = true;
782  }
783  else
784  ret = false;
785  }
786  return ret;
787 }
788 
789 /*---------------------------------------------------------------
790  getLastWindowImagePtr
791  ---------------------------------------------------------------*/
793 {
794  std::lock_guard<std::mutex> lock(m_last_captured_img_cs);
795  return m_last_captured_img;
796 }
797 
799 {
800  const double ALPHA = 0.99;
801  m_last_FPS = ALPHA * m_last_FPS + (1 - ALPHA) * FPS;
802 }
803 
804 // Called by CMyGLCanvas_DisplayWindow3D::OnPostRenderSwapBuffers
806 {
807  const mrptEvent3DWindowGrabImageFile ev(this, fil);
808  publishEvent(ev);
809 }
810 
811 // Returns the "main" viewport of the scene.
813 {
814  std::lock_guard<std::recursive_timed_mutex> lck(m_csAccess3DScene);
815  return m_3Dscene->getViewport("main");
816 }
817 
819 {
820  std::lock_guard<std::recursive_timed_mutex> lck(m_csAccess3DScene);
821  m_3Dscene->getViewport("main")->setImageView(img);
822 }
823 
825 {
826  std::lock_guard<std::recursive_timed_mutex> lck(m_csAccess3DScene);
827  m_3Dscene->getViewport("main")->setImageView(std::move(img));
828 }
829 
832  : m_win(win)
833 {
834  out_scene_ptr = m_win.get3DSceneAndLock();
835 }
837  : m_win(win)
838 {
840 }
842 {
844 }
mrpt::gui::CDisplayWindow3DLocker::m_win
CDisplayWindow3D & m_win
Definition: CDisplayWindow3D.h:451
mrpt::gui::mrptEventWindowClosed::allow_close
bool allow_close
Definition: CBaseGUIWindow.h:295
mrpt::gui::CDisplayWindow3D::setFOV
void setFOV(float v)
Changes the camera field of view (in degrees) (used for gluPerspective).
Definition: CDisplayWindow3D.cpp:611
mrpt::gui::CDisplayWindow3D::internal_emitGrabImageEvent
void internal_emitGrabImageEvent(const std::string &fil)
called by CMyGLCanvas_DisplayWindow3D::OnPostRenderSwapBuffers
Definition: CDisplayWindow3D.cpp:805
mrpt::gui::CDisplayWindow3D::setCursorCross
void setCursorCross(bool cursorIsCross) override
Set cursor style to default (cursorIsCross=false) or to a cross (cursorIsCross=true)
Definition: CDisplayWindow3D.cpp:726
mrpt::system::timeDifference
double timeDifference(const mrpt::system::TTimeStamp t_first, const mrpt::system::TTimeStamp t_later)
Returns the time difference from t1 to t2 (positive if t2 is posterior to t1), in seconds
Definition: datetime.h:123
mrpt::gui::CDisplayWindow3D::isCameraProjective
bool isCameraProjective() const
Sets the camera as projective, or orthogonal.
Definition: CDisplayWindow3D.cpp:681
mrpt::gui::CDisplayWindow3D::getFOV
float getFOV() const
Return the camera field of view (in degrees) (used for gluPerspective)
Definition: CDisplayWindow3D.cpp:602
mrpt::gui::CDisplayWindow3D::getCameraElevationDeg
float getCameraElevationDeg() const
Get camera parameters programmatically.
Definition: CDisplayWindow3D.cpp:622
mrpt::gui::CBaseGUIWindow::createWxWindow
void createWxWindow(unsigned int initialWidth, unsigned int initialHeight)
Must be called by child classes just within the constructor.
Definition: CBaseGUIWindow.cpp:42
mrpt::gui::CBaseGUIWindow::m_keyPushedModifier
std::atomic< mrptKeyModifier > m_keyPushedModifier
Definition: CBaseGUIWindow.h:67
mrpt::gui::C3DWindowDialog::~C3DWindowDialog
~C3DWindowDialog() override
Definition: CDisplayWindow3D.cpp:301
mrpt::gui::CDisplayWindow3D::m_3Dscene
mrpt::opengl::COpenGLScene::Ptr m_3Dscene
Internal OpenGL object (see general discussion in about usage of this object)
Definition: CDisplayWindow3D.h:129
mrpt::gui::CDisplayWindow3D::grabImagesStart
void grabImagesStart(const std::string &grab_imgs_prefix=std::string("video_"))
Start to save rendered images to disk.
Definition: CDisplayWindow3D.cpp:739
mrpt::gui::CDisplayWindow3D::isCapturingImgs
bool isCapturingImgs() const
Definition: CDisplayWindow3D.h:306
mrpt::gui::CDisplayWindow3D::Create
static CDisplayWindow3D::Ptr Create(const std::string &windowCaption, unsigned int initialWindowWidth=400, unsigned int initialWindowHeight=300)
Class factory returning a smart pointer.
Definition: CDisplayWindow3D.cpp:387
mrpt::gui::CDisplayWindow3D::CDisplayWindow3D
CDisplayWindow3D(const std::string &windowCaption=std::string(), unsigned int initialWindowWidth=400, unsigned int initialWindowHeight=300)
Constructor.
Definition: CDisplayWindow3D.cpp:377
mrpt::gui::CDisplayWindow3D::setWindowTitle
void setWindowTitle(const std::string &str) override
Changes the window title.
Definition: CDisplayWindow3D.cpp:460
mrpt::gui::CDisplayWindow3D::setMinRange
void setMinRange(float new_min)
Changes the camera min clip range (z) (used for gluPerspective).
Definition: CDisplayWindow3D.cpp:573
mrpt::gui::WxSubsystem::pushPendingWxRequest
static void pushPendingWxRequest(TRequestToWxMainThread *data)
Thread-safe method to insert a new pending request (The memory must be dinamically allocated with "ne...
Definition: WxSubsystem.cpp:256
mrpt::system::CObservable::publishEvent
void publishEvent(const mrptEvent &e) const
Called when you want this object to emit an event to all the observers currently subscribed to this o...
Definition: CObservable.cpp:57
mrpt::gui::C3DWindowDialog::OnMenuAbout
void OnMenuAbout(wxCommandEvent &event)
Definition: CDisplayWindow3D.cpp:338
mrpt::gui::CBaseGUIWindow::m_keyPushedCode
std::atomic_int m_keyPushedCode
Definition: CBaseGUIWindow.h:66
WxSubsystem.h
mrpt::gui::C3DWindowDialog::OnClose
void OnClose(wxCloseEvent &event)
Definition: CDisplayWindow3D.cpp:307
mrpt::img::CImage::Ptr
std::shared_ptr< mrpt::img ::CImage > Ptr
Definition: img/CImage.h:150
mrpt::gui::CDisplayWindow3D::getCameraPointingToPoint
void getCameraPointingToPoint(float &x, float &y, float &z) const
Get camera parameters programmatically.
Definition: CDisplayWindow3D.cpp:648
mrpt::system::now
mrpt::system::TTimeStamp now()
A shortcut for system::getCurrentTime.
Definition: datetime.h:86
mrpt::gui::CDisplayWindow3D::~CDisplayWindow3D
~CDisplayWindow3D() override
Destructor.
Definition: CDisplayWindow3D.cpp:397
mrpt::gui::CDisplayWindow3D::m_grab_imgs_prefix
std::string m_grab_imgs_prefix
Definition: CDisplayWindow3D.h:139
mrpt::gui::CDisplayWindow3D::setCameraZoom
void setCameraZoom(float zoom)
Changes the camera parameters programmatically.
Definition: CDisplayWindow3D.cpp:554
mrpt::gui::mrptEventMouseMove
An event sent by a window when the mouse is moved over it.
Definition: CBaseGUIWindow.h:247
mrpt::gui::CDisplayWindow3D::captureImagesStart
void captureImagesStart()
Enables the grabbing of CImage objects from screenshots of the window.
Definition: CDisplayWindow3D.cpp:764
mrpt::gui::CDisplayWindow3D::getLastMousePosition
bool getLastMousePosition(int &x, int &y) const override
Gets the last x,y pixel coordinates of the mouse.
Definition: CDisplayWindow3D.cpp:694
mrpt::gui::CDisplayWindow3D::get3DSceneAndLock
mrpt::opengl::COpenGLScene::Ptr & get3DSceneAndLock()
Gets a reference to the smart shared pointer that holds the internal scene (carefuly read introductio...
Definition: CDisplayWindow3D.cpp:479
mrpt::gui::mrptEventWindowChar
An event sent by a window upon a char pressed by the user.
Definition: CBaseGUIWindow.h:165
mrpt
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
Definition: BaseAppDataSource.h:15
mrpt::gui::C3DWindowDialog::OnResize
void OnResize(wxSizeEvent &event)
Definition: CDisplayWindow3D.cpp:352
THROW_EXCEPTION
#define THROW_EXCEPTION(msg)
Definition: exceptions.h:67
ID_MENUITEM1
const long ID_MENUITEM1
Definition: CDisplayWindow.cpp:34
mrpt::gui::CDisplayWindow3D::getDefaultViewport
mrpt::opengl::COpenGLViewport::Ptr getDefaultViewport()
A short cut for getting the "main" viewport of the scene object, it is equivalent to:
Definition: CDisplayWindow3D.cpp:812
mrpt::gui::CDisplayWindow3D::resize
void resize(unsigned int width, unsigned int height) override
Resizes the window, stretching the image to fit into the display area.
Definition: CDisplayWindow3D.cpp:413
CDisplayWindow3D.h
mrpt::gui::mrptEventWindowResize
An event sent by a window upon resize.
Definition: CBaseGUIWindow.h:192
mrpt::gui::mrptEvent3DWindowGrabImageFile
An event sent by a CDisplayWindow3D window when an image is saved after enabling this feature with CD...
Definition: CDisplayWindow3D.h:408
mrpt::gui::WxSubsystem
This class implements the GUI thread required for the wxWidgets-based GUI.
Definition: WxSubsystem.h:96
mrpt::gui::CBaseGUIWindow::m_windowDestroyed
std::promise< void > m_windowDestroyed
This semaphore will be signaled when the wx window is destroyed.
Definition: CBaseGUIWindow.h:58
mrpt::gui::CDisplayWindow3D::m_is_capturing_imgs
bool m_is_capturing_imgs
Definition: CDisplayWindow3D.h:142
WxUtils.h
mrpt::gui::CDisplayWindow3D::useCameraFromScene
void useCameraFromScene(bool useIt=true)
If set to true (default = false), the mouse-based scene navigation will be disabled and the camera po...
Definition: CDisplayWindow3D.cpp:516
mrpt::gui::WxSubsystem::getMRPTDefaultIcon
static wxBitmap getMRPTDefaultIcon()
Definition: WxSubsystem.cpp:770
mrpt::gui::WxSubsystem::CWXMainFrame::notifyWindowCreation
static int notifyWindowCreation()
Atomically increments the number of windows created with the main frame as parent.
Definition: WxSubsystem.cpp:195
mrpt::gui::C3DWindowDialog::OnMenuClose
void OnMenuClose(wxCommandEvent &event)
Definition: CDisplayWindow3D.cpp:336
mrpt::gui::CDisplayWindow3D::getCameraAzimuthDeg
float getCameraAzimuthDeg() const
Get camera parameters programmatically.
Definition: CDisplayWindow3D.cpp:635
mrpt::gui::WxSubsystem::CWXMainFrame::notifyWindowDestruction
static int notifyWindowDestruction()
Atomically decrements the number of windows created with the main frame as parent.
Definition: WxSubsystem.cpp:201
mrpt::gui::CBaseGUIWindow
The base class for GUI window classes based on wxWidgets.
Definition: CBaseGUIWindow.h:40
mrpt::gui::mrptEventMouseDown
An event sent by a window upon a mouse click, giving the (x,y) pixel coordinates.
Definition: CBaseGUIWindow.h:218
mrpt::gui::CDisplayWindow3D::setCameraProjective
void setCameraProjective(bool isProjective)
Sets the camera as projective, or orthogonal.
Definition: CDisplayWindow3D.cpp:565
mrpt::gui::CBaseGUIWindow::isOpen
bool isOpen()
Returns false if the user has already closed the window.
Definition: CBaseGUIWindow.cpp:201
mrpt::img
Definition: CCanvas.h:16
mrpt::gui::WxSubsystem::TRequestToWxMainThread
The data structure for each inter-thread request:
Definition: WxSubsystem.h:189
mrpt::opengl::COpenGLViewport::Ptr
std::shared_ptr< mrpt::opengl ::COpenGLViewport > Ptr
Definition: COpenGLViewport.h:65
mrpt::gui::CDisplayWindow3D::setCameraPointingToPoint
void setCameraPointingToPoint(float x, float y, float z)
Changes the camera parameters programmatically.
Definition: CDisplayWindow3D.cpp:538
mrpt::gui::CDisplayWindow3D::unlockAccess3DScene
void unlockAccess3DScene()
Unlocks the access to the internal 3D scene.
Definition: CDisplayWindow3D.cpp:485
ID_MENUITEM2
const long ID_MENUITEM2
Definition: CDisplayWindow.cpp:35
mrpt::gui::CDisplayWindow3D::getLastMousePositionRay
bool getLastMousePositionRay(mrpt::math::TLine3D &ray) const
Gets the 3D ray for the direction line of the pixel where the mouse cursor is at.
Definition: CDisplayWindow3D.cpp:710
mrpt::gui::CDisplayWindow3D::getCameraZoom
float getCameraZoom() const
Get camera parameters programmatically.
Definition: CDisplayWindow3D.cpp:668
mrpt::gui::CBaseGUIWindow::m_caption
std::string m_caption
The caption of the window.
Definition: CBaseGUIWindow.h:60
win
mrpt::gui::CDisplayWindow3D::Ptr win
Definition: vision_stereo_rectify/test.cpp:31
mrpt::gui::CDisplayWindow3D::captureImagesStop
void captureImagesStop()
Stop image grabbing.
Definition: CDisplayWindow3D.cpp:768
mrpt::system::CObservable::hasSubscribers
bool hasSubscribers() const
Can be called by a derived class before preparing an event for publishing with publishEvent to determ...
Definition: CObservable.h:53
mrpt::gui::CBaseGUIWindow::m_hwnd
mrpt::void_ptr_noncopy m_hwnd
The window handle.
Definition: CBaseGUIWindow.h:62
mrpt::gui::CDisplayWindow3D::grabImageGetNextFile
std::string grabImageGetNextFile()
Increments by one the image counter and return the next image file name (Users normally don't want to...
Definition: CDisplayWindow3D.cpp:752
mrpt::gui::CDisplayWindow3D::setCameraElevationDeg
void setCameraElevationDeg(float deg)
Changes the camera parameters programmatically.
Definition: CDisplayWindow3D.cpp:508
mrpt::gui::CDisplayWindow3D::m_lastFullScreen
mrpt::system::TTimeStamp m_lastFullScreen
Definition: CDisplayWindow3D.h:148
mrpt::gui::C3DWindowDialog
Definition: WxSubsystem.h:381
mrpt::gui::keyEventToMrptKeyModifier
mrptKeyModifier keyEventToMrptKeyModifier(const wxKeyEvent &ev)
Extracts the key modifiers from a wxKeyEvent.
Definition: WxUtils.cpp:939
mrpt::gui::CDisplayWindow3D::Ptr
std::shared_ptr< CDisplayWindow3D > Ptr
Definition: CDisplayWindow3D.h:120
mrpt::math::size
size_t size(const MATRIXLIKE &m, const int dim)
Definition: math/include/mrpt/math/bits_math.h:21
mrpt::gui::CDisplayWindow3D::m_csAccess3DScene
std::recursive_timed_mutex m_csAccess3DScene
Critical section for accesing m_3Dscene.
Definition: CDisplayWindow3D.h:131
mrpt::gui::CDisplayWindow3D::setMaxRange
void setMaxRange(float new_max)
Changes the camera max clip range (z) (used for gluPerspective.
Definition: CDisplayWindow3D.cpp:587
mrpt::gui::CDisplayWindow3D::forceRepaint
void forceRepaint()
Repaints the window.
Definition: CDisplayWindow3D.cpp:487
gui-precomp.h
mrpt::img::CH_RGB
@ CH_RGB
Definition: img/CImage.h:62
mrpt::gui
Classes for creating GUI windows for 2D and 3D visualization.
Definition: about_box.h:14
mrpt::gui::CDisplayWindow3D::m_last_captured_img_cs
std::mutex m_last_captured_img_cs
Definition: CDisplayWindow3D.h:144
mrpt::gui::CBaseGUIWindow::notifyChildWindowDestruction
void notifyChildWindowDestruction()
Called by wx main thread to set m_hwnd to NULL.
Definition: CBaseGUIWindow.cpp:148
mrpt::img::CImage
A class for storing images as grayscale or RGB bitmaps.
Definition: img/CImage.h:148
mrpt::gui::C3DWindowDialog::m_win3D
CDisplayWindow3D * m_win3D
Definition: WxSubsystem.h:393
mrpt::opengl::COpenGLScene::Ptr
std::shared_ptr< mrpt::opengl ::COpenGLScene > Ptr
Definition: COpenGLScene.h:58
mrpt::gui::CDisplayWindow3DLocker::CDisplayWindow3DLocker
CDisplayWindow3DLocker(CDisplayWindow3D &win, mrpt::opengl::COpenGLScene::Ptr &out_scene_ptr)
Acquires the lock of the 3D scene of the referenced window, and returns a copy of the smart pointer t...
Definition: CDisplayWindow3D.cpp:830
mrpt::gui::CDisplayWindow3D::m_grab_imgs_idx
unsigned int m_grab_imgs_idx
Definition: CDisplayWindow3D.h:140
mrpt::gui::CDisplayWindow3D::internal_setRenderingFPS
void internal_setRenderingFPS(double FPS)
Set the rendering FPS (users don't call this, the method is for internal MRPT objects only)
Definition: CDisplayWindow3D.cpp:798
mrpt::gui::CBaseGUIWindow::m_keyPushed
std::atomic_bool m_keyPushed
Definition: CBaseGUIWindow.h:65
CTicTac.h
mrpt::gui::CDisplayWindow3D::getLastWindowImage
bool getLastWindowImage(mrpt::img::CImage &out_img) const
Retrieve the last captured image from the window.
Definition: CDisplayWindow3D.cpp:772
mrpt::gui::MRPTK_RETURN
@ MRPTK_RETURN
Definition: keycodes.h:26
mrpt::gui::mrptKeyModifier
mrptKeyModifier
Definition: keycodes.h:156
mrpt::gui::CDisplayWindow3D::m_last_FPS
double m_last_FPS
Definition: CDisplayWindow3D.h:151
mrpt::math
This base provides a set of functions for maths stuff.
Definition: math/include/mrpt/math/bits_math.h:11
CWxGLCanvasBase.h
mrpt::math::TLine3D
3D line, represented by a base point and a director vector.
Definition: TLine3D.h:19
CImage.h
mrpt::gui::C3DWindowDialog::OnChar
void OnChar(wxKeyEvent &event)
Definition: CDisplayWindow3D.cpp:345
mrpt::gui::CDisplayWindow3D::setPos
void setPos(int x, int y) override
Changes the position of the window on the screen.
Definition: CDisplayWindow3D.cpp:437
mrpt::gui::CDisplayWindow3D::setCameraAzimuthDeg
void setCameraAzimuthDeg(float deg)
Changes the camera parameters programmatically.
Definition: CDisplayWindow3D.cpp:527
mrpt::img::TPixelCoord
A pair (x,y) of pixel coordinates (integer resolution).
Definition: TPixelCoord.h:40
mrpt::gui::CBaseGUIWindow::destroyWxWindow
void destroyWxWindow()
Must be called by child classes in their destructors.
Definition: CBaseGUIWindow.cpp:103
mrpt::gui::WxSubsystem::TRequestToWxMainThread::source3D
mrpt::gui::CDisplayWindow3D * source3D
Only one of source* can be non-nullptr, indicating the class that generated the request.
Definition: WxSubsystem.h:199
mrpt::gui::mrptEventWindowClosed
An event sent by a window upon when it's about to be closed, either manually by the user or programma...
Definition: CBaseGUIWindow.h:283
mrpt::gui::CDisplayWindow3D::setImageView
void setImageView(const mrpt::img::CImage &img)
Set the "main" viewport into "image view"-mode, where an image is efficiently drawn (fitting the view...
Definition: CDisplayWindow3D.cpp:818
mrpt::gui::CDisplayWindow3D::getLastWindowImagePtr
mrpt::img::CImage::Ptr getLastWindowImagePtr() const
Retrieve the last captured image from the window, as a smart pointer.
Definition: CDisplayWindow3D.cpp:792
mrpt::opengl
The namespace for 3D scene representation and rendering.
Definition: CGlCanvasBase.h:13
mrpt::gui::CDisplayWindow3D
A graphical user interface (GUI) for efficiently rendering 3D scenes in real-time.
Definition: CDisplayWindow3D.h:117
mrpt::format
std::string std::string format(std::string_view fmt, ARGS &&... args)
Definition: format.h:26
mrpt::non_copiable_ptr_basic::get
T *& get()
Definition: safe_pointers.h:151
mrpt::gui::CDisplayWindow3D::m_last_captured_img
mrpt::img::CImage::Ptr m_last_captured_img
Definition: CDisplayWindow3D.h:143
mrpt::gui::CDisplayWindow3D::grabImagesStop
void grabImagesStop()
Stops image grabbing started by grabImagesStart.
Definition: CDisplayWindow3D.cpp:748
mrpt::gui::CDisplayWindow3DLocker::~CDisplayWindow3DLocker
~CDisplayWindow3DLocker()
Definition: CDisplayWindow3D.cpp:841



Page generated by Doxygen 1.8.17 for MRPT 2.0.3 at Fri May 15 15:49:54 UTC 2020