2412 lines
65 KiB
C++
2412 lines
65 KiB
C++
/**
|
|
******************************************************************************
|
|
*
|
|
* @file opmapwidget.cpp
|
|
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2012.
|
|
* @brief The Map Widget, this is the part exposed to the user
|
|
* @see The GNU Public License (GPL) Version 3
|
|
* @defgroup OPMapWidget
|
|
* @{
|
|
*
|
|
*****************************************************************************/
|
|
/*
|
|
* 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
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* for more details.
|
|
*
|
|
* 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.,
|
|
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "opmapwidget.h"
|
|
#include <QtGui>
|
|
#include <QMetaObject>
|
|
#include "waypointitem.h"
|
|
#include "QDir"
|
|
#include <QGraphicsSceneMouseEvent>
|
|
#include "QTextCodec"
|
|
|
|
|
|
namespace mapcontrol {
|
|
OPMapWidget::OPMapWidget(QWidget *parent, Configuration *config) : QGraphicsView(parent), configuration(config), UAV(0), GPS(0), Home(0)
|
|
, followmouse(true), compass(0), showuav(false), showhome(false), diagTimer(0), diagGraphItem(0), showDiag(false), overlayOpacity(1),isWPCreate(false)
|
|
{
|
|
//QTextCodec::setCodecForLocale(QTextCodec::codecForName("GB2312"));
|
|
QTextCodec::setCodecForLocale(QTextCodec::codecForName("utf8"));
|
|
setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
|
|
core = new internals::Core;
|
|
|
|
|
|
QDir *MapDir = new QDir;
|
|
if(!MapDir->exists("./maps"))
|
|
MapDir->mkdir("./maps");//如果文件夹不存在就新建
|
|
|
|
config->SetCacheLocation(QDir::currentPath() + QDir::separator() + "maps" + QDir::separator());
|
|
|
|
map = new MapGraphicItem(core, config);
|
|
|
|
//map->setAcceptDrops(true);
|
|
|
|
mscene.addItem(map);//添加图层
|
|
|
|
this->setScene(&mscene);
|
|
Home = new HomeItem(map, this);
|
|
Home->setParentItem(map);
|
|
Home->setZValue(-1);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
this->adjustSize();
|
|
connect(map, SIGNAL(zoomChanged(double, double, double)), this, SIGNAL(zoomChanged(double, double, double)));
|
|
connect(map->core, SIGNAL(OnCurrentPositionChanged(internals::PointLatLng)), this, SIGNAL(OnCurrentPositionChanged(internals::PointLatLng)));
|
|
connect(map->core, SIGNAL(OnEmptyTileError(int, core::Point)), this, SIGNAL(OnEmptyTileError(int, core::Point)));
|
|
connect(map->core, SIGNAL(OnMapDrag()), this, SIGNAL(OnMapDrag()));
|
|
connect(map->core, SIGNAL(OnMapTypeChanged(MapType::Types)), this, SIGNAL(OnMapTypeChanged(MapType::Types)));
|
|
connect(map->core, SIGNAL(OnMapZoomChanged()), this, SIGNAL(OnMapZoomChanged()));
|
|
connect(map->core, SIGNAL(OnTileLoadComplete()), this, SIGNAL(OnTileLoadComplete()));
|
|
connect(map->core, SIGNAL(OnTileLoadStart()), this, SIGNAL(OnTileLoadStart()));
|
|
connect(map->core, SIGNAL(OnTilesStillToLoad(int)), this, SIGNAL(OnTilesStillToLoad(int)));
|
|
connect(map, SIGNAL(wpdoubleclicked(WayPointItem *)), this, SIGNAL(OnWayPointDoubleClicked(WayPointItem *)));
|
|
connect(&mscene, SIGNAL(selectionChanged()), this, SLOT(OnSelectionChanged()));
|
|
SetShowDiagnostics(showDiag);
|
|
this->setMouseTracking(followmouse);
|
|
SetShowCompass(false);
|
|
QPixmapCache::setCacheLimit(1024 * 1024);//set 1M byte
|
|
|
|
setOverlayOpacity(overlayOpacity);
|
|
|
|
|
|
altitudeitem = new AltitudeItem(map,Qt::red);
|
|
altitudeitem->setParentItem(map);
|
|
altitudeitem->setPos(0,(this->height() - altitudeitem->boundingRect().height())/2);
|
|
altitudeitem->hide();
|
|
|
|
|
|
waypointsetting = new WayPointSetting(map,QColor("#a39d9c"));
|
|
mscene.addItem(waypointsetting);
|
|
waypointsetting->hide();
|
|
|
|
connect(waypointsetting,SIGNAL(WPotherPoint(int)),
|
|
this,SLOT(WPotherPoint(int)));
|
|
|
|
|
|
connect(waypointsetting,SIGNAL(WPDelete()),
|
|
this,SLOT(WPDelete()));
|
|
|
|
connect(waypointsetting,SIGNAL(WPInsert()),
|
|
this,SLOT(WPInsert()));
|
|
|
|
connect(waypointsetting,SIGNAL(WPUpload()),
|
|
this,SLOT(WPUpload()));
|
|
|
|
connect(waypointsetting,SIGNAL(WPDownload()),
|
|
this,SLOT(WPDownload()));
|
|
|
|
connect(waypointsetting,SIGNAL(WPSave(QString)),
|
|
this,SLOT(WPSave(QString)));
|
|
|
|
connect(waypointsetting,SIGNAL(WPLoad(QString)),
|
|
this,SLOT(WPLoad(QString)));
|
|
|
|
/*
|
|
connect(this,SIGNAL(allPoint(QMap<int,int>)),
|
|
waypointsetting,SLOT(setallPoint(QMap<int,int>)));
|
|
*/
|
|
|
|
connect(waypointsetting,SIGNAL(searchall()),
|
|
this,SLOT(WPsearchall()));
|
|
|
|
connect(waypointsetting,SIGNAL(WPRuler()),
|
|
this,SLOT(ruler_clicked()));
|
|
|
|
connect(waypointsetting,SIGNAL(WPTable()),
|
|
this,SLOT(table_clicked()));
|
|
|
|
|
|
|
|
//missiontable = new MissionDialog();
|
|
|
|
//missiontable->hide();
|
|
|
|
point_begin.SetLat(0);
|
|
point_begin.SetLng(0);
|
|
|
|
point_end.SetLat(0);
|
|
point_end.SetLng(0);
|
|
|
|
measureline = new MeasureLine(point_begin, point_end, map, QColor("#FFFF00"));
|
|
mscene.addItem(measureline);
|
|
measureline->hide();
|
|
|
|
|
|
NoOperationTimer = new QTimer(this);
|
|
connect(NoOperationTimer,SIGNAL(timeout()),
|
|
this,SLOT(NOPTimeout()));
|
|
NoOperationTimer->start(20000);//20s不操作
|
|
|
|
|
|
|
|
currentGroup = 3;
|
|
|
|
}
|
|
|
|
void OPMapWidget::dragEnterEvent(QDragEnterEvent *event)
|
|
{
|
|
QString suffix = event->mimeData()->urls()[0].fileName().right(5);
|
|
|
|
if(!suffix.compare(tr(".plan")))
|
|
{
|
|
event->acceptProposedAction();
|
|
}
|
|
else
|
|
{
|
|
event->ignore();
|
|
}
|
|
}
|
|
|
|
void OPMapWidget::dropEvent(QDropEvent *event)
|
|
{
|
|
const QMimeData *qm = event->mimeData();
|
|
|
|
QString fileName = qm->urls()[0].toLocalFile();
|
|
|
|
if(fileName.right(5) == ".plan")
|
|
{
|
|
WPLoad(fileName);
|
|
}
|
|
}
|
|
|
|
void OPMapWidget::ruler_clicked(void)
|
|
{
|
|
if(isMeasure)
|
|
{
|
|
isMeasure = false;
|
|
this->setCursor(Qt::ArrowCursor);
|
|
}
|
|
else
|
|
{
|
|
isMeasure = true;
|
|
measurenumber = 1;//开始记录
|
|
|
|
if(measureline)
|
|
{
|
|
measureline->show();
|
|
}
|
|
|
|
QPixmap pix(":/markers/images/ruler.png");
|
|
this->setCursor(QCursor(pix.scaled(QSize(50,50), Qt::KeepAspectRatio)));
|
|
}
|
|
}
|
|
|
|
void OPMapWidget::table_clicked(void)
|
|
{
|
|
/*
|
|
if(missiontable)
|
|
{
|
|
if(missiontable->isHidden())
|
|
{
|
|
missiontable->show();
|
|
}
|
|
else
|
|
{
|
|
missiontable->hide();
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
|
|
void OPMapWidget::SetShowDiagnostics(bool const & value)
|
|
{
|
|
showDiag = value;
|
|
}
|
|
void OPMapWidget::SetUavPic(QString UAVPic)
|
|
{
|
|
if (UAV != 0) {
|
|
UAV->SetUavPic(UAVPic);
|
|
}
|
|
if (GPS != 0) {
|
|
GPS->SetUavPic(UAVPic);
|
|
}
|
|
}
|
|
|
|
void OPMapWidget::SetShowUAV(const bool &value)
|
|
{
|
|
|
|
if (value && UAV == 0) {
|
|
UAV = new UAVItem(map, this);
|
|
UAV->setParentItem(map);
|
|
connect(this, SIGNAL(UAVLeftSafetyBouble(internals::PointLatLng)), UAV, SIGNAL(UAVLeftSafetyBouble(internals::PointLatLng)));
|
|
connect(this, SIGNAL(UAVReachedWayPoint(int, WayPointItem *)), UAV, SIGNAL(UAVReachedWayPoint(int, WayPointItem *)));
|
|
|
|
connect(UAV,SIGNAL(selected(int,int)),
|
|
this,SIGNAL(uav_selected(int,int)));
|
|
|
|
UAV->setOpacity(overlayOpacity);
|
|
} else if (!value) {
|
|
if (UAV != 0) {
|
|
delete UAV;
|
|
UAV = NULL;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void OPMapWidget::addUAV(int sysid,int compid)
|
|
{
|
|
UAVItem *uavItem = new UAVItem(map, this);
|
|
uavItem->setParentItem(map);
|
|
uavItem->SetUavPic("Fixwing.png");
|
|
uavItem->setID(sysid,compid);
|
|
|
|
connect(this, SIGNAL(UAVLeftSafetyBouble(internals::PointLatLng)),
|
|
uavItem, SIGNAL(UAVLeftSafetyBouble(internals::PointLatLng)));
|
|
connect(this, SIGNAL(UAVReachedWayPoint(int, WayPointItem *)),
|
|
uavItem, SIGNAL(UAVReachedWayPoint(int, WayPointItem *)));
|
|
|
|
connect(uavItem,SIGNAL(selected(int,int)),
|
|
this,SIGNAL(uav_selected(int,int)));
|
|
|
|
uavItem->setOpacity(overlayOpacity);
|
|
|
|
//检测，如果只有一个飞机，那么就选中
|
|
uint32_t uavCount = 0;
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
UAVItem *u = qgraphicsitem_cast<UAVItem *>(i);
|
|
if (u) {
|
|
uavCount ++;
|
|
}
|
|
}
|
|
|
|
if(uavCount <= 1)
|
|
{
|
|
uavItem->setSelect(true);
|
|
}
|
|
else
|
|
{
|
|
uavItem->setSelect(false);
|
|
}
|
|
|
|
|
|
this->SetCurrentPosition();
|
|
}
|
|
|
|
void OPMapWidget::NOPTimeout()
|
|
{
|
|
//qDebug() << "NOPTimeout";
|
|
//这个超限
|
|
if(isWPCreate == false)
|
|
{
|
|
isLNOP = true;
|
|
}
|
|
}
|
|
|
|
|
|
void OPMapWidget::SetCurrentPosition()
|
|
{
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
UAVItem *u = qgraphicsitem_cast<UAVItem *>(i);
|
|
if (u) {
|
|
|
|
if(u->Select())//当前选中，那么检查如果超出了屏幕范围，就将位置拉回中点
|
|
{
|
|
map->core->SetCurrentPosition(u->UAVPos());//缓慢拉回来
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OPMapWidget::SetCurrentPosition(internals::PointLatLng const & value)
|
|
{
|
|
map->core->SetCurrentPosition(value);
|
|
}
|
|
|
|
|
|
void OPMapWidget::setUAVPos(int sysid,int compid,double x,double y,double z)
|
|
{
|
|
//qDebug() << sysid << compid;
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
UAVItem *u = qgraphicsitem_cast<UAVItem *>(i);
|
|
if (u) {
|
|
if(u->SysID() == sysid)
|
|
{
|
|
internals::PointLatLng LatLng;
|
|
LatLng.SetLat(x);
|
|
LatLng.SetLng(y);
|
|
u->SetUAVPos(LatLng,z);
|
|
|
|
/*
|
|
//==========================
|
|
编辑界面不拉回
|
|
飞行界面 20s不操作才会拉回一次
|
|
//===========================*/
|
|
|
|
if(isWPCreate == false)
|
|
{
|
|
if(u->Select())//当前选中，那么检查如果超出了屏幕范围，就将位置拉回中点
|
|
{
|
|
if(((u->pos().x() <= 0)||
|
|
(u->pos().x() >= this->size().width())||
|
|
(u->pos().y() < 0)||
|
|
(u->pos().y() >= this->size().height()))&&(isLNOP == true))
|
|
{
|
|
this->SetCurrentPosition(LatLng);//缓慢拉回来
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OPMapWidget::setUAVHeading(int sysid,int compid,float Heading)
|
|
{
|
|
Q_UNUSED(compid)
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
UAVItem *u = qgraphicsitem_cast<UAVItem *>(i);
|
|
if (u) {
|
|
if(u->SysID() == sysid)
|
|
{
|
|
u->SetUAVHeading(Heading);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
int OPMapWidget::getUAVCurrent(void)
|
|
{
|
|
int num = -1;
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
UAVItem *u = qgraphicsitem_cast<UAVItem *>(i);
|
|
if (u) {
|
|
if(u->Select())
|
|
{
|
|
num = u->SysID();
|
|
}
|
|
}
|
|
}
|
|
|
|
return num;
|
|
}
|
|
|
|
void OPMapWidget::DeleteTrail(void)
|
|
{
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
UAVItem *u = qgraphicsitem_cast<UAVItem *>(i);
|
|
if (u) {
|
|
if(u->Select())
|
|
{
|
|
u->DeleteTrail();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
WayPointLine *OPMapWidget::WPLineCreate(WayPointItem *from, WayPointItem *to, QColor color, bool dashed, int width)
|
|
{
|
|
if (!from | !to) {
|
|
return NULL;
|
|
}
|
|
WayPointLine *ret = new WayPointLine(from, to, map, color, dashed, width);
|
|
ret->setOpacity(overlayOpacity);
|
|
return ret;
|
|
}
|
|
|
|
WayPointLine *OPMapWidget::WPLineCreate(HomeItem *from, WayPointItem *to, QColor color, bool dashed, int width)
|
|
{
|
|
if (!from | !to) {
|
|
return NULL;
|
|
}
|
|
WayPointLine *ret = new WayPointLine(from, to, map, color, dashed, width);
|
|
ret->setOpacity(overlayOpacity);
|
|
return ret;
|
|
}
|
|
|
|
void OPMapWidget::WPLineUpdate(int group)//调用这个，刷新连接线
|
|
{
|
|
|
|
}
|
|
|
|
void OPMapWidget::WPLineDelete(WayPointItem *from, WayPointItem *to)
|
|
{
|
|
do
|
|
{
|
|
WayPointLine *line = WPLineFind(from,to);
|
|
if(line)
|
|
{
|
|
delete line;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}while(0);
|
|
}
|
|
|
|
WayPointLine *OPMapWidget::WPLineFind(WayPointItem *from, WayPointItem *to)
|
|
{
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointLine *l = qgraphicsitem_cast<WayPointLine *>(i);
|
|
|
|
if (l) {
|
|
if ((l->WPLineFrom() == from) && (l->WPLineTo() == to) )
|
|
{
|
|
return l;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
WayPointCircle *OPMapWidget::WPCircleCreate(WayPointItem *center, double radius, bool clockwise, QColor color, bool dashed, int width)
|
|
{
|
|
if (!center | !radius) {
|
|
return NULL;
|
|
}
|
|
WayPointCircle *ret = new WayPointCircle(center, radius, clockwise, map, color, dashed, width);
|
|
ret->setOpacity(overlayOpacity);
|
|
return ret;
|
|
}
|
|
|
|
WayPointCircle *OPMapWidget::WPCircleCreate(HomeItem *center, double radius, bool clockwise, QColor color, bool dashed, int width)
|
|
{
|
|
if (!center | !radius) {
|
|
return NULL;
|
|
}
|
|
WayPointCircle *ret = new WayPointCircle(center, radius, clockwise, map, color, dashed, width);
|
|
ret->setOpacity(overlayOpacity);
|
|
return ret;
|
|
}
|
|
|
|
void OPMapWidget::SetShowHome(const bool &value)
|
|
{
|
|
Home->setVisible(value);
|
|
}
|
|
|
|
void OPMapWidget::resizeEvent(QResizeEvent *event)
|
|
{
|
|
if (scene()) {
|
|
scene()->setSceneRect(
|
|
QRect(QPoint(0,0), event->size()));
|
|
}
|
|
|
|
QGraphicsView::resizeEvent(event);
|
|
if (compass) {
|
|
compass->setScale(0.1 + 0.05 * (qreal)(event->size().width()) / 1000 * (qreal)(event->size().height()) / 600);
|
|
}
|
|
|
|
}
|
|
QSize OPMapWidget::sizeHint() const
|
|
{
|
|
return map->sizeHint();
|
|
}
|
|
void OPMapWidget::showEvent(QShowEvent *event)
|
|
{
|
|
connect(&mscene, SIGNAL(sceneRectChanged(QRectF)), map, SLOT(resize(QRectF)));
|
|
map->start();
|
|
QGraphicsView::showEvent(event);
|
|
}
|
|
OPMapWidget::~OPMapWidget()
|
|
{
|
|
|
|
if (UAV) {
|
|
delete UAV;
|
|
}
|
|
if (Home) {
|
|
delete Home;
|
|
}
|
|
if (map) {
|
|
delete map;
|
|
}
|
|
if (core) {
|
|
delete core;
|
|
}
|
|
if (configuration) {
|
|
delete configuration;
|
|
}
|
|
foreach(QGraphicsItem * i, this->items()) {
|
|
if (i) {
|
|
delete i;
|
|
}
|
|
}
|
|
}
|
|
void OPMapWidget::closeEvent(QCloseEvent *event)
|
|
{
|
|
core->OnMapClose();
|
|
event->accept();
|
|
}
|
|
void OPMapWidget::SetUseOpenGL(const bool &value)
|
|
{
|
|
useOpenGL = value;
|
|
if (useOpenGL) {
|
|
setViewport(new QGLWidget(QGLFormat(QGL::SampleBuffers)));
|
|
} else {
|
|
setupViewport(new QWidget());
|
|
}
|
|
update();
|
|
}
|
|
internals::PointLatLng OPMapWidget::currentMousePosition()
|
|
{
|
|
return currentmouseposition;
|
|
}
|
|
|
|
void OPMapWidget::mouseMoveEvent(QMouseEvent *event)
|
|
{
|
|
QGraphicsView::mouseMoveEvent(event);
|
|
|
|
if(altitudeitem)
|
|
{
|
|
if((event->pos().x() > altitudeitem->x())&&(event->pos().x() < (altitudeitem->boundingRect().width() + altitudeitem->x())) &&
|
|
(event->pos().y() > altitudeitem->y())&&(event->pos().y() < (altitudeitem->boundingRect().height() + altitudeitem->y())))//在高度区域禁止生成航点
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
//一个区域内禁止生成
|
|
/*
|
|
if(waypointsetting)
|
|
{
|
|
if((event->pos().x() > waypointsetting->x())&&(event->pos().x() < (waypointsetting->boundingRect().width() + waypointsetting->x())) &&
|
|
(event->pos().y() > waypointsetting->y())&&(event->pos().y() < (waypointsetting->boundingRect().height() + waypointsetting->y())))//在按键区域禁止生成航点
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
QPointF p = event->pos();
|
|
|
|
//qDebug() << "mouseMoveEvent";
|
|
|
|
p = map->mapFromParent(p);
|
|
currentmouseposition = map->FromLocalToLatLng(p.x(), p.y());
|
|
|
|
|
|
isLNOP = false;
|
|
|
|
|
|
if(isMeasure)
|
|
{
|
|
QPointF p = event->pos();
|
|
p = map->mapFromParent(p);
|
|
point_end = map->FromLocalToLatLng(p.x(), p.y());
|
|
//measurenumber = 1;
|
|
|
|
if(measureline)
|
|
{
|
|
if(measurenumber == 2)//取了第一个点后
|
|
{
|
|
measureline->setTo(point_end);
|
|
}
|
|
}
|
|
}
|
|
|
|
emit EmitCurrentMousePosition(currentmouseposition);
|
|
|
|
if(isMeasure)
|
|
{
|
|
QPixmap pix(":/markers/images/ruler.png");
|
|
this->setCursor(QCursor(pix.scaled(QSize(50,50), Qt::KeepAspectRatio)));
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
void OPMapWidget::mousePressEvent(QMouseEvent *event)
|
|
{
|
|
QGraphicsView::mousePressEvent(event);
|
|
|
|
if(altitudeitem)
|
|
{
|
|
if((event->pos().x() > altitudeitem->x())&&(event->pos().x() < (altitudeitem->boundingRect().width() + altitudeitem->x())) &&
|
|
(event->pos().y() > altitudeitem->y())&&(event->pos().y() < (altitudeitem->boundingRect().height() + altitudeitem->y())))//在高度区域禁止生成航点
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
//一个区域内禁止生成
|
|
/*
|
|
if(waypointsetting)
|
|
{
|
|
if((event->pos().x() > waypointsetting->x())&&(event->pos().x() < (waypointsetting->boundingRect().width() + waypointsetting->x())) &&
|
|
(event->pos().y() > waypointsetting->y())&&(event->pos().y() < (waypointsetting->boundingRect().height() + waypointsetting->y())))//在按键区域禁止生成航点
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
*/
|
|
|
|
if(event->button() == Qt::LeftButton)
|
|
{
|
|
|
|
if(isMeasure)
|
|
{
|
|
if(measurenumber == 1)
|
|
{
|
|
QPointF p = event->pos();
|
|
p = map->mapFromParent(p);
|
|
point_begin = map->FromLocalToLatLng(p.x(), p.y());
|
|
measurenumber ++;
|
|
|
|
if(measureline)
|
|
{
|
|
measureline->setFrom(point_begin);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
QPointF p = event->pos();
|
|
p = map->mapFromParent(p);
|
|
point_end = map->FromLocalToLatLng(p.x(), p.y());
|
|
measurenumber = 1;
|
|
|
|
if(measureline)
|
|
{
|
|
measureline->setTo(point_end);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
isLNOP = false;
|
|
|
|
emit MousePressEvent(event);
|
|
|
|
if(isMeasure)
|
|
{
|
|
QPixmap pix(":/markers/images/ruler.png");
|
|
this->setCursor(QCursor(pix.scaled(QSize(50,50), Qt::KeepAspectRatio)));
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void OPMapWidget::mouseReleaseEvent(QMouseEvent *event)
|
|
{
|
|
isLNOP = false;
|
|
|
|
QGraphicsView::mouseReleaseEvent(event);
|
|
emit MouseReleaseEvent(event);
|
|
|
|
if(isMeasure)
|
|
{
|
|
QPixmap pix(":/markers/images/ruler.png");
|
|
this->setCursor(QCursor(pix.scaled(QSize(50,50), Qt::KeepAspectRatio)));
|
|
}
|
|
|
|
//qDebug() << "relea";
|
|
}
|
|
|
|
void OPMapWidget::mouseDoubleClickEvent(QMouseEvent *event)
|
|
{
|
|
QGraphicsView::mouseDoubleClickEvent(event);
|
|
|
|
if(isMeasure)
|
|
{
|
|
QPixmap pix(":/markers/images/ruler.png");
|
|
this->setCursor(QCursor(pix.scaled(QSize(50,50), Qt::KeepAspectRatio)));
|
|
}
|
|
|
|
if(isMeasure)
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
if(altitudeitem)
|
|
{
|
|
if((event->pos().x() > altitudeitem->x())&&(event->pos().x() < (altitudeitem->boundingRect().width() + altitudeitem->x())) &&
|
|
(event->pos().y() > altitudeitem->y())&&(event->pos().y() < (altitudeitem->boundingRect().height() + altitudeitem->y())))//在高度区域禁止生成航点
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
//一个区域内禁止生成
|
|
/*
|
|
if(waypointsetting)
|
|
{
|
|
if((event->pos().x() > waypointsetting->x())&&(event->pos().x() < (waypointsetting->boundingRect().width() + waypointsetting->x())) &&
|
|
(event->pos().y() > waypointsetting->y())&&(event->pos().y() < (waypointsetting->boundingRect().height() + waypointsetting->y())))//在按键区域禁止生成航点
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
|
|
|
|
isLNOP = false;
|
|
|
|
//生成一个列表
|
|
//如果是点击生成，那么就获取当前的编辑组，使用当前编辑组的编号
|
|
if(isWPCreate == true)
|
|
{
|
|
if(event->button() == Qt::LeftButton)
|
|
{
|
|
QPointF p = event->pos();
|
|
p = map->mapFromParent(p);
|
|
internals::PointLatLng LatLng;
|
|
LatLng = map->FromLocalToLatLng(p.x(), p.y());
|
|
WayPointItem *Item = WPCreate(LatLng,50);
|
|
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
|
|
if (w) {
|
|
if (w->MissionType() == Item->MissionType()) {
|
|
if(w->Number() == (Item->Number() - 1))
|
|
{
|
|
WPLineCreate(w,Item,Qt::green,false,2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
emit MouseDoubleClickEvent(event);
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////WAYPOINT////////////////////////
|
|
WayPointItem *OPMapWidget::WPCreate()
|
|
{
|
|
//获取当前组下面的seq最大值
|
|
int seq = getWaypointSize(currentGroup);
|
|
|
|
WayPointItem *item = new WayPointItem(this->CurrentPosition(), 0,seq,currentGroup, map);
|
|
|
|
ConnectWP(item);
|
|
item->setParentItem(map);
|
|
item->SetMissionType(currentGroup);
|
|
int position = item->Number();
|
|
emit WPCreated(position, item);
|
|
return item;
|
|
}
|
|
WayPointItem *OPMapWidget::magicWPCreate()
|
|
{
|
|
//获取当前组下面的seq最大值
|
|
int seq = getWaypointSize(currentGroup);
|
|
|
|
WayPointItem *item = new WayPointItem(seq,currentGroup,map, true);
|
|
|
|
item->SetShowNumber(false);
|
|
item->setParentItem(map);
|
|
item->SetMissionType(currentGroup);
|
|
return item;
|
|
}
|
|
void OPMapWidget::WPCreate(WayPointItem *item)
|
|
{
|
|
ConnectWP(item);
|
|
item->setParentItem(map);
|
|
item->SetMissionType(currentGroup);
|
|
int position = item->Number();
|
|
emit WPCreated(position, item);
|
|
setOverlayOpacity(overlayOpacity);
|
|
}
|
|
WayPointItem *OPMapWidget::WPCreate(internals::PointLatLng const & coord, int const & altitude)
|
|
{
|
|
//获取当前组下面的seq最大值
|
|
int seq = getWaypointSize(currentGroup);
|
|
|
|
WayPointItem *item = new WayPointItem(coord, altitude,seq,currentGroup, map);
|
|
|
|
ConnectWP(item);
|
|
item->setParentItem(map);
|
|
item->SetMissionType(currentGroup);
|
|
int position = item->Number();
|
|
emit WPCreated(position, item);
|
|
setOverlayOpacity(overlayOpacity);
|
|
return item;
|
|
}
|
|
WayPointItem *OPMapWidget::WPCreate(internals::PointLatLng const & coord, int const & altitude, QString const & description)
|
|
{
|
|
//获取当前组下面的seq最大值
|
|
int seq = getWaypointSize(currentGroup);
|
|
|
|
WayPointItem *item = new WayPointItem(coord, altitude,seq,currentGroup, description, map);
|
|
|
|
ConnectWP(item);
|
|
item->setParentItem(map);
|
|
item->SetMissionType(currentGroup);
|
|
int position = item->Number();
|
|
emit WPCreated(position, item);
|
|
setOverlayOpacity(overlayOpacity);
|
|
return item;
|
|
}
|
|
WayPointItem *OPMapWidget::WPCreate(const distBearingAltitude &relativeCoord, const QString &description)
|
|
{
|
|
//获取当前组下面的seq最大值
|
|
int seq = getWaypointSize(currentGroup);
|
|
|
|
WayPointItem *item = new WayPointItem(relativeCoord,seq,currentGroup, description, map);
|
|
|
|
ConnectWP(item);
|
|
item->setParentItem(map);
|
|
item->SetMissionType(currentGroup);
|
|
int position = item->Number();
|
|
emit WPCreated(position, item);
|
|
setOverlayOpacity(overlayOpacity);
|
|
return item;
|
|
}
|
|
|
|
int OPMapWidget::getWaypointSize(int group)
|
|
{
|
|
QList<WayPointItem *> list;
|
|
list.clear();
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
|
|
if (w) {
|
|
if (w->MissionType() == group) {
|
|
list.append(w);
|
|
}
|
|
}
|
|
}
|
|
|
|
return list.size();
|
|
}
|
|
|
|
void OPMapWidget::WPInsert()
|
|
{
|
|
//获取位置和组号
|
|
int position = 0;
|
|
int group = 3;
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
|
|
if (w) {
|
|
if (w->isSelected()) {
|
|
position = w->Number();
|
|
group = w->MissionType();
|
|
}
|
|
}
|
|
}
|
|
|
|
//刷新全部连线，目前连线很乱
|
|
internals::PointLatLng latlng;
|
|
|
|
WayPointItem *item_old0 = WPFind(group,position-1);
|
|
WayPointItem *item_old1 = WPFind(group,position);//当前选中的点
|
|
WayPointItem *item_old2 = WPFind(group,position+1);
|
|
|
|
//删除连线
|
|
if((item_old1)&&(item_old0))
|
|
{
|
|
WPLineDelete(item_old0,item_old1);
|
|
WPLineDelete(item_old1,item_old0);
|
|
|
|
internals::PointLatLng latlng1 = item_old0->Coord();
|
|
internals::PointLatLng latlng2 = item_old1->Coord();
|
|
|
|
latlng.SetLat((latlng1.Lat() + latlng2.Lat())/2);
|
|
latlng.SetLng((latlng1.Lng() + latlng2.Lng())/2);
|
|
}
|
|
else
|
|
{
|
|
if(item_old1)
|
|
{
|
|
latlng = item_old1->Coord();
|
|
}
|
|
}
|
|
|
|
|
|
//如果指定的点存在，那么就可以在这之前（编号比现在小）插入一个点
|
|
if(item_old1)
|
|
{
|
|
WayPointItem *item = new WayPointItem(latlng, item_old1->Altitude(), position,group,map);
|
|
|
|
ConnectWP(item);
|
|
item->SetNumber(position);
|
|
item->setParentItem(map);
|
|
item->SetMissionType(group);
|
|
setOverlayOpacity(overlayOpacity);
|
|
|
|
setSelectedWP(item);
|
|
item->emitWPProperty();//这个没有执行
|
|
|
|
//调整编号
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w) {
|
|
if(w->MissionType() == group)
|
|
{
|
|
if(w != item)
|
|
{
|
|
if(w->Number() >= item->Number())
|
|
{
|
|
w->SetNumber(w->Number()+1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
WayPointItem *w_last = WPFind(group,item->Number() - 1);
|
|
if(w_last)
|
|
{
|
|
WPLineCreate(w_last,item,Qt::green,false,2);
|
|
}
|
|
|
|
WayPointItem *w_next = WPFind(group,item->Number() + 1);
|
|
if(w_next)
|
|
{
|
|
WPLineCreate(item,w_next,Qt::green,false,2);
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
//设置跟随
|
|
/*
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w) {
|
|
WPFollowPrevious(w->FollowPrevious(),w);
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
void OPMapWidget::WPInsert(WayPointItem *item, const int &position)
|
|
{
|
|
item->SetNumber(position);
|
|
ConnectWP(item);
|
|
item->setParentItem(map);
|
|
item->SetMissionType(currentGroup);
|
|
emit WPInserted(position, item);
|
|
setOverlayOpacity(overlayOpacity);
|
|
}
|
|
WayPointItem *OPMapWidget::WPInsert(internals::PointLatLng const & coord, int const & altitude, const int &position)
|
|
{
|
|
WayPointItem *item = new WayPointItem(coord, altitude,position,currentGroup, map);
|
|
|
|
item->SetNumber(position);
|
|
ConnectWP(item);
|
|
item->setParentItem(map);
|
|
item->SetMissionType(currentGroup);
|
|
emit WPInserted(position, item);
|
|
setOverlayOpacity(overlayOpacity);
|
|
return item;
|
|
}
|
|
WayPointItem *OPMapWidget::WPInsert(internals::PointLatLng const & coord, int const & altitude, QString const & description, const int &position)
|
|
{
|
|
internals::PointLatLng mcoord;
|
|
bool reloc = false;
|
|
|
|
if (mcoord == internals::PointLatLng(0, 0)) {
|
|
mcoord = CurrentPosition();
|
|
reloc = true;
|
|
} else {
|
|
mcoord = coord;
|
|
}
|
|
WayPointItem *item = new WayPointItem(mcoord, altitude,position,currentGroup, description, map);
|
|
item->SetNumber(position);
|
|
ConnectWP(item);
|
|
item->setParentItem(map);
|
|
item->SetMissionType(currentGroup);
|
|
emit WPInserted(position, item);
|
|
if (reloc) {
|
|
emit WPValuesChanged(item);
|
|
}
|
|
setOverlayOpacity(overlayOpacity);
|
|
return item;
|
|
}
|
|
WayPointItem *OPMapWidget::WPInsert(distBearingAltitude const & relative, QString const & description, const int &position)
|
|
{
|
|
WayPointItem *item = new WayPointItem(relative,position,currentGroup, description, map);
|
|
|
|
item->SetNumber(position);
|
|
ConnectWP(item);
|
|
item->setParentItem(map);
|
|
item->SetMissionType(currentGroup);
|
|
emit WPInserted(position, item);
|
|
setOverlayOpacity(overlayOpacity);
|
|
return item;
|
|
}
|
|
|
|
void OPMapWidget::WPDelete(WayPointItem *item)
|
|
{
|
|
int number = item->Number();
|
|
int group = item->MissionType();
|
|
|
|
emit WPDeleted(number, item);
|
|
delete item;
|
|
|
|
//当前选中为上一点
|
|
WayPointItem *w = WPFind(group,number -1);
|
|
if(w)
|
|
{
|
|
setSelectedWP(w);
|
|
w->emitWPProperty();
|
|
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w_next = qgraphicsitem_cast<WayPointItem *>(i);
|
|
|
|
if (w_next) {
|
|
if (w->MissionType() == w_next->MissionType()) {
|
|
if(w->Number() == (w_next->Number() + 1))
|
|
{
|
|
WPLineCreate(w,w_next,Qt::green,false,2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WayPointItem *ww = WPFind(group,number);
|
|
if(ww)
|
|
{
|
|
setSelectedWP(ww);
|
|
ww->emitWPProperty();
|
|
}
|
|
}
|
|
}
|
|
void OPMapWidget::WPDelete(void)
|
|
{
|
|
int number = 0;
|
|
int group = 3;
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
|
|
if (w) {
|
|
if (w->isSelected()) {
|
|
|
|
number = w->Number();
|
|
group = w->MissionType();
|
|
emit WPDeleted(w->Number(), w);//这个会修改编号
|
|
delete w;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//当前选中为上一点
|
|
WayPointItem *item = WPFind(group,number -1);
|
|
if(item)
|
|
{
|
|
setSelectedWP(item);
|
|
item->emitWPProperty();
|
|
|
|
WayPointItem *item_next = WPFind(group,number);
|
|
if (item_next) {
|
|
WPLineCreate(item,item_next,Qt::green,false,2);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
WayPointItem *ww = WPFind(group,number);
|
|
if(ww)
|
|
{
|
|
setSelectedWP(ww);
|
|
ww->emitWPProperty();
|
|
}
|
|
}
|
|
|
|
/*
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w) {
|
|
WPFollowPrevious(w->FollowPrevious(),w);
|
|
}
|
|
}
|
|
*/
|
|
|
|
}
|
|
WayPointItem *OPMapWidget::WPFind(int group,int number)
|
|
{
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
|
|
if (w) {
|
|
if(w->MissionType() == group)
|
|
{
|
|
if (w->Number() == number) {
|
|
return w;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
void OPMapWidget::WPSetVisibleAll(bool value)
|
|
{
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
|
|
if (w) {
|
|
if (w->Number() != -1) {
|
|
w->setVisible(value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//清除当前航线才能下载
|
|
void OPMapWidget::WPDeleteAll()
|
|
{
|
|
//删除一个组
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
|
|
if (w) {
|
|
|
|
if(w->MissionType() == currentGroup)
|
|
{
|
|
emit WPDeleted(w->Number(), w);
|
|
delete w;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
bool OPMapWidget::WPPresent()
|
|
{
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
|
|
if (w) {
|
|
if (w->Number() != -1) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void OPMapWidget::deleteAllOverlays()
|
|
{
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointLine *w = qgraphicsitem_cast<WayPointLine *>(i);
|
|
|
|
if (w) {
|
|
w->deleteLater();
|
|
} else {
|
|
WayPointCircle *ww = qgraphicsitem_cast<WayPointCircle *>(i);
|
|
if (ww) {
|
|
ww->deleteLater();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
QList<WayPointItem *> OPMapWidget::WPSelected()
|
|
{
|
|
QList<WayPointItem *> list;
|
|
foreach(QGraphicsItem * i, mscene.selectedItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
|
|
if (w) {
|
|
list.append(w);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
void OPMapWidget::WPRenumber(WayPointItem *item, const int &newnumber)
|
|
{
|
|
item->SetNumber(newnumber);
|
|
}
|
|
|
|
void OPMapWidget::ConnectWP(WayPointItem *item)
|
|
{
|
|
connect(item, SIGNAL(WPNumberChanged(int, int, WayPointItem *)), this, SIGNAL(WPNumberChanged(int, int, WayPointItem *)), Qt::DirectConnection);
|
|
connect(item, SIGNAL(WPValuesChanged(WayPointItem *)), this, SIGNAL(WPValuesChanged(WayPointItem *)), Qt::DirectConnection);
|
|
connect(item, SIGNAL(localPositionChanged(QPointF, WayPointItem *)), this, SIGNAL(WPLocalPositionChanged(QPointF, WayPointItem *)), Qt::DirectConnection);
|
|
connect(item, SIGNAL(manualCoordChange(WayPointItem *)), this, SIGNAL(WPManualCoordChange(WayPointItem *)), Qt::DirectConnection);
|
|
connect(this, SIGNAL(WPInserted(int, WayPointItem *)), item, SLOT(WPInserted(int, WayPointItem *)), Qt::DirectConnection);
|
|
connect(this, SIGNAL(WPNumberChanged(int, int, WayPointItem *)), item, SLOT(WPRenumbered(int, int, WayPointItem *)), Qt::DirectConnection);
|
|
connect(this, SIGNAL(WPDeleted(int, WayPointItem *)), item, SLOT(WPDeleted(int, WayPointItem *)), Qt::DirectConnection);
|
|
connect(item,SIGNAL(WPChanged(int,double,double)),this,SIGNAL(WPChanged(int,double,double)));
|
|
|
|
connect(item, SIGNAL(WPProperty(float,float,float,float,int32_t,int32_t,float,uint16_t,uint16_t,uint16_t,uint8_t,uint8_t,uint8_t,uint8_t,uint8_t,uint8_t)),
|
|
this, SIGNAL(WPProperty(float,float,float,float,int32_t,int32_t,float,uint16_t,uint16_t,uint16_t,uint8_t,uint8_t,uint8_t,uint8_t,uint8_t,uint8_t)),Qt::DirectConnection);
|
|
|
|
connect(this, SIGNAL(setWPProperty(float,float,float,float,int32_t,int32_t,float,uint16_t,uint16_t,uint16_t,uint8_t,uint8_t,uint8_t,uint8_t,uint8_t,uint8_t)),
|
|
item, SLOT(setWPProperty(float,float,float,float,int32_t,int32_t,float,uint16_t,uint16_t,uint16_t,uint8_t,uint8_t,uint8_t,uint8_t,uint8_t,uint8_t)),Qt::DirectConnection);
|
|
|
|
|
|
|
|
connect(item, SIGNAL(WPProperty(float,float,float,float,int32_t,int32_t,float,uint16_t,uint16_t,uint16_t,uint8_t,uint8_t,uint8_t,uint8_t,uint8_t,uint8_t)),
|
|
this, SLOT(find_PointNumber()),Qt::DirectConnection);
|
|
|
|
|
|
connect(item, SIGNAL(WPFollowPrevious(bool,WayPointItem*)),
|
|
this, SLOT(WPFollowPrevious(bool,WayPointItem*)),Qt::DirectConnection);
|
|
|
|
connect(item, SIGNAL(localPositionChanged(QPointF, WayPointItem *)),
|
|
this, SLOT(WPLocalChanged(QPointF, WayPointItem *)), Qt::DirectConnection);
|
|
|
|
connect(item,SIGNAL(SetCurrent(int)),
|
|
this,SIGNAL(setCurrent(int)), Qt::DirectConnection);
|
|
|
|
|
|
|
|
|
|
connect(item,SIGNAL(ElevationChanged(int,double)),
|
|
this,SLOT(ElevationChanged(int,double)), Qt::DirectConnection);
|
|
|
|
connect(item,SIGNAL(AltitudeChanged(int,double)),
|
|
this,SLOT(AltitudeChanged(int,double)), Qt::DirectConnection);
|
|
|
|
connect(item,SIGNAL(setCurrentPoint(int)),
|
|
this,SLOT(setCurrentPoint(int)), Qt::DirectConnection);
|
|
|
|
|
|
connect(item,SIGNAL(currentMissiontype(int)),
|
|
this,SLOT(WPGroup(int)), Qt::DirectConnection);
|
|
|
|
|
|
//生成后立即选中，并且把信息发给ui界面
|
|
setSelectedWP(item);
|
|
item->emitWPProperty();
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void OPMapWidget::diagRefresh()
|
|
{
|
|
if (showDiag) {
|
|
if (diagGraphItem == 0) {
|
|
diagGraphItem = new QGraphicsTextItem();
|
|
mscene.addItem(diagGraphItem);
|
|
diagGraphItem->setPos(10, 100);
|
|
diagGraphItem->setZValue(3);
|
|
diagGraphItem->setFlag(QGraphicsItem::ItemIsMovable, true);
|
|
diagGraphItem->setDefaultTextColor(Qt::yellow);
|
|
}
|
|
diagGraphItem->setPlainText(core->GetDiagnostics().toString());
|
|
} else if (diagGraphItem != 0) {
|
|
delete diagGraphItem;
|
|
diagGraphItem = 0;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////
|
|
void OPMapWidget::SetShowCompass(const bool &value)
|
|
{
|
|
if (value && !compass) {
|
|
compass = new QGraphicsSvgItem(QString::fromUtf8(":/markers/images/compas.svg"));
|
|
compass->setScale(0.1 + 0.05 * (qreal)(this->size().width()) / 1000 * (qreal)(this->size().height()) / 600);
|
|
// compass->setTransformOriginPoint(compass->boundingRect().width(),compass->boundingRect().height());
|
|
compass->setFlag(QGraphicsItem::ItemIsMovable, true);
|
|
compass->setFlag(QGraphicsItem::ItemIsSelectable, true);
|
|
mscene.addItem(compass);
|
|
compass->setTransformOriginPoint(compass->boundingRect().width() / 2, compass->boundingRect().height() / 2);
|
|
compass->setPos(55 - compass->boundingRect().width() / 2, 55 - compass->boundingRect().height() / 2);
|
|
compass->setZValue(3);
|
|
compass->setOpacity(0.7);
|
|
}
|
|
if (!value && compass) {
|
|
delete compass;
|
|
compass = 0;
|
|
}
|
|
}
|
|
|
|
void OPMapWidget::setOverlayOpacity(qreal value)
|
|
{
|
|
map->setOverlayOpacity(value);
|
|
overlayOpacity = value;
|
|
}
|
|
void OPMapWidget::SetRotate(qreal const & value)
|
|
{
|
|
map->mapRotate(value);
|
|
if (compass && (compass->rotation() != value)) {
|
|
compass->setRotation(value);
|
|
}
|
|
}
|
|
void OPMapWidget::RipMap()
|
|
{
|
|
new MapRipper(core, map->SelectedArea());
|
|
}
|
|
|
|
void OPMapWidget::setSelectedWP(QList<WayPointItem * >list)
|
|
{
|
|
this->scene()->clearSelection();
|
|
foreach(WayPointItem * wp, list) {
|
|
wp->setSelected(true);
|
|
if(altitudeitem)
|
|
{
|
|
if(!wp->FollowPrevious())
|
|
altitudeitem->setCurrentPoint(wp->Number());
|
|
}
|
|
}
|
|
}
|
|
|
|
void OPMapWidget::setSelectedWP(int number)
|
|
{
|
|
this->scene()->clearSelection();
|
|
WayPointItem *wp = WPFind(currentGroup,number);
|
|
wp->setSelected(true);
|
|
|
|
if(altitudeitem)
|
|
{
|
|
if(!wp->FollowPrevious())
|
|
altitudeitem->setCurrentPoint(wp->Number());
|
|
}
|
|
|
|
}
|
|
|
|
void OPMapWidget::setSelectedWP(WayPointItem *item)
|
|
{
|
|
this->scene()->clearSelection();
|
|
item->setSelected(true);
|
|
|
|
if(altitudeitem)
|
|
{
|
|
if(!item->FollowPrevious())
|
|
altitudeitem->setCurrentPoint(item->Number());
|
|
}
|
|
}
|
|
|
|
|
|
void OPMapWidget::OnSelectionChanged()
|
|
{
|
|
QList<QGraphicsItem *> list;
|
|
QList<WayPointItem *> wplist;
|
|
list = this->scene()->selectedItems();
|
|
foreach(QGraphicsItem * item, list) {
|
|
WayPointItem *wp = qgraphicsitem_cast<WayPointItem *>(item);
|
|
|
|
qDebug() << "selete item" << wp->Number();
|
|
|
|
if (wp) {
|
|
wplist.append(wp);
|
|
}
|
|
}
|
|
if (wplist.length() > 0) {
|
|
emit selectedWPChanged(wplist);
|
|
}
|
|
}
|
|
|
|
|
|
void OPMapWidget::WPotherPoint(int number)
|
|
{
|
|
int position = 0;
|
|
int group = 3;
|
|
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
|
|
if (w) {
|
|
if (w->isSelected()) {
|
|
position = w->Number() + number;
|
|
group = w->MissionType();
|
|
}
|
|
}
|
|
}
|
|
|
|
if(1 != qAbs(number))
|
|
{
|
|
position = number;
|
|
}
|
|
|
|
|
|
//position = number;
|
|
|
|
WayPointItem *wp = WPFind(group,position);
|
|
|
|
if(wp)
|
|
{
|
|
setSelectedWP(position);
|
|
wp->emitWPProperty();
|
|
}
|
|
}
|
|
|
|
|
|
void OPMapWidget::setWPLock(bool const & lock)
|
|
{
|
|
bool isEdit = false;
|
|
|
|
if(lock == true)
|
|
{
|
|
isEdit = false;
|
|
}
|
|
else
|
|
{
|
|
isEdit = true;
|
|
}
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w) {
|
|
qDebug() << "set Edit" <<isEdit;
|
|
|
|
w->WPSetEdit(isEdit);
|
|
}
|
|
}
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
UAVItem *uav = qgraphicsitem_cast<UAVItem *>(i);
|
|
if (uav) {
|
|
uav->setEdit(isEdit);
|
|
}
|
|
}
|
|
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointLine *l = qgraphicsitem_cast<WayPointLine *>(i);
|
|
if (l) {
|
|
l->setEdit(isEdit);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
void OPMapWidget::WPSetCurrent(int seq)
|
|
{
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w) {
|
|
|
|
if(w->Number() == seq)
|
|
{
|
|
w->WPSetCurrent(true);
|
|
//qDebug() << "map WPSetCurrent" << seq;
|
|
}
|
|
else
|
|
{
|
|
w->WPSetCurrent(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void OPMapWidget::WPsearchall(void)
|
|
{
|
|
//重新排序一下
|
|
|
|
//QList<mapcontrol::WayPointItem *> list;
|
|
|
|
QMap<int,int> list;
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w) {
|
|
list.insert(w->Number(),w->Command());
|
|
}
|
|
}
|
|
|
|
for (QMap<int,int>::iterator i = list.begin();i != list.end(); ++i)
|
|
{
|
|
qDebug() << i.key() << i.value();
|
|
}
|
|
|
|
|
|
if(list.size() != 0)
|
|
{
|
|
emit allPoint(list);
|
|
}
|
|
}
|
|
|
|
void OPMapWidget::setWPCreate(bool const & value)
|
|
{
|
|
isWPCreate = value;
|
|
|
|
if(map)
|
|
{
|
|
if(value)
|
|
{
|
|
map->setAcceptDrops(true);
|
|
}
|
|
else
|
|
{
|
|
map->setAcceptDrops(false);
|
|
}
|
|
}
|
|
|
|
|
|
if(altitudeitem)
|
|
{
|
|
if(value)
|
|
{
|
|
altitudeitem->show();
|
|
}
|
|
else
|
|
{
|
|
altitudeitem->hide();
|
|
}
|
|
}
|
|
|
|
if(waypointsetting)
|
|
{
|
|
if(value)
|
|
{
|
|
//waypointsetting->show();
|
|
}
|
|
else
|
|
{
|
|
waypointsetting->hide();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void OPMapWidget::WPLocalChanged(QPointF p, WayPointItem *w)
|
|
{
|
|
WayPointItem *item = WPFind(w->MissionType(),w->Number() + 1);
|
|
|
|
if(item)
|
|
{
|
|
if(item->FollowPrevious() == true)
|
|
{
|
|
QPointF pos = p;
|
|
pos.setX(pos.x() + w->boundingRect().width());
|
|
item->setPosition(pos);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void OPMapWidget::WPFollowPrevious(bool flag,WayPointItem *w)
|
|
{
|
|
int Point_Count = 0;
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w) {//逐渐往下增加
|
|
Point_Count++;
|
|
}
|
|
}
|
|
|
|
|
|
if(flag)
|
|
{
|
|
WayPointItem *item = WPFind(w->MissionType(),w->Number() - 1);
|
|
if(item)
|
|
{
|
|
WPLineDelete(item,w);
|
|
|
|
//跟随上一点的位置
|
|
QPointF pos = item->pos();
|
|
pos.setX(pos.x() + w->boundingRect().width());
|
|
w->setPosition(pos);
|
|
|
|
//找到前后两个不是跟随的点，将他们连接起来
|
|
WayPointItem *front_item;
|
|
int front_seq = w->Number();
|
|
do{
|
|
front_item = WPFind(w->MissionType(),front_seq--);
|
|
if(front_item)
|
|
{
|
|
if(front_item->FollowPrevious() == false)
|
|
{
|
|
qDebug() << "front_item" << front_item->Number();
|
|
break;
|
|
}
|
|
else {
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}while(front_seq > 0);
|
|
|
|
WayPointItem *next_item;
|
|
int next_seq = w->Number();
|
|
do{
|
|
next_item = WPFind(w->MissionType(),next_seq++);
|
|
|
|
if(next_item)
|
|
{
|
|
WPLineDelete(w,next_item);
|
|
|
|
if(next_item->FollowPrevious() == false)
|
|
{
|
|
qDebug() << "next_item" << next_item->Number();
|
|
break;
|
|
}
|
|
else {
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}while(next_seq <= Point_Count);
|
|
|
|
if(next_item)
|
|
{
|
|
WPLineDelete(w,next_item);
|
|
}
|
|
|
|
if((front_item)&&(next_item))
|
|
{
|
|
WPLineCreate(front_item,next_item,Qt::green,false,2);
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
//找到前后两个不是跟随的点，将他们连接起来
|
|
WayPointItem *front_item;
|
|
int front_seq = w->Number()-1;
|
|
do{
|
|
front_item = WPFind(w->MissionType(),front_seq--);
|
|
|
|
if(front_item)
|
|
{
|
|
if(front_item->FollowPrevious() == false)
|
|
{
|
|
qDebug() << "front_item" << front_item->Number();
|
|
break;
|
|
}
|
|
else {
|
|
//如果上一点存在，那么就删除掉线
|
|
qDebug() << "Delete front" << front_item->Number();
|
|
WPLineDelete(front_item,w);
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}while(front_seq > 0);
|
|
|
|
WayPointItem *next_item;
|
|
int next_seq = w->Number()+1;
|
|
do{
|
|
next_item = WPFind(w->MissionType(),next_seq++);
|
|
|
|
if(next_item)
|
|
{
|
|
if(next_item->FollowPrevious() == false)
|
|
{
|
|
qDebug() << "next_item" << next_item->Number();
|
|
break;
|
|
}
|
|
else {
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}while(next_seq <= Point_Count);
|
|
|
|
if((front_item)&&(next_item))
|
|
{
|
|
WPLineDelete(front_item,next_item);
|
|
}
|
|
|
|
if(front_item)
|
|
{
|
|
WPLineCreate(front_item,w,Qt::green,false,2);
|
|
}
|
|
|
|
if(next_item)
|
|
{
|
|
WPLineCreate(w,next_item,Qt::green,false,2);
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//先清除再读取
|
|
void OPMapWidget::WPLoad(QString path)//带文件目录参数
|
|
{
|
|
//清除所有
|
|
WPDeleteAll();//清除当前航线
|
|
qDebug() << "WPLoad" << path;
|
|
//读取
|
|
QFile jsonFile(path);
|
|
if (!jsonFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
|
|
qWarning() << "Unable to open file" << path << jsonFile.errorString();
|
|
return;
|
|
}
|
|
|
|
QByteArray bytes = jsonFile.readAll();
|
|
|
|
jsonFile.close();
|
|
QJsonParseError jsonParseError;
|
|
QJsonDocument doc = QJsonDocument::fromJson(bytes, &jsonParseError);
|
|
if (jsonParseError.error != QJsonParseError::NoError) {
|
|
qWarning() << path << "Unable to open json document" << jsonParseError.errorString();
|
|
return;
|
|
}
|
|
|
|
QJsonObject json = doc.object();
|
|
|
|
//安全区解码
|
|
|
|
|
|
//任务解码
|
|
QJsonArray itemsArray = json.value("mission").toObject().value("items").toArray();
|
|
|
|
for(QJsonValue item: itemsArray) {
|
|
if (!item.isObject()) {
|
|
return;
|
|
}
|
|
|
|
uint8_t AMSLAltAboveTerrain = item.toObject().find("AMSLAltAboveTerrain").value().toInt();
|
|
uint8_t Altitude = item.toObject().find("Altitude").value().toDouble();
|
|
uint8_t AltitudeMode = item.toObject().find("AltitudeMode").value().toInt();
|
|
uint8_t autocontinue = item.toObject().find("autoContinue").value().toBool()?(1):(0);//bool
|
|
uint16_t command = item.toObject().find("command").value().toInt();
|
|
uint16_t seq = item.toObject().find("doJumpId").value().toInt();
|
|
uint8_t frame = item.toObject().find("frame").value().toInt();
|
|
QJsonArray params = item.toObject().find("params").value().toArray();//array
|
|
uint8_t mission_type = item.toObject().find("type").value().toInt();
|
|
|
|
float param1 = params.at(0).toDouble();
|
|
float param2 = params.at(1).toDouble();
|
|
float param3 = params.at(2).toDouble();
|
|
float param4 = params.at(3).toDouble();
|
|
int32_t x = params.at(4).toDouble() * 10e6;
|
|
int32_t y = params.at(5).toDouble() * 10e6;;
|
|
float z = params.at(6).toDouble();
|
|
|
|
internals::PointLatLng LatLng;
|
|
LatLng.SetLat(x * 10e-8);
|
|
LatLng.SetLng(y * 10e-8);
|
|
|
|
qDebug() << "LatLng" << LatLng.Lat() << LatLng.Lng();
|
|
|
|
WayPointItem *Item = WPCreate(LatLng,z);
|
|
|
|
Item->SetNumber(seq);
|
|
|
|
if(command > MAV_CMD::MAV_CMD_NAV_LAST)
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
//WPLineCreate(WPFind(Item->Number() - 1),Item,Qt::green,false,2);
|
|
}
|
|
|
|
//Item->setParent(map);
|
|
|
|
//qDebug() << "autocontinue" << autocontinue;
|
|
|
|
|
|
emit setWPProperty(param1,param2,param3,param4,
|
|
x,y,z,
|
|
seq,
|
|
currentGroup,//当前组
|
|
command,
|
|
0,
|
|
0,
|
|
frame,
|
|
0,
|
|
autocontinue,
|
|
mission_type);
|
|
|
|
|
|
Item->emitWPProperty();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
void OPMapWidget::WPSave(QString path)//带文件目录参数
|
|
{
|
|
qDebug() << "WPSave" << path;
|
|
//保存到文件 *.plan,使用qgc的协议 json读写
|
|
QJsonDocument *doc = new QJsonDocument();
|
|
QJsonObject root= doc->object();
|
|
|
|
QJsonObject geoFence;
|
|
QJsonObject mission;
|
|
QJsonObject rallyPoints;
|
|
|
|
|
|
//geoFence节点写入
|
|
{
|
|
QJsonArray circles;
|
|
QJsonArray polygons;
|
|
|
|
geoFence.insert("circles",circles);
|
|
geoFence.insert("polygons",polygons);
|
|
geoFence.insert("version",2);
|
|
}
|
|
|
|
//mission节点写入
|
|
{
|
|
QJsonArray items;
|
|
|
|
QJsonArray plannedHomePosition;
|
|
|
|
QMap<int,WayPointItem *> wlist;
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w) {//逐渐往下增加
|
|
wlist.insert(w->Number(),w);
|
|
}
|
|
}
|
|
|
|
for (QMap<int,WayPointItem *>::iterator i = wlist.begin(); i != wlist.end(); ++i) {
|
|
|
|
WayPointItem *w = i.value();
|
|
|
|
if (w) {//逐渐往下增加
|
|
if(w->Number()>0)
|
|
{
|
|
|
|
//存到items
|
|
QJsonArray params;
|
|
params.append(w->Param1());
|
|
params.append(w->Param2());
|
|
params.append(w->Param3());
|
|
params.append(w->Param4());
|
|
params.append(w->Coord().Lat());
|
|
params.append(w->Coord().Lng());
|
|
params.append(w->Alt());
|
|
|
|
//可能有点问题
|
|
QJsonObject item;
|
|
|
|
//如果这个点是指令，那么不会有高度信息
|
|
|
|
if(w->Command() < MAV_CMD::MAV_CMD_NAV_LAST) {
|
|
|
|
item.insert("AMSLAltAboveTerrain",w->Alt());
|
|
item.insert("Altitude",w->Alt());
|
|
item.insert("AltitudeMode",2);
|
|
}
|
|
|
|
item.insert("autoContinue",w->AutoContinue()?true:false);
|
|
item.insert("command",w->Command());
|
|
item.insert("doJumpId",w->Number());
|
|
item.insert("frame",w->Frame());
|
|
item.insert("params",params);
|
|
item.insert("type",w->MissionType());
|
|
|
|
items.append(item);
|
|
}
|
|
|
|
if(w->Number() == 1)
|
|
{
|
|
plannedHomePosition.append(w->Coord().Lat());
|
|
plannedHomePosition.append(w->Coord().Lng());
|
|
plannedHomePosition.append(w->Alt());
|
|
}
|
|
}
|
|
}
|
|
|
|
mission.insert("cruiseSpeed",2);
|
|
mission.insert("firmwareType",0);
|
|
mission.insert("hoverSpeed",2);
|
|
mission.insert("items",items);
|
|
mission.insert("plannedHomePosition",plannedHomePosition);
|
|
mission.insert("vehicleType",1);
|
|
mission.insert("version",2);
|
|
}
|
|
|
|
//rallyPoints节点写入
|
|
{
|
|
QJsonArray points;
|
|
rallyPoints.insert("points",points);
|
|
rallyPoints.insert("version",2);
|
|
}
|
|
|
|
//根节点写入
|
|
root.insert("fileType","Plan");
|
|
root.insert("geoFence",geoFence);
|
|
root.insert("groundStation","GCS_nf");
|
|
root.insert("mission", mission);
|
|
root.insert("rallyPoints", rallyPoints);
|
|
root.insert("version", 1);
|
|
|
|
//设置文档
|
|
doc->setObject(root);
|
|
|
|
//如果没有后缀名，那就追加
|
|
if(path.right(5) != ".plan")
|
|
{
|
|
path.append(".plan");
|
|
}
|
|
|
|
QFile file(path);
|
|
if(!file.open(QIODevice::ReadWrite|QFile::Truncate)) {
|
|
qDebug() << "File open error";
|
|
}
|
|
|
|
file.write(doc->toJson());
|
|
file.close();
|
|
}
|
|
|
|
void OPMapWidget::WPDownload(void)
|
|
{
|
|
//请求读取航点
|
|
qDebug() << "WPDownload";
|
|
|
|
WPDeleteAll();
|
|
|
|
int sysid = 0;
|
|
int compid = 0;
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
UAVItem *u = qgraphicsitem_cast<UAVItem *>(i);
|
|
if (u) {
|
|
if(u->Select() == true)
|
|
{
|
|
sysid = u->SysID();
|
|
compid = u->CompID();
|
|
|
|
emit signal_WPDownload(sysid,compid,currentGroup);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OPMapWidget::WPUpload(void)
|
|
{
|
|
//发送第一个
|
|
QList<mapcontrol::WayPointItem *> list;
|
|
//先发送一个清空指令
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w) {
|
|
list.append(w);
|
|
w->emitWPProperty();
|
|
|
|
//w->setVisible(false);
|
|
}
|
|
}
|
|
|
|
if(list.size() <= 0)
|
|
{
|
|
emit showMessage("请先载入任务航线");
|
|
return;
|
|
}
|
|
|
|
|
|
emit showMessage(tr("开始上传航点，总数%1").arg(list.size()));
|
|
|
|
//选择当前ID号
|
|
|
|
int sysid = 0;
|
|
int compid = 0;
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
UAVItem *u = qgraphicsitem_cast<UAVItem *>(i);
|
|
if (u) {
|
|
if(u->Select() == true)
|
|
{
|
|
sysid = u->SysID();
|
|
compid = u->CompID();
|
|
|
|
//如果有选中，那么就发送，选中几个就发几个
|
|
emit signal_WPUpload(sysid,compid,list.size(),currentGroup);//直接发送全部航点到
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//飞行界面收到的当前航点的消息
|
|
void OPMapWidget::groupchanged(int value)
|
|
{
|
|
//如果当前是在飞行界面，那么就下载，否则不动
|
|
|
|
if(isWPCreate == true)//编辑界面
|
|
{
|
|
|
|
}
|
|
else//飞行界面
|
|
{
|
|
/*
|
|
WPDeleteAll();
|
|
|
|
int sysid = 0;
|
|
int compid = 0;
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
UAVItem *u = qgraphicsitem_cast<UAVItem *>(i);
|
|
if (u) {
|
|
if(u->Select() == true)
|
|
{
|
|
sysid = u->SysID();
|
|
compid = u->CompID();
|
|
|
|
emit signal_WPDownload(sysid,compid,value);
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
update();
|
|
}
|
|
|
|
//编辑界面收到的组切换的消息
|
|
void OPMapWidget::WPGroup(int value)
|
|
{
|
|
currentGroup = value;
|
|
|
|
qDebug() << "group checkout" << value;
|
|
|
|
//切换当前航线，其他都隐藏，或者高亮当前
|
|
|
|
//将不是当前的全部变成灰色，当前的显示
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w) {
|
|
qDebug() << "missiontype" << w->MissionType();
|
|
if(w->MissionType() == currentGroup)
|
|
{
|
|
w->setisActive(true);
|
|
}
|
|
else
|
|
{
|
|
w->setisActive(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
//将不是当前的先全部变成灰色,当前的显示
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointLine *l = qgraphicsitem_cast<WayPointLine *>(i);
|
|
if (l) {
|
|
|
|
WayPointItem *from = qgraphicsitem_cast<WayPointItem *>(l->WPLineFrom());
|
|
WayPointItem *to = qgraphicsitem_cast<WayPointItem *>(l->WPLineTo());
|
|
|
|
if((from)||(to))
|
|
{
|
|
if(from)
|
|
{
|
|
if(from->MissionType() == currentGroup)
|
|
{
|
|
l->setisActive(true);
|
|
}
|
|
else
|
|
{
|
|
l->setisActive(false);
|
|
}
|
|
}
|
|
else if(to)
|
|
{
|
|
if(from->MissionType() == currentGroup)
|
|
{
|
|
l->setisActive(true);
|
|
}
|
|
else
|
|
{
|
|
l->setisActive(false);
|
|
}
|
|
}
|
|
else//不知道这句对不对
|
|
{
|
|
l->setisActive(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//按照当前的组生成新的航点和航线
|
|
/*
|
|
WPDeleteAll();
|
|
|
|
QMap<int,WayPointItem *> group;
|
|
|
|
group = waypointgroups.value(currentGroup);
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
update();
|
|
|
|
}
|
|
|
|
|
|
void OPMapWidget::WPSendItemOK(uint16_t seq, bool flag)
|
|
{
|
|
if(flag == true)
|
|
{
|
|
QString str;
|
|
str.append("上传航点");
|
|
str.append(QString::number(seq));
|
|
emit showMessage(str);
|
|
}
|
|
else
|
|
{
|
|
QString str;
|
|
str.append(tr("上传失败%1").arg(seq));
|
|
emit showMessage(str);
|
|
}
|
|
|
|
}
|
|
|
|
//这个有可能是其他线程运行，导致生成的航点不对,下载得到
|
|
void OPMapWidget::receivedPoint(float param1,float param2,float param3,float param4,
|
|
int32_t x,int32_t y,float z,
|
|
uint16_t seq,
|
|
uint16_t group,
|
|
uint16_t command,
|
|
uint8_t target_system,
|
|
uint8_t target_component,
|
|
uint8_t frame,
|
|
uint8_t current,
|
|
uint8_t autocontinue,
|
|
uint8_t mission_type)
|
|
{
|
|
|
|
qDebug() << "receivers Point";
|
|
// << QThread::currentThreadId();
|
|
|
|
|
|
//emit showMessage(tr("recieve way point %1").arg(seq + 1));
|
|
emit showMessage(tr("收到航点 %1").arg(seq + 1));
|
|
|
|
|
|
//qDebug() << "receivers Point" << x * 10e-8 << y * 10e-8 << 10e-8;
|
|
|
|
bool isExist = false;
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w) {
|
|
if(w->Number() == (seq+1))
|
|
{
|
|
isExist = true;
|
|
|
|
internals::PointLatLng LatLng;
|
|
|
|
LatLng.SetLat(x * 10e-8);
|
|
LatLng.SetLng(y * 10e-8);
|
|
|
|
|
|
w->SetLat(LatLng.Lat());
|
|
LatLng.SetLng(LatLng.Lng());
|
|
w->SetNumber(seq+1);
|
|
|
|
emit setWPProperty(param1,param2,param3,param4,
|
|
x,y,z,
|
|
seq+1,
|
|
group,
|
|
command,
|
|
target_system,
|
|
target_component,
|
|
frame,
|
|
current,
|
|
autocontinue,
|
|
mission_type);
|
|
|
|
|
|
w->emitWPProperty();
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!isExist)
|
|
{
|
|
|
|
internals::PointLatLng LatLng;
|
|
|
|
LatLng.SetLat(x * 10e-8);
|
|
LatLng.SetLng(y * 10e-8);
|
|
|
|
WayPointItem *Item = WPCreate(LatLng,z);
|
|
|
|
Item->SetNumber(seq+1);
|
|
|
|
emit setWPProperty(param1,param2,param3,param4,
|
|
x,y,z,
|
|
seq+1,
|
|
group,
|
|
command,
|
|
target_system,
|
|
target_component,
|
|
frame,
|
|
current,
|
|
autocontinue,
|
|
mission_type);
|
|
|
|
|
|
Item->emitWPProperty();
|
|
}
|
|
|
|
qDebug() << "Exist" << isExist;
|
|
|
|
}
|
|
|
|
|
|
|
|
void OPMapWidget::getMapTypes(void)
|
|
{
|
|
emit MapTypes(Helper::MapTypes());
|
|
}
|
|
|
|
void OPMapWidget::setMapTypes(QVariant value)
|
|
{
|
|
this->SetMapType(Helper::MapTypeFromString(value.toString()));
|
|
}
|
|
|
|
|
|
|
|
|
|
void OPMapWidget::ElevationChanged(int seq,double value)
|
|
{
|
|
QMap<int,float> Info;
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w)
|
|
{
|
|
if(!w->FollowPrevious())
|
|
Info.insert(w->Number(),w->getElevation());
|
|
}
|
|
}
|
|
if(altitudeitem)
|
|
{
|
|
altitudeitem->setElevation(Info);
|
|
}
|
|
}
|
|
|
|
void OPMapWidget::AltitudeChanged(int seq,double value)
|
|
{
|
|
QMap<int,float> Info;
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w)
|
|
{
|
|
if(!w->FollowPrevious())
|
|
Info.insert(w->Number(),w->Alt());
|
|
}
|
|
}
|
|
|
|
if(altitudeitem)
|
|
{
|
|
altitudeitem->setAltitude(Info);
|
|
}
|
|
|
|
updateMessage();
|
|
|
|
}
|
|
|
|
void OPMapWidget::setCurrentPoint(int value)
|
|
{
|
|
if(altitudeitem)
|
|
{
|
|
altitudeitem->setCurrentPoint(value);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void OPMapWidget::updateMessage(void)
|
|
{
|
|
totalDistance = 0;
|
|
|
|
|
|
WayPointItem *Last = nullptr;
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w)
|
|
{
|
|
if(Last != nullptr)
|
|
{
|
|
totalDistance += internals::PureProjection::DistanceBetweenLatLng(Last->Coord(),w->Coord()) * 10e2;
|
|
}
|
|
Last = w;
|
|
}
|
|
}
|
|
|
|
Last = nullptr;
|
|
delete Last;
|
|
|
|
emit TotalDistanceUpdate(totalDistance);
|
|
}
|
|
|
|
void OPMapWidget::find_PointNumber()
|
|
{
|
|
QList<int> nums;
|
|
nums.clear();
|
|
|
|
int number = 0;
|
|
|
|
foreach(QGraphicsItem * i, map->childItems()) {
|
|
WayPointItem *w = qgraphicsitem_cast<WayPointItem *>(i);
|
|
if (w)
|
|
{
|
|
|
|
number = w->Number();
|
|
|
|
if(w->Command() < MAV_CMD::MAV_CMD_NAV_LAST)
|
|
{
|
|
nums.append(number);
|
|
}
|
|
}
|
|
}
|
|
|
|
qDebug() << "nums" << nums;
|
|
|
|
emit PointNumber(nums);
|
|
}
|
|
|
|
|
|
}
|