SnakeWorker added

QGCExternalLibs.pri

@@ -92,11 +92,6 @@ exists($$MAVLINKPATH/common) {
 INCLUDEPATH += libs/eigen
 DEFINES += NOMINMAX
 
-#
-# [REQUIRED] snake library (Wima)
-INCLUDEPATH += libs/snake
-INCLUDEPATH += libs/or-tools/include
-
 #
 # [REQUIRED] shapelib library
 INCLUDEPATH += libs/shapelib
@@ -200,3 +195,13 @@ contains (DEFINES, DISABLE_AIRMAP) {
             $${AIRMAPD_PATH}/include
     }
 }
+
+# GeograpicLib (TODO: add Windows support!)
+LinuxBuild {
+    LIBS += -L/usr/local/lib -lGeographic # libGeograpic.so
+}
+
+# google or-tools (TODO: add Windows support!)
+LinuxBuild {
+    LIBS += -L/usr/local/lib -lortools # libortools.so
+}

libs/clipper/CMakeLists.txt

-cmake_minimum_required(VERSION 3.14)
-project(polyclipping)
-
-
-add_library(polyclipping 
-    STATIC
-        clipper.cpp)
-target_include_directories(polyclipping PUBLIC include)

libs/clipper/clipper/.gitignore

+# This file is used to ignore files which are generated
+# ----------------------------------------------------------------------------
+
+*~
+*.autosave
+*.a
+*.core
+*.moc
+*.o
+*.obj
+*.orig
+*.rej
+*.so
+*.so.*
+*_pch.h.cpp
+*_resource.rc
+*.qm
+.#*
+*.*#
+core
+!core/
+tags
+.DS_Store
+.directory
+*.debug
+Makefile*
+*.prl
+*.app
+moc_*.cpp
+ui_*.h
+qrc_*.cpp
+Thumbs.db
+*.res
+*.rc
+/.qmake.cache
+/.qmake.stash
+
+# qtcreator generated files
+*.pro.user*
+
+# xemacs temporary files
+*.flc
+
+# Vim temporary files
+.*.swp
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.pdb
+*.sln
+*.suo
+*.vcproj
+*vcproj.*.*.user
+*.ncb
+*.sdf
+*.opensdf
+*.vcxproj
+*vcxproj.*
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# Python byte code
+*.pyc
+
+# Binaries
+# --------
+*.dll
+*.exe
+

libs/clipper/clipper.cpp → libs/clipper/clipper/clipper.cpp

@@ -4329,10 +4329,10 @@ double DistanceFromLineSqrd(
   const IntPoint& pt, const IntPoint& ln1, const IntPoint& ln2)
 {
   //The equation of a line in general form (Ax + By + C = 0)
-  //given 2 points (x,y) & (x,y) is ...
-  //(y - y)x + (x - x)y + (y - y)x - (x - x)y = 0
-  //A = (y - y); B = (x - x); C = (y - y)x - (x - x)y
-  //perpendicular distance of point (x,y) = (Ax + By + C)/Sqrt(A + B)
+  //given 2 points (x�,y�) & (x�,y�) is ...
+  //(y� - y�)x + (x� - x�)y + (y� - y�)x� - (x� - x�)y� = 0
+  //A = (y� - y�); B = (x� - x�); C = (y� - y�)x� - (x� - x�)y�
+  //perpendicular distance of point (x�,y�) = (Ax� + By� + C)/Sqrt(A� + B�)
   //see http://en.wikipedia.org/wiki/Perpendicular_distance
   double A = double(ln1.Y - ln2.Y);
   double B = double(ln2.X - ln1.X);

libs/clipper/clipper/clipper.pro

+CONFIG -= qt
+
+TEMPLATE = lib
+DEFINES += CLIPPER_LIBRARY
+
+CONFIG += c++11
+
+# The following define makes your compiler emit warnings if you use
+# any Qt feature that has been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+# You can also make your code fail to compile if it uses deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+SOURCES += \
+    clipper.cpp
+
+HEADERS += \
+    clipper.hpp \
+    clipper_global.h
+
+# Default rules for deployment.
+unix {
+    target.path = /usr/lib
+}
+!isEmpty(target.path): INSTALLS += target

libs/clipper/clipper/clipper_global.h

+#ifndef CLIPPER_GLOBAL_H
+#define CLIPPER_GLOBAL_H
+
+#if defined(_MSC_VER) || defined(WIN64) || defined(_WIN64) || defined(__WIN64__) || defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
+#  define Q_DECL_EXPORT __declspec(dllexport)
+#  define Q_DECL_IMPORT __declspec(dllimport)
+#else
+#  define Q_DECL_EXPORT     __attribute__((visibility("default")))
+#  define Q_DECL_IMPORT     __attribute__((visibility("default")))
+#endif
+
+#if defined(CLIPPER_LIBRARY)
+#  define CLIPPER_EXPORT Q_DECL_EXPORT
+#else
+#  define CLIPPER_EXPORT Q_DECL_IMPORT
+#endif
+
+#endif // CLIPPER_GLOBAL_H

libs/clipper/cmake_install.cmake

-# Install script for directory: /home/valentin/Desktop/drones/qgroundcontrol/libs/clipper
-
-# Set the install prefix
-if(NOT DEFINED CMAKE_INSTALL_PREFIX)
-  set(CMAKE_INSTALL_PREFIX "/usr/local")
-endif()
-string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
-
-# Set the install configuration name.
-if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
-  if(BUILD_TYPE)
-    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
-           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
-  else()
-    set(CMAKE_INSTALL_CONFIG_NAME "RelWithDebInfo")
-  endif()
-  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
-endif()
-
-# Set the component getting installed.
-if(NOT CMAKE_INSTALL_COMPONENT)
-  if(COMPONENT)
-    message(STATUS "Install component: \"${COMPONENT}\"")
-    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
-  else()
-    set(CMAKE_INSTALL_COMPONENT)
-  endif()
-endif()
-
-# Install shared libraries without execute permission?
-if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
-  set(CMAKE_INSTALL_SO_NO_EXE "1")
-endif()
-
-# Is this installation the result of a crosscompile?
-if(NOT DEFINED CMAKE_CROSSCOMPILING)
-  set(CMAKE_CROSSCOMPILING "FALSE")
-endif()
-
-# Set default install directory permissions.
-if(NOT DEFINED CMAKE_OBJDUMP)
-  set(CMAKE_OBJDUMP "/usr/bin/objdump")
-endif()
-

libs/qwt/qwt_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+#include "EWIEGA46WW/moc_qwt_abstract_legend.cpp"
+#include "EWIEGA46WW/moc_qwt_abstract_scale.cpp"
+#include "EWIEGA46WW/moc_qwt_abstract_slider.cpp"
+#include "EWIEGA46WW/moc_qwt_analog_clock.cpp"
+#include "EWIEGA46WW/moc_qwt_compass.cpp"
+#include "EWIEGA46WW/moc_qwt_counter.cpp"
+#include "EWIEGA46WW/moc_qwt_dial.cpp"
+#include "EWIEGA46WW/moc_qwt_dyngrid_layout.cpp"
+#include "EWIEGA46WW/moc_qwt_knob.cpp"
+#include "EWIEGA46WW/moc_qwt_legend.cpp"
+#include "EWIEGA46WW/moc_qwt_legend_label.cpp"
+#include "EWIEGA46WW/moc_qwt_magnifier.cpp"
+#include "EWIEGA46WW/moc_qwt_panner.cpp"
+#include "EWIEGA46WW/moc_qwt_picker.cpp"
+#include "EWIEGA46WW/moc_qwt_plot.cpp"
+#include "EWIEGA46WW/moc_qwt_plot_canvas.cpp"
+#include "EWIEGA46WW/moc_qwt_plot_magnifier.cpp"
+#include "EWIEGA46WW/moc_qwt_plot_panner.cpp"
+#include "EWIEGA46WW/moc_qwt_plot_picker.cpp"
+#include "EWIEGA46WW/moc_qwt_plot_zoomer.cpp"
+#include "EWIEGA46WW/moc_qwt_scale_widget.cpp"
+#include "EWIEGA46WW/moc_qwt_slider.cpp"
+#include "EWIEGA46WW/moc_qwt_text_label.cpp"
+#include "EWIEGA46WW/moc_qwt_thermo.cpp"
+#include "EWIEGA46WW/moc_qwt_wheel.cpp"

libs/shapelib/dbfadd_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+// No files found that require moc or the moc files are included
+enum some_compilers { need_more_than_nothing };

libs/shapelib/dbfcreate_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+// No files found that require moc or the moc files are included
+enum some_compilers { need_more_than_nothing };

libs/shapelib/dbfdump_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+// No files found that require moc or the moc files are included
+enum some_compilers { need_more_than_nothing };

libs/shapelib/shp_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+// No files found that require moc or the moc files are included
+enum some_compilers { need_more_than_nothing };

libs/shapelib/shpadd_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+// No files found that require moc or the moc files are included
+enum some_compilers { need_more_than_nothing };

libs/shapelib/shpcreate_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+// No files found that require moc or the moc files are included
+enum some_compilers { need_more_than_nothing };

libs/shapelib/shpdump_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+// No files found that require moc or the moc files are included
+enum some_compilers { need_more_than_nothing };

libs/shapelib/shprewind_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+// No files found that require moc or the moc files are included
+enum some_compilers { need_more_than_nothing };

libs/shapelib/shptreedump_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+// No files found that require moc or the moc files are included
+enum some_compilers { need_more_than_nothing };

libs/snake/.gitignore

+# This file is used to ignore files which are generated
+# ----------------------------------------------------------------------------
+
+*~
+*.autosave
+*.a
+*.core
+*.moc
+*.o
+*.obj
+*.orig
+*.rej
+*.so
+*.so.*
+*_pch.h.cpp
+*_resource.rc
+*.qm
+.#*
+*.*#
+core
+!core/
+tags
+.DS_Store
+.directory
+*.debug
+Makefile*
+*.prl
+*.app
+moc_*.cpp
+ui_*.h
+qrc_*.cpp
+Thumbs.db
+*.res
+*.rc
+/.qmake.cache
+/.qmake.stash
+
+# qtcreator generated files
+*.pro.user*
+
+# xemacs temporary files
+*.flc
+
+# Vim temporary files
+.*.swp
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.pdb
+*.sln
+*.suo
+*.vcproj
+*vcproj.*.*.user
+*.ncb
+*.sdf
+*.opensdf
+*.vcxproj
+*vcxproj.*
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# Python byte code
+*.pyc
+
+# Binaries
+# --------
+*.dll
+*.exe
+

libs/snake/CMakeLists.txt

-add_library(snake
-    STATIC
-        snake.cpp
-        snake_geometry.cpp
-)
-find_package(GeographicLib REQUIRED)
-find_package(ortools CONFIG REQUIRED)
-
-
-target_link_libraries (snake ${GeographicLib_LIBRARIES} polyclipping ${ORTOOLS_LIBRARIES})
-
-target_include_directories(snake PRIVATE polylabel) # polylabel
-target_include_directories(snake PUBLIC include) # polylabel
-
-add_subdirectory(test)
-
-
-

libs/snake/cmake_install.cmake

-# Install script for directory: /home/valentin/Desktop/drones/qgroundcontrol/libs/snake
-
-# Set the install prefix
-if(NOT DEFINED CMAKE_INSTALL_PREFIX)
-  set(CMAKE_INSTALL_PREFIX "/usr/local")
-endif()
-string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
-
-# Set the install configuration name.
-if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
-  if(BUILD_TYPE)
-    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
-           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
-  else()
-    set(CMAKE_INSTALL_CONFIG_NAME "RelWithDebInfo")
-  endif()
-  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
-endif()
-
-# Set the component getting installed.
-if(NOT CMAKE_INSTALL_COMPONENT)
-  if(COMPONENT)
-    message(STATUS "Install component: \"${COMPONENT}\"")
-    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
-  else()
-    set(CMAKE_INSTALL_COMPONENT)
-  endif()
-endif()
-
-# Install shared libraries without execute permission?
-if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
-  set(CMAKE_INSTALL_SO_NO_EXE "1")
-endif()
-
-# Is this installation the result of a crosscompile?
-if(NOT DEFINED CMAKE_CROSSCOMPILING)
-  set(CMAKE_CROSSCOMPILING "FALSE")
-endif()
-
-# Set default install directory permissions.
-if(NOT DEFINED CMAKE_OBJDUMP)
-  set(CMAKE_OBJDUMP "/usr/bin/objdump")
-endif()
-
-if(NOT CMAKE_INSTALL_LOCAL_ONLY)
-  # Include the install script for each subdirectory.
-  include("/home/valentin/Desktop/drones/qgroundcontrol/libs/snake/test/cmake_install.cmake")
-
-endif()
-

libs/snake/snake.cpp

 #include <iostream>
 
 #include "snake.h"
-#include <clipper.hpp>
+#include "clipper.hpp"
 #define CLIPPER_SCALE 10000
 
 using namespace snake_geometry;

libs/snake/snake.pro

+CONFIG -= qt
+
+TEMPLATE = lib
+DEFINES += SNAKE_LIBRARY
+
+CONFIG += c++14
+
+# The following define makes your compiler emit warnings if you use
+# any Qt feature that has been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+# You can also make your code fail to compile if it uses deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+SOURCES += \
+    snake.cpp \
+    snake_geometry.cpp \
+    test/test_snake.cpp \
+    test/test_snake_geometry.cpp
+
+HEADERS += \
+    catch.hpp \
+    polylabel/mapbox/feature.hpp \
+    polylabel/mapbox/geometry.hpp \
+    polylabel/mapbox/geometry/box.hpp \
+    polylabel/mapbox/geometry/empty.hpp \
+    polylabel/mapbox/geometry/envelope.hpp \
+    polylabel/mapbox/geometry/for_each_point.hpp \
+    polylabel/mapbox/geometry/geometry.hpp \
+    polylabel/mapbox/geometry/line_string.hpp \
+    polylabel/mapbox/geometry/multi_line_string.hpp \
+    polylabel/mapbox/geometry/multi_point.hpp \
+    polylabel/mapbox/geometry/multi_polygon.hpp \
+    polylabel/mapbox/geometry/point.hpp \
+    polylabel/mapbox/geometry/point_arithmetic.hpp \
+    polylabel/mapbox/geometry/polygon.hpp \
+    polylabel/mapbox/geometry_io.hpp \
+    polylabel/mapbox/optional.hpp \
+    polylabel/mapbox/polylabel/polylabel.hpp \
+    polylabel/mapbox/recursive_wrapper.hpp \
+    polylabel/mapbox/variant.hpp \
+    polylabel/mapbox/variant_io.hpp \
+    snake_geometry.h \
+    snake_global.h \
+    snake.h
+
+# Default rules for deployment.
+unix {
+    target.path = /usr/lib
+}
+!isEmpty(target.path): INSTALLS += target
+
+win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/./release/ -lsnake
+else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/./debug/ -lsnake
+else:unix: LIBS += -L$$OUT_PWD/./ -lsnake
+
+INCLUDEPATH += $$PWD/../clipper/clipper
+DEPENDPATH += $$PWD/../clipper/clipper

libs/snake/snake_geometry.cpp

@@ -308,10 +308,7 @@ bool dijkstraAlgorithm(const size_t numElements,
                        std::vector<size_t> &elementPath,
                        std::function<double (const size_t, const size_t)> distanceDij)
 {
-    if (    numElements < 0
-         || startIndex < 0
-         || endIndex < 0
-         || startIndex >= numElements
+    if (    startIndex >= numElements
          || endIndex >= numElements
          || endIndex == startIndex) {
         return false;

libs/snake/snake_geometry.h.orig

-#pragma once
-#include <vector>
-#include <array>
-
-#include "WGS84toCartesian.hpp"
-
-namespace snake_geometry {
-
-typedef std::array<double, 2>   Point2D;
-typedef std::vector<Point2D>         Point2DList;
-typedef std::array<double, 3>   Point3D;
-typedef std::vector<Point3D>         Point3DList;
-typedef std::array<double, 2>   GeoPoint2D;
-typedef std::vector<GeoPoint2D>      GeoPoint2DList;
-typedef std::array<double, 3>   GeoPoint3D;
-typedef std::vector<GeoPoint3D>      GeoPoint3DList;
-
-typedef struct {
-    double width;
-    double height;
-    double angle;
-    std::array<Point2D,4> corners;
-}min_bbox_rt;
-
-<<<<<<< HEAD
-    Point3D toENU(const GeoPoint3D &WGS84Reference, const GeoPoint3D &WGS84Position);
-    GeoPoint3D fromENU(const Point3D &WGS84Reference, const Point3D &CartesianPosition);
-=======
-Point3D toENU(const Point3D &WGS84Reference, const Point3D &WGS84Position);
-Point3D fromENU(const Point3D &WGS84Reference, const Point3D &CartesianPosition);
->>>>>>> 5687fb4553282f37531aa25fac4d66ec9a84932e
-
-Point2D polygonCenter(const Point2DList &polygon);
-min_bbox_rt minimalBoundingBox(const Point2DList &polygon);
-
-}

libs/snake/snake_global.h

+#ifndef SNAKE_GLOBAL_H
+#define SNAKE_GLOBAL_H
+
+#if defined(_MSC_VER) || defined(WIN64) || defined(_WIN64) || defined(__WIN64__) || defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
+#  define Q_DECL_EXPORT __declspec(dllexport)
+#  define Q_DECL_IMPORT __declspec(dllimport)
+#else
+#  define Q_DECL_EXPORT     __attribute__((visibility("default")))
+#  define Q_DECL_IMPORT     __attribute__((visibility("default")))
+#endif
+
+#if defined(SNAKE_LIBRARY)
+#  define SNAKE_EXPORT Q_DECL_EXPORT
+#else
+#  define SNAKE_EXPORT Q_DECL_IMPORT
+#endif
+
+#endif // SNAKE_GLOBAL_H

libs/snake_old/polylabel/mapbox/feature.hpp

+#pragma once
+
+#include <mapbox/geometry.hpp>
+
+#include <mapbox/variant.hpp>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+namespace mapbox {
+namespace feature {
+
+struct value;
+
+struct null_value_t
+{
+};
+
+constexpr bool operator==(const null_value_t&, const null_value_t&) { return true; }
+constexpr bool operator!=(const null_value_t&, const null_value_t&) { return false; }
+constexpr bool operator<(const null_value_t&, const null_value_t&) { return false; }
+
+constexpr null_value_t null_value = null_value_t();
+
+// Multiple numeric types (uint64_t, int64_t, double) are present in order to support
+// the widest possible range of JSON numbers, which do not have a maximum range.
+// Implementations that produce `value`s should use that order for type preference,
+// using uint64_t for positive integers, int64_t for negative integers, and double
+// for non-integers and integers outside the range of 64 bits.
+using value_base = mapbox::util::variant<null_value_t, bool, uint64_t, int64_t, double, std::string,
+                                         mapbox::util::recursive_wrapper<std::vector<value>>,
+                                         mapbox::util::recursive_wrapper<std::unordered_map<std::string, value>>>;
+
+struct value : value_base
+{
+    using value_base::value_base;
+};
+
+using property_map = std::unordered_map<std::string, value>;
+
+// The same considerations and requirement for numeric types apply as for `value_base`.
+using identifier = mapbox::util::variant<null_value_t, uint64_t, int64_t, double, std::string>;
+
+template <class T>
+struct feature
+{
+    using coordinate_type = T;
+    using geometry_type = mapbox::geometry::geometry<T>; // Fully qualified to avoid GCC -fpermissive error.
+
+    geometry_type geometry;
+    property_map properties;
+    identifier id;
+
+    feature()
+        : geometry(),
+          properties(),
+          id() {}
+    feature(geometry_type const& geom_)
+        : geometry(geom_),
+          properties(),
+          id() {}
+    feature(geometry_type&& geom_)
+        : geometry(std::move(geom_)),
+          properties(),
+          id() {}
+    feature(geometry_type const& geom_, property_map const& prop_)
+        : geometry(geom_), properties(prop_), id() {}
+    feature(geometry_type&& geom_, property_map&& prop_)
+        : geometry(std::move(geom_)),
+          properties(std::move(prop_)),
+          id() {}
+    feature(geometry_type const& geom_, property_map const& prop_, identifier const& id_)
+        : geometry(geom_),
+          properties(prop_),
+          id(id_) {}
+    feature(geometry_type&& geom_, property_map&& prop_, identifier&& id_)
+        : geometry(std::move(geom_)),
+          properties(std::move(prop_)),
+          id(std::move(id_)) {}
+};
+
+template <class T>
+constexpr bool operator==(feature<T> const& lhs, feature<T> const& rhs)
+{
+    return lhs.id == rhs.id && lhs.geometry == rhs.geometry && lhs.properties == rhs.properties;
+}
+
+template <class T>
+constexpr bool operator!=(feature<T> const& lhs, feature<T> const& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template <class T, template <typename...> class Cont = std::vector>
+struct feature_collection : Cont<feature<T>>
+{
+    using coordinate_type = T;
+    using feature_type = feature<T>;
+    using container_type = Cont<feature_type>;
+    using size_type = typename container_type::size_type;
+
+    template <class... Args>
+    feature_collection(Args&&... args) : container_type(std::forward<Args>(args)...)
+    {
+    }
+    feature_collection(std::initializer_list<feature_type> args)
+        : container_type(std::move(args)) {}
+};
+
+} // namespace feature
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/geometry.hpp

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

libs/snake_old/polylabel/mapbox/geometry/box.hpp

+#pragma once
+
+#include <mapbox/geometry/point.hpp>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T>
+struct box
+{
+    using coordinate_type = T;
+    using point_type = point<coordinate_type>;
+
+    constexpr box(point_type const& min_, point_type const& max_)
+        : min(min_), max(max_)
+    {
+    }
+
+    point_type min;
+    point_type max;
+};
+
+template <typename T>
+constexpr bool operator==(box<T> const& lhs, box<T> const& rhs)
+{
+    return lhs.min == rhs.min && lhs.max == rhs.max;
+}
+
+template <typename T>
+constexpr bool operator!=(box<T> const& lhs, box<T> const& rhs)
+{
+    return lhs.min != rhs.min || lhs.max != rhs.max;
+}
+
+} // namespace geometry
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/geometry/empty.hpp

+#pragma once
+
+namespace mapbox {
+namespace geometry {
+
+struct empty
+{
+}; //  this Geometry type represents the empty point set, ∅, for the coordinate space (OGC Simple Features).
+
+constexpr bool operator==(empty, empty) { return true; }
+constexpr bool operator!=(empty, empty) { return false; }
+constexpr bool operator<(empty, empty) { return false; }
+constexpr bool operator>(empty, empty) { return false; }
+constexpr bool operator<=(empty, empty) { return true; }
+constexpr bool operator>=(empty, empty) { return true; }
+
+} // namespace geometry
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/geometry/envelope.hpp

+#pragma once
+
+#include <mapbox/geometry/box.hpp>
+#include <mapbox/geometry/for_each_point.hpp>
+
+#include <limits>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename G, typename T = typename G::coordinate_type>
+box<T> envelope(G const& geometry)
+{
+    using limits = std::numeric_limits<T>;
+
+    T min_t = limits::has_infinity ? -limits::infinity() : limits::min();
+    T max_t = limits::has_infinity ? limits::infinity() : limits::max();
+
+    point<T> min(max_t, max_t);
+    point<T> max(min_t, min_t);
+
+    for_each_point(geometry, [&](point<T> const& point) {
+        if (min.x > point.x) min.x = point.x;
+        if (min.y > point.y) min.y = point.y;
+        if (max.x < point.x) max.x = point.x;
+        if (max.y < point.y) max.y = point.y;
+    });
+
+    return box<T>(min, max);
+}
+
+} // namespace geometry
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/geometry/for_each_point.hpp

+#pragma once
+
+#include <mapbox/geometry/geometry.hpp>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename F>
+void for_each_point(mapbox::geometry::empty const&, F&&)
+{
+}
+
+template <typename Point, typename F>
+auto for_each_point(Point&& point, F&& f)
+    -> decltype(point.x, point.y, void())
+{
+    f(std::forward<Point>(point));
+}
+
+template <typename Container, typename F>
+auto for_each_point(Container&& container, F&& f)
+    -> decltype(container.begin(), container.end(), void());
+
+template <typename... Types, typename F>
+void for_each_point(mapbox::util::variant<Types...> const& geom, F&& f)
+{
+    mapbox::util::variant<Types...>::visit(geom, [&](auto const& g) {
+        for_each_point(g, f);
+    });
+}
+
+template <typename... Types, typename F>
+void for_each_point(mapbox::util::variant<Types...>& geom, F&& f)
+{
+    mapbox::util::variant<Types...>::visit(geom, [&](auto& g) {
+        for_each_point(g, f);
+    });
+}
+
+template <typename Container, typename F>
+auto for_each_point(Container&& container, F&& f)
+    -> decltype(container.begin(), container.end(), void())
+{
+    for (auto& e : container)
+    {
+        for_each_point(e, f);
+    }
+}
+
+} // namespace geometry
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/geometry/geometry.hpp

+#pragma once
+
+#include <mapbox/geometry/empty.hpp>
+#include <mapbox/geometry/point.hpp>
+#include <mapbox/geometry/line_string.hpp>
+#include <mapbox/geometry/polygon.hpp>
+#include <mapbox/geometry/multi_point.hpp>
+#include <mapbox/geometry/multi_line_string.hpp>
+#include <mapbox/geometry/multi_polygon.hpp>
+
+#include <mapbox/variant.hpp>
+
+// stl
+#include <vector>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct geometry_collection;
+
+template <typename T, template <typename...> class Cont = std::vector>
+using geometry_base = mapbox::util::variant<empty,
+                                            point<T>,
+                                            line_string<T, Cont>,
+                                            polygon<T, Cont>,
+                                            multi_point<T, Cont>,
+                                            multi_line_string<T, Cont>,
+                                            multi_polygon<T, Cont>,
+                                            geometry_collection<T, Cont>>;
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct geometry : geometry_base<T, Cont>
+{
+    using coordinate_type = T;
+    using geometry_base<T>::geometry_base;
+};
+
+template <typename T, template <typename...> class Cont>
+struct geometry_collection : Cont<geometry<T>>
+{
+    using coordinate_type = T;
+    using geometry_type = geometry<T>;
+    using container_type = Cont<geometry_type>;
+    using size_type = typename container_type::size_type;
+
+    template <class... Args>
+    geometry_collection(Args&&... args) : container_type(std::forward<Args>(args)...)
+    {
+    }
+    geometry_collection(std::initializer_list<geometry_type> args)
+        : container_type(std::move(args)) {}
+};
+
+} // namespace geometry
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/geometry/line_string.hpp

+#pragma once
+
+// mapbox
+#include <mapbox/geometry/point.hpp>
+// stl
+#include <vector>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct line_string : Cont<point<T>>
+{
+    using coordinate_type = T;
+    using point_type = point<T>;
+    using container_type = Cont<point_type>;
+    using size_type = typename container_type::size_type;
+
+    template <class... Args>
+    line_string(Args&&... args) : container_type(std::forward<Args>(args)...)
+    {
+    }
+    line_string(std::initializer_list<point_type> args)
+        : container_type(std::move(args)) {}
+};
+
+} // namespace geometry
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/geometry/multi_line_string.hpp

+#pragma once
+
+// mapbox
+#include <mapbox/geometry/line_string.hpp>
+// stl
+#include <vector>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct multi_line_string : Cont<line_string<T>>
+{
+    using coordinate_type = T;
+    using line_string_type = line_string<T>;
+    using container_type = Cont<line_string_type>;
+    using size_type = typename container_type::size_type;
+
+    template <class... Args>
+    multi_line_string(Args&&... args) : container_type(std::forward<Args>(args)...)
+    {
+    }
+    multi_line_string(std::initializer_list<line_string_type> args)
+        : container_type(std::move(args)) {}
+};
+
+} // namespace geometry
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/geometry/multi_point.hpp

+#pragma once
+
+// mapbox
+#include <mapbox/geometry/point.hpp>
+// stl
+#include <vector>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct multi_point : Cont<point<T>>
+{
+    using coordinate_type = T;
+    using point_type = point<T>;
+    using container_type = Cont<point_type>;
+    using size_type = typename container_type::size_type;
+
+    template <class... Args>
+    multi_point(Args&&... args) : container_type(std::forward<Args>(args)...)
+    {
+    }
+    multi_point(std::initializer_list<point_type> args)
+        : container_type(std::move(args)) {}
+};
+
+} // namespace geometry
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/geometry/multi_polygon.hpp

+#pragma once
+
+// mapbox
+#include <mapbox/geometry/polygon.hpp>
+// stl
+#include <vector>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct multi_polygon : Cont<polygon<T>>
+{
+    using coordinate_type = T;
+    using polygon_type = polygon<T>;
+    using container_type = Cont<polygon_type>;
+    using size_type = typename container_type::size_type;
+
+    template <class... Args>
+    multi_polygon(Args&&... args) : container_type(std::forward<Args>(args)...)
+    {
+    }
+    multi_polygon(std::initializer_list<polygon_type> args)
+        : container_type(std::move(args)) {}
+};
+
+} // namespace geometry
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/geometry/point.hpp

+#pragma once
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T>
+struct point
+{
+    using coordinate_type = T;
+
+    constexpr point()
+        : x(), y()
+    {
+    }
+    constexpr point(T x_, T y_)
+        : x(x_), y(y_)
+    {
+    }
+
+    T x;
+    T y;
+};
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+
+template <typename T>
+constexpr bool operator==(point<T> const& lhs, point<T> const& rhs)
+{
+    return lhs.x == rhs.x && lhs.y == rhs.y;
+}
+
+#pragma GCC diagnostic pop
+
+template <typename T>
+constexpr bool operator!=(point<T> const& lhs, point<T> const& rhs)
+{
+    return !(lhs == rhs);
+}
+
+} // namespace geometry
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/geometry/point_arithmetic.hpp

+#pragma once
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T>
+point<T> operator+(point<T> const& lhs, point<T> const& rhs)
+{
+    return point<T>(lhs.x + rhs.x, lhs.y + rhs.y);
+}
+
+template <typename T>
+point<T> operator+(point<T> const& lhs, T const& rhs)
+{
+    return point<T>(lhs.x + rhs, lhs.y + rhs);
+}
+
+template <typename T>
+point<T> operator-(point<T> const& lhs, point<T> const& rhs)
+{
+    return point<T>(lhs.x - rhs.x, lhs.y - rhs.y);
+}
+
+template <typename T>
+point<T> operator-(point<T> const& lhs, T const& rhs)
+{
+    return point<T>(lhs.x - rhs, lhs.y - rhs);
+}
+
+template <typename T>
+point<T> operator*(point<T> const& lhs, point<T> const& rhs)
+{
+    return point<T>(lhs.x * rhs.x, lhs.y * rhs.y);
+}
+
+template <typename T>
+point<T> operator*(point<T> const& lhs, T const& rhs)
+{
+    return point<T>(lhs.x * rhs, lhs.y * rhs);
+}
+
+template <typename T>
+point<T> operator/(point<T> const& lhs, point<T> const& rhs)
+{
+    return point<T>(lhs.x / rhs.x, lhs.y / rhs.y);
+}
+
+template <typename T>
+point<T> operator/(point<T> const& lhs, T const& rhs)
+{
+    return point<T>(lhs.x / rhs, lhs.y / rhs);
+}
+
+template <typename T>
+point<T>& operator+=(point<T>& lhs, point<T> const& rhs)
+{
+    lhs.x += rhs.x;
+    lhs.y += rhs.y;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator+=(point<T>& lhs, T const& rhs)
+{
+    lhs.x += rhs;
+    lhs.y += rhs;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator-=(point<T>& lhs, point<T> const& rhs)
+{
+    lhs.x -= rhs.x;
+    lhs.y -= rhs.y;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator-=(point<T>& lhs, T const& rhs)
+{
+    lhs.x -= rhs;
+    lhs.y -= rhs;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator*=(point<T>& lhs, point<T> const& rhs)
+{
+    lhs.x *= rhs.x;
+    lhs.y *= rhs.y;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator*=(point<T>& lhs, T const& rhs)
+{
+    lhs.x *= rhs;
+    lhs.y *= rhs;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator/=(point<T>& lhs, point<T> const& rhs)
+{
+    lhs.x /= rhs.x;
+    lhs.y /= rhs.y;
+    return lhs;
+}
+
+template <typename T>
+point<T>& operator/=(point<T>& lhs, T const& rhs)
+{
+    lhs.x /= rhs;
+    lhs.y /= rhs;
+    return lhs;
+}
+
+} // namespace geometry
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/geometry/polygon.hpp

+#pragma once
+
+// mapbox
+#include <mapbox/geometry/point.hpp>
+
+// stl
+#include <vector>
+
+namespace mapbox {
+namespace geometry {
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct linear_ring : Cont<point<T>>
+{
+    using coordinate_type = T;
+    using point_type = point<T>;
+    using container_type = Cont<point_type>;
+    using size_type = typename container_type::size_type;
+
+    template <class... Args>
+    linear_ring(Args&&... args) : container_type(std::forward<Args>(args)...)
+    {
+    }
+    linear_ring(std::initializer_list<point_type> args)
+        : container_type(std::move(args)) {}
+};
+
+template <typename T, template <typename...> class Cont = std::vector>
+struct polygon : Cont<linear_ring<T>>
+{
+    using coordinate_type = T;
+    using linear_ring_type = linear_ring<T>;
+    using container_type = Cont<linear_ring_type>;
+    using size_type = typename container_type::size_type;
+
+    template <class... Args>
+    polygon(Args&&... args) : container_type(std::forward<Args>(args)...)
+    {
+    }
+    polygon(std::initializer_list<linear_ring_type> args)
+        : container_type(std::move(args)) {}
+};
+
+} // namespace geometry
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/geometry_io.hpp

+#pragma once
+
+#include <mapbox/geometry/empty.hpp>
+#include <mapbox/feature.hpp>
+
+#include <iostream>
+#include <string>
+
+namespace mapbox {
+namespace geometry {
+
+std::ostream& operator<<(std::ostream& os, const empty&)
+{
+    return os << "[]";
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const point<T>& point)
+{
+    return os << "[" << point.x << "," << point.y << "]";
+}
+
+template <typename T, template <class, class...> class C, class... Args>
+std::ostream& operator<<(std::ostream& os, const C<T, Args...>& cont)
+{
+    os << "[";
+    for (auto it = cont.cbegin();;)
+    {
+        os << *it;
+        if (++it == cont.cend())
+        {
+            break;
+        }
+        os << ",";
+    }
+    return os << "]";
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const line_string<T>& geom)
+{
+    return os << static_cast<typename line_string<T>::container_type>(geom);
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const linear_ring<T>& geom)
+{
+    return os << static_cast<typename linear_ring<T>::container_type>(geom);
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const polygon<T>& geom)
+{
+    return os << static_cast<typename polygon<T>::container_type>(geom);
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const multi_point<T>& geom)
+{
+    return os << static_cast<typename multi_point<T>::container_type>(geom);
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const multi_line_string<T>& geom)
+{
+    return os << static_cast<typename multi_line_string<T>::container_type>(geom);
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const multi_polygon<T>& geom)
+{
+    return os << static_cast<typename multi_polygon<T>::container_type>(geom);
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const geometry<T>& geom)
+{
+    geometry<T>::visit(geom, [&](const auto& g) { os << g; });
+    return os;
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const geometry_collection<T>& geom)
+{
+    return os << static_cast<typename geometry_collection<T>::container_type>(geom);
+}
+
+} // namespace geometry
+
+namespace feature {
+
+std::ostream& operator<<(std::ostream& os, const null_value_t&)
+{
+    return os << "[]";
+}
+
+} // namespace feature
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/optional.hpp

+#ifndef MAPBOX_UTIL_OPTIONAL_HPP
+#define MAPBOX_UTIL_OPTIONAL_HPP
+
+#pragma message("This implementation of optional is deprecated. See https://github.com/mapbox/variant/issues/64.")
+
+#include <type_traits>
+#include <utility>
+
+#include "variant.hpp"
+
+namespace mapbox {
+namespace util {
+
+template <typename T>
+class optional
+{
+    static_assert(!std::is_reference<T>::value, "optional doesn't support references");
+
+    struct none_type
+    {
+    };
+
+    variant<none_type, T> variant_;
+
+  public:
+    optional() = default;
+
+    optional(optional const& rhs)
+    {
+        if (this != &rhs)
+        { // protect against invalid self-assignment
+            variant_ = rhs.variant_;
+        }
+    }
+
+    optional(T const& v) { variant_ = v; }
+
+    explicit operator bool() const noexcept { return variant_.template is<T>(); }
+
+    T const& get() const { return variant_.template get<T>(); }
+    T& get() { return variant_.template get<T>(); }
+
+    T const& operator*() const { return this->get(); }
+    T operator*() { return this->get(); }
+
+    optional& operator=(T const& v)
+    {
+        variant_ = v;
+        return *this;
+    }
+
+    optional& operator=(optional const& rhs)
+    {
+        if (this != &rhs)
+        {
+            variant_ = rhs.variant_;
+        }
+        return *this;
+    }
+
+    template <typename... Args>
+    void emplace(Args&&... args)
+    {
+        variant_ = T{std::forward<Args>(args)...};
+    }
+
+    void reset() { variant_ = none_type{}; }
+
+}; // class optional
+
+} // namespace util
+} // namespace mapbox
+
+#endif // MAPBOX_UTIL_OPTIONAL_HPP

libs/snake_old/polylabel/mapbox/polylabel/polylabel.hpp

+#pragma once
+
+#include <mapbox/geometry/polygon.hpp>
+#include <mapbox/geometry/envelope.hpp>
+#include <mapbox/geometry/point.hpp>
+#include <mapbox/geometry/point_arithmetic.hpp>
+
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+#include <queue>
+
+namespace mapbox {
+
+namespace detail {
+
+// get squared distance from a point to a segment
+template <class T>
+T getSegDistSq(const geometry::point<T>& p,
+               const geometry::point<T>& a,
+               const geometry::point<T>& b) {
+    auto x = a.x;
+    auto y = a.y;
+    auto dx = b.x - x;
+    auto dy = b.y - y;
+
+    if (dx != 0 || dy != 0) {
+
+        auto t = ((p.x - x) * dx + (p.y - y) * dy) / (dx * dx + dy * dy);
+
+        if (t > 1) {
+            x = b.x;
+            y = b.y;
+
+        } else if (t > 0) {
+            x += dx * t;
+            y += dy * t;
+        }
+    }
+
+    dx = p.x - x;
+    dy = p.y - y;
+
+    return dx * dx + dy * dy;
+}
+
+// signed distance from point to polygon outline (negative if point is outside)
+template <class T>
+auto pointToPolygonDist(const geometry::point<T>& point, const geometry::polygon<T>& polygon) {
+    bool inside = false;
+    auto minDistSq = std::numeric_limits<double>::infinity();
+
+    for (const auto& ring : polygon) {
+        for (std::size_t i = 0, len = ring.size(), j = len - 1; i < len; j = i++) {
+            const auto& a = ring[i];
+            const auto& b = ring[j];
+
+            if ((a.y > point.y) != (b.y > point.y) &&
+                (point.x < (b.x - a.x) * (point.y - a.y) / (b.y - a.y) + a.x)) inside = !inside;
+
+            minDistSq = std::min(minDistSq, getSegDistSq(point, a, b));
+        }
+    }
+
+    return (inside ? 1 : -1) * std::sqrt(minDistSq);
+}
+
+template <class T>
+struct Cell {
+    Cell(const geometry::point<T>& c_, T h_, const geometry::polygon<T>& polygon)
+        : c(c_),
+          h(h_),
+          d(pointToPolygonDist(c, polygon)),
+          max(d + h * std::sqrt(2))
+        {}
+
+    geometry::point<T> c; // cell center
+    T h; // half the cell size
+    T d; // distance from cell center to polygon
+    T max; // max distance to polygon within a cell
+};
+
+// get polygon centroid
+template <class T>
+Cell<T> getCentroidCell(const geometry::polygon<T>& polygon) {
+    T area = 0;
+    geometry::point<T> c { 0, 0 };
+    const auto& ring = polygon.at(0);
+
+    for (std::size_t i = 0, len = ring.size(), j = len - 1; i < len; j = i++) {
+        const geometry::point<T>& a = ring[i];
+        const geometry::point<T>& b = ring[j];
+        auto f = a.x * b.y - b.x * a.y;
+        c.x += (a.x + b.x) * f;
+        c.y += (a.y + b.y) * f;
+        area += f * 3;
+    }
+
+    return Cell<T>(area == 0 ? ring.at(0) : c / area, 0, polygon);
+}
+
+} // namespace detail
+
+template <class T>
+geometry::point<T> polylabel(const geometry::polygon<T>& polygon, T precision = 1, bool debug = false) {
+    using namespace detail;
+
+    // find the bounding box of the outer ring
+    const geometry::box<T> envelope = geometry::envelope(polygon.at(0));
+
+    const geometry::point<T> size {
+        envelope.max.x - envelope.min.x,
+        envelope.max.y - envelope.min.y
+    };
+
+    const T cellSize = std::min(size.x, size.y);
+    T h = cellSize / 2;
+
+    // a priority queue of cells in order of their "potential" (max distance to polygon)
+    auto compareMax = [] (const Cell<T>& a, const Cell<T>& b) {
+        return a.max < b.max;
+    };
+    using Queue = std::priority_queue<Cell<T>, std::vector<Cell<T>>, decltype(compareMax)>;
+    Queue cellQueue(compareMax);
+
+    if (cellSize == 0) {
+        return envelope.min;
+    }
+
+    // cover polygon with initial cells
+    for (T x = envelope.min.x; x < envelope.max.x; x += cellSize) {
+        for (T y = envelope.min.y; y < envelope.max.y; y += cellSize) {
+            cellQueue.push(Cell<T>({x + h, y + h}, h, polygon));
+        }
+    }
+
+    // take centroid as the first best guess
+    auto bestCell = getCentroidCell(polygon);
+
+    // special case for rectangular polygons
+    Cell<T> bboxCell(envelope.min + size / 2.0, 0, polygon);
+    if (bboxCell.d > bestCell.d) {
+        bestCell = bboxCell;
+    }
+
+    auto numProbes = cellQueue.size();
+    while (!cellQueue.empty()) {
+        // pick the most promising cell from the queue
+        auto cell = cellQueue.top();
+        cellQueue.pop();
+
+        // update the best cell if we found a better one
+        if (cell.d > bestCell.d) {
+            bestCell = cell;
+            if (debug) std::cout << "found best " << ::round(1e4 * cell.d) / 1e4 << " after " << numProbes << " probes" << std::endl;
+        }
+
+        // do not drill down further if there's no chance of a better solution
+        if (cell.max - bestCell.d <= precision) continue;
+
+        // split the cell into four cells
+        h = cell.h / 2;
+        cellQueue.push(Cell<T>({cell.c.x - h, cell.c.y - h}, h, polygon));
+        cellQueue.push(Cell<T>({cell.c.x + h, cell.c.y - h}, h, polygon));
+        cellQueue.push(Cell<T>({cell.c.x - h, cell.c.y + h}, h, polygon));
+        cellQueue.push(Cell<T>({cell.c.x + h, cell.c.y + h}, h, polygon));
+        numProbes += 4;
+    }
+
+    if (debug) {
+        std::cout << "num probes: " << numProbes << std::endl;
+        std::cout << "best distance: " << bestCell.d << std::endl;
+    }
+
+    return bestCell.c;
+}
+
+} // namespace mapbox

libs/snake_old/polylabel/mapbox/recursive_wrapper.hpp

+#ifndef MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
+#define MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
+
+// Based on variant/recursive_wrapper.hpp from boost.
+//
+// Original license:
+//
+// Copyright (c) 2002-2003
+// Eric Friedman, Itay Maman
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cassert>
+#include <utility>
+
+namespace mapbox {
+namespace util {
+
+template <typename T>
+class recursive_wrapper
+{
+
+    T* p_;
+
+    void assign(T const& rhs)
+    {
+        this->get() = rhs;
+    }
+
+  public:
+    using type = T;
+
+    /**
+     * Default constructor default initializes the internally stored value.
+     * For POD types this means nothing is done and the storage is
+     * uninitialized.
+     *
+     * @throws std::bad_alloc if there is insufficient memory for an object
+     *         of type T.
+     * @throws any exception thrown by the default constructur of T.
+     */
+    recursive_wrapper()
+        : p_(new T){};
+
+    ~recursive_wrapper() noexcept { delete p_; };
+
+    recursive_wrapper(recursive_wrapper const& operand)
+        : p_(new T(operand.get())) {}
+
+    recursive_wrapper(T const& operand)
+        : p_(new T(operand)) {}
+
+    recursive_wrapper(recursive_wrapper&& operand)
+        : p_(new T(std::move(operand.get()))) {}
+
+    recursive_wrapper(T&& operand)
+        : p_(new T(std::move(operand))) {}
+
+    inline recursive_wrapper& operator=(recursive_wrapper const& rhs)
+    {
+        assign(rhs.get());
+        return *this;
+    }
+
+    inline recursive_wrapper& operator=(T const& rhs)
+    {
+        assign(rhs);
+        return *this;
+    }
+
+    inline void swap(recursive_wrapper& operand) noexcept
+    {
+        T* temp = operand.p_;
+        operand.p_ = p_;
+        p_ = temp;
+    }
+
+    recursive_wrapper& operator=(recursive_wrapper&& rhs) noexcept
+    {
+        swap(rhs);
+        return *this;
+    }
+
+    recursive_wrapper& operator=(T&& rhs)
+    {
+        get() = std::move(rhs);
+        return *this;
+    }
+
+    T& get()
+    {
+        assert(p_);
+        return *get_pointer();
+    }
+
+    T const& get() const
+    {
+        assert(p_);
+        return *get_pointer();
+    }
+
+    T* get_pointer() { return p_; }
+
+    const T* get_pointer() const { return p_; }
+
+    operator T const&() const { return this->get(); }
+
+    operator T&() { return this->get(); }
+
+}; // class recursive_wrapper
+
+template <typename T>
+inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs) noexcept
+{
+    lhs.swap(rhs);
+}
+} // namespace util
+} // namespace mapbox
+
+#endif // MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP

libs/snake_old/polylabel/mapbox/variant_io.hpp

+#ifndef MAPBOX_UTIL_VARIANT_IO_HPP
+#define MAPBOX_UTIL_VARIANT_IO_HPP
+
+#include <iosfwd>
+
+#include "variant.hpp"
+
+namespace mapbox {
+namespace util {
+
+namespace detail {
+// operator<< helper
+template <typename Out>
+class printer
+{
+  public:
+    explicit printer(Out& out)
+        : out_(out) {}
+    printer& operator=(printer const&) = delete;
+
+    // visitor
+    template <typename T>
+    void operator()(T const& operand) const
+    {
+        out_ << operand;
+    }
+
+  private:
+    Out& out_;
+};
+}
+
+// operator<<
+template <typename CharT, typename Traits, typename... Types>
+VARIANT_INLINE std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& out, variant<Types...> const& rhs)
+{
+    detail::printer<std::basic_ostream<CharT, Traits>> visitor(out);
+    apply_visitor(visitor, rhs);
+    return out;
+}
+} // namespace util
+} // namespace mapbox
+
+#endif // MAPBOX_UTIL_VARIANT_IO_HPP

libs/snake_old/snake.h

+#pragma once
+
+#include <vector>
+#include <string>
+#include <array>
+
+#include "snake_geometry.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"
+
+using namespace std;
+using namespace snake_geometry;
+
+using namespace operations_research;
+
+namespace snake {
+
+    enum AreaType {MeasurementArea, ServiceArea, Corridor};
+
+    struct Area {
+        GeoPoint2DList      geoPolygon;
+        double              altitude;
+        size_t              layers;
+        AreaType            type;
+    };
+
+    //========================================================================================
+    // Scenario
+    //========================================================================================
+    class Scenario{
+    public:
+        Scenario();
+
+        bool addArea(Area &area);
+
+        const Area &getMeasurementArea() const {return _measurementArea;}
+        const Area &getServiceArea() const {return _serviceArea;}
+        const Area &getCorridor() const {return _corridor;}
+
+        const BoostPolygon &getMeasurementAreaENU() {return _measurementAreaENU;}
+        const BoostPolygon &getServiceAreaENU()     {return _serviceAreaENU;}
+        const BoostPolygon &getCorridorENU()        {return _corridorENU;}
+        const BoostPolygon &getJoineAreaENU()       {return _joinedAreaENU;}
+        const GeoPoint3D   &getOrigin()             {return _geoOrigin;}
+
+        const vector<BoostPolygon> &getTilesENU()               {return _tilesENU;}
+        const BoostLineString      &getTileCenterPointsENU()    {return _tileCenterPointsENU;}
+        const min_bbox_rt          &getMeasurementAreaBBoxENU() {return _mAreaBoundingBox;}
+        const BoostPoint           &getHomePositonENU()         {return _homePositionENU;}
+
+        bool defined(double tileWidth, double tileHeight, double minTileArea);
+
+        string errorString;
+
+    private:
+        bool _areas2enu();
+        bool _setMeasurementArea(Area &area);
+        bool _setServiceArea(Area &area);
+        bool _setCorridor(Area &area);
+        bool _calculateBoundingBox();
+        bool _calculateTiles(double tileWidth, double tileHeight, double minTileArea);
+        bool _calculateJoinedArea();
+
+        Area _measurementArea;
+        Area _serviceArea;
+        Area _corridor;
+
+        BoostPolygon _measurementAreaENU;
+        BoostPolygon _serviceAreaENU;
+        BoostPolygon _corridorENU;
+        BoostPolygon _joinedAreaENU;
+
+        min_bbox_rt _mAreaBoundingBox;
+
+        vector<BoostPolygon>    _tilesENU;
+        BoostLineString         _tileCenterPointsENU;
+
+        GeoPoint3D _geoOrigin;
+        BoostPoint _homePositionENU;
+    };
+
+    //========================================================================================
+    // FlightPlan
+    //========================================================================================
+
+    class FlightPlan{
+    public:
+        FlightPlan();
+
+        void setScenario(const Scenario &scenario)          {_scenario = scenario;}
+        void setProgress(const vector<int8_t> &progress)    {_progress = progress;}
+
+        const Scenario          &getScenario(void)      const {return _scenario;}
+        const BoostLineString   &getWaypointsENU(void)  const {return _waypointsENU;}
+        const GeoPoint2DList    &getWaypoints(void)     const {return _waypoints;}
+#ifndef NDEBUG
+        const BoostLineString   &getPathVertices(void)  const {return _PathVertices;}
+#endif
+
+        bool                            generate(double lineDistance, double minTransectLength);
+        const vector<BoostLineString>  &getTransects() const {return _transects;}
+
+        string errorString;
+
+    private:
+        // Search Filter to speed up routing.SolveWithParameters(...);
+        // Found here: http://www.lia.disi.unibo.it/Staff/MicheleLombardi/or-tools-doc/user_manual/manual/ls/ls_filtering.html
+        class SearchFilter : public LocalSearchFilter{
+
+        };
+
+        typedef struct{
+            Matrix<int64_t>                 distanceMatrix;
+            long                            numVehicles;
+            RoutingIndexManager::NodeIndex  depot;
+        }RoutingDataModel_t;
+
+        bool _generateTransects(double lineDistance, double minTransectLength);
+        void _generateRoutingModel(const BoostLineString &vertices,
+                                   const BoostPolygon &polygonOffset,
+                                   size_t n0,
+                                   RoutingDataModel_t &dataModel,
+                                   Matrix<double> &graph);
+
+        Scenario                                _scenario;
+        BoostLineString                         _waypointsENU;
+        GeoPoint2DList                          _waypoints;
+        vector<BoostLineString>                 _transects;
+        vector<int8_t>                          _progress;
+
+#ifndef NDEBUG
+        BoostLineString                         _PathVertices;
+#endif
+    };
+
+    namespace detail {
+        const double offsetConstant = 0.1; // meter, polygon offset to compenstate for numerical inaccurracies.
+    }
+}
+

libs/snake_old/snake_geometry.h

+#pragma once
+#include <vector>
+#include <array>
+#include <boost/geometry.hpp>
+#include <bits/stl_set.h>
+
+namespace bg = boost::geometry;
+
+namespace snake_geometry {
+
+typedef std::array<double, 3>   Point2D;
+typedef std::array<double, 3>   Point3D;
+typedef std::array<double, 3>   GeoPoint3D;
+typedef std::array<double, 2>   GeoPoint2D;
+typedef std::vector<Point2D>    Point2DList;
+typedef std::vector<Point3D>    Point3DList;
+typedef std::vector<GeoPoint2D> GeoPoint2DList;
+typedef std::vector<GeoPoint3D> GeoPoint3DList;
+
+typedef bg::model::point<double, 2, bg::cs::cartesian>  BoostPoint;
+//typedef std::vector<BoostPoint>                        BoostPointList;
+typedef bg::model::polygon<BoostPoint>                  BoostPolygon;
+typedef bg::model::linestring<BoostPoint>               BoostLineString;
+typedef std::vector<std::vector<int64_t>>               Int64Matrix;
+
+
+template<class T>
+class Matrix{
+public:
+    Matrix() :
+        _elements(0),
+        _m(0),
+        _n(0),
+        _isInitialized(false)
+    {
+    }
+    Matrix(size_t m, size_t n) : Matrix(m, n, T{0}){}
+    Matrix(size_t m, size_t n, T value) :
+        _elements(m*n),
+        _m(m),
+        _n(n),
+        _isInitialized(true)
+    {
+        assert((m > 0) || (n > 0));
+        _matrix.resize(_elements, value);
+    }
+
+    double get(size_t i, size_t j) const
+    {
+        assert(_isInitialized);
+        assert(i < _m);
+        assert(j < _n);
+        return _matrix[i*_m+j];
+    }
+
+    size_t getM() const { return _m;}
+    size_t getN() const { return _n;}
+
+    void set(size_t i, size_t j, const T &value)
+    {
+        assert(_isInitialized);
+        assert(i < _m);
+        assert(j < _n);
+        _matrix[i*_m+j] = value;
+    }
+
+    void setDimension(size_t m, size_t n, const T &value)
+    {
+        assert((m > 0) || (n > 0));
+        assert(!_isInitialized);
+        if (!_isInitialized){
+            _m = m;
+            _n = n;
+            _elements = n*m;
+            _matrix.resize(_elements, value);
+        }
+    }
+
+    void setDimension(size_t m, size_t n)
+    {
+        assert((m > 0) || (n > 0));
+        assert(!_isInitialized);
+        if (!_isInitialized){
+            _m = m;
+            _n = n;
+            _elements = n*m;
+            _matrix.resize(_elements);
+        }
+    }
+
+private:
+    size_t _elements;
+    size_t _m;
+    size_t _n;
+    bool   _isInitialized;
+    std::vector<T> _matrix;
+};
+
+typedef struct {
+    double width;
+    double height;
+    double angle;
+    BoostPolygon corners;
+}min_bbox_rt;
+
+void toENU(const GeoPoint3D &WGS84Reference, const GeoPoint3D &WGS84Position, Point3D &ENUPosition);
+void fromENU(const Point3D &WGS84Reference, const Point3D &ENUPosition, GeoPoint3D &WGS84Position);
+
+void polygonCenter(const BoostPolygon &polygon, BoostPoint &center);
+void minimalBoundingBox(const BoostPolygon &polygon, min_bbox_rt &minBBox);
+void offsetPolygon(const BoostPolygon &polygon, BoostPolygon &polygonOffset, double offset);
+
+void graphFromPolygon(const BoostPolygon &polygon, const BoostLineString &vertices, Matrix<double> &graph);
+void toDistanceMatrix(Matrix<double> &graph);
+bool dijkstraAlgorithm(const size_t numElements,
+                       size_t startIndex,
+                       size_t endIndex,
+                       std::vector<size_t> &elementPath,
+                       std::function<double (const size_t, const size_t)> distanceDij);
+void shortestPathFromGraph(const Matrix<double> &graph,
+                           size_t startIndex,
+                           size_t endIndex,
+                           std::vector<size_t> &pathIdx);
+
+
+void rotateDeg(const Point2DList &point_list, Point2DList &rotated_point_list, double degree);
+void rotateRad(const Point2DList &point_list, Point2DList &rotated_point_list, double rad);
+
+bool isClockwise(const Point2DList &point_list);
+
+void toBoost(const Point2D &point, BoostPoint &boost_point);
+void toBoost(const Point2DList &point_list, BoostPolygon &boost_polygon);
+
+void fromBoost(const BoostPoint &boost_point, Point2D &point);
+void fromBoost(const BoostPolygon &boost_polygon, Point2DList &point_list);
+}

qgroundcontrol.pro

@@ -209,7 +209,7 @@ LinuxBuild {
 
 CONFIG += qt \
     thread \
-    c++11
+    c++14
 
 DebugBuild {
     CONFIG -= qtquickcompiler
@@ -360,6 +360,7 @@ INCLUDEPATH += \
     src/QtLocationPlugin \
     src/QtLocationPlugin/QMLControl \
     src/Settings \
+    src/Snake \
     src/Terrain \
     src/VehicleSetup \
     src/ViewWidgets \
@@ -402,6 +403,31 @@ FORMS += \
 #
 
 HEADERS += \
+    src/Snake/clipper/clipper.hpp \
+    src/Snake/mapbox/feature.hpp \
+    src/Snake/mapbox/geometry.hpp \
+    src/Snake/mapbox/geometry/box.hpp \
+    src/Snake/mapbox/geometry/empty.hpp \
+    src/Snake/mapbox/geometry/envelope.hpp \
+    src/Snake/mapbox/geometry/for_each_point.hpp \
+    src/Snake/mapbox/geometry/geometry.hpp \
+    src/Snake/mapbox/geometry/line_string.hpp \
+    src/Snake/mapbox/geometry/multi_line_string.hpp \
+    src/Snake/mapbox/geometry/multi_point.hpp \
+    src/Snake/mapbox/geometry/multi_polygon.hpp \
+    src/Snake/mapbox/geometry/point.hpp \
+    src/Snake/mapbox/geometry/point_arithmetic.hpp \
+    src/Snake/mapbox/geometry/polygon.hpp \
+    src/Snake/mapbox/geometry_io.hpp \
+    src/Snake/mapbox/optional.hpp \
+    src/Snake/mapbox/polylabel.hpp \
+    src/Snake/mapbox/recursive_wrapper.hpp \
+    src/Snake/mapbox/variant.hpp \
+    src/Snake/mapbox/variant_io.hpp \
+    src/Snake/snake.h \
+    src/Snake/snake_geometry.h \
+    src/Snake/snake_global.h \
+    src/Wima/WimaControllerDetail.h \
     src/api/QGCCorePlugin.h \
     src/api/QGCOptions.h \
     src/api/QGCSettings.h \
@@ -435,8 +461,13 @@ HEADERS += \
     src/Wima/TestPolygonCalculus.h \
     src/Wima/testplanimetrycalculus.h \
     src/Settings/WimaSettings.h \
-    src/QmlControls/QmlObjectVectorModel.h
+    src/QmlControls/QmlObjectVectorModel.h \
+    src/comm/utilities.h
 SOURCES += \
+    src/Snake/clipper/clipper.cpp \
+    src/Snake/snake.cpp \
+    src/Snake/snake_geometry.cpp \
+    src/Wima/WimaControllerDetail.cc \
     src/api/QGCCorePlugin.cc \
     src/api/QGCOptions.cc \
     src/api/QGCSettings.cc \

src/Airmap/Airmap_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+#include "G2HJQHALR5/moc_AirspaceManager.cpp"

src/AnalyzeView/AnalyzeView_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+#include "EWIEGA46WW/moc_GeoTagController.cpp"
+#include "EWIEGA46WW/moc_LogDownloadController.cpp"
+#include "EWIEGA46WW/moc_LogDownloadTest.cpp"
+#include "EWIEGA46WW/moc_MavlinkConsoleController.cpp"

src/Audio/Audio_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+#include "EWIEGA46WW/moc_AudioOutput.cpp"
+#include "EWIEGA46WW/moc_AudioOutputTest.cpp"

src/AutoPilotPlugins/AutoPilotPlugins_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+#include "FFHNZN56LN/moc_APMAirframeComponent.cpp"
+#include "FFHNZN56LN/moc_APMAirframeComponentController.cpp"
+#include "FFHNZN56LN/moc_APMAirframeLoader.cpp"
+#include "FFHNZN56LN/moc_APMAutoPilotPlugin.cpp"
+#include "FFHNZN56LN/moc_APMCameraComponent.cpp"
+#include "FFHNZN56LN/moc_APMCompassCal.cpp"
+#include "FFHNZN56LN/moc_APMFlightModesComponent.cpp"
+#include "FFHNZN56LN/moc_APMFlightModesComponentController.cpp"
+#include "FFHNZN56LN/moc_APMHeliComponent.cpp"
+#include "FFHNZN56LN/moc_APMLightsComponent.cpp"
+#include "FFHNZN56LN/moc_APMMotorComponent.cpp"
+#include "FFHNZN56LN/moc_APMPowerComponent.cpp"
+#include "FFHNZN56LN/moc_APMRadioComponent.cpp"
+#include "FFHNZN56LN/moc_APMSafetyComponent.cpp"
+#include "FFHNZN56LN/moc_APMSensorsComponent.cpp"
+#include "FFHNZN56LN/moc_APMSensorsComponentController.cpp"
+#include "FFHNZN56LN/moc_APMSubFrameComponent.cpp"
+#include "FFHNZN56LN/moc_APMTuningComponent.cpp"
+#include "EWIEGA46WW/moc_AutoPilotPlugin.cpp"
+#include "U2NUAE3D6E/moc_ESP8266Component.cpp"
+#include "U2NUAE3D6E/moc_ESP8266ComponentController.cpp"
+#include "U2NUAE3D6E/moc_MotorComponent.cpp"
+#include "U2NUAE3D6E/moc_RadioComponentController.cpp"
+#include "U2NUAE3D6E/moc_SyslinkComponent.cpp"
+#include "U2NUAE3D6E/moc_SyslinkComponentController.cpp"
+#include "KYKGY3RYO2/moc_GenericAutoPilotPlugin.cpp"
+#include "KIEVYJJCTC/moc_AirframeComponent.cpp"
+#include "KIEVYJJCTC/moc_AirframeComponentController.cpp"
+#include "KIEVYJJCTC/moc_CameraComponent.cpp"
+#include "KIEVYJJCTC/moc_FlightModesComponent.cpp"
+#include "KIEVYJJCTC/moc_PX4AdvancedFlightModesController.cpp"
+#include "KIEVYJJCTC/moc_PX4AirframeLoader.cpp"
+#include "KIEVYJJCTC/moc_PX4AutoPilotPlugin.cpp"
+#include "KIEVYJJCTC/moc_PX4RadioComponent.cpp"
+#include "KIEVYJJCTC/moc_PX4SimpleFlightModesController.cpp"
+#include "KIEVYJJCTC/moc_PX4TuningComponent.cpp"
+#include "KIEVYJJCTC/moc_PowerComponent.cpp"
+#include "KIEVYJJCTC/moc_PowerComponentController.cpp"
+#include "KIEVYJJCTC/moc_SafetyComponent.cpp"
+#include "KIEVYJJCTC/moc_SensorsComponent.cpp"
+#include "KIEVYJJCTC/moc_SensorsComponentController.cpp"

src/Camera/Camera_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+#include "EWIEGA46WW/moc_QGCCameraControl.cpp"
+#include "EWIEGA46WW/moc_QGCCameraManager.cpp"

src/FlightDisplay/FlightDisplay_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+#include "EWIEGA46WW/moc_VideoManager.cpp"

src/FlightMap/FlightMap_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+#include "WHF3XMZT5M/moc_ValuesWidgetController.cpp"

src/FollowMe/FollowMe_autogen/mocs_compilation.cpp

+// This file is autogenerated. Changes will be overwritten.
+#include "EWIEGA46WW/moc_FollowMe.cpp"