将经纬度点转换为在Mercator投影上的像素坐标(x,y)

Question

我正试图将一个经纬度点转换成二维点，以便我可以在世界地图的图片上显示它（这是一种墨卡托投影）。

我看过一些不同的方法和一些stackoverflow上的问题。我尝试了不同的代码段，虽然我得到了正确的经度像素，但是纬度总是偏差较大，不过似乎越来越合理了。

我需要公式考虑到图片大小、宽度等因素。

我已经尝试过这段代码：

double minLat = -85.05112878;
double minLong = -180;
double maxLat = 85.05112878;
double maxLong = 180;

// Map image size (in points)
double mapHeight = 768.0;
double mapWidth = 991.0;

// Determine the map scale (points per degree)
double xScale = mapWidth/ (maxLong - minLong);
double yScale = mapHeight / (maxLat - minLat);

// position of map image for point
double x = (lon - minLong) * xScale;
double y = - (lat + minLat) * yScale;

System.out.println("final coords: " + x + " " + y);

在我尝试的示例中，纬度似乎偏移了约30像素。有任何帮助或建议吗？

更新

基于这个问题：Lat/lon to xy

我已经尝试使用提供的代码，但仍然在纬度转换方面遇到一些问题，而经度则没有问题。

int mapWidth = 991;
int mapHeight = 768;

double mapLonLeft = -180;
double mapLonRight = 180;
double mapLonDelta = mapLonRight - mapLonLeft;

double mapLatBottom = -85.05112878;
double mapLatBottomDegree = mapLatBottom * Math.PI / 180;
double worldMapWidth = ((mapWidth / mapLonDelta) * 360) / (2 * Math.PI);
double mapOffsetY = (worldMapWidth / 2 * Math.log((1 + Math.sin(mapLatBottomDegree)) / (1 - Math.sin(mapLatBottomDegree))));

double x = (lon - mapLonLeft) * (mapWidth / mapLonDelta);
double y = 0.1;
if (lat < 0) {
    lat = lat * Math.PI / 180;
    y = mapHeight - ((worldMapWidth / 2 * Math.log((1 + Math.sin(lat)) / (1 - Math.sin(lat)))) - mapOffsetY);
} else if (lat > 0) {
    lat = lat * Math.PI / 180;
    lat = lat * -1;
    y = mapHeight - ((worldMapWidth / 2 * Math.log((1 + Math.sin(lat)) / (1 - Math.sin(lat)))) - mapOffsetY);
    System.out.println("y before minus: " + y);
    y = mapHeight - y;
} else {
    y = mapHeight / 2;
}
System.out.println(x);
System.out.println(y);

使用原始代码时，如果纬度值为正，则会返回负点，因此我稍微修改了一下并与极端纬度进行了测试-应该是点0和点766，它可以正常工作。但是，当我尝试不同的纬度值，例如：58.07（英国以北），它显示为西班牙以北。

- drunkmonkey

---

你的公式只是线性插值，实际上这意味着你正在进行等面积投影而不是墨卡托投影。 - Drew Hall

我已经更新了代码，但是纬度仍然存在问题。 - drunkmonkey

正如@Drew所提到的，如果您的地图是Marcator投影，则需要使用Mercator投影将纬度/经度转换为x/y。检查您的地图是否为横向墨卡托投影或球形墨卡托投影，然后我们将得到公式... - Michael

这是一个球形墨卡托投影。 - drunkmonkey

Answer 1

墨卡托投影是兰伯特圆锥等积投影的一种特殊极限情况，以赤道作为唯一的标准平行线。所有其他纬线都是直线，经线也是直线，与赤道成直角并等间距分布。它是该投影的横向和斜向形式的基础。虽然在地图制图方面很少使用，但它几乎普遍用于导航图表中。除了具有等积性外，它还具有直线保角性质。因此，航海家可以从直线航线与经线形成的角度推导出其航向。^[1.]

从球面纬度φ和经度λ推导出投影东坐标和北坐标的公式为：

E = FE + R (λ – λₒ)
N = FN + R ln[tan(π/4 + φ/2)]   

其中λ_O表示自然原点的经度，FE和FN表示东移和北移偏移量。在球形墨卡托投影中，实际上并不使用这些值，因此您可以将公式简化为：

这是伪代码示例，因此可以适用于任何编程语言。

latitude    = 41.145556; // (φ)
longitude   = -73.995;   // (λ)

mapWidth    = 200;
mapHeight   = 100;

// get x value
x = (longitude+180)*(mapWidth/360)

// convert from degrees to radians
latRad = latitude*PI/180;

// get y value
mercN = ln(tan((PI/4)+(latRad/2)));
y     = (mapHeight/2)-(mapWidth*mercN/(2*PI));

来源：

1. OGP地理信息委员会，指南编号7，第2部分：坐标转换和转换
2. 墨卡托投影的推导
3. 国家地图集：地图投影
4. 墨卡托地图投影

编辑： 在PHP中创建了一个可行的示例（因为我很菜）

https://github.com/mfeldheim/mapStuff.git

编辑2

漂亮的墨卡托投影动画https://amp-reddit-com.cdn.ampproject.org/v/s/amp.reddit.com/r/educationalgifs/comments/5lhk8y/how_the_mercator_projection_distorts_the_poles/?usqp=mq331AQJCAEoAVgBgAEB&amp_js_v=0.1

- Michel Feldheim

---

甜心，我已经寻找这个方程的伪代码简化版本好久了，谢谢。 - AngryDuck

如果我想在我的坐标点中进行“缩放”，在这个算法中我应该在哪里乘以缩放因子？ - matheusvmbruno

我没有看到伪代码考虑了2D地图角落的纬度/经度坐标。这不是必要的吗？ - Henning

你的伪代码中，y值是否故意也依赖于mapWidth的值？伪代码中写道：y = (mapHeight/2)-(mapWidthmercN/(2PI))；难道不应该是：y = (mapHeight/2)-(mapHeightmercN/(2PI))？ - Quasimondo

我们需要做些什么才能让这个功能在被裁剪过的地图上运行——那些边界不是全球地图的地图？ - Gerry

Answer 2

因为世界不是平的，所以你不能简单地将经度/纬度转换为x/y坐标。你看过这篇文章吗？将经度/纬度转换为X/Y坐标

更新-1/18/13

我决定尝试一下，这就是我做的方法：

public class MapService {
    // CHANGE THIS: the output path of the image to be created
    private static final String IMAGE_FILE_PATH = "/some/user/path/map.png";

    // CHANGE THIS: image width in pixel
    private static final int IMAGE_WIDTH_IN_PX = 300;

    // CHANGE THIS: image height in pixel
    private static final int IMAGE_HEIGHT_IN_PX = 500;

    // CHANGE THIS: minimum padding in pixel
    private static final int MINIMUM_IMAGE_PADDING_IN_PX = 50;

    // formula for quarter PI
    private final static double QUARTERPI = Math.PI / 4.0;

    // some service that provides the county boundaries data in longitude and latitude
    private CountyService countyService;

    public void run() throws Exception {
        // configuring the buffered image and graphics to draw the map
        BufferedImage bufferedImage = new BufferedImage(IMAGE_WIDTH_IN_PX,
                                                        IMAGE_HEIGHT_IN_PX,
                                                        BufferedImage.TYPE_INT_RGB);

        Graphics2D g = bufferedImage.createGraphics();
        Map<RenderingHints.Key, Object> map = new HashMap<RenderingHints.Key, Object>();
        map.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
        map.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        map.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        RenderingHints renderHints = new RenderingHints(map);
        g.setRenderingHints(renderHints);

        // min and max coordinates, used in the computation below
        Point2D.Double minXY = new Point2D.Double(-1, -1);
        Point2D.Double maxXY = new Point2D.Double(-1, -1);

        // a list of counties where each county contains a list of coordinates that form the county boundary
        Collection<Collection<Point2D.Double>> countyBoundaries = new ArrayList<Collection<Point2D.Double>>();

        // for every county, convert the longitude/latitude to X/Y using Mercator projection formula
        for (County county : countyService.getAllCounties()) {
            Collection<Point2D.Double> lonLat = new ArrayList<Point2D.Double>();

            for (CountyBoundary countyBoundary : county.getCountyBoundaries()) {
                // convert to radian
                double longitude = countyBoundary.getLongitude() * Math.PI / 180;
                double latitude = countyBoundary.getLatitude() * Math.PI / 180;

                Point2D.Double xy = new Point2D.Double();
                xy.x = longitude;
                xy.y = Math.log(Math.tan(QUARTERPI + 0.5 * latitude));

                // The reason we need to determine the min X and Y values is because in order to draw the map,
                // we need to offset the position so that there will be no negative X and Y values
                minXY.x = (minXY.x == -1) ? xy.x : Math.min(minXY.x, xy.x);
                minXY.y = (minXY.y == -1) ? xy.y : Math.min(minXY.y, xy.y);

                lonLat.add(xy);
            }

            countyBoundaries.add(lonLat);
        }

        // readjust coordinate to ensure there are no negative values
        for (Collection<Point2D.Double> points : countyBoundaries) {
            for (Point2D.Double point : points) {
                point.x = point.x - minXY.x;
                point.y = point.y - minXY.y;

                // now, we need to keep track the max X and Y values
                maxXY.x = (maxXY.x == -1) ? point.x : Math.max(maxXY.x, point.x);
                maxXY.y = (maxXY.y == -1) ? point.y : Math.max(maxXY.y, point.y);
            }
        }

        int paddingBothSides = MINIMUM_IMAGE_PADDING_IN_PX * 2;

        // the actual drawing space for the map on the image
        int mapWidth = IMAGE_WIDTH_IN_PX - paddingBothSides;
        int mapHeight = IMAGE_HEIGHT_IN_PX - paddingBothSides;

        // determine the width and height ratio because we need to magnify the map to fit into the given image dimension
        double mapWidthRatio = mapWidth / maxXY.x;
        double mapHeightRatio = mapHeight / maxXY.y;

        // using different ratios for width and height will cause the map to be stretched. So, we have to determine
        // the global ratio that will perfectly fit into the given image dimension
        double globalRatio = Math.min(mapWidthRatio, mapHeightRatio);

        // now we need to readjust the padding to ensure the map is always drawn on the center of the given image dimension
        double heightPadding = (IMAGE_HEIGHT_IN_PX - (globalRatio * maxXY.y)) / 2;
        double widthPadding = (IMAGE_WIDTH_IN_PX - (globalRatio * maxXY.x)) / 2;

        // for each country, draw the boundary using polygon
        for (Collection<Point2D.Double> points : countyBoundaries) {
            Polygon polygon = new Polygon();

            for (Point2D.Double point : points) {
                int adjustedX = (int) (widthPadding + (point.getX() * globalRatio));

                // need to invert the Y since 0,0 starts at top left
                int adjustedY = (int) (IMAGE_HEIGHT_IN_PX - heightPadding - (point.getY() * globalRatio));

                polygon.addPoint(adjustedX, adjustedY);
            }

            g.drawPolygon(polygon);
        }

        // create the image file
        ImageIO.write(bufferedImage, "PNG", new File(IMAGE_FILE_PATH));
    }
}

结果：图片宽度=600px，图片高度=600px，图片内边距=50px

结果：图片宽度=300px，图片高度=500px，图片内边距=50px

- limc

---

我已经看过了，似乎作者的代码没有考虑地图图片的大小？我已经更新了我的问题，并提供了更准确的代码，虽然还不是完全正确。 - drunkmonkey

我更新了我的帖子... 这段代码考虑到了指定的图片宽度和高度。 - limc

Answer 3

以下是原版Google Maps JavaScript API v3的Java版本代码，它能够正常运行。

public final class GoogleMapsProjection2 
{
    private final int TILE_SIZE = 256;
    private PointF _pixelOrigin;
    private double _pixelsPerLonDegree;
    private double _pixelsPerLonRadian;

    public GoogleMapsProjection2()
    {
        this._pixelOrigin = new PointF(TILE_SIZE / 2.0,TILE_SIZE / 2.0);
        this._pixelsPerLonDegree = TILE_SIZE / 360.0;
        this._pixelsPerLonRadian = TILE_SIZE / (2 * Math.PI);
    }

    double bound(double val, double valMin, double valMax)
    {
        double res;
        res = Math.max(val, valMin);
        res = Math.min(res, valMax);
        return res;
    }

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

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

    PointF fromLatLngToPoint(double lat, double lng, int zoom)
    {
        PointF point = new PointF(0, 0);

        point.x = _pixelOrigin.x + lng * _pixelsPerLonDegree;       

        // Truncating to 0.9999 effectively limits latitude to 89.189. This is
        // about a third of a tile past the edge of the world tile.
        double siny = bound(Math.sin(degreesToRadians(lat)), -0.9999,0.9999);
        point.y = _pixelOrigin.y + 0.5 * Math.log((1 + siny) / (1 - siny)) *- _pixelsPerLonRadian;

        int numTiles = 1 << zoom;
        point.x = point.x * numTiles;
        point.y = point.y * numTiles;
        return point;
     }

    PointF fromPointToLatLng(PointF point, int zoom)
    {
        int numTiles = 1 << zoom;
        point.x = point.x / numTiles;
        point.y = point.y / numTiles;       

        double lng = (point.x - _pixelOrigin.x) / _pixelsPerLonDegree;
        double latRadians = (point.y - _pixelOrigin.y) / - _pixelsPerLonRadian;
        double lat = radiansToDegrees(2 * Math.atan(Math.exp(latRadians)) - Math.PI / 2);
        return new PointF(lat, lng);
    }

    public static void main(String []args) 
    {
        GoogleMapsProjection2 gmap2 = new GoogleMapsProjection2();

        PointF point1 = gmap2.fromLatLngToPoint(41.850033, -87.6500523, 15);
        System.out.println(point1.x+"   "+point1.y);
        PointF point2 = gmap2.fromPointToLatLng(point1,15);
        System.out.println(point2.x+"   "+point2.y);
    }
}

public final class PointF 
{
    public double x;
    public double y;

    public PointF(double x, double y)
    {
        this.x = x;
        this.y = y;
    }
}

- nik

---

瓦片大小由什么定义？我正在尝试在Unity中使用类似这样的东西。它是图像大小吗？还是对于Web上的Google地图或墨卡托投影是一个常量？ - John Demetriou

瓦片大小是地图瓦片的图像大小，当您从谷歌服务器接收地图瓦片图像时，它是一个256x256大小的PNG文件。 - nik

这适用于纬度，但经度值偏差很大。缺少什么？ - portfoliobuilder

Answer 4

JAVA独占吗？

这里有Python代码！请参考将纬度/经度点转换为墨卡托投影上的像素(x,y)

import math
from numpy import log as ln

# Define the size of map
mapWidth    = 200
mapHeight   = 100


def convert(latitude, longitude):
    # get x value
    x = (longitude + 180) * (mapWidth / 360)

    # convert from degrees to radians
    latRad = (latitude * math.pi) / 180

    # get y value
    mercN = ln(math.tan((math.pi / 4) + (latRad / 2)))
    y     = (mapHeight / 2) - (mapWidth * mercN / (2 * math.pi))
    
    return x, y

print(convert(41.145556, 121.2322))

Answer:

(167.35122222222225, 24.877939817552335)

- 武状元 Woa

Answer 5

我是新来的，只是想写点东西，因为我已经关注这个社区好几年了。我很高兴能够做出贡献。

嗯，我花了将近一天的时间去寻找答案，而你的问题鼓励我继续寻找。

我找到了下面这个函数，它可以工作！感谢这篇文章：https://towardsdatascience.com/geotiff-coordinate-querying-with-javascript-5e6caaaf88cf

var bbox = [minLong, minLat, maxLong, maxLat];
var pixelWidth = mapWidth;
var pixelHeight = mapHeight;
var bboxWidth = bbox[2] - bbox[0];
var bboxHeight = bbox[3] - bbox[1];

var convertToXY = function(latitude, longitude) {
    var widthPct = ( longitude - bbox[0] ) / bboxWidth;
    var heightPct = ( latitude - bbox[1] ) / bboxHeight;
    var x = Math.floor( pixelWidth * widthPct );
    var y = Math.floor( pixelHeight * ( 1 - heightPct ) );
    return { x, y };
}

- Fabric.io

Answer 6

 public static String getTileNumber(final double lat, final double lon, final int zoom) {
 int xtile = (int)Math.floor( (lon + 180) / 360 * (1<<zoom) ) ;
 int ytile = (int)Math.floor( (1 - Math.log(Math.tan(Math.toRadians(lat)) + 1 /  Math.cos(Math.toRadians(lat))) / Math.PI) / 2 * (1<<zoom) ) ;
if (xtile < 0)
 xtile=0;
if (xtile >= (1<<zoom))
 xtile=((1<<zoom)-1);
if (ytile < 0)
 ytile=0;
if (ytile >= (1<<zoom))
 ytile=((1<<zoom)-1);
return("" + zoom + "/" + xtile + "/" + ytile);
 }
}

- Farshid Ashouri