From 2f1c39b1def05a66f1d2d068ded5e0972aee260b Mon Sep 17 00:00:00 2001
From: Asheem Mamoowala <asheem.mamoowala@mapbox.com>
Date: Tue, 3 Oct 2017 15:29:31 -0700
Subject: [core] Use `Geometry<T>` as input to `cameraForGeometry()` with
 optional angle

---
 include/mbgl/map/map.hpp       |  8 ++++----
 include/mbgl/util/geometry.hpp |  6 ++++++
 src/mbgl/map/map.cpp           | 32 +++++++++++++++++++++-----------
 test/map/map.test.cpp          | 16 +++++++++++++++-
 4 files changed, 46 insertions(+), 16 deletions(-)

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index 3e1f090665..c5f90d99e1 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -8,6 +8,7 @@
 #include <mbgl/util/size.hpp>
 #include <mbgl/annotation/annotation.hpp>
 #include <mbgl/map/camera.hpp>
+#include <mbgl/util/geometry.hpp>
 
 #include <cstdint>
 #include <string>
@@ -66,10 +67,9 @@ public:
     void jumpTo(const CameraOptions&);
     void easeTo(const CameraOptions&, const AnimationOptions&);
     void flyTo(const CameraOptions&, const AnimationOptions&);
-    CameraOptions cameraForLatLngBounds(const LatLngBounds&, const EdgeInsets&) const;
-    CameraOptions cameraForLatLngs(const std::vector<LatLng>&, const EdgeInsets&) const;
-    CameraOptions cameraForLatLngs(const std::vector<LatLng>&, double heading, const EdgeInsets&) const;
-
+    CameraOptions cameraForLatLngBounds(const LatLngBounds&, const EdgeInsets&, optional<double> bearing = {}) const;
+    CameraOptions cameraForLatLngs(const std::vector<LatLng>&, const EdgeInsets&, optional<double> bearing = {}) const;
+    CameraOptions cameraForGeometry(const Geometry<double>&, const EdgeInsets&, optional<double> bearing = {}) const;
     LatLngBounds latLngBoundsForCamera(const CameraOptions&) const;
 
     // Position
diff --git a/include/mbgl/util/geometry.hpp b/include/mbgl/util/geometry.hpp
index 6dc16bc514..a28c59a47d 100644
--- a/include/mbgl/util/geometry.hpp
+++ b/include/mbgl/util/geometry.hpp
@@ -2,6 +2,7 @@
 
 #include <mapbox/geometry/geometry.hpp>
 #include <mapbox/geometry/point_arithmetic.hpp>
+#include <mapbox/geometry/for_each_point.hpp>
 
 namespace mbgl {
 
@@ -58,4 +59,9 @@ struct ToFeatureType {
     FeatureType operator()(const mapbox::geometry::geometry_collection<T> &) const { return FeatureType::Unknown; }
 };
 
+template <class T, typename F>
+auto forEachPoint(const Geometry<T>& g, F f) {
+    mapbox::geometry::for_each_point(g, f);
+}
+
 } // namespace mbgl
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index 76ef4bc69f..6eb555ad1e 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -364,13 +364,13 @@ void Map::setLatLngZoom(const LatLng& latLng, double zoom, const EdgeInsets& pad
     impl->onUpdate();
 }
 
-CameraOptions Map::cameraForLatLngBounds(const LatLngBounds& bounds, const EdgeInsets& padding) const {
+CameraOptions Map::cameraForLatLngBounds(const LatLngBounds& bounds, const EdgeInsets& padding, optional<double> bearing) const {
     return cameraForLatLngs({
         bounds.northwest(),
         bounds.southwest(),
         bounds.southeast(),
         bounds.northeast(),
-    }, padding);
+    }, padding, bearing);
 }
 
 CameraOptions cameraForLatLngs(const std::vector<LatLng>& latLngs, const Transform& transform, const EdgeInsets& padding) {
@@ -426,17 +426,27 @@ CameraOptions cameraForLatLngs(const std::vector<LatLng>& latLngs, const Transfo
     return options;
 }
 
-CameraOptions Map::cameraForLatLngs(const std::vector<LatLng>& latLngs, const EdgeInsets& padding) const {
-    return mbgl::cameraForLatLngs(latLngs, impl->transform, padding);
+CameraOptions Map::cameraForLatLngs(const std::vector<LatLng>& latLngs, const EdgeInsets& padding, optional<double> bearing) const {
+    if(bearing) {
+        double angle = -*bearing * util::DEG2RAD;  // Convert to radians
+        Transform transform(impl->transform.getState());
+        transform.setAngle(angle);
+        CameraOptions options = mbgl::cameraForLatLngs(latLngs, transform, padding);
+        options.angle = angle;
+        return options;
+    } else {
+        return mbgl::cameraForLatLngs(latLngs, impl->transform, padding);
+    }
 }
 
-CameraOptions Map::cameraForLatLngs(const std::vector<LatLng>& latLngs, double heading, const EdgeInsets& padding) const {
-    double angle = -heading * util::DEG2RAD;
-    Transform transform(impl->transform.getState());
-    transform.setAngle(angle);
-    CameraOptions options = mbgl::cameraForLatLngs(latLngs, transform, padding);
-    options.angle = angle;
-    return options;
+CameraOptions Map::cameraForGeometry(const Geometry<double>& geometry, const EdgeInsets& padding, optional<double> bearing) const {
+
+    std::vector<LatLng> latLngs;
+    forEachPoint(geometry, [&](const Point<double>& pt) {
+        latLngs.push_back({ pt.y, pt.x });
+    });
+    return cameraForLatLngs(latLngs, padding, bearing);
+
 }
 
 LatLngBounds Map::latLngBoundsForCamera(const CameraOptions& camera) const {
diff --git a/test/map/map.test.cpp b/test/map/map.test.cpp
index a86711925a..9358175297 100644
--- a/test/map/map.test.cpp
+++ b/test/map/map.test.cpp
@@ -109,6 +109,20 @@ TEST(Map, LatLngBoundsToCamera) {
 
     CameraOptions virtualCamera = test.map.cameraForLatLngBounds(bounds, {});
     ASSERT_TRUE(bounds.contains(*virtualCamera.center));
+    EXPECT_NEAR(*virtualCamera.zoom, 1.55467, 1e-5);
+}
+
+TEST(Map, LatLngBoundsToCameraWithAngle) {
+    MapTest<> test;
+
+    test.map.setLatLngZoom({ 40.712730, -74.005953 }, 16.0);
+
+    LatLngBounds bounds = LatLngBounds::hull({15.68169,73.499857}, {53.560711, 134.77281});
+
+    CameraOptions virtualCamera = test.map.cameraForLatLngBounds(bounds, {}, 35);
+    ASSERT_TRUE(bounds.contains(*virtualCamera.center));
+    EXPECT_NEAR(*virtualCamera.zoom, 1.21385, 1e-5);
+    EXPECT_DOUBLE_EQ(virtualCamera.angle.value_or(0), -35 * util::DEG2RAD);
 }
 
 TEST(Map, LatLngsToCamera) {
@@ -116,7 +130,7 @@ TEST(Map, LatLngsToCamera) {
 
     std::vector<LatLng> latLngs{{ 40.712730, 74.005953 }, {15.68169,73.499857}, {30.82678, 83.4082}};
 
-    CameraOptions virtualCamera = test.map.cameraForLatLngs(latLngs, 23, {});
+    CameraOptions virtualCamera = test.map.cameraForLatLngs(latLngs, {}, 23);
     EXPECT_DOUBLE_EQ(virtualCamera.angle.value_or(0), -23 * util::DEG2RAD);
     EXPECT_NEAR(virtualCamera.zoom.value_or(0), 2.75434, 1e-5);
     EXPECT_NEAR(virtualCamera.center->latitude(), 28.49288, 1e-5);
-- 
cgit v1.2.1