clearup temp commit

src/RouteMissionItem/.directory

+[Dolphin]
+Timestamp=2020,7,8,11,13,28
+Version=4
+ViewMode=1

src/RouteMissionItem/AreaData.cc

+#include "WimaPlanData.h"
+
+AreaData::AreaData(QObject *parent) : QObject(parent) {}
+
+AreaData::AreaData(const AreaData &other, QObject *parent)
+    : QObject(parent) {
+  *this = other;
+}
+
+AreaData &AreaData::operator=(const AreaData &other) {
+  this->append(other.measurementArea());
+  this->append(other.serviceArea());
+  this->append(other.joinedArea());
+  this->append(other.corridor());
+
+  return *this;
+}
+
+void AreaData::append(const WimaJoinedAreaData &areaData) {
+  if (_joinedArea != areaData) {
+    _joinedArea = areaData;
+    emit joinedAreaChanged();
+  }
+}
+
+void AreaData::append(const WimaServiceAreaData &areaData) {
+  if (_serviceArea != areaData) {
+    _serviceArea = areaData;
+    emit serviceAreaChanged();
+  }
+}
+
+void AreaData::append(const WimaCorridorData &areaData) {
+  if (_corridor != areaData) {
+    _corridor = areaData;
+    emit corridorChanged();
+  }
+}
+
+void AreaData::append(const WimaMeasurementAreaData &areaData) {
+  if (_measurementArea != areaData) {
+    _measurementArea = areaData;
+    emit measurementAreaChanged();
+
+    if (_measurementArea.coordinateList().size() > 0) {
+      setOrigin(_measurementArea.coordinateList().first());
+    } else {
+      setOrigin(QGeoCoordinate());
+    }
+  }
+}
+
+void AreaData::append(const WimaJoinedArea &areaData) {
+  if (_joinedArea != areaData) {
+    _joinedArea = areaData;
+    emit joinedAreaChanged();
+  }
+}
+
+void AreaData::append(const WimaArea &areaData) {
+  if (_serviceArea != areaData) {
+    _serviceArea = areaData;
+    emit serviceAreaChanged();
+  }
+}
+
+void AreaData::append(const WimaCorridor &areaData) {
+  if (_corridor != areaData) {
+    _corridor = areaData;
+    emit corridorChanged();
+  }
+}
+
+void AreaData::append(const WimaMeasurementArea &areaData) {
+  if (_measurementArea != areaData) {
+    _measurementArea = areaData;
+    emit measurementAreaChanged();
+
+    if (_measurementArea.coordinateList().size() > 0) {
+      setOrigin(_measurementArea.coordinateList().first());
+    } else {
+      setOrigin(QGeoCoordinate());
+    }
+  }
+}
+
+void AreaData::clear() { *this = AreaData(); }
+
+const QGeoCoordinate &AreaData::origin() const { return _origin; }
+
+bool AreaData::isValid() {
+  return _measurementArea.coordinateList().size() >= 3 &&
+         _serviceArea.coordinateList().size() >= 3 && _origin.isValid();
+}
+
+const WimaJoinedAreaData &AreaData::joinedArea() const {
+  return this->_joinedArea;
+}
+
+const WimaServiceAreaData &AreaData::serviceArea() const {
+  return this->_serviceArea;
+}
+
+const WimaCorridorData &AreaData::corridor() const {
+  return this->_corridor;
+}
+
+const WimaMeasurementAreaData &AreaData::measurementArea() const {
+  return this->_measurementArea;
+}
+
+WimaJoinedAreaData &AreaData::joinedArea() { return this->_joinedArea; }
+
+WimaServiceAreaData &AreaData::serviceArea() { return this->_serviceArea; }
+
+WimaCorridorData &AreaData::corridor() { return this->_corridor; }
+
+WimaMeasurementAreaData &AreaData::measurementArea() {
+  return this->_measurementArea;
+}
+
+bool AreaData::operator==(const AreaData &other) const {
+  return this->_joinedArea == other._joinedArea &&
+         this->_measurementArea == other._measurementArea &&
+         this->_corridor == other._corridor &&
+         this->_serviceArea == other._serviceArea;
+}
+bool AreaData::operator!=(const AreaData &other) const {
+  return !(*this == other);
+}
+
+void AreaData::setOrigin(const QGeoCoordinate &origin) {
+  if (this->_origin != origin) {
+    this->_origin = origin;
+    emit originChanged();
+  }
+}

src/RouteMissionItem/CircularGenerator.h

+#include "GeneratorBase.h"
+
+#include <QGeoCoordinate>
+
+namespace routing {
+
+class CircularGenerator : public GeneratorBase {
+  Q_OBJECT
+public:
+  CircularGenerator(QObject *parent = nullptr);
+  CircularGenerator(Data d, QObject *parent = nullptr);
+
+  Q_PROPERTY(QGeoCoordinate reference READ reference WRITE setReference NOTIFY
+                 referenceChanged)
+  Q_PROPERTY(Fact *distance READ distance CONSTANT)
+  Q_PROPERTY(Fact *deltaAlpha READ deltaAlpha CONSTANT)
+  Q_PROPERTY(Fact *minLength READ minLength CONSTANT)
+
+  virtual QString editorQml() override;
+  virtual QString mapVisualQml() override;
+
+  virtual QString name() override;
+  virtual QString abbreviation() override;
+
+  virtual bool get(Generator &generator) override;
+
+  QGeoCoordinate reference() const;
+  Fact *distance();
+  Fact *deltaAlpha();
+  Fact *minLength();
+
+  void setReference(const QGeoCoordinate &reference);
+
+  static const char *settingsGroup;
+  static const char *distanceName;
+  static const char *deltaAlphaName;
+  static const char *minLengthName;
+  static const char *refPointLongitudeName;
+  static const char *refPointLatitudeName;
+  static const char *refPointAltitudeName;
+
+signals:
+  void referenceChanged();
+
+public slots:
+  Q_INVOKABLE void resetReferenceIfInvalid();
+  Q_INVOKABLE void resetReference();
+
+protected:
+  virtual void establishConnections() override;
+  virtual void deleteConnections() override;
+
+private:
+  bool _connectionsEstablished;
+
+  QGeoCoordinate _reference;
+  QMap<QString, FactMetaData *> _metaDataMap;
+  SettingsFact _distance;
+  SettingsFact _deltaAlpha;
+  SettingsFact _minLength;
+};
+
+} // namespace routing

src/RouteMissionItem/GeneratorBase.cc

+#include "GeneratorBase.h"
+
+namespace routing {
+
+GeneratorBase::GeneratorBase(QObject *parent)
+    : GeneratorBase(nullptr, parent) {}
+
+GeneratorBase::GeneratorBase(GeneratorBase::Data d, QObject *parent)
+    : QObject(parent), _d(d) {
+  establishConnections();
+}
+
+GeneratorBase::~GeneratorBase() {}
+
+QString GeneratorBase::editorQml() { return QStringLiteral(""); }
+
+QString GeneratorBase::mapVisualQml() { return QStringLiteral(""); }
+
+GeneratorBase::Data GeneratorBase::data() const { return _d; }
+
+void GeneratorBase::setData(const Data &d) {
+  deleteConnections();
+  _d = d;
+  establishConnections();
+}
+
+void GeneratorBase::establishConnections() {}
+
+void GeneratorBase::deleteConnections() {}
+
+} // namespace routing

src/RouteMissionItem/GeneratorBase.h

+#pragma once
+
+#include <QObject>
+
+#include <functional>
+#include <memory>
+
+#include "snake.h"
+
+#include "Wima/WimaPlanData.h"
+
+namespace routing {
+
+class GeneratorBase : public QObject {
+  Q_OBJECT
+public:
+  using Data = std::shared_ptr<AreaData>;
+  using Generator = std::function<bool(snake::Transects &)>;
+
+  explicit GeneratorBase(QObject *parent = nullptr);
+  explicit GeneratorBase(Data d, QObject *parent = nullptr);
+  ~GeneratorBase();
+
+  Q_PROPERTY(QString editorQml READ editorQml CONSTANT)
+  Q_PROPERTY(QString mapVisualQml READ mapVisualQml CONSTANT)
+
+  virtual QString editorQml();
+  virtual QString mapVisualQml();
+
+  virtual QString name() = 0;
+  virtual QString abbreviation() = 0;
+
+  virtual bool get(Generator &generator) = 0;
+
+  Data data() const;
+  void setData(const Data &d);
+
+signals:
+  void generatorChanged();
+
+protected:
+  virtual void establishConnections();
+  virtual void deleteConnections();
+  Data _d;
+};
+
+} // namespace routing

src/RouteMissionItem/GenericSingelton.h

+#pragma once
+#include "call_once.h"
+#include <QScopedPointer>
+#include <QtGlobal>
+
+template <class T> class GenericSingelton {
+private:
+  typedef T *(*CreateInstanceFunction)();
+
+public:
+  static T *instance(CreateInstanceFunction create);
+
+private:
+  static void init();
+
+  GenericSingelton();
+  ~GenericSingelton();
+  Q_DISABLE_COPY(GenericSingelton)
+  static QBasicAtomicPointer<void> create;
+  static QBasicAtomicInt flag;
+  static QBasicAtomicPointer<void> tptr;
+  bool inited;
+};
+
+template <class T>
+T *GenericSingelton<T>::instance(CreateInstanceFunction create) {
+  GenericSingelton::create.store(reinterpret_cast<void *>(create));
+  qCallOnce(init, flag);
+  return (T *)tptr.load();
+}
+
+template <class T> void GenericSingelton<T>::init() {
+  static GenericSingelton singleton;
+  if (singleton.inited) {
+    CreateInstanceFunction createFunction =
+        (CreateInstanceFunction)GenericSingelton::create.load();
+    tptr.store(createFunction());
+  }
+}
+
+template <class T> GenericSingelton<T>::GenericSingelton() { inited = true; }
+
+template <class T> GenericSingelton<T>::~GenericSingelton() {
+  T *createdTptr = (T *)tptr.fetchAndStoreOrdered(nullptr);
+  if (createdTptr) {
+    delete createdTptr;
+  }
+  create.store(nullptr);
+}
+
+template <class T>
+QBasicAtomicPointer<void>
+    GenericSingelton<T>::create = Q_BASIC_ATOMIC_INITIALIZER(nullptr);
+template <class T>
+QBasicAtomicInt GenericSingelton<T>::flag =
+    Q_BASIC_ATOMIC_INITIALIZER(CallOnce::CO_Request);
+template <class T>
+QBasicAtomicPointer<void>
+    GenericSingelton<T>::tptr = Q_BASIC_ATOMIC_INITIALIZER(nullptr);

src/RouteMissionItem/LinearGenerator.h

+#include "GeneratorBase.h"
+
+#include <QGeoCoordinate>
+
+namespace routing {
+
+class LinearGenerator : public GeneratorBase {
+  Q_OBJECT
+public:
+  LinearGenerator(QObject *parent = nullptr);
+  LinearGenerator(Data d, QObject *parent = nullptr);
+
+  Q_PROPERTY(Fact *distance READ distance CONSTANT)
+  Q_PROPERTY(Fact *alpha READ alpha CONSTANT)
+  Q_PROPERTY(Fact *minLength READ minLength CONSTANT)
+
+  virtual QString editorQml() override;
+
+  virtual QString name() override;
+  virtual QString abbreviation() override;
+
+  virtual bool get(Generator &generator) override;
+
+  Fact *distance();
+  Fact *alpha();
+  Fact *minLength();
+
+  static const char *settingsGroup;
+  static const char *distanceName;
+  static const char *alphaName;
+  static const char *minLengthName;
+
+protected:
+  virtual void establishConnections() override;
+  virtual void deleteConnections() override;
+
+private:
+  bool _connectionsEstablished;
+
+  QMap<QString, FactMetaData *> _metaDataMap;
+  SettingsFact _distance;
+  SettingsFact _alpha;
+  SettingsFact _minLength;
+};
+
+} // namespace routing

src/RouteMissionItem/NemoInterface.h

+#pragma once
+
+#include <QGeoCoordinate>
+#include <QObject>
+
+#include <memory>
+
+class TileData;
+
+class NemoInterface : public QObject {
+  Q_OBJECT
+  class Impl;
+  using PImpl = std::unique_ptr<Impl>;
+
+public:
+  enum class STATUS {
+    NOT_CONNECTED = 0,
+    HEARTBEAT_DETECTED = 1,
+    WEBSOCKET_DETECTED = 2,
+    TIMEOUT = -1,
+    INVALID_HEARTBEAT = -2
+  };
+
+  explicit NemoInterface(QObject *parent = nullptr);
+  ~NemoInterface() override;
+
+  Q_PROPERTY(int status READ status NOTIFY statusChanged)
+  Q_PROPERTY(QString statusString READ statusString NOTIFY statusChanged)
+  Q_PROPERTY(QVector<int> progress READ progress NOTIFY progressChanged)
+  Q_PROPERTY(QString editorQml READ editorQml CONSTANT)
+  Q_PROPERTY(bool running READ running NOTIFY runningChanged)
+
+  Q_INVOKABLE void start();
+  Q_INVOKABLE void stop();
+  Q_INVOKABLE void publishTileData();
+  Q_INVOKABLE void requestProgress();
+
+  void setTileData(const TileData &tileData);
+  bool hasTileData(const TileData &tileData) const;
+  void setAutoPublish(bool ap);
+  void setHoldProgress(bool hp);
+
+  int status() const;
+  STATUS statusEnum() const;
+  QString statusString() const;
+  QVector<int> progress() const;
+  QString editorQml();
+  bool running();
+
+signals:
+  void statusChanged();
+  void progressChanged();
+  void runningChanged();
+
+private:
+  PImpl pImpl;
+};

src/RouteMissionItem/OptimisationTools.cc

+#include "OptimisationTools.h"
+
+namespace OptimisationTools {
+    namespace  {
+
+    } // end anonymous namespace
+
+    bool dijkstraAlgorithm(const int numElements, int startIndex, int endIndex, QVector<int> &elementPath, std::function<double (const int, const int)> distanceDij)
+    {
+        if (    numElements < 0
+             || startIndex < 0
+             || endIndex < 0
+             || startIndex >= numElements
+             || endIndex >= numElements
+             || endIndex == startIndex) {
+            return false;
+        }
+        // Node struct
+        // predecessorIndex is the index of the predecessor node (nodeList[predecessorIndex])
+        // distance is the distance between the node and the start node
+        // node number is stored by the position in nodeList
+        struct Node{
+            int predecessorIndex = -1;
+            double distance = std::numeric_limits<qreal>::infinity();
+        };
+
+        // The list with all Nodes (elements)
+        QVector<Node> nodeList(numElements);
+        // This list will be initalized with indices referring to the elements of nodeList.
+        // Elements will be successively remove during the execution of the Dijkstra Algorithm.
+        QVector<int> workingSet(numElements);
+
+        //append elements to node list
+        for (int i = 0; i < numElements; ++i) workingSet[i] = i;
+
+
+        nodeList[startIndex].distance = 0;
+
+//        qDebug() << "nodeList" ;
+//        for (auto node : nodeList) {
+//            qDebug() << "predecessor: " << node.predecessorIndex;
+//            qDebug() << "distance: " << node.distance;
+//        }
+//        qDebug() << "workingSet";
+//        for (auto node : workingSet) {
+//            qDebug() << "index: " << node;
+//        }
+
+        // Dijkstra Algorithm
+        // https://de.wikipedia.org/wiki/Dijkstra-Algorithmus
+        while (workingSet.size() > 0) {
+            // serach Node with minimal distance
+            double minDist = std::numeric_limits<qreal>::infinity();
+            int minDistIndex_WS = -1; // WS = workinSet
+            for (int i = 0; i < workingSet.size(); ++i) {
+                const int nodeIndex = workingSet.at(i);
+                const double dist = nodeList.at(nodeIndex).distance;
+                if (dist < minDist) {
+                    minDist = dist;
+                    minDistIndex_WS = i;
+                }
+            }
+            if (minDistIndex_WS == -1)
+                    return false;
+
+            int indexU_NL = workingSet.takeAt(minDistIndex_WS); // NL = nodeList
+            if (indexU_NL == endIndex) // shortest path found
+                break;
+
+            const double distanceU = nodeList.at(indexU_NL).distance;
+            //update distance
+            for (int i = 0; i < workingSet.size(); ++i) {
+                int indexV_NL = workingSet[i]; // NL = nodeList
+                Node* v = &nodeList[indexV_NL];
+                double dist = distanceDij(indexU_NL, indexV_NL);
+                // is ther an alternative path which is shorter?
+                double alternative = distanceU + dist;
+                if (alternative < v->distance)  {
+                    v->distance         = alternative;
+                    v->predecessorIndex = indexU_NL;
+                }
+            }
+
+        }
+        // end Djikstra Algorithm
+
+
+        // reverse assemble path
+        int e = endIndex;
+        while (1) {
+            if (e == -1) {
+                if (elementPath[0] == startIndex)// check if starting point was reached
+                    break;
+                return false;
+            }
+            elementPath.prepend(e);
+
+            //Update Node
+            e = nodeList[e].predecessorIndex;
+
+        }
+        return true;
+    }
+
+} // end OptimisationTools namespace

src/RouteMissionItem/OptimisationTools.h

+#pragma once
+#include <QObject>
+#include <QDebug>
+
+#include <functional>
+#include <QVector>
+
+namespace OptimisationTools {
+    bool dijkstraAlgorithm(const int numElements, int startIndex, int endIndex, QVector<int> &elementPath, std::function<double(const int, const int)> distanceDij);
+}
+
+

src/RouteMissionItem/RouteComplexItem.h

+#pragma once
+
+#include <QFutureWatcher>
+#include <QVector>
+#include <memory>
+
+#include "SettingsFact.h"
+#include "TransectStyleComplexItem.h"
+
+#include "Geometry/WimaJoinedAreaData.h"
+#include "Geometry/WimaMeasurementAreaData.h"
+#include "WimaPlanData.h"
+
+class RoutingThread;
+class RoutingData;
+
+namespace routing {
+class GeneratorBase;
+}
+
+class CircularSurvey : public TransectStyleComplexItem {
+  Q_OBJECT
+
+  using PtrGenerator = std::shared_ptr<routing::GeneratorBase>;
+  using PtrRoutingData = std::shared_ptr<RoutingData>;
+  using PtrWorker = std::unique_ptr<RoutingThread>;
+  using Transects = QList<QList<CoordInfo_t>>;
+  using Variant = Transects;
+
+  enum class STATE { IDLE, ROUTING, SKIPP, REVERT_PATH, CHANGE_VARIANT };
+
+public:
+  CircularSurvey(PlanMasterController *masterController, bool flyView,
+                 const QString &kmlOrShpFile, QObject *parent);
+  ~CircularSurvey();
+
+  Q_PROPERTY(Fact *variant READ variant CONSTANT)
+  Q_PROPERTY(
+      QStringList variantNames READ variantNames NOTIFY variantNamesChanged)
+  Q_PROPERTY(QStringList generatorNameList READ generatorNameList NOTIFY
+                 generatorNameListChanged)
+  Q_PROPERTY(bool calculating READ calculating NOTIFY calculatingChanged)
+  Q_PROPERTY(
+      routing::GeneratorBase *generator READ generator NOTIFY generatorChanged)
+  Q_PROPERTY(int generatorIndex READ generatorIndex NOTIFY generatorChanged)
+
+  Q_INVOKABLE void revert_path(void);
+
+  // Property getters
+  const AreaData &planData() const;
+  Fact *variant();
+  QStringList variantNames() const;
+  bool calculating() const;
+
+  // Overrides
+  virtual bool load(const QJsonObject &complexObject, int sequenceNumber,
+                    QString &errorString) override final;
+  virtual void save(QJsonArray &planItems) override final;
+  virtual QString mapVisualQML(void) const override final;
+  virtual bool specifiesCoordinate(void) const override final;
+  virtual double timeBetweenShots(void) override final;
+  virtual QString commandDescription(void) const override final;
+  virtual QString commandName(void) const override final;
+  virtual QString abbreviation(void) const override final;
+  virtual ReadyForSaveState readyForSaveState(void) const override final;
+  virtual double additionalTimeDelay(void) const override final;
+  virtual QString patternName(void) const override;
+
+  // Generator
+  bool registerGenerator(const QString &name,
+                         std::shared_ptr<routing::GeneratorBase> g);
+  bool unregisterGenerator(const QString &name);
+  bool unregisterGenerator(int index);
+  Q_INVOKABLE bool switchToGenerator(const QString &name);
+  Q_INVOKABLE bool switchToGenerator(int index);
+  QStringList generatorNameList();
+  routing::GeneratorBase *generator();
+  int generatorIndex();
+
+  static const char *settingsGroup;
+  static const char *variantName;
+  static const char *jsonComplexItemTypeValue;
+  static const QString name;
+
+signals:
+  void calculatingChanged();
+  void variantNamesChanged();
+  void generatorNameListChanged();
+  void generatorChanged();
+
+private slots:
+  // Overrides from TransectStyleComplexItem
+  virtual void _rebuildTransectsPhase1(void) override final;
+  virtual void _recalcCameraShots(void) override final;
+
+  // Worker functions.
+  void _setTransects(PtrRoutingData pRoute);
+  void _changeVariant();
+  bool _updateWorker();
+  void _changeVariantWorker();
+  void _reverseWorker();
+
+private:
+  bool _switchToGenerator(const PtrGenerator &newG);
+  void _setState(STATE state);
+  bool _calculating(STATE state) const;
+
+  // State.
+  STATE _state;
+
+  // center of the circular lanes, e.g. base station
+  QMap<QString, FactMetaData *> _metaDataMap;
+  SettingsFact _variant;
+  QStringList _variantNames;
+
+  // Area data
+  AreaData _areaData;
+
+  // Generators
+  QList<PtrGenerator> _generatorList;
+  QStringList _generatorNameList;
+  PtrGenerator _pGenerator;
+
+  // Routing.
+  QVector<Variant> _variantVector;
+  PtrWorker _pWorker;
+};

src/RouteMissionItem/RoutingThread.cpp

+#include "RoutingThread.h"
+// std
+#include <chrono>
+// Qt
+#include <QDebug>
+
+#include "QGCLoggingCategory.h"
+QGC_LOGGING_CATEGORY(RoutingThreadLog, "RoutingThreadLog")
+
+RoutingThread::RoutingThread(QObject *parent)
+    : QThread(parent), _calculating(false), _stop(false), _restart(false) {
+
+  static std::once_flag flag;
+  std::call_once(flag,
+                 [] { qRegisterMetaType<PtrRoutingData>("PtrRoutingData"); });
+}
+
+RoutingThread::~RoutingThread() {
+  this->_stop = true;
+  Lock lk(this->_mutex);
+  this->_restart = true;
+  this->_cv.notify_one();
+  lk.unlock();
+  this->wait();
+}
+
+bool RoutingThread::calculating() const { return this->_calculating; }
+
+void RoutingThread::route(const RoutingParameter &par,
+                          const Generator &generator) {
+  // Sample input.
+  Lock lk(this->_mutex);
+  this->_par = par;
+  this->_generator = generator;
+  lk.unlock();
+
+  if (!this->isRunning()) {
+    this->start();
+  } else {
+    Lock lk(this->_mutex);
+    this->_restart = true;
+    this->_cv.notify_one();
+  }
+}
+
+void RoutingThread::run() {
+  qCDebug(RoutingThreadLog) << "run(): thread start.";
+  while (!this->_stop) {
+    qCDebug(RoutingThreadLog) << "run(): calculation "
+                                 "started.";
+    // Copy input.
+    auto start = std::chrono::high_resolution_clock::now();
+
+    this->_calculating = true;
+    emit calculatingChanged();
+    Lock lk(this->_mutex);
+    auto par = this->_par;
+    auto generator = this->_generator;
+    lk.unlock();
+    auto safeAreaENU = par.safeArea;
+    auto numRuns = par.numRuns;
+    auto numSolutionsPerRun = par.numSolutions;
+
+    PtrRoutingData pRouteData(new RoutingData());
+    auto &transectsENU = pRouteData->transects;
+    // Generate transects.
+    if (generator(transectsENU)) {
+      // Check if generation was successful.
+      if (transectsENU.size() == 0) {
+        qCDebug(RoutingThreadLog) << "run(): "
+                                     "not able to generate transects.";
+      } else {
+        // Prepare data for routing.
+        auto &solutionVector = pRouteData->solutionVector;
+
+        snake::RouteParameter snakePar;
+        snakePar.numSolutionsPerRun = numSolutionsPerRun;
+        snakePar.numRuns = numRuns;
+
+        // Set time limit to 10 min.
+        const auto maxRoutingTime = std::chrono::minutes(10);
+        const auto routingEnd =
+            std::chrono::high_resolution_clock::now() + maxRoutingTime;
+        const auto &restart = this->_restart;
+        snakePar.stop = [&restart, routingEnd] {
+          bool expired = std::chrono::high_resolution_clock::now() > routingEnd;
+          return restart || expired;
+        };
+
+        // Route transects.
+        bool success =
+            snake::route(safeAreaENU, transectsENU, solutionVector, snakePar);
+
+        // Check if routing was successful.
+        if ((!success || solutionVector.size() < 1) && !this->_restart) {
+          qCDebug(RoutingThreadLog) << "run(): "
+                                       "routing failed. "
+                                    << snakePar.errorString.c_str();
+        } else if (this->_restart) {
+          qCDebug(RoutingThreadLog) << "run(): "
+                                       "restart requested.";
+        } else {
+          // Notify main thread.
+          emit result(pRouteData);
+          qCDebug(RoutingThreadLog) << "run(): "
+                                       "concurrent update success.";
+        }
+      }
+    } // end calculation
+    else {
+      qCDebug(RoutingThreadLog) << "run(): generator() failed.";
+    }
+    qCDebug(RoutingThreadLog)
+        << "run(): execution time: "
+        << std::chrono::duration_cast<std::chrono::milliseconds>(
+               std::chrono::high_resolution_clock::now() - start)
+               .count()
+        << " ms";
+    // Signal calulation end and set thread to sleep.
+    this->_calculating = false;
+    emit calculatingChanged();
+    Lock lk2(this->_mutex);
+    if (!this->_restart) {
+      this->_cv.wait(lk2, [this] { return this->_restart.load(); });
+    }
+    this->_restart = false;
+  } // main loop
+  qCDebug(RoutingThreadLog) << "run(): thread end.";
+}

src/RouteMissionItem/RoutingThread.h

+#pragma once
+
+#include <QGeoCoordinate>
+#include <QSharedPointer>
+#include <QThread>
+
+#include "snake.h"
+#include <atomic>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+
+struct RoutingData {
+  snake::Transects transects;
+  std::vector<snake::Solution> solutionVector;
+  std::string errorString;
+};
+
+struct RoutingParameter {
+  RoutingParameter() : numSolutions(1), numRuns(1) {}
+  snake::FPolygon safeArea;
+  std::size_t numSolutions;
+  std::size_t numRuns;
+};
+//!
+//! \brief The CSWorker class
+//! \note Don't call QThread::start, QThread::quit, etc. onyl use Worker
+//! members!
+class RoutingThread : public QThread {
+  Q_OBJECT
+  using Lock = std::unique_lock<std::mutex>;
+
+public:
+  using PtrRoutingData = shared_ptr<RoutingData>;
+  using Generator = std::function<bool(snake::Transects &)>;
+  using Consumer = std::function<void(const RoutingData &)>;
+
+  RoutingThread(QObject *parent = nullptr);
+  ~RoutingThread() override;
+
+  bool calculating() const;
+
+public slots:
+  void route(const RoutingParameter &par, const Generator &generator);
+
+signals:
+  void result(PtrRoutingData pTransects);
+  void calculatingChanged();
+
+protected:
+  void run() override;
+
+private:
+  mutable std::mutex _mutex;
+  mutable std::condition_variable _cv;
+  // Internal data
+  RoutingParameter _par;
+  Generator _generator; // transect generator
+  // State
+  std::atomic_bool _calculating;
+  std::atomic_bool _stop;
+  std::atomic_bool _restart;
+};

src/RouteMissionItem/WimaPlaner.h

+#pragma once
+
+#include "QmlObjectListModel.h"
+#include <QObject>
+#include <QScopedPointer>
+#include <QSharedPointer>
+
+#include "Geometry/WimaCorridor.h"
+#include "Geometry/WimaCorridorData.h"
+#include "Geometry/WimaJoinedArea.h"
+#include "Geometry/WimaJoinedAreaData.h"
+#include "Geometry/WimaMeasurementArea.h"
+#include "Geometry/WimaMeasurementAreaData.h"
+#include "Geometry/WimaServiceArea.h"
+#include "Geometry/WimaServiceAreaData.h"
+#include "WimaPlanData.h"
+
+#include "Snake/NemoInterface.h"
+
+#include "JsonHelper.h"
+
+class MissionController;
+class PlanMasterController;
+
+namespace wima_planer_detail {
+class WimaStateMachine;
+}
+
+class WimaPlaner : public QObject {
+  Q_OBJECT
+
+  enum FileType { WimaFile, PlanFile };
+
+public:
+  WimaPlaner(QObject *parent = nullptr);
+  ~WimaPlaner();
+  template <class T> WimaPlaner(T t, QObject *parent = nullptr) = delete;
+  template <class T> WimaPlaner(T t) = delete;
+
+  Q_PROPERTY(PlanMasterController *masterController READ masterController WRITE
+                 setMasterController NOTIFY masterControllerChanged)
+  Q_PROPERTY(MissionController *missionController READ missionController WRITE
+                 setMissionController NOTIFY missionControllerChanged)
+  Q_PROPERTY(QmlObjectListModel *visualItems READ visualItems NOTIFY
+                 visualItemsChanged)
+  Q_PROPERTY(int currentPolygonIndex READ currentPolygonIndex WRITE
+                 setCurrentPolygonIndex NOTIFY currentPolygonIndexChanged)
+  Q_PROPERTY(QString currentFile READ currentFile NOTIFY currentFileChanged)
+  Q_PROPERTY(QStringList loadNameFilters READ loadNameFilters CONSTANT)
+  Q_PROPERTY(QStringList saveNameFilters READ saveNameFilters CONSTANT)
+  Q_PROPERTY(QString fileExtension READ fileExtension CONSTANT)
+  Q_PROPERTY(QGeoCoordinate joinedAreaCenter READ joinedAreaCenter CONSTANT)
+  Q_PROPERTY(NemoInterface *nemoInterface READ nemoInterface CONSTANT)
+  Q_PROPERTY(bool synchronized READ synchronized NOTIFY synchronizedChanged)
+  Q_PROPERTY(bool needsUpdate READ needsUpdate NOTIFY needsUpdateChanged)
+  Q_PROPERTY(bool readyForSynchronization READ readyForSynchronization NOTIFY
+                 readyForSynchronizationChanged)
+  Q_PROPERTY(bool surveyReady READ surveyReady NOTIFY surveyReadyChanged)
+  Q_PROPERTY(bool progressLocked READ progressLocked WRITE setProgressLocked
+                 NOTIFY progressLockedChanged)
+
+  // Property accessors
+  PlanMasterController *masterController(void);
+  MissionController *missionController(void);
+  QmlObjectListModel *visualItems(void);
+  int currentPolygonIndex(void) const;
+  QString currentFile(void) const;
+  QStringList loadNameFilters(void) const;
+  QStringList saveNameFilters(void) const;
+  QString fileExtension(void) const;
+  QGeoCoordinate joinedAreaCenter(void) const;
+  NemoInterface *nemoInterface(void);
+  bool synchronized();
+  bool needsUpdate();
+  bool readyForSynchronization();
+  bool surveyReady();
+  bool progressLocked();
+
+  // Property setters
+  void setMasterController(PlanMasterController *masterController);
+  void setMissionController(MissionController *missionController);
+  /// Sets the integer index pointing to the current polygon. Current polygon is
+  /// set interactive.
+  void setCurrentPolygonIndex(int index);
+  void setProgressLocked(bool l);
+
+  Q_INVOKABLE bool addMeasurementArea();
+  /// Removes an area from _visualItems
+  /// @param index Index of the area to be removed
+  Q_INVOKABLE void removeArea(int index);
+  Q_INVOKABLE bool addServiceArea();
+  Q_INVOKABLE bool addCorridor();
+  /// Remove all areas from WimaPlaner and all mission items from
+  /// MissionController
+  Q_INVOKABLE void removeAll();
+  /// Recalculates vehicle corridor, flight path, etc.
+  Q_INVOKABLE void update();
+  /// Pushes the generated mission data to the wimaController.
+  Q_INVOKABLE void synchronize();
+  Q_INVOKABLE void saveToCurrent();
+  Q_INVOKABLE void saveToFile(const QString &filename);
+  Q_INVOKABLE bool loadFromCurrent();
+  Q_INVOKABLE bool loadFromFile(const QString &filename);
+  Q_INVOKABLE void resetAllInteractive(void);
+  Q_INVOKABLE void setInteractive(void);
+
+  QJsonDocument saveToJson(FileType fileType);
+  // static Members
+  static const char *wimaFileExtension;
+  static const char *areaItemsName;
+  static const char *missionItemsName;
+
+signals:
+  void masterControllerChanged(void);
+  void missionControllerChanged(void);
+  void visualItemsChanged(void);
+  void currentPolygonIndexChanged(int index);
+  void currentFileChanged();
+  void wimaBridgeChanged();
+  void synchronizedChanged(void);
+  void needsUpdateChanged(void);
+  void readyForSynchronizationChanged(void);
+  void surveyReadyChanged(void);
+  void progressLockedChanged();
+
+private slots:
+  void updatePolygonInteractivity(int index);
+  void _update();
+  void CSDestroyedHandler();
+  void CSVisualTransectPointsChangedHandler();
+  void mAreaPathChangedHandler();
+  void mAreaTilesChangedHandler();
+  void mAreaProgressChangedHandler();
+  void mAreaProgressAcceptedHandler();
+  void mAreaReadyChangedHandler();
+  void sAreaPathChangedHandler();
+  void corridorPathChangedHandler();
+  void depotChangedHandler();
+  void missionControllerVisualItemsChangedHandler();
+  void missionControllerWaypointPathChangedHandler();
+  void missionControllerNewItemsFromVehicleHandler();
+  void missionControllerMissionItemCountChangedHandler();
+  void nemoInterfaceProgressChangedHandler();
+
+#ifndef NDEBUG
+  void autoLoadMission(void);
+#endif
+
+private:
+signals:
+  void joinedAreaValidChanged();
+  void stateChanged();
+
+private:
+  // Member Functions
+  bool toPlanData(AreaData &planData);
+  bool shortestPath(const QGeoCoordinate &start,
+                    const QGeoCoordinate &destination,
+                    QVector<QGeoCoordinate> &path);
+  void setSynchronized(bool s);
+  void enableAreaMonitoring();
+  void disableAreaMonitoring();
+  void enableMissionControllerMonitoring();
+  void disableMissionControllerMonitoring();
+  bool areasMonitored();
+  bool missionControllerMonitored();
+
+  // Member Variables
+  PlanMasterController *_masterController;
+  MissionController *_missionController;
+  int _currentAreaIndex;
+  QString _currentFile;
+
+  WimaMeasurementArea _measurementArea;
+  WimaServiceArea _serviceArea;
+  WimaCorridor _corridor;
+  WimaJoinedArea _joinedArea;
+  QmlObjectListModel _visualItems; // all areas
+
+  CircularSurvey *_survey;
+
+#ifndef NDEBUG
+  QTimer _autoLoadTimer; // timer to auto load mission after some time, prevents
+                         // seg. faults
+#endif
+
+  NemoInterface _nemoInterface;
+
+  // State
+  QScopedPointer<wima_planer_detail::WimaStateMachine> _stateMachine;
+  bool _areasMonitored;
+  bool _missionControllerMonitored;
+  bool _progressLocked;
+  bool _synchronized; // true if planData is synchronized with
+                      // wimaController
+};

src/RouteMissionItem/WimaStateMachine.h

+#pragma once
+
+#include <QDataStream>
+#include <QObject>
+
+namespace wima_planer_detail {
+
+enum class STATE {
+  NEEDS_INIT,
+  WAITING_FOR_TILE_UPDATE,
+  NEEDS_J_AREA_UPDATE,
+  NEEDS_SURVEY_UPDATE,
+  WAITING_FOR_SURVEY_UPDATE,
+  NEEDS_PATH_UPDATE,
+  UP_TO_DATE
+};
+
+QDebug &operator<<(QDebug &ds, STATE s);
+
+enum class EVENT {
+  INIT_DONE,
+  M_AREA_NOT_READY,
+  M_AREA_READY,
+  M_AREA_PATH_CHANGED,
+  S_AREA_PATH_CHANGED,
+  CORRIDOR_PATH_CHANGED,
+  M_AREA_TILES_CHANGED,
+  M_AREA_PROGRESS_CHANGED,
+  J_AREA_UPDATED,
+  DEPOT_CHANGED,
+  SURVEY_DESTROYED,
+  MISSION_ITEMS_DESTROYED,
+  SURVEY_UPDATE_TRIGGERED,
+  SURVEY_UPDATED,
+  PATH_CHANGED,
+  PATH_UPDATED
+};
+
+QDebug &operator<<(QDebug &ds, EVENT s);
+
+class WimaStateMachine : public QObject {
+  Q_OBJECT
+public:
+  explicit WimaStateMachine(QObject *parent = nullptr);
+
+  STATE state();
+  void updateState(EVENT e);
+  bool upToDate();
+  bool surveyReady();
+
+signals:
+  void stateChanged();
+  void upToDateChanged();
+  void surveyReadyChanged();
+
+private:
+  void setState(STATE s);
+  bool surveyReady(STATE s);
+  bool upToDate(STATE s);
+
+  STATE _state;
+};
+
+} // namespace wima_planer_detail

src/RouteMissionItem/call_once.h

+#ifndef CALL_ONCE_H
+#define CALL_ONCE_H
+
+#include <QAtomicInt>
+#include <QMutex>
+#include <QThread>
+#include <QThreadStorage>
+#include <QWaitCondition>
+#include <QtGlobal>
+
+namespace CallOnce {
+enum ECallOnce { CO_Request, CO_InProgress, CO_Finished };
+
+Q_GLOBAL_STATIC(QThreadStorage<QAtomicInt *>, once_flag)
+} // namespace CallOnce
+
+template <class Function>
+inline static void qCallOnce(Function func, QBasicAtomicInt &flag) {
+  using namespace CallOnce;
+
+#if QT_VERSION < 0x050000
+  int protectFlag = flag.fetchAndStoreAcquire(flag);
+#elif QT_VERSION >= 0x050000
+  int protectFlag = flag.fetchAndStoreAcquire(flag.load());
+#endif
+
+  if (protectFlag == CO_Finished)
+    return;
+  if (protectFlag == CO_Request &&
+      flag.testAndSetRelaxed(protectFlag, CO_InProgress)) {
+    func();
+    flag.fetchAndStoreRelease(CO_Finished);
+  } else {
+    do {
+      QThread::yieldCurrentThread();
+    } while (!flag.testAndSetAcquire(CO_Finished, CO_Finished));
+  }
+}
+
+template <class Function> inline static void qCallOncePerThread(Function func) {
+  using namespace CallOnce;
+  if (!once_flag()->hasLocalData()) {
+    once_flag()->setLocalData(new QAtomicInt(CO_Request));
+    qCallOnce(func, *once_flag()->localData());
+  }
+}
+
+#endif // CALL_ONCE_H

src/RouteMissionItem/geometry/GenericCircle.h

+#pragma once
+
+#include <QObject>
+#include <QPointF>
+
+#include <cmath>
+
+#include "boost/units/systems/angle/degrees.hpp"
+#include "boost/units/systems/si.hpp"
+
+template <int k, class Point> auto get(const Point &p);
+
+namespace bu = boost::units;
+
+namespace qty {
+using Length = bu::quantity<bu::si::length>;
+using Angle = bu::quantity<bu::si::plane_angle>;
+using Degree = bu::quantity<bu::degree::plane_angle>;
+using Radian = bu::quantity<bu::si::plane_angle>;
+} // namespace qty
+
+template <class NumberType, class Point> class GenericCircle {
+public:
+  GenericCircle();
+  GenericCircle(NumberType rad, Point ori);
+
+  // Property setters
+  void setRadius(NumberType rad);
+  void setOrigin(const Point &ori);
+
+  // Property getters
+  NumberType radius() const;
+  const Point &origin() const;
+  Point &origin();
+
+private:
+  NumberType _r;
+  Point _origin;
+};
+
+// Free functions.
+template <class Circle, class Container>
+void approximate(Circle &circ, long n, qty::Angle alpha1, qty::Angle alpha2,
+                 Container &c);
+template <class Circle, class Container>
+void approximate(Circle &circ, long n, Container &c);
+
+// Impl.
+template <class NumberType, class Point>
+GenericCircle<NumberType, Point>::GenericCircle() : _r(0), _origin(0, 0) {}
+
+template <class NumberType, class Point>
+GenericCircle<NumberType, Point>::GenericCircle(NumberType rad, Point ori)
+    : _r(rad), _origin(ori) {}
+
+/*!
+ * Returns a polygon with \a n corners which approximates the
+ * circle.
+ *
+ * \sa Point
+ */
+
+template <class NumberType, class Point>
+void GenericCircle<NumberType, Point>::setRadius(NumberType rad) {
+  if (rad >= 0) {
+    this->_r = rad;
+  }
+}
+
+template <class NumberType, class Point>
+void GenericCircle<NumberType, Point>::setOrigin(const Point &ori) {
+  this->_origin = ori;
+}
+
+template <class NumberType, class Point>
+NumberType GenericCircle<NumberType, Point>::radius() const {
+  return this->_r;
+}
+
+template <class NumberType, class Point>
+const Point &GenericCircle<NumberType, Point>::origin() const {
+  return this->_origin;
+}
+
+template <class NumberType, class Point>
+Point &GenericCircle<NumberType, Point>::origin() {
+  return this->_origin;
+}
+
+template <class Circle, class Container>
+void approximate(Circle &circ, long n, qty::Angle alpha1, qty::Angle alpha2,
+                 Container &c) {
+
+  auto clipp = [](double angle) {
+    while (angle < 0) {
+      angle += 2 * M_PI;
+    }
+    while (angle > 2 * M_PI) {
+      angle -= 2 * M_PI;
+    }
+    return angle;
+  };
+
+  double a1 = clipp(alpha1.value());
+  double a2 = clipp(alpha2.value());
+  double angleDisc = 0;
+  if (n > 0) {
+    angleDisc = (a2 - a1) / (n - 1);
+  } else {
+    angleDisc = (a2 - a1) / (n + 1);
+    n = n * (-1);
+  }
+
+  double a = a1;
+  using Point =
+      std::remove_cv_t<std::remove_reference_t<decltype(circ.origin())>>;
+  auto x0 = get<0>(circ.origin());
+  auto y0 = get<1>(circ.origin());
+  auto r = circ.radius();
+  using NumberType = std::remove_cv_t<std::remove_reference_t<decltype(x0)>>;
+  while (n--) {
+    auto x = NumberType(x0 + r * std::cos(a));
+    auto y = NumberType(y0 + r * std::sin(a));
+    c.push_back(Point(x, y));
+    a += angleDisc;
+  }
+}
+
+template <class Circle, class Container>
+void approximate(Circle &circ, long n, Container &c) {
+  using namespace bu;
+
+  double angleDisc = 0;
+  if (n > 0) {
+    angleDisc = 2 * M_PI / (n - 1);
+  } else {
+    angleDisc = 2 * M_PI / (n + 1);
+    n = n * (-1);
+  }
+
+  double a = 0;
+  using Point =
+      std::remove_cv_t<std::remove_reference_t<decltype(circ.origin())>>;
+  auto x0 = get<0>(circ.origin());
+  auto y0 = get<1>(circ.origin());
+  auto r = circ.radius();
+  using NumberType = std::remove_cv_t<std::remove_reference_t<decltype(x0)>>;
+  while (n--) {
+    auto x = NumberType(x0 + r * std::cos(a));
+    auto y = NumberType(y0 + r * std::sin(a));
+    c.push_back(Point(x, y));
+    a += angleDisc;
+  }
+}

src/RouteMissionItem/geometry/GenericPolygon.h

+#pragma once
+
+#include <QPolygonF>
+#include <QPointF>
+
+#include "ros_bridge/include/messages/geometry_msgs/polygon_stamped.h"
+
+template <class PointType = QPointF, template <class, class...> class ContainerType = QVector>
+class GenericPolygon{ //
+    typedef ros_bridge::messages::geometry_msgs::polygon::GenericPolygon<PointType, ContainerType> Polygon;
+public:
+    GenericPolygon(){}
+    GenericPolygon(const GenericPolygon &other) : _polygon(other._polygon){}
+
+    GenericPolygon& operator=(const GenericPolygon& other) {
+        this->_polygon = other._polygon;
+        return *this;
+    }
+
+    const Polygon &polygon() const {return _polygon;}
+          Polygon &polygon()       {return _polygon;}
+
+  const ContainerType<PointType> &path() const {return _polygon.points();}
+        ContainerType<PointType> &path()       {return _polygon.points();}
+
+private:
+    Polygon _polygon;
+
+};

src/RouteMissionItem/geometry/GenericPolygonArray.h

+#pragma once
+
+#include "QmlObjectListModel.h"
+
+#include <QVector>
+#include <QString>
+
+template <class PolygonType, template <class, class...> class ContainerType = QVector>
+class GenericPolygonArray
+{
+public:
+    GenericPolygonArray() {}
+    GenericPolygonArray(const GenericPolygonArray &other) :
+        _polygons(other._polygons), _dirty(true)
+    {}
+    ~GenericPolygonArray(){
+        _objs.clearAndDeleteContents();
+    }
+
+    class QmlObjectListModel *QmlObjectListModel(){
+        if (_dirty)
+            _updateObjects();
+        _dirty = false;
+        return &_objs;
+    }
+
+    const ContainerType<PolygonType> &polygons() const {
+        return _polygons;
+    }
+
+    ContainerType<PolygonType> &polygons(){
+        _dirty = true;
+        return _polygons;
+    }
+
+    GenericPolygonArray &operator =(const GenericPolygonArray &other){
+        this->_polygons = other._polygons;
+        this->_dirty = true;
+        return *this;
+    }
+
+
+
+private:
+    void _updateObjects(void){
+        _objs.clearAndDeleteContents();
+        for (long i=0; i<_polygons.size(); ++i){
+            _objs.append(new PolygonType(_polygons[i]));
+        }
+    }
+
+    ContainerType<PolygonType> _polygons;
+    class QmlObjectListModel   _objs;
+    bool                       _dirty;
+
+};
+
+

src/RouteMissionItem/geometry/GeoPoint3D.cpp

+#include "GeoPoint3D.h"
+
+GeoPoint3D::GeoPoint3D(QObject *parent)
+    : QObject(parent), ROSGeoPoint() {}
+
+GeoPoint3D::GeoPoint3D(double latitude, double longitude, double altitude, QObject *parent)
+    : QObject(parent), ROSGeoPoint(latitude, longitude, altitude)
+{}
+
+GeoPoint3D::GeoPoint3D(const GeoPoint3D &p, QObject *parent)
+    : QObject(parent), ROSGeoPoint(p.latitude(), p.longitude(), p.altitude())
+{}
+
+GeoPoint3D::GeoPoint3D(const ROSGeoPoint &p, QObject *parent)
+    : QObject(parent), ROSGeoPoint(p.latitude(), p.longitude(), p.altitude())
+{}
+
+GeoPoint3D::GeoPoint3D(const QGeoCoordinate &p, QObject *parent)
+    : QObject(parent), ROSGeoPoint(p.latitude(), p.longitude(), p.altitude())
+{}
+
+GeoPoint3D &GeoPoint3D::operator=(const GeoPoint3D &p)
+{
+    this->setLatitude(p.latitude());
+    this->setLongitude(p.longitude());
+    this->setAltitude(p.altitude());
+
+    return *this;
+}
+GeoPoint3D &GeoPoint3D::operator=(const QGeoCoordinate &p)
+{
+    this->setLatitude(p.latitude());
+    this->setLongitude(p.longitude());
+    this->setAltitude(p.altitude());
+
+    return *this;
+}

src/RouteMissionItem/geometry/GeoPoint3D.h

+#pragma once
+
+#include <QGeoCoordinate>
+#include <QObject>
+
+#include "ros_bridge/include/messages/geographic_msgs/geopoint.h"
+
+
+typedef ros_bridge::messages::geographic_msgs::geo_point::GeoPoint ROSGeoPoint;
+class GeoPoint3D : public QObject, public ROSGeoPoint
+{
+    Q_OBJECT
+public:
+
+    GeoPoint3D(QObject *parent = nullptr);
+    GeoPoint3D(double latitude,
+               double longitude,
+               double altitude,
+               QObject *parent = nullptr);
+    GeoPoint3D(const GeoPoint3D& p,
+               QObject *parent = nullptr);
+    GeoPoint3D(const ROSGeoPoint& p,
+               QObject *parent = nullptr);
+    GeoPoint3D(const QGeoCoordinate& p,
+               QObject *parent = nullptr);
+
+    GeoPoint3D &operator=(const GeoPoint3D&p);
+    GeoPoint3D &operator=(const QGeoCoordinate&p);
+
+};
+
+

src/RouteMissionItem/geometry/PlanimetryCalculus.h

+#pragma once
+
+#include <QLineF>
+#include <QPointF>
+#include <QPolygonF>
+#include <QtMath>
+
+#include "GenericCircle.h"
+#include "PolygonCalculus.h"
+
+using Circle = GenericCircle<qreal, QPointF>;
+
+namespace PlanimetryCalculus {
+
+enum IntersectType {
+  InsideNoIntersection,
+  InsideTouching,
+  InsideIntersection,
+  OutsideIntersection,
+  OutsideTouching,
+  OutsideNoIntersection,
+  CirclesEqual, // Circle Circle intersection
+
+  Tangent,
+  Secant, // Circle Line Intersetion
+
+  EdgeCornerIntersection,
+  EdgeEdgeIntersection,
+  CornerCornerIntersection,
+  LinesParallel,
+  LinesEqual, // Line Line intersection
+
+  Interior, // Polygon contains
+
+  NoIntersection,
+  Error // general
+};
+
+typedef QVector<QPair<int, int>> NeighbourVector;
+typedef QVector<QPointF> QPointFVector;
+typedef QVector<IntersectType> IntersectVector;
+
+void rotateReference(QPointF &point, double alpha);
+void rotateReference(QPointFVector &points, double alpha);
+void rotateReference(QLineF &line, double alpha);
+// void rotateReference(QPolygonF &polygon, double alpha);
+
+QPointF rotateReturn(QPointF point, double alpha);
+QPointFVector rotateReturn(QPointFVector points, double alpha);
+QLineF rotateReturn(QLineF line, double alpha);
+// QPolygonF       rotateReturn(QPolygonF &polygon, double alpha);
+
+bool intersects(const Circle &circle1, const Circle &circle2);
+bool intersects(const Circle &circle1, const Circle &circle2,
+                IntersectType &type);
+bool intersects(const Circle &circle1, const Circle &circle2,
+                QPointFVector &intersectionPoints);
+bool intersects(const Circle &circle1, const Circle &circle2,
+                QPointFVector &intersectionPoints, IntersectType &type);
+
+bool intersects(const Circle &circle, const QLineF &line);
+bool intersects(const Circle &circle, const QLineF &line, IntersectType &type);
+bool intersects(const Circle &circle, const QLineF &line,
+                QPointFVector &intersectionPoints);
+bool intersects(const Circle &circle, const QLineF &line,
+                QPointFVector &intersectionPoints, IntersectType &type);
+
+bool intersects(const Circle &circle, const QPolygonF &polygon);
+bool intersects(const Circle &circle, const QPolygonF &polygon,
+                QVector<QPointFVector> &intersectionPoints);
+bool intersects(const Circle &circle, const QPolygonF &polygon,
+                QVector<QPointFVector> &intersectionPoints,
+                IntersectVector &typeList);
+bool intersects(const Circle &circle, const QPolygonF &polygon,
+                QVector<QPointFVector> &intersectionPoints,
+                NeighbourVector &neighbourList);
+bool intersects(const Circle &circle, const QPolygonF &polygon,
+                QVector<QPointFVector> &intersectionPoints,
+                NeighbourVector &neighbourList, IntersectVector &typeList);
+
+bool intersects(const QLineF &line1, const QLineF &line2);
+bool intersects(const QLineF &line1, const QLineF &line2,
+                QPointF &intersectionPt);
+bool intersects(const QLineF &line1, const QLineF &line2,
+                QPointF &intersectionPt, IntersectType &type);
+//    bool intersectsFast(const QLineF &line1, const QLineF &line2, QPointF
+//    &intersectionPt, IntersectType &type);
+bool intersects(const QPolygonF &polygon, const QLineF &line,
+                QPointFVector &intersectionList);
+bool intersects(const QPolygonF &polygon, const QLineF &line,
+                QPointFVector &intersectionList, IntersectVector &typeList);
+bool intersects(const QPolygonF &polygon, const QLineF &line,
+                QPointFVector &intersectionList,
+                NeighbourVector &neighbourList);
+bool intersects(const QPolygonF &polygon, const QLineF &line,
+                QPointFVector &intersectionList, NeighbourVector &neighbourList,
+                IntersectVector &typeList);
+
+bool intersectsFast(const QPolygonF &polygon, const QLineF &line);
+
+bool contains(const QLineF &line, const QPointF &point);
+bool contains(const QLineF &line, const QPointF &point, IntersectType &type);
+bool contains(const QPolygonF &polygon, const QPointF &point);
+bool contains(const QPolygonF &polygon, const QPointF &point,
+              IntersectType &type);
+
+double distance(const QPointF &p1, const QPointF p2);
+double norm(double x, double y);
+double norm(const QPointF &p);
+double angle(const QPointF &p1, const QPointF p2);
+double angle(const QPointF &p1);
+double angle(const QLineF &line);
+double angleDegree(const QPointF &p1, const QPointF p2);
+double truncateAngle(double angle);
+double truncateAngleDegree(double angle);
+
+/*!
+ * \fntemplate <typename T> int signum(T val)
+ * Returns the signum of a value \a val.
+ *
+ * \sa QPair, QVector
+ */
+template <typename T> int signum(T val) { return (T(0) < val) - (val < T(0)); }
+} // namespace PlanimetryCalculus

src/RouteMissionItem/geometry/PolygonCalculus.h

+#pragma once
+
+
+#include <QPointF>
+#include <QPolygonF>
+#include <QVector3D>
+
+
+
+namespace PolygonCalculus {
+
+    enum JoinPolygonError { NotSimplePolygon, PolygonJoined, Disjoint, PathSizeLow, Error};
+
+    typedef QList<QVector3D> QVector3DList;
+    typedef QList<QPointF> QPointFList;
+    typedef QVector<QPointF> QPointFVector;
+
+    int              closestVertexIndex  (const QPolygonF &polygon, const QPointF &coordinate);
+    QPointF          closestVertex       (const QPolygonF &polygon, const QPointF &coordinate);
+    int              nextVertexIndex     (int pathsize, int index);
+    int              previousVertexIndex (int pathsize, int index);
+    JoinPolygonError join                (QPolygonF polygon1, QPolygonF polygon2, QPolygonF &joinedPolygon);
+    bool             isSimplePolygon     (const QPolygonF &polygon);
+    bool             hasClockwiseWinding (const QPolygonF &path);
+    void             reversePath         (QPolygonF &path);
+    void             reversePath         (QPointFList &path);
+    void             reversePath         (QPointFVector &path);
+    void             offsetPolygon       (QPolygonF &polygon, double offset);
+    // returns true if the line c1-c2 is fully inside the polygon
+    bool             containsPath        (QPolygonF polygon, const QPointF &c1, const QPointF &c2);
+    // same as containsPath(), but works only if c1 and c2 are inside the polygon!
+    bool             containsPathFast    (QPolygonF polygon, const QPointF &c1, const QPointF &c2);
+    void             decomposeToConvex   (const QPolygonF &polygon, QList<QPolygonF> &convexPolygons);
+    bool             shortestPath        (const QPolygonF &polygon, const QPointF &startVertex, const QPointF &endVertex, QVector<QPointF> &shortestPath);
+
+    QPolygonF toQPolygonF(const QVector3DList &polygon);
+    QPolygonF toQPolygonF(const QPointFList &polygon);
+    QLineF toQLineF(const QVector3DList &line);
+    QPointFList toQPointFList(const QVector3DList &list);
+    QPointFList toQPointFList(const QPolygonF &list);
+    QVector3DList toQVector3DList(const QPointFList &listF);
+    QVector3DList toQVector3DList(const QPolygonF &listF);
+}
+
+

src/RouteMissionItem/geometry/json/WimaArea.SettingsGroup.json

+[
+{
+    "name":             "BorderPolygonOffset",
+    "shortDescription": "The distance between the measurement area and it's surrounding polygon",
+    "type":             "double",
+    "units":            "m",
+    "min":              0,
+    "decimalPlaces":    1,
+    "defaultValue":     5
+},
+{
+    "name":             "ShowBorderPolygon",
+    "shortDescription": "Border polygon will be displayed if checked.",
+    "type":             "bool",
+    "defaultValue":     true
+}
+]

src/RouteMissionItem/geometry/mapbox/geometry.hpp

+#pragma once
+
+#include <mapbox/geometry/point.hpp>
+#include <mapbox/geometry/line_string.hpp>
+#include <mapbox/geometry/polygon.hpp>
+#include <mapbox/geometry/multi_point.hpp>
+#include <mapbox/geometry/multi_line_string.hpp>
+#include <mapbox/geometry/multi_polygon.hpp>
+#include <mapbox/geometry/geometry.hpp>
+#include <mapbox/geometry/point_arithmetic.hpp>
+#include <mapbox/geometry/for_each_point.hpp>
+#include <mapbox/geometry/envelope.hpp>

src/RouteMissionItem/nemo_interface/QNemoHeartbeat.h

+#pragma once
+
+#include "ros_bridge/include/messages/nemo_msgs/heartbeat.h"
+
+using QNemoHeartbeat = ros_bridge::messages::nemo_msgs::heartbeat::Heartbeat;

src/RouteMissionItem/nemo_interface/QNemoProgress.cc

+#include "QNemoProgress.h"
+