Scenario and various libs added

.gitmodules

@@ -4,3 +4,9 @@
 [submodule "libs/mavlink/include/mavlink/v2.0"]
 	path = libs/mavlink/include/mavlink/v2.0
 	url = https://github.com/mavlink/c_library_v2.git
+[submodule "libs/WGS84toCartesian"]
+	path = libs/WGS84toCartesian
+	url = https://github.com/chrberger/WGS84toCartesian.git
+[submodule "libs/polylabel"]
+	path = libs/polylabel
+	url = https://github.com/mapbox/polylabel.git

WGS84toCartesian @ 15181a84

+Subproject commit 15181a849968866efa5ac220d3f7c2e5ac281254

libs/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/include/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/mason_packages/headers/geometry/1.0.0/mason.ini

+name=geometry
+version=1.0.0
+header_only=true
+include_dirs={prefix}/include

libs/mason_packages/headers/polylabel/1.0.3/LICENSE

+ISC License
+Copyright (c) 2016 Mapbox
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
+OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.

libs/mason_packages/headers/polylabel/1.0.3/README.md

+## polylabel [![Build Status](https://travis-ci.org/mapbox/polylabel.svg?branch=master)](https://travis-ci.org/mapbox/polylabel)
+
+A fast algorithm for finding polygon _pole of inaccessibility_,
+the most distant internal point from the polygon outline (not to be confused with centroid),
+implemented as a JavaScript library.
+Useful for optimal placement of a text label on a polygon.
+
+It's an iterative grid algorithm,
+inspired by [paper by Garcia-Castellanos & Lombardo, 2007](https://sites.google.com/site/polesofinaccessibility/).
+Unlike the one in the paper, this algorithm:
+
+- guarantees finding **global optimum** within the given precision
+- is many times faster (10-40x)
+
+![](https://cloud.githubusercontent.com/assets/25395/16745865/864a0a30-47c0-11e6-87bc-58acac41a520.png)
+
+### How the algorithm works
+
+This is an iterative grid-based algorithm, which starts by covering the polygon with big square cells and then iteratively splitting them in the order of the most promising ones, while aggressively pruning uninteresting cells.
+
+1. Generate initial square cells that fully cover the polygon (with cell size equal to either width or height, whichever is lower). Calculate distance from the center of each cell to the outer polygon, using negative value if the point is outside the polygon (detected by ray-casting).
+2. Put the cells into a priority queue sorted by the maximum potential distance from a point inside a cell, defined as a sum of the distance from the center and the cell radius (equal to `cell_size * sqrt(2) / 2`).
+3. Calculate the distance from the centroid of the polygon and pick it as the first "best so far".
+4. Pull out cells from the priority queue one by one. If a cell's distance is better than the current best, save it as such.
+Then, if the cell potentially contains a better solution that the current best (`cell_max - best_dist > precision`),
+split it into 4 children cells and put them in the queue.
+5. Stop the algorithm when we have exhausted the queue and return the best cell's center as the pole of inaccessibility.
+It will be guaranteed to be a global optimum within the given precision.
+
+![image](https://cloud.githubusercontent.com/assets/25395/16748630/e6b3336c-47cd-11e6-8059-0eeccf22cf6b.png)
+
+### JavaScript Usage
+
+Given polygon coordinates in
+[GeoJSON-like format](http://geojson.org/geojson-spec.html#polygon)
+and precision (`1.0` by default),
+Polylabel returns the pole of inaccessibility coordinate in `[x, y]` format.
+
+```js
+var p = polylabel(polygon, 1.0);
+```
+
+### TypeScript
+
+[TypeScript type definitions](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/concaveman)
+are available via `npm install --save @types/polylabel`.
+
+### C++ Usage
+
+It is recommended to install polylabel via [mason](https://github.com/mapbox/mason). You will also need to install its dependencies: [geometry.hpp](https://github.com/mapbox/geometry.hpp) and [variant](https://github.com/mapbox/variant).
+
+```C++
+#include <mapbox/polylabel.hpp>
+
+int main() {
+    mapbox::geometry::polygon<double> polygon = readPolygon(); // Get polygon data from somewhere.
+    mapbox::geometry::point<double> p = mapbox::polylabel(polygon, 1.0);
+    return 0;
+}
+```
+
+### Command Line Usage
+
+An external utility can be found at https://github.com/andrewharvey/geojson-polygon-labels

libs/mason_packages/headers/polylabel/1.0.3/include/mapbox/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/mason_packages/headers/polylabel/1.0.3/mason.ini

+name=polylabel
+version=1.0.3
+header_only=true
+include_dirs={prefix}/include

libs/mason_packages/headers/variant/1.1.0/LICENSE

+Copyright (c) MapBox
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+- Neither the name "MapBox" nor the names of its contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file

libs/mason_packages/headers/variant/1.1.0/README.md

+# Mapbox Variant
+
+An alternative to `boost::variant` for C++11.
+
+[![Build Status](https://secure.travis-ci.org/mapbox/variant.svg)](https://travis-ci.org/mapbox/variant)
+[![Build status](https://ci.appveyor.com/api/projects/status/v9tatx21j1k0fcgy)](https://ci.appveyor.com/project/Mapbox/variant)
+[![Coverage Status](https://coveralls.io/repos/mapbox/variant/badge.svg?branch=master&service=github)](https://coveralls.io/r/mapbox/variant?branch=master)
+
+
+## Why use Mapbox Variant?
+
+Mapbox variant has the same speedy performance of `boost::variant` but is
+faster to compile, results in smaller binaries, and has no dependencies.
+
+For example on OS X 10.9 with clang++ and libc++:
+
+Test | Mapbox Variant | Boost Variant
+---- | -------------- | -------------
+Size of pre-compiled header (release / debug) | 2.8/2.8 MB         | 12/15 MB
+Size of simple program linking variant (release / debug)     | 8/24 K             | 12/40 K
+Time to compile header     | 185 ms             |  675 ms
+
+(Numbers from an older version of Mapbox variant.)
+
+
+## Goals
+
+Mapbox `variant` has been a very valuable, lightweight alternative for apps
+that can use c++11 or c++14 but that do not want a boost dependency.
+Mapbox `variant` has also been useful in apps that do depend on boost, like
+mapnik, to help (slightly) with compile times and to majorly lessen dependence
+on boost in core headers. The original goal and near term goal is to maintain
+external API compatibility with `boost::variant` such that Mapbox `variant`
+can be a "drop in". At the same time the goal is to stay minimal: Only
+implement the features that are actually needed in existing software. So being
+an "incomplete" implementation is just fine.
+
+Currently Mapbox variant doesn't try to be API compatible with the upcoming
+variant standard, because the standard is not finished and it would be too much
+work. But we'll revisit this decision in the future if needed.
+
+If Mapbox variant is not for you, have a look at [these other
+implementations](doc/other_implementations.md).
+
+Want to know more about the upcoming standard? Have a look at our
+[overview](doc/standards_effort.md).
+
+
+## Depends
+
+ - Compiler supporting `-std=c++11` or `-std=c++14`
+
+Tested with:
+
+ - g++-4.7
+ - g++-4.8
+ - g++-4.9
+ - g++-5
+ - clang++-3.5
+ - clang++-3.6
+ - clang++-3.7
+ - clang++-3.8
+ - Visual Studio 2015
+
+## Usage
+
+There is nothing to build, just include `variant.hpp` and
+`recursive_wrapper.hpp` in your project. Include `variant_io.hpp` if you need
+the `operator<<` overload for variant.
+
+
+## Unit Tests
+
+On Unix systems compile and run the unit tests with `make test`.
+
+On Windows run `scripts/build-local.bat`.
+
+
+## Limitations
+
+* The `variant` can not hold references (something like `variant<int&>` is
+  not possible). You might want to try `std::reference_wrapper` instead.
+
+
+## Deprecations
+
+* The included implementation of `optional` is deprecated and will be removed
+  in a future version. See https://github.com/mapbox/variant/issues/64.
+* Old versions of the code needed visitors to derive from `static_visitor`.
+  This is not needed any more and marked as deprecated. The `static_visitor`
+  class will be removed in future versions.
+
+
+## Benchmarks
+
+The benchmarks depend on:
+
+ - Boost headers (for benchmarking against `boost::variant`)
+ - Boost built with `--with-timer` (used for benchmark timing)
+
+On Unix systems set your boost includes and libs locations and run `make test`:
+
+    export LDFLAGS='-L/opt/boost/lib'
+    export CXXFLAGS='-I/opt/boost/include'
+    make bench
+
+
+## Check object sizes
+
+    make sizes /path/to/boost/variant.hpp
+

libs/mason_packages/headers/variant/1.1.0/include/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/mason_packages/headers/variant/1.1.0/include/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/mason_packages/headers/variant/1.1.0/include/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/mason_packages/headers/variant/1.1.4/LICENSE

+Copyright (c) MapBox
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+- Neither the name "MapBox" nor the names of its contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file

libs/mason_packages/headers/variant/1.1.4/README.md

+# Mapbox Variant
+
+An header-only alternative to `boost::variant` for C++11 and C++14
+
+[![Build Status](https://secure.travis-ci.org/mapbox/variant.svg)](https://travis-ci.org/mapbox/variant)
+[![Build status](https://ci.appveyor.com/api/projects/status/v9tatx21j1k0fcgy)](https://ci.appveyor.com/project/Mapbox/variant)
+[![Coverage Status](https://coveralls.io/repos/mapbox/variant/badge.svg?branch=master&service=github)](https://coveralls.io/r/mapbox/variant?branch=master)
+
+## Introduction
+
+Variant's basic building blocks are:
+- `variant<Ts...>` - a type-safe representation for sum-types / discriminated unions
+- `recursive_wrapper<T>` - a helper type to represent recursive "tree-like" variants
+- `apply_visitor(visitor, myVariant)` - to invoke a custom visitor on the variant's underlying type
+- `get<T>()` - a function to directly unwrap a variant's underlying type
+- `.match([](Type){})` - a variant convenience member function taking an arbitrary number of lambdas creating a visitor behind the scenes and applying it to the variant
+
+
+### Basic Usage - HTTP API Example
+
+Suppose you want to represent a HTTP API response which is either a JSON result or an error:
+
+```c++
+struct Result {
+  Json object;
+};
+
+struct Error {
+  int32_t code;
+  string message;
+};
+```
+
+You can represent this at type level using a variant which is either an `Error` or a `Result`:
+
+```c++
+using Response = variant<Error, Result>;
+
+Response makeRequest() {
+  return Error{501, "Not Implemented"};
+}
+
+Response ret = makeRequest();
+```
+
+To see which type the `Response` holds you pattern match on the variant unwrapping the underlying value:
+
+```c++
+ret.match([] (Result r) { print(r.object); }
+          [] (Error e)  { print(e.message); });
+```
+
+Instead of using the variant's convenience `.match` pattern matching function you can create a type visitor functor and use `apply_visitor` manually:
+
+```c++
+struct ResponseVisitor {
+  void operator()(Result r) const {
+    print(r.object);
+  }
+
+  void operator()(Error e) const {
+    print(e.message);
+  }
+};
+
+ResponseVisitor visitor;
+apply_visitor(visitor, ret);
+```
+
+In both cases the compiler makes sure you handle all types the variant can represent at compile.
+
+
+### Recursive Variants - JSON Example
+
+[JSON](http://www.json.org/) consists of types `String`, `Number`, `True`, `False`, `Null`, `Array` and `Object`.
+
+
+```c++
+struct String { string value; };
+struct Number { double value; };
+struct True   { };
+struct False  { };
+struct Null   { };
+struct Array  { vector<?> values; };
+struct Object { unordered_map<string, ?> values; };
+```
+
+This works for primitive types but how do we represent recursive types such as `Array` which can hold multiple elements and `Array` itself, too?
+
+For these use cases Variant provides a `recursive_wrapper` helper type which lets you express recursive Variants.
+
+```c++
+struct String { string value; };
+struct Number { double value; };
+struct True   { };
+struct False  { };
+struct Null   { };
+
+// Forward declarations only
+struct Array;
+struct Object;
+
+using Value = variant<String, Number, True, False, Null, recursive_wrapper<Array>, recursive_wrapper<Object>>;
+
+struct Array {
+  vector<Value> values;
+};
+
+struct Object {
+  unordered_map<string, Value> values;
+};
+```
+
+For walkig the JSON representation you can again either create a `JSONVisitor`:
+
+```c++
+struct JSONVisitor {
+
+  void operator()(Null) const {
+    print("null");
+  }
+
+  // same for all other JSON types
+};
+
+JSONVisitor visitor;
+apply_visitor(visitor, json);
+```
+
+Or use the convenience `.match` pattern matching function:
+
+```c++
+json.match([] (Null) { print("null"); },
+           ...);
+```
+
+To summarize: use `recursive_wrapper` to represent recursive "tree-like" representations:
+
+```c++
+struct Empty { };
+struct Node;
+
+using Tree = variant<Empty, recursive_wrapper<Node>>;
+
+struct Node {
+  uint64_t value;
+}
+```
+### Advanced Usage Tips
+
+Creating type aliases for variants is a great way to reduce repetition.
+Keep in mind those type aliases are not checked at type level, though.
+We recommend creating a new type for all but basic variant usage:
+
+```c++
+// the compiler can't tell the following two apart
+using APIResult = variant<Error, Result>;
+using FilesystemResult = variant<Error, Result>;
+
+// new type
+struct APIResult : variant<Error, Result> {
+  using Base = variant<Error, Result>;
+  using Base::Base;
+}
+```
+
+
+## Why use Mapbox Variant?
+
+Mapbox variant has the same speedy performance of `boost::variant` but is
+faster to compile, results in smaller binaries, and has no dependencies.
+
+For example on OS X 10.9 with clang++ and libc++:
+
+Test | Mapbox Variant | Boost Variant
+---- | -------------- | -------------
+Size of pre-compiled header (release / debug) | 2.8/2.8 MB         | 12/15 MB
+Size of simple program linking variant (release / debug)     | 8/24 K             | 12/40 K
+Time to compile header     | 185 ms             |  675 ms
+
+(Numbers from an older version of Mapbox variant.)
+
+
+## Goals
+
+Mapbox `variant` has been a very valuable, lightweight alternative for apps
+that can use c++11 or c++14 but that do not want a boost dependency.
+Mapbox `variant` has also been useful in apps that do depend on boost, like
+mapnik, to help (slightly) with compile times and to majorly lessen dependence
+on boost in core headers. The original goal and near term goal is to maintain
+external API compatibility with `boost::variant` such that Mapbox `variant`
+can be a "drop in". At the same time the goal is to stay minimal: Only
+implement the features that are actually needed in existing software. So being
+an "incomplete" implementation is just fine.
+
+Currently Mapbox variant doesn't try to be API compatible with the upcoming
+variant standard, because the standard is not finished and it would be too much
+work. But we'll revisit this decision in the future if needed.
+
+If Mapbox variant is not for you, have a look at [these other
+implementations](doc/other_implementations.md).
+
+Want to know more about the upcoming standard? Have a look at our
+[overview](doc/standards_effort.md).
+
+Most modern high-level languages provide ways to express sum types directly.
+If you're curious have a look at Haskell's pattern matching or Rust's and Swift's enums.
+
+
+## Depends
+
+ - Compiler supporting `-std=c++11` or `-std=c++14`
+
+Tested with:
+
+ - g++-4.7
+ - g++-4.8
+ - g++-4.9
+ - g++-5.2
+ - clang++-3.5
+ - clang++-3.6
+ - clang++-3.7
+ - clang++-3.8
+ - clang++-3.9
+ - Visual Studio 2015
+
+
+## Unit Tests
+
+On Unix systems compile and run the unit tests with `make test`.
+
+On Windows run `scripts/build-local.bat`.
+
+
+## Limitations
+
+* The `variant` can not hold references (something like `variant<int&>` is
+  not possible). You might want to try `std::reference_wrapper` instead.
+
+
+## Deprecations
+
+* The included implementation of `optional` is deprecated and will be removed
+  in a future version. See https://github.com/mapbox/variant/issues/64.
+* Old versions of the code needed visitors to derive from `static_visitor`.
+  This is not needed any more and marked as deprecated. The `static_visitor`
+  class will be removed in future versions.
+
+
+## Benchmarks
+
+    make bench
+
+
+## Check object sizes
+
+    make sizes /path/to/boost/variant.hpp
+

libs/mason_packages/headers/variant/1.1.4/include/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 <mapbox/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/mason_packages/headers/variant/1.1.4/include/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/mason_packages/headers/variant/1.1.4/include/mapbox/variant_io.hpp

+#ifndef MAPBOX_UTIL_VARIANT_IO_HPP
+#define MAPBOX_UTIL_VARIANT_IO_HPP
+
+#include <iosfwd>
+
+#include <mapbox/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/mason_packages/headers/variant/1.1.4/include/mapbox/variant_visitor.hpp

+#ifndef MAPBOX_UTIL_VARIANT_VISITOR_HPP
+#define MAPBOX_UTIL_VARIANT_VISITOR_HPP
+
+namespace mapbox {
+namespace util {
+
+template <typename... Fns>
+struct visitor;
+
+template <typename Fn>
+struct visitor<Fn> : Fn
+{
+    using type = Fn;
+    using Fn::operator();
+
+    visitor(Fn fn) : Fn(fn) {}
+};
+
+template <typename Fn, typename... Fns>
+struct visitor<Fn, Fns...> : Fn, visitor<Fns...>
+{
+    using type = visitor;
+    using Fn::operator();
+    using visitor<Fns...>::operator();
+
+    visitor(Fn fn, Fns... fns) : Fn(fn), visitor<Fns...>(fns...) {}
+};
+
+template <typename... Fns>
+visitor<Fns...> make_visitor(Fns... fns)
+{
+    return visitor<Fns...>(fns...);
+}
+
+} // namespace util
+} // namespace mapbox
+
+#endif // MAPBOX_UTIL_VARIANT_VISITOR_HPP

libs/mason_packages/headers/variant/1.1.4/mason.ini

+name=variant
+version=1.1.4
+header_only=true
+include_dirs={prefix}/include

libs/snake/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/snake/CMakeLists.txt

+cmake_minimum_required(VERSION 3.5)
+
+project(snake LANGUAGES CXX)
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library(snake SHARED
+    snake.h
+    snake_geometry.h
+    snake.cpp
+    snake_geometry.cpp
+)
+
+
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../WGS84toCartesian)
+#add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../../WGS84toCartesian WGS84toCartesian)
+#target_link_libraries(${PROJECT_NAME} WGS84toCartesian)
+
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../mason_packages/headers/geometry/1.0.0/include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../mason_packages/headers/polylabel/1.0.3/include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../mason_packages/headers/variant/1.1.0/include)
+
+
+
+target_compile_definitions(snake PRIVATE SNAKE_LIBRARY)