adding

qgroundcontrol.pro

@@ -408,16 +408,19 @@ HEADERS += \
     src/comm/MavlinkMessagesTimer.h \
     src/GPS/Drivers/src/base_station.h \
     src/Wima/WimaArea.h \
-    src/Wima/WimaGOperationArea.h \
     src/Wima/WimaServiceArea.h \
-    src/Wima/WimaVCorridor.h \
     src/Wima/WimaTrackerPolyline.h \
     src/Wima/WimaController.h \
     src/Wima/WimaVehicle.h \
     src/Wima/WimaDataContainer.h \
     src/Wima/WimaPlaner.h \
     src/Wima/WimaPlaner.h \
-    src/Wima/WimaMeasurementArea.h
+    src/Wima/WimaMeasurementArea.h \
+    src/Wima/WimaCorridor.h \
+    src/Wima/WimaAreaData.h \
+    src/Wima/WimaServiceAreaData.h \
+    src/Wima/WimaCorridorData.h \
+    src/Wima/WimaMeasurementAreaData.h
 SOURCES += \
     src/api/QGCCorePlugin.cc \
     src/api/QGCOptions.cc \
@@ -426,13 +429,17 @@ SOURCES += \
     src/comm/MavlinkMessagesTimer.cc \
     src/Wima/WimaArea.cc \
     src/Wima/WimaServiceArea.cc \
-    src/Wima/WimaVCorridor.cc \
     src/Wima/WimaTrackerPolyline.cc \
     src/Wima/WimaController.cc \
     src/Wima/WimaVehicle.cc \
     src/Wima/WimaDataContainer.cc \
     src/Wima/WimaPlaner.cc \
-    src/Wima/WimaMeasurementArea.cc
+    src/Wima/WimaMeasurementArea.cc \
+    src/Wima/WimaCorridor.cc \
+    src/Wima/WimaAreaData.cc \
+    src/Wima/WimaServiceAreaData.cc \
+    src/Wima/WimaCorridorData.cpp \
+    src/Wima/WimaMeasurementAreaDataareadata.cc
 
 #
 # Unit Test specific configuration goes here (requires full debug build with all plugins)

src/Wima/WimaArea.cc

@@ -677,7 +677,7 @@ bool WimaArea::loadFromJson(const QJsonObject &json, QString& errorString)
 void WimaArea::update(const WimaArea &area)
 {
     this->QGCMapPolygon::update(area);
-    this->setMaxAltitude(area.maxAltitude());displays
+    this->setMaxAltitude(area.maxAltitude());
 }
 
 /*!

src/Wima/WimaArea.h

@@ -80,7 +80,7 @@ public:
     static bool            dijkstraPath         (const QGeoCoordinate& c1, const QGeoCoordinate& c2,
                                                  const WimaArea& area, QList<QGeoCoordinate>& dijkstraPath);
     /// @return true if the polygon is self intersecting
-    static bool            isSelfIntersecting   (const WimaArea& area);
+    static bool            isSelfIntersectin contrast to \c WimaAreaing   (const WimaArea& area);
            bool            isSelfIntersecting   ();
 
     // Friends

src/Wima/WimaAreaData.cc

+#include "WimaAreaData.h"
+
+WimaAreaData::WimaAreaData(QObject *parent) : QObject(parent)
+{
+    _maxAltitude = 0;
+}
+
+WimaAreaData::WimaAreaData(WimaAreaData &other, QObject *parent)
+    : QObject (parent)
+    , _maxAltitude(other.maxAltitude())
+{
+    setPath(other.path());
+}
+
+/*!
+ * \fn double WimaAreaData::maxAltitude()
+ *
+ * Returns the maximum altitude at which vehicles are allowed to fly.
+ */
+double WimaAreaData::maxAltitude() const
+{
+    return _maxAltitude;
+}
+
+/*!
+ * \fn double WimaAreaData::maxAltitude()
+ *
+ * Returns the path (vertex list defining the \l {Simple Polygon}).
+ */
+const QList<QGeoCoordinate> &WimaAreaData::path() const
+{
+    return _path;
+}
+
+/*!
+ * \fn void WimaAreaData::setMaxAltitude(double maxAltitude)
+ *
+ * Sets the maximum altitude member to \a maxAltitude and emits the \c maxAltitudeChanged() signal if
+ * \a maxAltitude differs from the members value.
+ */
+void WimaAreaData::setMaxAltitude(double maxAltitude)
+{
+    if ( !qFuzzyCompare(_maxAltitude, maxAltitude) ) {
+        _maxAltitude = maxAltitude;
+
+        emit maxAltitudeChanged(_maxAltitude);
+    }
+}
+
+/*!
+ * \fn void WimaAreaData::setPath(const QList<QGeoCoordinate> &coordinateList)
+ *
+ * Sets the path member to \a coordinateList by copying all entries of \a coordinateList.
+ * Emits the \c pathChanged() signal.
+ */
+void WimaAreaData::setPath(const QList<QGeoCoordinate> &coordinateList)
+{
+    _path.clear();
+
+    // copy all coordinates to _path
+    for(int i = 0; i < coordinateList.size(); i++) {
+        _path.append(coordinateList.value(i));
+    }
+
+    emit pathChanged(_path);
+}
+
+/*!
+ * \class WimaArea::WimaAreaData
+ * \brief Class to store and exchange data of a \c WimaArea Object.
+ * Class to store and exchange data of a \c WimaArea Object. In contrast to \c WimaArea this class
+ * does not provied any interface to a grafical user interface, neiter it uses the QGC Fact System.
+ * It is designed to exchange data between the \c WimaPlaner and the \c WimaController class. And it
+ * is the base class for any derived data objects
+ *
+ * \sa WimaArea
+ */

src/Wima/WimaAreaData.h

+#pragma once
+
+#include <QObject>
+
+#include "QGeoCoordinate"
+
+class WimaAreaData : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit WimaAreaData(QObject *parent = nullptr);
+    explicit WimaAreaData(WimaAreaData &other, QObject *parent = nullptr);
+
+    double                       maxAltitude() const;
+    const QList<QGeoCoordinate>& path() const;
+
+signals:
+    void maxAltitudeChanged(double maxAltitude);
+    void pathChanged(const QList<QGeoCoordinate>& coordinateList);
+
+
+public slots:
+    void setMaxAltitude(double maxAltitude);
+    void setPath(const QList<QGeoCoordinate>& coordinateList);
+
+private:
+    // see WimaArea.h for explanation
+    double                  _maxAltitude;
+    QList<QGeoCoordinate>   _path;
+};
+

src/Wima/WimaController.cc

-#include "WimaController.h"
+#include "WimaController.h"
 
 const char* WimaController::wimaFileExtension   = "wima";
 const char* WimaController::areaItemsName       = "AreaItems";
@@ -43,11 +43,6 @@ QGeoCoordinate WimaController::joinedAreaCenter() const
     return _joinedArea.center();
 }
 
-QGCMapPolygon WimaController::joinedArea() const
-{
-    return _joinedArea;
-}
-
 void WimaController::setMasterController(PlanMasterController *masterC)
 {
     _masterController = masterC;

src/Wima/WimaController.h

@@ -7,7 +7,7 @@
 #include "WimaArea.h"
 #include "WimaMeasurementArea.h"
 #include "WimaServiceArea.h"
-#include "WimaVCorridor.h"
+#include "WimaCorridor.h"
 #include "WimaDataContainer.h"
 
 #include "PlanMasterController.h"
@@ -37,8 +37,8 @@ public:
     Q_PROPERTY(QStringList              saveNameFilters     READ saveNameFilters                                        CONSTANT)
     Q_PROPERTY(QString                  fileExtension       READ fileExtension                                          CONSTANT)
     Q_PROPERTY(QGeoCoordinate           joinedAreaCenter    READ joinedAreaCenter                                       CONSTANT)
-    Q_PROPERTY(WimaArea                 joinedArea          READ joinedArea                                             NOTIFY joinedAreaChanged)
-    Q_PROPERTY(WimaDataContainer*       dataContainer                                   WRITE setDataContainer          NOTIFY dataContainerChanged)
+    Q_PROPERTY(QGCMapPolygon            joinedArea          READ joinedArea                                             NOTIFY joinedAreaChanged)
+    Q_PROPERTY(WimaDataContainer*       dataContainer       READ dataContainer           WRITE setDataContainer          NOTIFY dataContainerChanged)
     Q_PROPERTY(bool                     readyForSaveSend    READ readyForSaveSend                                       NOTIFY readyForSaveSendChanged)
 
 
@@ -51,7 +51,8 @@ public:
     QStringList                 saveNameFilters        (void) const;
     QString                     fileExtension          (void) const    { return wimaFileExtension; }
     QGeoCoordinate              joinedAreaCenter       (void) const;
-    QGCMapPolygon joinedArea(void) const;
+    QGCMapPolygon               joinedArea             (void) const;
+    WimaDataContainer*          dataContainer          (void) const;
     bool                        readyForSaveSend       (void) const    { return _readyForSaveSend; }
 
 
@@ -92,6 +93,7 @@ signals:
     void currentFileChanged             ();
     void dataContainerChanged           ();
     void readyForSaveSendChanged        (bool ready);
+    void joinedAreaChanged              ();
 
 private slots:
     void pullFromContainer          ();

src/Wima/WimaVCorridor.cc → src/Wima/WimaCorridor.cc

-#include "WimaVCorridor.h"
+#include "WimaCorridor.h"
 
-const char* WimaVCorridor::wimaVCorridorName = "Corridor";
+const char* WimaCorridor::WimaCorridorName = "Corridor";
 
 
 
-WimaVCorridor::WimaVCorridor(QObject *parent)
+WimaCorridor::WimaCorridor(QObject *parent)
     : WimaArea (parent)
 {
     init();
 }
 
-WimaVCorridor::WimaVCorridor(const WimaVCorridor &other, QObject *parent)
+WimaCorridor::WimaCorridor(const WimaCorridor &other, QObject *parent)
     : WimaArea (other, parent)
 {
     init();
 }
 
-void WimaVCorridor::saveToJson(QJsonObject &json)
+void WimaCorridor::saveToJson(QJsonObject &json)
 {
     this->WimaArea::saveToJson(json);
-    json[areaTypeName] = wimaVCorridorName;
+    json[areaTypeName] = WimaCorridorName;
 }
 
-bool WimaVCorridor::loadFromJson(const QJsonObject &json, QString &errorString)
+bool WimaCorridor::loadFromJson(const QJsonObject &json, QString &errorString)
 {
     if ( this->WimaArea::loadFromJson(json, errorString)) {
         bool retVal = true;
@@ -34,24 +34,30 @@ bool WimaVCorridor::loadFromJson(const QJsonObject &json, QString &errorString)
     }
 }
 
-void WimaVCorridor::update(const WimaVCorridor &area)
+void WimaCorridor::update(const WimaCorridor &area)
 {
     this->WimaArea::update(area);
 }
 
-void WimaVCorridor::init()
+void WimaCorridor::init()
 {
-    this->setObjectName(wimaVCorridorName);
+    this->setObjectName(WimaCorridorName);
 }
 
-void print(const WimaVCorridor &area)
+void print(const WimaCorridor &area)
 {
     QString message;
     print(area, message);
     qWarning() << message;
 }
 
-void print(const WimaVCorridor &area, QString &outputString)
+void print(const WimaCorridor &area, QString &outputString)
 {
     print(static_cast<const WimaArea&>(area), outputString);
 }
+
+
+/*!
+  \class WimaCorridor
+  \brief Corridor (derived from \c WimaArea) connecting the \c WimaMeasurementArea and the \c WimaServiceArea.
+*/

src/Wima/WimaVCorridor.h → src/Wima/WimaCorridor.h

@@ -3,37 +3,35 @@
 #include <QObject>
 #include "WimaArea.h"
 #include "WimaServiceArea.h"
-#include "WimaGOperationArea.h"
+#include "WimaMeasurementArea.h"
 
-class WimaVCorridor : public WimaArea
+class WimaCorridor : public WimaArea
 {
     Q_OBJECT
 public:
-    WimaVCorridor(QObject* parent = nullptr);
-    WimaVCorridor(const WimaVCorridor& other, QObject* parent = nullptr);
+    WimaCorridor(QObject* parent = nullptr);
+    WimaCorridor(const WimaCorridor& other, QObject* parent = nullptr);
 
     // Overrides from WimaPolygon
-    QString         mapVisualQML    (void) const { return "WimaVCorridorMapVisual.qml";}
-    QString         editorQML       (void) const { return "WimaVCorridorEditor.qml";}
+    QString         mapVisualQML    (void) const { return "WimaCorridorMapVisual.qml";}
+    QString         editorQML       (void) const { return "WimaCorridorEditor.qml";}
 
     // Methodes
     void                saveToJson     (QJsonObject& json);
     bool                loadFromJson   (const QJsonObject& json, QString& errorString);
 
     // static Members
-    static const char* wimaVCorridorName;
+    static const char* WimaCorridorName;
 
     // Friends
-    friend void print(const WimaVCorridor& area, QString& outputString);
-    friend void print(const WimaVCorridor& area);
+    friend void print(const WimaCorridor& area, QString& outputString);
+    friend void print(const WimaCorridor& area);
 
 signals:
-    void serviceAreaChanged (WimaServiceArea* serviceArea);
-    void opAreaChanged      (WimaGOperationArea* opArea);
 
 public slots:
     /// Updates this with data from area
-    void update(const WimaVCorridor& area);
+    void update(const WimaCorridor& area);
 
 private:
     void init();

src/Wima/WimaCorridorData.cpp

+#include "WimaCorridorData.h"
+
+
+WimaCorridorData::WimaCorridorData(QObject *parent)
+    :WimaAreaData (parent)
+{
+
+}
+
+WimaCorridorData::WimaCorridorData(WimaCorridorData &other, QObject *parent)
+    : WimaAreaData (other, parent)
+{
+
+}
+
+/*!
+ * \class WimaAreaData::WimaCorridorData
+ * \brief Class to store and exchange data of a \c WimaCorridorData Object.
+ * Class to store and exchange data of a \c WimaCorridor Object. In contrast to \c WimaCorridor this class
+ * does not provied any interface to a grafical user interface, neiter it uses the QGC Fact System.
+ * It is designed to exchange data between the \c WimaPlaner and the \c WimaController class. And it
+ * is the derived from WimaAreaData.
+ *
+ * \sa WimaCorridor, WimaAreaData
+ */

src/Wima/WimaCorridorData.h

+#pragma once
+
+#include <QObject>
+
+#include "WimaAreaData.h"
+#include "QGeoCoordinate"
+
+class WimaCorridorData : public WimaAreaData
+{
+    Q_OBJECT
+
+public:
+    explicit WimaCorridorData(QObject *parent = nullptr);
+    explicit WimaCorridorData(WimaCorridorData &other, QObject *parent = nullptr);
+
+signals:
+
+public slots:
+
+private:
+};
+

src/Wima/WimaDataContainer.cc

@@ -19,7 +19,7 @@ void WimaDataContainer::setJoinedArea(const WimaArea *joinedArea)
     }
 }
 
-void WimaDataContainer::setOpArea(const WimaGOperationArea *opArea)
+void WimaDataContainer::setOpArea(const WimaMeasurementArea *opArea)
 {
     if (_opArea != opArea)  {
         _opArea = opArea;
@@ -37,7 +37,7 @@ void WimaDataContainer::setSerArea(const WimaServiceArea *serArea)
     }
 }
 
-void WimaDataContainer::setCorridor(const WimaVCorridor *corridor)
+void WimaDataContainer::setCorridor(const WimaCorridor *corridor)
 {
     if (_corridor != corridor)  {
         _corridor = corridor;

src/Wima/WimaDataContainer.h

@@ -5,9 +5,9 @@
 #include "QmlObjectListModel.h"
 
 #include "WimaArea.h"
-#include "WimaGOperationArea.h"
+#include "WimaMeasurementArea.h"
 #include "WimaServiceArea.h"
-#include "WimaVCorridor.h"
+#include "WimaCorridor.h"
 
 class WimaDataContainer : public QObject
 {
@@ -18,30 +18,30 @@ public:
     WimaDataContainer(WimaDataContainer &other) = delete;
 
     const WimaArea *             joinedArea  (void) { return _joinedArea; }
-    const WimaGOperationArea *   opArea      (void) { return _opArea; }
+    const WimaMeasurementArea *   opArea      (void) { return _opArea; }
     const WimaServiceArea *      serArea     (void) { return _serArea; }
-    const WimaVCorridor *        corridor    (void) { return _corridor; }
+    const WimaCorridor *        corridor    (void) { return _corridor; }
     const QmlObjectListModel *   visualItems (void) { return _visualItems; }
 
 signals:
     void joinedAreaChanged  (const WimaArea             *area);
-    void opAreaChanged      (const WimaGOperationArea   *area);
+    void opAreaChanged      (const WimaMeasurementArea   *area);
     void serAreaChanged     (const WimaServiceArea      *area);
-    void corridorChanged    (const WimaVCorridor        *area);
+    void corridorChanged    (const WimaCorridor        *area);
     void visualItemsChanged (const QmlObjectListModel   *area);
 
 public slots:
     void setJoinedArea      (const WimaArea             *joinedArea);
-    void setOpArea          (const WimaGOperationArea   *opArea);
+    void setOpArea          (const WimaMeasurementArea   *opArea);
     void setSerArea         (const WimaServiceArea      *serArea);
-    void setCorridor        (const WimaVCorridor        *corridor);
+    void setCorridor        (const WimaCorridor        *corridor);
     void setVisualItems     (const QmlObjectListModel   *visualItems);
 
 private:
     const WimaArea           *_joinedArea;
-    const WimaGOperationArea *_opArea;
+    const WimaMeasurementArea *_opArea;
     const WimaServiceArea    *_serArea;
-    const WimaVCorridor      *_corridor;
+    const WimaCorridor      *_corridor;
     const QmlObjectListModel *_visualItems;
 };
 

src/Wima/WimaGOperationArea.h

-#pragma once
-
-#include <QObject>
-#include "WimaArea.h"
-#include "SettingsFact.h"
-#include "WimaTrackerPolyline.h"
-#include "WimaGOperationArea.h"
-
-#include "QScopedPointer"
-
-class WimaGOperationArea : public WimaArea
-{
-    Q_OBJECT
-public:
-    WimaGOperationArea(QObject* parent = nullptr);
-    WimaGOperationArea(const WimaGOperationArea &other, QObject *parent = nullptr);
-
-    Q_PROPERTY(Fact*            bottomLayerAltitude     READ bottomLayerAltitudeFact    CONSTANT)
-    Q_PROPERTY(Fact*            numberOfLayers          READ numberOfLayersFact         CONSTANT)
-    Q_PROPERTY(Fact*            layerDistance           READ layerDistanceFact          CONSTANT)
-    Q_PROPERTY(Fact*            borderPolygonOffset     READ borderPolygonOffsetFact    CONSTANT)
-    Q_PROPERTY(QGCMapPolygon    borderPolygon           READ borderPolygon              NOTIFY borderPolygonChanged)
-
-    // Overrides from WimaPolygon
-    QString         mapVisualQML    (void) const { return "WimaGOperationAreaMapVisual.qml";}
-    QString         editorQML       (void) const { return "WimaGOperationAreaEditor.qml";}
-
-    // Property accessors
-    Fact*           bottomLayerAltitudeFact (void)          { return &_bottomLayerAltitude;}
-    Fact*           numberOfLayersFact      (void)          { return &_numberOfLayers;}
-    Fact*           layerDistanceFact       (void)          { return &_layerDistance;}
-    Fact*           borderPolygonOffsetFact (void)          { return &_borderPolygonOffset;}
-    double          bottomLayerAltitude     (void) const    { return _bottomLayerAltitude.rawValue().toDouble();}
-    int             numberOfLayers          (void) const    { return _numberOfLayers.rawValue().toInt();}
-    double          layerDistance           (void) const    { return _layerDistance.rawValue().toDouble();}
-    double          borderPolygonOffset     (void) const    { return _borderPolygonOffset.rawValue().toDouble();}
-    QGCMapPolygon   borderPolygon           (void) const    { return _borderPolygon;}
-
-    // Member Methodes
-    void saveToJson(QJsonObject& json);
-    bool loadFromJson(const QJsonObject& json, QString &errorString);
-
-    // Friends
-    friend void print(const WimaGOperationArea& area, QString outputStr);
-    friend void print(const WimaGOperationArea& area);
-
-    // Static Variables
-    static const char* settingsGroup;
-    static const char* bottomLayerAltitudeName;
-    static const char* numberOfLayersName;
-    static const char* layerDistanceName;
-    static const char* borderPolygonOffsetName;
-    static const char* wimaGOperationAreaName;
-
-signals:
-    void bottomLayerAltitudeChanged     (void);
-    void numberOfLayersChanged          (void);
-    void layerDistanceChanged           (void);
-    void polylineChanged                (void);
-    void vehicleCorridorChanged         (WimaVCorridor* corridor);
-    void borderPolygonChanged           (void);
-
-public slots:
-    /// Updates this with data from area
-    void update(const WimaGOperationArea &area);
-    void setBottomLayerAltitude (double altitude);
-    void setNumberOfLayers      (double numLayers);
-    void setLayerDistance       (double layerDistance);
-    void setBorderPolygonOffset (double offset);
-private slots:
-    void recalcBorderPolygon            (void);
-private:
-    // Member Methodes
-    void init();
-
-    // Members
-    QMap<QString, FactMetaData*> _metaDataMap;
-
-    SettingsFact            _bottomLayerAltitude;
-    SettingsFact            _numberOfLayers;
-    SettingsFact            _layerDistance;
-    SettingsFact            _borderPolygonOffset;
-
-    QGCMapPolygon           _borderPolygon;
-};
-
-

src/Wima/WimaMeasurementArea.cc

 #include "WimaMeasurementArea.h"
 
-WimaMeasurementArea::WimaMeasurementArea()
+
+const char* WimaMeasurementArea::settingsGroup =                   "OperationArea";
+const char* WimaMeasurementArea::bottomLayerAltitudeName =         "BottomLayerAltitude";
+const char* WimaMeasurementArea::numberOfLayersName =              "NumberOfLayers";
+const char* WimaMeasurementArea::layerDistanceName =               "LayerDistance";
+const char* WimaMeasurementArea::borderPolygonOffsetName =         "BorderPolygonOffset";
+const char* WimaMeasurementArea::WimaMeasurementAreaName =          "Operation Area";
+
+
+WimaMeasurementArea::WimaMeasurementArea(QObject *parent)
+  : WimaArea (parent)
+{
+    init();
+}
+
+WimaMeasurementArea::WimaMeasurementArea(const WimaMeasurementArea &other, QObject *parent)
+  : WimaArea(other, parent)
+{
+    init();
+}
+
+void WimaMeasurementArea::saveToJson(QJsonObject &json)
+{
+    this->WimaArea::saveToJson(json);
+    json[bottomLayerAltitudeName]   = _bottomLayerAltitude.rawValue().toDouble();
+    json[numberOfLayersName]        = _numberOfLayers.rawValue().toInt();
+    json[layerDistanceName]         = _layerDistance.rawValue().toDouble();
+    json[borderPolygonOffsetName]   = _borderPolygonOffset.rawValue().toDouble();
+    json[areaTypeName]              = WimaMeasurementAreaName;
+}
+
+bool WimaMeasurementArea::loadFromJson(const QJsonObject &json, QString& errorString)
 {
+    if (this->WimaArea::loadFromJson(json, errorString)) {
+        bool retVal = true;
+
+        if ( json.contains(bottomLayerAltitudeName) && json[bottomLayerAltitudeName].isDouble() ) {
+            _bottomLayerAltitude.setRawValue(json[bottomLayerAltitudeName].toDouble());
+        } else {
+            errorString.append(tr("Could not load Bottom Layer Altitude!\n"));
+            retVal = false;
+        }
+
+        if ( json.contains(numberOfLayersName) && json[numberOfLayersName].isDouble() ) {
+            _numberOfLayers.setRawValue(json[numberOfLayersName].toInt());
+        } else {
+            errorString.append(tr("Could not load Number of Layers!\n"));
+            retVal = false;
+        }
 
+        if ( json.contains(layerDistanceName) && json[layerDistanceName].isDouble() ) {
+            _layerDistance.setRawValue(json[layerDistanceName].toDouble());
+        } else {
+            errorString.append(tr("Could not load Layer Distance!\n"));
+            retVal = false;
+        }
+
+        if ( json.contains(borderPolygonOffsetName) && json[borderPolygonOffsetName].isDouble() ) {
+            _borderPolygonOffset.setRawValue(json[borderPolygonOffsetName].toDouble());
+        } else {
+            errorString.append(tr("Could not load Border Polygon Offset!\n"));
+            retVal = false;
+        }
+
+        return retVal;
+    } else {
+        return false;
+    }
 }
+
+void WimaMeasurementArea::update(const WimaMeasurementArea &area)
+{
+    this->WimaArea::update(area);
+
+    this->setBottomLayerAltitude(area.bottomLayerAltitude());
+    this->setNumberOfLayers(area.numberOfLayers());
+    this->setLayerDistance(area.layerDistance());
+    this->setBorderPolygonOffset(area.borderPolygonOffset());
+
+    recalcBorderPolygon();
+}
+
+void WimaMeasurementArea::setBottomLayerAltitude(double altitude)
+{
+
+}
+
+void print(const WimaMeasurementArea &area)
+{
+    QString message;
+    print(area, message);
+    qWarning() << message;
+}
+
+void print(const WimaMeasurementArea &area, QString outputStr)
+{
+    print(static_cast<const WimaArea&>(area), outputStr);
+    outputStr.append(QString("Bottom Layer Altitude: %1\n").arg(area._bottomLayerAltitude.rawValue().toDouble()));
+    outputStr.append(QString("Number of Layers: %1\n").arg(area._numberOfLayers.rawValue().toInt()));
+    outputStr.append(QString("Layer Distance: %1\n").arg(area._layerDistance.rawValue().toDouble()));
+    outputStr.append(QString("Border Polygon Offset: %1\n").arg(area._borderPolygonOffset.rawValue().toDouble()));
+
+    outputStr.append(QString("Border Polygon Coordinates\n").arg(area._borderPolygonOffset.rawValue().toDouble()));
+    for (int i = 0; i < area._borderPolygon.count(); i++) {
+        QGeoCoordinate coordinate = area._borderPolygon.vertexCoordinate(i);
+        outputStr.append(QString("%1\n").arg(coordinate.toString(QGeoCoordinate::Degrees)));
+    }
+}
+
+void WimaMeasurementArea::recalcBorderPolygon()
+{
+    //qWarning("WimaMeasurementArea::recalcBorderPolygon() %f", _borderPolygonOffset.rawValue().toDouble());
+    QGCMapPolygon polyCopy = this->toQGCPolygon(*this);
+    polyCopy.offset(_borderPolygonOffset.rawValue().toDouble());
+    _borderPolygon.setPath(polyCopy.path());
+    polyCopy.deleteLater();
+
+    emit borderPolygonChanged();
+}
+
+void WimaMeasurementArea::init()
+{
+
+    _metaDataMap            = FactMetaData::createMapFromJsonFile(QStringLiteral(":/json/WimaMeasurementArea.SettingsGroup.json"), this /* QObject parent */);
+    _bottomLayerAltitude    = SettingsFact(settingsGroup, _metaDataMap[bottomLayerAltitudeName], this /* QObject parent */);
+    _numberOfLayers         = SettingsFact(settingsGroup, _metaDataMap[numberOfLayersName], this /* QObject parent */);
+    _layerDistance          = SettingsFact(settingsGroup, _metaDataMap[layerDistanceName], this /* QObject parent */);
+    _borderPolygonOffset    = SettingsFact(settingsGroup, _metaDataMap[borderPolygonOffsetName], this /* QObject parent */);
+    _borderPolygon          = new QGCMapPolygon(this);
+
+    this->setObjectName(WimaMeasurementAreaName);
+    connect(this, &WimaMeasurementArea::pathChanged, this, &WimaMeasurementArea::recalcBorderPolygon);
+    connect(&_borderPolygonOffset, &SettingsFact::rawValueChanged, this, &WimaMeasurementArea::recalcBorderPolygon);
+}
+
+

src/Wima/WimaMeasurementArea.h

-#ifndef WIMAMEASUREMENTAREA_H
-#define WIMAMEASUREMENTAREA_H
+#pragma once
 
+#include <QObject>
+#include "WimaArea.h"
+#include "SettingsFact.h"
+#include "WimaTrackerPolyline.h"
 
-class WimaMeasurementArea
+#include "QScopedPointer"
+
+class WimaMeasurementArea : public WimaArea
 {
+    Q_OBJECT
 public:
-    WimaMeasurementArea();
+    WimaMeasurementArea(QObject* parent = nullptr);
+    WimaMeasurementArea(const WimaMeasurementArea &other, QObject *parent = nullptr);
+
+    Q_PROPERTY(Fact*            bottomLayerAltitude     READ bottomLayerAltitudeFact    CONSTANT)
+    Q_PROPERTY(Fact*            numberOfLayers          READ numberOfLayersFact         CONSTANT)
+    Q_PROPERTY(Fact*            layerDistance           READ layerDistanceFact          CONSTANT)
+    Q_PROPERTY(Fact*            borderPolygonOffset     READ borderPolygonOffsetFact    CONSTANT)
+    Q_PROPERTY(QGCMapPolygon    borderPolygon           READ borderPolygon              NOTIFY borderPolygonChanged)
+
+    // Overrides from WimaPolygon
+    QString         mapVisualQML    (void) const { return "WimaMeasurementAreaMapVisual.qml";}
+    QString         editorQML       (void) const { return "WimaMeasurementAreaEditor.qml";}
+
+    // Property accessors
+    Fact*           bottomLayerAltitudeFact (void)          { return &_bottomLayerAltitude;}
+    Fact*           numberOfLayersFact      (void)          { return &_numberOfLayers;}
+    Fact*           layerDistanceFact       (void)          { return &_layerDistance;}
+    Fact*           borderPolygonOffsetFact (void)          { return &_borderPolygonOffset;}
+    double          bottomLayerAltitude     (void) const    { return _bottomLayerAltitude.rawValue().toDouble();}
+    int             numberOfLayers          (void) const    { return _numberOfLayers.rawValue().toInt();}
+    double          layerDistance           (void) const    { return _layerDistance.rawValue().toDouble();}
+    double          borderPolygonOffset     (void) const    { return _borderPolygonOffset.rawValue().toDouble();}
+    QGCMapPolygon   borderPolygon           (void) const    { return _borderPolygon;}
+
+    // Member Methodes
+    void saveToJson(QJsonObject& json);
+    bool loadFromJson(const QJsonObject& json, QString &errorString);
+
+    // Friends
+    friend void print(const WimaMeasurementArea& area, QString outputStr);
+    friend void print(const WimaMeasurementArea& area);
+
+    // Static Variables
+    static const char* settingsGroup;
+    static const char* bottomLayerAltitudeName;
+    static const char* numberOfLayersName;
+    static const char* layerDistanceName;
+    static const char* borderPolygonOffsetName;
+    static const char* WimaMeasurementAreaName;
+
+signals:
+    void bottomLayerAltitudeChanged     (void);
+    void numberOfLayersChanged          (void);
+    void layerDistanceChanged           (void);
+    void polylineChanged                (void);
+    void vehicleCorridorChanged         (WimaVCorridor* corridor);
+    void borderPolygonChanged           (void);
+
+public slots:
+    /// Updates this with data from area
+    void update(const WimaMeasurementArea &area);
+    void setBottomLayerAltitude (double altitude);
+    void setNumberOfLayers      (double numLayers);
+    void setLayerDistance       (double layerDistance);
+    void setBorderPolygonOffset (double offset);
+private slots:
+    void recalcBorderPolygon            (void);
+private:
+    // Member Methodes
+    void init();
+
+    // Members
+    QMap<QString, FactMetaData*> _metaDataMap;
+
+    SettingsFact            _bottomLayerAltitude;
+    SettingsFact            _numberOfLayers;
+    SettingsFact            _layerDistance;
+    SettingsFact            _borderPolygonOffset;
+
+    QGCMapPolygon           _borderPolygon;
 };
 
-#endif // WIMAMEASUREMENTAREA_H
\ No newline at end of file
+

src/Wima/WimaMeasurementAreaData.h

+#pragma once
+
+#include <QObject>
+
+#include "WimaAreaData.h"
+#include "QGeoCoordinate"
+
+class WimaMeasurementAreaData : public WimaAreaData
+{
+    Q_OBJECT
+
+public:
+    explicit WimaMeasurementAreaData(QObject *parent = nullptr);
+    explicit WimaMeasurementAreaData(WimaMeasurementAreaData &other, QObject *parent = nullptr);
+
+
+    const QGeoCoordinate &takeOffPosition() const;
+    const QGeoCoordinate &landOffPosition() const;
+
+signals:
+    void takeOffPositionChanged(const QGeoCoordinate& other);
+    void landOffPositionChanged(const QGeoCoordinate& other);
+
+public slots:
+    void setTakeOffPosition(const QGeoCoordinate& newCoordinate);
+    void setLandOffPosition(const QGeoCoordinate& newCoordinate);
+
+private:
+    // see WimaServieArea.h for explanation
+};
+

src/Wima/WimaMeasurementAreaDataareadata.cc

+#include "WimaMeasurementAreaData.h"
+
+WimaMeasurementAreaData::WimaMeasurementAreaData(QObject *parent) : QObject(parent)
+{
+
+}

src/Wima/WimaPlaner.cc

@@ -44,11 +44,6 @@ QGeoCoordinate WimaPlaner::joinedAreaCenter() const
     return _joinedArea.center();
 }
 
-WimaArea WimaPlaner::joinedArea() const
-{
-    return _joinedArea;
-}
-
 void WimaPlaner::setMasterController(PlanMasterController *masterC)
 {
     _masterController = masterC;
@@ -388,7 +383,7 @@ bool WimaPlaner::loadFromFile(const QString &filename)
             QJsonObject jsonArea = areaArray[i].toObject();
 
             if (jsonArea.contains(WimaArea::areaTypeName) && jsonArea[WimaArea::areaTypeName].isString()) {
-                if ( jsonArea[WimaArea::areaTypeName] == WimaGOperationArea::wimaGOperationAreaName) {
+                if ( jsonArea[WimaArea::areaTypeName] == WimaMeasurementArea::WimaMeasurementAreaName) {
                     print(_opArea);
                     bool success = _opArea.loadFromJson(jsonArea, errorString);
                     print(_opArea);
@@ -412,7 +407,7 @@ bool WimaPlaner::loadFromFile(const QString &filename)
                     validAreaCounter++;
                     _visualItems.append(&_serArea);
                     emit visualItemsChanged();
-                } else if ( jsonArea[WimaArea::areaTypeName] == WimaVCorridor::wimaVCorridorName) {
+                } else if ( jsonArea[WimaArea::areaTypeName] == WimaCorridor::WimaCorridorName) {
                     bool success = _corridor.loadFromJson(jsonArea, errorString);
 
                     if ( !success ) {
@@ -507,7 +502,6 @@ bool WimaPlaner::recalcJoinedArea()
     if ( !_joinedArea.join(_opArea) )
         return false; // this happens if all areas are pairwise disjoint
     else {
-        emit joinedAreaChanged() ;
         return true;
     }
 
@@ -566,7 +560,7 @@ QJsonDocument WimaPlaner::saveToJson(FileType fileType)
             }
 
             // check the type of area, create and append the JsonObject to the JsonArray once determined
-            WimaGOperationArea* opArea =  qobject_cast<WimaGOperationArea*>(area);
+            WimaMeasurementArea* opArea =  qobject_cast<WimaMeasurementArea*>(area);
             if (opArea != nullptr) {
                 opArea->saveToJson(json);
                 jsonArray.append(json);
@@ -580,7 +574,7 @@ QJsonDocument WimaPlaner::saveToJson(FileType fileType)
                 continue;
             }
 
-            WimaVCorridor* corridor =  qobject_cast<WimaVCorridor*>(area);
+            WimaCorridor* corridor =  qobject_cast<WimaCorridor*>(area);
             if (corridor != nullptr) {
                 corridor->saveToJson(json);
                 jsonArray.append(json);

src/Wima/WimaPlaner.h

@@ -5,9 +5,9 @@
 #include "QmlObjectListModel.h"
 
 #include "WimaArea.h"
-#include "WimaGOperationArea.h"
+#include "WimaMeasurementArea.h"
 #include "WimaServiceArea.h"
-#include "WimaVCorridor.h"
+#include "WimaCorridor.h"
 #include "WimaDataContainer.h"
 
 #include "PlanMasterController.h"
@@ -41,7 +41,6 @@ public:
     Q_PROPERTY(QStringList              saveNameFilters     READ saveNameFilters                                        CONSTANT)
     Q_PROPERTY(QString                  fileExtension       READ fileExtension                                          CONSTANT)
     Q_PROPERTY(QGeoCoordinate           joinedAreaCenter    READ joinedAreaCenter                                       CONSTANT)
-    Q_PROPERTY(WimaArea                 joinedArea          READ joinedArea                                             NOTIFY joinedAreaChanged)
     Q_PROPERTY(WimaDataContainer*       dataContainer                                   WRITE setDataContainer          NOTIFY dataContainerChanged)
     Q_PROPERTY(bool                     readyForSaveSend    READ readyForSaveSend                                       NOTIFY readyForSaveSendChanged)
 
@@ -56,7 +55,6 @@ public:
     QStringList                 saveNameFilters        (void) const;
     QString                     fileExtension          (void) const    { return wimaFileExtension; }
     QGeoCoordinate              joinedAreaCenter       (void) const;
-    WimaArea                    joinedArea             (void) const;
     bool                        readyForSaveSend       (void) const    { return _readyForSaveSend; }
 
 
@@ -110,7 +108,6 @@ signals:
     void visualItemsChanged             (void);
     void currentPolygonIndexChanged     (int index);
     void currentFileChanged             ();
-    void joinedAreaChanged              ();
     void dataContainerChanged           ();
     void readyForSaveSendChanged        (bool ready);
 
@@ -128,7 +125,7 @@ private:
     WimaDataContainer      *_container; // container for data exchange with WimaController
     QmlObjectListModel      _visualItems; // contains all visible areas
     WimaArea                _joinedArea; // joined area fromed by opArea, serArea, _corridor
-    WimaGOperationArea      _opArea; // measurement area
+    WimaMeasurementArea      _opArea; // measurement area
     WimaServiceArea         _serArea; // area for supplying
-    WimaVCorridor           _corridor; // corridor connecting opArea and serArea
+    WimaCorridor           _corridor; // corridor connecting opArea and serArea
 };

src/Wima/WimaServiceAreaData.cc

+#include "WimaServiceAreaData.h"
+
+
+WimaServiceAreaData::WimaServiceAreaData(QObject *parent)
+    : WimaAreaData(parent)
+{
+
+}
+
+WimaServiceAreaData::WimaServiceAreaData(WimaServiceAreaData &other, QObject *parent)
+    : WimaAreaData (other, parent)
+    , _takeOffPosition(other.takeOffPosition())
+    , _landPosition(other.landOffPosition())
+{
+
+}
+
+/*!
+ * \fn const QGeoCoordinate &WimaServiceAreaData::takeOffPosition() const
+ * Returns a constant reference to the takeOffPosition.
+ *
+ */
+const QGeoCoordinate &WimaServiceAreaData::takeOffPosition() const
+{
+    return _takeOffPosition;
+}
+
+/*!
+ * \fn const QGeoCoordinate &WimaServiceAreaData::landOffPosition() const
+ * Returns a constant reference to the landOffPosition.
+ *
+ */
+const QGeoCoordinate &WimaServiceAreaData::landOffPosition() const
+{
+    return _landPosition;
+}
+
+/*!
+ * \fn void WimaServiceAreaData::setTakeOffPosition(const QGeoCoordinate &newCoordinate)
+ * Sets the takeoff position to the \a newCoordinate and emits the takeOffPositionChanged() signal,
+ * if newCoordinate differs from the member value.
+ *
+ */
+void WimaServiceAreaData::setTakeOffPosition(const QGeoCoordinate &newCoordinate)
+{
+    if (_takeOffPosition != newCoordinate) {
+        _takeOffPosition = newCoordinate;
+
+        emit takeOffPositionChanged(_takeOffPosition);
+    }
+}
+
+/*!
+ * \fn void WimaServiceAreaData::setLandOffPosition(const QGeoCoordinate &newCoordinate)
+ * Sets the land position to the \a newCoordinate and emits the landOffPositionChanged() signal,
+ * if newCoordinate differs from the member value.
+ *
+ */
+void WimaServiceAreaData::setLandOffPosition(const QGeoCoordinate &newCoordinate)
+{
+    if (_landPosition != newCoordinate) {
+        _landPosition = newCoordinate;
+
+        emit landOffPositionChanged(_landPosition);
+    }
+}
+
+/*!
+ * \class WimaAreaData::WimaServiceAreaData
+ * \brief Class to store and exchange data of a \c WimaServiceArea Object.
+ * Class to store and exchange data of a \c WimaServiceArea Object. In contrast to \c WimaServiceArea this class
+ * does not provied any interface to a grafical user interface, neiter it uses the QGC Fact System.
+ * It is designed to exchange data between the \c WimaPlaner and the \c WimaController class. And it
+ * is the derived from WimaAreaData.
+ *
+ * \sa WimaServiceArea, WimaAreaData
+ */

src/Wima/WimaServiceAreaData.h

+#pragma once
+
+#include <QObject>
+
+#include "WimaAreaData.h"
+#include "QGeoCoordinate"
+
+class WimaServiceAreaData : public WimaAreaData
+{
+    Q_OBJECT
+
+public:
+    explicit WimaServiceAreaData(QObject *parent = nullptr);
+    explicit WimaServiceAreaData(WimaServiceAreaData &other, QObject *parent = nullptr);
+
+
+    const QGeoCoordinate &takeOffPosition() const;
+    const QGeoCoordinate &landOffPosition() const;
+
+signals:
+    void takeOffPositionChanged(const QGeoCoordinate& other);
+    void landOffPositionChanged(const QGeoCoordinate& other);
+
+public slots:
+    void setTakeOffPosition(const QGeoCoordinate& newCoordinate);
+    void setLandOffPosition(const QGeoCoordinate& newCoordinate);
+
+private:
+    // see WimaServieArea.h for explanation
+    QGeoCoordinate      _takeOffPosition;
+    QGeoCoordinate      _landPosition;
+};
+