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();