libGeographic dependency removed, snake namespace renamed to geometry,...

libGeographic dependency removed, snake namespace renamed to geometry, geometry.h and geometry.cpp cleared up

QGCCommon.pri

@@ -35,6 +35,8 @@ linux {
             QMAKE_CXXFLAGS_WARN_ON += -Werror \
                 -Wno-deprecated-copy \      # These come from mavlink headers
                 -Wno-unused-parameter \     # gst_plugins-good has these errors
+                -Wno-ignored-qualifiers\  # or-tools has these errors
+                -Wno-sign-compare\  # or-tools has these errors
                 -Wno-implicit-fallthrough   # gst_plugins-good has these errors
         }
     } else : linux-rasp-pi2-g++ {

qgroundcontrol.pro

@@ -445,6 +445,7 @@ contains (DEFINES, QGC_ENABLE_PAIRING) {
 #
 
 HEADERS += \
+    src/MeasurementComplexItem/geometry/geometry.h \
     src/QmlControls/QmlUnitsConversion.h \
     src/MeasurementComplexItem/geometry/GeoArea.h \
     src/MeasurementComplexItem/geometry/MeasurementArea.h \
@@ -479,7 +480,6 @@ HEADERS += \
     src/MeasurementComplexItem/geometry/mapbox/recursive_wrapper.hpp \
     src/MeasurementComplexItem/geometry/mapbox/variant.hpp \
     src/MeasurementComplexItem/geometry/mapbox/variant_io.hpp \
-    src/MeasurementComplexItem/geometry/snake.h \
     src/MeasurementComplexItem/geometry/GenericPolygon.h \
     src/MeasurementComplexItem/geometry/GenericPolygonArray.h \
     src/MeasurementComplexItem/geometry/GeoPoint3D.h \
@@ -524,6 +524,7 @@ SOURCES += \
     src/MeasurementComplexItem/geometry/GeoArea.cc \
     src/MeasurementComplexItem/geometry/MeasurementArea.cc \
     src/MeasurementComplexItem/geometry/SafeArea.cc \
+    src/MeasurementComplexItem/geometry/geometry.cpp \
     src/Vehicle/VehicleEscStatusFactGroup.cc \
     src/MeasurementComplexItem/AreaData.cc \
     src/api/QGCCorePlugin.cc \
@@ -537,7 +538,6 @@ SOURCES += \
     src/MeasurementComplexItem/GeneratorBase.cc \
     src/MeasurementComplexItem/LinearGenerator.cpp \
     src/MeasurementComplexItem/geometry/clipper/clipper.cpp \
-    src/MeasurementComplexItem/geometry/snake.cpp \
     src/MeasurementComplexItem/geometry/GeoPoint3D.cpp \
     src/MeasurementComplexItem/NemoInterface.cpp \
     src/MeasurementComplexItem/nemo_interface/QNemoProgress.cc \

src/MeasurementComplexItem/AreaData.cc

@@ -2,7 +2,7 @@
 
 #include "geometry/MeasurementArea.h"
 #include "geometry/SafeArea.h"
-#include "geometry/snake.h"
+#include "geometry/geometry.h"
 
 #include "JsonHelper.h"
 #include "QGCApplication.h"
@@ -116,10 +116,10 @@ bool AreaData::isCorrect(bool showError) {
     return false;
   }
   const auto &origin = this->origin();
-  snake::FPolygon safeAreaENU;
-  snake::areaToEnu(origin, safeArea->pathModel(), safeAreaENU);
-  snake::FPolygon measurementAreaENU;
-  snake::areaToEnu(origin, measurementArea->pathModel(), measurementAreaENU);
+  geometry::FPolygon safeAreaENU;
+  geometry::areaToEnu(origin, safeArea->pathModel(), safeAreaENU);
+  geometry::FPolygon measurementAreaENU;
+  geometry::areaToEnu(origin, measurementArea->pathModel(), measurementAreaENU);
   //  qDebug() << "origin" << origin;
   //  std::stringstream ss;
   //  ss << "measurementAreaENU: " << bg::wkt(measurementAreaENU) << std::endl;
@@ -218,14 +218,14 @@ void AreaData::intersection(bool showError) {
 
       // convert to ENU
       const auto origin = this->origin();
-      snake::FPolygon safeAreaENU;
-      snake::areaToEnu(origin, safeArea->pathModel(), safeAreaENU);
-      snake::FPolygon measurementAreaENU;
-      snake::areaToEnu(origin, measurementArea->pathModel(),
+      geometry::FPolygon safeAreaENU;
+      geometry::areaToEnu(origin, safeArea->pathModel(), safeAreaENU);
+      geometry::FPolygon measurementAreaENU;
+      geometry::areaToEnu(origin, measurementArea->pathModel(),
                        measurementAreaENU);
 
       // do intersection
-      std::deque<snake::FPolygon> outputENU;
+      std::deque<geometry::FPolygon> outputENU;
       boost::geometry::intersection(measurementAreaENU, safeAreaENU, outputENU);
 
       if (outputENU.size() < 1 || outputENU[0].outer().size() < 4) {
@@ -246,9 +246,9 @@ void AreaData::intersection(bool showError) {
 
       // Shrink the result if safeAreaENU doesn't cover it.
       auto large = std::move(outputENU[0]);
-      snake::FPolygon small;
+      geometry::FPolygon small;
       while (!bg::covered_by(large, safeAreaENU)) {
-        snake::offsetPolygon(large, small, -0.1);
+        geometry::offsetPolygon(large, small, -0.1);
         large = std::move(small);
       }
 
@@ -259,7 +259,7 @@ void AreaData::intersection(bool showError) {
         for (auto it = large.outer().begin(); it != large.outer().end() - 1;
              ++it) {
           QGeoCoordinate c;
-          snake::fromENU(origin, *it, c);
+          geometry::fromENU(origin, *it, c);
           measurementArea->appendVertex(c);
         }
       }

src/MeasurementComplexItem/CircularGenerator.cpp

@@ -31,11 +31,12 @@ const char *minLengthKey = "MinLength";
 const char *referenceKey = "ReferencePoint";
 } // namespace
 
-bool circularTransects(const snake::FPoint &reference,
-                       const snake::FPolygon &polygon,
-                       const std::vector<snake::FPolygon> &tiles,
-                       snake::Length deltaR, snake::Angle deltaAlpha,
-                       snake::Length minLength, snake::Transects &transects);
+bool circularTransects(const geometry::FPoint &reference,
+                       const geometry::FPolygon &polygon,
+                       const std::vector<geometry::FPolygon> &tiles,
+                       geometry::Length deltaR, geometry::Angle deltaAlpha,
+                       geometry::Length minLength,
+                       geometry::LineStringArray &transects);
 
 const char *CircularGenerator::settingsGroup = "CircularGenerator";
 const char *CircularGenerator::typeString = "CircularGenerator";
@@ -76,7 +77,7 @@ QString CircularGenerator::abbreviation() const { return tr("C. Gen."); }
 
 QString CircularGenerator::type() const { return typeString; }
 
-bool CircularGenerator::get(Generator &generator) {
+bool CircularGenerator::get(Work &work) {
   if (this->_d) {
     if (this->_d->isCorrect()) {
       // Prepare data.
@@ -93,8 +94,8 @@ bool CircularGenerator::get(Generator &generator) {
         qCDebug(CircularGeneratorLog) << "get(): reference invalid." << ref;
         return false;
       }
-      snake::FPoint reference;
-      snake::toENU(origin, ref, reference);
+      geometry::FPoint reference;
+      geometry::toENU(origin, ref, reference);
 
       auto measurementArea =
           getGeoArea<const MeasurementArea *>(*this->_d->areaList());
@@ -114,13 +115,13 @@ bool CircularGenerator::get(Generator &generator) {
           return false;
         }
       }
-      auto pPolygon = std::make_shared<snake::FPolygon>();
-      snake::areaToEnu(origin, geoPolygon, *pPolygon);
+      auto pPolygon = std::make_shared<geometry::FPolygon>();
+      geometry::areaToEnu(origin, geoPolygon, *pPolygon);
 
       // Progress and tiles.
       const auto &progress = measurementArea->progress();
       const auto *tiles = measurementArea->tiles();
-      auto pTiles = std::make_shared<std::vector<snake::FPolygon>>();
+      auto pTiles = std::make_shared<std::vector<geometry::FPolygon>>();
       if (progress.size() == tiles->count()) {
         for (int i = 0; i < tiles->count(); ++i) {
           if (progress[i] == 100) {
@@ -128,8 +129,8 @@ bool CircularGenerator::get(Generator &generator) {
             const auto *tile = qobject_cast<const SnakeTile *>(obj);
 
             if (tile != nullptr) {
-              snake::FPolygon tileENU;
-              snake::areaToEnu(origin, tile->coordinateList(), tileENU);
+              geometry::FPolygon tileENU;
+              geometry::areaToEnu(origin, tile->coordinateList(), tileENU);
               pTiles->push_back(std::move(tileENU));
             } else {
               qCDebug(CircularGeneratorLog)
@@ -154,22 +155,22 @@ bool CircularGenerator::get(Generator &generator) {
         qCDebug(CircularGeneratorLog) << "get(): depot invalid." << geoDepot;
         return false;
       }
-      snake::FPoint depot;
-      snake::toENU(origin, geoDepot, depot);
+      geometry::FPoint depot;
+      geometry::toENU(origin, geoDepot, depot);
 
       // Fetch transect parameter.
-      auto distance =
-          snake::Length(this->_distance.rawValue().toDouble() * bu::si::meter);
-      auto minLength =
-          snake::Length(this->_minLength.rawValue().toDouble() * bu::si::meter);
-      auto alpha = snake::Angle(this->_deltaAlpha.rawValue().toDouble() *
-                                bu::degree::degree);
-
-      generator = [reference, depot, pPolygon, pTiles, distance, alpha,
-                   minLength](snake::Transects &transects) -> bool {
+      auto distance = geometry::Length(this->_distance.rawValue().toDouble() *
+                                       bu::si::meter);
+      auto minLength = geometry::Length(this->_minLength.rawValue().toDouble() *
+                                        bu::si::meter);
+      auto alpha = geometry::Angle(this->_deltaAlpha.rawValue().toDouble() *
+                                   bu::degree::degree);
+
+      work = [reference, depot, pPolygon, pTiles, distance, alpha,
+              minLength](geometry::LineStringArray &transects) -> bool {
         bool value = circularTransects(reference, *pPolygon, *pTiles, distance,
                                        alpha, minLength, transects);
-        transects.insert(transects.begin(), snake::FLineString{depot});
+        transects.insert(transects.begin(), geometry::FLineString{depot});
         return value;
       };
       return true;
@@ -413,11 +414,12 @@ void CircularGenerator::setMeasurementArea(MeasurementArea *area) {
   }
 }
 
-bool circularTransects(const snake::FPoint &reference,
-                       const snake::FPolygon &polygon,
-                       const std::vector<snake::FPolygon> &tiles,
-                       snake::Length deltaR, snake::Angle deltaAlpha,
-                       snake::Length minLength, snake::Transects &transects) {
+bool circularTransects(const geometry::FPoint &reference,
+                       const geometry::FPolygon &polygon,
+                       const std::vector<geometry::FPolygon> &tiles,
+                       geometry::Length deltaR, geometry::Angle deltaAlpha,
+                       geometry::Length minLength,
+                       geometry::LineStringArray &transects) {
   auto s1 = std::chrono::high_resolution_clock::now();
 
   // Check preconitions
@@ -435,15 +437,16 @@ bool circularTransects(const snake::FPoint &reference,
       qCDebug(CircularGeneratorLog) << ss.str().c_str();
     } else {
       // Calculate polygon distances and angles.
-      std::vector<snake::Length> distances;
+      std::vector<geometry::Length> distances;
       distances.reserve(polygon.outer().size());
-      std::vector<snake::Angle> angles;
+      std::vector<geometry::Angle> angles;
       angles.reserve(polygon.outer().size());
       //      qCDebug(CircularGeneratorLog) << "circularTransects():";
       for (const auto &p : polygon.outer()) {
-        snake::Length distance = bg::distance(reference, p) * si::meter;
+        geometry::Length distance = bg::distance(reference, p) * si::meter;
         distances.push_back(distance);
-        snake::Angle alpha = (std::atan2(p.get<1>(), p.get<0>())) * si::radian;
+        geometry::Angle alpha =
+            (std::atan2(p.get<1>(), p.get<0>())) * si::radian;
         alpha = alpha < 0 * si::radian ? alpha + 2 * M_PI * si::radian : alpha;
         angles.push_back(alpha);
         //        qCDebug(CircularGeneratorLog) << "distances, angles,
@@ -456,8 +459,8 @@ bool circularTransects(const snake::FPoint &reference,
       }
 
       auto rMin = deltaR; // minimal circle radius
-      snake::Angle alpha1(0 * degree::degree);
-      snake::Angle alpha2(360 * degree::degree);
+      geometry::Angle alpha1(0 * degree::degree);
+      geometry::Angle alpha2(360 * degree::degree);
       // Determine r_min by successive approximation
       if (!bg::within(reference, polygon.outer())) {
         rMin = bg::distance(reference, polygon) * si::meter;
@@ -478,7 +481,7 @@ bool circularTransects(const snake::FPoint &reference,
       // Generate circle sectors.
       auto rScaled = rMinScaled;
       const auto nTran = long(std::ceil(((rMax - rMin) / deltaR).value()));
-      vector<ClipperLib::Path> sectors(nTran, ClipperLib::Path());
+      std::vector<ClipperLib::Path> sectors(nTran, ClipperLib::Path());
       const auto nSectors =
           long(std::round(((alpha2 - alpha1) / deltaAlpha).value()));
       //      qCDebug(CircularGeneratorLog) << "circularTransects(): sector
@@ -504,8 +507,8 @@ bool circularTransects(const snake::FPoint &reference,
       }
       // Clip sectors to polygonENU.
       ClipperLib::Path polygonClipper;
-      snake::FPolygon shrinked;
-      snake::offsetPolygon(polygon, shrinked, -0.3);
+      geometry::FPolygon shrinked;
+      geometry::offsetPolygon(polygon, shrinked, -0.3);
       auto &outer = shrinked.outer();
       polygonClipper.reserve(outer.size());
       for (auto it = outer.begin(); it < outer.end() - 1; ++it) {
@@ -522,7 +525,7 @@ bool circularTransects(const snake::FPoint &reference,
 
       // Subtract holes.
       if (tiles.size() > 0) {
-        vector<ClipperLib::Path> processedTiles;
+        std::vector<ClipperLib::Path> processedTiles;
         for (const auto &tile : tiles) {
           ClipperLib::Path path;
           for (const auto &v : tile.outer()) {
@@ -546,12 +549,12 @@ bool circularTransects(const snake::FPoint &reference,
       // Extract transects from  PolyTree and convert them to
       // BoostLineString
       for (const auto &child : transectsClipper.Childs) {
-        snake::FLineString transect;
+        geometry::FLineString transect;
         transect.reserve(child->Contour.size());
         for (const auto &vertex : child->Contour) {
           auto x = static_cast<double>(vertex.X) / CLIPPER_SCALE;
           auto y = static_cast<double>(vertex.Y) / CLIPPER_SCALE;
-          transect.push_back(snake::FPoint(x, y));
+          transect.push_back(geometry::FPoint(x, y));
         }
         transects.push_back(transect);
       }
@@ -562,7 +565,7 @@ bool circularTransects(const snake::FPoint &reference,
         for (auto iti = ito + 1; iti < transects.end(); ++iti) {
           auto dist1 = bg::distance(ito->front(), iti->front());
           if (dist1 < th) {
-            snake::FLineString temp;
+            geometry::FLineString temp;
             for (auto it = iti->end() - 1; it >= iti->begin(); --it) {
               temp.push_back(*it);
             }
@@ -573,7 +576,7 @@ bool circularTransects(const snake::FPoint &reference,
           }
           auto dist2 = bg::distance(ito->front(), iti->back());
           if (dist2 < th) {
-            snake::FLineString temp;
+            geometry::FLineString temp;
             temp.insert(temp.end(), iti->begin(), iti->end());
             temp.insert(temp.end(), ito->begin(), ito->end());
             *ito = temp;
@@ -582,7 +585,7 @@ bool circularTransects(const snake::FPoint &reference,
           }
           auto dist3 = bg::distance(ito->back(), iti->front());
           if (dist3 < th) {
-            snake::FLineString temp;
+            geometry::FLineString temp;
             temp.insert(temp.end(), ito->begin(), ito->end());
             temp.insert(temp.end(), iti->begin(), iti->end());
             *ito = temp;
@@ -591,7 +594,7 @@ bool circularTransects(const snake::FPoint &reference,
           }
           auto dist4 = bg::distance(ito->back(), iti->back());
           if (dist4 < th) {
-            snake::FLineString temp;
+            geometry::FLineString temp;
             temp.insert(temp.end(), ito->begin(), ito->end());
             for (auto it = iti->end() - 1; it >= iti->begin(); --it) {
               temp.push_back(*it);

src/MeasurementComplexItem/CircularGenerator.h

@@ -26,7 +26,7 @@ public:
   virtual QString abbreviation() const override;
   virtual QString type() const override;
 
-  virtual bool get(Generator &generator) override;
+  virtual bool get(Work &work) override;
 
   QGeoCoordinate reference() const;
   Fact *distance();

src/MeasurementComplexItem/GeneratorBase.h

@@ -7,7 +7,7 @@
 #include <functional>
 #include <memory>
 
-#include "geometry/snake.h"
+#include "geometry/geometry.h"
 
 #include "AreaData.h"
 
@@ -17,7 +17,7 @@ class GeneratorBase : public QObject {
   Q_OBJECT
 public:
   using Data = AreaData *;
-  using Generator = std::function<bool(snake::Transects &)>;
+  using Work = std::function<bool(geometry::LineStringArray &)>;
 
   explicit GeneratorBase(QObject *parent = nullptr);
   explicit GeneratorBase(Data d, QObject *parent = nullptr);
@@ -39,7 +39,7 @@ public:
   virtual QString abbreviation() const = 0;
   virtual QString type() const = 0;
 
-  virtual bool get(Generator &generator) = 0;
+  virtual bool get(Work &work) = 0;
 
   Data data() const;
   void setData(Data d);

src/MeasurementComplexItem/LinearGenerator.cpp

@@ -23,10 +23,11 @@ const char *minLengthKey = "MinLength";
 
 QGC_LOGGING_CATEGORY(LinearGeneratorLog, "LinearGeneratorLog")
 
-bool linearTransects(const snake::FPolygon &polygon,
-                     const std::vector<snake::FPolygon> &tiles,
-                     snake::Length distance, snake::Angle angle,
-                     snake::Length minLength, snake::Transects &transects);
+bool linearTransects(const geometry::FPolygon &polygon,
+                     const std::vector<geometry::FPolygon> &tiles,
+                     geometry::Length distance, geometry::Angle angle,
+                     geometry::Length minLength,
+                     geometry::LineStringArray &transects);
 
 const char *LinearGenerator::settingsGroup = "LinearGenerator";
 const char *LinearGenerator::typeString = "LinearGenerator";
@@ -67,7 +68,7 @@ QString LinearGenerator::abbreviation() const {
 
 QString LinearGenerator::type() const { return typeString; }
 
-bool LinearGenerator::get(Generator &generator) {
+bool LinearGenerator::get(Work &generator) {
   if (_d != nullptr) {
     if (this->_d->isCorrect()) {
       // Prepare data.
@@ -95,13 +96,13 @@ bool LinearGenerator::get(Generator &generator) {
           return false;
         }
       }
-      auto pPolygon = std::make_shared<snake::FPolygon>();
-      snake::areaToEnu(origin, geoPolygon, *pPolygon);
+      auto pPolygon = std::make_shared<geometry::FPolygon>();
+      geometry::areaToEnu(origin, geoPolygon, *pPolygon);
 
       // Progress and tiles.
       const auto &progress = measurementArea->progress();
       const auto *tiles = measurementArea->tiles();
-      auto pTiles = std::make_shared<std::vector<snake::FPolygon>>();
+      auto pTiles = std::make_shared<std::vector<geometry::FPolygon>>();
       if (progress.size() == tiles->count()) {
         for (int i = 0; i < tiles->count(); ++i) {
           if (progress[i] == 100) {
@@ -109,8 +110,8 @@ bool LinearGenerator::get(Generator &generator) {
             const auto *tile = qobject_cast<const SnakeTile *>(obj);
 
             if (tile != nullptr) {
-              snake::FPolygon tileENU;
-              snake::areaToEnu(origin, tile->coordinateList(), tileENU);
+              geometry::FPolygon tileENU;
+              geometry::areaToEnu(origin, tile->coordinateList(), tileENU);
               pTiles->push_back(std::move(tileENU));
             } else {
               qCDebug(LinearGeneratorLog) << "get(): tile == nullptr";
@@ -134,21 +135,21 @@ bool LinearGenerator::get(Generator &generator) {
         qCDebug(LinearGeneratorLog) << "get(): depot invalid." << geoDepot;
         return false;
       }
-      snake::FPoint depot;
-      snake::toENU(origin, geoDepot, depot);
+      geometry::FPoint depot;
+      geometry::toENU(origin, geoDepot, depot);
 
       // Fetch transect parameter.
-      auto distance =
-          snake::Length(this->_distance.rawValue().toDouble() * bu::si::meter);
-      auto minLength =
-          snake::Length(this->_minLength.rawValue().toDouble() * bu::si::meter);
-      auto alpha =
-          snake::Angle(this->_alpha.rawValue().toDouble() * bu::degree::degree);
+      auto distance = geometry::Length(this->_distance.rawValue().toDouble() *
+                                       bu::si::meter);
+      auto minLength = geometry::Length(this->_minLength.rawValue().toDouble() *
+                                        bu::si::meter);
+      auto alpha = geometry::Angle(this->_alpha.rawValue().toDouble() *
+                                   bu::degree::degree);
       generator = [depot, pPolygon, pTiles, distance, alpha,
-                   minLength](snake::Transects &transects) -> bool {
+                   minLength](geometry::LineStringArray &transects) -> bool {
         bool value = linearTransects(*pPolygon, *pTiles, distance, alpha,
                                      minLength, transects);
-        transects.insert(transects.begin(), snake::FLineString{depot});
+        transects.insert(transects.begin(), geometry::FLineString{depot});
         return value;
       };
       return true;
@@ -326,10 +327,11 @@ void LinearGenerator::setMeasurementArea(MeasurementArea *area) {
   }
 }
 
-bool linearTransects(const snake::FPolygon &polygon,
-                     const std::vector<snake::FPolygon> &tiles,
-                     snake::Length distance, snake::Angle angle,
-                     snake::Length minLength, snake::Transects &transects) {
+bool linearTransects(const geometry::FPolygon &polygon,
+                     const std::vector<geometry::FPolygon> &tiles,
+                     geometry::Length distance, geometry::Angle angle,
+                     geometry::Length minLength,
+                     geometry::LineStringArray &transects) {
   namespace tr = bg::strategy::transform;
   auto s1 = std::chrono::high_resolution_clock::now();
 
@@ -349,9 +351,9 @@ bool linearTransects(const snake::FPolygon &polygon,
       tr::rotate_transformer<bg::degree, double, 2, 2> rotate(angle.value() *
                                                               180 / M_PI);
       // Rotate polygon by angle and calculate bounding box.
-      snake::FPolygon polygonENURotated;
+      geometry::FPolygon polygonENURotated;
       bg::transform(polygon.outer(), polygonENURotated.outer(), rotate);
-      snake::FBox box;
+      geometry::FBox box;
       boost::geometry::envelope(polygonENURotated, box);
       double x0 = box.min_corner().get<0>();
       double y0 = box.min_corner().get<1>();
@@ -360,17 +362,17 @@ bool linearTransects(const snake::FPolygon &polygon,
 
       // Generate transects and convert them to clipper path.
       size_t num_t = ceil((y1 - y0) / distance.value()); // number of transects
-      vector<ClipperLib::Path> transectsClipper;
+      std::vector<ClipperLib::Path> transectsClipper;
       transectsClipper.reserve(num_t);
       for (size_t i = 0; i < num_t; ++i) {
         // calculate transect
-        snake::FPoint v1{x0, y0 + i * distance.value()};
-        snake::FPoint v2{x1, y0 + i * distance.value()};
-        snake::FLineString transect;
+        geometry::FPoint v1{x0, y0 + i * distance.value()};
+        geometry::FPoint v2{x1, y0 + i * distance.value()};
+        geometry::FLineString transect;
         transect.push_back(v1);
         transect.push_back(v2);
         // transform back
-        snake::FLineString temp_transect;
+        geometry::FLineString temp_transect;
         tr::rotate_transformer<bg::degree, double, 2, 2> rotate_back(
             -angle.value() * 180 / M_PI);
         bg::transform(transect, temp_transect, rotate_back);
@@ -397,8 +399,8 @@ bool linearTransects(const snake::FPolygon &polygon,
       }
 
       // Convert measurement area to clipper path.
-      snake::FPolygon shrinked;
-      snake::offsetPolygon(polygon, shrinked, -0.2);
+      geometry::FPolygon shrinked;
+      geometry::offsetPolygon(polygon, shrinked, -0.2);
       auto &outer = shrinked.outer();
       ClipperLib::Path polygonClipper;
       for (auto vertex : outer) {
@@ -418,7 +420,7 @@ bool linearTransects(const snake::FPolygon &polygon,
 
       // Subtract holes.
       if (tiles.size() > 0) {
-        vector<ClipperLib::Path> processedTiles;
+        std::vector<ClipperLib::Path> processedTiles;
         for (const auto &tile : tiles) {
           ClipperLib::Path path;
           for (const auto &v : tile.outer()) {
@@ -442,14 +444,14 @@ bool linearTransects(const snake::FPolygon &polygon,
       // Extract transects from  PolyTree and convert them to BoostLineString
       for (const auto &child : clippedTransecs.Childs) {
         const auto &clipperTransect = child->Contour;
-        snake::FPoint v1{
+        geometry::FPoint v1{
             static_cast<double>(clipperTransect[0].X) / CLIPPER_SCALE,
             static_cast<double>(clipperTransect[0].Y) / CLIPPER_SCALE};
-        snake::FPoint v2{
+        geometry::FPoint v2{
             static_cast<double>(clipperTransect[1].X) / CLIPPER_SCALE,
             static_cast<double>(clipperTransect[1].Y) / CLIPPER_SCALE};
 
-        snake::FLineString transect{v1, v2};
+        geometry::FLineString transect{v1, v2};
         if (bg::length(transect) >= minLength.value()) {
           transects.push_back(transect);
         }

src/MeasurementComplexItem/LinearGenerator.h

@@ -25,7 +25,7 @@ public:
   virtual QString abbreviation() const override;
   virtual QString type() const override;
 
-  virtual bool get(Generator &generator) override;
+  virtual bool get(Work &generator) override;
 
   //!
   //! \brief save Saves the generator.

src/MeasurementComplexItem/MeasurementComplexItem.cc

@@ -7,7 +7,7 @@
 #include "geometry/MeasurementArea.h"
 #include "geometry/SafeArea.h"
 #include "geometry/clipper/clipper.hpp"
-#include "geometry/snake.h"
+#include "geometry/geometry.h"
 #include "nemo_interface/SnakeTile.h"
 
 // QGC
@@ -365,13 +365,13 @@ bool MeasurementComplexItem::load(const QJsonObject &complexObject,
         auto safeArea = safeAreaArray[0];
         QGeoCoordinate origin =
             safeArea->pathModel().value<QGCQGeoCoordinate *>(0)->coordinate();
-        snake::FPolygon safeAreaENU;
-        snake::areaToEnu(origin, safeArea->coordinateList(), safeAreaENU);
+        geometry::FPolygon safeAreaENU;
+        geometry::areaToEnu(origin, safeArea->coordinateList(), safeAreaENU);
         for (const auto &variant : variantVector) {
-          snake::FLineString varENU;
+          geometry::FLineString varENU;
           for (const auto &vertex : variant) {
-            snake::FPoint vertexENU;
-            snake::toENU(origin, vertex.value<QGeoCoordinate>(), vertexENU);
+            geometry::FPoint vertexENU;
+            geometry::toENU(origin, vertex.value<QGeoCoordinate>(), vertexENU);
             varENU.push_back(vertexENU);
           }
 
@@ -833,11 +833,11 @@ void MeasurementComplexItem::_updateRoute() {
       RoutingParameter par;
       par.numSolutions = 5;
       auto &safeAreaENU = par.safeArea;
-      snake::areaToEnu(origin, geoSafeArea, safeAreaENU);
+      geometry::areaToEnu(origin, geoSafeArea, safeAreaENU);
 
       // Create generator.
       if (this->_pGenerator != nullptr) {
-        routing::GeneratorBase::Generator g; // Transect generator.
+        routing::GeneratorBase::Work g; // Transect generator.
         if (this->_pGenerator->get(g)) {
           // Start/Restart routing worker.
           this->_pWorker->route(par, g);
@@ -1182,7 +1182,7 @@ void MeasurementComplexItem::_storeRoutingData(
     auto ori = this->_pAreaData->origin();
     ori.setAltitude(0);
     QVector<Variant> variantVector;
-    const auto nSolutions = pRoute->solutionVector.size();
+    const std::size_t nSolutions = pRoute->solutionVector.size();
 
     for (std::size_t j = 0; j < nSolutions; ++j) {
       Variant var;
@@ -1195,7 +1195,7 @@ void MeasurementComplexItem::_storeRoutingData(
 
         for (const auto &vertex : path) {
           QGeoCoordinate c;
-          snake::fromENU(ori, vertex, c);
+          geometry::fromENU(ori, vertex, c);
           var.append(QVariant::fromValue(c));
         }
       } else {

src/MeasurementComplexItem/MeasurementComplexItem.h

@@ -12,7 +12,7 @@
 #include "AreaData.h"
 
 class RoutingThread;
-class RoutingData;
+class RoutingResult;
 
 namespace routing {
 class GeneratorBase;
@@ -23,7 +23,7 @@ class MeasurementComplexItem : public ComplexMissionItem {
 
   using PtrGenerator = routing::GeneratorBase *;
   using PtrAreaData = AreaData *;
-  using PtrRoutingData = std::shared_ptr<RoutingData>;
+  using PtrRoutingData = std::shared_ptr<RoutingResult>;
   using PtrWorker = RoutingThread *;
   using Variant = QVariantList;
 

src/MeasurementComplexItem/NemoInterface.cpp

@@ -14,7 +14,7 @@
 
 #include "GenericSingelton.h"
 #include "geometry/MeasurementArea.h"
-#include "geometry/snake.h"
+#include "geometry/geometry.h"
 #include "nemo_interface/QNemoHeartbeat.h"
 #include "nemo_interface/QNemoProgress.h"
 #include "nemo_interface/SnakeTile.h"
@@ -170,7 +170,7 @@ void NemoInterface::Impl::setTileData(const TileData &tileData) {
             tile = qobject_cast<const SnakeTile *>(obj);
             if (tile != nullptr) {
               SnakeTileLocal tileENU;
-              snake::areaToEnu(origin, tile->coordinateList(), tileENU.path());
+              geometry::areaToEnu(origin, tile->coordinateList(), tileENU.path());
               this->tilesENU.polygons().push_back(std::move(tileENU));
             } else {
               qCDebug(NemoInterfaceLog) << "Impl::setTileData(): nullptr.";

src/MeasurementComplexItem/RoutingThread.cpp

@@ -3,10 +3,35 @@
 #include <chrono>
 // Qt
 #include <QDebug>
-
+// or-tools
 #include "QGCLoggingCategory.h"
+#include "ortools/constraint_solver/routing.h"
+#include "ortools/constraint_solver/routing_enums.pb.h"
+#include "ortools/constraint_solver/routing_index_manager.h"
+#include "ortools/constraint_solver/routing_parameters.h"
+
 QGC_LOGGING_CATEGORY(RoutingThreadLog, "RoutingThreadLog")
 
+using namespace geometry;
+using namespace operations_research;
+
+// Aux struct and functions.
+struct InternalParameters {
+  InternalParameters()
+      : numSolutionsPerRun(1), numRuns(1), minNumTransectsPerRun(5),
+        stop([] { return false; }) {}
+  std::size_t numSolutionsPerRun;
+  std::size_t numRuns;
+  std::size_t minNumTransectsPerRun;
+  std::function<bool(void)> stop;
+  mutable std::string errorString;
+};
+
+bool getRoute(const FPolygon &area, const LineStringArray &transects,
+              std::vector<Solution> &solutionVector,
+              const InternalParameters &par = InternalParameters());
+
+// class RoutingThread
 RoutingThread::RoutingThread(QObject *parent)
     : QThread(parent), _calculating(false), _stop(false), _restart(false) {
 
@@ -26,12 +51,11 @@ RoutingThread::~RoutingThread() {
 
 bool RoutingThread::calculating() const { return this->_calculating; }
 
-void RoutingThread::route(const RoutingParameter &par,<