[core] Use geometry.hpp types for shape annotations

3 files changed, 86 insertions, 23 deletions

diff --git a/src/mbgl/annotation/shape_annotation_impl.cpp b/src/mbgl/annotation/shape_annotation_impl.cpp
index 76a237bfc2..a96c4eae72 100644
--- a/src/mbgl/annotation/shape_annotation_impl.cpp
+++ b/src/mbgl/annotation/shape_annotation_impl.cpp
@@ -80,33 +80,94 @@ void ShapeAnnotationImpl::updateStyle(Style& style) {
     }
 }
 
-void ShapeAnnotationImpl::updateTile(const CanonicalTileID& tileID, AnnotationTile& tile) {
-    static const double baseTolerance = 4;
+struct ToGeoJSONVT {
+    const double tolerance;
 
-    if (!shapeTiler) {
-        const uint64_t maxAmountOfTiles = 1 << maxZoom;
-        const double tolerance = baseTolerance / (maxAmountOfTiles * util::EXTENT);
+    ToGeoJSONVT(const double tolerance_)
+        : tolerance(tolerance_) {
+    }
 
-        geojsonvt::ProjectedRings rings;
-        for (auto& segment : shape.segments) {
-            std::vector<geojsonvt::LonLat> points;
-            for (auto& latLng : segment) {
-                const double wrappedLongitude = util::wrap(latLng.longitude, -util::LONGITUDE_MAX, util::LONGITUDE_MAX);
-                const double clampedLatitude = util::clamp(latLng.latitude, -util::LATITUDE_MAX, util::LATITUDE_MAX);
-                points.push_back(geojsonvt::LonLat(wrappedLongitude, clampedLatitude));
-            }
+    geojsonvt::ProjectedFeature operator()(const LineString<double>& line) const {
+        geojsonvt::ProjectedRings converted;
+        converted.push_back(convertPoints(geojsonvt::ProjectedFeatureType::Polygon, line));
+        return convertFeature(geojsonvt::ProjectedFeatureType::LineString, converted);
+    }
 
-            if (type == geojsonvt::ProjectedFeatureType::Polygon &&
-                    (points.front().lon != points.back().lon || points.front().lat != points.back().lat)) {
-                points.push_back(geojsonvt::LonLat(points.front().lon, points.front().lat));
+    geojsonvt::ProjectedFeature operator()(const Polygon<double>& polygon) const {
+        geojsonvt::ProjectedRings converted;
+        for (const auto& ring : polygon) {
+            converted.push_back(convertPoints(geojsonvt::ProjectedFeatureType::Polygon, ring));
+        }
+        return convertFeature(geojsonvt::ProjectedFeatureType::Polygon, converted);
+    }
+
+    geojsonvt::ProjectedFeature operator()(const MultiLineString<double>& lines) const {
+        geojsonvt::ProjectedRings converted;
+        for (const auto& line : lines) {
+            converted.push_back(convertPoints(geojsonvt::ProjectedFeatureType::LineString, line));
+        }
+        return convertFeature(geojsonvt::ProjectedFeatureType::LineString, converted);
+    }
+
+    geojsonvt::ProjectedFeature operator()(const MultiPolygon<double>& polygons) const {
+        geojsonvt::ProjectedRings converted;
+        for (const auto& polygon : polygons) {
+            for (const auto& ring : polygon) {
+                converted.push_back(convertPoints(geojsonvt::ProjectedFeatureType::Polygon, ring));
             }
+        }
+        return convertFeature(geojsonvt::ProjectedFeatureType::Polygon, converted);
+    }
+
+    geojsonvt::ProjectedFeature operator()(const Point<double>&) {
+        throw std::runtime_error("unsupported shape annotation geometry type");
+    }
+
+    geojsonvt::ProjectedFeature operator()(const MultiPoint<double>&) {
+        throw std::runtime_error("unsupported shape annotation geometry type");
+    }
+
+    geojsonvt::ProjectedFeature operator()(const mapbox::geometry::geometry_collection<double>&) {
+        throw std::runtime_error("unsupported shape annotation geometry type");
+    }
+
+private:
+    geojsonvt::LonLat convertPoint(const Point<double>& p) const {
+        return {
+            util::wrap(p.x, -util::LONGITUDE_MAX, util::LONGITUDE_MAX),
+            util::clamp(p.y, -util::LATITUDE_MAX, util::LATITUDE_MAX)
+        };
+    }
 
-            auto ring = geojsonvt::Convert::projectRing(points, tolerance);
-            rings.push_back(ring);
+    geojsonvt::ProjectedRing convertPoints(geojsonvt::ProjectedFeatureType type, const std::vector<Point<double>>& points) const {
+        std::vector<geojsonvt::LonLat> converted;
+
+        for (const auto& p : points) {
+            converted.push_back(convertPoint(p));
+        }
+
+        if (type == geojsonvt::ProjectedFeatureType::Polygon && points.front() != points.back()) {
+            converted.push_back(converted.front());
         }
 
-        std::vector<geojsonvt::ProjectedFeature> features;
-        features.push_back(geojsonvt::Convert::create(geojsonvt::Tags(), type, rings));
+        return geojsonvt::Convert::projectRing(converted, tolerance);
+    }
+
+    geojsonvt::ProjectedFeature convertFeature(geojsonvt::ProjectedFeatureType type, const geojsonvt::ProjectedRings& rings) const {
+        return geojsonvt::Convert::create(geojsonvt::Tags(), type, rings);
+    }
+};
+
+void ShapeAnnotationImpl::updateTile(const CanonicalTileID& tileID, AnnotationTile& tile) {
+    static const double baseTolerance = 4;
+
+    if (!shapeTiler) {
+        const uint64_t maxAmountOfTiles = 1 << maxZoom;
+        const double tolerance = baseTolerance / (maxAmountOfTiles * util::EXTENT);
+
+        std::vector<geojsonvt::ProjectedFeature> features = {
+            Geometry<double>::visit(shape.geometry, ToGeoJSONVT(tolerance))
+        };
 
         mapbox::geojsonvt::Options options;
         options.maxZoom = maxZoom;
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index b7b8b584ec..e0a73c2a06 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -481,13 +481,12 @@ void Map::setLatLngZoom(const LatLng& latLng, double zoom, optional<EdgeInsets>
 }
 
 CameraOptions Map::cameraForLatLngBounds(const LatLngBounds& bounds, optional<EdgeInsets> padding) const {
-    AnnotationSegment segment = {
+    return cameraForLatLngs({
         bounds.northwest(),
         bounds.southwest(),
         bounds.southeast(),
         bounds.northeast(),
-    };
-    return cameraForLatLngs(segment, padding);
+    }, padding);
 }
 
 CameraOptions Map::cameraForLatLngs(const std::vector<LatLng>& latLngs, optional<EdgeInsets> padding) const {
diff --git a/src/mbgl/util/geometry.hpp b/src/mbgl/util/geometry.hpp
index f9b91bcb39..6b9c332bf2 100644
--- a/src/mbgl/util/geometry.hpp
+++ b/src/mbgl/util/geometry.hpp
@@ -26,6 +26,9 @@ using MultiPolygon = mapbox::geometry::multi_polygon<T>;
 template <class T>
 using LinearRing = mapbox::geometry::linear_ring<T>;
 
+template <class T>
+using Geometry = mapbox::geometry::geometry<T>;
+
 template <class S, class T>
 Point<S> convertPoint(const Point<T>& p) {
     return Point<S>(p.x, p.y);