rooty/LibrePilot
1
0
Fork 0
mirror of https://bitbucket.org/librepilot/librepilot.git synced 2025-02-05 21:52:10 +01:00
Code Issues Releases Activity

Can now manually move the HomeLocation icon on the map, it updates the uavobject with lat, lon & new Be values.

Browse Source 
git-svn-id: svn://svn.openpilot.org/OpenPilot/trunk@2541 ebee16cc-31ac-478f-84a7-5cbb03baadba
This commit is contained in:
pip 2011-01-23 13:00:53 +00:00 committed by pip
parent 8223580783
commit 0579de11e3
2 changed files with 2790 additions and 2716 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4833
ground/openpilotgcs/src/plugins/opmap/opmapgadgetwidget.cpp
View File

@ -1,2381 +1,2452 @@
/** /**
****************************************************************************** ******************************************************************************
* *
* @file opmapgadgetwidget.cpp * @file opmapgadgetwidget.cpp
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @addtogroup GCSPlugins GCS Plugins * @addtogroup GCSPlugins GCS Plugins
* @{ * @{
* @addtogroup OPMapPlugin OpenPilot Map Plugin * @addtogroup OPMapPlugin OpenPilot Map Plugin
* @{ * @{
* @brief The OpenPilot Map plugin * @brief The OpenPilot Map plugin
*****************************************************************************/ *****************************************************************************/
/* /*
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, but * This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details. * for more details.
* *
* You should have received a copy of the GNU General Public License along * You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc., * with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/ */
#include "opmapgadgetwidget.h" #include "opmapgadgetwidget.h"
#include "ui_opmap_widget.h" #include "ui_opmap_widget.h"
#include <utils/stylehelper.h>
#include <QtGui/QApplication> #include <QtGui/QApplication>
#include <QtGui/QHBoxLayout> #include <QtGui/QHBoxLayout>
#include <QtGui/QVBoxLayout> #include <QtGui/QVBoxLayout>
#include <QtGui/QClipboard> #include <QtGui/QClipboard>
#include <QtGui/QMenu> #include <QtGui/QMenu>
#include <QStringList> #include <QStringList>
#include <QDir> #include <QDir>
#include <QFile> #include <QFile>
#include <QDateTime> #include <QDateTime>
#include <math.h> #include <math.h>
#include "utils/worldmagmodel.h" #include "utils/stylehelper.h"
#include "uavtalk/telemetrymanager.h" #include "utils/worldmagmodel.h"
#include "extensionsystem/pluginmanager.h"
#include "uavobjectmanager.h" #include "uavtalk/telemetrymanager.h"
#include "uavobject.h"
#include "positionactual.h" #include "extensionsystem/pluginmanager.h"
#include "homelocation.h" #include "uavobjectmanager.h"
#include "uavobject.h"
// #define allow_manual_home_location_move #include "objectpersistence.h"
// ************************************************************************************* #include "positionactual.h"
#include "homelocation.h"
#define deg_to_rad ((double)M_PI / 180.0)
#define rad_to_deg (180.0 / (double)M_PI) #define allow_manual_home_location_move
#define earth_mean_radius 6371 // kilometers // *************************************************************************************
#define max_digital_zoom 3 // maximum allowed digital zoom level #define deg_to_rad ((double)M_PI / 180.0)
#define rad_to_deg (180.0 / (double)M_PI)
const int safe_area_radius_list[] = {5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000}; // meters
#define earth_mean_radius 6371 // kilometers
const int uav_trail_time_list[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // seconds
#define max_digital_zoom 3 // maximum allowed digital zoom level
const int uav_trail_distance_list[] = {1, 2, 5, 10, 20, 50, 100, 200, 500}; // meters
const int safe_area_radius_list[] = {5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000}; // meters
// *************************************************************************************
const int uav_trail_time_list[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // seconds
// ************************************************************************************* const int uav_trail_distance_list[] = {1, 2, 5, 10, 20, 50, 100, 200, 500}; // meters
// NOTE: go back to SVN REV 2137 and earlier to get back to experimental waypoint support.
// ************************************************************************************* // *************************************************************************************
// constructor // *************************************************************************************
OPMapGadgetWidget::OPMapGadgetWidget(QWidget *parent) : QWidget(parent) // NOTE: go back to SVN REV 2137 and earlier to get back to experimental waypoint support.
{ // *************************************************************************************
// **************
m_widget = NULL; // constructor
m_map = NULL; OPMapGadgetWidget::OPMapGadgetWidget(QWidget *parent) : QWidget(parent)
findPlaceCompleter = NULL; {
m_overlay_widget = NULL; // **************
m_map_graphics_scene = NULL; m_widget = NULL;
m_map_scene_proxy = NULL; m_map = NULL;
m_zoom_slider_widget = NULL; findPlaceCompleter = NULL;
m_statusbar_widget = NULL; m_overlay_widget = NULL;
m_mouse_waypoint = NULL; m_map_graphics_scene = NULL;
m_map_scene_proxy = NULL;
prev_tile_number = 0; m_zoom_slider_widget = NULL;
m_statusbar_widget = NULL;
min_zoom = max_zoom = 0;
m_mouse_waypoint = NULL;
m_map_mode = Normal_MapMode;
prev_tile_number = 0;
telemetry_connected = false;
min_zoom = max_zoom = 0;
context_menu_lat_lon = mouse_lat_lon = internals::PointLatLng(0, 0);
m_map_mode = Normal_MapMode;
setMouseTracking(true);
telemetry_connected = false;
ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
context_menu_lat_lon = mouse_lat_lon = internals::PointLatLng(0, 0);
// **************
// get current location setMouseTracking(true);
double latitude = 0; ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
double longitude = 0;
double altitude = 0; // **************
// get current location
// current position
getUAV_LLA(latitude, longitude, altitude); double latitude = 0;
//getGPS_LLA(latitude, longitude, altitude); double longitude = 0;
double altitude = 0;
internals::PointLatLng pos_lat_lon = internals::PointLatLng(latitude, longitude);
// current position
// ************** getUAV_LLA(latitude, longitude, altitude);
// default home position //getGPS_LLA(latitude, longitude, altitude);
home_position.coord = pos_lat_lon; internals::PointLatLng pos_lat_lon = internals::PointLatLng(latitude, longitude);
home_position.altitude = altitude;
home_position.locked = false; // **************
// default home position
// **************
// default magic waypoint params home_position.coord = pos_lat_lon;
home_position.altitude = altitude;
magic_waypoint.map_wp_item = NULL; home_position.locked = false;
magic_waypoint.coord = home_position.coord;
magic_waypoint.altitude = altitude; // **************
magic_waypoint.description = "Magic waypoint"; // default magic waypoint params
magic_waypoint.locked = false;
magic_waypoint.time_seconds = 0; magic_waypoint.map_wp_item = NULL;
magic_waypoint.hold_time_seconds = 0; magic_waypoint.coord = home_position.coord;
magic_waypoint.altitude = altitude;
// ************** magic_waypoint.description = "Magic waypoint";
// create the widget that holds the user controls and the map magic_waypoint.locked = false;
magic_waypoint.time_seconds = 0;
m_widget = new Ui::OPMap_Widget(); magic_waypoint.hold_time_seconds = 0;
m_widget->setupUi(this);
// **************
// ************** // create the widget that holds the user controls and the map
// create the central map widget
m_widget = new Ui::OPMap_Widget();
m_map = new mapcontrol::OPMapWidget(); // create the map object m_widget->setupUi(this);
m_map->setFrameStyle(QFrame::NoFrame); // no border frame // **************
m_map->setBackgroundBrush(QBrush(Utils::StyleHelper::baseColor())); // tile background // create the central map widget
m_map->configuration->DragButton = Qt::LeftButton; // use the left mouse button for map dragging m_map = new mapcontrol::OPMapWidget(); // create the map object
m_widget->horizontalSliderZoom->setMinimum(m_map->MinZoom()); // m_map->setFrameStyle(QFrame::NoFrame); // no border frame
m_widget->horizontalSliderZoom->setMaximum(m_map->MaxZoom() + max_digital_zoom); // m_map->setBackgroundBrush(QBrush(Utils::StyleHelper::baseColor())); // tile background
min_zoom = m_widget->horizontalSliderZoom->minimum(); // minimum zoom we can accept m_map->configuration->DragButton = Qt::LeftButton; // use the left mouse button for map dragging
max_zoom = m_widget->horizontalSliderZoom->maximum(); // maximum zoom we can accept
m_widget->horizontalSliderZoom->setMinimum(m_map->MinZoom()); //
m_map->SetMouseWheelZoomType(internals::MouseWheelZoomType::MousePositionWithoutCenter); // set how the mouse wheel zoom functions m_widget->horizontalSliderZoom->setMaximum(m_map->MaxZoom() + max_digital_zoom); //
m_map->SetFollowMouse(true); // we want a contiuous mouse position reading
min_zoom = m_widget->horizontalSliderZoom->minimum(); // minimum zoom we can accept
m_map->SetShowHome(true); // display the HOME position on the map max_zoom = m_widget->horizontalSliderZoom->maximum(); // maximum zoom we can accept
m_map->SetShowUAV(true); // display the UAV position on the map
m_map->SetMouseWheelZoomType(internals::MouseWheelZoomType::MousePositionWithoutCenter); // set how the mouse wheel zoom functions
m_map->Home->SetSafeArea(safe_area_radius_list[3]); // set radius (meters) m_map->SetFollowMouse(true); // we want a contiuous mouse position reading
m_map->Home->SetShowSafeArea(true); // show the safe area
m_map->SetShowHome(true); // display the HOME position on the map
m_map->UAV->SetTrailTime(uav_trail_time_list[0]); // seconds m_map->SetShowUAV(true); // display the UAV position on the map
m_map->UAV->SetTrailDistance(uav_trail_distance_list[1]); // meters
m_map->Home->SetSafeArea(safe_area_radius_list[3]); // set radius (meters)
m_map->UAV->SetTrailType(UAVTrailType::ByTimeElapsed); m_map->Home->SetShowSafeArea(true); // show the safe area
// m_map->UAV->SetTrailType(UAVTrailType::ByDistance);
m_map->UAV->SetTrailTime(uav_trail_time_list[0]); // seconds
m_map->GPS->SetTrailTime(uav_trail_time_list[0]); // seconds m_map->UAV->SetTrailDistance(uav_trail_distance_list[1]); // meters
m_map->GPS->SetTrailDistance(uav_trail_distance_list[1]); // meters
m_map->UAV->SetTrailType(UAVTrailType::ByTimeElapsed);
m_map->GPS->SetTrailType(UAVTrailType::ByTimeElapsed); // m_map->UAV->SetTrailType(UAVTrailType::ByDistance);
// m_map->GPS->SetTrailType(UAVTrailType::ByDistance);
m_map->GPS->SetTrailTime(uav_trail_time_list[0]); // seconds
// ************** m_map->GPS->SetTrailDistance(uav_trail_distance_list[1]); // meters
setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding); m_map->GPS->SetTrailType(UAVTrailType::ByTimeElapsed);
// m_map->GPS->SetTrailType(UAVTrailType::ByDistance);
QVBoxLayout *layout = new QVBoxLayout;
layout->setSpacing(0); // **************
layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(m_map); setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
m_widget->mapWidget->setLayout(layout);
QVBoxLayout *layout = new QVBoxLayout;
// ************** layout->setSpacing(0);
// create the user controls overlayed onto the map layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(m_map);
// doing this makes the map VERY slow :( m_widget->mapWidget->setLayout(layout);
/* // **************
m_zoom_slider_widget = new opmap_zoom_slider_widget(); // create the user controls overlayed onto the map
m_statusbar_widget = new opmap_statusbar_widget();
// doing this makes the map VERY slow :(
m_map_graphics_scene = m_map->scene();
/*
m_map_scene_proxy = m_map_graphics_scene->addWidget(m_zoom_slider_widget); m_zoom_slider_widget = new opmap_zoom_slider_widget();
m_map_scene_proxy = m_map_graphics_scene->addWidget(m_statusbar_widget); m_statusbar_widget = new opmap_statusbar_widget();
m_zoom_slider_widget->move(m_map->width() - 20 - m_zoom_slider_widget->width(), 20); m_map_graphics_scene = m_map->scene();
m_statusbar_widget->move(0, m_map->height() - m_statusbar_widget->height());
*/ m_map_scene_proxy = m_map_graphics_scene->addWidget(m_zoom_slider_widget);
/* m_map_scene_proxy = m_map_graphics_scene->addWidget(m_statusbar_widget);
m_overlay_widget = new opmap_overlay_widget(m_map);
QVBoxLayout *layout2 = new QVBoxLayout; m_zoom_slider_widget->move(m_map->width() - 20 - m_zoom_slider_widget->width(), 20);
layout2->setSpacing(0); m_statusbar_widget->move(0, m_map->height() - m_statusbar_widget->height());
layout2->setContentsMargins(0, 0, 0, 0); */
layout2->addWidget(m_overlay_widget); /*
m_map->setLayout(layout2); m_overlay_widget = new opmap_overlay_widget(m_map);
*/ QVBoxLayout *layout2 = new QVBoxLayout;
// ************** layout2->setSpacing(0);
// set the user control options layout2->setContentsMargins(0, 0, 0, 0);
layout2->addWidget(m_overlay_widget);
m_map->setLayout(layout2);
// TODO: this switch does not make sense, does it?? */
// **************
switch (m_map_mode) // set the user control options
{
case Normal_MapMode:
m_widget->toolButtonMagicWaypointMapMode->setChecked(false); // TODO: this switch does not make sense, does it??
m_widget->toolButtonNormalMapMode->setChecked(true);
hideMagicWaypointControls(); switch (m_map_mode)
break; {
case Normal_MapMode:
case MagicWaypoint_MapMode: m_widget->toolButtonMagicWaypointMapMode->setChecked(false);
m_widget->toolButtonNormalMapMode->setChecked(false); m_widget->toolButtonNormalMapMode->setChecked(true);
m_widget->toolButtonMagicWaypointMapMode->setChecked(true); hideMagicWaypointControls();
showMagicWaypointControls(); break;
break;
case MagicWaypoint_MapMode:
default: m_widget->toolButtonNormalMapMode->setChecked(false);
m_map_mode = Normal_MapMode; m_widget->toolButtonMagicWaypointMapMode->setChecked(true);
m_widget->toolButtonMagicWaypointMapMode->setChecked(false); showMagicWaypointControls();
m_widget->toolButtonNormalMapMode->setChecked(true); break;
hideMagicWaypointControls();
break; default:
} m_map_mode = Normal_MapMode;
m_widget->toolButtonMagicWaypointMapMode->setChecked(false);
m_widget->labelUAVPos->setText("---"); m_widget->toolButtonNormalMapMode->setChecked(true);
m_widget->labelMapPos->setText("---"); hideMagicWaypointControls();
m_widget->labelMousePos->setText("---"); break;
m_widget->labelMapZoom->setText("---"); }
m_widget->labelUAVPos->setText("---");
// Splitter is not used at the moment: m_widget->labelMapPos->setText("---");
// m_widget->splitter->setCollapsible(1, false); m_widget->labelMousePos->setText("---");
m_widget->labelMapZoom->setText("---");
// set the size of the collapsable widgets
//QList<int> m_SizeList;
//m_SizeList << 0 << 0 << 0; // Splitter is not used at the moment:
//m_widget->splitter->setSizes(m_SizeList); // m_widget->splitter->setCollapsible(1, false);
m_widget->progressBarMap->setMaximum(1); // set the size of the collapsable widgets
//QList<int> m_SizeList;
/* //m_SizeList << 0 << 0 << 0;
#if defined(Q_OS_MAC) //m_widget->splitter->setSizes(m_SizeList);
#elif defined(Q_OS_WIN)
m_widget->comboBoxFindPlace->clear(); m_widget->progressBarMap->setMaximum(1);
loadComboBoxLines(m_widget->comboBoxFindPlace, QCoreApplication::applicationDirPath() + "/opmap_find_place_history.txt");
m_widget->comboBoxFindPlace->setCurrentIndex(-1); /*
#else #if defined(Q_OS_MAC)
#endif #elif defined(Q_OS_WIN)
*/ m_widget->comboBoxFindPlace->clear();
loadComboBoxLines(m_widget->comboBoxFindPlace, QCoreApplication::applicationDirPath() + "/opmap_find_place_history.txt");
m_widget->comboBoxFindPlace->setCurrentIndex(-1);
// ************** #else
// map stuff #endif
*/
connect(m_map, SIGNAL(zoomChanged(double, double, double)), this, SLOT(zoomChanged(double, double, double))); // map zoom change signals
connect(m_map, SIGNAL(OnCurrentPositionChanged(internals::PointLatLng)), this, SLOT(OnCurrentPositionChanged(internals::PointLatLng))); // map poisition change signals
connect(m_map, SIGNAL(OnTileLoadComplete()), this, SLOT(OnTileLoadComplete())); // tile loading stop signals // **************
connect(m_map, SIGNAL(OnTileLoadStart()), this, SLOT(OnTileLoadStart())); // tile loading start signals // map stuff
connect(m_map, SIGNAL(OnMapDrag()), this, SLOT(OnMapDrag())); // map drag signals
connect(m_map, SIGNAL(OnMapZoomChanged()), this, SLOT(OnMapZoomChanged())); // map zoom changed connect(m_map, SIGNAL(zoomChanged(double, double, double)), this, SLOT(zoomChanged(double, double, double))); // map zoom change signals
connect(m_map, SIGNAL(OnMapTypeChanged(MapType::Types)), this, SLOT(OnMapTypeChanged(MapType::Types))); // map type changed connect(m_map, SIGNAL(OnCurrentPositionChanged(internals::PointLatLng)), this, SLOT(OnCurrentPositionChanged(internals::PointLatLng))); // map poisition change signals
connect(m_map, SIGNAL(OnEmptyTileError(int, core::Point)), this, SLOT(OnEmptyTileError(int, core::Point))); // tile error connect(m_map, SIGNAL(OnTileLoadComplete()), this, SLOT(OnTileLoadComplete())); // tile loading stop signals
connect(m_map, SIGNAL(OnTilesStillToLoad(int)), this, SLOT(OnTilesStillToLoad(int))); // tile loading signals connect(m_map, SIGNAL(OnTileLoadStart()), this, SLOT(OnTileLoadStart())); // tile loading start signals
connect(m_map, SIGNAL(WPNumberChanged(int const&,int const&,WayPointItem*)), this, SLOT(WPNumberChanged(int const&,int const&,WayPointItem*))); connect(m_map, SIGNAL(OnMapDrag()), this, SLOT(OnMapDrag())); // map drag signals
connect(m_map, SIGNAL(WPValuesChanged(WayPointItem*)), this, SLOT(WPValuesChanged(WayPointItem*))); connect(m_map, SIGNAL(OnMapZoomChanged()), this, SLOT(OnMapZoomChanged())); // map zoom changed
connect(m_map, SIGNAL(WPInserted(int const&, WayPointItem*)), this, SLOT(WPInserted(int const&, WayPointItem*))); connect(m_map, SIGNAL(OnMapTypeChanged(MapType::Types)), this, SLOT(OnMapTypeChanged(MapType::Types))); // map type changed
connect(m_map, SIGNAL(WPDeleted(int const&)), this, SLOT(WPDeleted(int const&))); connect(m_map, SIGNAL(OnEmptyTileError(int, core::Point)), this, SLOT(OnEmptyTileError(int, core::Point))); // tile error
connect(m_map, SIGNAL(OnTilesStillToLoad(int)), this, SLOT(OnTilesStillToLoad(int))); // tile loading signals
m_map->SetCurrentPosition(home_position.coord); // set the map position connect(m_map, SIGNAL(WPNumberChanged(int const&,int const&,WayPointItem*)), this, SLOT(WPNumberChanged(int const&,int const&,WayPointItem*)));
m_map->Home->SetCoord(home_position.coord); // set the HOME position connect(m_map, SIGNAL(WPValuesChanged(WayPointItem*)), this, SLOT(WPValuesChanged(WayPointItem*)));
m_map->UAV->SetUAVPos(home_position.coord, 0.0); // set the UAV position connect(m_map, SIGNAL(WPInserted(int const&, WayPointItem*)), this, SLOT(WPInserted(int const&, WayPointItem*)));
m_map->GPS->SetUAVPos(home_position.coord, 0.0); // set the UAV position connect(m_map, SIGNAL(WPDeleted(int const&)), this, SLOT(WPDeleted(int const&)));
// ************** m_map->SetCurrentPosition(home_position.coord); // set the map position
// create various context menu (mouse right click menu) actions m_map->Home->SetCoord(home_position.coord); // set the HOME position
m_map->UAV->SetUAVPos(home_position.coord, 0.0); // set the UAV position
createActions(); m_map->GPS->SetUAVPos(home_position.coord, 0.0); // set the UAV position
// ************** // **************
// connect to the UAVObject updates we require to become a bit aware of our environment: // create various context menu (mouse right click menu) actions
if (pm) createActions();
{
// Register for Home Location state changes // **************
UAVObjectManager *obm = pm->getObject<UAVObjectManager>(); // connect to the UAVObject updates we require to become a bit aware of our environment:
if (obm)
{ if (pm)
UAVDataObject *obj = dynamic_cast<UAVDataObject*>(obm->getObject(QString("HomeLocation"))); {
if (obj) // Register for Home Location state changes
{ UAVObjectManager *obm = pm->getObject<UAVObjectManager>();
connect(obj, SIGNAL(objectUpdated(UAVObject*)), this , SLOT(homePositionUpdated(UAVObject*))); if (obm)
} {
} UAVDataObject *obj = dynamic_cast<UAVDataObject*>(obm->getObject(QString("HomeLocation")));
if (obj)
// Listen to telemetry connection events {
TelemetryManager *telMngr = pm->getObject<TelemetryManager>(); connect(obj, SIGNAL(objectUpdated(UAVObject*)), this , SLOT(homePositionUpdated(UAVObject*)));
if (telMngr) }
{ }
connect(telMngr, SIGNAL(connected()), this, SLOT(onTelemetryConnect()));
connect(telMngr, SIGNAL(disconnected()), this, SLOT(onTelemetryDisconnect())); // Listen to telemetry connection events
} TelemetryManager *telMngr = pm->getObject<TelemetryManager>();
} if (telMngr)
{
// ************** connect(telMngr, SIGNAL(connected()), this, SLOT(onTelemetryConnect()));
// create the desired timers connect(telMngr, SIGNAL(disconnected()), this, SLOT(onTelemetryDisconnect()));
}
m_updateTimer = new QTimer(); }
m_updateTimer->setInterval(200);
connect(m_updateTimer, SIGNAL(timeout()), this, SLOT(updatePosition())); // **************
m_updateTimer->start(); // create the desired timers
m_statusUpdateTimer = new QTimer(); m_updateTimer = new QTimer();
m_statusUpdateTimer->setInterval(100); m_updateTimer->setInterval(200);
connect(m_statusUpdateTimer, SIGNAL(timeout()), this, SLOT(updateMousePos())); connect(m_updateTimer, SIGNAL(timeout()), this, SLOT(updatePosition()));
m_statusUpdateTimer->start(); m_updateTimer->start();
// ************** m_statusUpdateTimer = new QTimer();
m_statusUpdateTimer->setInterval(100);
m_map->setFocus(); connect(m_statusUpdateTimer, SIGNAL(timeout()), this, SLOT(updateMousePos()));
} m_statusUpdateTimer->start();
// destructor // **************
OPMapGadgetWidget::~OPMapGadgetWidget()
{ m_map->setFocus();
}
// this destructor doesn't appear to be called at shutdown??? // destructor
OPMapGadgetWidget::~OPMapGadgetWidget()
// #if defined(Q_OS_MAC) {
// #elif defined(Q_OS_WIN)
// saveComboBoxLines(m_widget->comboBoxFindPlace, QCoreApplication::applicationDirPath() + "/opmap_find_place_history.txt");
// #else // this destructor doesn't appear to be called at shutdown???
// #endif
// #if defined(Q_OS_MAC)
m_waypoint_list_mutex.lock(); // #elif defined(Q_OS_WIN)
foreach (t_waypoint *wp, m_waypoint_list) // saveComboBoxLines(m_widget->comboBoxFindPlace, QCoreApplication::applicationDirPath() + "/opmap_find_place_history.txt");
{ // #else
if (!wp) continue; // #endif
m_waypoint_list_mutex.lock();
// todo: foreach (t_waypoint *wp, m_waypoint_list)
{
if (!wp) continue;
delete wp->map_wp_item;
}
m_waypoint_list_mutex.unlock(); // todo:
m_waypoint_list.clear();
if (m_zoom_slider_widget) delete m_zoom_slider_widget; delete wp->map_wp_item;
if (m_statusbar_widget) delete m_statusbar_widget; }
if (m_map) delete m_map; m_waypoint_list_mutex.unlock();
if (m_widget) delete m_widget; m_waypoint_list.clear();
}
if (m_zoom_slider_widget) delete m_zoom_slider_widget;
// ************************************************************************************* if (m_statusbar_widget) delete m_statusbar_widget;
// widget signals .. the mouseMoveEvent does not get called - don't yet know why if (m_map) delete m_map;
if (m_widget) delete m_widget;
void OPMapGadgetWidget::resizeEvent(QResizeEvent *event) }
{
qDebug("opmap: resizeEvent"); // *************************************************************************************
// widget signals .. the mouseMoveEvent does not get called - don't yet know why
QWidget::resizeEvent(event);
} void OPMapGadgetWidget::resizeEvent(QResizeEvent *event)
{
void OPMapGadgetWidget::mouseMoveEvent(QMouseEvent *event) qDebug("opmap: resizeEvent");
{
qDebug("opmap: mouseMoveEvent"); QWidget::resizeEvent(event);
}
if (m_widget && m_map)
{ void OPMapGadgetWidget::mouseMoveEvent(QMouseEvent *event)
} {
qDebug("opmap: mouseMoveEvent");
if (event->buttons() & Qt::LeftButton)
{ if (m_widget && m_map)
// QPoint pos = event->pos(); {
} }
QWidget::mouseMoveEvent(event); if (event->buttons() & Qt::LeftButton)
} {
// QPoint pos = event->pos();
void OPMapGadgetWidget::contextMenuEvent(QContextMenuEvent *event) }
{ // the user has right clicked on the map - create the pop-up context menu and display it
QWidget::mouseMoveEvent(event);
QString s; }
if (!m_widget || !m_map) void OPMapGadgetWidget::contextMenuEvent(QContextMenuEvent *event)
return; { // the user has right clicked on the map - create the pop-up context menu and display it
if (event->reason() != QContextMenuEvent::Mouse) QString s;
return; // not a mouse click event
if (!m_widget || !m_map)
// current mouse position return;
QPoint p = m_map->mapFromGlobal(event->globalPos());
context_menu_lat_lon = m_map->GetFromLocalToLatLng(p); if (event->reason() != QContextMenuEvent::Mouse)
// context_menu_lat_lon = m_map->currentMousePosition(); return; // not a mouse click event
if (!m_map->contentsRect().contains(p)) // current mouse position
return; // the mouse click was not on the map QPoint p = m_map->mapFromGlobal(event->globalPos());
context_menu_lat_lon = m_map->GetFromLocalToLatLng(p);
// show the mouse position // context_menu_lat_lon = m_map->currentMousePosition();
s = QString::number(context_menu_lat_lon.Lat(), 'f', 7) + " " + QString::number(context_menu_lat_lon.Lng(), 'f', 7);
m_widget->labelMousePos->setText(s); if (!m_map->contentsRect().contains(p))
return; // the mouse click was not on the map
// find out if we have a waypoint under the mouse cursor
QGraphicsItem *item = m_map->itemAt(p); // show the mouse position
m_mouse_waypoint = qgraphicsitem_cast<mapcontrol::WayPointItem *>(item); s = QString::number(context_menu_lat_lon.Lat(), 'f', 7) + " " + QString::number(context_menu_lat_lon.Lng(), 'f', 7);
m_widget->labelMousePos->setText(s);
// find out if the waypoint is locked (or not)
bool waypoint_locked = false; // find out if we have a waypoint under the mouse cursor
if (m_mouse_waypoint) QGraphicsItem *item = m_map->itemAt(p);
waypoint_locked = (m_mouse_waypoint->flags() & QGraphicsItem::ItemIsMovable) == 0; m_mouse_waypoint = qgraphicsitem_cast<mapcontrol::WayPointItem *>(item);
// **************** // find out if the waypoint is locked (or not)
// Dynamically create the popup menu bool waypoint_locked = false;
if (m_mouse_waypoint)
QMenu menu(this); waypoint_locked = (m_mouse_waypoint->flags() & QGraphicsItem::ItemIsMovable) == 0;
menu.addAction(closeAct1); // ****************
// Dynamically create the popup menu
menu.addSeparator();
QMenu menu(this);
menu.addAction(reloadAct);
menu.addAction(closeAct1);
menu.addSeparator();
menu.addSeparator();
switch (m_map_mode)
{ menu.addAction(reloadAct);
case Normal_MapMode: s = tr(" (Normal)"); break;
case MagicWaypoint_MapMode: s = tr(" (Magic Waypoint)"); break; menu.addSeparator();
default: s = tr(" (Unknown)"); break;
} switch (m_map_mode)
for (int i = 0; i < mapModeAct.count(); i++) {
{ // set the menu to checked (or not) case Normal_MapMode: s = tr(" (Normal)"); break;
QAction *act = mapModeAct.at(i); case MagicWaypoint_MapMode: s = tr(" (Magic Waypoint)"); break;
if (!act) continue; default: s = tr(" (Unknown)"); break;
if (act->data().toInt() == (int)m_map_mode) }
act->setChecked(true); for (int i = 0; i < mapModeAct.count(); i++)
} { // set the menu to checked (or not)
QMenu mapModeSubMenu(tr("Map mode") + s, this); QAction *act = mapModeAct.at(i);
for (int i = 0; i < mapModeAct.count(); i++) if (!act) continue;
mapModeSubMenu.addAction(mapModeAct.at(i)); if (act->data().toInt() == (int)m_map_mode)
menu.addMenu(&mapModeSubMenu); act->setChecked(true);
}
menu.addSeparator(); QMenu mapModeSubMenu(tr("Map mode") + s, this);
for (int i = 0; i < mapModeAct.count(); i++)
QMenu copySubMenu(tr("Copy"), this); mapModeSubMenu.addAction(mapModeAct.at(i));
copySubMenu.addAction(copyMouseLatLonToClipAct); menu.addMenu(&mapModeSubMenu);
copySubMenu.addAction(copyMouseLatToClipAct);
copySubMenu.addAction(copyMouseLonToClipAct); menu.addSeparator();
menu.addMenu(&copySubMenu);
QMenu copySubMenu(tr("Copy"), this);
menu.addSeparator(); copySubMenu.addAction(copyMouseLatLonToClipAct);
copySubMenu.addAction(copyMouseLatToClipAct);
/* copySubMenu.addAction(copyMouseLonToClipAct);
menu.addAction(findPlaceAct); menu.addMenu(&copySubMenu);
menu.addSeparator(); menu.addSeparator();
*/
/*
menu.addAction(showSafeAreaAct); menu.addAction(findPlaceAct);
QMenu safeAreaSubMenu(tr("Safe Area Radius") + " (" + QString::number(m_map->Home->SafeArea()) + "m)", this);
for (int i = 0; i < safeAreaAct.count(); i++) menu.addSeparator();
safeAreaSubMenu.addAction(safeAreaAct.at(i)); */
menu.addMenu(&safeAreaSubMenu);
menu.addAction(showSafeAreaAct);
menu.addSeparator(); QMenu safeAreaSubMenu(tr("Safe Area Radius") + " (" + QString::number(m_map->Home->SafeArea()) + "m)", this);
for (int i = 0; i < safeAreaAct.count(); i++)
menu.addAction(showCompassAct); safeAreaSubMenu.addAction(safeAreaAct.at(i));
menu.addMenu(&safeAreaSubMenu);
menu.addSeparator()->setText(tr("Zoom"));
menu.addSeparator();
menu.addAction(zoomInAct);
menu.addAction(zoomOutAct); menu.addAction(showCompassAct);
QMenu zoomSubMenu(tr("&Zoom ") + "(" + QString::number(m_map->ZoomTotal()) + ")", this); menu.addSeparator()->setText(tr("Zoom"));
for (int i = 0; i < zoomAct.count(); i++)
zoomSubMenu.addAction(zoomAct.at(i)); menu.addAction(zoomInAct);
menu.addMenu(&zoomSubMenu); menu.addAction(zoomOutAct);
menu.addSeparator(); QMenu zoomSubMenu(tr("&Zoom ") + "(" + QString::number(m_map->ZoomTotal()) + ")", this);
for (int i = 0; i < zoomAct.count(); i++)
menu.addAction(goMouseClickAct); zoomSubMenu.addAction(zoomAct.at(i));
menu.addMenu(&zoomSubMenu);
menu.addSeparator()->setText(tr("HOME"));
menu.addSeparator();
menu.addAction(setHomeAct);
menu.addAction(showHomeAct); menu.addAction(goMouseClickAct);
menu.addAction(goHomeAct);
menu.addSeparator()->setText(tr("HOME"));
// ****
// uav trails menu.addAction(setHomeAct);
menu.addAction(showHomeAct);
menu.addSeparator()->setText(tr("UAV Trail")); menu.addAction(goHomeAct);
QMenu uavTrailTypeSubMenu(tr("UAV trail type") + " (" + mapcontrol::Helper::StrFromUAVTrailType(m_map->UAV->GetTrailType()) + ")", this); // ****
for (int i = 0; i < uavTrailTypeAct.count(); i++) // uav trails
uavTrailTypeSubMenu.addAction(uavTrailTypeAct.at(i));
menu.addMenu(&uavTrailTypeSubMenu); menu.addSeparator()->setText(tr("UAV Trail"));
QMenu uavTrailTimeSubMenu(tr("UAV trail time") + " (" + QString::number(m_map->UAV->TrailTime()) + " sec)", this); QMenu uavTrailTypeSubMenu(tr("UAV trail type") + " (" + mapcontrol::Helper::StrFromUAVTrailType(m_map->UAV->GetTrailType()) + ")", this);
for (int i = 0; i < uavTrailTimeAct.count(); i++) for (int i = 0; i < uavTrailTypeAct.count(); i++)
uavTrailTimeSubMenu.addAction(uavTrailTimeAct.at(i)); uavTrailTypeSubMenu.addAction(uavTrailTypeAct.at(i));
menu.addMenu(&uavTrailTimeSubMenu); menu.addMenu(&uavTrailTypeSubMenu);
QMenu uavTrailDistanceSubMenu(tr("UAV trail distance") + " (" + QString::number(m_map->UAV->TrailDistance()) + " meters)", this); QMenu uavTrailTimeSubMenu(tr("UAV trail time") + " (" + QString::number(m_map->UAV->TrailTime()) + " sec)", this);
for (int i = 0; i < uavTrailDistanceAct.count(); i++) for (int i = 0; i < uavTrailTimeAct.count(); i++)
uavTrailDistanceSubMenu.addAction(uavTrailDistanceAct.at(i)); uavTrailTimeSubMenu.addAction(uavTrailTimeAct.at(i));
menu.addMenu(&uavTrailDistanceSubMenu); menu.addMenu(&uavTrailTimeSubMenu);
menu.addAction(clearUAVtrailAct); QMenu uavTrailDistanceSubMenu(tr("UAV trail distance") + " (" + QString::number(m_map->UAV->TrailDistance()) + " meters)", this);
for (int i = 0; i < uavTrailDistanceAct.count(); i++)
// **** uavTrailDistanceSubMenu.addAction(uavTrailDistanceAct.at(i));
menu.addMenu(&uavTrailDistanceSubMenu);
menu.addSeparator()->setText(tr("UAV"));
menu.addAction(clearUAVtrailAct);
menu.addAction(showUAVAct);
menu.addAction(followUAVpositionAct); // ****
menu.addAction(followUAVheadingAct);
menu.addAction(goUAVAct); menu.addSeparator()->setText(tr("UAV"));
// ********* menu.addAction(showUAVAct);
menu.addAction(followUAVpositionAct);
switch (m_map_mode) menu.addAction(followUAVheadingAct);
{ menu.addAction(goUAVAct);
case Normal_MapMode:
// only show the waypoint stuff if not in 'magic waypoint' mode // *********
/*
menu.addSeparator()->setText(tr("Waypoints")); switch (m_map_mode)
{
menu.addAction(wayPointEditorAct); case Normal_MapMode:
menu.addAction(addWayPointAct); // only show the waypoint stuff if not in 'magic waypoint' mode
/*
if (m_mouse_waypoint) menu.addSeparator()->setText(tr("Waypoints"));
{ // we have a waypoint under the mouse
menu.addAction(editWayPointAct); menu.addAction(wayPointEditorAct);
menu.addAction(addWayPointAct);
lockWayPointAct->setChecked(waypoint_locked);
menu.addAction(lockWayPointAct); if (m_mouse_waypoint)
{ // we have a waypoint under the mouse
if (!waypoint_locked) menu.addAction(editWayPointAct);
menu.addAction(deleteWayPointAct);
} lockWayPointAct->setChecked(waypoint_locked);
menu.addAction(lockWayPointAct);
m_waypoint_list_mutex.lock();
if (m_waypoint_list.count() > 0) if (!waypoint_locked)
menu.addAction(clearWayPointsAct); // we have waypoints menu.addAction(deleteWayPointAct);
m_waypoint_list_mutex.unlock(); }
*/
m_waypoint_list_mutex.lock();
break; if (m_waypoint_list.count() > 0)
menu.addAction(clearWayPointsAct); // we have waypoints
case MagicWaypoint_MapMode: m_waypoint_list_mutex.unlock();
menu.addSeparator()->setText(tr("Waypoints")); */
menu.addAction(homeMagicWaypointAct);
break; break;
}
case MagicWaypoint_MapMode:
// ********* menu.addSeparator()->setText(tr("Waypoints"));
menu.addAction(homeMagicWaypointAct);
menu.addSeparator(); break;
}
menu.addAction(closeAct2);
// *********
menu.exec(event->globalPos()); // popup the menu
menu.addSeparator();
// ****************
} menu.addAction(closeAct2);
void OPMapGadgetWidget::keyPressEvent(QKeyEvent* event) menu.exec(event->globalPos()); // popup the menu
{
qDebug() << "opmap: keyPressEvent, key =" << event->key() << endl; // ****************
}
switch (event->key())
{ void OPMapGadgetWidget::keyPressEvent(QKeyEvent* event)
case Qt::Key_Escape: {
break; qDebug() << "opmap: keyPressEvent, key =" << event->key() << endl;
case Qt::Key_F1: switch (event->key())
break; {
case Qt::Key_Escape:
case Qt::Key_F2: break;
break;
case Qt::Key_F1:
case Qt::Key_Up: break;
break;
case Qt::Key_F2:
case Qt::Key_Down: break;
break;
case Qt::Key_Up:
case Qt::Key_Left: break;
break;
case Qt::Key_Down:
case Qt::Key_Right: break;
break;
case Qt::Key_Left:
case Qt::Key_PageUp: break;
break;
case Qt::Key_Right:
case Qt::Key_PageDown: break;
break;
} case Qt::Key_PageUp:
} break;
// ************************************************************************************* case Qt::Key_PageDown:
// timer signals break;
}
}
/**
Updates the UAV position on the map. It is called every 200ms // *************************************************************************************
by a timer. // timer signals
TODO: consider updating upon object update, not timer.
*/ /**
void OPMapGadgetWidget::updatePosition() Updates the UAV position on the map. It is called every 200ms
{ by a timer.
if (!m_widget || !m_map)
return; TODO: consider updating upon object update, not timer.
*/
QMutexLocker locker(&m_map_mutex); void OPMapGadgetWidget::updatePosition()
{
if (!telemetry_connected) if (!m_widget || !m_map)
return; return;
double latitude; QMutexLocker locker(&m_map_mutex);
double longitude;
double altitude; if (!telemetry_connected)
return;
// get current UAV position
if (!getUAV_LLA(latitude, longitude, altitude)) double latitude;
return; double longitude;
double altitude;
// get current UAV heading
float yaw = getUAV_Yaw(); // get current UAV position
if (!getUAV_LLA(latitude, longitude, altitude))
internals::PointLatLng uav_pos = internals::PointLatLng(latitude, longitude); // current UAV position return;
float uav_heading_degrees = yaw; // current UAV heading
float uav_altitude_meters = altitude; // current UAV height // get current UAV heading
float uav_ground_speed_meters_per_second = 0; //data.Groundspeed; // current UAV ground speed float yaw = getUAV_Yaw();
// display the UAV lat/lon position internals::PointLatLng uav_pos = internals::PointLatLng(latitude, longitude); // current UAV position
QString str = float uav_heading_degrees = yaw; // current UAV heading
"lat: " + QString::number(uav_pos.Lat(), 'f', 7) + float uav_altitude_meters = altitude; // current UAV height
" lon: " + QString::number(uav_pos.Lng(), 'f', 7) + float uav_ground_speed_meters_per_second = 0; //data.Groundspeed; // current UAV ground speed
" " + QString::number(uav_heading_degrees, 'f', 1) + "deg" +
" " + QString::number(uav_altitude_meters, 'f', 1) + "m" + // display the UAV lat/lon position
" " + QString::number(uav_ground_speed_meters_per_second, 'f', 1) + "m/s"; QString str =
m_widget->labelUAVPos->setText(str); "lat: " + QString::number(uav_pos.Lat(), 'f', 7) +
" lon: " + QString::number(uav_pos.Lng(), 'f', 7) +
m_map->UAV->SetUAVPos(uav_pos, uav_altitude_meters); // set the maps UAV position " " + QString::number(uav_heading_degrees, 'f', 1) + "deg" +
m_map->UAV->SetUAVHeading(uav_heading_degrees); // set the maps UAV heading " " + QString::number(uav_altitude_meters, 'f', 1) + "m" +
" " + QString::number(uav_ground_speed_meters_per_second, 'f', 1) + "m/s";
if (!getGPS_LLA(latitude, longitude, altitude)) m_widget->labelUAVPos->setText(str);
return;
m_map->UAV->SetUAVPos(uav_pos, uav_altitude_meters); // set the maps UAV position
uav_pos = internals::PointLatLng(latitude, longitude); // current UAV position m_map->UAV->SetUAVHeading(uav_heading_degrees); // set the maps UAV heading
m_map->GPS->SetUAVPos(uav_pos, uav_altitude_meters); // set the maps UAV position
m_map->GPS->SetUAVHeading(uav_heading_degrees); // set the maps UAV heading if (!getGPS_LLA(latitude, longitude, altitude))
} return;
/** uav_pos = internals::PointLatLng(latitude, longitude); // current UAV position
Update plugin behaviour based on mouse position; Called every few ms by a m_map->GPS->SetUAVPos(uav_pos, uav_altitude_meters); // set the maps UAV position
timer. m_map->GPS->SetUAVHeading(uav_heading_degrees); // set the maps UAV heading
*/ }
void OPMapGadgetWidget::updateMousePos()
{ /**
if (!m_widget || !m_map) Update plugin behaviour based on mouse position; Called every few ms by a
return; timer.
*/
QMutexLocker locker(&m_map_mutex); void OPMapGadgetWidget::updateMousePos()
{
QPoint p = m_map->mapFromGlobal(QCursor::pos()); if (!m_widget || !m_map)
internals::PointLatLng lat_lon = m_map->GetFromLocalToLatLng(p); // fetch the current lat/lon mouse position return;
if (!m_map->contentsRect().contains(p)) QMutexLocker locker(&m_map_mutex);
return; // the mouse is not on the map
QPoint p = m_map->mapFromGlobal(QCursor::pos());
// internals::PointLatLng lat_lon = m_map->currentMousePosition(); // fetch the current lat/lon mouse position internals::PointLatLng lat_lon = m_map->GetFromLocalToLatLng(p); // fetch the current lat/lon mouse position
QGraphicsItem *item = m_map->itemAt(p); if (!m_map->contentsRect().contains(p))
return; // the mouse is not on the map
// find out if we are over the home position
mapcontrol::HomeItem *home = qgraphicsitem_cast<mapcontrol::HomeItem *>(item); // internals::PointLatLng lat_lon = m_map->currentMousePosition(); // fetch the current lat/lon mouse position
// find out if we are over the UAV QGraphicsItem *item = m_map->itemAt(p);
mapcontrol::UAVItem *uav = qgraphicsitem_cast<mapcontrol::UAVItem *>(item);
// find out if we are over the home position
// find out if we have a waypoint under the mouse cursor mapcontrol::HomeItem *home = qgraphicsitem_cast<mapcontrol::HomeItem *>(item);
mapcontrol::WayPointItem *wp = qgraphicsitem_cast<mapcontrol::WayPointItem *>(item);
// find out if we are over the UAV
if (mouse_lat_lon == lat_lon) mapcontrol::UAVItem *uav = qgraphicsitem_cast<mapcontrol::UAVItem *>(item);
return; // the mouse has not moved
// find out if we have a waypoint under the mouse cursor
mouse_lat_lon = lat_lon; // yes it has! mapcontrol::WayPointItem *wp = qgraphicsitem_cast<mapcontrol::WayPointItem *>(item);
internals::PointLatLng home_lat_lon = m_map->Home->Coord(); if (mouse_lat_lon == lat_lon)
return; // the mouse has not moved
QString s = QString::number(mouse_lat_lon.Lat(), 'f', 7) + " " + QString::number(mouse_lat_lon.Lng(), 'f', 7);
if (wp) mouse_lat_lon = lat_lon; // yes it has!
{
s += " wp[" + QString::number(wp->Number()) + "]"; internals::PointLatLng home_lat_lon = m_map->Home->Coord();
double dist = distance(home_lat_lon, wp->Coord()); QString s = QString::number(mouse_lat_lon.Lat(), 'f', 7) + " " + QString::number(mouse_lat_lon.Lng(), 'f', 7);
double bear = bearing(home_lat_lon, wp->Coord()); if (wp)
s += " " + QString::number(dist * 1000, 'f', 1) + "m"; {
s += " " + QString::number(bear, 'f', 1) + "deg"; s += " wp[" + QString::number(wp->Number()) + "]";
}
else double dist = distance(home_lat_lon, wp->Coord());
if (home) double bear = bearing(home_lat_lon, wp->Coord());
{ s += " " + QString::number(dist * 1000, 'f', 1) + "m";
s += " home"; s += " " + QString::number(bear, 'f', 1) + "deg";
}
double dist = distance(home_lat_lon, mouse_lat_lon); else
double bear = bearing(home_lat_lon, mouse_lat_lon); if (home)
s += " " + QString::number(dist * 1000, 'f', 1) + "m"; {
s += " " + QString::number(bear, 'f', 1) + "deg"; s += " home";
}
else double dist = distance(home_lat_lon, mouse_lat_lon);
if (uav) double bear = bearing(home_lat_lon, mouse_lat_lon);
{ s += " " + QString::number(dist * 1000, 'f', 1) + "m";
s += " uav"; s += " " + QString::number(bear, 'f', 1) + "deg";
}
double latitude; else
double longitude; if (uav)
double altitude; {
if (getUAV_LLA(latitude, longitude, altitude)) // get current UAV position s += " uav";
{
internals::PointLatLng uav_pos = internals::PointLatLng(latitude, longitude); double latitude;
double longitude;
// double dist = distance(home_lat_lon, uav_pos); double altitude;
// double bear = bearing(home_lat_lon, uav_pos); if (getUAV_LLA(latitude, longitude, altitude)) // get current UAV position
// s += " " + QString::number(dist * 1000, 'f', 1) + "m"; {
// s += " " + QString::number(bear, 'f', 1) + "deg"; internals::PointLatLng uav_pos = internals::PointLatLng(latitude, longitude);
}
} // double dist = distance(home_lat_lon, uav_pos);
m_widget->labelMousePos->setText(s); // double bear = bearing(home_lat_lon, uav_pos);
} // s += " " + QString::number(dist * 1000, 'f', 1) + "m";
// s += " " + QString::number(bear, 'f', 1) + "deg";
// ************************************************************************************* }
// map signals }
m_widget->labelMousePos->setText(s);
}
/**
Update the Plugin UI to reflect a change in zoom level // *************************************************************************************
*/ // map signals
void OPMapGadgetWidget::zoomChanged(double zoomt, double zoom, double zoomd)
{
if (!m_widget || !m_map) /**
return; Update the Plugin UI to reflect a change in zoom level
*/
QString s = "tot:" + QString::number(zoomt, 'f', 1) + " rea:" + QString::number(zoom, 'f', 1) + " dig:" + QString::number(zoomd, 'f', 1); void OPMapGadgetWidget::zoomChanged(double zoomt, double zoom, double zoomd)
m_widget->labelMapZoom->setText(s); {
if (!m_widget || !m_map)
int i_zoom = (int)(zoomt + 0.5); return;
if (i_zoom < min_zoom) i_zoom = min_zoom; QString s = "tot:" + QString::number(zoomt, 'f', 1) + " rea:" + QString::number(zoom, 'f', 1) + " dig:" + QString::number(zoomd, 'f', 1);
else m_widget->labelMapZoom->setText(s);
if (i_zoom > max_zoom) i_zoom = max_zoom;
int i_zoom = (int)(zoomt + 0.5);
if (m_widget->horizontalSliderZoom->value() != i_zoom)
m_widget->horizontalSliderZoom->setValue(i_zoom); // set the GUI zoom slider position if (i_zoom < min_zoom) i_zoom = min_zoom;
else
int index0_zoom = i_zoom - min_zoom; // zoom level starting at index level '0' if (i_zoom > max_zoom) i_zoom = max_zoom;
if (index0_zoom < zoomAct.count())
zoomAct.at(index0_zoom)->setChecked(true); // set the right-click context menu zoom level if (m_widget->horizontalSliderZoom->value() != i_zoom)
} m_widget->horizontalSliderZoom->setValue(i_zoom); // set the GUI zoom slider position
void OPMapGadgetWidget::OnMapDrag() int index0_zoom = i_zoom - min_zoom; // zoom level starting at index level '0'
{ if (index0_zoom < zoomAct.count())
} zoomAct.at(index0_zoom)->setChecked(true); // set the right-click context menu zoom level
}
void OPMapGadgetWidget::OnCurrentPositionChanged(internals::PointLatLng point)
{ void OPMapGadgetWidget::OnMapDrag()
if (!m_widget || !m_map) {
return; }
QString coord_str = QString::number(point.Lat(), 'f', 7) + " " + QString::number(point.Lng(), 'f', 7) + " "; void OPMapGadgetWidget::OnCurrentPositionChanged(internals::PointLatLng point)
m_widget->labelMapPos->setText(coord_str); {
} if (!m_widget || !m_map)
return;
/**
Update the progress bar while there are still tiles to load QString coord_str = QString::number(point.Lat(), 'f', 7) + " " + QString::number(point.Lng(), 'f', 7) + " ";
*/ m_widget->labelMapPos->setText(coord_str);
void OPMapGadgetWidget::OnTilesStillToLoad(int number) }
{
if (!m_widget || !m_map) /**
return; Update the progress bar while there are still tiles to load
*/
// if (prev_tile_number < number || m_widget->progressBarMap->maximum() < number) void OPMapGadgetWidget::OnTilesStillToLoad(int number)
// m_widget->progressBarMap->setMaximum(number); {
if (!m_widget || !m_map)
if (m_widget->progressBarMap->maximum() < number) return;
m_widget->progressBarMap->setMaximum(number);
// if (prev_tile_number < number || m_widget->progressBarMap->maximum() < number)
m_widget->progressBarMap->setValue(m_widget->progressBarMap->maximum() - number); // update the progress bar // m_widget->progressBarMap->setMaximum(number);
// m_widget->labelNumTilesToLoad->setText(QString::number(number)); if (m_widget->progressBarMap->maximum() < number)
m_widget->progressBarMap->setMaximum(number);
prev_tile_number = number;
} m_widget->progressBarMap->setValue(m_widget->progressBarMap->maximum() - number); // update the progress bar
/** // m_widget->labelNumTilesToLoad->setText(QString::number(number));
Show the progress bar as soon as the map lib starts downloading
*/ prev_tile_number = number;
void OPMapGadgetWidget::OnTileLoadStart() }
{
if (!m_widget || !m_map) /**
return; Show the progress bar as soon as the map lib starts downloading
*/
m_widget->progressBarMap->setVisible(true); void OPMapGadgetWidget::OnTileLoadStart()
} {
if (!m_widget || !m_map)
/** return;
Hide the progress bar once the map lib has finished downloading
m_widget->progressBarMap->setVisible(true);
TODO: somehow this gets called before tile load is actually complete? }
*/
/**
void OPMapGadgetWidget::OnTileLoadComplete() Hide the progress bar once the map lib has finished downloading
{
if (!m_widget || !m_map) TODO: somehow this gets called before tile load is actually complete?
return; */
m_widget->progressBarMap->setVisible(false); void OPMapGadgetWidget::OnTileLoadComplete()
} {
if (!m_widget || !m_map)
void OPMapGadgetWidget::OnMapZoomChanged() return;
{
} m_widget->progressBarMap->setVisible(false);
}
void OPMapGadgetWidget::OnMapTypeChanged(MapType::Types type)
{ void OPMapGadgetWidget::OnMapZoomChanged()
Q_UNUSED(type); {
} }
void OPMapGadgetWidget::OnEmptyTileError(int zoom, core::Point pos) void OPMapGadgetWidget::OnMapTypeChanged(MapType::Types type)
{ {
Q_UNUSED(zoom); Q_UNUSED(type);
Q_UNUSED(pos); }
}
void OPMapGadgetWidget::OnEmptyTileError(int zoom, core::Point pos)
void OPMapGadgetWidget::WPNumberChanged(int const &oldnumber, int const &newnumber, WayPointItem *waypoint) {
{ Q_UNUSED(zoom);
Q_UNUSED(oldnumber); Q_UNUSED(pos);
Q_UNUSED(newnumber); }
Q_UNUSED(waypoint);
} void OPMapGadgetWidget::WPNumberChanged(int const &oldnumber, int const &newnumber, WayPointItem *waypoint)
{
void OPMapGadgetWidget::WPValuesChanged(WayPointItem *waypoint) Q_UNUSED(oldnumber);
{ Q_UNUSED(newnumber);
// qDebug("opmap: WPValuesChanged"); Q_UNUSED(waypoint);
}
switch (m_map_mode)
{ void OPMapGadgetWidget::WPValuesChanged(WayPointItem *waypoint)
case Normal_MapMode: {
m_waypoint_list_mutex.lock(); // qDebug("opmap: WPValuesChanged");
foreach (t_waypoint *wp, m_waypoint_list)
{ // search for the waypoint in our own waypoint list and update it switch (m_map_mode)
if (!wp) continue; {
if (!wp->map_wp_item) continue; case Normal_MapMode:
if (wp->map_wp_item != waypoint) continue; m_waypoint_list_mutex.lock();
// found the waypoint in our list foreach (t_waypoint *wp, m_waypoint_list)
wp->coord = waypoint->Coord(); { // search for the waypoint in our own waypoint list and update it
wp->altitude = waypoint->Altitude(); if (!wp) continue;
wp->description = waypoint->Description(); if (!wp->map_wp_item) continue;
break; if (wp->map_wp_item != waypoint) continue;
} // found the waypoint in our list
m_waypoint_list_mutex.unlock(); wp->coord = waypoint->Coord();
break; wp->altitude = waypoint->Altitude();
wp->description = waypoint->Description();
case MagicWaypoint_MapMode: break;
// update our copy of the magic waypoint }
if (magic_waypoint.map_wp_item && magic_waypoint.map_wp_item == waypoint) m_waypoint_list_mutex.unlock();
{ break;
magic_waypoint.coord = waypoint->Coord();
magic_waypoint.altitude = waypoint->Altitude(); case MagicWaypoint_MapMode:
magic_waypoint.description = waypoint->Description(); // update our copy of the magic waypoint
if (magic_waypoint.map_wp_item && magic_waypoint.map_wp_item == waypoint)
// move the UAV to the magic waypoint position {
// moveToMagicWaypointPosition(); magic_waypoint.coord = waypoint->Coord();
} magic_waypoint.altitude = waypoint->Altitude();
break; magic_waypoint.description = waypoint->Description();
}
// move the UAV to the magic waypoint position
} // moveToMagicWaypointPosition();
}
/** break;
TODO: slot to do something upon Waypoint insertion }
*/
void OPMapGadgetWidget::WPInserted(int const &number, WayPointItem *waypoint) }
{
Q_UNUSED(number); /**
Q_UNUSED(waypoint); TODO: slot to do something upon Waypoint insertion
} */
void OPMapGadgetWidget::WPInserted(int const &number, WayPointItem *waypoint)
/** {
TODO: slot to do something upon Waypoint deletion Q_UNUSED(number);
*/ Q_UNUSED(waypoint);
void OPMapGadgetWidget::WPDeleted(int const &number) }
{
Q_UNUSED(number); /**
} TODO: slot to do something upon Waypoint deletion
*/
void OPMapGadgetWidget::WPDeleted(int const &number)
void OPMapGadgetWidget::on_toolButtonZoomP_clicked() {
{ Q_UNUSED(number);
QMutexLocker locker(&m_map_mutex); }
zoomIn();
}
void OPMapGadgetWidget::on_toolButtonZoomP_clicked()
void OPMapGadgetWidget::on_toolButtonZoomM_clicked() {
{ QMutexLocker locker(&m_map_mutex);
QMutexLocker locker(&m_map_mutex); zoomIn();
zoomOut(); }
}
void OPMapGadgetWidget::on_toolButtonZoomM_clicked()
void OPMapGadgetWidget::on_toolButtonMapHome_clicked() {
{ QMutexLocker locker(&m_map_mutex);
QMutexLocker locker(&m_map_mutex); zoomOut();
goHome(); }
}
void OPMapGadgetWidget::on_toolButtonMapHome_clicked()
void OPMapGadgetWidget::on_toolButtonMapUAV_clicked() {
{ QMutexLocker locker(&m_map_mutex);
if (!m_widget || !m_map) goHome();
return; }
QMutexLocker locker(&m_map_mutex); void OPMapGadgetWidget::on_toolButtonMapUAV_clicked()
{
followUAVpositionAct->toggle(); if (!m_widget || !m_map)
} return;
void OPMapGadgetWidget::on_toolButtonMapUAVheading_clicked() QMutexLocker locker(&m_map_mutex);
{
if (!m_widget || !m_map) followUAVpositionAct->toggle();
return; }
followUAVheadingAct->toggle(); void OPMapGadgetWidget::on_toolButtonMapUAVheading_clicked()
} {
if (!m_widget || !m_map)
void OPMapGadgetWidget::on_horizontalSliderZoom_sliderMoved(int position) return;
{
if (!m_widget || !m_map) followUAVheadingAct->toggle();
return; }
QMutexLocker locker(&m_map_mutex); void OPMapGadgetWidget::on_horizontalSliderZoom_sliderMoved(int position)
{
setZoom(position); if (!m_widget || !m_map)
} return;
QMutexLocker locker(&m_map_mutex);
void OPMapGadgetWidget::on_toolButtonNormalMapMode_clicked()
{ setZoom(position);
setMapMode(Normal_MapMode); }
}
void OPMapGadgetWidget::on_toolButtonMagicWaypointMapMode_clicked() void OPMapGadgetWidget::on_toolButtonNormalMapMode_clicked()
{ {
setMapMode(MagicWaypoint_MapMode); setMapMode(Normal_MapMode);
} }
void OPMapGadgetWidget::on_toolButtonHomeWaypoint_clicked() void OPMapGadgetWidget::on_toolButtonMagicWaypointMapMode_clicked()
{ {
homeMagicWaypoint(); setMapMode(MagicWaypoint_MapMode);
} }
void OPMapGadgetWidget::on_toolButtonMoveToWP_clicked() void OPMapGadgetWidget::on_toolButtonHomeWaypoint_clicked()
{ {
moveToMagicWaypointPosition(); homeMagicWaypoint();
} }
// ************************************************************************************* void OPMapGadgetWidget::on_toolButtonMoveToWP_clicked()
// public slots {
moveToMagicWaypointPosition();
void OPMapGadgetWidget::onTelemetryConnect() }
{
telemetry_connected = true; // *************************************************************************************
// public slots
ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
if (!pm) return; void OPMapGadgetWidget::onTelemetryConnect()
{
UAVObjectManager *obm = pm->getObject<UAVObjectManager>(); telemetry_connected = true;
if (!obm) return;
ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
UAVDataObject *obj; if (!pm) return;
// UAVObjectField *field;
UAVObjectManager *obm = pm->getObject<UAVObjectManager>();
// *********************** if (!obm) return;
// fetch the home location
UAVDataObject *obj;
obj = dynamic_cast<UAVDataObject*>(obm->getObject(QString("HomeLocation"))); // UAVObjectField *field;
if (!obj) return;
// ***********************
double lat = obj->getField("Latitude")->getDouble() * 1e-7; // fetch the home location
double lon = obj->getField("Longitude")->getDouble() * 1e-7;
// double alt = obj->getField("Altitude")->getDouble(); obj = dynamic_cast<UAVDataObject*>(obm->getObject(QString("HomeLocation")));
setHome(internals::PointLatLng(lat, lon)); if (!obj) return;
if (m_map) double lat = obj->getField("Latitude")->getDouble() * 1e-7;
m_map->SetCurrentPosition(home_position.coord); // set the map position double lon = obj->getField("Longitude")->getDouble() * 1e-7;
// double alt = obj->getField("Altitude")->getDouble();
// field = obj->getField(QString("Be")); setHome(internals::PointLatLng(lat, lon));
// if (!field) return;
if (m_map)
// *********************** m_map->SetCurrentPosition(home_position.coord); // set the map position
}
// field = obj->getField(QString("Be"));
void OPMapGadgetWidget::onTelemetryDisconnect() // if (!field) return;
{
telemetry_connected = false; // ***********************
} }
// Updates the Home position icon whenever the HomePosition object is updated void OPMapGadgetWidget::onTelemetryDisconnect()
void OPMapGadgetWidget::homePositionUpdated(UAVObject *hp) {
{ telemetry_connected = false;
if (!hp) }
return;
// Updates the Home position icon whenever the HomePosition object is updated
double lat = hp->getField("Latitude")->getDouble() * 1e-7; void OPMapGadgetWidget::homePositionUpdated(UAVObject *hp)
double lon = hp->getField("Longitude")->getDouble() * 1e-7; {
setHome(internals::PointLatLng(lat, lon)); if (!hp)
} return;
// ************************************************************************************* double lat = hp->getField("Latitude")->getDouble() * 1e-7;
// public functions double lon = hp->getField("Longitude")->getDouble() * 1e-7;
setHome(internals::PointLatLng(lat, lon));
/** }
Sets the home position on the map widget
*/ // *************************************************************************************
void OPMapGadgetWidget::setHome(QPointF pos) // public functions
{
if (!m_widget || !m_map) /**
return; Sets the home position on the map widget
*/
double latitude = pos.x(); void OPMapGadgetWidget::setHome(QPointF pos)
double longitude = pos.y(); {
if (!m_widget || !m_map)
if (latitude > 90) latitude = 90; return;
else
if (latitude < -90) latitude = -90; double latitude = pos.x();
double longitude = pos.y();
if (longitude != longitude) longitude = 0; // nan detection
else if (latitude > 90) latitude = 90;
if (longitude > 180) longitude = 180; else
else if (latitude < -90) latitude = -90;
if (longitude < -180) longitude = -180;
if (longitude != longitude) longitude = 0; // nan detection
setHome(internals::PointLatLng(latitude, longitude)); else
} if (longitude > 180) longitude = 180;
else
/** if (longitude < -180) longitude = -180;
Sets the home position on the map widget
*/ setHome(internals::PointLatLng(latitude, longitude));
void OPMapGadgetWidget::setHome(internals::PointLatLng pos_lat_lon) }
{
if (!m_widget || !m_map) /**
return; Sets the home position on the map widget
*/
if (pos_lat_lon.Lat() != pos_lat_lon.Lat() || pos_lat_lon.Lng() != pos_lat_lon.Lng()) void OPMapGadgetWidget::setHome(internals::PointLatLng pos_lat_lon)
return;; // nan prevention {
if (!m_widget || !m_map)
double latitude = pos_lat_lon.Lat(); return;
double longitude = pos_lat_lon.Lng();
if (pos_lat_lon.Lat() != pos_lat_lon.Lat() || pos_lat_lon.Lng() != pos_lat_lon.Lng())
if (latitude != latitude) latitude = 0; // nan detection return;; // nan prevention
else
if (latitude > 90) latitude = 90; double latitude = pos_lat_lon.Lat();
else double longitude = pos_lat_lon.Lng();
if (latitude < -90) latitude = -90;
if (latitude != latitude) latitude = 0; // nan detection
if (longitude != longitude) longitude = 0; // nan detection else
else if (latitude > 90) latitude = 90;
if (longitude > 180) longitude = 180; else
else if (latitude < -90) latitude = -90;
if (longitude < -180) longitude = -180;
if (longitude != longitude) longitude = 0; // nan detection
// ********* else
if (longitude > 180) longitude = 180;
home_position.coord = internals::PointLatLng(latitude, longitude); else
if (longitude < -180) longitude = -180;
m_map->Home->SetCoord(home_position.coord);
m_map->Home->RefreshPos(); // *********
// move the magic waypoint to keep it within the safe area boundry home_position.coord = internals::PointLatLng(latitude, longitude);
keepMagicWaypointWithInSafeArea();
} m_map->Home->SetCoord(home_position.coord);
m_map->Home->RefreshPos();
/** // move the magic waypoint to keep it within the safe area boundry
Centers the map over the home position keepMagicWaypointWithInSafeArea();
*/ }
void OPMapGadgetWidget::goHome()
{
if (!m_widget || !m_map) /**
return; Centers the map over the home position
*/
followUAVpositionAct->setChecked(false); void OPMapGadgetWidget::goHome()
{
internals::PointLatLng home_pos = home_position.coord; // get the home location if (!m_widget || !m_map)
m_map->SetCurrentPosition(home_pos); // center the map onto the home location return;
}
followUAVpositionAct->setChecked(false);
void OPMapGadgetWidget::zoomIn() internals::PointLatLng home_pos = home_position.coord; // get the home location
{ m_map->SetCurrentPosition(home_pos); // center the map onto the home location
if (!m_widget || !m_map) }
return;
int zoom = m_map->ZoomTotal() + 1; void OPMapGadgetWidget::zoomIn()
{
if (zoom < min_zoom) zoom = min_zoom; if (!m_widget || !m_map)
else return;
if (zoom > max_zoom) zoom = max_zoom;
int zoom = m_map->ZoomTotal() + 1;
m_map->SetZoom(zoom);
} if (zoom < min_zoom) zoom = min_zoom;
else
void OPMapGadgetWidget::zoomOut() if (zoom > max_zoom) zoom = max_zoom;
{
if (!m_widget || !m_map) m_map->SetZoom(zoom);
return; }
int zoom = m_map->ZoomTotal() - 1; void OPMapGadgetWidget::zoomOut()
{
if (zoom < min_zoom) zoom = min_zoom; if (!m_widget || !m_map)
else return;
if (zoom > max_zoom) zoom = max_zoom;
int zoom = m_map->ZoomTotal() - 1;
m_map->SetZoom(zoom);
} if (zoom < min_zoom) zoom = min_zoom;
else
void OPMapGadgetWidget::setZoom(int zoom) if (zoom > max_zoom) zoom = max_zoom;
{
if (!m_widget || !m_map) m_map->SetZoom(zoom);
return; }
if (zoom < min_zoom) zoom = min_zoom; void OPMapGadgetWidget::setZoom(int zoom)
else {
if (zoom > max_zoom) zoom = max_zoom; if (!m_widget || !m_map)
return;
internals::MouseWheelZoomType::Types zoom_type = m_map->GetMouseWheelZoomType();
m_map->SetMouseWheelZoomType(internals::MouseWheelZoomType::ViewCenter); if (zoom < min_zoom) zoom = min_zoom;
else
m_map->SetZoom(zoom); if (zoom > max_zoom) zoom = max_zoom;
m_map->SetMouseWheelZoomType(zoom_type); internals::MouseWheelZoomType::Types zoom_type = m_map->GetMouseWheelZoomType();
} m_map->SetMouseWheelZoomType(internals::MouseWheelZoomType::ViewCenter);
void OPMapGadgetWidget::setPosition(QPointF pos) m_map->SetZoom(zoom);
{
if (!m_widget || !m_map) m_map->SetMouseWheelZoomType(zoom_type);
return; }
double latitude = pos.y(); void OPMapGadgetWidget::setPosition(QPointF pos)
double longitude = pos.x(); {
if (!m_widget || !m_map)
if (latitude != latitude || longitude != longitude) return;
return; // nan prevention
double latitude = pos.y();
if (latitude > 90) latitude = 90; double longitude = pos.x();
else
if (latitude < -90) latitude = -90; if (latitude != latitude || longitude != longitude)
return; // nan prevention
if (longitude > 180) longitude = 180;
else if (latitude > 90) latitude = 90;
if (longitude < -180) longitude = -180; else
if (latitude < -90) latitude = -90;
m_map->SetCurrentPosition(internals::PointLatLng(latitude, longitude));
} if (longitude > 180) longitude = 180;
else
void OPMapGadgetWidget::setMapProvider(QString provider) if (longitude < -180) longitude = -180;
{
if (!m_widget || !m_map) m_map->SetCurrentPosition(internals::PointLatLng(latitude, longitude));
return; }
m_map->SetMapType(mapcontrol::Helper::MapTypeFromString(provider)); void OPMapGadgetWidget::setMapProvider(QString provider)
} {
if (!m_widget || !m_map)
void OPMapGadgetWidget::setAccessMode(QString accessMode) return;
{
if (!m_widget || !m_map) m_map->SetMapType(mapcontrol::Helper::MapTypeFromString(provider));
return; }
m_map->configuration->SetAccessMode(mapcontrol::Helper::AccessModeFromString(accessMode)); void OPMapGadgetWidget::setAccessMode(QString accessMode)
} {
if (!m_widget || !m_map)
void OPMapGadgetWidget::setUseOpenGL(bool useOpenGL) return;
{
if (!m_widget || !m_map) m_map->configuration->SetAccessMode(mapcontrol::Helper::AccessModeFromString(accessMode));
return; }
m_map->SetUseOpenGL(useOpenGL); void OPMapGadgetWidget::setUseOpenGL(bool useOpenGL)
} {
if (!m_widget || !m_map)
void OPMapGadgetWidget::setShowTileGridLines(bool showTileGridLines) return;
{
if (!m_widget || !m_map) m_map->SetUseOpenGL(useOpenGL);
return; }
m_map->SetShowTileGridLines(showTileGridLines); void OPMapGadgetWidget::setShowTileGridLines(bool showTileGridLines)
} {
if (!m_widget || !m_map)
void OPMapGadgetWidget::setUseMemoryCache(bool useMemoryCache) return;
{
if (!m_widget || !m_map) m_map->SetShowTileGridLines(showTileGridLines);
return; }
m_map->configuration->SetUseMemoryCache(useMemoryCache); void OPMapGadgetWidget::setUseMemoryCache(bool useMemoryCache)
} {
if (!m_widget || !m_map)
void OPMapGadgetWidget::setCacheLocation(QString cacheLocation) return;
{
if (!m_widget || !m_map) m_map->configuration->SetUseMemoryCache(useMemoryCache);
return; }
cacheLocation = cacheLocation.simplified(); // remove any surrounding spaces void OPMapGadgetWidget::setCacheLocation(QString cacheLocation)
{
if (cacheLocation.isEmpty()) return; if (!m_widget || !m_map)
return;
// #if defined(Q_WS_WIN)
// if (!cacheLocation.endsWith('\\')) cacheLocation += '\\'; cacheLocation = cacheLocation.simplified(); // remove any surrounding spaces
// #elif defined(Q_WS_X11)
if (!cacheLocation.endsWith(QDir::separator())) cacheLocation += QDir::separator(); if (cacheLocation.isEmpty()) return;
// #elif defined(Q_WS_MAC)
// if (!cacheLocation.endsWith(QDir::separator())) cacheLocation += QDir::separator(); // #if defined(Q_WS_WIN)
// #endif // if (!cacheLocation.endsWith('\\')) cacheLocation += '\\';
// #elif defined(Q_WS_X11)
QDir dir; if (!cacheLocation.endsWith(QDir::separator())) cacheLocation += QDir::separator();
if (!dir.exists(cacheLocation)) // #elif defined(Q_WS_MAC)
if (!dir.mkpath(cacheLocation)) // if (!cacheLocation.endsWith(QDir::separator())) cacheLocation += QDir::separator();
return; // #endif
// qDebug() << "opmap: map cache dir: " << cacheLocation; QDir dir;
if (!dir.exists(cacheLocation))
m_map->configuration->SetCacheLocation(cacheLocation); if (!dir.mkpath(cacheLocation))
} return;
void OPMapGadgetWidget::setMapMode(opMapModeType mode) // qDebug() << "opmap: map cache dir: " << cacheLocation;
{
if (!m_widget || !m_map) m_map->configuration->SetCacheLocation(cacheLocation);
return; }
if (mode != Normal_MapMode && mode != MagicWaypoint_MapMode) void OPMapGadgetWidget::setMapMode(opMapModeType mode)
mode = Normal_MapMode; // fix error {
if (!m_widget || !m_map)
if (m_map_mode == mode) return;
{ // no change in map mode
switch (mode) if (mode != Normal_MapMode && mode != MagicWaypoint_MapMode)
{ // make sure the UI buttons are set correctly mode = Normal_MapMode; // fix error
case Normal_MapMode:
m_widget->toolButtonMagicWaypointMapMode->setChecked(false); if (m_map_mode == mode)
m_widget->toolButtonNormalMapMode->setChecked(true); { // no change in map mode
break; switch (mode)
case MagicWaypoint_MapMode: { // make sure the UI buttons are set correctly
m_widget->toolButtonNormalMapMode->setChecked(false); case Normal_MapMode:
m_widget->toolButtonMagicWaypointMapMode->setChecked(true); m_widget->toolButtonMagicWaypointMapMode->setChecked(false);
break; m_widget->toolButtonNormalMapMode->setChecked(true);
} break;
return; case MagicWaypoint_MapMode:
} m_widget->toolButtonNormalMapMode->setChecked(false);
m_widget->toolButtonMagicWaypointMapMode->setChecked(true);
switch (mode) break;
{ }
case Normal_MapMode: return;
m_map_mode = Normal_MapMode; }
m_widget->toolButtonMagicWaypointMapMode->setChecked(false); switch (mode)
m_widget->toolButtonNormalMapMode->setChecked(true); {
case Normal_MapMode:
hideMagicWaypointControls(); m_map_mode = Normal_MapMode;
// delete the magic waypoint from the map m_widget->toolButtonMagicWaypointMapMode->setChecked(false);
if (magic_waypoint.map_wp_item) m_widget->toolButtonNormalMapMode->setChecked(true);
{
magic_waypoint.coord = magic_waypoint.map_wp_item->Coord(); hideMagicWaypointControls();
magic_waypoint.altitude = magic_waypoint.map_wp_item->Altitude();
magic_waypoint.description = magic_waypoint.map_wp_item->Description(); // delete the magic waypoint from the map
magic_waypoint.map_wp_item = NULL; if (magic_waypoint.map_wp_item)
} {
m_map->WPDeleteAll(); magic_waypoint.coord = magic_waypoint.map_wp_item->Coord();
magic_waypoint.altitude = magic_waypoint.map_wp_item->Altitude();
// restore the normal waypoints on the map magic_waypoint.description = magic_waypoint.map_wp_item->Description();
m_waypoint_list_mutex.lock(); magic_waypoint.map_wp_item = NULL;
foreach (t_waypoint *wp, m_waypoint_list) }
{ m_map->WPDeleteAll();
if (!wp) continue;
wp->map_wp_item = m_map->WPCreate(wp->coord, wp->altitude, wp->description); // restore the normal waypoints on the map
if (!wp->map_wp_item) continue; m_waypoint_list_mutex.lock();
wp->map_wp_item->setZValue(10 + wp->map_wp_item->Number()); foreach (t_waypoint *wp, m_waypoint_list)
wp->map_wp_item->setFlag(QGraphicsItem::ItemIsMovable, !wp->locked); {
if (!wp->locked) if (!wp) continue;
wp->map_wp_item->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker1.png")); wp->map_wp_item = m_map->WPCreate(wp->coord, wp->altitude, wp->description);
else if (!wp->map_wp_item) continue;
wp->map_wp_item->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker2.png")); wp->map_wp_item->setZValue(10 + wp->map_wp_item->Number());
wp->map_wp_item->update(); wp->map_wp_item->setFlag(QGraphicsItem::ItemIsMovable, !wp->locked);
} if (!wp->locked)
m_waypoint_list_mutex.unlock(); wp->map_wp_item->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker1.png"));
else
break; wp->map_wp_item->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker2.png"));
wp->map_wp_item->update();
case MagicWaypoint_MapMode: }
m_map_mode = MagicWaypoint_MapMode; m_waypoint_list_mutex.unlock();
m_widget->toolButtonNormalMapMode->setChecked(false); break;
m_widget->toolButtonMagicWaypointMapMode->setChecked(true);
case MagicWaypoint_MapMode:
showMagicWaypointControls(); m_map_mode = MagicWaypoint_MapMode;
// delete the normal waypoints from the map m_widget->toolButtonNormalMapMode->setChecked(false);
m_waypoint_list_mutex.lock(); m_widget->toolButtonMagicWaypointMapMode->setChecked(true);
foreach (t_waypoint *wp, m_waypoint_list)
{ showMagicWaypointControls();
if (!wp) continue;
if (!wp->map_wp_item) continue; // delete the normal waypoints from the map
wp->coord = wp->map_wp_item->Coord(); m_waypoint_list_mutex.lock();
wp->altitude = wp->map_wp_item->Altitude(); foreach (t_waypoint *wp, m_waypoint_list)
wp->description = wp->map_wp_item->Description(); {
wp->locked = (wp->map_wp_item->flags() & QGraphicsItem::ItemIsMovable) == 0; if (!wp) continue;
wp->map_wp_item = NULL; if (!wp->map_wp_item) continue;
} wp->coord = wp->map_wp_item->Coord();
m_map->WPDeleteAll(); wp->altitude = wp->map_wp_item->Altitude();
m_waypoint_list_mutex.unlock(); wp->description = wp->map_wp_item->Description();
wp->locked = (wp->map_wp_item->flags() & QGraphicsItem::ItemIsMovable) == 0;
// restore the magic waypoint on the map wp->map_wp_item = NULL;
magic_waypoint.map_wp_item = m_map->WPCreate(magic_waypoint.coord, magic_waypoint.altitude, magic_waypoint.description); }
magic_waypoint.map_wp_item->setZValue(10 + magic_waypoint.map_wp_item->Number()); m_map->WPDeleteAll();
magic_waypoint.map_wp_item->SetShowNumber(false); m_waypoint_list_mutex.unlock();
magic_waypoint.map_wp_item->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker3.png"));
// restore the magic waypoint on the map
break; magic_waypoint.map_wp_item = m_map->WPCreate(magic_waypoint.coord, magic_waypoint.altitude, magic_waypoint.description);
} magic_waypoint.map_wp_item->setZValue(10 + magic_waypoint.map_wp_item->Number());
} magic_waypoint.map_wp_item->SetShowNumber(false);
magic_waypoint.map_wp_item->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker3.png"));
// *************************************************************************************
// Context menu stuff break;
}
void OPMapGadgetWidget::createActions() }
{
if (!m_widget) // *************************************************************************************
return; // Context menu stuff
// *********************** void OPMapGadgetWidget::createActions()
// create menu actions {
if (!m_widget)
closeAct1 = new QAction(tr("Close menu"), this); return;
closeAct1->setStatusTip(tr("Close the context menu"));
// ***********************
closeAct2 = new QAction(tr("Close menu"), this); // create menu actions
closeAct2->setStatusTip(tr("Close the context menu"));
closeAct1 = new QAction(tr("Close menu"), this);
reloadAct = new QAction(tr("&Reload map"), this); closeAct1->setStatusTip(tr("Close the context menu"));
reloadAct->setShortcut(tr("F5"));
reloadAct->setStatusTip(tr("Reload the map tiles")); closeAct2 = new QAction(tr("Close menu"), this);
connect(reloadAct, SIGNAL(triggered()), this, SLOT(onReloadAct_triggered())); closeAct2->setStatusTip(tr("Close the context menu"));
copyMouseLatLonToClipAct = new QAction(tr("Mouse latitude and longitude"), this); reloadAct = new QAction(tr("&Reload map"), this);
copyMouseLatLonToClipAct->setStatusTip(tr("Copy the mouse latitude and longitude to the clipboard")); reloadAct->setShortcut(tr("F5"));
connect(copyMouseLatLonToClipAct, SIGNAL(triggered()), this, SLOT(onCopyMouseLatLonToClipAct_triggered())); reloadAct->setStatusTip(tr("Reload the map tiles"));
connect(reloadAct, SIGNAL(triggered()), this, SLOT(onReloadAct_triggered()));
copyMouseLatToClipAct = new QAction(tr("Mouse latitude"), this);
copyMouseLatToClipAct->setStatusTip(tr("Copy the mouse latitude to the clipboard")); copyMouseLatLonToClipAct = new QAction(tr("Mouse latitude and longitude"), this);
connect(copyMouseLatToClipAct, SIGNAL(triggered()), this, SLOT(onCopyMouseLatToClipAct_triggered())); copyMouseLatLonToClipAct->setStatusTip(tr("Copy the mouse latitude and longitude to the clipboard"));
connect(copyMouseLatLonToClipAct, SIGNAL(triggered()), this, SLOT(onCopyMouseLatLonToClipAct_triggered()));
copyMouseLonToClipAct = new QAction(tr("Mouse longitude"), this);
copyMouseLonToClipAct->setStatusTip(tr("Copy the mouse longitude to the clipboard")); copyMouseLatToClipAct = new QAction(tr("Mouse latitude"), this);
connect(copyMouseLonToClipAct, SIGNAL(triggered()), this, SLOT(onCopyMouseLonToClipAct_triggered())); copyMouseLatToClipAct->setStatusTip(tr("Copy the mouse latitude to the clipboard"));
connect(copyMouseLatToClipAct, SIGNAL(triggered()), this, SLOT(onCopyMouseLatToClipAct_triggered()));
/*
findPlaceAct = new QAction(tr("&Find place"), this); copyMouseLonToClipAct = new QAction(tr("Mouse longitude"), this);
findPlaceAct->setShortcut(tr("Ctrl+F")); copyMouseLonToClipAct->setStatusTip(tr("Copy the mouse longitude to the clipboard"));
findPlaceAct->setStatusTip(tr("Find a location")); connect(copyMouseLonToClipAct, SIGNAL(triggered()), this, SLOT(onCopyMouseLonToClipAct_triggered()));
connect(findPlaceAct, SIGNAL(triggered()), this, SLOT(onFindPlaceAct_triggered()));
*/ /*
findPlaceAct = new QAction(tr("&Find place"), this);
showCompassAct = new QAction(tr("Show compass"), this); findPlaceAct->setShortcut(tr("Ctrl+F"));
showCompassAct->setStatusTip(tr("Show/Hide the compass")); findPlaceAct->setStatusTip(tr("Find a location"));
showCompassAct->setCheckable(true); connect(findPlaceAct, SIGNAL(triggered()), this, SLOT(onFindPlaceAct_triggered()));
showCompassAct->setChecked(true); */
connect(showCompassAct, SIGNAL(toggled(bool)), this, SLOT(onShowCompassAct_toggled(bool)));
showCompassAct = new QAction(tr("Show compass"), this);
showHomeAct = new QAction(tr("Show Home"), this); showCompassAct->setStatusTip(tr("Show/Hide the compass"));
showHomeAct->setStatusTip(tr("Show/Hide the Home location")); showCompassAct->setCheckable(true);
showHomeAct->setCheckable(true); showCompassAct->setChecked(true);
showHomeAct->setChecked(true); connect(showCompassAct, SIGNAL(toggled(bool)), this, SLOT(onShowCompassAct_toggled(bool)));
connect(showHomeAct, SIGNAL(toggled(bool)), this, SLOT(onShowHomeAct_toggled(bool)));
showHomeAct = new QAction(tr("Show Home"), this);
showUAVAct = new QAction(tr("Show UAV"), this); showHomeAct->setStatusTip(tr("Show/Hide the Home location"));
showUAVAct->setStatusTip(tr("Show/Hide the UAV")); showHomeAct->setCheckable(true);
showUAVAct->setCheckable(true); showHomeAct->setChecked(true);
showUAVAct->setChecked(true); connect(showHomeAct, SIGNAL(toggled(bool)), this, SLOT(onShowHomeAct_toggled(bool)));
connect(showUAVAct, SIGNAL(toggled(bool)), this, SLOT(onShowUAVAct_toggled(bool)));
showUAVAct = new QAction(tr("Show UAV"), this);
zoomInAct = new QAction(tr("Zoom &In"), this); showUAVAct->setStatusTip(tr("Show/Hide the UAV"));
zoomInAct->setShortcut(Qt::Key_PageUp); showUAVAct->setCheckable(true);
zoomInAct->setStatusTip(tr("Zoom the map in")); showUAVAct->setChecked(true);
connect(zoomInAct, SIGNAL(triggered()), this, SLOT(onGoZoomInAct_triggered())); connect(showUAVAct, SIGNAL(toggled(bool)), this, SLOT(onShowUAVAct_toggled(bool)));
zoomOutAct = new QAction(tr("Zoom &Out"), this); zoomInAct = new QAction(tr("Zoom &In"), this);
zoomOutAct->setShortcut(Qt::Key_PageDown); zoomInAct->setShortcut(Qt::Key_PageUp);
zoomOutAct->setStatusTip(tr("Zoom the map out")); zoomInAct->setStatusTip(tr("Zoom the map in"));
connect(zoomOutAct, SIGNAL(triggered()), this, SLOT(onGoZoomOutAct_triggered())); connect(zoomInAct, SIGNAL(triggered()), this, SLOT(onGoZoomInAct_triggered()));
goMouseClickAct = new QAction(tr("Go to where you right clicked the mouse"), this); zoomOutAct = new QAction(tr("Zoom &Out"), this);
goMouseClickAct->setStatusTip(tr("Center the map onto where you right clicked the mouse")); zoomOutAct->setShortcut(Qt::Key_PageDown);
connect(goMouseClickAct, SIGNAL(triggered()), this, SLOT(onGoMouseClickAct_triggered())); zoomOutAct->setStatusTip(tr("Zoom the map out"));
connect(zoomOutAct, SIGNAL(triggered()), this, SLOT(onGoZoomOutAct_triggered()));
setHomeAct = new QAction(tr("Set the home location"), this);
setHomeAct->setStatusTip(tr("Set the home location to where you clicked")); goMouseClickAct = new QAction(tr("Go to where you right clicked the mouse"), this);
#if !defined(allow_manual_home_location_move) goMouseClickAct->setStatusTip(tr("Center the map onto where you right clicked the mouse"));
setHomeAct->setEnabled(false); connect(goMouseClickAct, SIGNAL(triggered()), this, SLOT(onGoMouseClickAct_triggered()));
#endif
connect(setHomeAct, SIGNAL(triggered()), this, SLOT(onSetHomeAct_triggered())); setHomeAct = new QAction(tr("Set the home location"), this);
setHomeAct->setStatusTip(tr("Set the home location to where you clicked"));
goHomeAct = new QAction(tr("Go to &Home location"), this); #if !defined(allow_manual_home_location_move)
goHomeAct->setShortcut(tr("Ctrl+H")); setHomeAct->setEnabled(false);
goHomeAct->setStatusTip(tr("Center the map onto the home location")); #endif
connect(goHomeAct, SIGNAL(triggered()), this, SLOT(onGoHomeAct_triggered())); connect(setHomeAct, SIGNAL(triggered()), this, SLOT(onSetHomeAct_triggered()));
goUAVAct = new QAction(tr("Go to &UAV location"), this); goHomeAct = new QAction(tr("Go to &Home location"), this);
goUAVAct->setShortcut(tr("Ctrl+U")); goHomeAct->setShortcut(tr("Ctrl+H"));
goUAVAct->setStatusTip(tr("Center the map onto the UAV location")); goHomeAct->setStatusTip(tr("Center the map onto the home location"));
connect(goUAVAct, SIGNAL(triggered()), this, SLOT(onGoUAVAct_triggered())); connect(goHomeAct, SIGNAL(triggered()), this, SLOT(onGoHomeAct_triggered()));
followUAVpositionAct = new QAction(tr("Follow UAV position"), this); goUAVAct = new QAction(tr("Go to &UAV location"), this);
followUAVpositionAct->setShortcut(tr("Ctrl+F")); goUAVAct->setShortcut(tr("Ctrl+U"));
followUAVpositionAct->setStatusTip(tr("Keep the map centered onto the UAV")); goUAVAct->setStatusTip(tr("Center the map onto the UAV location"));
followUAVpositionAct->setCheckable(true); connect(goUAVAct, SIGNAL(triggered()), this, SLOT(onGoUAVAct_triggered()));
followUAVpositionAct->setChecked(false);
connect(followUAVpositionAct, SIGNAL(toggled(bool)), this, SLOT(onFollowUAVpositionAct_toggled(bool))); followUAVpositionAct = new QAction(tr("Follow UAV position"), this);
followUAVpositionAct->setShortcut(tr("Ctrl+F"));
followUAVheadingAct = new QAction(tr("Follow UAV heading"), this); followUAVpositionAct->setStatusTip(tr("Keep the map centered onto the UAV"));
followUAVheadingAct->setShortcut(tr("Ctrl+F")); followUAVpositionAct->setCheckable(true);
followUAVheadingAct->setStatusTip(tr("Keep the map rotation to the UAV heading")); followUAVpositionAct->setChecked(false);
followUAVheadingAct->setCheckable(true); connect(followUAVpositionAct, SIGNAL(toggled(bool)), this, SLOT(onFollowUAVpositionAct_toggled(bool)));
followUAVheadingAct->setChecked(false);
connect(followUAVheadingAct, SIGNAL(toggled(bool)), this, SLOT(onFollowUAVheadingAct_toggled(bool))); followUAVheadingAct = new QAction(tr("Follow UAV heading"), this);
followUAVheadingAct->setShortcut(tr("Ctrl+F"));
/* followUAVheadingAct->setStatusTip(tr("Keep the map rotation to the UAV heading"));
TODO: Waypoint support is disabled for v1.0 followUAVheadingAct->setCheckable(true);
*/ followUAVheadingAct->setChecked(false);
connect(followUAVheadingAct, SIGNAL(toggled(bool)), this, SLOT(onFollowUAVheadingAct_toggled(bool)));
/*
wayPointEditorAct = new QAction(tr("&Waypoint editor"), this); /*
wayPointEditorAct->setShortcut(tr("Ctrl+W")); TODO: Waypoint support is disabled for v1.0
wayPointEditorAct->setStatusTip(tr("Open the waypoint editor")); */
wayPointEditorAct->setEnabled(false); // temporary
connect(wayPointEditorAct, SIGNAL(triggered()), this, SLOT(onOpenWayPointEditorAct_triggered())); /*
wayPointEditorAct = new QAction(tr("&Waypoint editor"), this);
addWayPointAct = new QAction(tr("&Add waypoint"), this); wayPointEditorAct->setShortcut(tr("Ctrl+W"));
addWayPointAct->setShortcut(tr("Ctrl+A")); wayPointEditorAct->setStatusTip(tr("Open the waypoint editor"));
addWayPointAct->setStatusTip(tr("Add waypoint")); wayPointEditorAct->setEnabled(false); // temporary
connect(addWayPointAct, SIGNAL(triggered()), this, SLOT(onAddWayPointAct_triggered())); connect(wayPointEditorAct, SIGNAL(triggered()), this, SLOT(onOpenWayPointEditorAct_triggered()));
editWayPointAct = new QAction(tr("&Edit waypoint"), this); addWayPointAct = new QAction(tr("&Add waypoint"), this);
editWayPointAct->setShortcut(tr("Ctrl+E")); addWayPointAct->setShortcut(tr("Ctrl+A"));
editWayPointAct->setStatusTip(tr("Edit waypoint")); addWayPointAct->setStatusTip(tr("Add waypoint"));
connect(editWayPointAct, SIGNAL(triggered()), this, SLOT(onEditWayPointAct_triggered())); connect(addWayPointAct, SIGNAL(triggered()), this, SLOT(onAddWayPointAct_triggered()));
lockWayPointAct = new QAction(tr("&Lock waypoint"), this); editWayPointAct = new QAction(tr("&Edit waypoint"), this);
lockWayPointAct->setStatusTip(tr("Lock/Unlock a waypoint")); editWayPointAct->setShortcut(tr("Ctrl+E"));
lockWayPointAct->setCheckable(true); editWayPointAct->setStatusTip(tr("Edit waypoint"));
lockWayPointAct->setChecked(false); connect(editWayPointAct, SIGNAL(triggered()), this, SLOT(onEditWayPointAct_triggered()));
connect(lockWayPointAct, SIGNAL(triggered()), this, SLOT(onLockWayPointAct_triggered()));
lockWayPointAct = new QAction(tr("&Lock waypoint"), this);
deleteWayPointAct = new QAction(tr("&Delete waypoint"), this); lockWayPointAct->setStatusTip(tr("Lock/Unlock a waypoint"));
deleteWayPointAct->setShortcut(tr("Ctrl+D")); lockWayPointAct->setCheckable(true);
deleteWayPointAct->setStatusTip(tr("Delete waypoint")); lockWayPointAct->setChecked(false);
connect(deleteWayPointAct, SIGNAL(triggered()), this, SLOT(onDeleteWayPointAct_triggered())); connect(lockWayPointAct, SIGNAL(triggered()), this, SLOT(onLockWayPointAct_triggered()));
clearWayPointsAct = new QAction(tr("&Clear waypoints"), this); deleteWayPointAct = new QAction(tr("&Delete waypoint"), this);
clearWayPointsAct->setShortcut(tr("Ctrl+C")); deleteWayPointAct->setShortcut(tr("Ctrl+D"));
clearWayPointsAct->setStatusTip(tr("Clear waypoints")); deleteWayPointAct->setStatusTip(tr("Delete waypoint"));
connect(clearWayPointsAct, SIGNAL(triggered()), this, SLOT(onClearWayPointsAct_triggered())); connect(deleteWayPointAct, SIGNAL(triggered()), this, SLOT(onDeleteWayPointAct_triggered()));
*/
clearWayPointsAct = new QAction(tr("&Clear waypoints"), this);
homeMagicWaypointAct = new QAction(tr("Home magic waypoint"), this); clearWayPointsAct->setShortcut(tr("Ctrl+C"));
homeMagicWaypointAct->setStatusTip(tr("Move the magic waypoint to the home position")); clearWayPointsAct->setStatusTip(tr("Clear waypoints"));
connect(homeMagicWaypointAct, SIGNAL(triggered()), this, SLOT(onHomeMagicWaypointAct_triggered())); connect(clearWayPointsAct, SIGNAL(triggered()), this, SLOT(onClearWayPointsAct_triggered()));
*/
mapModeActGroup = new QActionGroup(this);
connect(mapModeActGroup, SIGNAL(triggered(QAction *)), this, SLOT(onMapModeActGroup_triggered(QAction *))); homeMagicWaypointAct = new QAction(tr("Home magic waypoint"), this);
mapModeAct.clear(); homeMagicWaypointAct->setStatusTip(tr("Move the magic waypoint to the home position"));
{ connect(homeMagicWaypointAct, SIGNAL(triggered()), this, SLOT(onHomeMagicWaypointAct_triggered()));
QAction *map_mode_act;
mapModeActGroup = new QActionGroup(this);
map_mode_act = new QAction(tr("Normal"), mapModeActGroup); connect(mapModeActGroup, SIGNAL(triggered(QAction *)), this, SLOT(onMapModeActGroup_triggered(QAction *)));
map_mode_act->setCheckable(true); mapModeAct.clear();
map_mode_act->setChecked(m_map_mode == Normal_MapMode); {
map_mode_act->setData((int)Normal_MapMode); QAction *map_mode_act;
mapModeAct.append(map_mode_act);
map_mode_act = new QAction(tr("Normal"), mapModeActGroup);
map_mode_act = new QAction(tr("Magic Waypoint"), mapModeActGroup); map_mode_act->setCheckable(true);
map_mode_act->setCheckable(true); map_mode_act->setChecked(m_map_mode == Normal_MapMode);
map_mode_act->setChecked(m_map_mode == MagicWaypoint_MapMode); map_mode_act->setData((int)Normal_MapMode);
map_mode_act->setData((int)MagicWaypoint_MapMode); mapModeAct.append(map_mode_act);
mapModeAct.append(map_mode_act);
} map_mode_act = new QAction(tr("Magic Waypoint"), mapModeActGroup);
map_mode_act->setCheckable(true);
zoomActGroup = new QActionGroup(this); map_mode_act->setChecked(m_map_mode == MagicWaypoint_MapMode);
connect(zoomActGroup, SIGNAL(triggered(QAction *)), this, SLOT(onZoomActGroup_triggered(QAction *))); map_mode_act->setData((int)MagicWaypoint_MapMode);
zoomAct.clear(); mapModeAct.append(map_mode_act);
for (int i = min_zoom; i <= max_zoom; i++) }
{
QAction *zoom_act = new QAction(QString::number(i), zoomActGroup); zoomActGroup = new QActionGroup(this);
zoom_act->setCheckable(true); connect(zoomActGroup, SIGNAL(triggered(QAction *)), this, SLOT(onZoomActGroup_triggered(QAction *)));
zoom_act->setData(i); zoomAct.clear();
zoomAct.append(zoom_act); for (int i = min_zoom; i <= max_zoom; i++)
} {
QAction *zoom_act = new QAction(QString::number(i), zoomActGroup);
// ***** zoom_act->setCheckable(true);
// safe area zoom_act->setData(i);
zoomAct.append(zoom_act);
showSafeAreaAct = new QAction(tr("Show Safe Area"), this); }
showSafeAreaAct->setStatusTip(tr("Show/Hide the Safe Area around the home location"));
showSafeAreaAct->setCheckable(true); // *****
showSafeAreaAct->setChecked(m_map->Home->ShowSafeArea()); // safe area
connect(showSafeAreaAct, SIGNAL(toggled(bool)), this, SLOT(onShowSafeAreaAct_toggled(bool)));
showSafeAreaAct = new QAction(tr("Show Safe Area"), this);
safeAreaActGroup = new QActionGroup(this); showSafeAreaAct->setStatusTip(tr("Show/Hide the Safe Area around the home location"));
connect(safeAreaActGroup, SIGNAL(triggered(QAction *)), this, SLOT(onSafeAreaActGroup_triggered(QAction *))); showSafeAreaAct->setCheckable(true);
safeAreaAct.clear(); showSafeAreaAct->setChecked(m_map->Home->ShowSafeArea());
for (int i = 0; i < (int)(sizeof(safe_area_radius_list) / sizeof(safe_area_radius_list[0])); i++) connect(showSafeAreaAct, SIGNAL(toggled(bool)), this, SLOT(onShowSafeAreaAct_toggled(bool)));
{
int safeArea = safe_area_radius_list[i]; safeAreaActGroup = new QActionGroup(this);
QAction *safeArea_act = new QAction(QString::number(safeArea) + "m", safeAreaActGroup); connect(safeAreaActGroup, SIGNAL(triggered(QAction *)), this, SLOT(onSafeAreaActGroup_triggered(QAction *)));
safeArea_act->setCheckable(true); safeAreaAct.clear();
safeArea_act->setChecked(safeArea == m_map->Home->SafeArea()); for (int i = 0; i < (int)(sizeof(safe_area_radius_list) / sizeof(safe_area_radius_list[0])); i++)
safeArea_act->setData(safeArea); {
safeAreaAct.append(safeArea_act); int safeArea = safe_area_radius_list[i];
} QAction *safeArea_act = new QAction(QString::number(safeArea) + "m", safeAreaActGroup);
safeArea_act->setCheckable(true);
// ***** safeArea_act->setChecked(safeArea == m_map->Home->SafeArea());
// UAV trail safeArea_act->setData(safeArea);
safeAreaAct.append(safeArea_act);
uavTrailTypeActGroup = new QActionGroup(this); }
connect(uavTrailTypeActGroup, SIGNAL(triggered(QAction *)), this, SLOT(onUAVTrailTypeActGroup_triggered(QAction *)));
uavTrailTypeAct.clear(); // *****
QStringList uav_trail_type_list = mapcontrol::Helper::UAVTrailTypes(); // UAV trail
for (int i = 0; i < uav_trail_type_list.count(); i++)
{ uavTrailTypeActGroup = new QActionGroup(this);
mapcontrol::UAVTrailType::Types uav_trail_type = mapcontrol::Helper::UAVTrailTypeFromString(uav_trail_type_list[i]); connect(uavTrailTypeActGroup, SIGNAL(triggered(QAction *)), this, SLOT(onUAVTrailTypeActGroup_triggered(QAction *)));
QAction *uavTrailType_act = new QAction(mapcontrol::Helper::StrFromUAVTrailType(uav_trail_type), uavTrailTypeActGroup); uavTrailTypeAct.clear();
uavTrailType_act->setCheckable(true); QStringList uav_trail_type_list = mapcontrol::Helper::UAVTrailTypes();
uavTrailType_act->setChecked(uav_trail_type == m_map->UAV->GetTrailType()); for (int i = 0; i < uav_trail_type_list.count(); i++)
uavTrailType_act->setData(i); {
uavTrailTypeAct.append(uavTrailType_act); mapcontrol::UAVTrailType::Types uav_trail_type = mapcontrol::Helper::UAVTrailTypeFromString(uav_trail_type_list[i]);
} QAction *uavTrailType_act = new QAction(mapcontrol::Helper::StrFromUAVTrailType(uav_trail_type), uavTrailTypeActGroup);
uavTrailType_act->setCheckable(true);
clearUAVtrailAct = new QAction(tr("Clear UAV trail"), this); uavTrailType_act->setChecked(uav_trail_type == m_map->UAV->GetTrailType());
clearUAVtrailAct->setStatusTip(tr("Clear the UAV trail")); uavTrailType_act->setData(i);
connect(clearUAVtrailAct, SIGNAL(triggered()), this, SLOT(onClearUAVtrailAct_triggered())); uavTrailTypeAct.append(uavTrailType_act);
}
uavTrailTimeActGroup = new QActionGroup(this);
connect(uavTrailTimeActGroup, SIGNAL(triggered(QAction *)), this, SLOT(onUAVTrailTimeActGroup_triggered(QAction *))); clearUAVtrailAct = new QAction(tr("Clear UAV trail"), this);
uavTrailTimeAct.clear(); clearUAVtrailAct->setStatusTip(tr("Clear the UAV trail"));
for (int i = 0; i < (int)(sizeof(uav_trail_time_list) / sizeof(uav_trail_time_list[0])); i++) connect(clearUAVtrailAct, SIGNAL(triggered()), this, SLOT(onClearUAVtrailAct_triggered()));
{
int uav_trail_time = uav_trail_time_list[i]; uavTrailTimeActGroup = new QActionGroup(this);
QAction *uavTrailTime_act = new QAction(QString::number(uav_trail_time) + " sec", uavTrailTimeActGroup); connect(uavTrailTimeActGroup, SIGNAL(triggered(QAction *)), this, SLOT(onUAVTrailTimeActGroup_triggered(QAction *)));
uavTrailTime_act->setCheckable(true); uavTrailTimeAct.clear();
uavTrailTime_act->setChecked(uav_trail_time == m_map->UAV->TrailTime()); for (int i = 0; i < (int)(sizeof(uav_trail_time_list) / sizeof(uav_trail_time_list[0])); i++)
uavTrailTime_act->setData(uav_trail_time); {
uavTrailTimeAct.append(uavTrailTime_act); int uav_trail_time = uav_trail_time_list[i];
} QAction *uavTrailTime_act = new QAction(QString::number(uav_trail_time) + " sec", uavTrailTimeActGroup);
uavTrailTime_act->setCheckable(true);
uavTrailDistanceActGroup = new QActionGroup(this); uavTrailTime_act->setChecked(uav_trail_time == m_map->UAV->TrailTime());
connect(uavTrailDistanceActGroup, SIGNAL(triggered(QAction *)), this, SLOT(onUAVTrailDistanceActGroup_triggered(QAction *))); uavTrailTime_act->setData(uav_trail_time);
uavTrailDistanceAct.clear(); uavTrailTimeAct.append(uavTrailTime_act);
for (int i = 0; i < (int)(sizeof(uav_trail_distance_list) / sizeof(uav_trail_distance_list[0])); i++) }
{
int uav_trail_distance = uav_trail_distance_list[i]; uavTrailDistanceActGroup = new QActionGroup(this);
QAction *uavTrailDistance_act = new QAction(QString::number(uav_trail_distance) + " meters", uavTrailDistanceActGroup); connect(uavTrailDistanceActGroup, SIGNAL(triggered(QAction *)), this, SLOT(onUAVTrailDistanceActGroup_triggered(QAction *)));
uavTrailDistance_act->setCheckable(true); uavTrailDistanceAct.clear();
uavTrailDistance_act->setChecked(uav_trail_distance == m_map->UAV->TrailDistance()); for (int i = 0; i < (int)(sizeof(uav_trail_distance_list) / sizeof(uav_trail_distance_list[0])); i++)
uavTrailDistance_act->setData(uav_trail_distance); {
uavTrailDistanceAct.append(uavTrailDistance_act); int uav_trail_distance = uav_trail_distance_list[i];
} QAction *uavTrailDistance_act = new QAction(QString::number(uav_trail_distance) + " meters", uavTrailDistanceActGroup);
uavTrailDistance_act->setCheckable(true);
// ***** uavTrailDistance_act->setChecked(uav_trail_distance == m_map->UAV->TrailDistance());
uavTrailDistance_act->setData(uav_trail_distance);
// *********************** uavTrailDistanceAct.append(uavTrailDistance_act);
} }
void OPMapGadgetWidget::onReloadAct_triggered() // *****
{
if (!m_widget || !m_map) // ***********************
return; }
m_map->ReloadMap(); void OPMapGadgetWidget::onReloadAct_triggered()
} {
if (!m_widget || !m_map)
void OPMapGadgetWidget::onCopyMouseLatLonToClipAct_triggered() return;
{
// QClipboard *clipboard = qApp->clipboard(); m_map->ReloadMap();
QClipboard *clipboard = QApplication::clipboard(); }
clipboard->setText(QString::number(context_menu_lat_lon.Lat(), 'f', 7) + ", " + QString::number(context_menu_lat_lon.Lng(), 'f', 7), QClipboard::Clipboard);
} void OPMapGadgetWidget::onCopyMouseLatLonToClipAct_triggered()
{
void OPMapGadgetWidget::onCopyMouseLatToClipAct_triggered() // QClipboard *clipboard = qApp->clipboard();
{ QClipboard *clipboard = QApplication::clipboard();
// QClipboard *clipboard = qApp->clipboard(); clipboard->setText(QString::number(context_menu_lat_lon.Lat(), 'f', 7) + ", " + QString::number(context_menu_lat_lon.Lng(), 'f', 7), QClipboard::Clipboard);
QClipboard *clipboard = QApplication::clipboard(); }
clipboard->setText(QString::number(context_menu_lat_lon.Lat(), 'f', 7), QClipboard::Clipboard);
} void OPMapGadgetWidget::onCopyMouseLatToClipAct_triggered()
{
void OPMapGadgetWidget::onCopyMouseLonToClipAct_triggered() // QClipboard *clipboard = qApp->clipboard();
{ QClipboard *clipboard = QApplication::clipboard();
// QClipboard *clipboard = qApp->clipboard(); clipboard->setText(QString::number(context_menu_lat_lon.Lat(), 'f', 7), QClipboard::Clipboard);
QClipboard *clipboard = QApplication::clipboard(); }
clipboard->setText(QString::number(context_menu_lat_lon.Lng(), 'f', 7), QClipboard::Clipboard);
} void OPMapGadgetWidget::onCopyMouseLonToClipAct_triggered()
{
// QClipboard *clipboard = qApp->clipboard();
void OPMapGadgetWidget::onShowCompassAct_toggled(bool show) QClipboard *clipboard = QApplication::clipboard();
{ clipboard->setText(QString::number(context_menu_lat_lon.Lng(), 'f', 7), QClipboard::Clipboard);
if (!m_widget || !m_map) }
return;
m_map->SetShowCompass(show); void OPMapGadgetWidget::onShowCompassAct_toggled(bool show)
} {
if (!m_widget || !m_map)
void OPMapGadgetWidget::onShowHomeAct_toggled(bool show) return;
{
if (!m_widget || !m_map) m_map->SetShowCompass(show);
return; }
m_map->Home->setVisible(show); void OPMapGadgetWidget::onShowHomeAct_toggled(bool show)
} {
if (!m_widget || !m_map)
void OPMapGadgetWidget::onShowUAVAct_toggled(bool show) return;
{
if (!m_widget || !m_map) m_map->Home->setVisible(show);
return; }
m_map->UAV->setVisible(show); void OPMapGadgetWidget::onShowUAVAct_toggled(bool show)
m_map->GPS->setVisible(show); {
} if (!m_widget || !m_map)
return;
void OPMapGadgetWidget::onMapModeActGroup_triggered(QAction *action)
{ m_map->UAV->setVisible(show);
if (!m_widget || !m_map || !action) m_map->GPS->setVisible(show);
return; }
opMapModeType mode = (opMapModeType)action->data().toInt(); void OPMapGadgetWidget::onMapModeActGroup_triggered(QAction *action)
{
setMapMode(mode); if (!m_widget || !m_map || !action)
} return;
void OPMapGadgetWidget::onGoZoomInAct_triggered() opMapModeType mode = (opMapModeType)action->data().toInt();
{
zoomIn(); setMapMode(mode);
} }
void OPMapGadgetWidget::onGoZoomOutAct_triggered() void OPMapGadgetWidget::onGoZoomInAct_triggered()
{ {
zoomOut(); zoomIn();
} }
void OPMapGadgetWidget::onZoomActGroup_triggered(QAction *action) void OPMapGadgetWidget::onGoZoomOutAct_triggered()
{ {
if (!m_widget || !action) zoomOut();
return; }
setZoom(action->data().toInt()); void OPMapGadgetWidget::onZoomActGroup_triggered(QAction *action)
} {
if (!m_widget || !action)
void OPMapGadgetWidget::onGoMouseClickAct_triggered() return;
{
if (!m_widget || !m_map) setZoom(action->data().toInt());
return; }
m_map->SetCurrentPosition(m_map->currentMousePosition()); // center the map onto the mouse position void OPMapGadgetWidget::onGoMouseClickAct_triggered()
} {
if (!m_widget || !m_map)
void OPMapGadgetWidget::onSetHomeAct_triggered() return;
{
if (!m_widget || !m_map) m_map->SetCurrentPosition(m_map->currentMousePosition()); // center the map onto the mouse position
return; }
setHome(context_menu_lat_lon); void OPMapGadgetWidget::onSetHomeAct_triggered()
{
// *************** if (!m_widget || !m_map)
// calculate the magnetic model return;
double X, Y, Z; setHome(context_menu_lat_lon);
QDateTime dt = QDateTime::currentDateTime().toUTC();
// ***************
Utils::WorldMagModel *wmm = new Utils::WorldMagModel(); // calculate the magnetic model and update the HomeLocation uavobject with lat, lon & correct 'Be' values
if (wmm)
{ double X, Y, Z;
if (wmm->GetMagVector(home_position.coord.Lat(), home_position.coord.Lng(), home_position.altitude, dt.date().month(), dt.date().day(), dt.date().year(), &X, &Y, &Z) >= 0) QDateTime dt = QDateTime::currentDateTime().toUTC();
{
QString s = "lat:" + QString::number(home_position.coord.Lat(), 'f', 7) + " lon:" + QString::number(home_position.coord.Lng(), 'f', 7); Utils::WorldMagModel *wmm = new Utils::WorldMagModel();
s += " x:" + QString::number(X, 'f', 2) + " y:" + QString::number(Y, 'f', 2) + " z:" + QString::number(Z, 'f', 2); if (wmm)
{
qDebug() << "opmap HomePosition WMM .. " << s << endl; if (wmm->GetMagVector(home_position.coord.Lat(), home_position.coord.Lng(), home_position.altitude, dt.date().month(), dt.date().day(), dt.date().year(), &X, &Y, &Z) >= 0)
} {
QString s = "lat:" + QString::number(home_position.coord.Lat(), 'f', 7) + " lon:" + QString::number(home_position.coord.Lng(), 'f', 7);
delete wmm; s += " x:" + QString::number(X, 'f', 2) + " y:" + QString::number(Y, 'f', 2) + " z:" + QString::number(Z, 'f', 2);
} qDebug() << "opmap HomePosition WMM .. " << s << endl;
// *************** // send the new position to the OP board
} ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
if (pm)
void OPMapGadgetWidget::onGoHomeAct_triggered() {
{ UAVObjectManager *obm = pm->getObject<UAVObjectManager>();
if (!m_widget || !m_map) if (obm)
return; {
UAVDataObject *obj = dynamic_cast<UAVDataObject*>(obm->getObject(QString("HomeLocation")));
goHome(); UAVObjectField *Be_field = obj->getField(QString("Be"));
}
if (obj && Be_field)
void OPMapGadgetWidget::onGoUAVAct_triggered() {
{ double current_altitude = obj->getField("Altitude")->getDouble();
if (!m_widget || !m_map)
return; obj->getField("Set")->setValue("TRUE");
obj->getField("Latitude")->setValue(home_position.coord.Lat() * 10e6);
double latitude; obj->getField("Longitude")->setValue(home_position.coord.Lng() * 10e6);
double longitude; obj->getField("Altitude")->setValue(current_altitude);
double altitude; Be_field->setDouble(X, 0);
if (getUAV_LLA(latitude, longitude, altitude)) // get current UAV position Be_field->setDouble(Y, 1);
{ Be_field->setDouble(Z, 2);
internals::PointLatLng uav_pos = internals::PointLatLng(latitude, longitude); // current UAV position
internals::PointLatLng map_pos = m_map->CurrentPosition(); // current MAP position obj->updated();
if (map_pos != uav_pos) m_map->SetCurrentPosition(uav_pos); // center the map onto the UAV
} // save the new location to SD card .. don't use this yet
} // saveObjectToSD(obj);
}
void OPMapGadgetWidget::onFollowUAVpositionAct_toggled(bool checked) }
{ }
if (!m_widget || !m_map)
return;
}
if (m_widget->toolButtonMapUAV->isChecked() != checked)
m_widget->toolButtonMapUAV->setChecked(checked); delete wmm;
}
setMapFollowingMode();
} // ***************
}
void OPMapGadgetWidget::onFollowUAVheadingAct_toggled(bool checked)
{ void OPMapGadgetWidget::onGoHomeAct_triggered()
if (!m_widget || !m_map) {
return; if (!m_widget || !m_map)
return;
if (m_widget->toolButtonMapUAVheading->isChecked() != checked)
m_widget->toolButtonMapUAVheading->setChecked(checked); goHome();
}
setMapFollowingMode();
} void OPMapGadgetWidget::onGoUAVAct_triggered()
{
void OPMapGadgetWidget::onUAVTrailTypeActGroup_triggered(QAction *action) if (!m_widget || !m_map)
{ return;
if (!m_widget || !m_map)
return; double latitude;
double longitude;
int trail_type_idx = action->data().toInt(); double altitude;
if (getUAV_LLA(latitude, longitude, altitude)) // get current UAV position
QStringList uav_trail_type_list = mapcontrol::Helper::UAVTrailTypes(); {
mapcontrol::UAVTrailType::Types uav_trail_type = mapcontrol::Helper::UAVTrailTypeFromString(uav_trail_type_list[trail_type_idx]); internals::PointLatLng uav_pos = internals::PointLatLng(latitude, longitude); // current UAV position
internals::PointLatLng map_pos = m_map->CurrentPosition(); // current MAP position
m_map->UAV->SetTrailType(uav_trail_type); if (map_pos != uav_pos) m_map->SetCurrentPosition(uav_pos); // center the map onto the UAV
} }
}
void OPMapGadgetWidget::onClearUAVtrailAct_triggered()
{ void OPMapGadgetWidget::onFollowUAVpositionAct_toggled(bool checked)
if (!m_widget || !m_map) {
return; if (!m_widget || !m_map)
return;
m_map->UAV->DeleteTrail();
m_map->GPS->DeleteTrail(); if (m_widget->toolButtonMapUAV->isChecked() != checked)
} m_widget->toolButtonMapUAV->setChecked(checked);
void OPMapGadgetWidget::onUAVTrailTimeActGroup_triggered(QAction *action) setMapFollowingMode();
{ }
if (!m_widget || !m_map)
return; void OPMapGadgetWidget::onFollowUAVheadingAct_toggled(bool checked)
{
int trail_time = (double)action->data().toInt(); if (!m_widget || !m_map)
return;
m_map->UAV->SetTrailTime(trail_time);
} if (m_widget->toolButtonMapUAVheading->isChecked() != checked)
m_widget->toolButtonMapUAVheading->setChecked(checked);
void OPMapGadgetWidget::onUAVTrailDistanceActGroup_triggered(QAction *action)
{ setMapFollowingMode();
if (!m_widget || !m_map) }
return;
void OPMapGadgetWidget::onUAVTrailTypeActGroup_triggered(QAction *action)
int trail_distance = action->data().toInt(); {
if (!m_widget || !m_map)
m_map->UAV->SetTrailDistance(trail_distance); return;
}
int trail_type_idx = action->data().toInt();
/**
* TODO: unused for v1.0 QStringList uav_trail_type_list = mapcontrol::Helper::UAVTrailTypes();
**/ mapcontrol::UAVTrailType::Types uav_trail_type = mapcontrol::Helper::UAVTrailTypeFromString(uav_trail_type_list[trail_type_idx]);
/*
void OPMapGadgetWidget::onAddWayPointAct_triggered() m_map->UAV->SetTrailType(uav_trail_type);
{ }
if (!m_widget || !m_map)
return; void OPMapGadgetWidget::onClearUAVtrailAct_triggered()
{
if (m_map_mode != Normal_MapMode) if (!m_widget || !m_map)
return; return;
m_waypoint_list_mutex.lock(); m_map->UAV->DeleteTrail();
m_map->GPS->DeleteTrail();
// create a waypoint on the map at the last known mouse position }
t_waypoint *wp = new t_waypoint;
wp->map_wp_item = NULL; void OPMapGadgetWidget::onUAVTrailTimeActGroup_triggered(QAction *action)
wp->coord = context_menu_lat_lon; {
wp->altitude = 0; if (!m_widget || !m_map)
wp->description = ""; return;
wp->locked = false;
wp->time_seconds = 0; int trail_time = (double)action->data().toInt();
wp->hold_time_seconds = 0;
wp->map_wp_item = m_map->WPCreate(wp->coord, wp->altitude, wp->description); m_map->UAV->SetTrailTime(trail_time);
}
wp->map_wp_item->setZValue(10 + wp->map_wp_item->Number());
void OPMapGadgetWidget::onUAVTrailDistanceActGroup_triggered(QAction *action)
wp->map_wp_item->setFlag(QGraphicsItem::ItemIsMovable, !wp->locked); {
if (!m_widget || !m_map)
if (wp->map_wp_item) return;
{
if (!wp->locked) int trail_distance = action->data().toInt();
wp->map_wp_item->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker1.png"));
else m_map->UAV->SetTrailDistance(trail_distance);
wp->map_wp_item->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker2.png")); }
wp->map_wp_item->update();
} /**
* TODO: unused for v1.0
// and remember it in our own local waypoint list **/
m_waypoint_list.append(wp); /*
void OPMapGadgetWidget::onAddWayPointAct_triggered()
m_waypoint_list_mutex.unlock(); {
} if (!m_widget || !m_map)
*/ return;
/** if (m_map_mode != Normal_MapMode)
* Called when the user asks to edit a waypoint from the map return;
*
* TODO: should open an interface to edit waypoint properties, or m_waypoint_list_mutex.lock();
* propagate the signal to a specific WP plugin (tbd).
**/ // create a waypoint on the map at the last known mouse position
/* t_waypoint *wp = new t_waypoint;
void OPMapGadgetWidget::onEditWayPointAct_triggered() wp->map_wp_item = NULL;
{ wp->coord = context_menu_lat_lon;
if (!m_widget || !m_map) wp->altitude = 0;
return; wp->description = "";
wp->locked = false;
if (m_map_mode != Normal_MapMode) wp->time_seconds = 0;
return; wp->hold_time_seconds = 0;
wp->map_wp_item = m_map->WPCreate(wp->coord, wp->altitude, wp->description);
if (!m_mouse_waypoint)
return; wp->map_wp_item->setZValue(10 + wp->map_wp_item->Number());
//waypoint_edit_dialog.editWaypoint(m_mouse_waypoint); wp->map_wp_item->setFlag(QGraphicsItem::ItemIsMovable, !wp->locked);
m_mouse_waypoint = NULL; if (wp->map_wp_item)
} {
*/ if (!wp->locked)
wp->map_wp_item->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker1.png"));
/** else
* TODO: unused for v1.0 wp->map_wp_item->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker2.png"));
*/ wp->map_wp_item->update();
/* }
void OPMapGadgetWidget::onLockWayPointAct_triggered()
{ // and remember it in our own local waypoint list
if (!m_widget || !m_map || !m_mouse_waypoint) m_waypoint_list.append(wp);
return;
m_waypoint_list_mutex.unlock();
if (m_map_mode != Normal_MapMode) }
return; */
bool locked = (m_mouse_waypoint->flags() & QGraphicsItem::ItemIsMovable) == 0; /**
m_mouse_waypoint->setFlag(QGraphicsItem::ItemIsMovable, locked); * Called when the user asks to edit a waypoint from the map
*
if (!locked) * TODO: should open an interface to edit waypoint properties, or
m_mouse_waypoint->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker2.png")); * propagate the signal to a specific WP plugin (tbd).
else **/
m_mouse_waypoint->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker1.png")); /*
m_mouse_waypoint->update(); void OPMapGadgetWidget::onEditWayPointAct_triggered()
{
m_mouse_waypoint = NULL; if (!m_widget || !m_map)
} return;
*/
if (m_map_mode != Normal_MapMode)
/** return;
* TODO: unused for v1.0
*/ if (!m_mouse_waypoint)
/* return;
void OPMapGadgetWidget::onDeleteWayPointAct_triggered()
{ //waypoint_edit_dialog.editWaypoint(m_mouse_waypoint);
if (!m_widget || !m_map)
return; m_mouse_waypoint = NULL;
}
if (m_map_mode != Normal_MapMode) */
return;
/**
if (!m_mouse_waypoint) * TODO: unused for v1.0
return; */
/*
bool locked = (m_mouse_waypoint->flags() & QGraphicsItem::ItemIsMovable) == 0; void OPMapGadgetWidget::onLockWayPointAct_triggered()
{
if (locked) return; // waypoint is locked if (!m_widget || !m_map || !m_mouse_waypoint)
return;
QMutexLocker locker(&m_waypoint_list_mutex);
if (m_map_mode != Normal_MapMode)
for (int i = 0; i < m_waypoint_list.count(); i++) return;
{
t_waypoint *wp = m_waypoint_list.at(i); bool locked = (m_mouse_waypoint->flags() & QGraphicsItem::ItemIsMovable) == 0;
if (!wp) continue; m_mouse_waypoint->setFlag(QGraphicsItem::ItemIsMovable, locked);
if (!wp->map_wp_item || wp->map_wp_item != m_mouse_waypoint) continue;
if (!locked)
// delete the waypoint from the map m_mouse_waypoint->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker2.png"));
m_map->WPDelete(wp->map_wp_item); else
m_mouse_waypoint->picture.load(QString::fromUtf8(":/opmap/images/waypoint_marker1.png"));
// delete the waypoint from our local waypoint list m_mouse_waypoint->update();
m_waypoint_list.removeAt(i);
m_mouse_waypoint = NULL;
delete wp; }
*/
break;
} /**
// * TODO: unused for v1.0
// foreach (t_waypoint *wp, m_waypoint_list) */
// { /*
// if (!wp) continue; void OPMapGadgetWidget::onDeleteWayPointAct_triggered()
// if (!wp->map_wp_item || wp->map_wp_item != m_mouse_waypoint) continue; {
// if (!m_widget || !m_map)
// // delete the waypoint from the map return;
// m_map->WPDelete(wp->map_wp_item);
// if (m_map_mode != Normal_MapMode)
// // delete the waypoint from our local waypoint list return;
// m_waypoint_list.removeOne(wp);
// if (!m_mouse_waypoint)
// delete wp; return;
//
// break; bool locked = (m_mouse_waypoint->flags() & QGraphicsItem::ItemIsMovable) == 0;
// }
if (locked) return; // waypoint is locked
m_mouse_waypoint = NULL;
} QMutexLocker locker(&m_waypoint_list_mutex);
*/
for (int i = 0; i < m_waypoint_list.count(); i++)
/** {
* TODO: No Waypoint support in v1.0 t_waypoint *wp = m_waypoint_list.at(i);
*/ if (!wp) continue;
/* if (!wp->map_wp_item || wp->map_wp_item != m_mouse_waypoint) continue;
void OPMapGadgetWidget::onClearWayPointsAct_triggered()
{ // delete the waypoint from the map
if (!m_widget || !m_map) m_map->WPDelete(wp->map_wp_item);
return;
// delete the waypoint from our local waypoint list
if (m_map_mode != Normal_MapMode) m_waypoint_list.removeAt(i);
return;
delete wp;
QMutexLocker locker(&m_waypoint_list_mutex);
break;
m_map->WPDeleteAll(); }
//
foreach (t_waypoint *wp, m_waypoint_list) // foreach (t_waypoint *wp, m_waypoint_list)
{ // {
if (wp) // if (!wp) continue;
{ // if (!wp->map_wp_item || wp->map_wp_item != m_mouse_waypoint) continue;
delete wp; //
wp = NULL; // // delete the waypoint from the map
} // m_map->WPDelete(wp->map_wp_item);
} //
// // delete the waypoint from our local waypoint list
m_waypoint_list.clear(); // m_waypoint_list.removeOne(wp);
} //
*/ // delete wp;
//
void OPMapGadgetWidget::onHomeMagicWaypointAct_triggered() // break;
{ // }
// center the magic waypoint on the home position
homeMagicWaypoint(); m_mouse_waypoint = NULL;
} }
*/
void OPMapGadgetWidget::onShowSafeAreaAct_toggled(bool show)
{ /**
if (!m_widget || !m_map) * TODO: No Waypoint support in v1.0
return; */
/*
m_map->Home->SetShowSafeArea(show); // show the safe area void OPMapGadgetWidget::onClearWayPointsAct_triggered()
m_map->Home->RefreshPos(); {
} if (!m_widget || !m_map)
return;
void OPMapGadgetWidget::onSafeAreaActGroup_triggered(QAction *action)
{ if (m_map_mode != Normal_MapMode)
if (!m_widget || !m_map) return;
return;
QMutexLocker locker(&m_waypoint_list_mutex);
int radius = action->data().toInt();
m_map->WPDeleteAll();
m_map->Home->SetSafeArea(radius); // set the radius (meters)
m_map->Home->RefreshPos(); foreach (t_waypoint *wp, m_waypoint_list)
{
// move the magic waypoint if need be to keep it within the safe area around the home position if (wp)
keepMagicWaypointWithInSafeArea(); {
} delete wp;
wp = NULL;
/** }
* move the magic waypoint to the home position }
**/
void OPMapGadgetWidget::homeMagicWaypoint() m_waypoint_list.clear();
{ }
if (!m_widget || !m_map) */
return;
void OPMapGadgetWidget::onHomeMagicWaypointAct_triggered()
if (m_map_mode != MagicWaypoint_MapMode) {
return; // center the magic waypoint on the home position
homeMagicWaypoint();
magic_waypoint.coord = home_position.coord; }
if (magic_waypoint.map_wp_item) void OPMapGadgetWidget::onShowSafeAreaAct_toggled(bool show)
magic_waypoint.map_wp_item->SetCoord(magic_waypoint.coord); {
} if (!m_widget || !m_map)
return;
// *************************************************************************************
// move the UAV to the magic waypoint position m_map->Home->SetShowSafeArea(show); // show the safe area
m_map->Home->RefreshPos();
void OPMapGadgetWidget::moveToMagicWaypointPosition() }
{
if (!m_widget || !m_map) void OPMapGadgetWidget::onSafeAreaActGroup_triggered(QAction *action)
return; {
if (!m_widget || !m_map)
if (m_map_mode != MagicWaypoint_MapMode) return;
return;
int radius = action->data().toInt();
internals::PointLatLng coord = magic_waypoint.coord;
double altitude = magic_waypoint.altitude; m_map->Home->SetSafeArea(radius); // set the radius (meters)
m_map->Home->RefreshPos();
// ToDo: // move the magic waypoint if need be to keep it within the safe area around the home position
keepMagicWaypointWithInSafeArea();
} }
// ************************************************************************************* /**
// temporary until an object is created for managing the save/restore * move the magic waypoint to the home position
**/
// load the contents of a simple text file into a combobox void OPMapGadgetWidget::homeMagicWaypoint()
void OPMapGadgetWidget::loadComboBoxLines(QComboBox *comboBox, QString filename) {
{ if (!m_widget || !m_map)
if (!comboBox) return; return;
if (filename.isNull() || filename.isEmpty()) return;
if (m_map_mode != MagicWaypoint_MapMode)
QFile file(filename); return;
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return; magic_waypoint.coord = home_position.coord;
QTextStream in(&file); if (magic_waypoint.map_wp_item)
magic_waypoint.map_wp_item->SetCoord(magic_waypoint.coord);
while (!in.atEnd()) }
{
QString line = in.readLine().simplified(); // *************************************************************************************
if (line.isNull() || line.isEmpty()) continue; // move the UAV to the magic waypoint position
comboBox->addItem(line);
} void OPMapGadgetWidget::moveToMagicWaypointPosition()
{
file.close(); if (!m_widget || !m_map)
} return;
// save a combobox text contents to a simple text file if (m_map_mode != MagicWaypoint_MapMode)
void OPMapGadgetWidget::saveComboBoxLines(QComboBox *comboBox, QString filename) return;
{
if (!comboBox) return; // internals::PointLatLng coord = magic_waypoint.coord;
if (filename.isNull() || filename.isEmpty()) return; // double altitude = magic_waypoint.altitude;
QFile file(filename);
if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) // ToDo:
return;
}
QTextStream out(&file);
// *************************************************************************************
for (int i = 0; i < comboBox->count(); i++) // temporary until an object is created for managing the save/restore
{
QString line = comboBox->itemText(i).simplified(); // load the contents of a simple text file into a combobox
if (line.isNull() || line.isEmpty()) continue; void OPMapGadgetWidget::loadComboBoxLines(QComboBox *comboBox, QString filename)
out << line << "\n"; {
} if (!comboBox) return;
if (filename.isNull() || filename.isEmpty()) return;
file.close();
} QFile file(filename);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
// ************************************************************************************* return;
// show/hide the magic waypoint controls
QTextStream in(&file);
void OPMapGadgetWidget::hideMagicWaypointControls()
{ while (!in.atEnd())
m_widget->lineWaypoint->setVisible(false); {
m_widget->toolButtonHomeWaypoint->setVisible(false); QString line = in.readLine().simplified();
m_widget->toolButtonMoveToWP->setVisible(false); if (line.isNull() || line.isEmpty()) continue;
} comboBox->addItem(line);
}
void OPMapGadgetWidget::showMagicWaypointControls()
{ file.close();
m_widget->lineWaypoint->setVisible(true); }
m_widget->toolButtonHomeWaypoint->setVisible(true);
// save a combobox text contents to a simple text file
#if defined(allow_manual_home_location_move) void OPMapGadgetWidget::saveComboBoxLines(QComboBox *comboBox, QString filename)
m_widget->toolButtonMoveToWP->setVisible(true); {
#else if (!comboBox) return;
m_widget->toolButtonMoveToWP->setVisible(false); if (filename.isNull() || filename.isEmpty()) return;
#endif
} QFile file(filename);
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
// ************************************************************************************* return;
// move the magic waypoint to keep it within the safe area boundry
QTextStream out(&file);
void OPMapGadgetWidget::keepMagicWaypointWithInSafeArea()
{ for (int i = 0; i < comboBox->count(); i++)
{
// calcute the bearing and distance from the home position to the magic waypoint QString line = comboBox->itemText(i).simplified();
double dist = distance(home_position.coord, magic_waypoint.coord); if (line.isNull() || line.isEmpty()) continue;
double bear = bearing(home_position.coord, magic_waypoint.coord); out << line << "\n";
}
// get the maximum safe distance - in kilometers
double boundry_dist = (double)m_map->Home->SafeArea() / 1000; file.close();
}
// if (dist <= boundry_dist)
// return; // the magic waypoint is still within the safe area, don't move it // *************************************************************************************
// show/hide the magic waypoint controls
if (dist > boundry_dist) dist = boundry_dist;
void OPMapGadgetWidget::hideMagicWaypointControls()
// move the magic waypoint {
m_widget->lineWaypoint->setVisible(false);
magic_waypoint.coord = destPoint(home_position.coord, bear, dist); m_widget->toolButtonHomeWaypoint->setVisible(false);
m_widget->toolButtonMoveToWP->setVisible(false);
if (m_map_mode == MagicWaypoint_MapMode) }
{ // move the on-screen waypoint
if (magic_waypoint.map_wp_item) void OPMapGadgetWidget::showMagicWaypointControls()
magic_waypoint.map_wp_item->SetCoord(magic_waypoint.coord); {
} m_widget->lineWaypoint->setVisible(true);
} m_widget->toolButtonHomeWaypoint->setVisible(true);
// ************************************************************************************* #if defined(allow_manual_home_location_move)
// return the distance between two points .. in kilometers m_widget->toolButtonMoveToWP->setVisible(true);
#else
double OPMapGadgetWidget::distance(internals::PointLatLng from, internals::PointLatLng to) m_widget->toolButtonMoveToWP->setVisible(false);
{ #endif
double lat1 = from.Lat() * deg_to_rad; }
double lon1 = from.Lng() * deg_to_rad;
// *************************************************************************************
double lat2 = to.Lat() * deg_to_rad; // move the magic waypoint to keep it within the safe area boundry
double lon2 = to.Lng() * deg_to_rad;
void OPMapGadgetWidget::keepMagicWaypointWithInSafeArea()
// *********************** {
// Haversine formula
/* // calcute the bearing and distance from the home position to the magic waypoint
double delta_lat = lat2 - lat1; double dist = distance(home_position.coord, magic_waypoint.coord);
double delta_lon = lon2 - lon1; double bear = bearing(home_position.coord, magic_waypoint.coord);
double t1 = sin(delta_lat / 2); // get the maximum safe distance - in kilometers
double t2 = sin(delta_lon / 2); double boundry_dist = (double)m_map->Home->SafeArea() / 1000;
double a = (t1 * t1) + cos(lat1) * cos(lat2) * (t2 * t2);
double c = 2 * atan2(sqrt(a), sqrt(1 - a)); // if (dist <= boundry_dist)
// return; // the magic waypoint is still within the safe area, don't move it
return (earth_mean_radius * c);
*/ if (dist > boundry_dist) dist = boundry_dist;
// ***********************
// Spherical Law of Cosines // move the magic waypoint
return (acos(sin(lat1) * sin(lat2) + cos(lat1) * cos(lat2) * cos(lon2 - lon1)) * earth_mean_radius); magic_waypoint.coord = destPoint(home_position.coord, bear, dist);
// *********************** if (m_map_mode == MagicWaypoint_MapMode)
} { // move the on-screen waypoint
if (magic_waypoint.map_wp_item)
// ************************************************************************************* magic_waypoint.map_wp_item->SetCoord(magic_waypoint.coord);
// return the bearing from one point to another .. in degrees }
}
double OPMapGadgetWidget::bearing(internals::PointLatLng from, internals::PointLatLng to)
{ // *************************************************************************************
double lat1 = from.Lat() * deg_to_rad; // return the distance between two points .. in kilometers
double lon1 = from.Lng() * deg_to_rad;
double OPMapGadgetWidget::distance(internals::PointLatLng from, internals::PointLatLng to)
double lat2 = to.Lat() * deg_to_rad; {
double lon2 = to.Lng() * deg_to_rad; double lat1 = from.Lat() * deg_to_rad;
double lon1 = from.Lng() * deg_to_rad;
// double delta_lat = lat2 - lat1;
double delta_lon = lon2 - lon1; double lat2 = to.Lat() * deg_to_rad;
double lon2 = to.Lng() * deg_to_rad;
double y = sin(delta_lon) * cos(lat2);
double x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(delta_lon); // ***********************
double bear = atan2(y, x) * rad_to_deg; // Haversine formula
/*
bear += 360; double delta_lat = lat2 - lat1;
while (bear < 0) bear += 360; double delta_lon = lon2 - lon1;
while (bear >= 360) bear -= 360;
double t1 = sin(delta_lat / 2);
return bear; double t2 = sin(delta_lon / 2);
} double a = (t1 * t1) + cos(lat1) * cos(lat2) * (t2 * t2);
double c = 2 * atan2(sqrt(a), sqrt(1 - a));
// *************************************************************************************
// return a destination lat/lon point given a source lat/lon point and the bearing and distance from the source point return (earth_mean_radius * c);
*/
internals::PointLatLng OPMapGadgetWidget::destPoint(internals::PointLatLng source, double bear, double dist) // ***********************
{ // Spherical Law of Cosines
double lat1 = source.Lat() * deg_to_rad;
double lon1 = source.Lng() * deg_to_rad; return (acos(sin(lat1) * sin(lat2) + cos(lat1) * cos(lat2) * cos(lon2 - lon1)) * earth_mean_radius);
bear *= deg_to_rad; // ***********************
}
double ad = dist / earth_mean_radius;
// *************************************************************************************
double lat2 = asin(sin(lat1) * cos(ad) + cos(lat1) * sin(ad) * cos(bear)); // return the bearing from one point to another .. in degrees
double lon2 = lon1 + atan2(sin(bear) * sin(ad) * cos(lat1), cos(ad) - sin(lat1) * sin(lat2));
double OPMapGadgetWidget::bearing(internals::PointLatLng from, internals::PointLatLng to)
return internals::PointLatLng(lat2 * rad_to_deg, lon2 * rad_to_deg); {
} double lat1 = from.Lat() * deg_to_rad;
double lon1 = from.Lng() * deg_to_rad;
// *************************************************************************************
double lat2 = to.Lat() * deg_to_rad;
bool OPMapGadgetWidget::getUAV_LLA(double &latitude, double &longitude, double &altitude) double lon2 = to.Lng() * deg_to_rad;
{
double BaseECEF[3]; // double delta_lat = lat2 - lat1;
double NED[3]; double delta_lon = lon2 - lon1;
double LLA[3];
UAVObject *obj; double y = sin(delta_lon) * cos(lat2);
double x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(delta_lon);
ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance(); double bear = atan2(y, x) * rad_to_deg;
if (!pm) return false;
UAVObjectManager *om = pm->getObject<UAVObjectManager>(); bear += 360;
if (!om) return false; while (bear < 0) bear += 360;
while (bear >= 360) bear -= 360;
obj = dynamic_cast<UAVDataObject*>(om->getObject(QString("HomeLocation")));
if (!obj) return false; return bear;
BaseECEF[0] = obj->getField(QString("ECEF"))->getDouble(0) / 100; }
BaseECEF[1] = obj->getField(QString("ECEF"))->getDouble(1) / 100;
BaseECEF[2] = obj->getField(QString("ECEF"))->getDouble(2) / 100; // *************************************************************************************
// return a destination lat/lon point given a source lat/lon point and the bearing and distance from the source point
obj = dynamic_cast<UAVDataObject*>(om->getObject(QString("PositionActual")));
if (!obj) return false; internals::PointLatLng OPMapGadgetWidget::destPoint(internals::PointLatLng source, double bear, double dist)
NED[0] = obj->getField(QString("North"))->getDouble() / 100; {
NED[1] = obj->getField(QString("East"))->getDouble() / 100; double lat1 = source.Lat() * deg_to_rad;
NED[2] = obj->getField(QString("Down"))->getDouble() / 100; double lon1 = source.Lng() * deg_to_rad;
// obj = dynamic_cast<UAVDataObject*>(om->getObject(QString("PositionDesired"))); bear *= deg_to_rad;
// obj = dynamic_cast<UAVDataObject*>(objManager->getObject("VelocityActual")); // air speed double ad = dist / earth_mean_radius;
Utils::CoordinateConversions().GetLLA(BaseECEF, NED, LLA); double lat2 = asin(sin(lat1) * cos(ad) + cos(lat1) * sin(ad) * cos(bear));
double lon2 = lon1 + atan2(sin(bear) * sin(ad) * cos(lat1), cos(ad) - sin(lat1) * sin(lat2));
latitude = LLA[0];
longitude = LLA[1]; return internals::PointLatLng(lat2 * rad_to_deg, lon2 * rad_to_deg);
altitude = LLA[2]; }
if (latitude != latitude) latitude = 0; // nan detection // *************************************************************************************
// if (isNan(latitude)) latitude = 0; // nan detection
else bool OPMapGadgetWidget::getUAV_LLA(double &latitude, double &longitude, double &altitude)
// if (!isFinite(latitude)) latitude = 0; {
// else double BaseECEF[3];
if (latitude > 90) latitude = 90; double NED[3];
else double LLA[3];
if (latitude < -90) latitude = -90; UAVObject *obj;
if (longitude != longitude) longitude = 0; // nan detection ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
else if (!pm) return false;
// if (longitude > std::numeric_limits<double>::max()) longitude = 0; // +infinite UAVObjectManager *om = pm->getObject<UAVObjectManager>();
// else if (!om) return false;
// if (longitude < -std::numeric_limits<double>::max()) longitude = 0; // -infinite
// else obj = dynamic_cast<UAVDataObject*>(om->getObject(QString("HomeLocation")));
if (longitude > 180) longitude = 180; if (!obj) return false;
else BaseECEF[0] = obj->getField(QString("ECEF"))->getDouble(0) / 100;
if (longitude < -180) longitude = -180; BaseECEF[1] = obj->getField(QString("ECEF"))->getDouble(1) / 100;
BaseECEF[2] = obj->getField(QString("ECEF"))->getDouble(2) / 100;
if (altitude != altitude) altitude = 0; // nan detection
obj = dynamic_cast<UAVDataObject*>(om->getObject(QString("PositionActual")));
return true; if (!obj) return false;
} NED[0] = obj->getField(QString("North"))->getDouble() / 100;
NED[1] = obj->getField(QString("East"))->getDouble() / 100;
// ************************************************************************************* NED[2] = obj->getField(QString("Down"))->getDouble() / 100;
bool OPMapGadgetWidget::getGPS_LLA(double &latitude, double &longitude, double &altitude) // obj = dynamic_cast<UAVDataObject*>(om->getObject(QString("PositionDesired")));
{
UAVObject *obj; // obj = dynamic_cast<UAVDataObject*>(objManager->getObject("VelocityActual")); // air speed
ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance(); Utils::CoordinateConversions().GetLLA(BaseECEF, NED, LLA);
if (!pm) return false;
UAVObjectManager *om = pm->getObject<UAVObjectManager>(); latitude = LLA[0];
if (!om) return false; longitude = LLA[1];
altitude = LLA[2];
obj = dynamic_cast<UAVDataObject*>(om->getObject(QString("GPSPosition")));
if (!obj) return false; if (latitude != latitude) latitude = 0; // nan detection
latitude = obj->getField(QString("Latitude"))->getDouble(); // if (isNan(latitude)) latitude = 0; // nan detection
longitude = obj->getField(QString("Longitude"))->getDouble(); else
altitude = obj->getField(QString("Altitude"))->getDouble(); // if (!isFinite(latitude)) latitude = 0;
// else
latitude *= 1E-7; if (latitude > 90) latitude = 90;
longitude *= 1E-7; else
if (latitude < -90) latitude = -90;
if (latitude != latitude) latitude = 0; // nan detection
// if (isNan(latitude)) latitude = 0; // nan detection if (longitude != longitude) longitude = 0; // nan detection
else else
// if (!isFinite(latitude)) latitude = 0; // if (longitude > std::numeric_limits<double>::max()) longitude = 0; // +infinite
// else // else
if (latitude > 90) latitude = 90; // if (longitude < -std::numeric_limits<double>::max()) longitude = 0; // -infinite
else // else
if (latitude < -90) latitude = -90; if (longitude > 180) longitude = 180;
else
if (longitude != longitude) longitude = 0; // nan detection if (longitude < -180) longitude = -180;
else
// if (longitude > std::numeric_limits<double>::max()) longitude = 0; // +infinite if (altitude != altitude) altitude = 0; // nan detection
// else
// if (longitude < -std::numeric_limits<double>::max()) longitude = 0; // -infinite return true;
// else }
if (longitude > 180) longitude = 180;
else // *************************************************************************************
if (longitude < -180) longitude = -180;
bool OPMapGadgetWidget::getGPS_LLA(double &latitude, double &longitude, double &altitude)
if (altitude != altitude) altitude = 0; // nan detection {
UAVObject *obj;
return true;
} ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
if (!pm) return false;
UAVObjectManager *om = pm->getObject<UAVObjectManager>();
double OPMapGadgetWidget::getUAV_Yaw() if (!om) return false;
{
ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance(); obj = dynamic_cast<UAVDataObject*>(om->getObject(QString("GPSPosition")));
if (!pm) return 0.0; if (!obj) return false;
UAVObjectManager *om = pm->getObject<UAVObjectManager>(); latitude = obj->getField(QString("Latitude"))->getDouble();
if (!om) return 0.0; longitude = obj->getField(QString("Longitude"))->getDouble();
altitude = obj->getField(QString("Altitude"))->getDouble();
UAVObject *obj = dynamic_cast<UAVDataObject*>(om->getObject(QString("AttitudeActual")));
double yaw = obj->getField(QString("Yaw"))->getDouble(); latitude *= 1E-7;
longitude *= 1E-7;
if (yaw != yaw) yaw = 0; // nan detection
if (latitude != latitude) latitude = 0; // nan detection
while (yaw < 0) yaw += 360; // if (isNan(latitude)) latitude = 0; // nan detection
while (yaw >= 360) yaw -= 360; else
// if (!isFinite(latitude)) latitude = 0;
return yaw; // else
} if (latitude > 90) latitude = 90;
else
// ************************************************************************************* if (latitude < -90) latitude = -90;
void OPMapGadgetWidget::setMapFollowingMode() if (longitude != longitude) longitude = 0; // nan detection
{ else
if (!m_widget || !m_map) // if (longitude > std::numeric_limits<double>::max()) longitude = 0; // +infinite
return; // else
// if (longitude < -std::numeric_limits<double>::max()) longitude = 0; // -infinite
if (!followUAVpositionAct->isChecked()) // else
{ if (longitude > 180) longitude = 180;
m_map->UAV->SetMapFollowType(UAVMapFollowType::None); else
m_map->SetRotate(0); // reset map rotation to 0deg if (longitude < -180) longitude = -180;
}
else if (altitude != altitude) altitude = 0; // nan detection
if (!followUAVheadingAct->isChecked())
{ return true;
m_map->UAV->SetMapFollowType(UAVMapFollowType::CenterMap); }
m_map->SetRotate(0); // reset map rotation to 0deg
} double OPMapGadgetWidget::getUAV_Yaw()
else {
{ ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
m_map->UAV->SetMapFollowType(UAVMapFollowType::CenterMap); // the map library won't let you reset the uav rotation if it's already in rotate mode if (!pm) return 0.0;
UAVObjectManager *om = pm->getObject<UAVObjectManager>();
m_map->UAV->SetUAVHeading(0); // reset the UAV heading to 0deg if (!om) return 0.0;
m_map->UAV->SetMapFollowType(UAVMapFollowType::CenterAndRotateMap);
} UAVObject *obj = dynamic_cast<UAVDataObject*>(om->getObject(QString("AttitudeActual")));
} double yaw = obj->getField(QString("Yaw"))->getDouble();
// ************************************************************************************* if (yaw != yaw) yaw = 0; // nan detection
while (yaw < 0) yaw += 360;
while (yaw >= 360) yaw -= 360;
return yaw;
}
// *************************************************************************************
// save an object to SD card
void OPMapGadgetWidget::saveObjectToSD(UAVObject *obj)
{
if (!obj) return;
ExtensionSystem::PluginManager *pm = ExtensionSystem::PluginManager::instance();
if (!pm) return;
UAVObjectManager *obm = pm->getObject<UAVObjectManager>();
if (!obm) return;
ObjectPersistence *objper = dynamic_cast<ObjectPersistence *>( obm->getObject(ObjectPersistence::NAME) );
if (!objper) return;
connect(objper, SIGNAL(transactionCompleted(UAVObject *, bool)), this, SLOT(uavObjectTransactionCompleted(UAVObject *, bool)));
ObjectPersistence::DataFields data;
data.Operation = ObjectPersistence::OPERATION_SAVE;
data.Selection = ObjectPersistence::SELECTION_SINGLEOBJECT;
data.ObjectID = obj->getObjID();
data.InstanceID = obj->getInstID();
objper->setData(data);
objper->updated();
}
void OPMapGadgetWidget::uavObjectTransactionCompleted(UAVObject *obj, bool success)
{
Q_UNUSED(success);
// Disconnect from sending object
if (obj) obj->disconnect(this);
}
// *************************************************************************************
void OPMapGadgetWidget::setMapFollowingMode()
{
if (!m_widget || !m_map)
return;
if (!followUAVpositionAct->isChecked())
{
m_map->UAV->SetMapFollowType(UAVMapFollowType::None);
m_map->SetRotate(0); // reset map rotation to 0deg
}
else
if (!followUAVheadingAct->isChecked())
{
m_map->UAV->SetMapFollowType(UAVMapFollowType::CenterMap);
m_map->SetRotate(0); // reset map rotation to 0deg
}
else
{
m_map->UAV->SetMapFollowType(UAVMapFollowType::CenterMap); // the map library won't let you reset the uav rotation if it's already in rotate mode
m_map->UAV->SetUAVHeading(0); // reset the UAV heading to 0deg
m_map->UAV->SetMapFollowType(UAVMapFollowType::CenterAndRotateMap);
}
}
// *************************************************************************************

673
ground/openpilotgcs/src/plugins/opmap/opmapgadgetwidget.h
View File

@ -1,335 +1,338 @@
/** /**
****************************************************************************** ******************************************************************************
* *
* @file opmapgadgetwidget.h * @file opmapgadgetwidget.h
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010. * @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* @addtogroup GCSPlugins GCS Plugins * @addtogroup GCSPlugins GCS Plugins
* @{ * @{
* @addtogroup OPMapPlugin OpenPilot Map Plugin * @addtogroup OPMapPlugin OpenPilot Map Plugin
* @{ * @{
* @brief The OpenPilot Map plugin * @brief The OpenPilot Map plugin
*****************************************************************************/ *****************************************************************************/
/* /*
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, but * This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details. * for more details.
* *
* You should have received a copy of the GNU General Public License along * You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc., * with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/ */
#ifndef OPMAP_GADGETWIDGET_H_ #ifndef OPMAP_GADGETWIDGET_H_
#define OPMAP_GADGETWIDGET_H_ #define OPMAP_GADGETWIDGET_H_
// ****************************************************** // ******************************************************
#include <QtGui/QWidget> #include <QtGui/QWidget>
#include <QtGui/QMenu> #include <QtGui/QMenu>
#include <QStringList> #include <QStringList>
#include <QStandardItemModel> #include <QStandardItemModel>
#include <QList> #include <QList>
#include <QMutex> #include <QMutex>
#include <QMutexLocker> #include <QMutexLocker>
#include <QPointF> #include <QPointF>
#include "opmapcontrol/opmapcontrol.h" #include "opmapcontrol/opmapcontrol.h"
#include "opmap_overlay_widget.h" #include "opmap_overlay_widget.h"
#include "opmap_zoom_slider_widget.h" #include "opmap_zoom_slider_widget.h"
#include "opmap_statusbar_widget.h" #include "opmap_statusbar_widget.h"
#include "utils/coordinateconversions.h" #include "utils/coordinateconversions.h"
// ****************************************************** // ******************************************************
namespace Ui namespace Ui
{ {
class OPMap_Widget; class OPMap_Widget;
} }
using namespace mapcontrol; using namespace mapcontrol;
// ****************************************************** // ******************************************************
typedef struct t_home typedef struct t_home
{ {
internals::PointLatLng coord; internals::PointLatLng coord;
double altitude; double altitude;
bool locked; bool locked;
} t_home; } t_home;
// local waypoint list item structure // local waypoint list item structure
typedef struct t_waypoint typedef struct t_waypoint
{ {
mapcontrol::WayPointItem *map_wp_item; mapcontrol::WayPointItem *map_wp_item;
internals::PointLatLng coord; internals::PointLatLng coord;
double altitude; double altitude;
QString description; QString description;
bool locked; bool locked;
int time_seconds; int time_seconds;
int hold_time_seconds; int hold_time_seconds;
} t_waypoint; } t_waypoint;
// ****************************************************** // ******************************************************
enum opMapModeType { Normal_MapMode = 0, enum opMapModeType { Normal_MapMode = 0,
MagicWaypoint_MapMode = 1}; MagicWaypoint_MapMode = 1};
// ****************************************************** // ******************************************************
class OPMapGadgetWidget : public QWidget class OPMapGadgetWidget : public QWidget
{ {
Q_OBJECT Q_OBJECT
public: public:
OPMapGadgetWidget(QWidget *parent = 0); OPMapGadgetWidget(QWidget *parent = 0);
~OPMapGadgetWidget(); ~OPMapGadgetWidget();
/** /**
* @brief public functions * @brief public functions
* *
* @param * @param
*/ */
void setHome(QPointF pos); void setHome(QPointF pos);
void setHome(internals::PointLatLng pos_lat_lon); void setHome(internals::PointLatLng pos_lat_lon);
void goHome(); void goHome();
void setZoom(int zoom); void setZoom(int zoom);
void setPosition(QPointF pos); void setPosition(QPointF pos);
void setMapProvider(QString provider); void setMapProvider(QString provider);
void setUseOpenGL(bool useOpenGL); void setUseOpenGL(bool useOpenGL);
void setShowTileGridLines(bool showTileGridLines); void setShowTileGridLines(bool showTileGridLines);
void setAccessMode(QString accessMode); void setAccessMode(QString accessMode);
void setUseMemoryCache(bool useMemoryCache); void setUseMemoryCache(bool useMemoryCache);
void setCacheLocation(QString cacheLocation); void setCacheLocation(QString cacheLocation);
void setMapMode(opMapModeType mode); void setMapMode(opMapModeType mode);
public slots: public slots:
void homePositionUpdated(UAVObject*); void homePositionUpdated(UAVObject *);
void onTelemetryConnect(); void onTelemetryConnect();
void onTelemetryDisconnect(); void onTelemetryDisconnect();
void uavObjectTransactionCompleted(UAVObject *obj, bool success);
protected:
void resizeEvent(QResizeEvent *event); protected:
void mouseMoveEvent(QMouseEvent *event); void resizeEvent(QResizeEvent *event);
void contextMenuEvent(QContextMenuEvent *event); void mouseMoveEvent(QMouseEvent *event);
void keyPressEvent(QKeyEvent* event); void contextMenuEvent(QContextMenuEvent *event);
void keyPressEvent(QKeyEvent* event);
private slots:
void updatePosition(); private slots:
void updatePosition();
void updateMousePos();
void updateMousePos();
void zoomIn();
void zoomOut(); void zoomIn();
void zoomOut();
/**
* @brief signals received from the various map plug-in widget user controls /**
* * @brief signals received from the various map plug-in widget user controls
* Some are currently disabled for the v1.0 plugin version. *
*/ * Some are currently disabled for the v1.0 plugin version.
// void comboBoxFindPlace_returnPressed(); */
// void on_toolButtonFindPlace_clicked(); // void comboBoxFindPlace_returnPressed();
void on_toolButtonZoomM_clicked(); // void on_toolButtonFindPlace_clicked();
void on_toolButtonZoomP_clicked(); void on_toolButtonZoomM_clicked();
void on_toolButtonMapHome_clicked(); void on_toolButtonZoomP_clicked();
void on_toolButtonMapUAV_clicked(); void on_toolButtonMapHome_clicked();
void on_toolButtonMapUAVheading_clicked(); void on_toolButtonMapUAV_clicked();
void on_horizontalSliderZoom_sliderMoved(int position); void on_toolButtonMapUAVheading_clicked();
// void on_toolButtonAddWaypoint_clicked(); void on_horizontalSliderZoom_sliderMoved(int position);
// void on_treeViewWaypoints_clicked(QModelIndex index); // void on_toolButtonAddWaypoint_clicked();
// void on_toolButtonHome_clicked(); // void on_treeViewWaypoints_clicked(QModelIndex index);
// void on_toolButtonNextWaypoint_clicked(); // void on_toolButtonHome_clicked();
// void on_toolButtonPrevWaypoint_clicked(); // void on_toolButtonNextWaypoint_clicked();
// void on_toolButtonHoldPosition_clicked(); // void on_toolButtonPrevWaypoint_clicked();
// void on_toolButtonGo_clicked(); // void on_toolButtonHoldPosition_clicked();
void on_toolButtonMagicWaypointMapMode_clicked(); // void on_toolButtonGo_clicked();
void on_toolButtonNormalMapMode_clicked(); void on_toolButtonMagicWaypointMapMode_clicked();
void on_toolButtonHomeWaypoint_clicked(); void on_toolButtonNormalMapMode_clicked();
void on_toolButtonMoveToWP_clicked(); void on_toolButtonHomeWaypoint_clicked();
void on_toolButtonMoveToWP_clicked();
/**
* @brief signals received from the map object /**
*/ * @brief signals received from the map object
void zoomChanged(double zoomt,double zoom, double zoomd); */
void OnCurrentPositionChanged(internals::PointLatLng point); void zoomChanged(double zoomt,double zoom, double zoomd);
void OnTileLoadComplete(); void OnCurrentPositionChanged(internals::PointLatLng point);
void OnTileLoadStart(); void OnTileLoadComplete();
void OnMapDrag(); void OnTileLoadStart();
void OnMapZoomChanged(); void OnMapDrag();
void OnMapTypeChanged(MapType::Types type); void OnMapZoomChanged();
void OnEmptyTileError(int zoom, core::Point pos); void OnMapTypeChanged(MapType::Types type);
void OnTilesStillToLoad(int number); void OnEmptyTileError(int zoom, core::Point pos);
void OnTilesStillToLoad(int number);
/**
* Unused for now, hooks for future waypoint support /**
*/ * Unused for now, hooks for future waypoint support
void WPNumberChanged(int const& oldnumber,int const& newnumber, WayPointItem* waypoint); */
void WPValuesChanged(WayPointItem* waypoint); void WPNumberChanged(int const& oldnumber,int const& newnumber, WayPointItem* waypoint);
void WPInserted(int const& number, WayPointItem* waypoint); void WPValuesChanged(WayPointItem* waypoint);
void WPDeleted(int const& number); void WPInserted(int const& number, WayPointItem* waypoint);
void WPDeleted(int const& number);
/**
* @brief mouse right click context menu signals /**
*/ * @brief mouse right click context menu signals
void onReloadAct_triggered(); */
void onCopyMouseLatLonToClipAct_triggered(); void onReloadAct_triggered();
void onCopyMouseLatToClipAct_triggered(); void onCopyMouseLatLonToClipAct_triggered();
void onCopyMouseLonToClipAct_triggered(); void onCopyMouseLatToClipAct_triggered();
// void onFindPlaceAct_triggered(); void onCopyMouseLonToClipAct_triggered();
void onShowCompassAct_toggled(bool show); // void onFindPlaceAct_triggered();
void onShowUAVAct_toggled(bool show); void onShowCompassAct_toggled(bool show);
void onShowHomeAct_toggled(bool show); void onShowUAVAct_toggled(bool show);
void onGoZoomInAct_triggered(); void onShowHomeAct_toggled(bool show);
void onGoZoomOutAct_triggered(); void onGoZoomInAct_triggered();
void onGoMouseClickAct_triggered(); void onGoZoomOutAct_triggered();
void onSetHomeAct_triggered(); void onGoMouseClickAct_triggered();
void onGoHomeAct_triggered(); void onSetHomeAct_triggered();
void onGoUAVAct_triggered(); void onGoHomeAct_triggered();
void onFollowUAVpositionAct_toggled(bool checked); void onGoUAVAct_triggered();
void onFollowUAVheadingAct_toggled(bool checked); void onFollowUAVpositionAct_toggled(bool checked);
/* void onFollowUAVheadingAct_toggled(bool checked);
void onOpenWayPointEditorAct_triggered(); /*
void onAddWayPointAct_triggered(); void onOpenWayPointEditorAct_triggered();
void onEditWayPointAct_triggered(); void onAddWayPointAct_triggered();
void onLockWayPointAct_triggered(); void onEditWayPointAct_triggered();
void onDeleteWayPointAct_triggered(); void onLockWayPointAct_triggered();
void onClearWayPointsAct_triggered(); void onDeleteWayPointAct_triggered();
*/ void onClearWayPointsAct_triggered();
void onMapModeActGroup_triggered(QAction *action); */
void onZoomActGroup_triggered(QAction *action); void onMapModeActGroup_triggered(QAction *action);
void onHomeMagicWaypointAct_triggered(); void onZoomActGroup_triggered(QAction *action);
void onShowSafeAreaAct_toggled(bool show); void onHomeMagicWaypointAct_triggered();
void onSafeAreaActGroup_triggered(QAction *action); void onShowSafeAreaAct_toggled(bool show);
void onUAVTrailTypeActGroup_triggered(QAction *action); void onSafeAreaActGroup_triggered(QAction *action);
void onClearUAVtrailAct_triggered(); void onUAVTrailTypeActGroup_triggered(QAction *action);
void onUAVTrailTimeActGroup_triggered(QAction *action); void onClearUAVtrailAct_triggered();
void onUAVTrailDistanceActGroup_triggered(QAction *action); void onUAVTrailTimeActGroup_triggered(QAction *action);
void onUAVTrailDistanceActGroup_triggered(QAction *action);
private:
int min_zoom; private:
int max_zoom; int min_zoom;
int max_zoom;
double m_heading; // uav heading
double m_heading; // uav heading
internals::PointLatLng mouse_lat_lon;
internals::PointLatLng context_menu_lat_lon; internals::PointLatLng mouse_lat_lon;
internals::PointLatLng context_menu_lat_lon;
int prev_tile_number;
int prev_tile_number;
opMapModeType m_map_mode;
opMapModeType m_map_mode;
t_home home_position;
t_home home_position;
t_waypoint magic_waypoint;
t_waypoint magic_waypoint;
QStringList findPlaceWordList;
QCompleter *findPlaceCompleter; QStringList findPlaceWordList;
QCompleter *findPlaceCompleter;
QTimer *m_updateTimer;
QTimer *m_statusUpdateTimer; QTimer *m_updateTimer;
QTimer *m_statusUpdateTimer;
Ui::OPMap_Widget *m_widget;
Ui::OPMap_Widget *m_widget;
mapcontrol::OPMapWidget *m_map;
mapcontrol::OPMapWidget *m_map;
//opmap_waypointeditor_dialog waypoint_editor_dialog;
//opmap_waypointeditor_dialog waypoint_editor_dialog;
//opmap_edit_waypoint_dialog waypoint_edit_dialog;
//opmap_edit_waypoint_dialog waypoint_edit_dialog;
opmap_overlay_widget *m_overlay_widget;
opmap_overlay_widget *m_overlay_widget;
QGraphicsScene *m_map_graphics_scene;
QGraphicsProxyWidget *m_map_scene_proxy; QGraphicsScene *m_map_graphics_scene;
opmap_zoom_slider_widget *m_zoom_slider_widget; QGraphicsProxyWidget *m_map_scene_proxy;
opmap_statusbar_widget *m_statusbar_widget; opmap_zoom_slider_widget *m_zoom_slider_widget;
opmap_statusbar_widget *m_statusbar_widget;
QStandardItemModel wayPoint_treeView_model;
QStandardItemModel wayPoint_treeView_model;
mapcontrol::WayPointItem *m_mouse_waypoint;
mapcontrol::WayPointItem *m_mouse_waypoint;
QList<t_waypoint *> m_waypoint_list;
QMutex m_waypoint_list_mutex; QList<t_waypoint *> m_waypoint_list;
QMutex m_waypoint_list_mutex;
QMutex m_map_mutex;
QMutex m_map_mutex;
bool telemetry_connected;
bool telemetry_connected;
void createActions();
void createActions();
QAction *closeAct1;
QAction *closeAct2; QAction *closeAct1;
QAction *reloadAct; QAction *closeAct2;
QAction *copyMouseLatLonToClipAct; QAction *reloadAct;
QAction *copyMouseLatToClipAct; QAction *copyMouseLatLonToClipAct;
QAction *copyMouseLonToClipAct; QAction *copyMouseLatToClipAct;
QAction *findPlaceAct; QAction *copyMouseLonToClipAct;
QAction *showCompassAct; QAction *findPlaceAct;
QAction *showHomeAct; QAction *showCompassAct;
QAction *showUAVAct; QAction *showHomeAct;
QAction *zoomInAct; QAction *showUAVAct;
QAction *zoomOutAct; QAction *zoomInAct;
QAction *goMouseClickAct; QAction *zoomOutAct;
QAction *setHomeAct; QAction *goMouseClickAct;
QAction *goHomeAct; QAction *setHomeAct;
QAction *goUAVAct; QAction *goHomeAct;
QAction *followUAVpositionAct; QAction *goUAVAct;
QAction *followUAVheadingAct; QAction *followUAVpositionAct;
/* QAction *followUAVheadingAct;
QAction *wayPointEditorAct; /*
QAction *addWayPointAct; QAction *wayPointEditorAct;
QAction *editWayPointAct; QAction *addWayPointAct;
QAction *lockWayPointAct; QAction *editWayPointAct;
QAction *deleteWayPointAct; QAction *lockWayPointAct;
QAction *clearWayPointsAct; QAction *deleteWayPointAct;
*/ QAction *clearWayPointsAct;
QAction *homeMagicWaypointAct; */
QAction *homeMagicWaypointAct;
QAction *showSafeAreaAct;
QActionGroup *safeAreaActGroup; QAction *showSafeAreaAct;
QList<QAction *> safeAreaAct; QActionGroup *safeAreaActGroup;
QList<QAction *> safeAreaAct;
QActionGroup *uavTrailTypeActGroup;
QList<QAction *> uavTrailTypeAct; QActionGroup *uavTrailTypeActGroup;
QAction *clearUAVtrailAct; QList<QAction *> uavTrailTypeAct;
QActionGroup *uavTrailTimeActGroup; QAction *clearUAVtrailAct;
QList<QAction *> uavTrailTimeAct; QActionGroup *uavTrailTimeActGroup;
QActionGroup *uavTrailDistanceActGroup; QList<QAction *> uavTrailTimeAct;
QList<QAction *> uavTrailDistanceAct; QActionGroup *uavTrailDistanceActGroup;
QList<QAction *> uavTrailDistanceAct;
QActionGroup *mapModeActGroup;
QList<QAction *> mapModeAct; QActionGroup *mapModeActGroup;
QList<QAction *> mapModeAct;
QActionGroup *zoomActGroup;
QList<QAction *> zoomAct; QActionGroup *zoomActGroup;
QList<QAction *> zoomAct;
void homeMagicWaypoint();
void homeMagicWaypoint();
void moveToMagicWaypointPosition();
void moveToMagicWaypointPosition();
void loadComboBoxLines(QComboBox *comboBox, QString filename);
void saveComboBoxLines(QComboBox *comboBox, QString filename); void loadComboBoxLines(QComboBox *comboBox, QString filename);
void saveComboBoxLines(QComboBox *comboBox, QString filename);
void hideMagicWaypointControls();
void showMagicWaypointControls(); void hideMagicWaypointControls();
void showMagicWaypointControls();
void keepMagicWaypointWithInSafeArea();
void keepMagicWaypointWithInSafeArea();
double distance(internals::PointLatLng from, internals::PointLatLng to);
double bearing(internals::PointLatLng from, internals::PointLatLng to); double distance(internals::PointLatLng from, internals::PointLatLng to);
internals::PointLatLng destPoint(internals::PointLatLng source, double bear, double dist); double bearing(internals::PointLatLng from, internals::PointLatLng to);
internals::PointLatLng destPoint(internals::PointLatLng source, double bear, double dist);
bool getUAV_LLA(double &latitude, double &longitude, double &altitude);
bool getGPS_LLA(double &latitude, double &longitude, double &altitude); bool getUAV_LLA(double &latitude, double &longitude, double &altitude);
double getUAV_Yaw(); bool getGPS_LLA(double &latitude, double &longitude, double &altitude);
double getUAV_Yaw();
void setMapFollowingMode();
}; void saveObjectToSD(UAVObject *obj);
#endif /* OPMAP_GADGETWIDGET_H_ */ void setMapFollowingMode();
};
#endif /* OPMAP_GADGETWIDGET_H_ */