在墨卡托投影上将纬度/经度点转换为像素(x,y)


69

我正在尝试将经纬度点转换为2d点,以便可以在世界图像上显示它,这是墨卡托投影。

我已经看到了执行此操作的各种方法以及有关堆栈溢出的一些问题-我已经尝试了不同的代码段,尽管我获得了正确的像素经度,但是纬度始终似乎似乎变得越来越合理。

我需要公式来考虑图像的大小,宽度等。

我已经试过这段代码:

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);

在我尝试的示例中,纬度似乎减少了30px。有什么帮助或建议吗?

更新资料

基于以下问题:纬度/经度到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所述,如果您的地图是Marcator投影,则需要使用Mercator投影将经纬度转换为x / y。检查您的地图是横向墨卡托还是球形墨卡托,我们将前往配方设计师...
Michael

这是球形墨卡托投影
drunkmonkey 2013年

Answers:


131

墨卡托地图投影是兰伯特圆锥形保形地图投影的一种特殊限制情况,其中赤道为单个标准平行线。所有其他纬度平行线都是直线,子午线也是与赤道成直角的等距直线。它是投影的横向和倾斜形式的基础。它很少用于土地制图目的,而几乎用于导航图。它不仅是保形的,还具有特殊的特性,即在其上绘制的直线是恒定方位线。因此,导航员可以从直线路线与子午线形成的角度得出路线。[1.]

墨卡托投影

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

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

其中λ Ø是天然来源和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中创建了一个工作示例(因为我对Java很烂)

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=mq331AQJCAEoAVgB_g=gEB_amp


1
SWEET iv一直在寻找将该方程简单地放入伪代码中以获取aaaages ty
AngryDuck

3
如果我想在坐标点中进行“缩放”,那么在该算法中可以在哪里乘以缩放倍数?
matheusvmbruno 2013年

5
y是否也取决于mapWidth值-在您的伪代码中它说:y =(mapHeight / 2)-(mapWidth mercN /(2 * PI)); -不应该是:y =(mapHeight / 2)-(mapHeight mercN /(2 * PI)); ?
Quasimondo 2014年

5
我们需要做些什么才能使用裁剪后的地图-该地图的边界不是完整的世界地图?
2014年

2
@Juicy,请尝试使用此修改后的公式y = (mapHeight/2)-(mapHeight*mercN/(2*PI));。我认为@Quasimondo实际上是正确的。该公式在我的示例中确实起作用,因为我使用了宽度和高度相同的地图
Michel Feldheim,2015年

13

您不能仅仅那样从经度/纬度转换为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));
    }
}

结果:图像宽度= 600像素,图像高度= 600像素,图像填充= 50像素

在此处输入图片说明

结果:图像宽度= 300像素,图像高度= 500像素,图像填充= 50像素

在此处输入图片说明


1
我看了一下,似乎作者的代码似乎没有考虑到地图图像的大小?我已经用更准确的代码更新了我的问题,尽管仍然不正确。
drunkmonkey 2013年

我更新了我的文章...此代码考虑了指定的图像宽度和高度。
limc

11

原始Google Maps JavaScript API v3的Java版本的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;
    }
}

什么定义了图块大小?我试图在Unity中使用类似的东西。它是图像尺寸吗?还是Google地图或墨卡托投影在网络上的常量?
John Demetriou 2016年

tile size是地图图块的图像大小,当您从Google服务器收到地图图块图像时,它是256x256大小的png文件
nik

这适用于纬度,但经度值相去甚远。什么东西少了?
portfoliobuilder

3

我想指出,过程边界中的代码应阅读

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

1
谢谢你 我更新了@nik的答案以包含此内容。
adam0101

0

仅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))

回答:

(167.35122222222225, 24.877939817552335)

-1
 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);
 }
}
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.