From f15226ae4cc353a4ecb9675135e1c34ba47cb130 Mon Sep 17 00:00:00 2001 From: Gus Grubba Date: Tue, 30 Jan 2018 02:16:43 -0500 Subject: [PATCH] An rather unfruitful attempt at consolidating Advisories and Airspaces (they are both arrays of Airspaces). No such luck as they vary wildly. In the end, I'm now exposing the restrictions (Polygons) directly (and inherently) instead of copying them. Tweaked polygon overlay colors and borders. --- src/Airmap/AirMapAdvisoryManager.cc | 28 ++++++---- src/Airmap/AirMapAdvisoryManager.h | 3 +- src/Airmap/AirMapManager.cc | 18 +++---- src/Airmap/AirMapManager.h | 4 +- src/Airmap/AirMapRestrictionManager.cc | 33 +++++++++--- src/Airmap/AirMapRestrictionManager.h | 21 +++++--- src/Airmap/AirMapRulesetsManager.cc | 2 +- src/Airmap/README.md | 2 + src/AirspaceManagement/AirspaceController.cc | 18 +++---- src/AirspaceManagement/AirspaceController.h | 7 ++- src/AirspaceManagement/AirspaceManager.cc | 51 +++++-------------- src/AirspaceManagement/AirspaceManager.h | 32 ++++-------- .../AirspaceRestrictionProvider.h | 16 +++--- src/FlightDisplay/FlightDisplayViewMap.qml | 10 ++-- 14 files changed, 118 insertions(+), 127 deletions(-) diff --git a/src/Airmap/AirMapAdvisoryManager.cc b/src/Airmap/AirMapAdvisoryManager.cc index 76e886015..2d232ffcb 100644 --- a/src/Airmap/AirMapAdvisoryManager.cc +++ b/src/Airmap/AirMapAdvisoryManager.cc @@ -8,8 +8,13 @@ ****************************************************************************/ #include "AirMapAdvisoryManager.h" +#include "AirspaceRestriction.h" #include "AirMapManager.h" +#include + +#include "airmap/airspaces.h" + #define ADVISORY_UPDATE_DISTANCE 500 //-- 500m threshold for updates using namespace airmap; @@ -25,6 +30,7 @@ AirMapAdvisory::AirMapAdvisory(QObject* parent) AirMapAdvisoryManager::AirMapAdvisoryManager(AirMapSharedState& shared, QObject *parent) : AirspaceAdvisoryProvider(parent) , _valid(false) + , _lastRadius(0.0) , _shared(shared) { } @@ -34,9 +40,10 @@ void AirMapAdvisoryManager::setROI(const QGeoCoordinate& center, double radiusMeters) { //-- If first time or we've moved more than ADVISORY_UPDATE_DISTANCE, ask for updates. - if(!_lastRoiCenter.isValid() || _lastRoiCenter.distanceTo(center) > ADVISORY_UPDATE_DISTANCE) { + if(!_lastRoiCenter.isValid() || _lastRoiCenter.distanceTo(center) > ADVISORY_UPDATE_DISTANCE || _lastRadius != radiusMeters) { + _lastRadius = radiusMeters; _lastRoiCenter = center; - _requestAdvisories(center, radiusMeters); + _requestAdvisories(); } } @@ -52,7 +59,7 @@ adv_sort(QObject* a, QObject* b) //----------------------------------------------------------------------------- void -AirMapAdvisoryManager::_requestAdvisories(const QGeoCoordinate& coordinate, double radiusMeters) +AirMapAdvisoryManager::_requestAdvisories() { qCDebug(AirMapManagerLog) << "Advisories Request"; if (!_shared.client()) { @@ -64,11 +71,14 @@ AirMapAdvisoryManager::_requestAdvisories(const QGeoCoordinate& coordinate, doub _valid = false; _airspaces.clearAndDeleteContents(); Status::GetStatus::Parameters params; - params.longitude = coordinate.longitude(); - params.latitude = coordinate.latitude(); + params.longitude = _lastRoiCenter.longitude(); + params.latitude = _lastRoiCenter.latitude(); + params.types = Airspace::Type::all; params.weather = false; - params.buffer = radiusMeters; - _shared.client()->status().get_status_by_point(params, [this, coordinate](const Status::GetStatus::Result& result) { + params.buffer = _lastRadius; + std::weak_ptr isAlive(_instance); + _shared.client()->status().get_status_by_point(params, [this, isAlive](const Status::GetStatus::Result& result) { + if (!isAlive.lock()) return; if (result) { qCDebug(AirMapManagerLog) << "Successful advisory search. Items:" << result.value().advisories.size(); _airspaceColor = (AirspaceAdvisoryProvider::AdvisoryColor)(int)result.value().advisory_color; @@ -79,10 +89,6 @@ AirMapAdvisoryManager::_requestAdvisories(const QGeoCoordinate& coordinate, doub pAdvisory->_name = QString::fromStdString(advisory.airspace.name()); pAdvisory->_type = (AirspaceAdvisory::AdvisoryType)(int)advisory.airspace.type(); pAdvisory->_color = (AirspaceAdvisoryProvider::AdvisoryColor)(int)advisory.color; - //-- TODO: Add airspace center coordinates and radius (easy to get from Json but - // I have no idea how to get it from airmap::Airspace.) - // pAdvisory->_coordinates = QGeoCoordinate( something ); - // pAdvisory->_radius = something ; _airspaces.append(pAdvisory); qCDebug(AirMapManagerLog) << "Adding advisory" << pAdvisory->name(); } diff --git a/src/Airmap/AirMapAdvisoryManager.h b/src/Airmap/AirMapAdvisoryManager.h index b6f305010..37af8400c 100644 --- a/src/Airmap/AirMapAdvisoryManager.h +++ b/src/Airmap/AirMapAdvisoryManager.h @@ -60,9 +60,10 @@ public: signals: void error (const QString& what, const QString& airmapdMessage, const QString& airmapdDetails); private: - void _requestAdvisories (const QGeoCoordinate& coordinate, double radiusMeters); + void _requestAdvisories(); private: bool _valid; + double _lastRadius; AirMapSharedState& _shared; QGeoCoordinate _lastRoiCenter; QmlObjectListModel _airspaces; diff --git a/src/Airmap/AirMapManager.cc b/src/Airmap/AirMapManager.cc index 493cdd347..e432d6516 100644 --- a/src/Airmap/AirMapManager.cc +++ b/src/Airmap/AirMapManager.cc @@ -10,10 +10,10 @@ #include "AirMapManager.h" #include "AirMapAdvisoryManager.h" #include "AirMapWeatherInfoManager.h" -#include "AirMapRestrictionManager.h" #include "AirMapRulesetsManager.h" #include "AirMapSettings.h" #include "AirMapTelemetry.h" +#include "AirMapRestrictionManager.h" #include "AirMapTrafficMonitor.h" #include "AirMapVehicleManager.h" @@ -112,14 +112,6 @@ AirMapManager::instantiateVehicle(const Vehicle& vehicle) return manager; } -AirspaceRestrictionProvider* -AirMapManager::instantiateRestrictionProvider() -{ - AirMapRestrictionManager* restrictionManager = new AirMapRestrictionManager(_shared); - connect(restrictionManager, &AirMapRestrictionManager::error, this, &AirMapManager::_error); - return restrictionManager; -} - AirspaceRulesetsProvider* AirMapManager::instantiateRulesetsProvider() { @@ -143,3 +135,11 @@ AirMapManager::instatiateAirspaceAdvisoryProvider() connect(advisories, &AirMapAdvisoryManager::error, this, &AirMapManager::_error); return advisories; } + +AirspaceRestrictionProvider* +AirMapManager::instantiateAirspaceRestrictionProvider() +{ + AirMapRestrictionManager* airspaces = new AirMapRestrictionManager(_shared); + connect(airspaces, &AirMapRestrictionManager::error, this, &AirMapManager::_error); + return airspaces; +} diff --git a/src/Airmap/AirMapManager.h b/src/Airmap/AirMapManager.h index cea6af5de..81d84e991 100644 --- a/src/Airmap/AirMapManager.h +++ b/src/Airmap/AirMapManager.h @@ -20,10 +20,10 @@ class QGCToolbox; class AirspaceVehicleManager; -class AirspaceRestrictionProvider; class AirspaceRulesetsProvider; class AirspaceWeatherInfoProvider; class AirspaceAdvisoryProvider; +class AirspaceRestrictionProvider; Q_DECLARE_LOGGING_CATEGORY(AirMapManagerLog) @@ -44,10 +44,10 @@ public: void setToolbox (QGCToolbox* toolbox) override; AirspaceVehicleManager* instantiateVehicle (const Vehicle& vehicle) override; - AirspaceRestrictionProvider* instantiateRestrictionProvider () override; AirspaceRulesetsProvider* instantiateRulesetsProvider () override; AirspaceWeatherInfoProvider* instatiateAirspaceWeatherInfoProvider () override; AirspaceAdvisoryProvider* instatiateAirspaceAdvisoryProvider () override; + AirspaceRestrictionProvider* instantiateAirspaceRestrictionProvider () override; QString name () const override { return "AirMap"; } diff --git a/src/Airmap/AirMapRestrictionManager.cc b/src/Airmap/AirMapRestrictionManager.cc index db6432b49..777f61160 100644 --- a/src/Airmap/AirMapRestrictionManager.cc +++ b/src/Airmap/AirMapRestrictionManager.cc @@ -13,15 +13,32 @@ #include "airmap/airspaces.h" +#define RESTRICTION_UPDATE_DISTANCE 500 //-- 500m threshold for updates + using namespace airmap; +//----------------------------------------------------------------------------- AirMapRestrictionManager::AirMapRestrictionManager(AirMapSharedState& shared) : _shared(shared) + , _lastRadius(0.0) { } +//----------------------------------------------------------------------------- void AirMapRestrictionManager::setROI(const QGeoCoordinate& center, double radiusMeters) +{ + //-- If first time or we've moved more than ADVISORY_UPDATE_DISTANCE, ask for updates. + if(!_lastRoiCenter.isValid() || _lastRoiCenter.distanceTo(center) > RESTRICTION_UPDATE_DISTANCE || _lastRadius != radiusMeters) { + _lastRadius = radiusMeters; + _lastRoiCenter = center; + _requestRestrictions(center, radiusMeters); + } +} + +//----------------------------------------------------------------------------- +void +AirMapRestrictionManager::_requestRestrictions(const QGeoCoordinate& center, double radiusMeters) { if (!_shared.client()) { qCDebug(AirMapManagerLog) << "No AirMap client instance. Not updating Airspace"; @@ -32,8 +49,8 @@ AirMapRestrictionManager::setROI(const QGeoCoordinate& center, double radiusMete return; } qCDebug(AirMapManagerLog) << "setting ROI"; - _polygonList.clear(); - _circleList.clear(); + _polygons.clear(); + _circles.clear(); _state = State::RetrieveItems; Airspaces::Search::Parameters params; params.geometry = Geometry::point(center.latitude(), center.longitude()); @@ -52,19 +69,19 @@ AirMapRestrictionManager::setROI(const QGeoCoordinate& center, double radiusMete switch(geometry.type()) { case Geometry::Type::polygon: { const Geometry::Polygon& polygon = geometry.details_for_polygon(); - _addPolygonToList(polygon, _polygonList); + _addPolygonToList(polygon); } break; case Geometry::Type::multi_polygon: { const Geometry::MultiPolygon& multiPolygon = geometry.details_for_multi_polygon(); for (const auto& polygon : multiPolygon) { - _addPolygonToList(polygon, _polygonList); + _addPolygonToList(polygon); } } break; case Geometry::Type::point: { const Geometry::Point& point = geometry.details_for_point(); - _circleList.append(new AirspaceCircularRestriction(QGeoCoordinate(point.latitude, point.longitude), 0.)); + _circles.append(new AirspaceCircularRestriction(QGeoCoordinate(point.latitude, point.longitude), 0.)); // TODO: radius??? } break; @@ -78,13 +95,13 @@ AirMapRestrictionManager::setROI(const QGeoCoordinate& center, double radiusMete emit error("Failed to retrieve Geofences", QString::fromStdString(result.error().message()), description); } - emit requestDone(true); _state = State::Idle; }); } +//----------------------------------------------------------------------------- void -AirMapRestrictionManager::_addPolygonToList(const airmap::Geometry::Polygon& polygon, QList& list) +AirMapRestrictionManager::_addPolygonToList(const airmap::Geometry::Polygon& polygon) { QVariantList polygonArray; for (const auto& vertex : polygon.outer_ring.coordinates) { @@ -96,7 +113,7 @@ AirMapRestrictionManager::_addPolygonToList(const airmap::Geometry::Polygon& pol } polygonArray.append(QVariant::fromValue(coord)); } - list.append(new AirspacePolygonRestriction(polygonArray)); + _polygons.append(new AirspacePolygonRestriction(polygonArray)); 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: "<& list); + void _requestRestrictions(const QGeoCoordinate& center, double radiusMeters); + void _addPolygonToList (const airmap::Geometry::Polygon& polygon); + enum class State { Idle, RetrieveItems, }; - State _state = State::Idle; - AirMapSharedState& _shared; + + AirMapSharedState& _shared; + double _lastRadius; + QGeoCoordinate _lastRoiCenter; + State _state = State::Idle; + QmlObjectListModel _polygons; + QmlObjectListModel _circles; }; diff --git a/src/Airmap/AirMapRulesetsManager.cc b/src/Airmap/AirMapRulesetsManager.cc index 927724577..2906a84f2 100644 --- a/src/Airmap/AirMapRulesetsManager.cc +++ b/src/Airmap/AirMapRulesetsManager.cc @@ -35,7 +35,7 @@ void AirMapRulesetsManager::setROI(const QGeoCoordinate& center) return; } if (_state != State::Idle) { - qCWarning(AirMapManagerLog) << "AirMapRestrictionManager::updateROI: state not idle"; + qCWarning(AirMapManagerLog) << "AirMapRulesetsManager::updateROI: state not idle"; return; } qCDebug(AirMapManagerLog) << "Setting ROI for Rulesets"; diff --git a/src/Airmap/README.md b/src/Airmap/README.md index a93d003c8..c3977d352 100644 --- a/src/Airmap/README.md +++ b/src/Airmap/README.md @@ -1,5 +1,7 @@ ## To be deleted when development is complete +* "Required" rules must be pre-selectd and cannot be unselected by the user + * AirMapRestrictionManager seems to be incomplete (if not redundant). Shouldn't we use the array of AirSpace items returned by AirMapAdvisoryManager instead? In addition to the AirSpace object, it gives you a color to use in order of importance. * Traffic monitor timeout is now set to 2 minutes following instructions from Thomas Voß. diff --git a/src/AirspaceManagement/AirspaceController.cc b/src/AirspaceManagement/AirspaceController.cc index 91397ddc1..9bc18116f 100644 --- a/src/AirspaceManagement/AirspaceController.cc +++ b/src/AirspaceManagement/AirspaceController.cc @@ -29,18 +29,6 @@ AirspaceController::setROI(QGeoCoordinate center, double radius) _manager->setROI(center, radius); } -QmlObjectListModel* -AirspaceController::polygons() -{ - return _manager->polygonRestrictions(); -} - -QmlObjectListModel* -AirspaceController::circles() -{ - return _manager->circularRestrictions(); -} - QString AirspaceController::providerName() { @@ -64,3 +52,9 @@ AirspaceController::rulesets() { return _manager->rulesets(); } + +AirspaceRestrictionProvider* +AirspaceController::airspaces() +{ + return _manager->airspaces(); +} diff --git a/src/AirspaceManagement/AirspaceController.h b/src/AirspaceManagement/AirspaceController.h index ef1b0f905..4b0ab7243 100644 --- a/src/AirspaceManagement/AirspaceController.h +++ b/src/AirspaceManagement/AirspaceController.h @@ -17,6 +17,7 @@ class QmlObjectListModel; class AirspaceWeatherInfoProvider; class AirspaceAdvisoryProvider; class AirspaceRulesetsProvider; +class AirspaceRestrictionProvider; class AirspaceController : public QObject { @@ -25,22 +26,20 @@ public: AirspaceController(QObject* parent = NULL); ~AirspaceController() = default; - Q_PROPERTY(QmlObjectListModel* polygons READ polygons CONSTANT) ///< List of AirspacePolygonRestriction objects - Q_PROPERTY(QmlObjectListModel* circles READ circles CONSTANT) ///< List of AirspaceCircularRestriction objects Q_PROPERTY(QString providerName READ providerName CONSTANT) Q_PROPERTY(AirspaceWeatherInfoProvider* weatherInfo READ weatherInfo CONSTANT) Q_PROPERTY(AirspaceAdvisoryProvider* advisories READ advisories CONSTANT) Q_PROPERTY(AirspaceRulesetsProvider* rulesets READ rulesets CONSTANT) + Q_PROPERTY(AirspaceRestrictionProvider* airspaces READ airspaces CONSTANT) Q_PROPERTY(bool airspaceVisible READ airspaceVisible WRITE setairspaceVisible NOTIFY airspaceVisibleChanged) Q_INVOKABLE void setROI (QGeoCoordinate center, double radius); - QmlObjectListModel* polygons (); - QmlObjectListModel* circles (); QString providerName (); AirspaceWeatherInfoProvider* weatherInfo (); AirspaceAdvisoryProvider* advisories (); AirspaceRulesetsProvider* rulesets (); + AirspaceRestrictionProvider* airspaces (); bool airspaceVisible () { return _airspaceVisible; } void setairspaceVisible (bool set) { _airspaceVisible = set; emit airspaceVisibleChanged(); } diff --git a/src/AirspaceManagement/AirspaceManager.cc b/src/AirspaceManagement/AirspaceManager.cc index 1a94762e9..4ca953306 100644 --- a/src/AirspaceManagement/AirspaceManager.cc +++ b/src/AirspaceManagement/AirspaceManager.cc @@ -12,8 +12,8 @@ #include "AirspaceWeatherInfoProvider.h" #include "AirspaceAdvisoryProvider.h" #include "AirspaceRestriction.h" -#include "AirspaceRestrictionProvider.h" #include "AirspaceRulesetsProvider.h" +#include "AirspaceRestrictionProvider.h" #include "AirspaceVehicleManager.h" #include "AirspaceController.h" @@ -28,12 +28,13 @@ AirspaceManager::AirspaceManager(QGCApplication* app, QGCToolbox* toolbox) _roiUpdateTimer.setInterval(2000); _roiUpdateTimer.setSingleShot(true); connect(&_roiUpdateTimer, &QTimer::timeout, this, &AirspaceManager::_updateToROI); - qmlRegisterUncreatableType ("QGroundControl", 1, 0, "AirspaceAuthorization", "Reference only"); - qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceController", "Reference only"); - qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceWeatherInfoProvider","Reference only"); - qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceAdvisoryProvider", "Reference only"); - qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceRule", "Reference only"); - qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceRulesetsProvider", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl", 1, 0, "AirspaceAuthorization", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceController", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceWeatherInfoProvider", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceAdvisoryProvider", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceRule", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceRulesetsProvider", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceRestrictionProvider", "Reference only"); } AirspaceManager::~AirspaceManager() @@ -47,24 +48,19 @@ AirspaceManager::~AirspaceManager() if(_rulesetsProvider) { delete _rulesetsProvider; } - if (_restrictionsProvider) { - delete _restrictionsProvider; + if(_airspaces) { + delete _airspaces; } - _polygonRestrictions.clearAndDeleteContents(); - _circleRestrictions.clearAndDeleteContents(); } void AirspaceManager::setToolbox(QGCToolbox* toolbox) { QGCTool::setToolbox(toolbox); // We should not call virtual methods in the constructor, so we instantiate the restriction provider here - _restrictionsProvider = instantiateRestrictionProvider(); - if (_restrictionsProvider) { - connect(_restrictionsProvider, &AirspaceRestrictionProvider::requestDone, this, &AirspaceManager::_restrictionsUpdated); - } _rulesetsProvider = instantiateRulesetsProvider(); _weatherProvider = instatiateAirspaceWeatherInfoProvider(); _advisories = instatiateAirspaceAdvisoryProvider(); + _airspaces = instantiateAirspaceRestrictionProvider(); } void AirspaceManager::setROI(const QGeoCoordinate& center, double radiusMeters) @@ -76,8 +72,8 @@ void AirspaceManager::setROI(const QGeoCoordinate& center, double radiusMeters) void AirspaceManager::_updateToROI() { - if (_restrictionsProvider) { - _restrictionsProvider->setROI(_roiCenter, _roiRadius); + if(_airspaces) { + _airspaces->setROI(_roiCenter, _roiRadius); } if(_rulesetsProvider) { _rulesetsProvider->setROI(_roiCenter); @@ -89,24 +85,3 @@ void AirspaceManager::_updateToROI() _advisories->setROI(_roiCenter, _roiRadius); } } - -void AirspaceManager::_restrictionsUpdated(bool success) -{ - _polygonRestrictions.clearAndDeleteContents(); - _circleRestrictions.clearAndDeleteContents(); - if (success) { - for (const auto& circle : _restrictionsProvider->circles()) { - _circleRestrictions.append(circle); - } - for (const auto& polygon : _restrictionsProvider->polygons()) { - _polygonRestrictions.append(polygon); - } - } else { - // TODO: show error? - } -} - -void AirspaceManager::_rulessetsUpdated(bool) -{ - -} diff --git a/src/AirspaceManagement/AirspaceManager.h b/src/AirspaceManagement/AirspaceManager.h index 349298402..93e7f3e62 100644 --- a/src/AirspaceManagement/AirspaceManager.h +++ b/src/AirspaceManagement/AirspaceManager.h @@ -18,8 +18,8 @@ * classes. * - AirspaceVehicleManager * this provides the multi-vehicle support - each vehicle has an instance - * - AirspaceRestrictionProvider - * provides airspace restrictions. Currently only used by AirspaceManager, but + * - AirspaceAdvisoriesProvider + * Provides airspace advisories and restrictions. Currently only used by AirspaceManager, but * each vehicle could have its own restrictions. */ @@ -36,10 +36,10 @@ class Vehicle; class QGCApplication; class AirspaceWeatherInfoProvider; -class AirspaceRestrictionProvider; class AirspaceRulesetsProvider; class AirspaceVehicleManager; class AirspaceAdvisoryProvider; +class AirspaceRestrictionProvider; Q_DECLARE_LOGGING_CATEGORY(AirspaceManagementLog) @@ -59,11 +59,6 @@ public: */ virtual AirspaceVehicleManager* instantiateVehicle (const Vehicle& vehicle) = 0; - /** - * Factory method to create an AirspaceRestrictionProvider object - */ - virtual AirspaceRestrictionProvider* instantiateRestrictionProvider () = 0; - /** * Factory method to create an AirspaceRulesetsProvider object */ @@ -79,6 +74,11 @@ public: */ virtual AirspaceAdvisoryProvider* instatiateAirspaceAdvisoryProvider () = 0; + /** + * Factory method to create an AirspaceRestrictionProvider object + */ + virtual AirspaceRestrictionProvider* instantiateAirspaceRestrictionProvider () = 0; + /** * Set the ROI for airspace information (restrictions shown in UI) * @param center Center coordinate for ROI @@ -86,11 +86,10 @@ public: */ void setROI (const QGeoCoordinate& center, double radiusMeters); - QmlObjectListModel* polygonRestrictions () { return &_polygonRestrictions; } - QmlObjectListModel* circularRestrictions () { return &_circleRestrictions; } AirspaceWeatherInfoProvider* weatherInfo () { return _weatherProvider; } AirspaceAdvisoryProvider* advisories () { return _advisories; } AirspaceRulesetsProvider* rulesets () { return _rulesetsProvider; } + AirspaceRestrictionProvider* airspaces () { return _airspaces; } void setToolbox(QGCToolbox* toolbox) override; @@ -99,22 +98,13 @@ public: */ virtual QString name () const = 0; -protected slots: - virtual void _rulessetsUpdated (bool success); - -private slots: - void _restrictionsUpdated (bool success); - private: void _updateToROI (); - AirspaceRestrictionProvider* _restrictionsProvider = nullptr; ///< Restrictions that are shown in the UI - AirspaceRulesetsProvider* _rulesetsProvider = nullptr; ///< Restrictions that are shown in the UI + AirspaceRulesetsProvider* _rulesetsProvider = nullptr; ///< Rulesets that are shown in the UI AirspaceWeatherInfoProvider* _weatherProvider = nullptr; ///< Weather info that is shown in the UI AirspaceAdvisoryProvider* _advisories = nullptr; ///< Advisory info that is shown in the UI - - QmlObjectListModel _polygonRestrictions; ///< current polygon restrictions - QmlObjectListModel _circleRestrictions; ///< current circle restrictions + AirspaceRestrictionProvider* _airspaces = nullptr; ///< Airspace info that is shown in the UI QTimer _roiUpdateTimer; QGeoCoordinate _roiCenter; diff --git a/src/AirspaceManagement/AirspaceRestrictionProvider.h b/src/AirspaceManagement/AirspaceRestrictionProvider.h index 6e1c0828e..2b627ec8e 100644 --- a/src/AirspaceManagement/AirspaceRestrictionProvider.h +++ b/src/AirspaceManagement/AirspaceRestrictionProvider.h @@ -14,6 +14,8 @@ * Base class that queries for airspace restrictions */ +#include "QmlObjectListModel.h" + #include #include #include @@ -27,6 +29,9 @@ public: AirspaceRestrictionProvider (QObject* parent = NULL); ~AirspaceRestrictionProvider () = default; + Q_PROPERTY(QmlObjectListModel* polygons READ polygons CONSTANT) + Q_PROPERTY(QmlObjectListModel* circles READ circles CONSTANT) + /** * Set region of interest that should be queried. When finished, the requestDone() signal will be emmited. * @param center Center coordinate for ROI @@ -34,13 +39,6 @@ public: */ virtual void setROI (const QGeoCoordinate& center, double radiusMeters) = 0; - const QList& polygons() const { return _polygonList; } - const QList& circles () const { return _circleList; } - -signals: - void requestDone (bool success); - -protected: - QList _polygonList; - QList _circleList; + virtual QmlObjectListModel* polygons () = 0; ///< List of AirspacePolygonRestriction objects + virtual QmlObjectListModel* circles () = 0; ///< List of AirspaceCircularRestriction objects }; diff --git a/src/FlightDisplay/FlightDisplayViewMap.qml b/src/FlightDisplay/FlightDisplayViewMap.qml index ca8517263..00acc809b 100644 --- a/src/FlightDisplay/FlightDisplayViewMap.qml +++ b/src/FlightDisplay/FlightDisplayViewMap.qml @@ -331,21 +331,21 @@ FlightMap { // Airspace overlap support MapItemView { - model: _airspaceManagement && _activeVehicle.airspaceController.airspaceVisible ? _activeVehicle.airspaceController.circles : [] + model: _airspaceManagement && _activeVehicle.airspaceController.airspaceVisible ? _activeVehicle.airspaceController.airspaces.circles : [] delegate: MapCircle { center: object.center radius: object.radius + color: Qt.rgba(0.94, 0.87, 0, 0.15) border.color: Qt.rgba(1,1,1,0.85) - color: Qt.rgba(0.94,0.87,0,0.25) } } MapItemView { - model: _airspaceManagement && _activeVehicle.airspaceController.airspaceVisible ? _activeVehicle.airspaceController.polygons : [] + model: _airspaceManagement && _activeVehicle.airspaceController.airspaceVisible ? _activeVehicle.airspaceController.airspaces.polygons : [] delegate: MapPolygon { - border.color: Qt.rgba(1,1,1,0.85) - color: Qt.rgba(0.94,0.87,0,0.25) path: object.polygon + color: Qt.rgba(0.94, 0.87, 0, 0.15) + border.color: Qt.rgba(1,1,1,0.85) } } } -- 2.22.0