[core] Use unwrapped longitude for bounds check

3 files changed, 62 insertions, 44 deletions

diff --git a/src/mbgl/map/transform.cpp b/src/mbgl/map/transform.cpp
index 7d3c9d8b74..8065bc17ce 100644
--- a/src/mbgl/map/transform.cpp
+++ b/src/mbgl/map/transform.cpp
@@ -82,8 +82,10 @@ void Transform::jumpTo(const CameraOptions& camera) {
  * not included in `options`.
  */
 void Transform::easeTo(const CameraOptions& camera, const AnimationOptions& animation) {
-    const LatLng unwrappedLatLng = camera.center.value_or(getLatLng());
-    const LatLng latLng = unwrappedLatLng.wrapped();
+    const EdgeInsets& padding = camera.padding;
+    LatLng startLatLng = getLatLng(padding, LatLng::Unwrapped);
+    const LatLng& unwrappedLatLng = camera.center.value_or(startLatLng);
+    const LatLng& latLng = state.bounds ? unwrappedLatLng : unwrappedLatLng.wrapped();
     double zoom = camera.zoom.value_or(getZoom());
     double angle = camera.angle ? -*camera.angle * util::DEG2RAD : getAngle();
     double pitch = camera.pitch ? *camera.pitch * util::DEG2RAD : getPitch();
@@ -92,17 +94,18 @@ void Transform::easeTo(const CameraOptions& camera, const AnimationOptions& anim
         return;
     }
 
-    // Determine endpoints.
-    EdgeInsets padding = camera.padding;
-    LatLng startLatLng = getLatLng(padding);
-    // If gesture in progress, we transfer the world rounds from the end
-    // longitude into start, so we can guarantee the "scroll effect" of rounding
-    // the world while assuring the end longitude remains wrapped.
-    if (isGestureInProgress()) {
-        startLatLng = LatLng(startLatLng.latitude(), startLatLng.longitude() - (unwrappedLatLng.longitude() - latLng.longitude()));
+    if (!state.bounds) {
+        if (isGestureInProgress()) {
+            // If gesture in progress, we transfer the wrap rounds from the end longitude into
+            // start, so the "scroll effect" of rounding the world is the same while assuring the
+            // end longitude remains wrapped.
+            const double wrap = unwrappedLatLng.longitude() - latLng.longitude();
+            startLatLng = LatLng(startLatLng.latitude(), startLatLng.longitude() - wrap);
+        } else {
+            // Find the shortest path otherwise.
+            startLatLng.unwrapForShortestPath(latLng);
+        }
     }
-    // Find the shortest path otherwise.
-    else startLatLng.unwrapForShortestPath(latLng);
 
     const Point<double> startPoint = Projection::project(startLatLng, state.scale);
     const Point<double> endPoint = Projection::project(latLng, state.scale);
@@ -156,7 +159,8 @@ void Transform::easeTo(const CameraOptions& camera, const AnimationOptions& anim
     Where applicable, local variable documentation begins with the associated
     variable or function in van Wijk (2003). */
 void Transform::flyTo(const CameraOptions &camera, const AnimationOptions &animation) {
-    const LatLng latLng = camera.center.value_or(getLatLng()).wrapped();
+    const EdgeInsets& padding = camera.padding;
+    const LatLng& latLng = camera.center.value_or(getLatLng(padding, LatLng::Unwrapped)).wrapped();
     double zoom = camera.zoom.value_or(getZoom());
     double angle = camera.angle ? -*camera.angle * util::DEG2RAD : getAngle();
     double pitch = camera.pitch ? *camera.pitch * util::DEG2RAD : getPitch();
@@ -166,8 +170,7 @@ void Transform::flyTo(const CameraOptions &camera, const AnimationOptions &anima
     }
 
     // Determine endpoints.
-    EdgeInsets padding = camera.padding;
-    LatLng startLatLng = getLatLng(padding).wrapped();
+    LatLng startLatLng = getLatLng(padding, LatLng::Unwrapped).wrapped();
     startLatLng.unwrapForShortestPath(latLng);
 
     const Point<double> startPoint = Projection::project(startLatLng, state.scale);
@@ -316,9 +319,9 @@ void Transform::moveBy(const ScreenCoordinate& offset, const AnimationOptions& a
     easeTo(CameraOptions().withCenter(state.screenCoordinateToLatLng(centerPoint)), animation);
 }
 
-LatLng Transform::getLatLng(const EdgeInsets& padding) const {
+LatLng Transform::getLatLng(const EdgeInsets& padding, LatLng::WrapMode wrap) const {
     if (padding.isFlush()) {
-        return state.getLatLng();
+        return state.getLatLng(wrap);
     } else {
         return screenCoordinateToLatLng(padding.getCenter(state.size.width, state.size.height));
     }
diff --git a/src/mbgl/map/transform.hpp b/src/mbgl/map/transform.hpp
index e872ed444b..da62a3f04e 100644
--- a/src/mbgl/map/transform.hpp
+++ b/src/mbgl/map/transform.hpp
@@ -46,7 +46,7 @@ public:
         @param offset The distance to pan the map by, measured in pixels from
             top to bottom and from left to right. */
     void moveBy(const ScreenCoordinate& offset, const AnimationOptions& = {});
-    LatLng getLatLng(const EdgeInsets& = {}) const;
+    LatLng getLatLng(const EdgeInsets& = {}, LatLng::WrapMode = LatLng::Wrapped) const;
     ScreenCoordinate getScreenCoordinate(const EdgeInsets& = {}) const;
 
     // Bounds
diff --git a/src/mbgl/util/geo.cpp b/src/mbgl/util/geo.cpp
index a04e2c5355..19510e2039 100644
--- a/src/mbgl/util/geo.cpp
+++ b/src/mbgl/util/geo.cpp
@@ -39,35 +39,12 @@ bool LatLngBounds::contains(const CanonicalTileID& tileID) const {
 }
 
 bool LatLngBounds::contains(const LatLng& point, LatLng::WrapMode wrap /*= LatLng::Unwrapped*/) const {
-    bool containsLatitude = point.latitude() >= sw.latitude() &&
-                            point.latitude() <= ne.latitude();
-    if (!containsLatitude) {
-        return false;
-    }
-
-    bool containsUnwrappedLongitude = point.longitude() >= sw.longitude() &&
-                                      point.longitude() <= ne.longitude();
-    if (containsUnwrappedLongitude) {
-        return true;
-    } else if (wrap == LatLng::Wrapped) {
-        LatLngBounds wrapped(sw.wrapped(), ne.wrapped());
-        auto ptLon = point.wrapped().longitude();
-        if (crossesAntimeridian()) {
-            return (ptLon >= wrapped.sw.longitude() &&
-                    ptLon <= util::LONGITUDE_MAX) ||
-                   (ptLon <= wrapped.ne.longitude() &&
-                    ptLon >= -util::LONGITUDE_MAX);
-        } else {
-            return (ptLon >= wrapped.sw.longitude() &&
-                    ptLon <= wrapped.ne.longitude());
-        }
-    }
-    return false;
+    return containsLatitude(point.latitude()) && containsLongitude(point.longitude(), wrap);
 }
 
 bool LatLngBounds::contains(const LatLngBounds& area, LatLng::WrapMode wrap /*= LatLng::Unwrapped*/) const {
-    bool containsLatitude = area.north() <= north() && area.south() >= south();
-    if (!containsLatitude) {
+    bool containsAreaLatitude = area.north() <= north() && area.south() >= south();
+    if (!containsAreaLatitude) {
         return false;
     }
 
@@ -114,6 +91,44 @@ bool LatLngBounds::intersects(const LatLngBounds area, LatLng::WrapMode wrap /*=
     return false;
 }
 
+LatLng LatLngBounds::constrain(const LatLng& p) const {
+    double lat = p.latitude();
+    double lng = p.longitude();
+
+    if (!containsLatitude(lat)) {
+        lat = util::clamp(lat, south(), north());
+    }
+
+    if (!containsLongitude(lng, LatLng::Unwrapped)) {
+        lng = util::clamp(lng, west(), east());
+    }
+
+    return LatLng { lat, lng };
+}
+
+bool LatLngBounds::containsLatitude(double latitude) const {
+    return latitude >= south() && latitude <= north();
+}
+
+bool LatLngBounds::containsLongitude(double longitude, LatLng::WrapMode wrap) const {
+    if (longitude >= west() && longitude <= east()) {
+        return true;
+    }
+
+    if (wrap == LatLng::Wrapped) {
+        LatLngBounds wrapped(sw.wrapped(), ne.wrapped());
+        longitude = LatLng(0.0, longitude).wrapped().longitude();
+        if (crossesAntimeridian()) {
+            return (longitude >= -util::LONGITUDE_MAX && longitude <= wrapped.east()) ||
+                   (longitude >= wrapped.west() && longitude <= util::LONGITUDE_MAX);
+        }
+
+        return longitude >= wrapped.west() && longitude <= wrapped.east();
+    }
+
+    return false;
+}
+
 ScreenCoordinate EdgeInsets::getCenter(uint16_t width, uint16_t height) const {
     return {
         (width - left() - right()) / 2.0 + left(),