1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
/****************************************************************************
*
* (c) 2017 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.
*
****************************************************************************/
#pragma once
/**
* @file AirspaceManager.h
* This file contains the interface definitions used by an airspace management implementation (AirMap).
* There are 3 base classes that must be subclassed:
* - AirspaceManager
* main manager that contains the restrictions for display. It acts as a factory to create instances of the other
* classes.
* - AirspaceVehicleManager
* this provides the multi-vehicle support - each vehicle has an instance
* - AirspaceAdvisoriesProvider
* Provides airspace advisories and restrictions. Currently only used by AirspaceManager, but
* each vehicle could have its own restrictions.
*/
#include "QGCToolbox.h"
#include "QGCLoggingCategory.h"
#include "QmlObjectListModel.h"
#include "QGCGeoBoundingCube.h"
#include <QGeoCoordinate>
#include <QObject>
#include <QString>
#include <QList>
#include <QTimer>
class AirspaceAdvisoryProvider;
class AirspaceFlightPlanProvider;
class AirspaceRestrictionProvider;
class AirspaceRulesetsProvider;
class AirspaceVehicleManager;
class AirspaceWeatherInfoProvider;
class PlanMasterController;
class QGCApplication;
class Vehicle;
Q_DECLARE_LOGGING_CATEGORY(AirspaceManagementLog)
//-----------------------------------------------------------------------------
/**
* @class AirspaceManager
* Base class for airspace management. There is one (global) instantiation of this
*/
class AirspaceManager : public QGCTool {
Q_OBJECT
public:
AirspaceManager(QGCApplication* app, QGCToolbox* toolbox);
virtual ~AirspaceManager() override;
enum AuthStatus {
Unknown,
Anonymous,
Authenticated,
Error
};
Q_ENUM(AuthStatus)
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(AirspaceFlightPlanProvider* flightPlan READ flightPlan CONSTANT)
Q_PROPERTY(bool connected READ connected NOTIFY connectedChanged)
Q_PROPERTY(QString connectStatus READ connectStatus NOTIFY connectStatusChanged)
Q_PROPERTY(AirspaceManager::AuthStatus authStatus READ authStatus NOTIFY authStatusChanged)
Q_PROPERTY(bool airspaceVisible READ airspaceVisible WRITE setAirspaceVisible NOTIFY airspaceVisibleChanged)
Q_INVOKABLE void setROI (const QGeoCoordinate& pointNW, const QGeoCoordinate& pointSE, bool planView, bool reset = false);
AirspaceWeatherInfoProvider* weatherInfo () { return _weatherProvider; }
AirspaceAdvisoryProvider* advisories () { return _advisories; }
AirspaceRulesetsProvider* ruleSets () { return _ruleSetsProvider; }
AirspaceRestrictionProvider* airspaces () { return _airspaces; }
AirspaceFlightPlanProvider* flightPlan () { return _flightPlan; }
void setToolbox(QGCToolbox* toolbox) override;
virtual QString providerName () const = 0; ///< Name of the airspace management provider (used in the UI)
virtual bool airspaceVisible () { return _airspaceVisible; }
virtual void setAirspaceVisible (bool set) { _airspaceVisible = set; emit airspaceVisibleChanged(); }
virtual bool connected () const = 0;
virtual QString connectStatus () const { return QString(); }
virtual double maxAreaOfInterest() const { return _maxAreaOfInterest; }
virtual AirspaceManager::AuthStatus authStatus () const { return Anonymous; }
/**
* Factory method to create an AirspaceVehicleManager object
*/
virtual AirspaceVehicleManager* instantiateVehicle (const Vehicle& vehicle) = 0;
signals:
void airspaceVisibleChanged ();
void connectedChanged ();
void connectStatusChanged ();
void authStatusChanged ();
protected:
/**
* Set the ROI for airspace information (restrictions shown in UI)
* @param center Center coordinate for ROI
* @param radiusMeters Radius in meters around center which is of interest
*/
virtual void _setROI (const QGCGeoBoundingCube& roi);
/**
* Factory methods
*/
virtual AirspaceRulesetsProvider* _instantiateRulesetsProvider () = 0;
virtual AirspaceWeatherInfoProvider* _instatiateAirspaceWeatherInfoProvider () = 0;
virtual AirspaceAdvisoryProvider* _instatiateAirspaceAdvisoryProvider () = 0;
virtual AirspaceRestrictionProvider* _instantiateAirspaceRestrictionProvider () = 0;
virtual AirspaceFlightPlanProvider* _instantiateAirspaceFlightPlanProvider () = 0;
protected:
bool _airspaceVisible = false;
AirspaceRulesetsProvider* _ruleSetsProvider = nullptr; ///< Rulesets
AirspaceWeatherInfoProvider* _weatherProvider = nullptr; ///< Weather info
AirspaceAdvisoryProvider* _advisories = nullptr; ///< Advisory info
AirspaceRestrictionProvider* _airspaces = nullptr; ///< Airspace info
AirspaceFlightPlanProvider* _flightPlan = nullptr; ///< Flight plan management
double _maxAreaOfInterest = 500.0; ///< Ignore area larger than 500km^2
QTimer _ruleUpdateTimer;
QTimer _updateTimer;
QGCGeoBoundingCube _roi;
private slots:
void _updateRulesTimeout ();
void _updateTimeout ();
void _rulesChanged ();
private:
void _updateToROI (bool reset = false);
};