MRPT  2.0.4
CDisplayWindow.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/core/round.h>
14 #include <mrpt/img/CImage.h>
15 #include <mrpt/system/os.h>
16 
17 #include <mrpt/gui/WxSubsystem.h>
18 #include <mrpt/gui/WxUtils.h>
19 
20 using namespace mrpt;
21 using namespace mrpt::math;
22 using namespace mrpt::gui;
23 using namespace mrpt::system;
24 using namespace std;
25 using namespace mrpt::img;
26 
27 #if MRPT_HAS_WXWIDGETS
28 
29 BEGIN_EVENT_TABLE(CWindowDialog, wxFrame)
30 
31 END_EVENT_TABLE()
32 
33 const long CWindowDialog::ID_IMAGE_BITMAP = wxNewId();
34 const long ID_MENUITEM1 = wxNewId();
35 const long ID_MENUITEM2 = wxNewId();
36 const long ID_MENUITEM3 = wxNewId();
37 
39  wxWindow* parent, wxWindowID winID, int x, int y, int width, int height)
40  : m_img(nullptr)
41 {
42  this->Create(parent, winID, wxPoint(x, y), wxSize(width, height));
43 
44  Bind(wxEVT_PAINT, &CWindowDialog::wxMRPTImageControl::OnPaint, this);
45  Bind(wxEVT_MOTION, &CWindowDialog::wxMRPTImageControl::OnMouseMove, this);
46  Bind(
47  wxEVT_LEFT_DOWN, &CWindowDialog::wxMRPTImageControl::OnMouseClick,
48  this);
49  Bind(
50  wxEVT_CHAR, &CWindowDialog::wxMRPTImageControl::OnChar, this, wxID_ANY);
51  Bind(wxEVT_CHAR, &CWindowDialog::wxMRPTImageControl::OnChar, this);
52 }
53 
54 CWindowDialog::wxMRPTImageControl::~wxMRPTImageControl()
55 {
56  std::lock_guard<std::mutex> lock(m_img_cs);
57  if (m_img) m_img.reset();
58 }
59 
60 void CWindowDialog::wxMRPTImageControl::OnMouseMove(wxMouseEvent& ev)
61 {
62  // std::lock_guard<std::mutex> lock( m_mouse_cs);
63  m_last_mouse_point = ev.GetPosition();
64 }
65 
66 void CWindowDialog::wxMRPTImageControl::OnMouseClick(wxMouseEvent& ev)
67 {
68  // std::lock_guard<std::mutex> lock( m_mouse_cs);
69  m_last_mouse_click = ev.GetPosition();
70 }
71 
72 void CWindowDialog::wxMRPTImageControl::OnChar(wxKeyEvent& ev) {}
73 void CWindowDialog::wxMRPTImageControl::AssignImage(wxBitmap* img)
74 {
75  std::lock_guard<std::mutex> lock(m_img_cs);
76  m_img.reset(img);
77 }
78 
79 void CWindowDialog::wxMRPTImageControl::OnPaint(wxPaintEvent& ev)
80 {
81  wxPaintDC dc(this);
82 
83  std::lock_guard<std::mutex> lock(m_img_cs);
84  if (!m_img)
85  {
86  // Erase background:
87  return;
88  }
89 
90  dc.DrawBitmap(*m_img, 0, 0);
91 }
92 
93 void CWindowDialog::wxMRPTImageControl::GetBitmap(wxBitmap& bmp)
94 {
95  std::lock_guard<std::mutex> lock(m_img_cs);
96  if (!m_img) return;
97  bmp = *m_img;
98 }
99 
100 CWindowDialog::CWindowDialog(
101  CDisplayWindow* win2D, WxSubsystem::CWXMainFrame* parent, wxWindowID id,
102  const std::string& caption, wxSize initialSize)
103  : m_win2D(win2D), m_mainFrame(parent)
104 {
105  Create(
106  parent, id, caption.c_str(), wxDefaultPosition, initialSize,
107  wxDEFAULT_FRAME_STYLE, _T("id"));
108  SetClientSize(initialSize);
109 
110  wxIcon FrameIcon;
111  FrameIcon.CopyFromBitmap(mrpt::gui::WxSubsystem::getMRPTDefaultIcon());
112  SetIcon(FrameIcon);
113 
114  // Create the image object:
116  this, ID_IMAGE_BITMAP, 0, 0, 10, 10);
117 
118  // wxCLIP_CHILDREN seems to avoid flicker
119  SetWindowStyle(GetWindowStyle() | wxCLIP_CHILDREN);
120 
121  // Menu:
122  auto* MenuBar1 = new wxMenuBar();
123 
124  auto* Menu1 = new wxMenu();
125  wxMenuItem* MenuItem3 = new wxMenuItem(
126  Menu1, ID_MENUITEM3, _("Save to file..."), _(""), wxITEM_NORMAL);
127  Menu1->Append(MenuItem3);
128  wxMenuItem* MenuItem1 =
129  new wxMenuItem(Menu1, ID_MENUITEM1, _("Close"), _(""), wxITEM_NORMAL);
130  Menu1->Append(MenuItem1);
131  MenuBar1->Append(Menu1, _("&File"));
132 
133  auto* Menu2 = new wxMenu();
134  wxMenuItem* MenuItem2 = new wxMenuItem(
135  Menu2, ID_MENUITEM2, _("About..."), _(""), wxITEM_NORMAL);
136  Menu2->Append(MenuItem2);
137  MenuBar1->Append(Menu2, _("&Help"));
138 
139  SetMenuBar(MenuBar1);
140 
141  // Events:
142  Bind(wxEVT_CLOSE_WINDOW, &CWindowDialog::OnClose, this, wxID_ANY);
143  Bind(wxEVT_MENU, &CWindowDialog::OnMenuClose, this, ID_MENUITEM1);
144  Bind(wxEVT_MENU, &CWindowDialog::OnMenuAbout, this, ID_MENUITEM2);
145  Bind(wxEVT_MENU, &CWindowDialog::OnMenuSave, this, ID_MENUITEM3);
146 
147  Bind(wxEVT_KEY_DOWN, &CWindowDialog::OnChar, this, wxID_ANY);
148  Bind(wxEVT_CHAR, &CWindowDialog::OnChar, this, wxID_ANY);
149 
150  m_image->Bind(wxEVT_KEY_DOWN, &CWindowDialog::OnChar, this);
151  m_image->Bind(wxEVT_SIZE, &CWindowDialog::OnResize, this);
152 
153  m_image->Bind(wxEVT_LEFT_DOWN, &CWindowDialog::OnMouseDown, this);
154  m_image->Bind(wxEVT_RIGHT_DOWN, &CWindowDialog::OnMouseDown, this);
155  m_image->Bind(wxEVT_MOTION, &CWindowDialog::OnMouseMove, this);
156 
157  // Increment number of windows:
158  // int winCount =
160 
161  // this->Iconize(false);
162 }
163 
164 // Destructor
166 // OnClose event:
167 void CWindowDialog::OnClose(wxCloseEvent& event)
168 {
169  // Send the event:
170  bool allow_close = true;
171  try
172  {
173  mrptEventWindowClosed ev(m_win2D, true /* allow close */);
174  m_win2D->publishEvent(ev);
175  allow_close = ev.allow_close;
176  }
177  catch (...)
178  {
179  }
180  if (!allow_close) return; // Don't process this close event.
181 
182  // Set the m_hwnd=nullptr in our parent object.
184 
185  // Decrement number of windows:
187 
188  m_win2D->m_windowDestroyed.set_value();
189 
190  event.Skip(); // keep processing by parent classes.
191 }
192 
193 void CWindowDialog::OnKeyDown(wxKeyEvent& event)
194 {
195  event.Skip(); // So OnChar event is produced.
196 }
197 
198 void CWindowDialog::OnChar(wxKeyEvent& event)
199 {
200  if (m_win2D)
201  {
202  const int code = event.GetKeyCode();
204 
205  m_win2D->m_keyPushedCode = code;
207  m_win2D->m_keyPushed = true;
208 
209  // Send the event:
210  try
211  {
213  }
214  catch (...)
215  {
216  }
217  }
218  event.Skip();
219 }
220 
221 void CWindowDialog::OnResize(wxSizeEvent& event)
222 {
223  // Send the event:
224  if (m_win2D && m_win2D->hasSubscribers())
225  {
226  try
227  {
229  m_win2D, event.GetSize().GetWidth(),
230  event.GetSize().GetHeight()));
231  }
232  catch (...)
233  {
234  }
235  }
236  event.Skip(); // so it's processed by the wx system!
237 }
238 
239 void CWindowDialog::OnMouseDown(wxMouseEvent& event)
240 {
241  // Send the event:
242  if (m_win2D && m_win2D->hasSubscribers())
243  {
244  try
245  {
247  m_win2D, TPixelCoord(event.GetX(), event.GetY()),
248  event.LeftDown(), event.RightDown()));
249  }
250  catch (...)
251  {
252  }
253  }
254  event.Skip(); // so it's processed by the wx system!
255 }
256 
257 void CWindowDialog::OnMouseMove(wxMouseEvent& event)
258 {
259  // Send the event:
260  if (m_win2D && m_win2D->hasSubscribers())
261  {
262  try
263  {
265  m_win2D, TPixelCoord(event.GetX(), event.GetY()),
266  event.LeftDown(), event.RightDown()));
267  }
268  catch (...)
269  {
270  }
271  }
272  event.Skip(); // so it's processed by the wx system!
273 }
274 
275 // Menu: Close
276 void CWindowDialog::OnMenuClose(wxCommandEvent& event) { Close(); }
277 // Menu: About
278 void CWindowDialog::OnMenuAbout(wxCommandEvent& event)
279 {
280  ::wxMessageBox(
281  _("Image viewer\n Class gui::CDisplayWindow\n MRPT C++ library"),
282  _("About..."));
283 }
284 
285 // Menu: Save to file
286 void CWindowDialog::OnMenuSave(wxCommandEvent& event)
287 {
288  wxFileDialog dialog(
289  this, wxT("Save image as..."), wxT("."), wxT("image.png"),
290  wxT("PNG image files (*.png)|*.png"),
291  wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
292 
293  if (wxID_OK == dialog.ShowModal())
294  {
295  try
296  {
297  wxBitmap bmp;
298  m_image->GetBitmap(bmp);
299  bmp.SaveFile(dialog.GetPath(), wxBITMAP_TYPE_PNG);
300  }
301  catch (...)
302  {
303  }
304  }
305 }
306 
307 #endif
308 
310  const std::string& windowCaption, unsigned int initWidth,
311  unsigned int initHeight)
312 {
313  return std::make_shared<CDisplayWindow>(
314  windowCaption, initWidth, initHeight);
315 }
316 /*---------------------------------------------------------------
317  Constructor
318  ---------------------------------------------------------------*/
320  const std::string& windowCaption, unsigned int initWidth,
321  unsigned int initHeight)
322  : CBaseGUIWindow(static_cast<void*>(this), 200, 299, windowCaption)
323 
324 {
325  CBaseGUIWindow::createWxWindow(initWidth, initHeight);
326 }
327 
328 /*---------------------------------------------------------------
329  Destructor
330  ---------------------------------------------------------------*/
332 /** Set cursor style to default (cursorIsCross=false) or to a cross
333  * (cursorIsCross=true) */
334 void CDisplayWindow::setCursorCross([[maybe_unused]] bool cursorIsCross)
335 {
336 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
337  const auto* win = (const CWindowDialog*)m_hwnd.get();
338  if (!win) return;
339  win->m_image->SetCursor(
340  *(cursorIsCross ? wxCROSS_CURSOR : wxSTANDARD_CURSOR));
341 #endif
342 }
343 
344 /*---------------------------------------------------------------
345  getLastMousePosition
346  ---------------------------------------------------------------*/
348  [[maybe_unused]] int& x, [[maybe_unused]] int& y) const
349 {
350 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
351  const auto* win = (const CWindowDialog*)m_hwnd.get();
352  if (!win) return false;
353  x = win->m_image->m_last_mouse_point.x;
354  y = win->m_image->m_last_mouse_point.y;
355  return true;
356 #else
357  return false;
358 #endif
359 }
360 
361 /*---------------------------------------------------------------
362  showImage
363  ---------------------------------------------------------------*/
364 void CDisplayWindow::showImage([[maybe_unused]] const CImage& img)
365 {
366 #if MRPT_HAS_WXWIDGETS
367  MRPT_START
368 
369  // Send message of new image:
370  wxImage* newImg = mrpt::gui::MRPTImage2wxImage(img);
371 
372  // Send a request to destroy this object:
373  auto* REQ = new WxSubsystem::TRequestToWxMainThread[1];
374  REQ->source2D = this;
375  REQ->OPCODE = 201;
376  REQ->voidPtr = m_hwnd.get();
377  REQ->voidPtr2 = (void*)newImg;
379 
380  MRPT_END
381 #endif
382 }
383 
384 /*---------------------------------------------------------------
385  showImageAndPoints
386  ---------------------------------------------------------------*/
388  const CImage& img, const CVectorFloat& x_, const CVectorFloat& y_,
389  const TColor& color, bool showNumbers)
390 {
391  std::vector<float> x(x_.size()), y(y_.size());
392  for (size_t i = 0; i < x.size(); i++) x[i] = x_[i];
393  for (size_t i = 0; i < y.size(); i++) y[i] = y_[i];
394  showImageAndPoints(img, x, y, color, showNumbers);
395 }
396 
398  [[maybe_unused]] const CImage& img,
399  [[maybe_unused]] const std::vector<float>& x,
400  [[maybe_unused]] const std::vector<float>& y,
401  [[maybe_unused]] const TColor& color, [[maybe_unused]] bool showNumbers)
402 {
403 #if MRPT_HAS_WXWIDGETS
404  MRPT_START
405  ASSERT_(x.size() == y.size());
406 
407  CImage imgColor = img.colorImage(); // Create a colorimage
408  for (size_t i = 0; i < x.size(); i++)
409  {
410  imgColor.drawMark(round(x[i]), round(y[i]), color, '+');
411 
412  if (showNumbers)
413  {
414  char buf[15];
415  mrpt::system::os::sprintf(buf, 15, "%d", int(i));
416  imgColor.textOut(round(x[i]) - 10, round(y[i]), buf, color);
417  }
418  } // end-for
419  showImage(imgColor);
420  MRPT_END
421 #endif
422 }
423 
424 /*---------------------------------------------------------------
425  plot
426  ---------------------------------------------------------------*/
428 {
429  MRPT_START
430 
431  ASSERT_(x.size() == y.size());
432 
433  const int ox = 40;
434  const int oy = 40;
435 
436  // Suboptimal but...
437  CImage imgColor(640, 480, mrpt::img::CH_RGB);
438  // Draw axis:
439  imgColor.filledRectangle(0, 0, 640, 480, TColor(255, 255, 255));
440  imgColor.line(40, 40, 560, 40, TColor::black(), 3);
441  imgColor.line(40, 40, 40, 440, TColor::black(), 3);
442  imgColor.line(560, 40, 555, 45, TColor::black(), 3);
443  imgColor.line(560, 40, 555, 35, TColor::black(), 3);
444  imgColor.line(40, 440, 35, 435, TColor::black(), 3);
445  imgColor.line(40, 440, 45, 435, TColor::black(), 3);
446 
447  // imgColor.textOut( 550, 25, "x", TColor::black );
448  // imgColor.textOut( 25, 430, "y", TColor::black );
449 
451  CVectorFloat::const_iterator itymx, itymn;
452  itymx = std::max_element(y.begin(), y.end());
453  itymn = std::min_element(y.begin(), y.end());
454  float px = (x[x.size() - 1] - x[0]) / 520;
455  float py = (*itymx - *itymn) / 400;
456 
457  float tpxA = 0, tpyA = 0;
458 
459  for (itx = x.begin(), ity = y.begin(); itx != x.end(); ++itx, ++ity)
460  {
461  float tpx = (*itx - x[0]) / px + ox;
462  float tpy = (*ity - *itymn) / py + oy;
463  imgColor.drawMark(round(tpx), round(tpy), TColor(255, 0, 0), 'x');
464  if (itx != x.begin())
465  imgColor.line(
466  round(tpxA), round(tpyA), round(tpx), round(tpy),
467  TColor(0, 0, 255), 3);
468  tpxA = tpx;
469  tpyA = tpy;
470  } // end for
471 
472  showImage(imgColor);
473 
474  MRPT_END
475 }
476 
477 /*---------------------------------------------------------------
478  plot
479  ---------------------------------------------------------------*/
481 {
482  MRPT_START
483 
484  ASSERT_(y.size() >= 0);
485 
486  const int ox = 40;
487  const int oy = 40;
488 
489  // Suboptimal but...
490  CImage imgColor(640, 480, mrpt::img::CH_RGB);
491  // Draw axis:
492  imgColor.filledRectangle(0, 0, 640, 480, TColor::white());
493  imgColor.line(40, 40, 560, 40, TColor::black(), 3);
494  imgColor.line(40, 40, 40, 440, TColor::black(), 3);
495  imgColor.line(560, 40, 555, 45, TColor::black(), 3);
496  imgColor.line(560, 40, 555, 35, TColor::black(), 3);
497  imgColor.line(40, 440, 35, 435, TColor::black(), 3);
498  imgColor.line(40, 440, 45, 435, TColor::black(), 3);
499 
500  imgColor.textOut(550, 25, "x", TColor::black());
501  imgColor.textOut(25, 430, "y", TColor::black());
502 
504  CVectorFloat::const_iterator itymx, itymn;
505  itymx = std::max_element(y.begin(), y.end());
506  itymn = std::min_element(y.begin(), y.end());
507  float px = y.size() / 520.0f;
508  float py = (*itymx - *itymn) / 400.0f;
509  int tpxA = 0, tpyA = 0;
510 
511  unsigned int k = 0;
512 
513  for (k = 0, ity = y.begin(); ity != y.end(); ++k, ++ity)
514  {
515  auto tpx = round(k / px + ox);
516  auto tpy = round((*ity - *itymn) / py + oy);
517  imgColor.drawMark(tpx, tpy, TColor::red(), 'x');
518  if (k > 0) imgColor.line(tpxA, tpyA, tpx, tpy, TColor::blue(), 3);
519  tpxA = tpx;
520  tpyA = tpy;
521  } // end for
522 
523  showImage(imgColor);
524 
525  MRPT_END
526 }
527 
528 /*---------------------------------------------------------------
529  resize
530  ---------------------------------------------------------------*/
532  [[maybe_unused]] unsigned int width, [[maybe_unused]] unsigned int height)
533 {
534 #if MRPT_HAS_WXWIDGETS
535  if (!isOpen())
536  {
537  cerr << "[CDisplayWindow::resize] Window closed!: " << m_caption
538  << endl;
539  return;
540  }
541 
542  // Send a request to destroy this object:
543  auto* REQ = new WxSubsystem::TRequestToWxMainThread[1];
544  REQ->source2D = this;
545  REQ->OPCODE = 203;
546  REQ->x = width;
547  REQ->y = height;
549 #endif
550 }
551 
552 /*---------------------------------------------------------------
553  setPos
554  ---------------------------------------------------------------*/
555 void CDisplayWindow::setPos([[maybe_unused]] int x, [[maybe_unused]] int y)
556 {
557 #if MRPT_HAS_WXWIDGETS
558  if (!isOpen())
559  {
560  cerr << "[CDisplayWindow::setPos] Window closed!: " << m_caption
561  << endl;
562  return;
563  }
564 
565  // Send a request to destroy this object:
566  auto* REQ = new WxSubsystem::TRequestToWxMainThread[1];
567  REQ->source2D = this;
568  REQ->OPCODE = 202;
569  REQ->x = x;
570  REQ->y = y;
572 #endif
573 }
574 
575 /*---------------------------------------------------------------
576  setWindowTitle
577  ---------------------------------------------------------------*/
578 void CDisplayWindow::setWindowTitle([[maybe_unused]] const std::string& str)
579 {
580 #if MRPT_HAS_WXWIDGETS
581  if (!isOpen())
582  {
583  cerr << "[CDisplayWindow::setWindowTitle] Window closed!: " << m_caption
584  << endl;
585  return;
586  }
587 
588  // Send a request to destroy this object:
589  auto* REQ = new WxSubsystem::TRequestToWxMainThread[1];
590  REQ->source2D = this;
591  REQ->OPCODE = 204;
592  REQ->str = str;
594 #endif
595 }
mrpt::gui::CDisplayWindow::showImageAndPoints
void showImageAndPoints(const mrpt::img::CImage &img, const mrpt::math::CVectorFloat &x, const mrpt::math::CVectorFloat &y, const mrpt::img::TColor &color=mrpt::img::TColor::red(), bool showNumbers=false)
Show a given color or grayscale image on the window and print a set of points on it.
Definition: CDisplayWindow.cpp:387
mrpt::gui::mrptEventWindowClosed::allow_close
bool allow_close
Definition: CBaseGUIWindow.h:295
os.h
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::CDisplayWindow::resize
void resize(unsigned int width, unsigned int height) override
Resizes the window, stretching the image to fit into the display area.
Definition: CDisplayWindow.cpp:531
mrpt::gui::CWindowDialog
The wx dialog for gui::CDisplayWindow.
Definition: WxSubsystem.h:315
mrpt::gui::CWindowDialog::OnClose
void OnClose(wxCloseEvent &event)
Definition: CDisplayWindow.cpp:167
mrpt::math::CVectorDynamic::begin
iterator begin()
Definition: CVectorDynamic.h:61
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:254
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::CBaseGUIWindow::m_keyPushedCode
std::atomic_int m_keyPushedCode
Definition: CBaseGUIWindow.h:66
mrpt::gui::CWindowDialog::OnMenuClose
void OnMenuClose(wxCommandEvent &event)
Definition: CDisplayWindow.cpp:276
mrpt::gui::CWindowDialog::wxMRPTImageControl::GetBitmap
void GetBitmap(wxBitmap &bmp)
Definition: CDisplayWindow.cpp:93
mrpt::gui::CWindowDialog::OnResize
void OnResize(wxSizeEvent &event)
Definition: CDisplayWindow.cpp:221
mrpt::gui::CWindowDialog::wxMRPTImageControl
A custom control to display the bitmap and avoid flicker.
Definition: WxSubsystem.h:320
WxSubsystem.h
mrpt::math::CVectorDynamic::const_iterator
typename vec_t::const_iterator const_iterator
Definition: CVectorDynamic.h:60
mrpt::gui::mrptEventMouseMove
An event sent by a window when the mouse is moved over it.
Definition: CBaseGUIWindow.h:247
mrpt::gui::CDisplayWindow::setPos
void setPos(int x, int y) override
Changes the position of the window on the screen.
Definition: CDisplayWindow.cpp:555
mrpt::gui::MRPTImage2wxImage
wxImage * MRPTImage2wxImage(const mrpt::img::CImage &img)
Create a wxImage from a MRPT image.
Definition: WxUtils.cpp:24
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::CDisplayWindow::~CDisplayWindow
~CDisplayWindow() override
Destructor.
Definition: CDisplayWindow.cpp:331
ASSERT_
#define ASSERT_(f)
Defines an assertion mechanism.
Definition: exceptions.h:120
mrpt::gui::CDisplayWindow::setCursorCross
void setCursorCross(bool cursorIsCross) override
Set cursor style to default (cursorIsCross=false) or to a cross (cursorIsCross=true)
Definition: CDisplayWindow.cpp:334
ID_MENUITEM1
const long ID_MENUITEM1
Definition: CDisplayWindow.cpp:34
mrpt::gui::CDisplayWindow::Create
static CDisplayWindow::Ptr Create(const std::string &windowCaption, unsigned int initWidth=400, unsigned int initHeight=400)
Class factory returning a smart pointer.
Definition: CDisplayWindow.cpp:309
ID_MENUITEM3
const long ID_MENUITEM3
Definition: CDisplayWindow.cpp:36
mrpt::gui::mrptEventWindowResize
An event sent by a window upon resize.
Definition: CBaseGUIWindow.h:192
mrpt::gui::CDisplayWindow::showImage
void showImage(const mrpt::img::CImage &img)
Show a given color or grayscale image on the window.
Definition: CDisplayWindow.cpp:364
mrpt::gui::CDisplayWindow::plot
void plot(const mrpt::math::CVectorFloat &x, const mrpt::math::CVectorFloat &y)
Plots a graph in MATLAB-like style.
Definition: CDisplayWindow.cpp:427
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
WxUtils.h
mrpt::gui::WxSubsystem::getMRPTDefaultIcon
static wxBitmap getMRPTDefaultIcon()
Definition: WxSubsystem.cpp:769
mrpt::gui::WxSubsystem::CWXMainFrame::notifyWindowCreation
static int notifyWindowCreation()
Atomically increments the number of windows created with the main frame as parent.
Definition: WxSubsystem.cpp:193
mrpt::system::os::sprintf
int sprintf(char *buf, size_t bufSize, const char *format,...) noexcept MRPT_printf_format_check(3
An OS-independent version of sprintf (Notice the bufSize param, which may be ignored in some compiler...
mrpt::gui::CDisplayWindow::Ptr
std::shared_ptr< CDisplayWindow > Ptr
Definition: CDisplayWindow.h:36
mrpt::gui::WxSubsystem::TRequestToWxMainThread::source2D
mrpt::gui::CDisplayWindow * source2D
Only one of source* can be non-nullptr, indicating the class that generated the request.
Definition: WxSubsystem.h:195
mrpt::gui::WxSubsystem::CWXMainFrame::notifyWindowDestruction
static int notifyWindowDestruction()
Atomically decrements the number of windows created with the main frame as parent.
Definition: WxSubsystem.cpp:199
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::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
ID_MENUITEM2
const long ID_MENUITEM2
Definition: CDisplayWindow.cpp:35
mrpt::round
int round(const T value)
Returns the closer integer (int) to x.
Definition: round.h:24
MRPT_START
#define MRPT_START
Definition: exceptions.h:241
mrpt::gui::CWindowDialog::m_image
wxMRPTImageControl * m_image
Definition: WxSubsystem.h:363
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::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::img::CCanvas::drawMark
void drawMark(int x0, int y0, const mrpt::img::TColor color, char type, int size=5, unsigned int width=1)
Draw a mark.
Definition: CCanvas.cpp:304
mrpt::gui::keyEventToMrptKeyModifier
mrptKeyModifier keyEventToMrptKeyModifier(const wxKeyEvent &ev)
Extracts the key modifiers from a wxKeyEvent.
Definition: WxUtils.cpp:939
mrpt::img::CImage::line
void line(int x0, int y0, int x1, int y1, const mrpt::img::TColor color, unsigned int width=1, TPenStyle penStyle=psSolid) override
Draws a line.
Definition: CImage.cpp:1123
mrpt::img::TColor
A RGB color - 8bit.
Definition: TColor.h:25
round.h
mrpt::img::CImage::colorImage
CImage colorImage() const
Returns a color (RGB) version of the grayscale image, or a shallow copy of itself if it is already a ...
Definition: CImage.cpp:1867
mrpt::gui::CWindowDialog::OnChar
void OnChar(wxKeyEvent &event)
Definition: CDisplayWindow.cpp:198
gui-precomp.h
mrpt::img::CH_RGB
@ CH_RGB
Definition: img/CImage.h:62
mrpt::gui::CDisplayWindow
This class creates a window as a graphical user interface (GUI) for displaying images to the user.
Definition: CDisplayWindow.h:33
mrpt::gui::CWindowDialog::m_win2D
CDisplayWindow * m_win2D
Definition: WxSubsystem.h:359
mrpt::gui
Classes for creating GUI windows for 2D and 3D visualization.
Definition: about_box.h:14
mrpt::gui::WxSubsystem::CWXMainFrame
The main frame of the wxWidgets application.
Definition: WxSubsystem.h:132
mrpt::gui::CBaseGUIWindow::notifyChildWindowDestruction
void notifyChildWindowDestruction()
Called by wx main thread to set m_hwnd to NULL.
Definition: CBaseGUIWindow.cpp:148
mrpt::gui::CWindowDialog::OnMenuSave
void OnMenuSave(wxCommandEvent &event)
Definition: CDisplayWindow.cpp:286
mrpt::math::CVectorDynamic
Template for column vectors of dynamic size, compatible with Eigen.
Definition: CVectorDynamic.h:31
mrpt::img::CImage
A class for storing images as grayscale or RGB bitmaps.
Definition: img/CImage.h:148
mrpt::gui::CWindowDialog::OnMouseMove
void OnMouseMove(wxMouseEvent &event)
Definition: CDisplayWindow.cpp:257
mrpt::math::CVectorDynamic::end
iterator end()
Definition: CVectorDynamic.h:62
mrpt::math::CVectorDynamic::size
size_type size() const
Get a 2-vector with [NROWS NCOLS] (as in MATLAB command size(x))
Definition: CVectorDynamic.h:141
mrpt::gui::CWindowDialog::ID_IMAGE_BITMAP
static const long ID_IMAGE_BITMAP
Definition: WxSubsystem.h:365
mrpt::gui::CWindowDialog::OnMouseDown
void OnMouseDown(wxMouseEvent &event)
Definition: CDisplayWindow.cpp:239
mrpt::gui::CWindowDialog::~CWindowDialog
~CWindowDialog() override
mrpt::gui::CBaseGUIWindow::m_keyPushed
std::atomic_bool m_keyPushed
Definition: CBaseGUIWindow.h:65
MRPT_END
#define MRPT_END
Definition: exceptions.h:245
mrpt::gui::mrptKeyModifier
mrptKeyModifier
Definition: keycodes.h:156
mrpt::gui::CDisplayWindow::setWindowTitle
void setWindowTitle(const std::string &str) override
Changes the window title text.
Definition: CDisplayWindow.cpp:578
mrpt::math
This base provides a set of functions for maths stuff.
Definition: math/include/mrpt/math/bits_math.h:11
CImage.h
mrpt::img::CCanvas::textOut
virtual void textOut(int x0, int y0, const std::string &str, const mrpt::img::TColor color)
Renders 2D text using bitmap fonts.
Definition: CCanvas.cpp:374
mrpt::gui::CDisplayWindow::getLastMousePosition
bool getLastMousePosition(int &x, int &y) const override
Gets the last x,y pixel coordinates of the mouse.
Definition: CDisplayWindow.cpp:347
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::CDisplayWindow::CDisplayWindow
CDisplayWindow(const std::string &windowCaption=std::string(), unsigned int initWidth=400, unsigned int initHeight=400)
Constructor.
Definition: CDisplayWindow.cpp:319
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::CWindowDialog::OnMenuAbout
void OnMenuAbout(wxCommandEvent &event)
Definition: CDisplayWindow.cpp:278
CDisplayWindow.h
mrpt::gui::CWindowDialog::OnKeyDown
void OnKeyDown(wxKeyEvent &event)
Definition: CDisplayWindow.cpp:193
mrpt::non_copiable_ptr_basic::get
T *& get()
Definition: safe_pointers.h:151
mrpt::system
Definition: backtrace.h:14
mrpt::img::CCanvas::filledRectangle
virtual void filledRectangle(int x0, int y0, int x1, int y1, const mrpt::img::TColor color)
Draws a filled rectangle.
Definition: CCanvas.cpp:205



Page generated by Doxygen 1.8.17 for MRPT 2.0.4 at Sat Jun 27 14:00:59 UTC 2020