Merge branch 'dev1' of ssh://squid.nt.tuwien.ac.at:22103/platzgummer/qgroundcontrol into dev1

qgroundcontrol.pro

@@ -418,6 +418,9 @@ HEADERS += \
     src/Wima/GenericSingelton.h \
     src/Wima/Geometry/GenericCircle.h \
     src/Wima/RoutingThread.h \
+    src/Wima/Snake/CircularGenerator.h \
+    src/Wima/Snake/GeneratorBase.h \
+    src/Wima/Snake/LinearGenerator.h \
     src/Wima/Snake/clipper/clipper.hpp \
     src/Wima/Snake/mapbox/feature.hpp \
     src/Wima/Snake/mapbox/geometry.hpp \
@@ -510,6 +513,9 @@ SOURCES += \
     src/Wima/CircularSurvey.cc \
     src/Wima/GenericSingelton.cpp \
     src/Wima/RoutingThread.cpp \
+    src/Wima/Snake/CircularGenerator.cpp \
+    src/Wima/Snake/GeneratorBase.cc \
+    src/Wima/Snake/LinearGenerator.cpp \
     src/Wima/Snake/clipper/clipper.cpp \
     src/Wima/Snake/snake.cpp \
     src/Wima/Geometry/GeoPoint3D.cpp \
@@ -1449,5 +1455,8 @@ contains (CONFIG, QGC_DISABLE_INSTALLER_SETUP) {
 }
 
 DISTFILES += \
+    src/Wima/Routing/json/CircularGenerator.SettingsGroup.json \
+    src/Wima/Snake/json/LinearGenerator.SettingsGroup.json \
+    src/Wima/json/CircularSurvey.SettingsGroup.json \
     src/WimaView/WimaMeasurementAreaEditor.qml \
     src/Settings/Wima.SettingsGroup.json

src/FlightDisplay/FlightDisplayViewMap.qml

@@ -24,6 +24,8 @@ import QGroundControl.Palette       1.0
 import QGroundControl.ScreenTools   1.0
 import QGroundControl.Vehicle       1.0
 
+import Wima 1.0
+
 FlightMap {
     id:                         flightMap
     anchors.fill:               parent

src/FlightMap/MapItems/MissionLineView.qml

@@ -30,5 +30,9 @@ MapItemView {
             object.coordinate1,
             object.coordinate2,
         ] : []
+
+//        onParentChanged: {
+//            console.log("MapItemView, path:" + path)
+//        }
     }
 }

src/PlanView/MissionItemMapVisual.qml

@@ -15,7 +15,7 @@ import QtPositioning    5.3
 import QGroundControl.ScreenTools   1.0
 import QGroundControl.Palette       1.0
 import QGroundControl.Controls      1.0
-
+import Wima 					    1.0
 
 /// Mission item map visual
 Item {

src/QGCApplication.cc

@@ -89,6 +89,8 @@
 #include "VideoSurface.h"
 #include "ViewWidgetController.h"
 #include "VisualMissionItem.h"
+#include "Wima/Snake/CircularGenerator.h"
+#include "Wima/Snake/LinearGenerator.h"
 #include "Wima/Snake/NemoInterface.h"
 #include "Wima/WimaController.h"
 #include "Wima/WimaPlaner.h"
@@ -520,6 +522,10 @@ void QGCApplication::_initCommon(void) {
   qmlRegisterType<WimaController>("Wima", 1, 0, "WimaController");
   qmlRegisterType<WimaPlaner>("Wima", 1, 0, "WimaPlaner");
   qmlRegisterType<NemoInterface>("Wima", 1, 0, "NemoInterface");
+  qmlRegisterInterface<routing::GeneratorBase>("GeneratorBase");
+  qmlRegisterType<routing::CircularGenerator>("Wima", 1, 0,
+                                              "CircularGenerator");
+  qmlRegisterType<routing::LinearGenerator>("Wima", 1, 0, "LinearGenerator");
 
   // Register Qml Singletons
   qmlRegisterSingletonType<QGroundControlQmlGlobal>(

src/QmlControls/QGroundControl.Controls.qmldir

@@ -65,7 +65,6 @@ QGCViewDialog           1.0 QGCViewDialog.qml
 QGCViewDialogContainer  1.0 QGCViewDialogContainer.qml
 QGCViewMessage          1.0 QGCViewMessage.qml
 QGCViewPanel            1.0 QGCViewPanel.qml
-WimaToolBar             1.0 WimaToolBar.qml
 RallyPointEditorHeader  1.0 RallyPointEditorHeader.qml
 RallyPointItemEditor    1.0 RallyPointItemEditor.qml
 RallyPointMapVisuals    1.0 RallyPointMapVisuals.qml
@@ -85,22 +84,6 @@ VehicleSummaryRow       1.0 VehicleSummaryRow.qml
 ViewWidget              1.0 ViewWidget.qml
 FlyAreaItemEditor       1.0 FlyAreaItemEditor.qml
 
-WimaMapVisual                       1.0 WimaMapVisual.qml
-WimaMeasurementAreaMapVisual        1.0 WimaMeasurementAreaMapVisual.qml
-WimaJoinedAreaMapVisual             1.0 WimaJoinedAreaMapVisual.qml
-WimaMeasurementAreaEditor           1.0 WimaMeasurementAreaEditor.qml
-WimaServiceAreaMapVisual            1.0 WimaServiceAreaMapVisual.qml
-WimaAreaMapVisual                   1.0 WimaAreaMapVisual.qml
-WimaServiceAreaEditor               1.0 WimaServiceAreaEditor.qml
-WimaCorridorMapVisual               1.0 WimaCorridorMapVisual.qml
-WimaItemEditor                      1.0 WimaItemEditor.qml
-WimaMapPolygonVisuals               1.0 WimaMapPolygonVisuals.qml
-WimaMapPolylineVisuals              1.0 WimaMapPolylineVisuals.qml
-CircularSurveyMapVisual             1.0 CircularSurveyMapVisual.qml
-DragCoordinate                      1.0 DragCoordinate.qml
-CoordinateIndicator                 1.0 CoordinateIndicator.qml
-CoordinateIndicatorDrag             1.0 CoordinateIndicatorDrag.qml
-ProgressIndicator                   1.0 ProgressIndicator.qml
 QGCButtonColumn	                    1.0 QGCButtonColumn.qml
 
 

src/Wima/CircularSurvey.h

@@ -2,26 +2,30 @@
 
 #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
-public:
-  using PtrRoutingData = QSharedPointer<RoutingData>;
-  enum class Type {
-    Circular = 0,
-    Linear = 1,
-    Count = 2 // Must me last, onyl for counting
-  };
 
+  using PtrGenerator = std::shared_ptr<routing::GeneratorBase>;
+  using PtrRoutingData = std::shared_ptr<RoutingData>;
+  using PtrWorker = std::shared_ptr<RoutingThread>;
+
+public:
   /// @param vehicle Vehicle which this is being contructed for
   /// @param flyView true: Created for use in the Fly View, false: Created for
   /// use in the Plan View
@@ -31,50 +35,27 @@ public:
                  QObject *parent);
   ~CircularSurvey();
 
-  Q_PROPERTY(QGeoCoordinate refPoint READ refPoint WRITE setRefPoint NOTIFY
-                 refPointChanged)
-  Q_PROPERTY(Fact *transectDistance READ transectDistance CONSTANT)
-  Q_PROPERTY(Fact *alpha READ alpha CONSTANT)
-  Q_PROPERTY(Fact *minLength READ minLength CONSTANT)
-  Q_PROPERTY(Fact *type READ type CONSTANT)
   Q_PROPERTY(Fact *variant READ variant CONSTANT)
-  Q_PROPERTY(Fact *numRuns READ numRuns CONSTANT)
-  Q_PROPERTY(Fact *run READ run CONSTANT)
-  Q_PROPERTY(int typeCount READ typeCount 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(bool hidePolygon READ hidePolygon NOTIFY hidePolygonChanged)
   Q_PROPERTY(
-      QList<QString> variantNames READ variantNames NOTIFY variantNamesChanged)
-  Q_PROPERTY(QList<QString> runNames READ runNames NOTIFY runNamesChanged)
+      routing::GeneratorBase *generator READ generator NOTIFY generatorChanged)
+  Q_PROPERTY(int generatorIndex READ generatorIndex NOTIFY generatorChanged)
 
-  Q_INVOKABLE void resetReference(void);
   Q_INVOKABLE void reverse(void);
 
   // Property setters
-  void setRefPoint(const QGeoCoordinate &refPt);
-  void setHidePolygon(bool hide);
-  void setMeasurementArea(const WimaMeasurementAreaData &mArea);
-  void setJoinedArea(const WimaJoinedAreaData &jArea);
-  void setMeasurementArea(const WimaMeasurementArea &mArea);
-  void setJoinedArea(const WimaJoinedArea &jArea);
-  void setDepot(const QGeoCoordinate &depot);
+  void setPlanData(const WimaPlanData &d);
 
   // Property getters
-  QGeoCoordinate refPoint() const;
-  Fact *transectDistance();
-  Fact *alpha();
-  Fact *minLength();
-  Fact *type();
+  const WimaPlanData &planData() const;
+  WimaPlanData &planData();
   Fact *variant();
-  Fact *numRuns();
-  Fact *run();
-  int typeCount() const;
+  QStringList variantNames() const;
   bool calculating() const;
-  bool hidePolygon() const;
-  QList<QString> variantNames() const;
-  QList<QString> runNames() const;
-  QGeoCoordinate depot() const;
-  const QList<QList<QGeoCoordinate>> &rawTransects() const;
 
   // Overrides
   bool load(const QJsonObject &complexObject, int sequenceNumber,
@@ -92,91 +73,73 @@ public:
   bool readyForSave(void) const override final;
   double additionalTimeDelay(void) const override final;
 
+  // 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 *transectDistanceName;
-  static const char *alphaName;
-  static const char *minLengthName;
-  static const char *typeName;
   static const char *variantName;
-  static const char *numRunsName;
-  static const char *runName;
   static const char *CircularSurveyName;
-  static const char *refPointLongitudeName;
-  static const char *refPointLatitudeName;
-  static const char *refPointAltitudeName;
 
 signals:
-  void refPointChanged();
   void calculatingChanged();
-  void hidePolygonChanged();
-  void depotChanged();
   void variantNamesChanged();
-  void runNamesChanged();
-  void measurementAreaChanged();
-  void joinedAreaChanged();
+  void generatorNameListChanged();
+  void generatorChanged();
 
 private slots:
   // Overrides from TransectStyleComplexItem
   void _rebuildTransectsPhase1(void) final;
   void _recalcComplexDistance(void) final;
   void _recalcCameraShots(void) final;
+
+  // Worker functions.
   void _setTransects(PtrRoutingData pRoute);
+  void _changeVariant();
+  void _updateWorker();
+  void _changeVariantWorker();
+  void _reverseWorker();
 
 private:
   void _appendLoadedMissionItems(QList<MissionItem *> &items,
                                  QObject *missionItemParent);
   void _buildAndAppendMissionItems(QList<MissionItem *> &items,
                                    QObject *missionItemParent);
-  void _changeVariant();
-  void _changeRun();
 
-  void _updateWorker();
-  void _changeVariantRunWorker();
-  void _reverseWorker();
-  void _storeWorker();
-  void _changeRunWorker();
-
-  // center of the circular lanes, e.g. base station
-  QGeoCoordinate _referencePoint;
-  QMap<QString, FactMetaData *> _metaDataMap;
-  // distance between two neighbour circles
-  SettingsFact _transectDistance;
-  // angle discretisation of the circles
-  SettingsFact _alpha;
-  // minimal transect lenght, transects are rejected if they are shorter than
-  // this value
-  SettingsFact _minLength;
-  SettingsFact _type;
-  SettingsFact _variant;
-  QList<QString> _variantNames;
-  SettingsFact _numRuns;
-  SettingsFact _run;
-  QList<QString> _runNames;
-
-  // Area data
-  WimaMeasurementAreaData _mArea;
-  WimaJoinedAreaData _jArea;
-  QGeoCoordinate _depot;
-
-  // Worker
-  using PtrWorker = std::shared_ptr<RoutingThread>;
-  PtrWorker _pWorker;
-  PtrRoutingData _pRoutingData;
-
-  // Routing data.
-  QList<QList<QGeoCoordinate>> _rawTransects;
-  using Runs = QVector<Transects>;
-  QVector<Runs> _variantVector;
+  bool _switchToGenerator(const PtrGenerator &newG);
 
   // State.
   enum class STATE {
-    DEFAULT,
-    STORE,
+    IDLE,
+    SKIPP,
     REVERSE,
     VARIANT_CHANGE,
     RUN_CHANGE,
   };
   STATE _state;
 
-  bool _hidePolygon;
+  // center of the circular lanes, e.g. base station
+  QMap<QString, FactMetaData *> _metaDataMap;
+  SettingsFact _variant;
+  QStringList _variantNames;
+
+  // Area data
+  std::shared_ptr<WimaPlanData> _pAreaData;
+
+  // Generators
+  QList<PtrGenerator> _generatorList;
+  QStringList _generatorNameList;
+  PtrGenerator _pGenerator;
+
+  // Routing.
+  using Variant = Transects;
+  QVector<Variant> _variantVector;
+  PtrWorker _pWorker;
 };

src/Wima/Geometry/WimaAreaData.cc

@@ -2,7 +2,14 @@
 
 WimaAreaData::WimaAreaData(QObject *parent) : QObject(parent) {}
 
-WimaAreaData::~WimaAreaData() {}
+WimaAreaData::WimaAreaData(const WimaAreaData &other, QObject *parent)
+    : QObject(parent), _path(other._path), _list(other._list),
+      _center(other._center) {}
+
+WimaAreaData::WimaAreaData(const WimaArea &otherData, QObject *parent)
+    : QObject(parent), _center(otherData.center()) {
+  _setPathImpl(otherData.path());
+}
 
 bool WimaAreaData::operator==(const WimaAreaData &data) const {
   return this->_path == data._path && this->_center == data._center;
@@ -25,7 +32,7 @@ bool WimaAreaData::containsCoordinate(const QGeoCoordinate &coordinate) const {
   using namespace PolygonCalculus;
   using namespace GeoUtilities;
 
-  if (_path.size() > 2) {
+  if (this->coordinateList().size() > 2) {
     QPolygonF polygon;
     toCartesianList(this->coordinateList(), coordinate, polygon);
     return PlanimetryCalculus::contains(polygon, QPointF(0, 0));
@@ -36,44 +43,60 @@ bool WimaAreaData::containsCoordinate(const QGeoCoordinate &coordinate) const {
 void WimaAreaData::append(const QGeoCoordinate &c) {
   _list.append(c);
   _path.push_back(QVariant::fromValue(c));
+  emit pathChanged();
 }
 
 void WimaAreaData::push_back(const QGeoCoordinate &c) { append(c); }
 
 void WimaAreaData::clear() {
-  _list.clear();
-  _path.clear();
+  if (_list.size() > 0 || _path.size() > 0) {
+    _list.clear();
+    _path.clear();
+    emit pathChanged();
+  }
 }
 
 void WimaAreaData::setPath(const QVariantList &coordinateList) {
-  _path = coordinateList;
-  _list.clear();
-  for (auto variant : coordinateList) {
-    _list.push_back(variant.value<QGeoCoordinate>());
+  if (_path != coordinateList) {
+    _setPathImpl(coordinateList);
+    emit pathChanged();
   }
 }
 
 void WimaAreaData::setCenter(const QGeoCoordinate &center) {
   if (_center != center) {
     _center = center;
-
     emit centerChanged();
   }
 }
 
-/*!
- * \fn void WimaAreaData::assign(const WimaAreaData &other)
- *
- * Assigns \a other to the invoking object
- */
-void WimaAreaData::assign(const WimaAreaData &other) {
-  setPath(other.path());
-  setCenter(other.center());
+WimaAreaData &WimaAreaData::operator=(const WimaAreaData &otherData) {
+  setPath(otherData._list);
+  setCenter(otherData._center);
+  return *this;
 }
 
-void WimaAreaData::assign(const WimaArea &other) {
-  setPath(other.path());
-  setCenter(other.center());
+WimaAreaData &WimaAreaData::operator=(const WimaArea &otherData) {
+  setPath(otherData.path());
+  setCenter(otherData.center());
+  return *this;
+}
+
+void WimaAreaData::_setPathImpl(const QList<QGeoCoordinate> &coordinateList) {
+  _list = coordinateList;
+  _path.clear();
+  // copy all coordinates to _path
+  for (const auto &vertex : coordinateList) {
+    _path.append(QVariant::fromValue(vertex));
+  }
+}
+
+void WimaAreaData::_setPathImpl(const QVariantList &coordinateList) {
+  _path = coordinateList;
+  _list.clear();
+  for (const auto &variant : coordinateList) {
+    _list.push_back(variant.value<QGeoCoordinate>());
+  }
 }
 
 /*!
@@ -83,24 +106,26 @@ void WimaAreaData::assign(const WimaArea &other) {
  * coordinateList. Emits the \c pathChanged() signal.
  */
 void WimaAreaData::setPath(const QList<QGeoCoordinate> &coordinateList) {
-  _list = coordinateList;
-
-  _path.clear();
-  // copy all coordinates to _path
-  for (int i = 0; i < coordinateList.size(); i++) {
-    _path.append(QVariant::fromValue(coordinateList.value(i)));
+  if (_list != coordinateList) {
+    _setPathImpl(coordinateList);
+    emit pathChanged();
   }
-
-  emit pathChanged(_path);
 }
 
 bool operator==(const WimaAreaData &m1, const WimaArea &m2) {
   return m1.path() == m2.path() && m1.center() == m2.center();
 }
+
 bool operator!=(const WimaAreaData &m1, const WimaArea &m2) {
   return !operator==(m1, m2);
 }
 
+bool operator==(const WimaArea &m1, const WimaAreaData &m2) { return m2 == m1; }
+
+bool operator!=(const WimaArea &m1, const WimaAreaData &m2) {
+  return !operator==(m2, m1);
+}
+
 /*!
  * \class WimaArea::WimaAreaData
  * \brief Class to store and exchange data of a \c WimaArea Object.

src/Wima/Geometry/WimaAreaData.h

-#pragma once
+#pragma once
 
 #include <QObject>
 
@@ -11,16 +11,12 @@ class WimaAreaData
 {
   Q_OBJECT
 public:
+  WimaAreaData(QObject *parent = nullptr);
+
   Q_PROPERTY(const QVariantList path READ path NOTIFY pathChanged)
   Q_PROPERTY(QString type READ type CONSTANT)
   Q_PROPERTY(QString mapVisualQML READ mapVisualQML CONSTANT)
 
-  WimaAreaData(QObject *parent = nullptr);
-  ~WimaAreaData();
-  WimaAreaData(const WimaAreaData &otherData) = delete; // avoid slicing
-  WimaAreaData &
-  operator=(const WimaAreaData &otherData) = delete; // avoid slicing
-
   bool operator==(const WimaAreaData &data) const;
   bool operator!=(const WimaAreaData &data) const;
 
@@ -37,8 +33,8 @@ public:
   void clear();
 
 signals:
-  void pathChanged(const QVariantList &coordinateList);
-  void centerChanged(void);
+  void pathChanged();
+  void centerChanged();
 
 public slots:
   void setPath(const QList<QGeoCoordinate> &coordinateList);
@@ -46,18 +42,21 @@ public slots:
   void setCenter(const QGeoCoordinate &center);
 
 protected:
-  void assign(const WimaAreaData &other);
-  void assign(const WimaArea &other);
+  WimaAreaData(const WimaAreaData &otherData, QObject *parent);
+  WimaAreaData(const WimaArea &otherData, QObject *parent);
+  WimaAreaData &operator=(const WimaAreaData &otherData);
+  WimaAreaData &operator=(const WimaArea &otherData);
 
 private:
-  // Member Functions
-
+  void _setPathImpl(const QList<QGeoCoordinate> &coordinateList);
+  void _setPathImpl(const QVariantList &coordinateList);
   // Member Variables
-  // see WimaArea.h for explanation
-  QVariantList _path;
-  mutable QList<QGeoCoordinate> _list;
+  mutable QVariantList _path;
+  QList<QGeoCoordinate> _list;
   QGeoCoordinate _center;
 };
 
 bool operator==(const WimaAreaData &m1, const WimaArea &m2);
 bool operator!=(const WimaAreaData &m1, const WimaArea &m2);
+bool operator==(const WimaArea &m1, const WimaAreaData &m2);
+bool operator!=(const WimaArea &m1, const WimaAreaData &m2);

src/Wima/Geometry/WimaCorridorData.cpp

@@ -6,14 +6,10 @@ WimaCorridorData::WimaCorridorData(QObject *parent) : WimaAreaData(parent) {}
 
 WimaCorridorData::WimaCorridorData(const WimaCorridorData &other,
                                    QObject *parent)
-    : WimaAreaData(parent) {
-  *this = other;
-}
+    : WimaAreaData(other, parent) {}
 
 WimaCorridorData::WimaCorridorData(const WimaCorridor &other, QObject *parent)
-    : WimaAreaData(parent) {
-  *this = other;
-}
+    : WimaAreaData(other, parent) {}
 
 /*!
  * \overload operator=()
@@ -21,8 +17,7 @@ WimaCorridorData::WimaCorridorData(const WimaCorridor &other, QObject *parent)
  * Assigns \a other to the invoking object.
  */
 WimaCorridorData &WimaCorridorData::operator=(const WimaCorridorData &other) {
-  this->assign(other);
-
+  WimaAreaData::operator=(other);
   return *this;
 }
 
@@ -32,8 +27,7 @@ WimaCorridorData &WimaCorridorData::operator=(const WimaCorridorData &other) {
  * Assigns \a other to the invoking object.
  */
 WimaCorridorData &WimaCorridorData::operator=(const WimaCorridor &other) {
-  this->assign(other);
-
+  WimaAreaData::operator=(other);
   return *this;
 }
 
@@ -43,14 +37,6 @@ QString WimaCorridorData::mapVisualQML() const {
 
 QString WimaCorridorData::type() const { return this->typeString; }
 
-void WimaCorridorData::assign(const WimaCorridorData &corridorData) {
-  WimaAreaData::assign(corridorData);
-}
-
-void WimaCorridorData::assign(const WimaCorridor &corridor) {
-  WimaAreaData::assign(corridor);
-}
-
 /*!
  * \class WimaAreaData::WimaCorridorData
  * \brief Class to store and exchange data of a \c WimaCorridorData Object.

src/Wima/Geometry/WimaCorridorData.h

@@ -23,14 +23,4 @@ public:
   WimaCorridorData *Clone() const { return new WimaCorridorData(*this); }
 
   static const char *typeString;
-
-signals:
-
-public slots:
-
-protected:
-  void assign(const WimaCorridorData &corridorData);
-  void assign(const WimaCorridor &corridor);
-
-private:
 };

src/Wima/Geometry/WimaJoinedAreaData.cc

@@ -7,15 +7,11 @@ WimaJoinedAreaData::WimaJoinedAreaData(QObject *parent)
 
 WimaJoinedAreaData::WimaJoinedAreaData(const WimaJoinedAreaData &other,
                                        QObject *parent)
-    : WimaAreaData(parent) {
-  *this = other;
-}
+    : WimaAreaData(other, parent) {}
 
 WimaJoinedAreaData::WimaJoinedAreaData(const WimaJoinedArea &other,
                                        QObject *parent)
-    : WimaAreaData(parent) {
-  *this = other;
-}
+    : WimaAreaData(other, parent) {}
 
 /*!
  * \overload operator=()
@@ -24,8 +20,7 @@ WimaJoinedAreaData::WimaJoinedAreaData(const WimaJoinedArea &other,
  */
 WimaJoinedAreaData &WimaJoinedAreaData::
 operator=(const WimaJoinedAreaData &other) {
-  assign(other);
-
+  WimaAreaData::operator=(other);
   return *this;
 }
 
@@ -35,7 +30,7 @@ operator=(const WimaJoinedAreaData &other) {
  * Assigns \a other to the invoking object.
  */
 WimaJoinedAreaData &WimaJoinedAreaData::operator=(const WimaJoinedArea &other) {
-  assign(other);
+  WimaAreaData::operator=(other);
   return *this;
 }
 
@@ -45,14 +40,6 @@ QString WimaJoinedAreaData::mapVisualQML() const {
 
 QString WimaJoinedAreaData::type() const { return this->typeString; }
 
-void WimaJoinedAreaData::assign(const WimaJoinedAreaData &other) {
-  WimaAreaData::assign(other);
-}
-
-void WimaJoinedAreaData::assign(const WimaJoinedArea &other) {
-  WimaAreaData::assign(other);
-}
-
 /*!
  * \class WimaAreaData::WimaJoinedAreaData
  * \brief Class to store and exchange data of a \c WimaJoinedAreaData Object.

src/Wima/Geometry/WimaJoinedAreaData.h

@@ -24,10 +24,4 @@ public:
   WimaJoinedAreaData *Clone() const { return new WimaJoinedAreaData(*this); }
 
   static const char *typeString;
-
-protected:
-  void assign(const WimaJoinedAreaData &other);
-  void assign(const WimaJoinedArea &other);
-
-private:
 };

src/Wima/Geometry/WimaMeasurementArea.cc

@@ -72,7 +72,7 @@ WimaMeasurementArea::WimaMeasurementArea(QObject *parent)
                               this /* QObject parent */)),
       _minTileAreaPercent(SettingsFact(settingsGroup,
                                        _metaDataMap[minTileAreaName],
-                                       this /* QObject parent */)),
+                                      this /* QObject parent */)),
       _showTiles(SettingsFact(settingsGroup, _metaDataMap[showTilesName],
                               this /* QObject parent */)),
       _state(STATE::IDLE) {
@@ -91,7 +91,7 @@ WimaMeasurementArea::WimaMeasurementArea(const WimaMeasurementArea &other,
                               this /* QObject parent */)),
       _minTileAreaPercent(SettingsFact(settingsGroup,
                                        _metaDataMap[minTileAreaName],
-                                       this /* QObject parent */)),
+                                      this /* QObject parent */)),
       _showTiles(SettingsFact(settingsGroup, _metaDataMap[showTilesName],
                               this /* QObject parent */)),
       _state(STATE::IDLE) {
@@ -157,12 +157,12 @@ bool WimaMeasurementArea::ready() const { return this->_state == STATE::IDLE; }
 
 void WimaMeasurementArea::saveToJson(QJsonObject &json) {
   if (ready()) {
-    this->WimaArea::saveToJson(json);
-    json[tileHeightName] = _tileHeight.rawValue().toDouble();
-    json[tileWidthName] = _tileWidth.rawValue().toDouble();
+  this->WimaArea::saveToJson(json);
+  json[tileHeightName] = _tileHeight.rawValue().toDouble();
+  json[tileWidthName] = _tileWidth.rawValue().toDouble();
     json[minTileAreaName] = _minTileAreaPercent.rawValue().toDouble();
-    json[showTilesName] = _showTiles.rawValue().toBool();
-    json[areaTypeName] = WimaMeasurementAreaName;
+  json[showTilesName] = _showTiles.rawValue().toBool();
+  json[areaTypeName] = WimaMeasurementAreaName;
   } else {
     qCDebug(WimaMeasurementAreaLog) << "saveToJson(): not ready for saveing.";
   }
@@ -231,70 +231,70 @@ void WimaMeasurementArea::doUpdate() {
   using namespace boost::units;
 
   auto start = std::chrono::high_resolution_clock::now();
-  // Check state.
+
   if (this->_state != STATE::UPDATEING && this->_state != STATE::STOP) {
-    const auto height = this->_tileHeight.rawValue().toDouble() * si::meter;
-    const auto width = this->_tileWidth.rawValue().toDouble() * si::meter;
-    const auto tileArea = width * height;
-    const auto totalArea = this->area() * si::meter * si::meter;
-    const auto estNumTiles = totalArea / tileArea;
+  const auto height = this->_tileHeight.rawValue().toDouble() * si::meter;
+  const auto width = this->_tileWidth.rawValue().toDouble() * si::meter;
+  const auto tileArea = width * height;
+  const auto totalArea = this->area() * si::meter * si::meter;
+  const auto estNumTiles = totalArea / tileArea;
     // Check some conditions.
     if (long(std::ceil(estNumTiles.value())) <= SNAKE_MAX_TILES &&
-        this->count() >= 3 && this->isSimplePolygon()) {
+      this->count() >= 3 && this->isSimplePolygon()) {
       setState(STATE::UPDATEING);
 
-      auto polygon = this->coordinateList();
-      for (auto &v : polygon) {
-        v.setAltitude(0);
-      }
-      const auto minArea =
+    auto polygon = this->coordinateList();
+    for (auto &v : polygon) {
+      v.setAltitude(0);
+    }
+    const auto minArea =
           this->_minTileAreaPercent.rawValue().toDouble() / 100 * tileArea;
-      auto *th = this->thread();
-      auto future = QtConcurrent::run([polygon, th, height, width, minArea] {
-        auto start = std::chrono::high_resolution_clock::now();
-
-        DataPtr pData(new TileData());
-        // Convert to ENU system.
-        QGeoCoordinate origin = polygon.first();
-        FPolygon polygonENU;
-        areaToEnu(origin, polygon, polygonENU);
-        std::vector<FPolygon> tilesENU;
-        BoundingBox bbox;
-        std::string errorString;
-        // Generate tiles.
-        if (snake::tiles(polygonENU, height, width, minArea, tilesENU, bbox,
-                         errorString)) {
-          // Convert to geo system.
-          for (const auto &t : tilesENU) {
-            auto geoTile = new SnakeTile(pData.get());
-            for (const auto &v : t.outer()) {
-              QGeoCoordinate geoVertex;
-              fromENU(origin, v, geoVertex);
-              geoTile->push_back(geoVertex);
-            }
-            pData->tiles.append(geoTile);
-            // Calculate center.
-            snake::FPoint center;
-            snake::polygonCenter(t, center);
-            QGeoCoordinate geoCenter;
-            fromENU(origin, center, geoCenter);
-            pData->tileCenterPoints.append(QVariant::fromValue(geoCenter));
+    auto *th = this->thread();
+    auto future = QtConcurrent::run([polygon, th, height, width, minArea] {
+      auto start = std::chrono::high_resolution_clock::now();
+
+      DataPtr pData(new TileData());
+      // Convert to ENU system.
+      QGeoCoordinate origin = polygon.first();
+      FPolygon polygonENU;
+      areaToEnu(origin, polygon, polygonENU);
+      std::vector<FPolygon> tilesENU;
+      BoundingBox bbox;
+      std::string errorString;
+      // Generate tiles.
+      if (snake::tiles(polygonENU, height, width, minArea, tilesENU, bbox,
+                       errorString)) {
+        // Convert to geo system.
+        for (const auto &t : tilesENU) {
+          auto geoTile = new SnakeTile(pData.get());
+          for (const auto &v : t.outer()) {
+            QGeoCoordinate geoVertex;
+            fromENU(origin, v, geoVertex);
+            geoTile->push_back(geoVertex);
           }
+          pData->tiles.append(geoTile);
+          // Calculate center.
+          snake::FPoint center;
+          snake::polygonCenter(t, center);
+          QGeoCoordinate geoCenter;
+          fromENU(origin, center, geoCenter);
+          pData->tileCenterPoints.append(QVariant::fromValue(geoCenter));
         }
-        pData->moveToThread(th);
+      }
+      pData->moveToThread(th);
 
-        qCDebug(WimaMeasurementAreaLog)
-            << "doUpdate(): update time: "
-            << std::chrono::duration_cast<std::chrono::milliseconds>(
-                   std::chrono::high_resolution_clock::now() - start)
-                   .count()
-            << " ms";
+      qCDebug(WimaMeasurementAreaLog)
+          << "doUpdate(): update time: "
+          << std::chrono::duration_cast<std::chrono::milliseconds>(
+                 std::chrono::high_resolution_clock::now() - start)
+                 .count()
+          << " ms";
 
-        return pData;
-      }); // QtConcurrent::run()
+      return pData;
+    }); // QtConcurrent::run()
 
-      this->_watcher.setFuture(future);
-    }
+    this->_watcher.setFuture(future);
+  }
   }
   qCDebug(WimaMeasurementAreaLog)
       << "doUpdate(): execution time: "

src/Wima/Geometry/WimaMeasurementArea.h

@@ -106,7 +106,7 @@ private:
   SettingsFact _showTiles;
 
   QVector<int> _progress;
-
+  // Tile stuff.
   // Tile stuff.
   mutable QTimer _timer;
   using DataPtr = std::shared_ptr<TileData>;

src/Wima/Geometry/WimaMeasurementAreaData.cc

@@ -22,6 +22,7 @@ bool WimaMeasurementAreaData::
 operator==(const WimaMeasurementAreaData &other) const {
   return this->WimaAreaData::operator==(other) &&
          this->_tileData == other.tileData() &&
+         this->_progress == other.progress() &&
          this->center() == other.center();
 }
 
@@ -33,6 +34,8 @@ operator!=(const WimaMeasurementAreaData &other) const {
 void WimaMeasurementAreaData::setTileData(const TileData &d) {
   if (this->_tileData != d) {
     this->_tileData = d;
+    this->_progress.fill(0, d.size());
+    emit progressChanged();
     emit tileDataChanged();
   }
 }
@@ -51,7 +54,9 @@ void WimaMeasurementAreaData::setProgress(const QVector<int> &d) {
  */
 WimaMeasurementAreaData &WimaMeasurementAreaData::
 operator=(const WimaMeasurementAreaData &other) {
-  assign(other);
+  WimaAreaData::operator=(other);
+  setTileData(other._tileData);
+  setProgress(other._progress);
 
   return *this;
 }
@@ -63,7 +68,14 @@ operator=(const WimaMeasurementAreaData &other) {
  */
 WimaMeasurementAreaData &WimaMeasurementAreaData::
 operator=(const WimaMeasurementArea &other) {
-  assign(other);
+  WimaAreaData::operator=(other);
+  if (other.ready()) {
+    setTileData(other.tileData());
+    setProgress(other.progress());
+  } else {
+    qWarning() << "WimaMeasurementAreaData::operator=(): WimaMeasurementArea "
+                  "not ready.";
+  }
 
   return *this;
 }
@@ -102,23 +114,6 @@ const QVector<int> &WimaMeasurementAreaData::progress() const {
 
 QVector<int> &WimaMeasurementAreaData::progress() { return this->_progress; }
 
-void WimaMeasurementAreaData::assign(const WimaMeasurementAreaData &other) {
-  WimaAreaData::assign(other);
-  setTileData(other._tileData);
-  setProgress(other._progress);
-}
-
-void WimaMeasurementAreaData::assign(const WimaMeasurementArea &other) {
-  WimaAreaData::assign(other);
-  if (other.ready()) {
-    setTileData(other.tileData());
-    setProgress(other.progress());
-  } else {
-    qWarning()
-        << "WimaMeasurementAreaData::assign(): WimaMeasurementArea not ready.";
-  }
-}
-
 bool operator==(const WimaMeasurementAreaData &m1,
                 const WimaMeasurementArea &m2) {
   return operator==(*static_cast<const WimaAreaData *>(&m1),

src/Wima/Geometry/WimaMeasurementAreaData.h

@@ -50,10 +50,6 @@ signals:
   void tileDataChanged();
   void progressChanged();
 
-protected:
-  void assign(const WimaMeasurementAreaData &other);
-  void assign(const WimaMeasurementArea &other);
-
 private:
   TileData _tileData;
   QVector<int> _progress;

src/Wima/Geometry/WimaServiceAreaData.cc

@@ -7,26 +7,22 @@ WimaServiceAreaData::WimaServiceAreaData(QObject *parent)
 
 WimaServiceAreaData::WimaServiceAreaData(const WimaServiceAreaData &other,
                                          QObject *parent)
-    : WimaAreaData(parent) {
-  *this = other;
-}
+    : WimaAreaData(other, parent), _depot(other._depot) {}
 
 WimaServiceAreaData::WimaServiceAreaData(const WimaServiceArea &other,
                                          QObject *parent)
-    : WimaAreaData(parent) {
-  *this = other;
-}
+    : WimaAreaData(other, parent), _depot(other.depot()) {}
 
 WimaServiceAreaData &WimaServiceAreaData::
 operator=(const WimaServiceAreaData &otherData) {
-  this->assign(otherData);
+  WimaAreaData::operator=(otherData);
   this->setDepot(otherData.depot());
   return *this;
 }
 
 WimaServiceAreaData &WimaServiceAreaData::
 operator=(const WimaServiceArea &otherArea) {
-  this->assign(otherArea);
+  WimaAreaData::operator=(otherArea);
   this->setDepot(otherArea.depot());
   return *this;
 }
@@ -57,16 +53,6 @@ void WimaServiceAreaData::setDepot(const QGeoCoordinate &newCoordinate) {
   }
 }
 
-void WimaServiceAreaData::assign(const WimaServiceAreaData &other) {
-  WimaAreaData::assign(other);
-  setDepot(other.depot());
-}
-
-void WimaServiceAreaData::assign(const WimaServiceArea &other) {
-  WimaAreaData::assign(other);
-  setDepot(other.depot());
-}
-
 /*!
  * \class WimaAreaData::WimaServiceAreaData
  * \brief Class to store and exchange data of a \c WimaServiceArea Object.

src/Wima/Geometry/WimaServiceAreaData.h

@@ -31,10 +31,6 @@ signals:
 public slots:
   void setDepot(const QGeoCoordinate &newCoordinate);
 
-protected:
-  void assign(const WimaServiceAreaData &other);
-  void assign(const WimaServiceArea &other);
-
 private:
   // see WimaServieArea.h for explanation
   QGeoCoordinate _depot;

src/Wima/RoutingThread.cpp

@@ -5,7 +5,7 @@
 #include <QDebug>
 
 #include "QGCLoggingCategory.h"
-QGC_LOGGING_CATEGORY(RoutingWorkerLog, "RoutingWorkerLog")
+QGC_LOGGING_CATEGORY(RoutingThreadLog, "RoutingThreadLog")
 
 RoutingThread::RoutingThread(QObject *parent)
     : QThread(parent), _calculating(false), _stop(false), _restart(false) {
@@ -44,10 +44,10 @@ void RoutingThread::route(const RoutingParameter &par,
 }
 
 void RoutingThread::run() {
-  qCWarning(RoutingWorkerLog) << "run(): thread start.";
+  qCDebug(RoutingThreadLog) << "run(): thread start.";
   while (!this->_stop) {
-    qCWarning(RoutingWorkerLog) << "run(): calculation "
-                                   "started.";
+    qCDebug(RoutingThreadLog) << "run(): calculation "
+                                 "started.";
     // Copy input.
     auto start = std::chrono::high_resolution_clock::now();
 
@@ -59,7 +59,7 @@ void RoutingThread::run() {
     lk.unlock();
     auto safeAreaENU = par.safeArea;
     auto numRuns = par.numRuns;
-    auto numSolutionsPerRun = par.numSolutionsPerRun;
+    auto numSolutionsPerRun = par.numSolutions;
 
     PtrRoutingData pRouteData(new RoutingData());
     auto &transectsENU = pRouteData->transects;
@@ -67,8 +67,8 @@ void RoutingThread::run() {
     if (generator(transectsENU)) {
       // Check if generation was successful.
       if (transectsENU.size() == 0) {
-        qCWarning(RoutingWorkerLog) << "run(): "
-                                       "not able to generate transects.";
+        qCDebug(RoutingThreadLog) << "run(): "
+                                     "not able to generate transects.";
       } else {
         // Prepare data for routing.
         auto &solutionVector = pRouteData->solutionVector;
@@ -93,24 +93,24 @@ void RoutingThread::run() {
 
         // Check if routing was successful.
         if ((!success || solutionVector.size() < 1) && !this->_restart) {
-          qCWarning(RoutingWorkerLog) << "run(): "
-                                         "routing failed. "
-                                      << snakePar.errorString.c_str();
+          qCDebug(RoutingThreadLog) << "run(): "
+                                       "routing failed. "
+                                    << snakePar.errorString.c_str();
         } else if (this->_restart) {
-          qCWarning(RoutingWorkerLog) << "run(): "
-                                         "restart requested.";
+          qCDebug(RoutingThreadLog) << "run(): "
+                                       "restart requested.";
         } else {
           // Notify main thread.
           emit result(pRouteData);
-          qCWarning(RoutingWorkerLog) << "run(): "
-                                         "concurrent update success.";
+          qCDebug(RoutingThreadLog) << "run(): "
+                                       "concurrent update success.";
         }
       }
     } // end calculation
     else {
-      qCWarning(RoutingWorkerLog) << "run(): generator() failed.";
+      qCDebug(RoutingThreadLog) << "run(): generator() failed.";
     }
-    qCWarning(RoutingWorkerLog)
+    qCDebug(RoutingThreadLog)
         << "run(): execution time: "
         << std::chrono::duration_cast<std::chrono::milliseconds>(
                std::chrono::high_resolution_clock::now() - start)
@@ -125,5 +125,5 @@ void RoutingThread::run() {
     }
     this->_restart = false;
   } // main loop
-  qCWarning(RoutingWorkerLog) << "run(): thread end.";
+  qCDebug(RoutingThreadLog) << "run(): thread end.";
 }

src/Wima/RoutingThread.h

@@ -17,9 +17,9 @@ struct RoutingData {
 };
 
 struct RoutingParameter {
-  RoutingParameter() : numSolutionsPerRun(1), numRuns(1) {}
+  RoutingParameter() : numSolutions(1), numRuns(1) {}
   snake::FPolygon safeArea;
-  std::size_t numSolutionsPerRun;
+  std::size_t numSolutions;
   std::size_t numRuns;
 };
 //!
@@ -31,7 +31,7 @@ class RoutingThread : public QThread {
   using Lock = std::unique_lock<std::mutex>;
 
 public:
-  using PtrRoutingData = QSharedPointer<RoutingData>;
+  using PtrRoutingData = shared_ptr<RoutingData>;
   using Generator = std::function<bool(snake::Transects &)>;
   using Consumer = std::function<void(const RoutingData &)>;
 

src/Wima/Snake/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/Wima/Snake/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/Wima/Snake/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<WimaPlanData>;
+  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/Wima/Snake/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/Wima/Snake/NemoInterface.cpp

@@ -2,6 +2,7 @@
 #include "SnakeTilesLocal.h"
 
 #include "QGCApplication.h"
+#include "QGCLoggingCategory.h"
 #include "QGCToolbox.h"
 #include "SettingsFact.h"
 #include "SettingsManager.h"
@@ -26,6 +27,8 @@
 #include "ros_bridge/rapidjson/include/rapidjson/ostreamwrapper.h"
 #include "ros_bridge/rapidjson/include/rapidjson/writer.h"
 
+QGC_LOGGING_CATEGORY(NemoInterfaceLog, "NemoInterfaceLog")
+
 #define EVENT_TIMER_INTERVAL 100 // ms
 auto static timeoutInterval = std::chrono::milliseconds(3000);
 
@@ -160,28 +163,28 @@ void NemoInterface::Impl::setTileData(const TileData &tileData) {
     if (tile != nullptr) {
       if (tile->coordinateList().size() > 0) {
         if (tile->coordinateList().first().isValid()) {
-          this->ENUOrigin = tile->coordinateList().first();
-          const auto &origin = this->ENUOrigin;
-          this->tilesENU.polygons().clear();
-          for (int i = 0; i < tileData.tiles.count(); ++i) {
-            obj = tileData.tiles.get(i);
-            tile = qobject_cast<const SnakeTile *>(obj);
-            if (tile != nullptr) {
-              SnakeTileLocal tileENU;
-              snake::areaToEnu(origin, tile->coordinateList(), tileENU.path());
-              this->tilesENU.polygons().push_back(std::move(tileENU));
-            } else {
-              qWarning() << "NemoInterface::Impl::setTileData(): nullptr.";
-              break;
-            }
+        this->ENUOrigin = tile->coordinateList().first();
+        const auto &origin = this->ENUOrigin;
+        this->tilesENU.polygons().clear();
+        for (int i = 0; i < tileData.tiles.count(); ++i) {
+          obj = tileData.tiles.get(i);
+          tile = qobject_cast<const SnakeTile *>(obj);
+          if (tile != nullptr) {
+            SnakeTileLocal tileENU;
+            snake::areaToEnu(origin, tile->coordinateList(), tileENU.path());
+            this->tilesENU.polygons().push_back(std::move(tileENU));
+          } else {
+              qCDebug(NemoInterfaceLog) << "Impl::setTileData(): nullptr.";
+            break;
           }
-        } else {
-          qWarning() << "NemoInterface::Impl::setTileData(): Origin invalid.";
         }
       } else {
-        qWarning() << "NemoInterface::Impl::setTileData(): tile empty.";
+          qCDebug(NemoInterfaceLog) << "Impl::setTileData(): Origin invalid.";
       }
+      } else {
+        qCDebug(NemoInterfaceLog) << "Impl::setTileData(): tile empty.";
     }
+  }
   } else {
     this->tileData.clear();
 
@@ -300,12 +303,17 @@ void NemoInterface::Impl::doTopicServiceSetup() {
             std::make_unique<rapidjson::Document>(rapidjson::kObjectType));
         auto &origin = this->ENUOrigin;
         rapidjson::Value jOrigin(rapidjson::kObjectType);
-        bool ret = geographic_msgs::geo_point::toJson(origin, jOrigin,
-                                                      pDoc->GetAllocator());
         lk.unlock();
-        Q_ASSERT(ret);
-        (void)ret;
+        if (geographic_msgs::geo_point::toJson(origin, jOrigin,
+                                               pDoc->GetAllocator())) {
+          lk.unlock();
         pDoc->AddMember("origin", jOrigin, pDoc->GetAllocator());
+        } else {
+          lk.unlock();
+          qCWarning(NemoInterfaceLog)
+              << "/snake/get_origin service: could not create json document.";
+        }
+
         return pDoc;
       });
 
@@ -318,11 +326,17 @@ void NemoInterface::Impl::doTopicServiceSetup() {
         JsonDocUPtr pDoc(
             std::make_unique<rapidjson::Document>(rapidjson::kObjectType));
         rapidjson::Value jSnakeTiles(rapidjson::kObjectType);
-        bool ret = jsk_recognition_msgs::polygon_array::toJson(
-            this->tilesENU, jSnakeTiles, pDoc->GetAllocator());
-        Q_ASSERT(ret);
-        (void)ret;
+
+        if (jsk_recognition_msgs::polygon_array::toJson(
+                this->tilesENU, jSnakeTiles, pDoc->GetAllocator())) {
+          lk.unlock();
         pDoc->AddMember("tiles", jSnakeTiles, pDoc->GetAllocator());
+        } else {
+          lk.unlock();
+          qCWarning(NemoInterfaceLog)
+              << "/snake/get_tiles service: could not create json document.";
+        }
+
         return pDoc;
       });
 }
@@ -336,7 +350,7 @@ void NemoInterface::Impl::loop() {
     } else if (this->pRosBridge->isRunning() && this->pRosBridge->connected() &&
                !this->topicServiceSetupDone) {
       this->doTopicServiceSetup();
-      this->topicServiceSetupDone = true;
+        this->topicServiceSetupDone = true;
 
       this->setStatus(STATUS::WEBSOCKET_DETECTED);
     } else if (this->pRosBridge->isRunning() &&
@@ -379,22 +393,26 @@ void NemoInterface::Impl::publishTilesENU() {
   using namespace ros_bridge::messages;
   JsonDocUPtr jSnakeTiles(
       std::make_unique<rapidjson::Document>(rapidjson::kObjectType));
-  bool ret = jsk_recognition_msgs::polygon_array::toJson(
-      this->tilesENU, *jSnakeTiles, jSnakeTiles->GetAllocator());
-  Q_ASSERT(ret);
-  (void)ret;
+  if (jsk_recognition_msgs::polygon_array::toJson(
+          this->tilesENU, *jSnakeTiles, jSnakeTiles->GetAllocator())) {
   this->pRosBridge->publish(std::move(jSnakeTiles), "/snake/tiles");
+  } else {
+    qCWarning(NemoInterfaceLog)
+        << "Impl::publishTilesENU: could not create json document.";
+  }
 }
 
 void NemoInterface::Impl::publishENUOrigin() {
   using namespace ros_bridge::messages;
   JsonDocUPtr jOrigin(
       std::make_unique<rapidjson::Document>(rapidjson::kObjectType));
-  bool ret = geographic_msgs::geo_point::toJson(this->ENUOrigin, *jOrigin,
-                                                jOrigin->GetAllocator());
-  Q_ASSERT(ret);
-  (void)ret;
+  if (geographic_msgs::geo_point::toJson(this->ENUOrigin, *jOrigin,
+                                         jOrigin->GetAllocator())) {
   this->pRosBridge->publish(std::move(jOrigin), "/snake/origin");
+  } else {
+    qCWarning(NemoInterfaceLog)
+        << "Impl::publishENUOrigin: could not create json document.";
+  }
 }
 
 bool NemoInterface::Impl::setStatus(NemoInterface::STATUS s) {
@@ -421,7 +439,7 @@ void NemoInterface::stop() { this->pImpl->stop(); }
 void NemoInterface::publishTileData() { this->pImpl->publishTileData(); }
 
 void NemoInterface::requestProgress() {
-  qWarning() << "NemoInterface::requestProgress(): dummy.";
+  qCWarning(NemoInterfaceLog) << "requestProgress(): dummy.";
 }
 
 void NemoInterface::setTileData(const TileData &tileData) {

src/Wima/Snake/SnakeTile.cpp

@@ -18,8 +18,6 @@ QString SnakeTile::type() const { return "Tile"; }
 SnakeTile *SnakeTile::Clone() const { return new SnakeTile(*this); }
 
 SnakeTile &SnakeTile::operator=(const SnakeTile &other) {
-  this->assign(other);
+  this->WimaAreaData::operator=(other);
   return *this;
 }
-
-void SnakeTile::assign(const SnakeTile &other) { WimaAreaData::assign(other); }

src/Wima/Snake/json/CircularGenerator.SettingsGroup.json

+[
+{
+    "name":             "TransectDistance",
+    "shortDescription": "The distance between transects.",
+    "type":             "double",
+    "units":            "m",
+    "min":              0.3,
+    "decimalPlaces":    1,
+    "defaultValue":     5.0
+},
+{
+    "name":             "DeltaAlpha",
+    "shortDescription": "Angle discretisation.",
+    "type":             "double",
+    "units":            "Deg",
+    "min":              0.3,
+    "max":              90,
+    "decimalPlaces":    1,
+    "defaultValue":     5.0
+},
+{
+    "name":             "MinLength",
+    "shortDescription": "The minimal transect length.",
+    "type":             "double",
+    "units":            "m",
+    "min":              0.3,
+    "decimalPlaces":    1,
+    "defaultValue":     5.0
+}
+]

src/Wima/Snake/json/LinearGenerator.SettingsGroup.json

+[
+{
+    "name":             "TransectDistance",
+    "shortDescription": "The distance between transects.",
+    "type":             "double",
+    "units":            "m",
+    "min":              0.3,
+    "decimalPlaces":    1,
+    "defaultValue":     5.0
+},
+{
+    "name":             "Alpha",
+    "shortDescription": "Transect angle.",
+    "type":             "double",
+    "units":            "Deg",
+    "min":              0,
+    "max":              180,
+    "decimalPlaces":    1,
+    "defaultValue":     0.0
+},
+{
+    "name":             "MinLength",
+    "shortDescription": "The minimal transect length.",
+    "type":             "double",
+    "units":            "m",
+    "min":              0.3,
+    "decimalPlaces":    1,
+    "defaultValue":     5.0
+}
+]

src/Wima/Snake/snake.cpp

@@ -760,7 +760,17 @@ bool route(const FPolygon &area, const Transects &transects,
       if (std::isinf(dist)) {
         std::vector<std::size_t> route;
         if (!dijkstraAlgorithm(n, i, j, route, dist, distLambda)) {
-          par.errorString = "Distance matrix calculation failed.";
+          std::stringstream ss;
+          ss << "Distance matrix calculation failed. connection graph: "
+             << connectionGraph << std::endl;
+          ss << "area: " << bg::wkt(area) << std::endl;
+          ss << "transects:" << std::endl;
+          for (const auto &t : transects) {
+
+            ss << bg::wkt(t) << std::endl;
+          }
+
+          par.errorString = ss.str();
           return false;
         }
         (void)route;

src/Wima/WimaController.cc

@@ -230,74 +230,53 @@ void WimaController::planDataChangedHandler() {
   _serviceArea = WimaServiceAreaData();
   _corridor = WimaCorridorData();
   _joinedArea = WimaJoinedAreaData();
+  _planDataValid = false;
 
   emit visualItemsChanged();
   emit missionItemsChanged();
   emit waypointPathChanged();
 
-  _planDataValid = false;
-
+  // Extract areas.
   auto planData = WimaBridge::instance()->planData();
-  // extract list with WimaAreas
-  QList<const WimaAreaData *> areaList = planData.areaList();
-
-  int areaCounter = 0;
-  const int numAreas = 4; // extract only numAreas Areas, if there are more
-                          // they are invalid and ignored
-  for (int i = 0; i < areaList.size(); i++) {
-    const WimaAreaData *areaData = areaList[i];
-
-    if (areaData->type() ==
-        WimaServiceAreaData::typeString) { // is it a service area?
-      _serviceArea = *qobject_cast<const WimaServiceAreaData *>(areaData);
-      areaCounter++;
-      _areas.append(&_serviceArea);
-
-      continue;
-    }
 
-    if (areaData->type() ==
-        WimaMeasurementAreaData::typeString) { // is it a measurement area?
-      _measurementArea =
-          *qobject_cast<const WimaMeasurementAreaData *>(areaData);
-      areaCounter++;
-      _areas.append(&_measurementArea);
+  // Measurement Area.
+  if (planData.measurementArea().coordinateList().size() >= 3) {
+    _measurementArea = planData.measurementArea();
+    _areas.append(&_measurementArea);
 
-      continue;
-    }
+    // Service Area.
+    if (planData.serviceArea().coordinateList().size() >= 3) {
+      _serviceArea = planData.serviceArea();
+      _areas.append(&_serviceArea);
 
-    if (areaData->type() == WimaCorridorData::typeString) { // is it a corridor?
-      _corridor = *qobject_cast<const WimaCorridorData *>(areaData);
-      areaCounter++;
-      //_visualItems.append(&_corridor); // not needed
+      _WMSettings.setHomePosition(
+          QGeoCoordinate(_serviceArea.depot().latitude(),
+                         _serviceArea.depot().longitude(), 0));
 
-      continue;
-    }
+      // Joined Area.
+      if (planData.joinedArea().coordinateList().size() >= 3) {
+        _joinedArea = planData.joinedArea();
+        _areas.append(&_joinedArea);
 
-    if (areaData->type() ==
-        WimaJoinedAreaData::typeString) { // is it a corridor?
-      _joinedArea = *qobject_cast<const WimaJoinedAreaData *>(areaData);
-      areaCounter++;
-      _areas.append(&_joinedArea);
+        _planDataValid = true;
 
-      continue;
+        // Corridor.
+        if (planData.corridor().coordinateList().size() >= 3) {
+          _corridor = planData.corridor();
+        }
+      }
     }
-
-    if (areaCounter >= numAreas)
-      break;
   }
 
-  if (areaCounter != numAreas) {
-    Q_ASSERT(false);
-    return;
+  if (_planDataValid) {
+    emit visualItemsChanged();
+  } else {
+    _areas.clear();
+    _measurementArea = WimaMeasurementAreaData();
+    _serviceArea = WimaServiceAreaData();
+    _corridor = WimaCorridorData();
+    _joinedArea = WimaJoinedAreaData();
   }
-
-  emit visualItemsChanged();
-
-  _WMSettings.setHomePosition(QGeoCoordinate(
-      _serviceArea.depot().latitude(), _serviceArea.depot().longitude(), 0));
-
-  _planDataValid = true;
 }
 
 void WimaController::progressChangedHandler() {

src/Wima/WimaPlanData.h

@@ -18,33 +18,47 @@ public:
   WimaPlanData &operator=(const WimaPlanData &other);
 
   // Member Methodes
-  void append(const WimaJoinedAreaData &areaData);
-  void append(const WimaServiceAreaData &areaData);
-  void append(const WimaCorridorData &areaData);
-  void append(const WimaMeasurementAreaData &areaData);
-
-  void setTransects(const QList<QList<QGeoCoordinate>> &transects);
-  //!
-  //! \brief append
-  //! \param missionItems
-  //! \note Takes owenership of MissionItems*
-  void append(const QList<MissionItem *> &missionItems);
+  void set(const WimaJoinedAreaData &areaData);
+  void set(const WimaServiceAreaData &areaData);
+  void set(const WimaCorridorData &areaData);
+  void set(const WimaMeasurementAreaData &areaData);
+
+  void set(const WimaJoinedArea &areaData);
+  void set(const WimaServiceArea &areaData);
+  void set(const WimaCorridor &areaData);
+  void set(const WimaMeasurementArea &areaData);
   void clear();
 
-  const QList<const WimaAreaData *> &areaList() const;
-  const QList<QList<QGeoCoordinate>> &transects() const;
-  const QList<MissionItem *> &missionItems() const;
+  const WimaJoinedAreaData &joinedArea() const;
+  const WimaServiceAreaData &serviceArea() const;
+  const WimaCorridorData &corridor() const;
+  const WimaMeasurementAreaData &measurementArea() const;
+
+  WimaJoinedAreaData &joinedArea();
+  WimaServiceAreaData &serviceArea();
+  WimaCorridorData &corridor();
+  WimaMeasurementAreaData &measurementArea();
+
+  QGeoCoordinate origin();
+  bool isValid();
 
   bool operator==(const WimaPlanData &other) const;
   bool operator!=(const WimaPlanData &other) const;
 
 signals:
-  void areaListChanged();
+  void joinedAreaChanged();
+  void serviceAreaChanged();
+  void corridorChanged();
+  void measurementAreaChanged();
+  void originChanged();
 
 private:
+  void setOrigin(const QGeoCoordinate &origin);
+
   WimaJoinedAreaData _joinedArea;
   WimaServiceAreaData _serviceArea;
   WimaCorridorData _corridor;
   WimaMeasurementAreaData _measurementArea;
-  QList<const WimaAreaData *> _areaList;
+
+  QGeoCoordinate _origin;
 };