[core] Rewrite TileCoordinate in terms of geometry.hpp point

3 files changed, 39 insertions, 69 deletions

diff --git a/src/mbgl/map/transform.cpp b/src/mbgl/map/transform.cpp
index 958f9d9b63..4a40e13202 100644
--- a/src/mbgl/map/transform.cpp
+++ b/src/mbgl/map/transform.cpp
@@ -109,14 +109,9 @@ void Transform::easeTo(const CameraOptions& camera, const AnimationOptions& anim
     // Find the shortest path otherwise.
     else startLatLng.unwrapForShortestPath(latLng);
 
-    const ScreenCoordinate startPoint = {
-        state.lngX(startLatLng.longitude),
-        state.latY(startLatLng.latitude),
-    };
-    const ScreenCoordinate endPoint = {
-        state.lngX(latLng.longitude),
-        state.latY(latLng.latitude),
-    };
+    const Point<double> startPoint = state.project(startLatLng);
+    const Point<double> endPoint = state.project(latLng);
+
     ScreenCoordinate center = getScreenCoordinate(padding);
     center.y = state.height - center.y;
     
@@ -145,11 +140,8 @@ void Transform::easeTo(const CameraOptions& camera, const AnimationOptions& anim
     state.rotating = angle != startAngle;
 
     startTransition(camera, animation, [=](double t) {
-        ScreenCoordinate framePoint = util::interpolate(startPoint, endPoint, t);
-        LatLng frameLatLng = {
-            state.yLat(framePoint.y, startWorldSize),
-            state.xLng(framePoint.x, startWorldSize)
-        };
+        Point<double> framePoint = util::interpolate(startPoint, endPoint, t);
+        LatLng frameLatLng = state.unproject(framePoint, startWorldSize);
         double frameScale = util::interpolate(startScale, scale, t);
         state.setLatLngZoom(frameLatLng, state.scaleZoom(frameScale));
         
@@ -191,14 +183,9 @@ void Transform::flyTo(const CameraOptions &camera, const AnimationOptions &anima
     LatLng startLatLng = getLatLng(padding).wrapped();
     startLatLng.unwrapForShortestPath(latLng);
 
-    const ScreenCoordinate startPoint = {
-        state.lngX(startLatLng.longitude),
-        state.latY(startLatLng.latitude),
-    };
-    const ScreenCoordinate endPoint = {
-        state.lngX(latLng.longitude),
-        state.latY(latLng.latitude),
-    };
+    const Point<double> startPoint = state.project(startLatLng);
+    const Point<double> endPoint = state.project(latLng);
+
     ScreenCoordinate center = getScreenCoordinate(padding);
     center.y = state.height - center.y;
     
@@ -316,14 +303,11 @@ void Transform::flyTo(const CameraOptions &camera, const AnimationOptions &anima
         double us = u(s);
         
         // Calculate the current point and zoom level along the flight path.
-        ScreenCoordinate framePoint = util::interpolate(startPoint, endPoint, us);
+        Point<double> framePoint = util::interpolate(startPoint, endPoint, us);
         double frameZoom = startZoom + state.scaleZoom(1 / w(s));
         
         // Convert to geographic coordinates and set the new viewpoint.
-        LatLng frameLatLng = {
-            state.yLat(framePoint.y, startWorldSize),
-            state.xLng(framePoint.x, startWorldSize),
-        };
+        LatLng frameLatLng = state.unproject(framePoint, startWorldSize);
         state.setLatLngZoom(frameLatLng, frameZoom);
         
         if (angle != startAngle) {
diff --git a/src/mbgl/map/transform_state.cpp b/src/mbgl/map/transform_state.cpp
index 0b8d831e54..ad41c9eea2 100644
--- a/src/mbgl/map/transform_state.cpp
+++ b/src/mbgl/map/transform_state.cpp
@@ -201,22 +201,20 @@ bool TransformState::isGestureInProgress() const {
 
 #pragma mark - Projection
 
-double TransformState::lngX(double lng) const {
-    return (util::LONGITUDE_MAX + lng) * worldSize() / util::DEGREES_MAX;
-}
-
-double TransformState::latY(double lat) const {
-    double y_ = util::RAD2DEG * std::log(std::tan(M_PI / 4 + lat * M_PI / util::DEGREES_MAX));
-    return (util::LONGITUDE_MAX - y_) * worldSize() / util::DEGREES_MAX;
-}
-
-double TransformState::xLng(double x_, double worldSize_) const {
-    return x_ * util::DEGREES_MAX / worldSize_ - util::LONGITUDE_MAX;
-}
-
-double TransformState::yLat(double y_, double worldSize_) const {
-    double y2 = util::LONGITUDE_MAX - y_ * util::DEGREES_MAX / worldSize_;
-    return util::DEGREES_MAX / M_PI * std::atan(std::exp(y2 * util::DEG2RAD)) - 90.0f;
+Point<double> TransformState::project(const LatLng& ll) const {
+    return Point<double>(
+        (util::LONGITUDE_MAX + ll.longitude),
+        (util::LONGITUDE_MAX - util::RAD2DEG * std::log(std::tan(M_PI / 4 + ll.latitude * M_PI / util::DEGREES_MAX)))
+    ) * worldSize() / util::DEGREES_MAX;
+}
+
+LatLng TransformState::unproject(const Point<double>& p, double worldSize, LatLng::WrapMode wrapMode) const {
+    Point<double> p2 = p * util::DEGREES_MAX / worldSize;
+    return LatLng(
+        util::DEGREES_MAX / M_PI * std::atan(std::exp((util::LONGITUDE_MAX - p2.y) * util::DEG2RAD)) - 90.0f,
+        p2.x - util::LONGITUDE_MAX,
+        wrapMode
+    );
 }
 
 double TransformState::zoomScale(double zoom) const {
@@ -234,7 +232,8 @@ double TransformState::worldSize() const {
 ScreenCoordinate TransformState::latLngToScreenCoordinate(const LatLng& latLng) const {
     mat4 mat = coordinatePointMatrix(getZoom());
     vec4 p;
-    vec4 c = {{ lngX(latLng.longitude) / util::tileSize, latY(latLng.latitude) / util::tileSize, 0, 1 }};
+    Point<double> pt = project(latLng) / double(util::tileSize);
+    vec4 c = {{ pt.x, pt.y, 0, 1 }};
     matrix::transformMat4(p, c, mat);
     return { p[0] / p[3], height - p[1] / p[3] };
 }
@@ -263,19 +262,15 @@ LatLng TransformState::screenCoordinateToLatLng(const ScreenCoordinate& point, L
 
     double w0 = coord0[3];
     double w1 = coord1[3];
-    double x0 = coord0[0] / w0;
-    double x1 = coord1[0] / w1;
-    double y0 = coord0[1] / w0;
-    double y1 = coord1[1] / w1;
+
+    Point<double> p0 = Point<double>(coord0[0], coord0[1]) / w0;
+    Point<double> p1 = Point<double>(coord1[0], coord1[1]) / w1;
+
     double z0 = coord0[2] / w0;
     double z1 = coord1[2] / w1;
-
     double t = z0 == z1 ? 0 : (targetZ - z0) / (z1 - z0);
-    return {
-        yLat(util::interpolate(y0, y1, t), scale),
-        xLng(util::interpolate(x0, x1, t), scale),
-        wrapMode
-    };
+
+    return unproject(util::interpolate(p0, p1, t), scale, wrapMode);
 }
 
 mat4 TransformState::coordinatePointMatrix(double z) const {
@@ -322,18 +317,10 @@ void TransformState::constrain(double& scale_, double& x_, double& y_) const {
 }
 
 void TransformState::moveLatLng(const LatLng& latLng, const ScreenCoordinate& anchor) {
-    auto latLngToTileCoord = [&](const LatLng& ll) -> Point<double> {
-        return { lngX(ll.longitude), latY(ll.latitude) };
-    };
-
-    auto tileCoordToLatLng = [&](const Point<double> coord) -> LatLng {
-        return { yLat(coord.y, worldSize()), xLng(coord.x, worldSize()) };
-    };
-
-    auto centerCoord = latLngToTileCoord(getLatLng(LatLng::Unwrapped));
-    auto latLngCoord = latLngToTileCoord(latLng);
-    auto anchorCoord = latLngToTileCoord(screenCoordinateToLatLng(anchor));
-    setLatLngZoom(tileCoordToLatLng(centerCoord + latLngCoord - anchorCoord), getZoom());
+    auto centerCoord = project(getLatLng(LatLng::Unwrapped));
+    auto latLngCoord = project(latLng);
+    auto anchorCoord = project(screenCoordinateToLatLng(anchor));
+    setLatLngZoom(unproject(centerCoord + latLngCoord - anchorCoord, worldSize()), getZoom());
 }
 
 void TransformState::setLatLngZoom(const LatLng &latLng, double zoom) {
diff --git a/src/mbgl/map/transform_state.hpp b/src/mbgl/map/transform_state.hpp
index 970dda2613..438094a4c5 100644
--- a/src/mbgl/map/transform_state.hpp
+++ b/src/mbgl/map/transform_state.hpp
@@ -3,6 +3,7 @@
 
 #include <mbgl/map/mode.hpp>
 #include <mbgl/util/geo.hpp>
+#include <mbgl/util/geometry.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/mat4.hpp>
 
@@ -69,10 +70,8 @@ public:
     ScreenCoordinate latLngToScreenCoordinate(const LatLng&) const;
     LatLng screenCoordinateToLatLng(const ScreenCoordinate&, LatLng::WrapMode = LatLng::Unwrapped) const;
 
-    double xLng(double x, double worldSize) const;
-    double yLat(double y, double worldSize) const;
-    double lngX(double lon) const;
-    double latY(double lat) const;
+    Point<double> project(const LatLng&) const;
+    LatLng unproject(const Point<double>&, double worldSize, LatLng::WrapMode = LatLng::Unwrapped) const;
 
 private:
     bool rotatedNorth() const;