获取 Google Static Maps API 的 SW 和 NE 角答案

【问题标题】：Get SW & NE corners of Google Static Maps API获取 Google Static Maps API 的 SW 和 NE 角
【发布时间】：2016-08-28 17:29:57
【问题描述】：

我在 Unity 应用程序中获取 Google 静态地图的边界时遇到问题。我已经尝试了在 stackoverflow 上找到的多个答案。

.NET related question

Javascript related question

我要计算角的地图是this 一个。

首先，我尝试将 marcelo 他的代码从 javascript 转换为 C#。翻译成下面的类。

using System;
using UnityEngine;
public class MercatorProjection
{
    static double MERCATOR_RANGE = 256;
    Point pixelsOrigin;
    double pixelsPerLonDegree;
    double pixelsPerLonRadian;

    public MercatorProjection()
    {
        pixelsOrigin = new Point(MERCATOR_RANGE / 2, MERCATOR_RANGE / 2);
        pixelsPerLonDegree = MERCATOR_RANGE / 360;
        pixelsPerLonRadian = MERCATOR_RANGE / (2 * Math.PI);
    }

    double bound(double value, double opt_min, double opt_max)
    {
        if (opt_min != 0)
            value = Math.Max(value, opt_min);
        if (opt_max != 0)
            value = Math.Min(value, opt_max);
        return value;
    }

    double degreesToRadians(double deg)
    {
        return deg * (Math.PI / 180);
    }

    double radiansToDegrees(double rad)
    {
        return rad / (Math.PI / 180);
    }

    Point fromLatLonToPoint(Coordinates latLon)
    {
        Point point = new Point();
        Point origin = pixelsOrigin;

        point.X = origin.X + latLon.Longitude * pixelsPerLonDegree;

        double sinY = bound(Math.Sin(degreesToRadians(latLon.Latitude)), -0.9999, 0.9999);

        point.Y = origin.Y + 0.5 * Math.Log((1 + sinY) / (1 - sinY)) * -pixelsPerLonRadian;

        return point;
    }

    Coordinates fromPointToLatlon(Point point)
    {
        Point origin = pixelsOrigin;
        Coordinates latLon = new Coordinates();

        latLon.Latitude = (point.X - origin.X) / pixelsPerLonDegree;
        double latRadians = (point.Y - origin.Y) / -pixelsPerLonRadian;
        latLon.Longitude = radiansToDegrees(2 * Math.Atan(Math.Exp(latRadians)) - Math.PI / 2);

        return latLon;
    }

    public void GetCorners(Coordinates center, float zoom, float mapWidth, float mapHeight)
    {
        double scale = Math.Pow(2, zoom);
        Point centerPx = fromLatLonToPoint(center);
        Point SWPoint = new Point(centerPx.X - (mapWidth / 2) / scale, centerPx.Y + (mapHeight / 2) / scale);
        Coordinates SWLatLon = fromPointToLatlon(SWPoint);
        Debug.Log(SWLatLon.Latitude + " " + SWLatLon.Longitude + " " + SWPoint.X + " " + SWPoint.Y);
    }
}

所以起初我尝试只获取地图的西南角，它非常接近，但有点偏离。

MercatorProjection.GetCorners(new Coordinates(Coordinates.Longitude, Coordinates.Latitude), 16, 640, 640);

给我带来了this 结果。

由于有这么多人投票，首先我尝试将marcelo 他的答案翻译过来，我想我在将代码翻译成 C# 的过程中做错了。

我偶然发现了peterjb's answer，他已经将 javascript 答案翻译成 C#，甚至还举了一些例子，说明他的代码获得了 Google 静态地图的正确边界。所以在下面的类中尝试peterjb的代码后；

using System;

public static class GoogleMapsAPI{

    static GoogleMapsAPI()
    {
        OriginX = TileSize / 2;
        OriginY = TileSize / 2;
        PixelsPerLonDegree = TileSize / 360.0;
        PixelsPerLonRadian = TileSize / (2 * Math.PI);
    }

    public static int TileSize = 256;
    public static double OriginX, OriginY;
    public static double PixelsPerLonDegree;
    public static double PixelsPerLonRadian;

    public static double DegreesToRadians(double deg)
    {
        return deg * Math.PI / 180.0;
    }

    public static double RadiansToDegrees(double rads)
    {
        return rads * 180.0 / Math.PI;
    }

    public static double Bound(double value, double min, double max)
    {
        value = Math.Min(value, max);
        return Math.Max(value, min);
    }

    //From Lat, Lon to World Coordinate X, Y. I'm being explicit in assigning to
    //X and Y properties.
    public static Coordinate Mercator(double latitude, double longitude)
    {
        double siny = Bound(Math.Sin(DegreesToRadians(latitude)), -.9999, .9999);

        Coordinate c = new Coordinate(0, 0);
        c.X = OriginX + longitude * PixelsPerLonDegree;
        c.Y = OriginY + .5 * Math.Log((1 + siny) / (1 - siny)) * -PixelsPerLonRadian;

        return c;
    }

    //From World Coordinate X, Y to Lat, Lon. I'm being explicit in assigning to
    //Latitude and Longitude properties.
    public static Coordinate InverseMercator(double x, double y)
    {
        Coordinate c = new Coordinate(0, 0);

        c.Longitude = (x - OriginX) / PixelsPerLonDegree;
        double latRadians = (y - OriginY) / -PixelsPerLonRadian;
        c.Latitude = RadiansToDegrees(Math.Atan(Math.Sinh(latRadians)));

        return c;
    }

    public static MapCoordinates GetBounds(Coordinate center, int zoom, int mapWidth, int mapHeight)
    {
        var scale = Math.Pow(2, zoom);

        var centerWorld = Mercator(center.Latitude, center.Longitude);
        var centerPixel = new Coordinate(0, 0);
        centerPixel.X = centerWorld.X * scale;
        centerPixel.Y = centerWorld.Y * scale;

        var NEPixel = new Coordinate(0, 0);
        NEPixel.X = centerPixel.X + mapWidth / 2.0;
        NEPixel.Y = centerPixel.Y - mapHeight / 2.0;

        var SWPixel = new Coordinate(0, 0);
        SWPixel.X = centerPixel.X - mapWidth / 2.0;
        SWPixel.Y = centerPixel.Y + mapHeight / 2.0;

        var NEWorld = new Coordinate(0, 0);
        NEWorld.X = NEPixel.X / scale;
        NEWorld.Y = NEPixel.Y / scale;

        var SWWorld = new Coordinate(0, 0);
        SWWorld.X = SWPixel.X / scale;
        SWWorld.Y = SWPixel.Y / scale;

        var NELatLon = InverseMercator(NEWorld.X, NEWorld.Y);
        var SWLatLon = InverseMercator(SWWorld.X, SWWorld.Y);

        return new MapCoordinates() { NorthEast = NELatLon, SouthWest = SWLatLon };
    }
}
public class MapCoordinates
{
    public Coordinate SouthWest { get; set; }
    public Coordinate NorthEast { get; set; }
}

public class Coordinate
{
    public double Latitude { get; set; }
    public double Longitude { get; set; }

    public double Y { get { return Latitude; } set { Latitude = value; } }
    public double X { get { return Longitude; } set { Longitude = value; } }

    public Coordinate(double lng, double lat)
    {
        Latitude = lat;
        Longitude = lng;
    }

    public override string ToString()
    {
        return Math.Round(X, 6).ToString() + ", " + Math.Round(Y, 6).ToString();
    }
}

我尝试通过调用以下命令再次计算 SW 和 NE 角

Coordinates = new Coordinate(51.445691, 5.460318);
var result = GoogleMapsAPI.GetBounds(Coordinates, 16, 640, 640);
Debug.Log("SouthWest: "+result.SouthWest.ToString() + " NorthEast: "+result.NorthEast.ToString());

输出：

西南：51.438825、5.453483 东北：51.452557、5.467153

西南坐标与我自己的 javascript 翻译完全相同。因此，由于 peterjb 在他的回答中声称他的解决方案适用于比利时的某个地区，所以我在同一地区尝试了代码。但是，结果又是差了很多。

因此，我非常随机地尝试对名为 Kano / Static map 的尼日利亚城镇进行计算，令我惊讶的是，西南角非常准确！

输出：

西南：12.015251、8.527824 东北：12.028983、8.541404

SouthWest position.

之后，我尝试了世界上其他多个地区，但通常距离很远，有时甚至有数百英里。所以也许尼日利亚的这个小镇只是一个巧合，但我希望有人能给我一个解释和/或解决方案。

特别感谢peterjb 和marcelo

【问题讨论】：

相关信息：alastaira.wordpress.com/2011/01/23/…
您好 Leniaal，我认为问题在于您的坐标构造函数将参数作为 lng，lat，但您传入的是 lat，lng。 Kano 示例可能很接近，因为 lat 和 lng 几乎相同。我希望这会有所帮助，如果还没有，请告诉我。
嘿@peterjb 感谢您的时间和兴趣。你是对的，我不敢相信我忽略了这一点。我很高兴你注意到了它，因为我对这个问题视而不见，非常感谢！如果您愿意，可以将其添加为答案，以便我将此问题标记为已回答。
没问题，很高兴能帮上忙。我以前肯定有过类似的经历:)

标签： javascript c# android google-maps google-static-maps

【解决方案1】：

Coordinate 类的构造函数接受 (lng, lat) 而不是 (lat, lng) 如您所料，因此参数的顺序与您传入的顺序不同。

我还注意到 Coordinate 的 ToString 覆盖也打印为 (lng, lat)，因此如果您希望看到 (lat, lng) 可能会造成混淆。

只需在静态 API 中交换这两者。

【讨论】：