[core] Include geometry in queryRenderedFeatures results

3 files changed, 87 insertions, 0 deletions

diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp
index 9f57c7ab6f..2e3d0576db 100644
--- a/src/mbgl/tile/geometry_tile.cpp
+++ b/src/mbgl/tile/geometry_tile.cpp
@@ -51,4 +51,85 @@ std::vector<GeometryCollection> classifyRings(const GeometryCollection& rings) {
     return polygons;
 }
 
+static Feature::geometry_type convertGeometry(const GeometryTileFeature& geometryTileFeature, const CanonicalTileID& tileID) {
+    const double size = util::EXTENT * std::pow(2, tileID.z);
+    const double x0 = util::EXTENT * tileID.x;
+    const double y0 = util::EXTENT * tileID.y;
+
+    auto tileCoordinatesToLatLng = [&] (const Point<int16_t>& p) {
+        double y2 = 180 - (p.y + y0) * 360 / size;
+        return Point<double>(
+            (p.x + x0) * 360 / size - 180,
+            360.0 / M_PI * std::atan(std::exp(y2 * M_PI / 180)) - 90.0
+        );
+    };
+
+    GeometryCollection geometries = geometryTileFeature.getGeometries();
+
+    switch (geometryTileFeature.getType()) {
+        case FeatureType::Unknown: {
+            assert(false);
+            return Point<double>(NAN, NAN);
+        }
+
+        case FeatureType::Point: {
+            MultiPoint<double> multiPoint;
+            for (const auto& p : geometries.at(0)) {
+                multiPoint.push_back(tileCoordinatesToLatLng(p));
+            }
+            if (multiPoint.size() == 1) {
+                return multiPoint[0];
+            } else {
+                return multiPoint;
+            }
+        }
+
+        case FeatureType::LineString: {
+            MultiLineString<double> multiLineString;
+            for (const auto& g : geometries) {
+                LineString<double> lineString;
+                for (const auto& p : g) {
+                    lineString.push_back(tileCoordinatesToLatLng(p));
+                }
+                multiLineString.push_back(std::move(lineString));
+            }
+            if (multiLineString.size() == 1) {
+                return multiLineString[0];
+            } else {
+                return multiLineString;
+            }
+        }
+
+        case FeatureType::Polygon: {
+            MultiPolygon<double> multiPolygon;
+            for (const auto& pg : classifyRings(geometries)) {
+                Polygon<double> polygon;
+                for (const auto& r : pg) {
+                    LinearRing<double> linearRing;
+                    for (const auto& p : r) {
+                        linearRing.push_back(tileCoordinatesToLatLng(p));
+                    }
+                    polygon.push_back(std::move(linearRing));
+                }
+                multiPolygon.push_back(std::move(polygon));
+            }
+            if (multiPolygon.size() == 1) {
+                return multiPolygon[0];
+            } else {
+                return multiPolygon;
+            }
+        }
+    }
+
+    // Unreachable, but placate GCC.
+    return Point<double>();
+}
+
+Feature convertFeature(const GeometryTileFeature& geometryTileFeature, const CanonicalTileID& tileID) {
+    Feature feature { convertGeometry(geometryTileFeature, tileID) };
+    feature.properties = geometryTileFeature.getProperties();
+    feature.id = geometryTileFeature.getID();
+    return feature;
+}
+
 } // namespace mbgl
diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp
index edbe91b6c9..d98e1b3b0c 100644
--- a/src/mbgl/tile/geometry_tile.hpp
+++ b/src/mbgl/tile/geometry_tile.hpp
@@ -25,6 +25,8 @@ enum class FeatureType : uint8_t {
     Polygon = 3
 };
 
+class CanonicalTileID;
+
 // Normalized vector tile coordinates.
 // Each geometry coordinate represents a point in a bidimensional space,
 // varying from -V...0...+V, where V is the maximum extent applicable.
@@ -90,6 +92,9 @@ public:
 // classifies an array of rings into polygons with outer rings and holes
 std::vector<GeometryCollection> classifyRings(const GeometryCollection&);
 
+// convert from GeometryTileFeature to Feature (eventually we should eliminate GeometryTileFeature)
+Feature convertFeature(const GeometryTileFeature&, const CanonicalTileID&);
+
 } // namespace mbgl
 
 #endif
diff --git a/src/mbgl/tile/vector_tile_data.cpp b/src/mbgl/tile/vector_tile_data.cpp
index 457ffd4171..10b5bae182 100644
--- a/src/mbgl/tile/vector_tile_data.cpp
+++ b/src/mbgl/tile/vector_tile_data.cpp
@@ -206,6 +206,7 @@ void VectorTileData::queryRenderedFeatures(
                         std::pow(2, transformState.getZoom() - id.overscaledZ),
                         layerIDs,
                         *geometryTile,
+                        id.canonical,
                         style);
 }