Newer
Older
/****************************************************************************
*
* (c) 2009-2016 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
*
* QGroundControl is licensed according to the terms in the file
* COPYING.md in the root of the source code directory.
*
****************************************************************************/
#include "QGCApplication.h"
#include "SettingsManager.h"
Gus Grubba
committed
#define RESTRICTION_UPDATE_DISTANCE 500 //-- 500m threshold for updates
Gus Grubba
committed
//-----------------------------------------------------------------------------
AirMapRestrictionManager::AirMapRestrictionManager(AirMapSharedState& shared)
: _shared(shared)
{
}
Gus Grubba
committed
//-----------------------------------------------------------------------------
Gus Grubba
committed
AirMapRestrictionManager::setROI(const QGCGeoBoundingCube& roi, bool reset)
Gus Grubba
committed
{
if(qgcApp()->toolbox()->settingsManager()->airMapSettings()->enableAirspace()->rawValue().toBool()) {
//-- If first time or we've moved more than RESTRICTION_UPDATE_DISTANCE, ask for updates.
if(reset ||
(!_lastROI.isValid() || _lastROI.pointNW.distanceTo(roi.pointNW) > RESTRICTION_UPDATE_DISTANCE || _lastROI.pointSE.distanceTo(roi.pointSE) > RESTRICTION_UPDATE_DISTANCE) ||
(_polygons.count() == 0 && _circles.count() == 0)) {
//-- Limit area of interest
qCDebug(AirMapManagerLog) << "ROI Area:" << roi.area() << "km^2";
if(roi.area() < qgcApp()->toolbox()->airspaceManager()->maxAreaOfInterest()) {
_lastROI = roi;
_requestRestrictions(roi);
} else {
_polygons.clear();
_circles.clear();
}
Gus Grubba
committed
}
Gus Grubba
committed
}
}
//-----------------------------------------------------------------------------
void
AirMapRestrictionManager::_getColor(const Airspace& airspace, QColor& color, QColor& lineColor, float& lineWidth)
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
if(airspace.type() == Airspace::Type::airport) {
color = QColor(246,165,23,50);
lineColor = QColor(246,165,23,255);
lineWidth = 2.0f;
} else if(airspace.type() == Airspace::Type::controlled_airspace) {
QString classification = QString::fromStdString(airspace.details_for_controlled_airspace().airspace_classification).toUpper();
if(classification == "B") {
color = QColor(31,160,211,25);
lineColor = QColor(31,160,211,255);
lineWidth = 1.5f;
} else if(classification == "C") {
color = QColor(155,108,157,25);
lineColor = QColor(155,108,157,255);
lineWidth = 1.5f;
} else if(classification == "D") {
color = QColor(26,116,179,25);
lineColor = QColor(26,116,179,255);
lineWidth = 1.0f;
} else if(classification == "E") {
color = QColor(155,108,157,25);
lineColor = QColor(155,108,157,255);
lineWidth = 1.0f;
} else {
//-- Don't know it
qCWarning(AirMapManagerLog) << "Unknown airspace classification:" << QString::fromStdString(airspace.details_for_controlled_airspace().airspace_classification);
color = QColor(255,230,0,25);
lineColor = QColor(255,230,0,255);
lineWidth = 0.5f;
}
} else if(airspace.type() == Airspace::Type::special_use_airspace) {
color = QColor(27,90,207,38);
lineColor = QColor(27,90,207,255);
lineWidth = 1.0f;
} else if(airspace.type() == Airspace::Type::tfr) {
color = QColor(244,67,54,38);
lineColor = QColor(244,67,54,255);
lineWidth = 2.0f;
} else if(airspace.type() == Airspace::Type::wildfire) {
color = QColor(244,67,54,50);
lineColor = QColor(244,67,54,255);
lineWidth = 1.0f;
} else if(airspace.type() == Airspace::Type::park) {
color = QColor(224,18,18,25);
lineColor = QColor(224,18,18,255);
lineWidth = 1.0f;
} else if(airspace.type() == Airspace::Type::power_plant) {
color = QColor(246,165,23,25);
lineColor = QColor(246,165,23,255);
lineWidth = 1.0f;
} else if(airspace.type() == Airspace::Type::heliport) {
color = QColor(246,165,23,20);
lineColor = QColor(246,165,23,100);
lineWidth = 1.0f;
} else if(airspace.type() == Airspace::Type::prison) {
color = QColor(246,165,23,38);
lineColor = QColor(246,165,23,255);
lineWidth = 1.0f;
} else if(airspace.type() == Airspace::Type::school) {
color = QColor(246,165,23,38);
lineColor = QColor(246,165,23,255);
lineWidth = 1.0f;
} else if(airspace.type() == Airspace::Type::hospital) {
color = QColor(246,165,23,38);
lineColor = QColor(246,165,23,255);
lineWidth = 1.0f;
} else if(airspace.type() == Airspace::Type::fire) {
color = QColor(244,67,54,50);
lineColor = QColor(244,67,54,255);
lineWidth = 1.0f;
} else if(airspace.type() == Airspace::Type::emergency) {
color = QColor(246,113,23,77);
lineColor = QColor(246,113,23,255);
lineWidth = 1.0f;
} else {
//-- Don't know it
qCWarning(AirMapManagerLog) << "Unknown airspace type:" << static_cast<int>(airspace.type());
color = QColor(255,0,230,25);
lineColor = QColor(255,0,230,255);
lineWidth = 0.5f;
}
Gus Grubba
committed
//-----------------------------------------------------------------------------
void
Gus Grubba
committed
AirMapRestrictionManager::_requestRestrictions(const QGCGeoBoundingCube& roi)
{
if (!_shared.client()) {
qCDebug(AirMapManagerLog) << "No AirMap client instance. Not updating Airspace";
return;
}
if (_state != State::Idle) {
qCWarning(AirMapManagerLog) << "AirMapRestrictionManager::updateROI: state not idle";
return;
}
qCDebug(AirMapManagerLog) << "Restrictions Request (ROI Changed)";
Gus Grubba
committed
_polygons.clear();
_circles.clear();
_state = State::RetrieveItems;
Airspaces::Search::Parameters params;
Gus Grubba
committed
params.date_time = Clock::universal_time();
//-- Geometry: Polygon
Geometry::Polygon polygon;
for (const auto& qcoord : roi.polygon2D()) {
Geometry::Coordinate coord;
coord.latitude = qcoord.latitude();
coord.longitude = qcoord.longitude();
polygon.outer_ring.coordinates.push_back(coord);
}
params.geometry = Geometry(polygon);
std::weak_ptr<LifetimeChecker> isAlive(_instance);
_shared.client()->airspaces().search(params,
[this, isAlive](const Airspaces::Search::Result& result) {
if (!isAlive.lock()) return;
if (_state != State::RetrieveItems) return;
if (result) {
const std::vector<Airspace>& airspaces = result.value();
qCDebug(AirMapManagerLog)<<"Successful search. Items:" << airspaces.size();
for (const auto& airspace : airspaces) {
QColor color;
QColor lineColor;
float lineWidth;
_getColor(airspace, color, lineColor, lineWidth);
const Geometry& geometry = airspace.geometry();
switch(geometry.type()) {
case Geometry::Type::polygon: {
const Geometry::Polygon& polygon = geometry.details_for_polygon();
_addPolygonToList(polygon, QString::fromStdString(airspace.id()), color, lineColor, lineWidth);
}
break;
case Geometry::Type::multi_polygon: {
const Geometry::MultiPolygon& multiPolygon = geometry.details_for_multi_polygon();
for (const auto& polygon : multiPolygon) {
_addPolygonToList(polygon, QString::fromStdString(airspace.id()), color, lineColor, lineWidth);
}
}
break;
case Geometry::Type::point: {
const Geometry::Point& point = geometry.details_for_point();
_circles.append(new AirspaceCircularRestriction(QGeoCoordinate(point.latitude, point.longitude), 0., QString::fromStdString(airspace.id()), color, lineColor, lineWidth));
Gus Grubba
committed
case Geometry::Type::invalid: {
qWarning() << "Invalid geometry type";
}
break;
Gus Grubba
committed
qWarning() << "Unsupported geometry type: " << static_cast<int>(geometry.type());
break;
}
}
} else {
QString description = QString::fromStdString(result.error().description() ? result.error().description().get() : "");
emit error("Failed to retrieve Geofences",
QString::fromStdString(result.error().message()), description);
}
_state = State::Idle;
});
}
Gus Grubba
committed
//-----------------------------------------------------------------------------
AirMapRestrictionManager::_addPolygonToList(const airmap::Geometry::Polygon& polygon, const QString advisoryID, const QColor color, const QColor lineColor, float lineWidth)
{
QVariantList polygonArray;
for (const auto& vertex : polygon.outer_ring.coordinates) {
QGeoCoordinate coord;
if (vertex.altitude) {
coord = QGeoCoordinate(vertex.latitude, vertex.longitude, vertex.altitude.get());
} else {
coord = QGeoCoordinate(vertex.latitude, vertex.longitude);
}
polygonArray.append(QVariant::fromValue(coord));
}
_polygons.append(new AirspacePolygonRestriction(polygonArray, advisoryID, color, lineColor, lineWidth));
if (polygon.inner_rings.size() > 0) {
// no need to support those (they are rare, and in most cases, there's a more restrictive polygon filling the hole)
qCDebug(AirMapManagerLog) << "Polygon with holes. Size: "<<polygon.inner_rings.size();
}
}