/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          https://www.mrpt.org/                         |
   |                                                                        |
   | Copyright (c) 2005-2024, Individual contributors, see AUTHORS file     |
   | See: https://www.mrpt.org/Authors - All rights reserved.               |
   | Released under BSD License. See: https://www.mrpt.org/License          |
   +------------------------------------------------------------------------+ */

#include "reactive_navigator_demoMain.h"

#include <wx/msgdlg.h>
#include <wx/textdlg.h>

#include <memory>

//(*InternalHeaders(reactive_navigator_demoframe)
#include <wx/artprov.h>
#include <wx/bitmap.h>
#include <wx/font.h>
#include <wx/image.h>
#include <wx/intl.h>
#include <wx/settings.h>
#include <wx/string.h>
#include <wx/tglbtn.h>
//*)

#include <mrpt/config/CConfigFilePrefixer.h>
#include <mrpt/gui/WxUtils.h>
#include <mrpt/gui/about_box.h>
#include <mrpt/io/CFileGZInputStream.h>
#include <mrpt/io/CFileGZOutputStream.h>
#include <mrpt/math/TLine3D.h>
#include <mrpt/math/TObject3D.h>
#include <mrpt/poses/CPoint2D.h>
#include <mrpt/poses/CPose2D.h>

#include "../wx-common/mrpt_logo.xpm"
#include "DEFAULT_GRIDMAP_DATA.h"
#include "imgs/main_icon.xpm"

const double NAV_SIMUL_TIMESTEP_MS = 25;

// A custom Art provider for customizing the icons:
class MyArtProvider : public wxArtProvider
{
 protected:
  wxBitmap CreateBitmap(const wxArtID& id, const wxArtClient& client, const wxSize& size) override;
};

// CreateBitmap function
wxBitmap MyArtProvider::CreateBitmap(
    const wxArtID& id, const wxArtClient& client, const wxSize& size)
{
  if (id == wxART_MAKE_ART_ID(MAIN_ICON)) return wxBitmap(main_icon_xpm);
  if (id == wxART_MAKE_ART_ID(IMG_MRPT_LOGO)) return wxBitmap(mrpt_logo_xpm);

  // Any wxWidgets icons not implemented here
  // will be provided by the default art provider.
  return wxNullBitmap;
}

#include <mrpt/nav.h>
#include <mrpt/opengl.h>
#include <mrpt/serialization/CArchive.h>
#include <mrpt/system/filesystem.h>
#include <mrpt/system/os.h>

using namespace mrpt;
using namespace mrpt::maps;
using namespace mrpt::obs;
using namespace mrpt::opengl;
using namespace mrpt::io;
using namespace mrpt::config;
using namespace mrpt::img;
using namespace mrpt::serialization;
using namespace mrpt::math;
using namespace mrpt::system;
using namespace mrpt::nav;
using namespace mrpt::poses;
using namespace std;

//(*IdInit(reactive_navigator_demoframe)
const long reactive_navigator_demoframe::ID_BUTTON4 = wxNewId();
const long reactive_navigator_demoframe::ID_BUTTON5 = wxNewId();
const long reactive_navigator_demoframe::ID_BUTTON7 = wxNewId();
const long reactive_navigator_demoframe::ID_BUTTON12 = wxNewId();
const long reactive_navigator_demoframe::ID_STATICTEXT10 = wxNewId();
const long reactive_navigator_demoframe::ID_STATICTEXT9 = wxNewId();
const long reactive_navigator_demoframe::ID_STATICTEXT8 = wxNewId();
const long reactive_navigator_demoframe::ID_TEXTCTRL6 = wxNewId();
const long reactive_navigator_demoframe::ID_BUTTON6 = wxNewId();
const long reactive_navigator_demoframe::ID_BUTTON8 = wxNewId();
const long reactive_navigator_demoframe::ID_BUTTON11 = wxNewId();
const long reactive_navigator_demoframe::ID_BUTTON1 = wxNewId();
const long reactive_navigator_demoframe::ID_BUTTON9 = wxNewId();
const long reactive_navigator_demoframe::ID_BUTTON10 = wxNewId();
const long reactive_navigator_demoframe::ID_BUTTON2 = wxNewId();
const long reactive_navigator_demoframe::ID_BUTTON3 = wxNewId();
const long reactive_navigator_demoframe::ID_RADIOBOX2 = wxNewId();
const long reactive_navigator_demoframe::ID_CHECKBOX1 = wxNewId();
const long reactive_navigator_demoframe::ID_CHECKBOX2 = wxNewId();
const long reactive_navigator_demoframe::ID_CHECKBOX3 = wxNewId();
const long reactive_navigator_demoframe::ID_CHECKBOX4 = wxNewId();
const long reactive_navigator_demoframe::ID_CHECKBOX5 = wxNewId();
const long reactive_navigator_demoframe::ID_RADIOBOX1 = wxNewId();
const long reactive_navigator_demoframe::ID_BUTTON13 = wxNewId();
const long reactive_navigator_demoframe::ID_PANEL6 = wxNewId();
const long reactive_navigator_demoframe::ID_TEXTCTRL1 = wxNewId();
const long reactive_navigator_demoframe::ID_PANEL2 = wxNewId();
const long reactive_navigator_demoframe::ID_TEXTCTRL4 = wxNewId();
const long reactive_navigator_demoframe::ID_PANEL4 = wxNewId();
const long reactive_navigator_demoframe::ID_TEXTCTRL3 = wxNewId();
const long reactive_navigator_demoframe::ID_PANEL3 = wxNewId();
const long reactive_navigator_demoframe::ID_NOTEBOOK1 = wxNewId();
const long reactive_navigator_demoframe::ID_PANEL1 = wxNewId();
const long reactive_navigator_demoframe::ID_STATICTEXT3 = wxNewId();
const long reactive_navigator_demoframe::ID_TEXTCTRL5 = wxNewId();
const long reactive_navigator_demoframe::ID_PANEL7 = wxNewId();
const long reactive_navigator_demoframe::ID_STATICTEXT2 = wxNewId();
const long reactive_navigator_demoframe::ID_STATICTEXT1 = wxNewId();
const long reactive_navigator_demoframe::ID_XY_GLCANVAS = wxNewId();
const long reactive_navigator_demoframe::ID_STATICTEXT4 = wxNewId();
const long reactive_navigator_demoframe::ID_CHOICE1 = wxNewId();
const long reactive_navigator_demoframe::ID_CUSTOM1 = wxNewId();
const long reactive_navigator_demoframe::ID_TEXTCTRL2 = wxNewId();
const long reactive_navigator_demoframe::ID_PANEL8 = wxNewId();
const long reactive_navigator_demoframe::ID_SPLITTERWINDOW2 = wxNewId();
const long reactive_navigator_demoframe::ID_PANEL5 = wxNewId();
const long reactive_navigator_demoframe::ID_SPLITTERWINDOW1 = wxNewId();
const long reactive_navigator_demoframe::ID_MENUITEM4 = wxNewId();
const long reactive_navigator_demoframe::idMenuQuit = wxNewId();
const long reactive_navigator_demoframe::ID_MENUITEM1 = wxNewId();
const long reactive_navigator_demoframe::ID_MENUITEM2 = wxNewId();
const long reactive_navigator_demoframe::ID_MENUITEM3 = wxNewId();
const long reactive_navigator_demoframe::idMenuAbout = wxNewId();
const long reactive_navigator_demoframe::ID_STATUSBAR1 = wxNewId();
const long reactive_navigator_demoframe::ID_TIMER1 = wxNewId();
//*)

BEGIN_EVENT_TABLE(reactive_navigator_demoframe, wxFrame)
//(*EventTable(reactive_navigator_demoframe)
//*)
END_EVENT_TABLE()

reactive_navigator_demoframe::reactive_navigator_demoframe(wxWindow* parent, wxWindowID id) :
    m_gridMap(),
    m_targetPoint(.0, .0),
    m_is_running(false),
    m_curCursorPos(0, 0),
    m_cursorPickState(cpsNone)
{
  // Load my custom icons:
  wxArtProvider::Push(new MyArtProvider);

  //(*Initialize(reactive_navigator_demoframe)
  wxFlexGridSizer* FlexGridSizer4;
  wxMenuItem* MenuItem2;
  wxFlexGridSizer* FlexGridSizer10;
  wxFlexGridSizer* FlexGridSizer3;
  wxMenuItem* MenuItem1;
  wxFlexGridSizer* FlexGridSizer5;
  wxFlexGridSizer* FlexGridSizer9;
  wxFlexGridSizer* FlexGridSizer2;
  wxMenu* Menu1;
  wxFlexGridSizer* FlexGridSizer7;
  wxFlexGridSizer* FlexGridSizer8;
  wxFlexGridSizer* FlexGridSizer12;
  wxMenuBar* MenuBar1;
  wxFlexGridSizer* FlexGridSizer6;
  wxFlexGridSizer* FlexGridSizer1;
  wxFlexGridSizer* FlexGridSizer11;
  wxBoxSizer* BoxSizer3;
  wxMenu* Menu2;

  Create(
      parent, wxID_ANY, _("Reactive Navigation Tester - Part of MRPT"), wxDefaultPosition,
      wxDefaultSize, wxDEFAULT_FRAME_STYLE, _T("wxID_ANY"));
  SetClientSize(wxSize(893, 576));
  {
    wxIcon FrameIcon;
    FrameIcon.CopyFromBitmap(
        wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("MAIN_ICON")), wxART_OTHER));
    SetIcon(FrameIcon);
  }
  FlexGridSizer1 = new wxFlexGridSizer(1, 2, 0, 0);
  FlexGridSizer1->AddGrowableCol(1);
  FlexGridSizer1->AddGrowableRow(0);
  FlexGridSizer4 = new wxFlexGridSizer(0, 1, 0, 0);
  FlexGridSizer4->AddGrowableCol(0);
  btnStart = new wxCustomButton(
      this, ID_BUTTON4, _("RUN"),
      wxArtProvider::GetBitmap(
          wxART_MAKE_ART_ID_FROM_STR(_T("wxART_GO_FORWARD")),
          wxART_MAKE_CLIENT_ID_FROM_STR(wxString(wxEmptyString))),
      wxDefaultPosition, wxSize(-1, 60), wxCUSTBUT_BUTTON | wxCUSTBUT_BOTTOM, wxDefaultValidator,
      _T("ID_BUTTON4"));
  btnStart->SetBitmapDisabled(btnStart->CreateBitmapDisabled(btnStart->GetBitmapLabel()));
  btnStart->SetBitmapMargin(wxSize(2, 4));
  FlexGridSizer4->Add(btnStart, 1, wxEXPAND, 2);
  btnStop = new wxCustomButton(
      this, ID_BUTTON5, _("STOP"),
      wxArtProvider::GetBitmap(
          wxART_MAKE_ART_ID_FROM_STR(_T("wxART_CROSS_MARK")),
          wxART_MAKE_CLIENT_ID_FROM_STR(wxString(wxEmptyString))),
      wxDefaultPosition, wxSize(-1, 60), wxCUSTBUT_BUTTON | wxCUSTBUT_BOTTOM, wxDefaultValidator,
      _T("ID_BUTTON5"));
  btnStop->SetBitmapDisabled(btnStop->CreateBitmapDisabled(btnStop->GetBitmapLabel()));
  btnStop->SetBitmapMargin(wxSize(2, 4));
  FlexGridSizer4->Add(btnStop, 1, wxEXPAND, 2);
  FlexGridSizer4->Add(-1, -1, 1, wxALL | wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL, 1);
  btnPlaceTarget = new wxCustomButton(
      this, ID_BUTTON7, _("Set target..."),
      wxArtProvider::GetBitmap(
          wxART_MAKE_ART_ID_FROM_STR(_T("wxART_FIND")),
          wxART_MAKE_CLIENT_ID_FROM_STR(wxString(wxEmptyString))),
      wxDefaultPosition, wxSize(-1, 60), wxCUSTBUT_BUTTON | wxCUSTBUT_BOTTOM, wxDefaultValidator,
      _T("ID_BUTTON7"));
  btnPlaceTarget->SetBitmapDisabled(
      btnPlaceTarget->CreateBitmapDisabled(btnPlaceTarget->GetBitmapLabel()));
  btnPlaceTarget->SetBitmapMargin(wxSize(2, 4));
  FlexGridSizer4->Add(btnPlaceTarget, 1, wxEXPAND, 2);
  btnSetWaypointSeq = new wxCustomButton(
      this, ID_BUTTON12, _("Waypoint list..."),
      wxArtProvider::GetBitmap(
          wxART_MAKE_ART_ID_FROM_STR(_T("wxART_FIND")),
          wxART_MAKE_CLIENT_ID_FROM_STR(wxString(wxEmptyString))),
      wxDefaultPosition, wxSize(-1, 60), wxCUSTBUT_BUTTON | wxCUSTBUT_BOTTOM, wxDefaultValidator,
      _T("ID_BUTTON12"));
  btnSetWaypointSeq->SetBitmapDisabled(
      btnSetWaypointSeq->CreateBitmapDisabled(btnSetWaypointSeq->GetBitmapLabel()));
  btnSetWaypointSeq->SetBitmapMargin(wxSize(2, 4));
  FlexGridSizer4->Add(btnSetWaypointSeq, 1, wxEXPAND, 2);
  StaticText8 = new wxStaticText(
      this, ID_STATICTEXT10, _("(non-skip:SHIFT+click)"), wxDefaultPosition, wxDefaultSize, 0,
      _T("ID_STATICTEXT10"));
  FlexGridSizer4->Add(StaticText8, 1, wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL, 5);
  StaticText7 = new wxStaticText(
      this, ID_STATICTEXT9, _("(with yaw: CTRL+click)"), wxDefaultPosition, wxDefaultSize, 0,
      _T("ID_STATICTEXT9"));
  FlexGridSizer4->Add(StaticText7, 1, wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL, 5);
  StaticText6 = new wxStaticText(
      this, ID_STATICTEXT8, _("Waypt yaw (deg):"), wxDefaultPosition, wxDefaultSize, 0,
      _T("ID_STATICTEXT8"));
  FlexGridSizer4->Add(StaticText6, 1, wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL, 5);
  edWayPtHeading = new wxTextCtrl(
      this, ID_TEXTCTRL6, _("0.0"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator,
      _T("ID_TEXTCTRL6"));
  FlexGridSizer4->Add(
      edWayPtHeading, 1, wxALL | wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL, 5);
  btnPlaceRobot = new wxCustomButton(
      this, ID_BUTTON6, _("Replace robot..."),
      wxArtProvider::GetBitmap(
          wxART_MAKE_ART_ID_FROM_STR(_T("wxART_FIND")),
          wxART_MAKE_CLIENT_ID_FROM_STR(wxString(wxEmptyString))),
      wxDefaultPosition, wxSize(-1, 60), wxCUSTBUT_BUTTON | wxCUSTBUT_BOTTOM, wxDefaultValidator,
      _T("ID_BUTTON6"));
  btnPlaceRobot->SetBitmapDisabled(
      btnPlaceRobot->CreateBitmapDisabled(btnPlaceRobot->GetBitmapLabel()));
  btnPlaceRobot->SetBitmapMargin(wxSize(2, 4));
  FlexGridSizer4->Add(btnPlaceRobot, 1, wxEXPAND, 2);
  FlexGridSizer4->Add(-1, -1, 1, wxALL | wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL, 1);
  btnDrawMapObs = new wxCustomButton(
      this, ID_BUTTON8, _("Draw occupied..."),
      wxArtProvider::GetBitmap(
          wxART_MAKE_ART_ID_FROM_STR(_T("wxART_GO_FORWARD")),
          wxART_MAKE_CLIENT_ID_FROM_STR(wxString(wxEmptyString))),
      wxDefaultPosition, wxSize(-1, 50), wxCUSTBUT_BUTTON | wxCUSTBUT_BOTTOM, wxDefaultValidator,
      _T("ID_BUTTON8"));
  btnDrawMapObs->SetBitmapDisabled(
      btnDrawMapObs->CreateBitmapDisabled(btnDrawMapObs->GetBitmapLabel()));
  btnDrawMapObs->SetBitmapMargin(wxSize(2, 4));
  FlexGridSizer4->Add(btnDrawMapObs, 1, wxEXPAND, 2);
  btnDrawEmpty = new wxCustomButton(
      this, ID_BUTTON11, _("Draw empty..."),
      wxArtProvider::GetBitmap(
          wxART_MAKE_ART_ID_FROM_STR(_T("wxART_GO_FORWARD")),
          wxART_MAKE_CLIENT_ID_FROM_STR(wxString(wxEmptyString))),
      wxDefaultPosition, wxSize(-1, 50), wxCUSTBUT_BUTTON | wxCUSTBUT_BOTTOM, wxDefaultValidator,
      _T("ID_BUTTON11"));
  btnDrawEmpty->SetBitmapDisabled(
      btnDrawEmpty->CreateBitmapDisabled(btnDrawEmpty->GetBitmapLabel()));
  btnDrawEmpty->SetBitmapMargin(wxSize(2, 4));
  FlexGridSizer4->Add(btnDrawEmpty, 1, wxEXPAND, 2);
  FlexGridSizer12 = new wxFlexGridSizer(0, 2, 0, 0);
  FlexGridSizer12->AddGrowableCol(0);
  FlexGridSizer12->AddGrowableCol(1);
  btnLoadMap = new wxCustomButton(
      this, ID_BUTTON1, _("Load map..."),
      wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_FILE_OPEN")), wxART_BUTTON),
      wxDefaultPosition, wxSize(-1, 60), wxCUSTBUT_BUTTON | wxCUSTBUT_BOTTOM, wxDefaultValidator,
      _T("ID_BUTTON1"));
  btnLoadMap->SetBitmapDisabled(btnLoadMap->CreateBitmapDisabled(btnLoadMap->GetBitmapLabel()));
  btnLoadMap->SetBitmapMargin(wxSize(2, 4));
  FlexGridSizer12->Add(btnLoadMap, 1, wxEXPAND, 2);
  btnEmptyMap = new wxCustomButton(
      this, ID_BUTTON9, _("New map..."),
      wxArtProvider::GetBitmap(
          wxART_MAKE_ART_ID_FROM_STR(_T("wxART_NEW")),
          wxART_MAKE_CLIENT_ID_FROM_STR(wxString(wxEmptyString))),
      wxDefaultPosition, wxSize(-1, 50), wxCUSTBUT_BUTTON | wxCUSTBUT_BOTTOM, wxDefaultValidator,
      _T("ID_BUTTON9"));
  btnEmptyMap->SetBitmapDisabled(btnEmptyMap->CreateBitmapDisabled(btnEmptyMap->GetBitmapLabel()));
  btnEmptyMap->SetBitmapMargin(wxSize(2, 4));
  FlexGridSizer12->Add(btnEmptyMap, 1, wxEXPAND, 2);
  btnSaveMap = new wxCustomButton(
      this, ID_BUTTON10, _("Save map..."),
      wxArtProvider::GetBitmap(wxART_MAKE_ART_ID_FROM_STR(_T("wxART_FILE_SAVE")), wxART_BUTTON),
      wxDefaultPosition, wxSize(-1, 64), wxCUSTBUT_BUTTON | wxCUSTBUT_BOTTOM, wxDefaultValidator,
      _T("ID_BUTTON10"));
  btnSaveMap->SetBitmapDisabled(btnSaveMap->CreateBitmapDisabled(btnSaveMap->GetBitmapLabel()));
  btnSaveMap->SetBitmapMargin(wxSize(2, 4));
  FlexGridSizer12->Add(btnSaveMap, 1, wxEXPAND, 2);
  btnHelp = new wxCustomButton(
      this, ID_BUTTON2, _("About..."),
      wxArtProvider::GetBitmap(
          wxART_MAKE_ART_ID_FROM_STR(_T("wxART_QUESTION")),
          wxART_MAKE_CLIENT_ID_FROM_STR(wxString(wxEmptyString))),
      wxDefaultPosition, wxSize(-1, 60), wxCUSTBUT_BUTTON | wxCUSTBUT_BOTTOM, wxDefaultValidator,
      _T("ID_BUTTON2"));
  btnHelp->SetBitmapDisabled(btnHelp->CreateBitmapDisabled(btnHelp->GetBitmapLabel()));
  btnHelp->SetBitmapMargin(wxSize(5, 4));
  FlexGridSizer12->Add(btnHelp, 1, wxEXPAND, 2);
  btnQuit = new wxCustomButton(
      this, ID_BUTTON3, _("Exit"),
      wxArtProvider::GetBitmap(
          wxART_MAKE_ART_ID_FROM_STR(_T("wxART_QUIT")),
          wxART_MAKE_CLIENT_ID_FROM_STR(wxString(wxEmptyString))),
      wxDefaultPosition, wxSize(-1, 60), wxCUSTBUT_BUTTON | wxCUSTBUT_BOTTOM, wxDefaultValidator,
      _T("ID_BUTTON3"));
  btnQuit->SetBitmapDisabled(btnQuit->CreateBitmapDisabled(btnQuit->GetBitmapLabel()));
  FlexGridSizer12->Add(btnQuit, 1, wxEXPAND, 2);
  FlexGridSizer4->Add(FlexGridSizer12, 1, wxEXPAND, 0);
  FlexGridSizer1->Add(FlexGridSizer4, 1, wxEXPAND, 0);
  SplitterWindow1 = new wxSplitterWindow(
      this, ID_SPLITTERWINDOW1, wxDefaultPosition, wxDefaultSize, wxSP_3D,
      _T("ID_SPLITTERWINDOW1"));
  SplitterWindow1->SetMinSize(wxSize(10, 10));
  SplitterWindow1->SetMinimumPaneSize(10);
  Panel1 = new wxPanel(
      SplitterWindow1, ID_PANEL1, wxDefaultPosition, wxSize(400, 143), wxTAB_TRAVERSAL,
      _T("ID_PANEL1"));
  FlexGridSizer2 = new wxFlexGridSizer(1, 2, 0, 0);
  FlexGridSizer2->AddGrowableCol(1);
  FlexGridSizer2->AddGrowableRow(0);
  pnNavSelButtons = new wxPanel(
      Panel1, ID_PANEL6, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL, _T("ID_PANEL6"));
  FlexGridSizer9 = new wxFlexGridSizer(0, 2, 0, 0);
  FlexGridSizer9->AddGrowableCol(0);
  wxString __wxRadioBoxChoices_1[2] = {
      _("Autonavigation (reactive)"), _("Preprogrammed sequences")};
  rbNavMode = new wxRadioBox(
      pnNavSelButtons, ID_RADIOBOX2, _("Navigator"), wxDefaultPosition, wxDefaultSize, 2,
      __wxRadioBoxChoices_1, 1, wxRA_SPECIFY_COLS, wxDefaultValidator, _T("ID_RADIOBOX2"));
  FlexGridSizer9->Add(rbNavMode, 1, wxEXPAND, 5);
  FlexGridSizer3 = new wxFlexGridSizer(0, 2, 0, 0);
  cbEnableLog = new wxCheckBox(
      pnNavSelButtons, ID_CHECKBOX1, _("Log trajectory"), wxDefaultPosition, wxDefaultSize, 0,
      wxDefaultValidator, _T("ID_CHECKBOX1"));
  cbEnableLog->SetValue(false);
  FlexGridSizer3->Add(cbEnableLog, 1, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 5);
  FlexGridSizer3->Add(-1, -1, 1, wxALL | wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL, 5);
  cbNavLog = new wxCheckBox(
      pnNavSelButtons, ID_CHECKBOX2, _("Record .navlog files"), wxDefaultPosition, wxDefaultSize, 0,
      wxDefaultValidator, _T("ID_CHECKBOX2"));
  cbNavLog->SetValue(false);
  FlexGridSizer3->Add(cbNavLog, 1, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 5);
  FlexGridSizer3->Add(-1, -1, 1, wxALL | wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL, 5);
  cbShowPredictedPTG = new wxCheckBox(
      pnNavSelButtons, ID_CHECKBOX3, _("Show selected PTG prediction"), wxDefaultPosition,
      wxDefaultSize, 0, wxDefaultValidator, _T("ID_CHECKBOX3"));
  cbShowPredictedPTG->SetValue(true);
  FlexGridSizer3->Add(cbShowPredictedPTG, 1, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 5);
  cbDrawShapePath = new wxCheckBox(
      pnNavSelButtons, ID_CHECKBOX4, _("and draw robot shape"), wxDefaultPosition, wxDefaultSize, 0,
      wxDefaultValidator, _T("ID_CHECKBOX4"));
  cbDrawShapePath->SetValue(true);
  FlexGridSizer3->Add(
      cbDrawShapePath, 1, wxALL | wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL, 5);
  cbWaypointsAllowSkip = new wxCheckBox(
      pnNavSelButtons, ID_CHECKBOX5, _("Allow skip waypoints"), wxDefaultPosition, wxDefaultSize, 0,
      wxDefaultValidator, _T("ID_CHECKBOX5"));
  cbWaypointsAllowSkip->SetValue(true);
  FlexGridSizer3->Add(cbWaypointsAllowSkip, 1, wxEXPAND, 5);
  FlexGridSizer9->Add(FlexGridSizer3, 1, wxEXPAND, 5);
  wxString __wxRadioBoxChoices_2[2] = {_("Differential (Ackermann) drive"), _("Holonomic")};
  rbKinType = new wxRadioBox(
      pnNavSelButtons, ID_RADIOBOX1, _("Robot kinematics type"), wxDefaultPosition, wxDefaultSize,
      2, __wxRadioBoxChoices_2, 1, wxRA_SPECIFY_COLS, wxDefaultValidator, _T("ID_RADIOBOX1"));
  FlexGridSizer9->Add(rbKinType, 1, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL, 5);
  btnGenerateTemplate = new wxButton(
      pnNavSelButtons, ID_BUTTON13, _("Generate template config file..."), wxDefaultPosition,
      wxDefaultSize, 0, wxDefaultValidator, _T("ID_BUTTON13"));
  FlexGridSizer9->Add(btnGenerateTemplate, 1, wxALL | wxALIGN_LEFT | wxALIGN_TOP, 5);
  pnNavSelButtons->SetSizer(FlexGridSizer9);
  FlexGridSizer9->Fit(pnNavSelButtons);
  FlexGridSizer9->SetSizeHints(pnNavSelButtons);
  FlexGridSizer2->Add(pnNavSelButtons, 1, wxEXPAND, 0);
  Notebook1 =
      new wxNotebook(Panel1, ID_NOTEBOOK1, wxDefaultPosition, wxDefaultSize, 0, _T("ID_NOTEBOOK1"));
  Notebook1->SetMinSize(wxSize(100, 50));
  pnParamsGeneral = new wxPanel(
      Notebook1, ID_PANEL2, wxDefaultPosition, wxSize(474, 170), wxTAB_TRAVERSAL, _T("ID_PANEL2"));
  FlexGridSizer7 = new wxFlexGridSizer(1, 1, 0, 0);
  FlexGridSizer7->AddGrowableCol(0);
  FlexGridSizer7->AddGrowableRow(0);
  edParamsGeneral = new wxTextCtrl(
      pnParamsGeneral, ID_TEXTCTRL1, wxEmptyString, wxDefaultPosition, wxDefaultSize,
      wxTE_PROCESS_ENTER | wxTE_PROCESS_TAB | wxTE_MULTILINE | wxHSCROLL | wxVSCROLL |
          wxALWAYS_SHOW_SB,
      wxDefaultValidator, _T("ID_TEXTCTRL1"));
  edParamsGeneral->SetMinSize(wxSize(-1, 100));
  wxFont edParamsGeneralFont(
      8, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false, wxEmptyString,
      wxFONTENCODING_DEFAULT);
  edParamsGeneral->SetFont(edParamsGeneralFont);
  FlexGridSizer7->Add(edParamsGeneral, 1, wxEXPAND, 2);
  pnParamsGeneral->SetSizer(FlexGridSizer7);
  FlexGridSizer7->SetSizeHints(pnParamsGeneral);
  pnParamsReactive = new wxPanel(
      Notebook1, ID_PANEL4, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL, _T("ID_PANEL4"));
  FlexGridSizer8 = new wxFlexGridSizer(1, 1, 0, 0);
  FlexGridSizer8->AddGrowableCol(0);
  FlexGridSizer8->AddGrowableRow(0);
  edParamsReactive = new wxTextCtrl(
      pnParamsReactive, ID_TEXTCTRL4,
      _("# "
        "--------------------------------------------------------------------"
        "----\n# Example configuration file for MRPT Reactive Navigation "
        "engine.\n# See C++ documentation: "
        "http://reference.mrpt.org/svn/"
        "classmrpt_1_1nav_1_1_c_reactive_navigation_system.html\n# See ROS "
        "node documentation: http://wiki.ros.org/mrpt_reactivenav2d\n# "
        "--------------------------------------------------------------------"
        "----\n\n[GLOBAL_CONFIG]\n# 0 or `hmVIRTUAL_FORCE_FIELDS`: Virtual "
        "Force Field\n# 1 or `hmSEARCH_FOR_BEST_GAP`: Nearness Diagram "
        "(ND)\n# `hmFULL_EVAL`: Evaluation of all possible "
        "directions\nHOLONOMIC_METHOD = "
        "hmFULL_EVAL\nALARM_SEEMS_NOT_APPROACHING_TARGET_TIMEOUT=100 # "
        "(seconds)\n\nrobotMax_V_mps = 2.0\t\t# Speed "
        "limits\nrobotMax_W_degps =120\n\n\n# Parameters for the "
        "\"FullEval\" Holonomic method\n# "
        "----------------------------------------------------\n[FULL_EVAL_"
        "CONFIG]\nfactorWeights=1.0 1.0 1.0 0.01 3.0\n// 0: Clearness in "
        "direction\n// 1: Closest approach to target along straight line "
        "(Euclidean)\n// 2: Distance of end collision-free point to target "
        "(Euclidean)\n// 3: Hysteresis\n// 4: Clearness to nearest obstacle "
        "along path\n\nTARGET_SLOW_APPROACHING_DISTANCE = 0.70 // Start to "
        "reduce speed when closer than this to target.\nTOO_CLOSE_OBSTACLE = "
        "0.05 // Directions with collision-free distances below this "
        "threshold are not elegible.\nHYSTERESIS_SECTOR_COUNT = 5 // Range "
        "of \"sectors\" (directions) for hysteresis over successive "
        "timesteps\n\nPHASE1_FACTORS = 0 1 2 // Indices of the factors above "
        "to be considered in phase 1\nPHASE2_FACTORS = 1 4 // Indices of the "
        "factors above to be considered in phase 2\nPHASE1_THRESHOLD = 0.6 "
        "// Indices of the factors above to be considered in phase "
        "1\n\n#\tParameters for the \"VFF\" Holonomic method\n# "
        "----------------------------------------------------\n[VFF_CONFIG]"
        "\nTARGET_SLOW_APPROACHING_DISTANCE = 0.1 // For stopping "
        "gradually\nTARGET_ATTRACTIVE_FORCE = 2.000000e+001 // "
        "Dimension-less (may have to be tuned depending on the density of "
        "obstacle sampling)\n\n#\tParameters for the \"Nearness diagram\" "
        "Holonomic method\n# "
        "----------------------------------------------------\n[ND_CONFIG]"
        "\nWIDE_GAP_SIZE_PERCENT = 2.500000e-001 "
        "\nMAX_SECTOR_DIST_FOR_D2_PERCENT = 2.500000e-001 "
        "\nRISK_EVALUATION_SECTORS_PERCENT = 1.000000e-001 "
        "\nRISK_EVALUATION_DISTANCE = 4.000000e-001 // In normalized "
        "ps-meters [0,1]\nTOO_CLOSE_OBSTACLE = 1.500000e-001 // For stopping "
        "gradually\nTARGET_SLOW_APPROACHING_DISTANCE = 0.1 // In normalized "
        "ps-meters\nfactorWeights = 1.00 0.50 2.00 0.40 // [0]=Free space, "
        "[1]=Dist. in sectors, [2]=Closer to target (Euclidean), "
        "[3]=Hysteresis\n\n# "
        "----------------------------------------------------\n#\tParameters "
        "for navigation: DIFFERENTIAL DRIVEN Robot\n# "
        "----------------------------------------------------\n[DIFF_"
        "ReactiveParams]\nweights=0.5 0.05 0.5 2.0 0.5 0.3\n# 1: Free "
        "space\n# 2: Dist. in sectors\t\t\t\n# 3: Heading toward target\n# "
        "4: Closer to target (euclidean)\n# 5: Hysteresis\n# 6: Security "
        "Distance\n\nDIST_TO_TARGET_FOR_SENDING_EVENT=0\t# Minimum. distance "
        "to target for sending the end event. Set to 0 to send it just on "
        "navigation end\n\nMinObstaclesHeight=0.0 \t\t# Minimum coordinate "
        "in the \"z\" axis for an obstacle to be taken into "
        "account.\nMaxObstaclesHeight=1.40 \t# Maximum coordinate in the "
        "\"z\" axis for an obstacle to be taken into "
        "account.\n\nMAX_REFERENCE_DISTANCE = 10.0 # Maximum distance to "
        "build PTGs (in meters), i.e. the visibility \"range\" of tentative "
        "paths\n\n# The constant time of a first-order low-pass filter of "
        "outgoing speed commands, \n# i.e. can be used to impose a maximum "
        "acceleration.\nSPEEDFILTER_TAU = 0.5 // seconds\n\n# PTGs: See "
        "classes derived from mrpt::nav::CParameterizedTrajectoryGenerator ( "
        "http://reference.mrpt.org/svn/"
        "classmrpt_1_1nav_1_1_c_parameterized_trajectory_generator.html)# "
        "refer to papers for "
        "details.\n#---------------------------------------------------------"
        "---------------------\nPTG_COUNT = 3\n\nPTG0_Type = "
        "CPTG_DiffDrive_C\nPTG0_resolution = 0.05 # Look-up-table cell size "
        "or resolution (in meters)\nPTG0_refDistance= 10.0 # Maximum "
        "distance to build PTGs (in meters), i.e. the visibility \"range\" "
        "of tentative paths\nPTG0_num_paths= 121\nPTG0_v_max_mps = "
        "1.0\nPTG0_w_max_dps = 60\nPTG0_K = 1.0\nPTG0_score_priority = "
        "1.0\n\nPTG1_Type = CPTG_DiffDrive_alpha\nPTG1_resolution = 0.05 # "
        "Look-up-table cell size or resolution (in "
        "meters)\nPTG1_refDistance= 10.0 # Maximum distance to build PTGs "
        "(in meters), i.e. the visibility \"range\" of tentative "
        "paths\nPTG1_num_paths = 121\nPTG1_v_max_mps = 1.0\nPTG1_w_max_dps = "
        "60\nPTG1_cte_a0v_deg = 57\nPTG1_cte_a0w_deg = "
        "57\nPTG1_score_priority = 1.0\n\nPTG2_Type = "
        "CPTG_DiffDrive_C\nPTG2_resolution = 0.05 # Look-up-table cell size "
        "or resolution (in meters)\nPTG2_refDistance= 10.0 # Maximum "
        "distance to build PTGs (in meters), i.e. the visibility \"range\" "
        "of tentative paths\nPTG2_num_paths = 121\nPTG2_v_max_mps = "
        "1.0\nPTG2_w_max_dps = 60\nPTG2_K = -1.0\nPTG2_score_priority = "
        "0.5\n\n\n# Default 2D robot shape for collision checks: (ignored in "
        "ROS, superseded by node parameters)\n# Each PTG will use only one "
        "of either (a) polygonal 2D shape or, (b) radius of a circular "
        "shape\nRobotModel_shape2D_xs=-0.2 0.5 0.5 "
        "-0.2\nRobotModel_shape2D_ys=0.3 0.3 -0.3 "
        "-0.3\nRobotModel_circular_shape_radius = 0.5\n\n# "
        "----------------------------------------------------\n#\tParameters "
        "for navigation: DIFFERENTIAL DRIVEN Robot\n# "
        "----------------------------------------------------\n[HOLO_"
        "ReactiveParams]\nweights=0.5 0.05 0.5 2.0 0.2 0.3\n# 1: Free "
        "space\n# 2: Dist. in sectors\t\t\t\n# 3: Heading toward target\n# "
        "4: Closer to target (euclidean)\n# 5: Hysteresis\n# 6: Security "
        "Distance\n\nDIST_TO_TARGET_FOR_SENDING_EVENT=0.6\t# Minimum. "
        "distance to target for sending the end event. Set to 0 to send it "
        "just on navigation end\n\nMinObstaclesHeight=0.0 \t\t# Minimum "
        "coordinate in the \"z\" axis for an obstacle to be taken into "
        "account.\nMaxObstaclesHeight=1.40 \t# Maximum coordinate in the "
        "\"z\" axis for an obstacle to be taken into "
        "account.\n\nMAX_REFERENCE_DISTANCE = 10.0 # Maximum distance to "
        "build PTGs (in meters), i.e. the visibility \"range\" of tentative "
        "paths\n\n# PTGs: See classes derived from "
        "mrpt::nav::CParameterizedTrajectoryGenerator ( "
        "http://reference.mrpt.org/svn/"
        "classmrpt_1_1nav_1_1_c_parameterized_trajectory_generator.html)# "
        "refer to papers for "
        "details.\n#---------------------------------------------------------"
        "---------------------\nPTG_COUNT = 1\n\nPTG0_Type = "
        "CPTG_Holo_Blend\nPTG0_refDistance= 6.0 # Maximum distance to build "
        "PTGs (in meters), i.e. the visibility \"range\" of tentative "
        "paths\nPTG0_num_paths = 100\nPTG0_v_max_mps = 1.5\nPTG0_w_max_dps = "
        "90\nPTG0_T_ramp_max = 0.8\nPTG0_score_priority = 1.0\n\n# Each PTG "
        "will use only one of either (a) polygonal 2D shape or, (b) radius "
        "of a circular shape\nRobotModel_circular_shape_radius = 0.36\n\n"),
      wxDefaultPosition, wxSize(226, 111),
      wxTE_PROCESS_ENTER | wxTE_PROCESS_TAB | wxTE_MULTILINE | wxHSCROLL | wxVSCROLL |
          wxALWAYS_SHOW_SB,
      wxDefaultValidator, _T("ID_TEXTCTRL4"));
  edParamsReactive->SetMinSize(wxSize(-1, 100));
  wxFont edParamsReactiveFont(
      8, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false, wxEmptyString,
      wxFONTENCODING_DEFAULT);
  edParamsReactive->SetFont(edParamsReactiveFont);
  FlexGridSizer8->Add(edParamsReactive, 1, wxEXPAND, 2);
  pnParamsReactive->SetSizer(FlexGridSizer8);
  FlexGridSizer8->Fit(pnParamsReactive);
  FlexGridSizer8->SetSizeHints(pnParamsReactive);
  pnParamsPreprog = new wxPanel(
      Notebook1, ID_PANEL3, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL, _T("ID_PANEL3"));
  FlexGridSizer6 = new wxFlexGridSizer(1, 1, 0, 0);
  FlexGridSizer6->AddGrowableCol(0);
  FlexGridSizer6->AddGrowableRow(0);
  edManualSeqs = new wxTextCtrl(
      pnParamsPreprog, ID_TEXTCTRL3,
      _("# Params for mode \"Preprogrammed sequences\" \n# Used for debug / "
        "testing. Separate sections for different robot kinematic models. # "
        "Enter below a list of velocity cmds and they will be executed "
        "sequentially. \n\n# Kinematics: Diff driven \n# Format: cmd{%d} = "
        "{time_of_the_cmd_sec} {lin_vel_mps} "
        "{rot_speed_radps}\n[DIFF_CMDS]\ncmd1= 1.0 0.5 0.0\ncmd2= 4.0 1.0 "
        "0.5\ncmd3= 6.0 0.0 0.0\n\n\n# Kinematics: Holonomic \n# Format: "
        "cmd{%d} = {time_of_the_cmd_sec} {velocity_mps} "
        "{global_orientation_rad} {ramp_time_secs} "
        "{rot_speed_radps}\n[HOLO_CMDS]\ncmd1= 1.0 0.5 0.1.0 1.0 0.9\ncmd2= "
        "4.0 1.0 0.4 1.0 0.9\ncmd3= 6.0 0.0 0.0 1.0 0.0\n"),
      wxDefaultPosition, wxSize(230, 167),
      wxTE_PROCESS_ENTER | wxTE_PROCESS_TAB | wxTE_MULTILINE | wxHSCROLL | wxVSCROLL |
          wxALWAYS_SHOW_SB,
      wxDefaultValidator, _T("ID_TEXTCTRL3"));
  edManualSeqs->SetMinSize(wxSize(-1, 100));
  wxFont edManualSeqsFont(
      8, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false, wxEmptyString,
      wxFONTENCODING_DEFAULT);
  edManualSeqs->SetFont(edManualSeqsFont);
  FlexGridSizer6->Add(edManualSeqs, 1, wxEXPAND, 0);
  pnParamsPreprog->SetSizer(FlexGridSizer6);
  FlexGridSizer6->Fit(pnParamsPreprog);
  FlexGridSizer6->SetSizeHints(pnParamsPreprog);
  Notebook1->AddPage(pnParamsGeneral, _("Params: Simulation"), true);
  Notebook1->AddPage(pnParamsReactive, _("Params: Reactive navigator"), false);
  Notebook1->AddPage(pnParamsPreprog, _("Params: Preprogrammed seq."), false);
  FlexGridSizer2->Add(Notebook1, 1, wxEXPAND, 2);
  Panel1->SetSizer(FlexGridSizer2);
  FlexGridSizer2->SetSizeHints(Panel1);
  Panel5 = new wxPanel(
      SplitterWindow1, ID_PANEL5, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL,
      _T("ID_PANEL5"));
  BoxSizer3 = new wxBoxSizer(wxHORIZONTAL);
  SplitterWindow2 = new wxSplitterWindow(
      Panel5, ID_SPLITTERWINDOW2, wxDefaultPosition, wxDefaultSize, wxSP_3D,
      _T("ID_SPLITTERWINDOW2"));
  SplitterWindow2->SetMinSize(wxSize(10, 10));
  SplitterWindow2->SetMinimumPaneSize(10);
  Panel2 = new wxPanel(
      SplitterWindow2, ID_PANEL7, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL,
      _T("ID_PANEL7"));
  FlexGridSizer10 = new wxFlexGridSizer(1, 2, 0, 0);
  FlexGridSizer10->AddGrowableCol(1);
  FlexGridSizer10->AddGrowableRow(0);
  StaticText3 = new wxStaticText(
      Panel2, ID_STATICTEXT3, _("Log:"), wxDefaultPosition, wxDefaultSize, 0, _T("ID_STATICTEXT3"));
  FlexGridSizer10->Add(StaticText3, 1, wxALL | wxALIGN_TOP | wxALIGN_CENTER_HORIZONTAL, 5);
  edLog = new wxTextCtrl(
      Panel2, ID_TEXTCTRL5, wxEmptyString, wxDefaultPosition, wxSize(612, 85),
      wxTE_MULTILINE | wxTE_READONLY | wxTE_DONTWRAP | wxALWAYS_SHOW_SB, wxDefaultValidator,
      _T("ID_TEXTCTRL5"));
  edLog->SetMinSize(wxSize(-1, 70));
  edLog->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
  wxFont edLogFont(
      8, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false, wxEmptyString,
      wxFONTENCODING_DEFAULT);
  edLog->SetFont(edLogFont);
  FlexGridSizer10->Add(edLog, 1, wxEXPAND, 0);
  Panel2->SetSizer(FlexGridSizer10);
  FlexGridSizer10->Fit(Panel2);
  FlexGridSizer10->SetSizeHints(Panel2);
  Panel3 = new wxPanel(
      SplitterWindow2, ID_PANEL8, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL,
      _T("ID_PANEL8"));
  FlexGridSizer5 = new wxFlexGridSizer(2, 2, 0, 0);
  FlexGridSizer5->AddGrowableCol(0);
  FlexGridSizer5->AddGrowableCol(1);
  FlexGridSizer5->AddGrowableRow(1);
  StaticText2 = new wxStaticText(
      Panel3, ID_STATICTEXT2, _("[3D view of the simulated world]"), wxDefaultPosition,
      wxDefaultSize, 0, _T("ID_STATICTEXT2"));
  FlexGridSizer5->Add(
      StaticText2, 1, wxALL | wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL, 5);
  StaticText1 = new wxStaticText(
      Panel3, ID_STATICTEXT1, _("[Local view]"), wxDefaultPosition, wxDefaultSize, 0,
      _T("ID_STATICTEXT1"));
  FlexGridSizer5->Add(
      StaticText1, 1, wxALL | wxALIGN_CENTER_HORIZONTAL | wxALIGN_CENTER_VERTICAL, 5);
  m_plot3D = new CMyGLCanvas(
      Panel3, ID_XY_GLCANVAS, wxDefaultPosition, wxSize(450, 350), wxTAB_TRAVERSAL,
      _T("ID_XY_GLCANVAS"));
  FlexGridSizer5->Add(
      m_plot3D, 1, wxALL | wxEXPAND | wxFIXED_MINSIZE | wxALIGN_LEFT | wxALIGN_TOP, 1);
  FlexGridSizer11 = new wxFlexGridSizer(4, 1, 0, 0);
  FlexGridSizer11->AddGrowableCol(0);
  FlexGridSizer11->AddGrowableRow(2);
  StaticText4 = new wxStaticText(
      Panel3, ID_STATICTEXT4, _("Show for PTG:"), wxDefaultPosition, wxDefaultSize, 0,
      _T("ID_STATICTEXT4"));
  FlexGridSizer11->Add(StaticText4, 1, wxEXPAND, 5);
  cbSelPTG = new wxChoice(
      Panel3, ID_CHOICE1, wxDefaultPosition, wxDefaultSize, 0, nullptr, 0, wxDefaultValidator,
      _T("ID_CHOICE1"));
  FlexGridSizer11->Add(cbSelPTG, 1, wxEXPAND, 5);
  m_plotLocalView = new CMyGLCanvas(
      Panel3, ID_CUSTOM1, wxDefaultPosition, wxSize(150, 150), wxTAB_TRAVERSAL, _T("ID_CUSTOM1"));
  FlexGridSizer11->Add(m_plotLocalView, 1, wxEXPAND, 1);
  edInfoLocalView = new wxTextCtrl(
      Panel3, ID_TEXTCTRL2, wxEmptyString, wxDefaultPosition, wxDefaultSize,
      wxTE_MULTILINE | wxTE_READONLY | wxTE_DONTWRAP | wxALWAYS_SHOW_SB, wxDefaultValidator,
      _T("ID_TEXTCTRL2"));
  edInfoLocalView->SetMinSize(wxSize(-1, 50));
  edInfoLocalView->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
  wxFont edInfoLocalViewFont(
      8, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false, wxEmptyString,
      wxFONTENCODING_DEFAULT);
  edInfoLocalView->SetFont(edInfoLocalViewFont);
  FlexGridSizer11->Add(edInfoLocalView, 1, wxEXPAND, 2);
  FlexGridSizer5->Add(FlexGridSizer11, 1, wxEXPAND, 0);
  Panel3->SetSizer(FlexGridSizer5);
  FlexGridSizer5->Fit(Panel3);
  FlexGridSizer5->SetSizeHints(Panel3);
  SplitterWindow2->SplitHorizontally(Panel2, Panel3);
  BoxSizer3->Add(SplitterWindow2, 1, wxEXPAND, 0);
  Panel5->SetSizer(BoxSizer3);
  BoxSizer3->Fit(Panel5);
  BoxSizer3->SetSizeHints(Panel5);
  SplitterWindow1->SplitHorizontally(Panel1, Panel5);
  FlexGridSizer1->Add(SplitterWindow1, 1, wxEXPAND, 0);
  SetSizer(FlexGridSizer1);
  MenuBar1 = new wxMenuBar();
  Menu1 = new wxMenu();
  MenuItem3 = new wxMenuItem(Menu1, ID_MENUITEM4, _("Load map..."), wxEmptyString, wxITEM_NORMAL);
  Menu1->Append(MenuItem3);
  MenuItem1 = new wxMenuItem(
      Menu1, idMenuQuit, _("Quit\tAlt-F4"), _("Quit the application"), wxITEM_NORMAL);
  Menu1->Append(MenuItem1);
  MenuBar1->Append(Menu1, _("&File"));
  Menu3 = new wxMenu();
  mnuViewMaxRange =
      new wxMenuItem(Menu3, ID_MENUITEM1, _("Maximum sensor range"), wxEmptyString, wxITEM_CHECK);
  Menu3->Append(mnuViewMaxRange);
  mnuViewRobotPath =
      new wxMenuItem(Menu3, ID_MENUITEM2, _("Robot path"), wxEmptyString, wxITEM_CHECK);
  Menu3->Append(mnuViewRobotPath);
  Menu3->AppendSeparator();
  MenuItem5 =
      new wxMenuItem(Menu3, ID_MENUITEM3, _("Clear robot path"), wxEmptyString, wxITEM_NORMAL);
  Menu3->Append(MenuItem5);
  MenuBar1->Append(Menu3, _("&View"));
  Menu2 = new wxMenu();
  MenuItem2 = new wxMenuItem(
      Menu2, idMenuAbout, _("About\tF1"), _("Show info about this application"), wxITEM_NORMAL);
  Menu2->Append(MenuItem2);
  MenuBar1->Append(Menu2, _("Help"));
  SetMenuBar(MenuBar1);
  StatusBar1 = new wxStatusBar(this, ID_STATUSBAR1, 0, _T("ID_STATUSBAR1"));
  int __wxStatusBarWidths_1[3] = {-2, -2, -3};
  int __wxStatusBarStyles_1[3] = {wxSB_NORMAL, wxSB_NORMAL, wxSB_NORMAL};
  StatusBar1->SetFieldsCount(3, __wxStatusBarWidths_1);
  StatusBar1->SetStatusStyles(3, __wxStatusBarStyles_1);
  SetStatusBar(StatusBar1);
  timRunSimul.SetOwner(this, ID_TIMER1);
  timRunSimul.Start(10, false);
  FlexGridSizer1->SetSizeHints(this);
  Center();

  using rndf = reactive_navigator_demoframe;

  Bind(wxEVT_BUTTON, &rndf::OnbtnStartClick, this, ID_BUTTON4);
  Bind(wxEVT_BUTTON, &rndf::OnbtnStopClick, this, ID_BUTTON5);
  Bind(wxEVT_BUTTON, &rndf::OnbtnPlaceTargetClick, this, ID_BUTTON7);
  Bind(wxEVT_BUTTON, &rndf::OnbtnSetWaypointSeqClick, this, ID_BUTTON12);
  Bind(wxEVT_BUTTON, &rndf::OnbtnPlaceRobotClick, this, ID_BUTTON6);
  Bind(wxEVT_BUTTON, &rndf::OnbtnDrawMapObsClick, this, ID_BUTTON8);
  Bind(wxEVT_BUTTON, &rndf::OnbtnDrawEmptyClick, this, ID_BUTTON11);
  Bind(wxEVT_BUTTON, &rndf::OnbtnLoadMapClick, this, ID_BUTTON1);
  Bind(wxEVT_BUTTON, &rndf::OnbtnEmptyMapClick, this, ID_BUTTON9);
  Bind(wxEVT_BUTTON, &rndf::OnbtnSaveMapClick, this, ID_BUTTON10);
  Bind(wxEVT_BUTTON, &rndf::OnAbout, this, ID_BUTTON2);
  Bind(wxEVT_BUTTON, &rndf::OnbtnQuitClick, this, ID_BUTTON3);
  Bind(wxEVT_RADIOBOX, &rndf::OnrbKinTypeSelect, this, ID_RADIOBOX1);
  Bind(wxEVT_BUTTON, &rndf::OnbtnGenerateTemplateClick, this, ID_BUTTON13);
  Bind(wxEVT_COMMAND_TEXT_UPDATED, &rndf::OnedManualKinRampsText, this, ID_TEXTCTRL3);
  Bind(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, &rndf::OnNotebook1PageChanged1, this, ID_NOTEBOOK1);
  Bind(wxEVT_MENU, &rndf::OnbtnLoadMapClick, this, ID_MENUITEM4);
  Bind(wxEVT_MENU, &rndf::OnQuit, this, idMenuQuit);
  Bind(wxEVT_MENU, &rndf::OnMenuItemChangeVisibleStuff, this, ID_MENUITEM1);
  Bind(wxEVT_MENU, &rndf::OnMenuItemChangeVisibleStuff, this, ID_MENUITEM2);
  Bind(wxEVT_MENU, &rndf::OnMenuItemClearRobotPath, this, ID_MENUITEM3);
  Bind(wxEVT_MENU, &rndf::OnAbout, this, idMenuAbout);
  Bind(wxEVT_TIMER, &rndf::OntimRunSimulTrigger, this, ID_TIMER1);
  //*)

  // Load updated cfg file:
  try
  {
    const std::string sFil = mrpt::system::find_mrpt_shared_dir() +
                             std::string("config_files/navigation-ptgs/reactivenav-app-config.ini");
    edParamsReactive->LoadFile(sFil.c_str());
  }
  catch (...)
  {
  }

  btnStart->SetToolTip(wxT("Initializes and starts the simulator."));
  btnPlaceTarget->SetToolTip(wxT("Left-click on the map to place a navigation command."));
  btnStop->SetToolTip(wxT("Stops the simulation."));
  btnSetWaypointSeq->SetToolTip(
      wxT("Left-click on the map to place waypoints, right click to end and "
          "start navigation."));

  SplitterWindow1->SetSashPosition(200);
  SplitterWindow2->SetSashPosition(90);

  m_plot3D->Bind(wxEVT_MOTION, &reactive_navigator_demoframe::Onplot3DMouseMove, this);
  m_plot3D->Bind(wxEVT_LEFT_DOWN, &reactive_navigator_demoframe::Onplot3DMouseClick, this);
  m_plot3D->Bind(wxEVT_RIGHT_DOWN, &reactive_navigator_demoframe::Onplot3DMouseClick, this);

  mnuViewMaxRange->Check(true);
  mnuViewRobotPath->Check(true);

  updateButtonsEnableState(false);

  // Redirect all output to control:
  m_myRedirector = std::make_unique<CMyRedirector>(edLog, false, 100, true);

  WX_START_TRY

  // Initialize gridmap:
  // -------------------------------
  CMemoryStream s(DEFAULT_GRIDMAP_DATA, sizeof(DEFAULT_GRIDMAP_DATA));
  archiveFrom(s) >> m_gridMap;

  // Populate 3D views:
  // -------------------------------
  auto openGLSceneRef = m_plot3D->getOpenGLSceneRef();
  {
    mrpt::opengl::CGridPlaneXY::Ptr obj =
        mrpt::opengl::CGridPlaneXY::Create(-50, 50, -50, 50, 0, 1);
    obj->setColor_u8(TColor(30, 30, 30, 50));
    openGLSceneRef->insert(obj);
  }

  gl_grid = mrpt::opengl::CSetOfObjects::Create();
  openGLSceneRef->insert(gl_grid);
  this->updateMap3DView();

  // Robot viz is built in OnrbKinTypeSelect()
  gl_robot_local = mrpt::opengl::CSetOfObjects::Create();
  gl_robot = mrpt::opengl::CSetOfObjects::Create();
  {
    mrpt::opengl::CSetOfObjects::Ptr gl_robot_render = mrpt::opengl::CSetOfObjects::Create();
    gl_robot_render->setName("robot_render");
    gl_robot->insert(gl_robot_render);
  }
  openGLSceneRef->insert(gl_robot);

  gl_scan3D = mrpt::opengl::CPlanarLaserScan::Create();
  gl_scan3D->enableLine(false);
  gl_scan3D->enableSurface(true);
  gl_scan3D->setSurfaceColor(1.0f, 0, 0, 0.2f);
  gl_scan3D->setPointSize(2.0);
  gl_scan3D->setLocation(0, 0, 0.01);
  gl_robot->insert(gl_scan3D);

  gl_robot_sensor_range = mrpt::opengl::CDisk::Create(0, 0);
  gl_robot_sensor_range->setColor_u8(TColor(0, 0, 255, 90));
  gl_robot_sensor_range->setLocation(0, 0, 0.01);
  gl_robot->insert(gl_robot_sensor_range);

  gl_robot_path = mrpt::opengl::CSetOfLines::Create();
  gl_robot_path->setLineWidth(1);
  gl_robot_path->setColor_u8(TColor(40, 40, 40, 200));
  gl_robot_path->setLocation(0, 0, 0.01);
  openGLSceneRef->insert(gl_robot_path);

  gl_target = mrpt::opengl::CSetOfObjects::Create();
  gl_target->setVisibility(false);
  {
    mrpt::opengl::CArrow::Ptr obj;
    obj = mrpt::opengl::CArrow::Create(1, 0, 0, 0.2f, 0, 0, 0.4f, 0.05f, 0.15f);
    obj->setColor_u8(TColor(0, 0, 255));
    gl_target->insert(obj);
    obj = mrpt::opengl::CArrow::Create(-1, 0, 0, -0.2f, 0, 0, 0.4f, 0.05f, 0.15f);
    obj->setColor_u8(TColor(0, 0, 255));
    gl_target->insert(obj);
    obj = mrpt::opengl::CArrow::Create(0, 1, 0, 0, 0.2f, 0, 0.4f, 0.05f, 0.15f);
    obj->setColor_u8(TColor(0, 0, 255));
    gl_target->insert(obj);
    obj = mrpt::opengl::CArrow::Create(0, -1, 0, 0, -0.2f, 0, 0.4f, 0.05f, 0.15f);
    obj->setColor_u8(TColor(0, 0, 255));
    gl_target->insert(obj);
    openGLSceneRef->insert(gl_target);
  }

  {
    gl_waypoints_clicking = std::make_shared<opengl::CSetOfObjects>();
    openGLSceneRef->insert(gl_waypoints_clicking);

    gl_waypoints_status = std::make_shared<opengl::CSetOfObjects>();
    openGLSceneRef->insert(gl_waypoints_status);
  }

  {  // Sign of "picking a navigation target":
    m_gl_placing_nav_target = std::make_shared<opengl::CSetOfObjects>();

    mrpt::opengl::CArrow::Ptr obj;
    obj = mrpt::opengl::CArrow::Create(1, 0, 0, 0.2f, 0, 0, 0.4f, 0.05f, 0.15f);
    obj->setColor_u8(TColor(0, 0, 255));
    m_gl_placing_nav_target->insert(obj);
    obj = mrpt::opengl::CArrow::Create(-1, 0, 0, -0.2f, 0, 0, 0.4f, 0.05f, 0.15f);
    obj->setColor_u8(TColor(0, 0, 255));
    m_gl_placing_nav_target->insert(obj);
    obj = mrpt::opengl::CArrow::Create(0, 1, 0, 0, 0.2f, 0, 0.4f, 0.05f, 0.15f);
    obj->setColor_u8(TColor(0, 0, 255));
    m_gl_placing_nav_target->insert(obj);
    obj = mrpt::opengl::CArrow::Create(0, -1, 0, 0, -0.2f, 0, 0.4f, 0.05f, 0.15f);
    obj->setColor_u8(TColor(0, 0, 255));
    m_gl_placing_nav_target->insert(obj);
    m_gl_placing_nav_target->setVisibility(false);  // Start invisible.
    openGLSceneRef->insert(m_gl_placing_nav_target);
  }
  {  // Sign of "replacing the robot":
    m_gl_placing_robot = std::make_shared<opengl::CSetOfObjects>();
    mrpt::opengl::CSetOfObjects::Ptr obj = mrpt::opengl::stock_objects::CornerXYZSimple(1.0, 2.0);
    obj->setColor_u8(TColor(255, 0, 0, 120));
    m_gl_placing_robot->insert(obj);

    m_gl_placing_robot->setVisibility(false);  // Start invisible.
    openGLSceneRef->insert(m_gl_placing_robot);
  }
  {  // Sign of "drawing obstacles":
    m_gl_drawing_obs = std::make_shared<opengl::CSetOfObjects>();

    mrpt::opengl::CCylinder::Ptr obj = mrpt::opengl::CCylinder::Create(0.05f, 0.10f, 1.0f);
    obj->setColor_u8(mrpt::img::TColor(0xff, 0x00, 0x00, 0x70));
    m_gl_drawing_obs->insert(obj);

    m_gl_drawing_obs->setVisibility(false);  // Start invisible.
    openGLSceneRef->insert(m_gl_drawing_obs);
  }

  openGLSceneRef->insert(mrpt::opengl::stock_objects::CornerXYZ(1));

  gl_robot_ptg_prediction = mrpt::opengl::CSetOfLines::Create();
  gl_robot_ptg_prediction->setName("ptg_prediction");
  gl_robot_ptg_prediction->setLineWidth(2.0);
  gl_robot_ptg_prediction->setColor_u8(mrpt::img::TColor(0x00, 0x00, 0xff));
  gl_robot->insert(gl_robot_ptg_prediction);

  // Set camera:
  m_plot3D->setCameraPointing(0.0f, 0.0f, 0.0f);
  m_plot3D->setZoomDistance(40.0f);
  m_plot3D->setElevationDegrees(70.0f);
  m_plot3D->setAzimuthDegrees(-100.0f);
  m_plot3D->setCameraProjective(true);

  // Init simulator & its adaptor to the navigator
  {
    wxCommandEvent ev;
    OnrbKinTypeSelect(ev);
  }

  // 2D view ==============
  auto openGLSceneLocalViewRef = m_plotLocalView->getOpenGLSceneRef();
  {
    mrpt::opengl::CGridPlaneXY::Ptr obj =
        mrpt::opengl::CGridPlaneXY::Create(-1, 1.001f, -1, 1.001f, 0, 1);
    obj->setColor_u8(TColor(30, 30, 30, 50));
    openGLSceneLocalViewRef->insert(obj);
  }

  gl_line_direction = mrpt::opengl::CSimpleLine::Create();
  gl_line_direction->setLineWidth(4);
  gl_line_direction->setColor_u8(TColor(0, 0, 0));
  openGLSceneLocalViewRef->insert(gl_line_direction);

  gl_rel_target = mrpt::opengl::CPointCloud::Create();
  gl_rel_target->setPointSize(7);
  gl_rel_target->setColor_u8(TColor(0, 0, 255));
  openGLSceneLocalViewRef->insert(gl_rel_target);

  gl_rel_robot = mrpt::opengl::CPointCloud::Create();
  gl_rel_robot->setPointSize(5);
  gl_rel_robot->setColor_u8(TColor(0, 0, 0));
  gl_rel_robot->insertPoint(0, 0, 0);
  openGLSceneLocalViewRef->insert(gl_rel_robot);

  m_plotLocalView->getOpenGLSceneRef()->insert(
      mrpt::opengl::stock_objects::CornerXYSimple(0.1f, 2));
  openGLSceneLocalViewRef->insert(gl_robot_local);

  gl_tp_obstacles = mrpt::opengl::CSetOfLines::Create();
  gl_tp_obstacles->setLineWidth(3);
  gl_tp_obstacles->setColor_u8(TColor(0, 0, 0));
  openGLSceneLocalViewRef->insert(gl_tp_obstacles);

  gl_nd_gaps = mrpt::opengl::CSetOfLines::Create();
  gl_nd_gaps->setLineWidth(1);
  gl_nd_gaps->setColor_u8(TColor(255, 0, 0));
  openGLSceneRef->insert(gl_nd_gaps);

  // Set camera:
  m_plotLocalView->setCameraPointing(0.0f, 0.0f, 0.0f);
  m_plotLocalView->setZoomDistance(2.2f);
  m_plotLocalView->setElevationDegrees(90.0f);
  m_plotLocalView->setAzimuthDegrees(-90.0f);
  m_plotLocalView->setCameraProjective(true);

  // Update positions of stuff:
  this->updateViewsDynamicObjects();

  // Retrieve default parameters for holonomic methods:
  // ------------------------------------------------------
  {
    mrpt::config::CConfigFileMemory cfg;

    m_simul_options.saveToConfigFile(cfg, "SIMULATOR");
    edParamsGeneral->SetValue(cfg.getContent().c_str());
  }

  WX_END_TRY

  this->Maximize();
}

reactive_navigator_demoframe::~reactive_navigator_demoframe()
{
  //(*Destroy(reactive_navigator_demoframe)
  //*)

  // Destroy this first to avoid problems, since it may contain a ref of the
  // simulator object:
  m_navMethod.reset();
}

void reactive_navigator_demoframe::OnQuit(wxCommandEvent&) { Close(); }
void reactive_navigator_demoframe::OnAbout(wxCommandEvent&)
{
  mrpt::gui::show_mrpt_about_box_wxWidgets(this, "ReactiveNavigatorDemo");
}

void reactive_navigator_demoframe::updateMap3DView() { m_gridMap.getVisualizationInto(*gl_grid); }

void reactive_navigator_demoframe::OnbtnPlaceRobotClick(wxCommandEvent& event)
{
  if (m_cursorPickState != cpsPlaceRobot)
  {
    m_cursorPickState = cpsPlaceRobot;
    m_plot3D->SetCursor(*wxCROSS_CURSOR);
  }
  else
  {  // Cancel:
    m_cursorPickState = cpsNone;
    m_plot3D->SetCursor(*wxSTANDARD_CURSOR);
    m_gl_placing_robot->setVisibility(false);
  }
  btnPlaceRobot->SetValue(m_cursorPickState == cpsPlaceRobot);
  btnPlaceRobot->Refresh();
}

void reactive_navigator_demoframe::OnbtnPlaceTargetClick(wxCommandEvent& event)
{
  if (m_cursorPickState != cpsPickTarget)
  {
    m_cursorPickState = cpsPickTarget;
    m_plot3D->SetCursor(*wxCROSS_CURSOR);
  }
  else
  {  // Cancel:
    m_cursorPickState = cpsNone;
    m_plot3D->SetCursor(*wxSTANDARD_CURSOR);
    m_gl_placing_nav_target->setVisibility(false);
  }
  btnPlaceTarget->SetValue(m_cursorPickState == cpsPickTarget);
  btnPlaceTarget->Refresh();
}

void reactive_navigator_demoframe::updateButtonsEnableState(bool is_running)
{
  btnStart->Enable(!is_running);
  btnStart->Refresh();
  btnStop->Enable(is_running);
  btnStop->Refresh();
  btnPlaceTarget->Enable(is_running);
  btnPlaceTarget->Refresh();
  btnSetWaypointSeq->Enable(is_running);
  btnSetWaypointSeq->Refresh();
  Notebook1->Enable(!is_running);
  pnNavSelButtons->Enable(!is_running);
}

void reactive_navigator_demoframe::OnbtnStartClick(wxCommandEvent& event)
{
  updateButtonsEnableState(true);
  if (!reinitSimulator())
  {
    updateButtonsEnableState(false);
    return;
  }
  m_is_running = true;
}

void reactive_navigator_demoframe::OnbtnStopClick(wxCommandEvent& event)
{
  updateButtonsEnableState(false);
  m_is_running = false;
}

// Run simulator (when "running"):
void reactive_navigator_demoframe::OntimRunSimulTrigger(wxTimerEvent& event)
{
  try
  {
    static int decim_call_dump_log = 0;
    if (decim_call_dump_log++ > 10)
    {
      decim_call_dump_log = 0;
      std::cout.flush();
      std::cerr.flush();
    }

    if (m_is_running)
    {
      simulateOneStep(NAV_SIMUL_TIMESTEP_MS * 1e-3);
    }
    updateViewsDynamicObjects();
    timRunSimul.Start(
        NAV_SIMUL_TIMESTEP_MS,
        true);  // execute the simulation step by
                // step ("one shot" timer) so in the
                // event of an exception, we don't
                // output an endless stream of
                // errors.
  }
  catch (const std::exception& e)
  {
    wxMessageBox(mrpt::exception_to_str(e), wxT("Exception"), wxOK, this);
    // Stop:
    wxCommandEvent ev;
    OnbtnStopClick(ev);
  }
}

// Create navigator object & load params from GUI:
bool reactive_navigator_demoframe::reinitSimulator()
{
  WX_START_TRY

  if (m_robotSimul2NavInterface)
  {
    // Params for simulator-to-nav interface:
    CConfigFileMemory cfg;
    cfg.setContent(std::string(edParamsReactive->GetValue().mb_str()));
    // m_robotSimul2NavInterface->loadConfigFile(cfg, "GLOBAL_CONFIG");
  }

  // Delete old & build new navigator:
  m_navMethod.reset();
  CConfigFileMemory cfg;
  switch (rbNavMode->GetSelection())
  {
    case 0:
    {
      mrpt::nav::CReactiveNavigationSystem* react =
          new mrpt::nav::CReactiveNavigationSystem(*m_robotSimul2NavInterface);
      m_navMethod.reset(react);

      react->enableKeepLogRecords();
      react->enableLogFile(cbNavLog->IsChecked());

      cfg.setContent(std::string(edParamsReactive->GetValue().mb_str()));
      break;
    }
    case 1:
    {
      m_navMethod =
          std::make_unique<mrpt::nav::CNavigatorManualSequence>(*m_robotSimul2NavInterface);
      cfg.setContent(std::string(edManualSeqs->GetValue().mb_str()));
      break;
    }
    default:
      throw std::runtime_error("Invalid nav method selected!");
  };
  ASSERT_(m_navMethod.get());
  // Load params:
  std::string sKinPrefix;
  switch (rbKinType->GetSelection())
  {
    case 0:
      sKinPrefix = "DIFF_";
      break;
    case 1:
      sKinPrefix = "HOLO_";
      break;
    default:
      throw std::runtime_error("Invalid kinematic model selected!");
  };

  {
    mrpt::config::CConfigFilePrefixer cfg_prefixer;
    cfg_prefixer.bind(cfg);
    cfg_prefixer.setPrefixes(sKinPrefix /*sections*/, "" /*keys*/);

    m_navMethod->loadConfigFile(cfg_prefixer);
  }
  m_navMethod->initialize();

  // params for simulator itself:
  {
    CConfigFileMemory cfgGeneral;
    cfgGeneral.setContent(std::string(edParamsGeneral->GetValue().mb_str()));
    m_simul_options.loadFromConfigFile(cfgGeneral, "SIMULATOR");
  }

  // Update GUI stuff:
  gl_robot_sensor_range->setDiskRadius(
      m_simul_options.MAX_SENSOR_RADIUS * 1.01, m_simul_options.MAX_SENSOR_RADIUS * 0.99);
  gl_target->setVisibility(false);
  gl_robot_ptg_prediction->clear();

  cbSelPTG->Clear();
  {
    auto* ptg_nav = dynamic_cast<mrpt::nav::CAbstractPTGBasedReactive*>(m_navMethod.get());
    if (ptg_nav)
    {
      for (size_t i = 0; i < ptg_nav->getPTG_count(); i++)
        cbSelPTG->Append(ptg_nav->getPTG(i)->getDescription().c_str());

      if (ptg_nav->getPTG_count() > 0) cbSelPTG->SetSelection(0);
    }
  }

  return true;

  WX_END_TRY
  return false;
}

void reactive_navigator_demoframe::simulateOneStep(double time_step)
{
  WX_START_TRY

  const double simul_time = m_robotSimul->getTime();

  static double LAST_TIM_LIDAR = -1e6;
  static double LAST_TIM_REACTIVE = -1e6;

  if (simul_time - LAST_TIM_LIDAR > 1.0 / m_simul_options.SENSOR_RATE)
  {
    LAST_TIM_LIDAR = simul_time;

    // Simulate 360deg range scan:
    CObservation2DRangeScan simulatedScan;

    simulatedScan.aperture = m_simul_options.SENSOR_FOV;
    simulatedScan.rightToLeft = true;
    simulatedScan.maxRange = m_simul_options.MAX_SENSOR_RADIUS;
    simulatedScan.sensorPose = CPose3D(0.10, 0, 0, 0, 0, 0);

    m_gridMap.laserScanSimulator(
        simulatedScan, CPose2D(m_robotSimul->getCurrentGTPose()), 0.5,
        m_simul_options.SENSOR_NUM_RANGES, m_simul_options.SENSOR_RANGE_NOISE_STD);

    // Build the obstacles points map for the reactive:
    {
      m_latest_obstacles.insertionOptions.minDistBetweenLaserPoints = 0.005f;
      m_latest_obstacles.insertionOptions.also_interpolate = false;

      m_latest_obstacles.clear();  // erase old points
      m_latest_obstacles.insertObservation(simulatedScan);
      // m_latest_obstacles is ref-copied into the robot2nav interface.
    }

    gl_scan3D->setScan(simulatedScan);  // Draw real scan in 3D view
  }

  // Navigate:
  if (simul_time - LAST_TIM_REACTIVE > 1.0 / m_simul_options.NAVIGATION_RATE)
  {
    LAST_TIM_REACTIVE = simul_time;

    m_navMethod->navigationStep();
  }

  // Run robot simulator:
  m_robotSimul->simulateOneTimeStep(time_step);

  // Update path graph:
  const TPoint3D cur_pt(
      m_robotSimul->getCurrentGTPose().x, m_robotSimul->getCurrentGTPose().y, 0.01);

  static int decim_path = 0;
  if (gl_robot_path->empty() || ++decim_path > 10)
  {
    gl_robot_path->appendLine(cur_pt, cur_pt);
  }
  else
  {
    gl_robot_path->appendLineStrip(cur_pt);
    decim_path = 0;
  }

  if (cbEnableLog->IsChecked())
  {
    if (!m_log_trajectory_file.is_open())
    {
      if (m_log_trajectory_file.open("traj_log.txt", mrpt::io::OpenMode::TRUNCATE))
      {
        m_log_trajectory_file.printf("%% File format: TIME  X   Y  PHI  VX  VY OMEGA\n");
      }
    }
    if (m_log_trajectory_file.is_open())  // just in case there was any error opening
    {
      const mrpt::math::TPose2D pose = m_robotSimul->getCurrentGTPose();
      const mrpt::math::TTwist2D vel = m_robotSimul->getCurrentGTVel();
      m_log_trajectory_file.printf(
          "%8.03f  %7.03f %7.03f %7.03f   %7.03f %7.03f %7.03f\n", m_robotSimul->getTime(), pose.x,
          pose.y, mrpt::RAD2DEG(pose.phi), vel.vx, vel.vy, mrpt::RAD2DEG(vel.omega));
    }
  }
  else
  {
    if (m_log_trajectory_file.is_open()) m_log_trajectory_file.close();
  }

  auto* ptg_nav = dynamic_cast<mrpt::nav::CAbstractPTGBasedReactive*>(m_navMethod.get());

  // Clear stuff which will be updated if used below:
  edInfoLocalView->Clear();
  gl_nd_gaps->clear();

  // Update 2D view graphs:
  mrpt::nav::CLogFileRecord lfr;
  if (ptg_nav) ptg_nav->getLastLogRecord(lfr);

  const int sel_PTG = cbSelPTG->GetSelection();
  if (sel_PTG >= 0 && sel_PTG < (int)lfr.infoPerPTG.size())
  {
    const size_t nObs = lfr.infoPerPTG[sel_PTG].TP_Obstacles.size();
    if (lfr.infoPerPTG.size() > 0 && lfr.infoPerPTG[sel_PTG].HLFR &&
        IS_CLASS(*lfr.infoPerPTG[sel_PTG].HLFR, CLogFileRecord_ND))
    {
      CLogFileRecord_ND::Ptr log =
          std::dynamic_pointer_cast<CLogFileRecord_ND>(lfr.infoPerPTG[sel_PTG].HLFR);
      const size_t nGaps = log->gaps_ini.size();

      const string sSitu =
          mrpt::typemeta::TEnumType<CHolonomicND::TSituations>::value2name(log->situation);

      string sLog = mrpt::format("ND situation : %s\n", sSitu.c_str());
      sLog += mrpt::format("Gap count    : %u\n", static_cast<unsigned int>(nGaps));

      edInfoLocalView->SetValue(sLog.c_str());

      gl_nd_gaps->appendLine(0, 0, 0, 0, 0, 0);
      for (size_t i = 0; i < nGaps; i++)
      {
        const size_t N_STEPS = 20;
        for (size_t j = 0; j < N_STEPS; j++)
        {
          const double sec = log->gaps_ini[i] + j * (log->gaps_end[i] - log->gaps_ini[i]) /
                                                    static_cast<double>(N_STEPS - 1);
          const double ang = M_PI * (-1.0 + 2.0 * sec / nObs);

          const double d = lfr.infoPerPTG[sel_PTG].TP_Obstacles[sec] - 0.05;
          gl_nd_gaps->appendLineStrip(d * cos(ang), d * sin(ang), 0);
        }
        gl_nd_gaps->appendLineStrip(0, 0, 0);
      }
    }

    // TP-Obstacles:
    gl_tp_obstacles->clear();
    if (nObs > 1)
    {
      for (size_t i = 0; i <= nObs; i++)
      {
        const double d0 = lfr.infoPerPTG[sel_PTG].TP_Obstacles[i % nObs];
        const double a0 = M_PI * (-1.0 + 2.0 * ((i % nObs) + 0.5) / nObs);
        const double d1 = lfr.infoPerPTG[sel_PTG].TP_Obstacles[(i + 1) % nObs];
        const double a1 = M_PI * (-1.0 + 2.0 * (((i + 1) % nObs) + 0.5) / nObs);
        gl_tp_obstacles->appendLine(
            d0 * cos(a0), d0 * sin(a0), 0.0, d1 * cos(a1), d1 * sin(a1), 0.0);
      }
    }

    // Movement direction:
    {
      const double desiredDirection = lfr.infoPerPTG[sel_PTG].desiredDirection;
      const double d = lfr.infoPerPTG[sel_PTG].desiredSpeed;  /// ROBOT_MAX_SPEED;
      gl_line_direction->setLineCoords(
          0, 0, 0, cos(desiredDirection) * d, sin(desiredDirection) * d, 0);
    }

    // TP Target:
    gl_rel_target->clear();
    for (const auto& t : lfr.infoPerPTG[sel_PTG].TP_Targets)
    {
      gl_rel_target->insertPoint(t.x, t.y, .0);
    }

    // TP Robot:
    gl_rel_robot->setLocation(mrpt::math::TPoint3D(lfr.infoPerPTG[sel_PTG].TP_Robot));

  }  // end valid PTG selected

  // Draw predicted path along selected PTG:
  if (cbShowPredictedPTG->IsChecked() && lfr.infoPerPTG.size() > 0 && ptg_nav)
  {
    // Selected PTG path:
    if (lfr.nSelectedPTG <= (int)ptg_nav->getPTG_count())  // the == case is for "NOP motion cmd"
    {
      const bool is_NOP_op = (lfr.nSelectedPTG == (int)ptg_nav->getPTG_count());
      const int idx_ptg = is_NOP_op ? lfr.ptg_index_NOP : lfr.nSelectedPTG;

      mrpt::nav::CParameterizedTrajectoryGenerator* ptg =
          idx_ptg >= 0 ? ptg_nav->getPTG(idx_ptg) : nullptr;
      if (ptg)
      {
        // Draw path:
        const auto& ipp = lfr.infoPerPTG[lfr.nSelectedPTG];

        const int selected_k =
            is_NOP_op ? lfr.ptg_last_k_NOP : ptg->alpha2index(ipp.desiredDirection);
        float max_dist = ptg->getRefDistance();
        gl_robot_ptg_prediction->clear();

        ptg->updateNavDynamicState(is_NOP_op ? ipp.lastDynState : ipp.dynState);

        ptg->renderPathAsSimpleLine(selected_k, *gl_robot_ptg_prediction, 0.10, max_dist);
        gl_robot_ptg_prediction->setColor_u8(mrpt::img::TColor(0xff, 0x00, 0x00));

        // Place it:
        if (is_NOP_op)
        {
          gl_robot_ptg_prediction->setPose(lfr.rel_pose_PTG_origin_wrt_sense_NOP);
        }
        else
        {
          gl_robot_ptg_prediction->setPose(CPose3D());
        }

        // Overlay a sequence of robot shapes:
        if (cbDrawShapePath->IsChecked())
        {
          double min_shape_dists = 1.0;
          for (double d = min_shape_dists; d < max_dist; d += min_shape_dists)
          {
            uint32_t step;
            if (!ptg->getPathStepForDist(selected_k, d, step)) continue;
            const auto p = ptg->getPathPose(selected_k, step);
            ptg->add_robotShape_to_setOfLines(*gl_robot_ptg_prediction, mrpt::poses::CPose2D(p));
          }
        }
      }
    }
  }

  auto* wp_nav = dynamic_cast<CWaypointsNavigator*>(m_navMethod.get());
  if (wp_nav)
  {
    static wxFrame* wxFrWpInfo = nullptr;
    static wxTextCtrl* edWpLog = nullptr;
    if (!wxFrWpInfo)
    {
      wxFrWpInfo = new wxFrame(
          this, -1, wxT("Waypoints info"), wxDefaultPosition, wxSize(400, 150),
          wxRESIZE_BORDER | wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxCAPTION | wxCLIP_CHILDREN |
              wxSTAY_ON_TOP);

      edWpLog = new wxTextCtrl(
          wxFrWpInfo, wxNewId(), wxEmptyString, wxDefaultPosition, wxSize(400, 150),
          wxTE_MULTILINE | wxTE_READONLY | wxTE_DONTWRAP | wxALWAYS_SHOW_SB, wxDefaultValidator,
          _T("ID_TEXTCTRL_WP"));
      edWpLog->SetMinSize(wxSize(190, 60));
      wxFont edLogFont(8, wxFONTFAMILY_TELETYPE, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
      edWpLog->SetFont(edLogFont);
    }

    TWaypointStatusSequence wp_status;
    wp_nav->getWaypointNavStatus(wp_status);
    const std::string sWpLog = wp_status.getAsText();

    if (!wp_status.waypoints.empty())
      if (!wxFrWpInfo->IsShown()) wxFrWpInfo->Show();

    if (wxFrWpInfo->IsShown()) edWpLog->SetValue(sWpLog.c_str());

    // Plot waypoints being clicked by the user graphically:
    m_waypoints_clicked.getAsOpenglVisualization(*gl_waypoints_clicking);

    // Plot firmly set waypoints and their status:
    wp_status.getAsOpenglVisualization(*gl_waypoints_status);
  }

  WX_END_TRY
}

void reactive_navigator_demoframe::updateViewsDynamicObjects()
{
  gl_robot->setPose(m_robotSimul->getCurrentGTPose());

  // animate target:
  {
    const double TARGET_BOUNCE_MIN = 0.7;
    const double TARGET_BOUNCE_MAX = 1;

    const double TARGET_BOUNCE_PERIOD = 1.0;
    const double t = fmod(m_runtime.Tac(), TARGET_BOUNCE_PERIOD) / TARGET_BOUNCE_PERIOD;

    // Parabolic path
    const double s = 4 * t * (TARGET_BOUNCE_MAX - TARGET_BOUNCE_MIN) * (1 - t) + TARGET_BOUNCE_MIN;

    gl_target->setLocation(m_targetPoint.x, m_targetPoint.y, 0);
    gl_target->setScale(s);
  }

  // Labels:
  StatusBar1->SetStatusText(
      (mrpt::format(
           "Robot pose: %s vel: %s", m_robotSimul->getCurrentGTPose().asString().c_str(),
           m_robotSimul->getCurrentGTVel().asString().c_str())
           .c_str()),
      0);
  StatusBar1->SetStatusText(
      (mrpt::format(
           "Simul time: %.03f Target: (%.03f,%.03f)", m_robotSimul->getTime(), m_targetPoint.x,
           m_targetPoint.y)
           .c_str()),
      1);

  // Show/hide:
  gl_robot_sensor_range->setVisibility(mnuViewMaxRange->IsChecked());
  gl_robot_path->setVisibility(mnuViewRobotPath->IsChecked());

  // Refresh:
  m_plot3D->Refresh();
  m_plotLocalView->Refresh();
}

void reactive_navigator_demoframe::Onplot3DMouseMove(wxMouseEvent& event)
{
  int X, Y;
  event.GetPosition(&X, &Y);
  bool skip_normal_process = false;

  // Intersection of 3D ray with ground plane ====================
  TLine3D ray;
  m_plot3D->getOpenGLSceneRef()->getViewport("main")->get3DRayForPixelCoord(X, Y, ray);
  // Create a 3D plane, e.g. Z=0
  const TPlane ground_plane(TPoint3D(0, 0, 0), TPoint3D(1, 0, 0), TPoint3D(0, 1, 0));
  // Intersection of the line with the plane:
  TObject3D inters;
  intersect(ray, ground_plane, inters);
  // Interpret the intersection as a point, if there is an intersection:
  TPoint3D inters_pt;
  if (inters.getPoint(inters_pt))
  {
    m_curCursorPos.x = inters_pt.x;
    m_curCursorPos.y = inters_pt.y;

    switch (m_cursorPickState)
    {
      case cpsPickTarget:
      case cpsPickWaypoints:
      {
        m_gl_placing_nav_target->setVisibility(true);
        m_gl_placing_nav_target->setLocation(m_curCursorPos.x, m_curCursorPos.y, 0.01);
      }
      break;
      case cpsPlaceRobot:
      {
        m_gl_placing_robot->setVisibility(true);
        m_gl_placing_robot->setLocation(m_curCursorPos.x, m_curCursorPos.y, 0.01);
      }
      break;
      case cpsDrawObstacles:
      case cpsDrawClear:
      {
        m_gl_drawing_obs->setLocation(m_curCursorPos.x, m_curCursorPos.y, 0.01);
        if (event.ButtonIsDown(wxMOUSE_BTN_LEFT))
        {
          const int cx = m_gridMap.x2idx(m_curCursorPos.x);
          const int cy = m_gridMap.y2idx(m_curCursorPos.y);
          if (cx >= 0 && cy >= 0 && cx < (int)m_gridMap.getSizeX() &&
              cy < (int)m_gridMap.getSizeY())
          {
            m_gridMap.setCell(cx, cy, m_cursorPickState == cpsDrawObstacles ? 0.01f : 0.99f);
            updateMap3DView();
            m_plot3D->Refresh();
          }
          skip_normal_process = true;
        }
      }
      break;
      default:
        break;
    };

    StatusBar1->SetStatusText(
        wxString::Format(wxT("X=%.03f Y=%.04f Z=0"), m_curCursorPos.x, m_curCursorPos.y), 2);
  }

  if (!skip_normal_process)
  {
    // Do normal process in that class:
    m_plot3D->OnMouseMove(event);
  }
}

void reactive_navigator_demoframe::Onplot3DMouseClick(wxMouseEvent& event)
{
  WX_START_TRY

  bool skip_normal_process = false;

  switch (m_cursorPickState)
  {
    case cpsPickWaypoints:
    {
      if (event.ButtonIsDown(wxMOUSE_BTN_LEFT))
      {
        const bool allow_skip_wps = !event.ShiftDown();
        double heading = TWaypoint::INVALID_NUM;
        if (event.ControlDown())
        {
          this->edWayPtHeading->GetValue().ToCDouble(&heading);
          heading *= M_PI / 180;
        }
        m_waypoints_clicked.waypoints.emplace_back(
            m_curCursorPos.x, m_curCursorPos.y, 0.35 /* allowed dist */, allow_skip_wps, heading);
      }
      if (event.ButtonIsDown(wxMOUSE_BTN_RIGHT))
      {
        btnPlaceTarget->SetValue(false);
        btnPlaceTarget->Refresh();
        m_gl_placing_nav_target->setVisibility(false);

        auto* wp_nav = dynamic_cast<CWaypointsNavigator*>(m_navMethod.get());
        if (wp_nav) wp_nav->navigateWaypoints(m_waypoints_clicked);

        m_waypoints_clicked.clear();

        m_plot3D->SetCursor(*wxSTANDARD_CURSOR);  // End of cross cursor
        m_cursorPickState = cpsNone;              // end of mode
      }
    }
    break;

    case cpsPickTarget:
      if (event.ButtonIsDown(wxMOUSE_BTN_LEFT))
      {
        m_targetPoint = m_curCursorPos;

        btnPlaceTarget->SetValue(false);
        btnPlaceTarget->Refresh();
        m_gl_placing_nav_target->setVisibility(false);

        // Issue a new navigation cmd:
        CAbstractPTGBasedReactive::TNavigationParamsPTG navParams;
        navParams.target.target_coords.x = m_targetPoint.x;
        navParams.target.target_coords.y = m_targetPoint.y;
        navParams.target.targetAllowedDistance = 0.40f;
        navParams.target.targetIsRelative = false;

        // Optional: restrict the PTGs to use
        // navParams.restrict_PTG_indices.push_back(1);

        m_navMethod->navigate(&navParams);
        gl_target->setVisibility(true);

        m_plot3D->SetCursor(*wxSTANDARD_CURSOR);  // End of cross cursor
        m_cursorPickState = cpsNone;              // end of mode
      }
      break;
    case cpsPlaceRobot:
      if (event.ButtonIsDown(wxMOUSE_BTN_LEFT))
      {
        m_robotSimul->setCurrentGTPose(mrpt::math::TPose2D(m_curCursorPos.x, m_curCursorPos.y, .0));

        btnPlaceRobot->SetValue(false);
        btnPlaceRobot->Refresh();
        m_gl_placing_robot->setVisibility(false);
        m_plot3D->SetCursor(*wxSTANDARD_CURSOR);  // End of cross cursor
        m_cursorPickState = cpsNone;              // end of mode
      }
      break;
    case cpsDrawObstacles:
    case cpsDrawClear:
      if (event.ButtonIsDown(wxMOUSE_BTN_LEFT))
      {
        const int cx = m_gridMap.x2idx(m_curCursorPos.x);
        const int cy = m_gridMap.y2idx(m_curCursorPos.y);
        if (cx >= 0 && cy >= 0 && cx < (int)m_gridMap.getSizeX() && cy < (int)m_gridMap.getSizeY())
        {
          m_gridMap.setCell(cx, cy, m_cursorPickState == cpsDrawObstacles ? 0.01f : 0.99f);
          updateMap3DView();
          m_plot3D->Refresh();
        }
        skip_normal_process = true;
      }
      break;
    default:
      break;
  }

  if (!skip_normal_process)
  {
    // Do normal process in that class:
    m_plot3D->OnMouseDown(event);
  }
  WX_END_TRY
}

// ==== reactive_navigator_demoframe::TOptions ======
void reactive_navigator_demoframe::TOptions::loadFromConfigFile(
    const mrpt::config::CConfigFileBase& source, const std::string& section)
{
  MRPT_START

  // Load from config text:
  MRPT_LOAD_CONFIG_VAR(MAX_SENSOR_RADIUS, double, source, section);
  MRPT_LOAD_CONFIG_VAR_DEGREES(SENSOR_FOV, source, section);
  MRPT_LOAD_CONFIG_VAR(SENSOR_NUM_RANGES, uint64_t, source, section);
  MRPT_LOAD_CONFIG_VAR(SENSOR_RANGE_NOISE_STD, double, source, section);
  MRPT_LOAD_CONFIG_VAR(SENSOR_RATE, double, source, section);
  MRPT_LOAD_CONFIG_VAR(NAVIGATION_RATE, double, source, section);

  MRPT_END
}

void reactive_navigator_demoframe::TOptions::saveToConfigFile(
    mrpt::config::CConfigFileBase& cfg, const std::string& section) const
{
  MRPT_START
  const int WN = 40, WV = 20;

  cfg.write(
      section, "MAX_SENSOR_RADIUS", MAX_SENSOR_RADIUS, WN, WV,
      "Maximum range of the LiDAR sensor (meters)");
  cfg.write(
      section, "SENSOR_FOV", 180.0 / M_PI * SENSOR_FOV, WN, WV,
      "Horizontal Field of view of the LiDAR (deg)");
  cfg.write(
      section, "SENSOR_NUM_RANGES", SENSOR_NUM_RANGES, WN, WV,
      "Number of ranges in the 360deg sensor FOV");
  cfg.write(
      section, "SENSOR_RANGE_NOISE_STD", SENSOR_RANGE_NOISE_STD, WN, WV,
      "Sensor noise (one sigma, in meters)");
  cfg.write(section, "SENSOR_RATE", SENSOR_RATE, WN, WV, "Sensor rate (Hz)");
  cfg.write(section, "NAVIGATION_RATE", NAVIGATION_RATE, WN, WV, "Navigation algorithm rate (Hz)");

  MRPT_END
}

void reactive_navigator_demoframe::OnMenuItemChangeVisibleStuff(wxCommandEvent& event)
{
  updateViewsDynamicObjects();
}

void reactive_navigator_demoframe::OnMenuItemClearRobotPath(wxCommandEvent& event)
{
  gl_robot_path->clear();
  updateViewsDynamicObjects();
}

void reactive_navigator_demoframe::OnbtnLoadMapClick(wxCommandEvent& event)
{
  WX_START_TRY

  wxFileDialog dlg(
      this, _("Select grid map to load"), _("."), _("grid.png"),
      wxT("Image files (*.png,*.jpg,*.gif) or binary gridmap files "
          "|*.png;*.jpg;*.gif;*.gridmap;*.gridmap.gz|All files (*.*)|*.*"),
      wxFD_OPEN | wxFD_FILE_MUST_EXIST);

  if (dlg.ShowModal() != wxID_OK) return;

  const wxString sFil = dlg.GetPath();
  const std::string fil = std::string(sFil.mb_str());

  const std::string fil_ext = mrpt::system::extractFileExtension(fil, true);

  if (mrpt::system::lowerCase(fil_ext) == "gridmap")
  {
    CFileGZInputStream f(fil);
    archiveFrom(f) >> m_gridMap;
  }
  else
  {
    // Try loading the image:
    CImage img;
    if (!img.loadFromFile(fil, 0 /* force grayscale */))
    {
      wxMessageBox(_("Error"), _("Can't load the image file (check its format)."));
    }
    else
    {
      // We also need the size of each pixel:
      double cx = -1;
      double cy = -1;
      double cell_size = 0.05;

      const wxString sCellSize = wxGetTextFromUser(
          _("Enter the size (in meters) of each pixel:"), _("Grid parameters"), _("0.05"), this);
      const wxString sCX = wxGetTextFromUser(
          _("Enter the central pixel (x-coordinate), or -1 = the image "
            "center:"),
          _("Grid parameters"), _("-1"), this);
      const wxString sCY = wxGetTextFromUser(
          _("Enter the central pixel (y-coordinate), or -1 = the image "
            "center:"),
          _("Grid parameters"), _("-1"), this);

      if (sCellSize.ToCDouble(&cell_size) && sCX.ToCDouble(&cx) && sCY.ToCDouble(&cy))
      {
        if (!m_gridMap.loadFromBitmap(img, cell_size, {cx, cy}))
          wxMessageBox(_("Error"), _("Can't load the image file into the gridmap..."));
      }
      else
        wxMessageBox(_("Error"), _("Error parsing the numbers you entered..."));
    }
  }

  updateMap3DView();
  m_plot3D->Refresh();

  WX_END_TRY
}

void reactive_navigator_demoframe::OnNotebook1PageChanged(wxNotebookEvent& event) {}

void reactive_navigator_demoframe::OnNotebook1PageChanged1(wxNotebookEvent& event) {}

void reactive_navigator_demoframe::OnedManualKinRampsText(wxCommandEvent& event) {}

void reactive_navigator_demoframe::OnbtnQuitClick(wxCommandEvent& event) { Close(); }

void create_viz_robot_holo(mrpt::opengl::CSetOfObjects& objs)
{
  objs.clear();
  {
    mrpt::opengl::CSetOfObjects::Ptr gl_xyz =
        mrpt::opengl::stock_objects::CornerXYZSimple(1.0f, 2.0f);
    gl_xyz->setLocation(0.0, 0.0, 1.25);
    objs.insert(gl_xyz);
  }

  mrpt::opengl::CCylinder::Ptr obj = mrpt::opengl::CCylinder::Create(
      0.36f /*base radius*/, 0.20f /*top radius */, 1.2f /*height*/);
  obj->setColor_u8(TColor::red());
  objs.insert(obj);
}
void create_viz_robot_diff(mrpt::opengl::CSetOfObjects& objs)
{
  objs.clear();
  objs.insert(mrpt::opengl::stock_objects::RobotPioneer());
}

void reactive_navigator_demoframe::OnrbKinTypeSelect(wxCommandEvent& event)
{
  // We must first detach the simulator from the navigator object before
  // deleting it:
  m_navMethod.reset();

  // Delete old & build new simulator:
  m_robotSimul2NavInterface.reset();
  m_robotSimul.reset();

  if (gl_robot_path) gl_robot_path->clear();
  if (gl_target) gl_target->setVisibility(false);

  switch (rbKinType->GetSelection())
  {
    case 0:
    {
      auto* sim = new mrpt::kinematics::CVehicleSimul_DiffDriven();
      m_robotSimul.reset(sim);
      m_robotSimul2NavInterface =
          std::make_unique<MyRobot2NavInterface_Diff>(*sim, m_latest_obstacles);
      // Opengl viz:
      create_viz_robot_diff(*std::dynamic_pointer_cast<mrpt::opengl::CSetOfObjects>(
          gl_robot->getByName("robot_render")));
      create_viz_robot_diff(*gl_robot_local);
      gl_robot_local->setScale(1.0 / m_simul_options.MAX_SENSOR_RADIUS);
    }
    break;
    case 1:
    {
      auto* sim = new mrpt::kinematics::CVehicleSimul_Holo();
      m_robotSimul.reset(sim);
      m_robotSimul2NavInterface =
          std::make_unique<MyRobot2NavInterface_Holo>(*sim, m_latest_obstacles);
      // Opengl viz:
      create_viz_robot_holo(*std::dynamic_pointer_cast<mrpt::opengl::CSetOfObjects>(
          gl_robot->getByName("robot_render")));
      create_viz_robot_holo(*gl_robot_local);
      gl_robot_local->setScale(1.0 / m_simul_options.MAX_SENSOR_RADIUS);
    }
    break;
    default:
      throw std::runtime_error("Invalid kinematic model selected!");
  };
}

void reactive_navigator_demoframe::OnbtnEmptyMapClick(wxCommandEvent& event)
{
  WX_START_TRY

  double lx = 30., ly = 30.;
  double res = 0.25;
  wxString s;
  s = wxGetTextFromUser(_("Width (x) [meters]:"), _("New map"), _("40.0"), this);
  if (s.IsEmpty()) return;
  if (!s.ToCDouble(&lx))
  {
    wxMessageBox(_("Invalid number"));
    return;
  }

  s = wxGetTextFromUser(_("Height (y) [meters]:"), _("New map"), _("30.0"), this);
  if (s.IsEmpty()) return;
  if (!s.ToCDouble(&ly))
  {
    wxMessageBox(_("Invalid number"));
    return;
  }

  s = wxGetTextFromUser(_("Grid resolution [meters]:"), _("New map"), _("0.25"), this);
  if (s.IsEmpty()) return;
  if (!s.ToCDouble(&res))
  {
    wxMessageBox(_("Invalid number"));
    return;
  }

  m_gridMap.setSize(-.5 * lx, .5 * lx, -.5 * ly, .5 * ly, res, 0.99f);

  updateMap3DView();
  m_plot3D->Refresh();

  WX_END_TRY
}

void reactive_navigator_demoframe::OnbtnSaveMapClick(wxCommandEvent& event)
{
  WX_START_TRY

  wxFileDialog dlg(
      this, _("Save gridmap to file"), _("."), _("map.gridmap.gz"),
      wxT("Binary gridmap files "
          "(*.gridmap,*.gridmap.gz)|*.gridmap;*.gridmap.gz|All files "
          "(*.*)|*.*"),
      wxFD_SAVE | wxFD_OVERWRITE_PROMPT);

  if (dlg.ShowModal() != wxID_OK) return;

  CFileGZOutputStream f(std::string(dlg.GetPath().mb_str()));
  archiveFrom(f) << m_gridMap;

  WX_END_TRY
}

void reactive_navigator_demoframe::OnbtnDrawMapObsClick(wxCommandEvent& event)
{
  if (m_cursorPickState != cpsDrawObstacles)
  {
    m_cursorPickState = cpsDrawObstacles;
    m_plot3D->SetCursor(*wxCROSS_CURSOR);
  }
  else
  {  // Cancel:
    m_cursorPickState = cpsNone;
    m_plot3D->SetCursor(*wxSTANDARD_CURSOR);
  }
  btnDrawMapObs->SetValue(m_cursorPickState == cpsDrawObstacles);
  btnDrawMapObs->Refresh();
  btnDrawEmpty->SetValue(m_cursorPickState == cpsDrawClear);
  btnDrawEmpty->Refresh();
  m_gl_drawing_obs->setVisibility(
      m_cursorPickState == cpsDrawObstacles || m_cursorPickState == cpsDrawClear);
  m_plot3D->Refresh();
}

void reactive_navigator_demoframe::OnbtnDrawEmptyClick(wxCommandEvent& event)
{
  if (m_cursorPickState != cpsDrawClear)
  {
    m_cursorPickState = cpsDrawClear;
    m_plot3D->SetCursor(*wxCROSS_CURSOR);
  }
  else
  {  // Cancel:
    m_cursorPickState = cpsNone;
    m_plot3D->SetCursor(*wxSTANDARD_CURSOR);
  }
  btnDrawMapObs->SetValue(m_cursorPickState == cpsDrawObstacles);
  btnDrawMapObs->Refresh();
  btnDrawEmpty->SetValue(m_cursorPickState == cpsDrawClear);
  btnDrawEmpty->Refresh();
  m_gl_drawing_obs->setVisibility(
      m_cursorPickState == cpsDrawObstacles || m_cursorPickState == cpsDrawClear);
  m_plot3D->Refresh();
}

void reactive_navigator_demoframe::OnbtnSetWaypointSeqClick(wxCommandEvent& event)
{
  auto* wp_nav = dynamic_cast<CWaypointsNavigator*>(m_navMethod.get());
  if (!wp_nav)
  {
    wxMessageBox(wxT("Navigator class does not support waypoints sequences!"));
    return;
  }

  if (m_cursorPickState != cpsPickWaypoints)
  {
    m_cursorPickState = cpsPickWaypoints;
    m_plot3D->SetCursor(*wxCROSS_CURSOR);
    m_waypoints_clicked.clear();
  }
  else
  {  // Cancel:
    m_cursorPickState = cpsNone;
    m_plot3D->SetCursor(*wxSTANDARD_CURSOR);
  }
  btnSetWaypointSeq->SetValue(m_cursorPickState == cpsPickWaypoints);
  btnSetWaypointSeq->Refresh();
  m_gl_placing_nav_target->setVisibility(m_cursorPickState == cpsPickWaypoints);
  m_plot3D->Refresh();
}

void reactive_navigator_demoframe::OnbtnGenerateTemplateClick(wxCommandEvent& event)
{
  WX_START_TRY;

  mrpt::nav::CReactiveNavigationSystem react(*m_robotSimul2NavInterface);

  mrpt::config::CConfigFileMemory cfgMem;
  react.saveConfigFile(cfgMem);
  edParamsReactive->SetValue(cfgMem.getContent().c_str());

  WX_END_TRY;
}
