Main MRPT website > C++ reference for MRPT 1.9.9
CDisplayWindowPlots.cpp
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | http://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file |
6  | See: http://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See details in http://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 
10 #include "gui-precomp.h" // Precompiled headers
11 
12 #include <mrpt/config.h>
14 #include <mrpt/system/os.h>
15 #include <mrpt/img/CImage.h>
16 #include <mrpt/gui/WxSubsystem.h>
17 #include <mrpt/gui/WxUtils.h>
18 
19 #include <mrpt/math/utils.h>
20 
21 using namespace mrpt;
22 using namespace mrpt::gui;
23 using namespace mrpt::math;
24 using namespace mrpt::system;
25 using namespace std;
27 
28 #if MRPT_HAS_WXWIDGETS
29 
30 BEGIN_EVENT_TABLE(CWindowDialogPlots, wxFrame)
31 
32 END_EVENT_TABLE()
33 
34 const long CWindowDialogPlots::ID_PLOT = wxNewId();
35 const long CWindowDialogPlots::ID_MENU_PRINT = wxNewId();
36 const long ID_MENUITEM1 = wxNewId();
37 const long ID_MENUITEM2 = wxNewId();
38 
40  CDisplayWindowPlots* winPlots, WxSubsystem::CWXMainFrame* parent,
41  wxWindowID id, const std::string& caption, wxSize initialSize)
42  : m_winPlots(winPlots), m_mainFrame(parent), m_firstSubmenu(true)
43 {
44  Create(
45  parent, id, _U(caption.c_str()), wxDefaultPosition, initialSize,
46  wxDEFAULT_FRAME_STYLE, _T("id"));
47 
48  SetClientSize(initialSize);
49 
50  wxIcon FrameIcon;
51  FrameIcon.CopyFromBitmap(mrpt::gui::WxSubsystem::getMRPTDefaultIcon());
52  SetIcon(FrameIcon);
53 
54  // Create the mpWindow object:
55  m_plot = new mpWindow(this, ID_PLOT);
56  m_plot->AddLayer(new mpScaleX());
57  m_plot->AddLayer(new mpScaleY());
58  m_plot->LockAspect(false);
59  m_plot->EnableDoubleBuffer(true);
60 
61  m_plot->Fit(-10, 10, -10, 10);
62 
63  // Menu:
64  wxMenuBar* MenuBar1 = new wxMenuBar();
65 
66  wxMenu* Menu1 = new wxMenu();
67  wxMenuItem* MenuItem1 =
68  new wxMenuItem(Menu1, ID_MENUITEM1, _("Close"), _(""), wxITEM_NORMAL);
69  Menu1->Append(MenuItem1);
70 
71  wxMenuItem* MenuItemPrint = new wxMenuItem(
72  Menu1, ID_MENU_PRINT, _("Print..."), _(""), wxITEM_NORMAL);
73  Menu1->Append(MenuItemPrint);
74 
75  MenuBar1->Append(Menu1, _("&File"));
76 
77  wxMenu* Menu2 = new wxMenu();
78  wxMenuItem* MenuItem2 = new wxMenuItem(
79  Menu2, ID_MENUITEM2, _("About..."), _(""), wxITEM_NORMAL);
80  Menu2->Append(MenuItem2);
81  MenuBar1->Append(Menu2, _("&Help"));
82 
83  SetMenuBar(MenuBar1);
84 
85  // Events:
86  Connect(
87  wxID_ANY, wxEVT_CLOSE_WINDOW,
88  (wxObjectEventFunction)&CWindowDialogPlots::OnClose);
89  Connect(
90  ID_MENUITEM1, wxEVT_COMMAND_MENU_SELECTED,
91  (wxObjectEventFunction)&CWindowDialogPlots::OnMenuClose);
92  Connect(
93  ID_MENU_PRINT, wxEVT_COMMAND_MENU_SELECTED,
94  (wxObjectEventFunction)&CWindowDialogPlots::OnMenuPrint);
95  Connect(
96  ID_MENUITEM2, wxEVT_COMMAND_MENU_SELECTED,
97  (wxObjectEventFunction)&CWindowDialogPlots::OnMenuAbout);
98 
99  Connect(
100  wxID_ANY, wxEVT_SIZE,
101  (wxObjectEventFunction)&CWindowDialogPlots::OnResize);
102 
103  Connect(
104  wxID_ANY, wxEVT_CHAR,
105  (wxObjectEventFunction)&CWindowDialogPlots::OnChar);
106  m_plot->Connect(
107  wxEVT_CHAR, (wxObjectEventFunction)&CWindowDialogPlots::OnChar, 0,
108  this);
109  m_plot->Connect(
110  wxEVT_MOTION, (wxObjectEventFunction)&CWindowDialogPlots::OnMouseMove,
111  0, this);
112 
113  m_plot->Connect(
114  wxEVT_LEFT_DOWN,
115  (wxObjectEventFunction)&CWindowDialogPlots::OnMouseDown, nullptr, this);
116  m_plot->Connect(
117  wxEVT_RIGHT_DOWN,
118  (wxObjectEventFunction)&CWindowDialogPlots::OnMouseDown, nullptr, this);
119 
120  // Increment number of windows:
121  // int winCount =
123 // cout << "[CWindowDialogPlots] Notifying new window: " << winCount <<
124 // endl;
125 
126 // this->Iconize(false);
127 
128 #if 0
129  // JL: TEST CODE: This is the seed of the future new implementation based on wxFreeChart...
130  double data[][2] = {
131  { 10, 20, },
132  { 13, 16, },
133  { 7, 30, },
134  { 15, 34, },
135  { 25, 4, },
136  };
137  // first step: create plot
138  XYPlot *plot = new XYPlot();
139  // create dataset
140  XYSimpleDataset *dataset = new XYSimpleDataset();
141  // and add serie to it
142  dataset->AddSerie((double *) data, WXSIZEOF(data));
143  // set line renderer to dataset
144  dataset->SetRenderer(new XYLineRenderer());
145  // add our dataset to plot
146  plot->AddDataset(dataset);
147  // create left and bottom number axes
148  NumberAxis *leftAxis = new NumberAxis(AXIS_LEFT);
149  NumberAxis *bottomAxis = new NumberAxis(AXIS_BOTTOM);
150  // optional: set axis titles
151  leftAxis->SetTitle(wxT("X"));
152  bottomAxis->SetTitle(wxT("Y"));
153  // add axes to plot
154  plot->AddAxis(leftAxis);
155  plot->AddAxis(bottomAxis);
156  // link axes and dataset
157  plot->LinkDataVerticalAxis(0, 0);
158  plot->LinkDataHorizontalAxis(0, 0);
159  // and finally create chart
160  Chart* chart = new Chart(plot, wxT("my title"));
161  wxChartPanel *m_chartPanel = new wxChartPanel( this ); //, ID_PLOT );
162  m_chartPanel->SetChart( chart );
163 #endif
164 }
165 
166 // Destructor
168 // OnClose event:
169 void CWindowDialogPlots::OnClose(wxCloseEvent& event)
170 {
171  // Send the event:
172  bool allow_close = true;
173  try
174  {
175  mrptEventWindowClosed ev(m_winPlots, true /* allow close */);
176  m_winPlots->publishEvent(ev);
177  allow_close = ev.allow_close;
178  }
179  catch (...)
180  {
181  }
182  if (!allow_close) return; // Don't process this close event.
183 
184  // Set the m_hwnd=nullptr in our parent object.
185  m_winPlots->notifyChildWindowDestruction();
186 
187  // Decrement number of windows:
189 
190  // Signal we are destroyed:
191  m_winPlots->m_windowDestroyed.set_value();
192 
193  event.Skip(); // keep processing by parent classes.
194 }
195 
196 void CWindowDialogPlots::OnChar(wxKeyEvent& event)
197 {
198  if (m_winPlots)
199  {
200  const int code = event.GetKeyCode();
202 
203  m_winPlots->m_keyPushedCode = code;
204  m_winPlots->m_keyPushedModifier = mod;
205  m_winPlots->m_keyPushed = true;
206  // Send the event:
207  try
208  {
209  m_winPlots->publishEvent(
210  mrptEventWindowChar(m_winPlots, code, mod));
211  }
212  catch (...)
213  {
214  }
215  }
216  event.Skip();
217 }
218 
219 void CWindowDialogPlots::OnResize(wxSizeEvent& event)
220 {
221  // Send the event:
222  if (m_winPlots)
223  {
224  try
225  {
226  m_winPlots->publishEvent(
228  m_winPlots, event.GetSize().GetWidth(),
229  event.GetSize().GetHeight()));
230  }
231  catch (...)
232  {
233  }
234  }
235  event.Skip(); // so it's processed by the wx system!
236 }
237 
238 void CWindowDialogPlots::OnMouseDown(wxMouseEvent& event)
239 {
240  // Send the event:
241  if (m_winPlots)
242  {
243  try
244  {
245  m_winPlots->publishEvent(
247  m_winPlots, 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 // Menu: Close
258 void CWindowDialogPlots::OnMenuClose(wxCommandEvent& event) { Close(); }
259 // Menu: Print
260 void CWindowDialogPlots::OnMenuPrint(wxCommandEvent& event)
261 {
262  m_plot->ShowPrintDialog();
263 }
264 // Menu: About
265 void CWindowDialogPlots::OnMenuAbout(wxCommandEvent& event)
266 {
267  ::wxMessageBox(
268  _("Plot viewer\n Class gui::CDisplayWindowPlots\n MRPT C++ & "
269  "wxMathPlot library"),
270  _("About..."));
271 }
272 
273 void CWindowDialogPlots::OnMenuSelected(wxCommandEvent& ev)
274 {
275  std::map<long, long>::const_iterator it = m_ID2ID.find(ev.GetId());
276  if (it != m_ID2ID.end())
277  {
278  if (m_winPlots && m_winPlots->m_callback)
279  m_winPlots->m_callback(
280  it->second, m_curCursorPos.x, m_curCursorPos.y,
281  m_winPlots->m_callback_param);
282  }
283 }
284 
285 void CWindowDialogPlots::OnMouseMove(wxMouseEvent& event)
286 {
287  int X, Y;
288  event.GetPosition(&X, &Y);
289  m_curCursorPos.x = m_plot->p2x(X);
290  m_curCursorPos.y = m_plot->p2y(Y);
291  m_last_mouse_point.x = X;
292  m_last_mouse_point.y = Y;
293 
294  // Send the event:
295  if (m_winPlots && m_winPlots->hasSubscribers())
296  {
297  try
298  {
299  m_winPlots->publishEvent(
301  m_winPlots,
302  mrpt::img::TPixelCoord(event.GetX(), event.GetY()),
303  event.LeftDown(), event.RightDown()));
304  }
305  catch (...)
306  {
307  }
308  }
309  event.Skip(); // so it's processed by the wx system!
310 }
311 
312 // Add / Modify a 2D plot using a MATLAB-like format string
314  const CVectorFloat& x, const CVectorFloat& y, const std::string& lineFormat,
315  const std::string& plotName)
316 {
317  mpFXYVector* theLayer;
318 
319  wxString lyName = _U(plotName.c_str());
320  bool updateAtTheEnd = false; // If we update an existing layer, update
321  // manually to refresh the changes!
322 
323  // Already existing layer?
324  mpLayer* existingLy = m_plot->GetLayerByName(lyName);
325 
326  if (existingLy)
327  {
328  // Assure the class:
329  mpFXYVector* lyPlot2D = static_cast<mpFXYVector*>(existingLy);
330 
331  if (!lyPlot2D)
332  {
333  cerr << "[CWindowDialogPlots::plot] Plot name '" << plotName
334  << "' is not of expected class mpFXYVector!." << endl;
335  return;
336  }
337 
338  // Ok:
339  theLayer = lyPlot2D;
340  updateAtTheEnd = true;
341  }
342  else
343  {
344  // Create it:
345  theLayer = new mpFXYVector(lyName);
346  m_plot->AddLayer(theLayer);
347  }
348 
349  // Set data:
350  {
351  std::vector<float> x_(x.size()), y_(x.size());
352  ::memcpy(&x_[0], &x[0], sizeof(x[0]) * x_.size());
353  ::memcpy(&y_[0], &y[0], sizeof(y[0]) * y_.size());
354  theLayer->SetData(x_, y_);
355  }
356 
357  // Line style:
358  // -------------------
359  bool isContinuous = true;
360  int lineColor[] = {0, 0, 255};
361  int lineWidth = 1;
362  int lineStyle = wxSOLID;
363 
364  // parse string:
365  if (string::npos != lineFormat.find("."))
366  {
367  isContinuous = false;
368  }
369  if (string::npos != lineFormat.find("-"))
370  {
371  isContinuous = true;
372  lineStyle = wxSOLID;
373  }
374  if (string::npos != lineFormat.find(":"))
375  {
376  isContinuous = true;
377  lineStyle = wxLONG_DASH;
378  }
379 
380  if (string::npos != lineFormat.find("r"))
381  {
382  lineColor[0] = 0xFF;
383  lineColor[1] = 0x00;
384  lineColor[2] = 0x00;
385  }
386  if (string::npos != lineFormat.find("g"))
387  {
388  lineColor[0] = 0x00;
389  lineColor[1] = 0xFF;
390  lineColor[2] = 0x00;
391  }
392  if (string::npos != lineFormat.find("b"))
393  {
394  lineColor[0] = 0x00;
395  lineColor[1] = 0x00;
396  lineColor[2] = 0xFF;
397  }
398  if (string::npos != lineFormat.find("k"))
399  {
400  lineColor[0] = 0x00;
401  lineColor[1] = 0x00;
402  lineColor[2] = 0x00;
403  }
404  if (string::npos != lineFormat.find("m"))
405  {
406  lineColor[0] = 192;
407  lineColor[1] = 0;
408  lineColor[2] = 192;
409  }
410  if (string::npos != lineFormat.find("c"))
411  {
412  lineColor[0] = 0;
413  lineColor[1] = 192;
414  lineColor[2] = 192;
415  }
416 
417  if (string::npos != lineFormat.find("1"))
418  {
419  lineWidth = 1;
420  }
421  if (string::npos != lineFormat.find("2"))
422  {
423  lineWidth = 2;
424  }
425  if (string::npos != lineFormat.find("3"))
426  {
427  lineWidth = 3;
428  }
429  if (string::npos != lineFormat.find("4"))
430  {
431  lineWidth = 4;
432  }
433  if (string::npos != lineFormat.find("5"))
434  {
435  lineWidth = 5;
436  }
437  if (string::npos != lineFormat.find("6"))
438  {
439  lineWidth = 6;
440  }
441  if (string::npos != lineFormat.find("7"))
442  {
443  lineWidth = 7;
444  }
445  if (string::npos != lineFormat.find("8"))
446  {
447  lineWidth = 8;
448  }
449  if (string::npos != lineFormat.find("9"))
450  {
451  lineWidth = 9;
452  }
453 
454  theLayer->SetContinuity(isContinuous);
455 
456  wxPen pen(
457  wxColour(lineColor[0], lineColor[1], lineColor[2]), lineWidth,
458  lineStyle);
459  theLayer->SetPen(pen);
460 
461  theLayer->ShowName(false);
462 
463  if (updateAtTheEnd) m_plot->Refresh(false);
464 }
465 
466 // Add / Modify a 2D ellipse
467 // x[0,1]: Mean
468 // y[0,1,2]: Covariance matrix (0,0),(1,1),(0,1)
470  const CVectorFloat& x, const CVectorFloat& y, const std::string& lineFormat,
471  const std::string& plotName, bool showName)
472 {
473  mpCovarianceEllipse* theLayer;
474 
475  if (x.size() != 3 || y.size() != 3)
476  {
477  cerr << "[CWindowDialogPlots::plotEllipse] vectors do not have "
478  "expected size!!"
479  << endl;
480  return;
481  }
482 
483  wxString lyName = _U(plotName.c_str());
484  bool updateAtTheEnd = false; // If we update an existing layer, update
485  // manually to refresh the changes!
486 
487  // Already existing layer?
488  mpLayer* existingLy = m_plot->GetLayerByName(lyName);
489 
490  if (existingLy)
491  {
492  // Assure the class:
493  mpCovarianceEllipse* lyPlotEllipse =
494  static_cast<mpCovarianceEllipse*>(existingLy);
495 
496  if (!lyPlotEllipse)
497  {
498  cerr << "[CWindowDialogPlots::plotEllipse] Plot name '" << plotName
499  << "' is not of expected class mpCovarianceEllipse!." << endl;
500  return;
501  }
502 
503  // Ok:
504  theLayer = lyPlotEllipse;
505  updateAtTheEnd = true;
506  }
507  else
508  {
509  // Create it:
510  theLayer = new mpCovarianceEllipse(1, 1, 0, 2, 32, lyName);
511  m_plot->AddLayer(theLayer);
512  }
513 
514  // Set data:
515  theLayer->SetCovarianceMatrix(y[0], y[2], y[1]);
516  theLayer->SetCoordinateBase(x[0], x[1]);
517  theLayer->SetQuantiles(x[2]);
518  theLayer->ShowName(showName);
519 
520  // Line style:
521  // -------------------
522  bool isContinuous = true;
523  int lineColor[] = {0, 0, 255};
524  int lineWidth = 1;
525  int lineStyle = wxSOLID;
526 
527  // parse string:
528  if (string::npos != lineFormat.find("."))
529  {
530  isContinuous = false;
531  }
532  if (string::npos != lineFormat.find("-"))
533  {
534  isContinuous = true;
535  lineStyle = wxSOLID;
536  }
537  if (string::npos != lineFormat.find(":"))
538  {
539  isContinuous = true;
540  lineStyle = wxLONG_DASH;
541  }
542 
543  if (string::npos != lineFormat.find("r"))
544  {
545  lineColor[0] = 0xFF;
546  lineColor[1] = 0x00;
547  lineColor[2] = 0x00;
548  }
549  if (string::npos != lineFormat.find("g"))
550  {
551  lineColor[0] = 0x00;
552  lineColor[1] = 0xFF;
553  lineColor[2] = 0x00;
554  }
555  if (string::npos != lineFormat.find("b"))
556  {
557  lineColor[0] = 0x00;
558  lineColor[1] = 0x00;
559  lineColor[2] = 0xFF;
560  }
561  if (string::npos != lineFormat.find("k"))
562  {
563  lineColor[0] = 0x00;
564  lineColor[1] = 0x00;
565  lineColor[2] = 0x00;
566  }
567  if (string::npos != lineFormat.find("m"))
568  {
569  lineColor[0] = 192;
570  lineColor[1] = 0;
571  lineColor[2] = 192;
572  }
573  if (string::npos != lineFormat.find("c"))
574  {
575  lineColor[0] = 0;
576  lineColor[1] = 192;
577  lineColor[2] = 192;
578  }
579 
580  if (string::npos != lineFormat.find("1"))
581  {
582  lineWidth = 1;
583  }
584  if (string::npos != lineFormat.find("2"))
585  {
586  lineWidth = 2;
587  }
588  if (string::npos != lineFormat.find("3"))
589  {
590  lineWidth = 3;
591  }
592  if (string::npos != lineFormat.find("4"))
593  {
594  lineWidth = 4;
595  }
596  if (string::npos != lineFormat.find("5"))
597  {
598  lineWidth = 5;
599  }
600  if (string::npos != lineFormat.find("6"))
601  {
602  lineWidth = 6;
603  }
604  if (string::npos != lineFormat.find("7"))
605  {
606  lineWidth = 7;
607  }
608  if (string::npos != lineFormat.find("8"))
609  {
610  lineWidth = 8;
611  }
612  if (string::npos != lineFormat.find("9"))
613  {
614  lineWidth = 9;
615  }
616 
617  theLayer->SetContinuity(isContinuous);
618 
619  wxPen pen(
620  wxColour(lineColor[0], lineColor[1], lineColor[2]), lineWidth,
621  lineStyle);
622  theLayer->SetPen(pen);
623 
624  if (updateAtTheEnd) m_plot->Refresh(false);
625 }
626 
628  void* theWxImage, const float& x0, const float& y0, const float& w,
629  const float& h, const std::string& plotName)
630 {
631  mpBitmapLayer* theLayer;
632 
633  wxString lyName = _U(plotName.c_str());
634  bool updateAtTheEnd = false; // If we update an existing layer, update
635  // manually to refresh the changes!
636 
637  // Already existing layer?
638  mpLayer* existingLy = m_plot->GetLayerByName(lyName);
639 
640  if (existingLy)
641  {
642  // Assure the class:
643  mpBitmapLayer* ly = static_cast<mpBitmapLayer*>(existingLy);
644 
645  if (!ly)
646  {
647  cerr << "[CWindowDialogPlots::image] Plot name '" << plotName
648  << "' is not of expected class mpBitmapLayer!." << endl;
649  return;
650  }
651 
652  // Ok:
653  theLayer = ly;
654  updateAtTheEnd = true;
655  }
656  else
657  {
658  // Create it:
659  theLayer = new mpBitmapLayer();
660  m_plot->AddLayer(theLayer);
661  }
662 
663  // Set data:
664  wxImage* ii = static_cast<wxImage*>(theWxImage);
665  theLayer->SetBitmap(*ii, x0, y0, w, h);
666 
667  delete ii;
668  theWxImage = nullptr;
669 
670  if (updateAtTheEnd) m_plot->Refresh();
671 }
672 
673 #endif
674 
676  const std::string& windowCaption, unsigned int initialWindowWidth,
677  unsigned int initialWindowHeight)
678 {
681  windowCaption, initialWindowWidth, initialWindowHeight));
682 }
683 /*---------------------------------------------------------------
684  Constructor
685  ---------------------------------------------------------------*/
687  const std::string& windowCaption, unsigned int initialWidth,
688  unsigned int initialHeight)
689  : CBaseGUIWindow(static_cast<void*>(this), 400, 499, windowCaption),
690  m_holdon(false),
691  m_holdon_just_disabled(false),
692  m_holdon_cnt(0),
693  m_callback(nullptr),
694  m_callback_param(nullptr)
695 {
696  CBaseGUIWindow::createWxWindow(initialWidth, initialHeight);
697 }
698 
699 /*---------------------------------------------------------------
700  Destructor
701  ---------------------------------------------------------------*/
703 {
705 }
706 
707 /** Set cursor style to default (cursorIsCross=false) or to a cross
708  * (cursorIsCross=true) */
709 void CDisplayWindowPlots::setCursorCross(bool cursorIsCross)
710 {
711 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
713  if (!win) return;
714  win->m_plot->SetCursor(
715  *(cursorIsCross ? wxCROSS_CURSOR : wxSTANDARD_CURSOR));
716 #else
717  MRPT_UNUSED_PARAM(cursorIsCross);
718 #endif
719 }
720 
721 /*---------------------------------------------------------------
722  getLastMousePosition
723  ---------------------------------------------------------------*/
725 {
726 #if MRPT_HAS_WXWIDGETS && MRPT_HAS_OPENGL_GLUT
728  if (!win) return false;
729  x = win->m_last_mouse_point.x;
730  y = win->m_last_mouse_point.y;
731  return true;
732 #else
735  return false;
736 #endif
737 }
738 
739 /*---------------------------------------------------------------
740  resize
741  ---------------------------------------------------------------*/
742 void CDisplayWindowPlots::resize(unsigned int width, unsigned int height)
743 {
744 #if MRPT_HAS_WXWIDGETS
745  if (!isOpen())
746  {
747  cerr << "[CDisplayWindowPlots::resize] Window closed!: " << m_caption
748  << endl;
749  return;
750  }
751 
752  // Send a request to destroy this object:
755  REQ->sourcePlots = this;
756  REQ->OPCODE = 403;
757  REQ->x = width;
758  REQ->y = height;
760 #else
763 #endif
764 }
765 
766 /*---------------------------------------------------------------
767  setPos
768  ---------------------------------------------------------------*/
770 {
771 #if MRPT_HAS_WXWIDGETS
772  if (!isOpen())
773  {
774  cerr << "[CDisplayWindowPlots::setPos] Window closed!: " << m_caption
775  << endl;
776  return;
777  }
778 
779  // Send a request to destroy this object:
782  REQ->sourcePlots = this;
783  REQ->OPCODE = 402;
784  REQ->x = x;
785  REQ->y = y;
787 #else
790 #endif
791 }
792 
793 /*---------------------------------------------------------------
794  setWindowTitle
795  ---------------------------------------------------------------*/
797 {
798 #if MRPT_HAS_WXWIDGETS
799  if (!isOpen())
800  {
801  cerr << "[CDisplayWindowPlots::setWindowTitle] Window closed!: "
802  << m_caption << endl;
803  return;
804  }
805 
806  // Send a request to destroy this object:
809  REQ->sourcePlots = this;
810  REQ->OPCODE = 404;
811  REQ->str = str;
813 #else
814  MRPT_UNUSED_PARAM(str);
815 #endif
816 }
817 
818 /*---------------------------------------------------------------
819  enableMousePanZoom
820  ---------------------------------------------------------------*/
822 {
823 #if MRPT_HAS_WXWIDGETS
824  if (!isOpen()) return;
825 
826  // Send a request to destroy this object:
829  REQ->sourcePlots = this;
830  REQ->OPCODE = 410;
831  REQ->boolVal = enabled;
833 #else
834  MRPT_UNUSED_PARAM(enabled);
835 #endif
836 }
837 
838 /*---------------------------------------------------------------
839  axis_equal
840  ---------------------------------------------------------------*/
842 {
843 #if MRPT_HAS_WXWIDGETS
844  if (!isOpen()) return;
845 
846  // Send a request to destroy this object:
849  REQ->sourcePlots = this;
850  REQ->OPCODE = 411;
851  REQ->boolVal = enabled;
853 #else
854  MRPT_UNUSED_PARAM(enabled);
855 #endif
856 }
857 
858 /*---------------------------------------------------------------
859  axis
860  ---------------------------------------------------------------*/
862  float x_min, float x_max, float y_min, float y_max, bool aspectRatioFix)
863 {
864 #if MRPT_HAS_WXWIDGETS
865  if (!isOpen()) return;
866 
867  // Send a request to destroy this object:
870  REQ->sourcePlots = this;
871  REQ->OPCODE = 412;
872  REQ->vector_x.resize(2);
873  REQ->vector_x[0] = x_min;
874  REQ->vector_x[1] = x_max;
875  REQ->vector_y.resize(2);
876  REQ->vector_y[0] = y_min;
877  REQ->vector_y[1] = y_max;
878  REQ->boolVal = aspectRatioFix;
880 #else
881  MRPT_UNUSED_PARAM(x_min);
882  MRPT_UNUSED_PARAM(x_max);
883  MRPT_UNUSED_PARAM(y_min);
884  MRPT_UNUSED_PARAM(y_max);
885  MRPT_UNUSED_PARAM(aspectRatioFix);
886 #endif
887 }
888 
889 /*---------------------------------------------------------------
890  axis_fit
891  ---------------------------------------------------------------*/
892 void CDisplayWindowPlots::axis_fit(bool aspectRatioFix)
893 {
894 #if MRPT_HAS_WXWIDGETS
895  if (!isOpen()) return;
896 
897  // Send a request to destroy this object:
900  REQ->sourcePlots = this;
901  REQ->OPCODE = 413;
902  REQ->boolVal = aspectRatioFix;
904 #else
905  MRPT_UNUSED_PARAM(aspectRatioFix);
906 #endif
907 }
908 
909 /*---------------------------------------------------------------
910  plotEllipse
911  ---------------------------------------------------------------*/
912 template <typename T>
914  const T mean_x, const T mean_y, const CMatrixTemplateNumeric<T>& cov22,
915  const float quantiles, const std::string& lineFormat,
916  const std::string& plotName, bool showName)
917 {
918 #if MRPT_HAS_WXWIDGETS
919  MRPT_START
920  if (!isOpen()) return;
921 
922  ASSERT_(cov22.cols() == 2 && cov22.rows() == 2);
923  ASSERT_(cov22(0, 0) >= 0);
924  ASSERT_(cov22(1, 1) >= 0);
925  ASSERT_(cov22(0, 1) == cov22(1, 0));
926 
928  {
929  m_holdon_just_disabled = false;
930  this->clf();
931  }
932  std::string holdon_post;
933  if (m_holdon)
934  holdon_post =
935  format("_fig_%u", static_cast<unsigned int>(m_holdon_cnt++));
936 
937  // Send a request to destroy this object:
940  REQ->sourcePlots = this;
941  REQ->OPCODE = 421;
942  // 421: Add/update a 2D ellipse: format string=str, plot name =plotName,
943  // vector_x[0,1]:X/Y center, vector_y[0,1,2]: Covariance matrix entries
944  // 00,11,01.
945  REQ->str = lineFormat;
946  REQ->plotName = plotName + holdon_post;
947 
948  REQ->vector_x.resize(3);
949  REQ->vector_x[0] = mean_x;
950  REQ->vector_x[1] = mean_y;
951  REQ->vector_x[2] = quantiles;
952 
953  REQ->vector_y.resize(3);
954  REQ->vector_y[0] = cov22(0, 0);
955  REQ->vector_y[1] = cov22(1, 1);
956  REQ->vector_y[2] = cov22(0, 1);
957 
958  REQ->boolVal = showName;
959 
961  MRPT_END
962 #else
963  MRPT_UNUSED_PARAM(mean_x);
964  MRPT_UNUSED_PARAM(mean_y);
965  MRPT_UNUSED_PARAM(cov22);
966  MRPT_UNUSED_PARAM(quantiles);
967  MRPT_UNUSED_PARAM(lineFormat);
968  MRPT_UNUSED_PARAM(plotName);
969  MRPT_UNUSED_PARAM(showName);
970 #endif
971 }
972 
973 // Explicit instantations:
975  const float mean_x, const float mean_y,
976  const CMatrixTemplateNumeric<float>& cov22, const float quantiles,
977  const std::string& lineFormat, const std::string& plotName, bool showName);
979  const double mean_x, const double mean_y,
980  const CMatrixTemplateNumeric<double>& cov22, const float quantiles,
981  const std::string& lineFormat, const std::string& plotName, bool showName);
982 
983 /*---------------------------------------------------------------
984  plotEllipse
985  ---------------------------------------------------------------*/
986 template <typename T>
988  const T mean_x, const T mean_y, const CMatrixFixedNumeric<T, 2, 2>& cov22,
989  const float quantiles, const std::string& lineFormat,
990  const std::string& plotName, bool showName)
991 {
992 #if MRPT_HAS_WXWIDGETS
993  MRPT_START
994  if (!isOpen()) return;
995 
996  ASSERT_(cov22(0, 0) >= 0);
997  ASSERT_(cov22(1, 1) >= 0);
998  ASSERT_(cov22(0, 1) == cov22(1, 0));
999 
1001  {
1002  m_holdon_just_disabled = false;
1003  this->clf();
1004  }
1005  std::string holdon_post;
1006  if (m_holdon)
1007  holdon_post =
1008  format("_fig_%u", static_cast<unsigned int>(m_holdon_cnt++));
1009 
1010  // Send a request to destroy this object:
1013  REQ->sourcePlots = this;
1014  REQ->OPCODE = 421;
1015  // 421: Add/update a 2D ellipse: format string=str, plot name =plotName,
1016  // vector_x[0,1]:X/Y center, vector_y[0,1,2]: Covariance matrix entries
1017  // 00,11,01.
1018  REQ->str = lineFormat;
1019  REQ->plotName = plotName + holdon_post;
1020 
1021  REQ->vector_x.resize(3);
1022  REQ->vector_x[0] = mean_x;
1023  REQ->vector_x[1] = mean_y;
1024  REQ->vector_x[2] = quantiles;
1025 
1026  REQ->vector_y.resize(3);
1027  REQ->vector_y[0] = cov22(0, 0);
1028  REQ->vector_y[1] = cov22(1, 1);
1029  REQ->vector_y[2] = cov22(0, 1);
1030 
1031  REQ->boolVal = showName;
1032 
1034  MRPT_END
1035 #else
1036  MRPT_UNUSED_PARAM(mean_x);
1037  MRPT_UNUSED_PARAM(mean_y);
1038  MRPT_UNUSED_PARAM(cov22);
1039  MRPT_UNUSED_PARAM(quantiles);
1040  MRPT_UNUSED_PARAM(lineFormat);
1041  MRPT_UNUSED_PARAM(plotName);
1042  MRPT_UNUSED_PARAM(showName);
1043 #endif
1044 }
1045 
1046 // Explicit instantations:
1047 template void CDisplayWindowPlots::plotEllipse(
1048  const float mean_x, const float mean_y,
1049  const CMatrixFixedNumeric<float, 2, 2>& cov22, const float quantiles,
1050  const std::string& lineFormat, const std::string& plotName, bool showName);
1051 template void CDisplayWindowPlots::plotEllipse(
1052  const double mean_x, const double mean_y,
1053  const CMatrixFixedNumeric<double, 2, 2>& cov22, const float quantiles,
1054  const std::string& lineFormat, const std::string& plotName, bool showName);
1055 
1056 /*---------------------------------------------------------------
1057  image
1058  ---------------------------------------------------------------*/
1060  const mrpt::img::CImage& img, const float& x_left, const float& y_bottom,
1061  const float& x_width, const float& y_height, const std::string& plotName)
1062 {
1063 #if MRPT_HAS_WXWIDGETS
1064  MRPT_START
1065  if (!isOpen()) return;
1066 
1068  {
1069  m_holdon_just_disabled = false;
1070  this->clf();
1071  }
1072  std::string holdon_post;
1073  if (m_holdon)
1074  holdon_post =
1075  format("_fig_%u", static_cast<unsigned int>(m_holdon_cnt++));
1076 
1077  // Send a request to destroy this object:
1080  REQ->sourcePlots = this;
1081  REQ->OPCODE = 422;
1082 
1083  // 422: Add/update a bitmap: plot name =plotName, vector_x[0,1]:X/Y corner,
1084  // vector_x[2,3]: X/Y widths, voidPtr2: pointer to a newly created wxImage
1085  // with the bitmap.
1086  REQ->plotName = plotName + holdon_post;
1087 
1088  REQ->vector_x.resize(4);
1089  REQ->vector_x[0] = x_left;
1090  REQ->vector_x[1] = y_bottom;
1091  REQ->vector_x[2] = x_width;
1092  REQ->vector_x[3] = y_height;
1093 
1095 
1097  MRPT_END
1098 #else
1100  MRPT_UNUSED_PARAM(x_left);
1101  MRPT_UNUSED_PARAM(y_bottom);
1102  MRPT_UNUSED_PARAM(x_width);
1103  MRPT_UNUSED_PARAM(y_height);
1104  MRPT_UNUSED_PARAM(plotName);
1105 #endif
1106 }
1107 
1108 /*---------------------------------------------------------------
1109  internal_plot
1110  ---------------------------------------------------------------*/
1112  CVectorFloat& x, CVectorFloat& y, const std::string& lineFormat,
1113  const std::string& plotName)
1114 {
1115 #if MRPT_HAS_WXWIDGETS
1116  MRPT_START
1117  if (!isOpen()) return;
1118 
1119  ASSERT_EQUAL_(x.size(), y.size());
1120 
1122  {
1123  m_holdon_just_disabled = false;
1124  this->clf();
1125  }
1126 
1127  if (x.empty()) return;
1128 
1129  std::string holdon_post;
1130  if (m_holdon)
1131  holdon_post =
1132  format("_fig_%u", static_cast<unsigned int>(m_holdon_cnt++));
1133 
1134  // Send a request to destroy this object:
1137  REQ->sourcePlots = this;
1138  REQ->OPCODE = 420;
1139  REQ->str = lineFormat;
1140  REQ->plotName = plotName + holdon_post;
1141  REQ->vector_x.swap(x);
1142  REQ->vector_y.swap(y);
1143 
1145  MRPT_END
1146 #else
1149  MRPT_UNUSED_PARAM(lineFormat);
1150  MRPT_UNUSED_PARAM(plotName);
1151 #endif
1152 }
1153 
1154 /*---------------------------------------------------------------
1155  clear
1156  ---------------------------------------------------------------*/
1158 {
1159  MRPT_START
1160 #if MRPT_HAS_WXWIDGETS
1161  if (!isOpen()) return;
1162 
1163  // Send a request to destroy this object:
1166  REQ->sourcePlots = this;
1167  REQ->OPCODE = 414;
1168 
1169  // 414: Clear all plot objects.
1170 
1172 #endif
1173  MRPT_END
1174 }
1175 
1176 /*---------------------------------------------------------------
1177  hold_on
1178  ---------------------------------------------------------------*/
1180 /*---------------------------------------------------------------
1181  hold_off
1182  ---------------------------------------------------------------*/
1184 {
1185  if (m_holdon)
1186  {
1187  m_holdon = false;
1188  m_holdon_just_disabled = true;
1189  }
1190 }
1191 
1192 /*---------------------------------------------------------------
1193  addPopupMenuEntry
1194  ---------------------------------------------------------------*/
1196  const std::string& label, int menuID)
1197 {
1198 #if MRPT_HAS_WXWIDGETS
1199  MRPT_START
1200  if (!isOpen()) return;
1201 
1204  REQ->sourcePlots = this;
1205  REQ->OPCODE = 440;
1206  REQ->plotName = label;
1207  REQ->x = menuID;
1208  // 440: Inser submenu in the popup menu.
1209 
1211  MRPT_END
1212 #else
1213  MRPT_UNUSED_PARAM(label);
1214  MRPT_UNUSED_PARAM(menuID);
1215 #endif
1216 }
1217 
1218 /*---------------------------------------------------------------
1219  setMenuCallback
1220  ---------------------------------------------------------------*/
1222  TCallbackMenu userFunction, void* userParam)
1223 {
1224  ASSERT_(userFunction != nullptr);
1225  m_callback = userFunction;
1226  m_callback_param = userParam;
1227 }
mrpt::gui::mrptEventWindowClosed::allow_close
bool allow_close
Definition: CBaseGUIWindow.h:292
os.h
mrpt::gui::WxSubsystem::TRequestToWxMainThread::sourcePlots
mrpt::gui::CDisplayWindowPlots * sourcePlots
Only one of source* can be non-nullptr, indicating the class that generated the request.
Definition: WxSubsystem.h:217
mrpt::gui::keyEventToMrptKeyModifier
mrptKeyModifier keyEventToMrptKeyModifier(const wxKeyEvent &ev)
Extracts the key modifiers from a wxKeyEvent.
Definition: WxUtils.cpp:1135
ID_MENUITEM1
const long ID_MENUITEM1
Definition: CDisplayWindowPlots.cpp:36
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
const_iterator
const Scalar * const_iterator
Definition: eigen_plugins.h:27
mrpt::gui::MRPTImage2wxImage
wxImage * MRPTImage2wxImage(const mrpt::img::CImage &img)
Create a wxImage from a MRPT image.
Definition: WxUtils.cpp:28
mrpt::gui::CDisplayWindowPlots::Ptr
std::shared_ptr< CDisplayWindowPlots > Ptr
Definition: CDisplayWindowPlots.h:34
ASSERT_EQUAL_
#define ASSERT_EQUAL_(__A, __B)
Assert comparing two values, reporting their actual values upon failure.
Definition: exceptions.h:153
mrpt::gui::CDisplayWindowPlots::Create
static CDisplayWindowPlots::Ptr Create(const std::string &windowCaption, unsigned int initialWindowWidth=400, unsigned int initialWindowHeight=300)
Class factory returning a smart pointer.
Definition: CDisplayWindowPlots.cpp:675
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:259
mrpt::math::dynamic_vector
Column vector, like Eigen::MatrixX*, but automatically initialized to zeros since construction.
Definition: eigen_frwds.h:44
mrpt::gui::CDisplayWindowPlots::axis_equal
void axis_equal(bool enable=true)
Enable/disable the fixed X/Y aspect ratio fix feature (default=disabled).
Definition: CDisplayWindowPlots.cpp:841
mrpt::gui::CDisplayWindowPlots::internal_plot
void internal_plot(mrpt::math::CVectorFloat &x, mrpt::math::CVectorFloat &y, const std::string &lineFormat, const std::string &plotName)
Definition: CDisplayWindowPlots.cpp:1111
mrpt::gui::CWindowDialogPlots::OnResize
void OnResize(wxSizeEvent &event)
Definition: CDisplayWindowPlots.cpp:219
mrpt::gui::CDisplayWindowPlots::resize
void resize(unsigned int width, unsigned int height) override
Resizes the window, stretching the image to fit into the display area.
Definition: CDisplayWindowPlots.cpp:742
WxSubsystem.h
mrpt::gui::CWindowDialogPlots::OnChar
void OnChar(wxKeyEvent &event)
Definition: CDisplayWindowPlots.cpp:196
mrpt::gui::CWindowDialogPlots::plotEllipse
void plotEllipse(const mrpt::math::CVectorFloat &x, const mrpt::math::CVectorFloat &y, const std::string &lineFormat, const std::string &plotName, bool showName=false)
Redirected from CDisplayWindowPlots::plotEllipse.
Definition: CDisplayWindowPlots.cpp:469
mrpt::gui::CDisplayWindowPlots::addPopupMenuEntry
void addPopupMenuEntry(const std::string &label, int menuID)
Disables keeping all the graphs (this is the default behavior).
Definition: CDisplayWindowPlots.cpp:1195
mrpt::gui::CWindowDialogPlots::OnMenuSelected
void OnMenuSelected(wxCommandEvent &ev)
Definition: CDisplayWindowPlots.cpp:273
MRPT_UNUSED_PARAM
#define MRPT_UNUSED_PARAM(a)
Determines whether this is an X86 or AMD64 platform.
Definition: common.h:186
mrpt::gui::CDisplayWindowPlots::axis
void axis(float x_min, float x_max, float y_min, float y_max, bool aspectRatioFix=false)
Set the view area according to the passed coordinated.
Definition: CDisplayWindowPlots.cpp:861
mrpt::gui::CDisplayWindowPlots::enableMousePanZoom
void enableMousePanZoom(bool enabled)
Enable/disable the feature of pan/zoom with the mouse (default=enabled)
Definition: CDisplayWindowPlots.cpp:821
mrpt::gui::mrptEventMouseMove
An event sent by a window when the mouse is moved over it.
Definition: CBaseGUIWindow.h:246
mrpt::gui::CDisplayWindowPlots::setMenuCallback
void setMenuCallback(TCallbackMenu userFunction, void *userParam=nullptr)
Must be called to have a callback when the user selects one of the user-defined entries in the popup ...
Definition: CDisplayWindowPlots.cpp:1221
mrpt::gui::CWindowDialogPlots::OnMenuClose
void OnMenuClose(wxCommandEvent &event)
Definition: CDisplayWindowPlots.cpp:258
mrpt::gui::CWindowDialogPlots::plot
void plot(const mrpt::math::CVectorFloat &x, const mrpt::math::CVectorFloat &y, const std::string &lineFormat, const std::string &plotName)
Redirected from CDisplayWindowPlots::plot.
Definition: CDisplayWindowPlots.cpp:313
mrpt::gui::mrptEventWindowChar
An event sent by a window upon a char pressed by the user.
Definition: CBaseGUIWindow.h:167
mrpt::gui::CWindowDialogPlots::~CWindowDialogPlots
virtual ~CWindowDialogPlots()
Definition: CDisplayWindowPlots.cpp:167
mrpt
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
Definition: CKalmanFilterCapable.h:30
w
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:4178
mrpt::gui::CWindowDialogPlots::OnMenuPrint
void OnMenuPrint(wxCommandEvent &event)
Definition: CDisplayWindowPlots.cpp:260
mrpt::gui::CWindowDialogPlots::OnMouseMove
void OnMouseMove(wxMouseEvent &event)
Definition: CDisplayWindowPlots.cpp:285
ASSERT_
#define ASSERT_(f)
Defines an assertion mechanism.
Definition: exceptions.h:113
mrpt::gui::CDisplayWindowPlots::hold_off
void hold_off()
Disables keeping all the graphs (this is the default behavior).
Definition: CDisplayWindowPlots.cpp:1183
mrpt::gui::mrptEventWindowResize
An event sent by a window upon resize.
Definition: CBaseGUIWindow.h:193
mrpt::gui::WxSubsystem
This class implements the GUI thread required for the wxWidgets-based GUI.
Definition: WxSubsystem.h:99
mrpt::gui::CDisplayWindowPlots::image
void image(const mrpt::img::CImage &img, const float &x_left, const float &y_bottom, const float &x_width, const float &y_height, const std::string &plotName=std::string("image"))
Adds a bitmap image layer.
Definition: CDisplayWindowPlots.cpp:1059
WxUtils.h
mrpt::gui::WxSubsystem::TRequestToWxMainThread::vector_x
mrpt::math::CVectorFloat vector_x
Definition: WxSubsystem.h:232
mrpt::math::CMatrixTemplateNumeric
A matrix of dynamic size.
Definition: CMatrixTemplateNumeric.h:37
mrpt::gui::CDisplayWindowPlots::plotEllipse
void plotEllipse(const T mean_x, const T mean_y, const mrpt::math::CMatrixTemplateNumeric< T > &cov22, const float quantiles, const std::string &lineFormat=std::string("b-"), const std::string &plotName=std::string("plotEllipse"), bool showName=false)
Plots a 2D ellipse given its mean, covariance matrix, and Each call to this function creates a new pl...
Definition: CDisplayWindowPlots.cpp:913
mrpt::gui::WxSubsystem::getMRPTDefaultIcon
static wxBitmap getMRPTDefaultIcon()
Definition: WxSubsystem.cpp:846
mrpt::gui::WxSubsystem::CWXMainFrame::notifyWindowCreation
static int notifyWindowCreation()
Atomically increments the number of windows created with the main frame as parent.
Definition: WxSubsystem.cpp:198
ID_MENUITEM2
const long ID_MENUITEM2
Definition: CDisplayWindowPlots.cpp:37
mrpt::gui::WxSubsystem::CWXMainFrame::notifyWindowDestruction
static int notifyWindowDestruction()
Atomically decrements the number of windows created with the main frame as parent.
Definition: WxSubsystem.cpp:204
mrpt::gui::CBaseGUIWindow
The base class for GUI window classes.
Definition: CBaseGUIWindow.h:42
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::WxSubsystem::TRequestToWxMainThread::str
std::string str
Parameters, depending on OPCODE.
Definition: WxSubsystem.h:225
mrpt::gui::CBaseGUIWindow::isOpen
bool isOpen()
Returns false if the user has already closed the window.
Definition: CBaseGUIWindow.cpp:213
data
GLsizei GLsizei GLenum GLenum const GLvoid * data
Definition: glext.h:3547
mrpt::gui::WxSubsystem::TRequestToWxMainThread
The data structure for each inter-thread request:
Definition: WxSubsystem.h:192
mrpt::gui::CDisplayWindowPlots::axis_fit
void axis_fit(bool aspectRatioFix=false)
Fix automatically the view area according to existing graphs.
Definition: CDisplayWindowPlots.cpp:892
mrpt::gui::WxSubsystem::TRequestToWxMainThread::boolVal
bool boolVal
Definition: WxSubsystem.h:231
mrpt::gui::CDisplayWindowPlots::setPos
void setPos(int x, int y) override
Changes the position of the window on the screen.
Definition: CDisplayWindowPlots.cpp:769
MRPT_START
#define MRPT_START
Definition: exceptions.h:262
mrpt::gui::CBaseGUIWindow::m_caption
std::string m_caption
The caption of the window.
Definition: CBaseGUIWindow.h:62
win
mrpt::gui::CDisplayWindow3D::Ptr win
Definition: vision_stereo_rectify/test.cpp:31
mrpt::format
std::string format(const char *fmt,...) MRPT_printf_format_check(1
A std::string version of C sprintf.
Definition: format.cpp:16
mrpt::gui::CBaseGUIWindow::m_hwnd
mrpt::void_ptr_noncopy m_hwnd
The window handle.
Definition: CBaseGUIWindow.h:64
mrpt::gui::CWindowDialogPlots::OnClose
void OnClose(wxCloseEvent &event)
Definition: CDisplayWindowPlots.cpp:169
mrpt::gui::WxSubsystem::TRequestToWxMainThread::OPCODE
int OPCODE
Valid codes are: For CDisplayWindow:
Definition: WxSubsystem.h:299
mrpt::gui::CWindowDialogPlots::OnMenuAbout
void OnMenuAbout(wxCommandEvent &event)
Definition: CDisplayWindowPlots.cpp:265
mrpt::gui::WxSubsystem::TRequestToWxMainThread::y
int y
Definition: WxSubsystem.h:230
mrpt::gui::CDisplayWindowPlots::TCallbackMenu
void(*)(int menuID, float cursor_x, float cursor_y, void *userParam) TCallbackMenu
Type for the callback function used in setMenuCallback.
Definition: CDisplayWindowPlots.h:38
mrpt::gui::WxSubsystem::TRequestToWxMainThread::plotName
std::string plotName
Definition: WxSubsystem.h:233
gui-precomp.h
mrpt::gui::CDisplayWindowPlots::m_holdon
bool m_holdon
Whether hold_on is enabled.
Definition: CDisplayWindowPlots.h:44
mrpt::gui
Classes for creating GUI windows for 2D and 3D visualization.
Definition: about_box.h:16
utils.h
mrpt::gui::CDisplayWindowPlots::m_holdon_just_disabled
bool m_holdon_just_disabled
Definition: CDisplayWindowPlots.h:45
mrpt::math::CMatrixFixedNumeric
A numeric matrix of compile-time fixed size.
Definition: CMatrixFixedNumeric.h:40
height
GLenum GLsizei GLsizei height
Definition: glext.h:3554
mrpt::img::CImage
A class for storing images as grayscale or RGB bitmaps.
Definition: img/CImage.h:130
mrpt::gui::CDisplayWindowPlots
Create a GUI window and display plots with MATLAB-like interfaces and commands.
Definition: CDisplayWindowPlots.h:31
mrpt::gui::CDisplayWindowPlots::clf
void clf()
Remove all plot objects in the display (clear and clf do exactly the same).
Definition: CDisplayWindowPlots.h:281
mrpt::gui::CDisplayWindowPlots::m_holdon_cnt
uint32_t m_holdon_cnt
Counter for hold_on.
Definition: CDisplayWindowPlots.h:47
mrpt::gui::CDisplayWindowPlots::clear
void clear()
Remove all plot objects in the display.
Definition: CDisplayWindowPlots.cpp:1157
mrpt::gui::CDisplayWindowPlots::~CDisplayWindowPlots
virtual ~CDisplayWindowPlots()
Destructor.
Definition: CDisplayWindowPlots.cpp:702
mrpt::gui::CDisplayWindowPlots::getLastMousePosition
virtual bool getLastMousePosition(int &x, int &y) const override
Gets the last x,y pixel coordinates of the mouse.
Definition: CDisplayWindowPlots.cpp:724
img
GLint GLvoid * img
Definition: glext.h:3763
width
GLenum GLsizei width
Definition: glext.h:3531
MRPT_END
#define MRPT_END
Definition: exceptions.h:266
void
typedef void(APIENTRYP PFNGLBLENDCOLORPROC)(GLclampf red
mrpt::gui::mrptKeyModifier
mrptKeyModifier
Definition: keycodes.h:159
mrpt::math
This base provides a set of functions for maths stuff.
Definition: math/include/mrpt/math/bits_math.h:13
mrpt::gui::WxSubsystem::TRequestToWxMainThread::x
int x
Definition: WxSubsystem.h:230
mrpt::gui::CDisplayWindowPlots::m_callback
TCallbackMenu m_callback
Definition: CDisplayWindowPlots.h:48
mrpt::gui::WxSubsystem::TRequestToWxMainThread::vector_y
mrpt::math::CVectorFloat vector_y
Definition: WxSubsystem.h:232
mrpt::gui::CWindowDialogPlots::OnMouseDown
void OnMouseDown(wxMouseEvent &event)
Definition: CDisplayWindowPlots.cpp:238
string
GLsizei const GLchar ** string
Definition: glext.h:4101
CImage.h
mrpt::gui::CDisplayWindowPlots::setCursorCross
virtual void setCursorCross(bool cursorIsCross) override
Set cursor style to default (cursorIsCross=false) or to a cross (cursorIsCross=true)
Definition: CDisplayWindowPlots.cpp:709
mrpt::gui::CWindowDialogPlots::image
void image(void *theWxImage, const float &x0, const float &y0, const float &w, const float &h, const std::string &plotName)
Redirected from CDisplayWindowPlots::image.
Definition: CDisplayWindowPlots.cpp:627
mrpt::gui::CDisplayWindowPlots::CDisplayWindowPlots
CDisplayWindowPlots(const std::string &windowCaption=std::string(), unsigned int initialWidth=350, unsigned int initialHeight=300)
Constructor.
Definition: CDisplayWindowPlots.cpp:686
code
Definition: inftrees.h:28
mrpt::img::TPixelCoord
A pair (x,y) of pixel coordinates (integer resolution).
Definition: TPixelCoord.h:39
mrpt::gui::CDisplayWindowPlots::setWindowTitle
void setWindowTitle(const std::string &str) override
Changes the window title text.
Definition: CDisplayWindowPlots.cpp:796
mrpt::gui::CDisplayWindowPlots::hold_on
void hold_on()
Enables keeping all the graphs, instead of overwritting them.
Definition: CDisplayWindowPlots.cpp:1179
mrpt::gui::CBaseGUIWindow::destroyWxWindow
void destroyWxWindow()
Must be called by child classes in their destructors.
Definition: CBaseGUIWindow.cpp:105
mrpt::gui::CDisplayWindowPlots::m_callback_param
void * m_callback_param
Definition: CDisplayWindowPlots.h:49
CDisplayWindowPlots.h
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:281
mrpt::gui::CWindowDialogPlots
The wx dialog for gui::CDisplayWindowPlots.
Definition: WxSubsystem.h:440
y
GLenum GLint GLint y
Definition: glext.h:3538
_U
#define _U(x)
Definition: WxSubsystem.h:505
x
GLenum GLint x
Definition: glext.h:3538
mrpt::non_copiable_ptr_basic::get
T *& get()
Definition: safe_pointers.h:146
mrpt::system
This namespace provides a OS-independent interface to many useful functions: filenames manipulation,...
Definition: math_frwds.h:25
mrpt::gui::WxSubsystem::TRequestToWxMainThread::voidPtr2
void * voidPtr2
Definition: WxSubsystem.h:229
mrpt::system::os::memcpy
void memcpy(void *dest, size_t destSize, const void *src, size_t copyCount) noexcept
An OS and compiler independent version of "memcpy".
Definition: os.cpp:356



Page generated by Doxygen 1.8.17 for MRPT 1.9.9 Git: ad3a9d8ae Tue May 1 23:10:22 2018 -0700 at miƩ 12 jul 2023 10:03:34 CEST