今天读了一下《地理坐标（经纬度坐标）和屏幕坐标（xy坐标）间的转换》，觉得内容很好，特摘录和附上自己的解释。

背景

在我们的屏幕上，有一张地图，这张地图经过缩放、平移、旋转，最终地理坐标和屏幕坐标的关系大致如下图所示：

这种关系要怎么描述呢？我们可以假设地图是一张纸，而屏幕是一堵墙。只要我们有两个图钉，我们就能把纸定在墙上。我们把这两个点称为锚点。锚点在屏幕坐标系上的坐标是(x1,y1)和(x2,y2)，对应在地理坐标系上的坐标是(lon1,lat1)和(lon2,lat2)。

那现在的问题就变成了，已知两个锚点的坐标，

（1）地理坐标转屏幕坐标：已知任意一点的地理坐标(lon,lat)，求它在屏幕上的坐标(x,y)

（2）屏幕坐标转地理坐标：已知任意一点的屏幕坐标(x,y)，求它的经纬度坐标(lon,lat)

lon 表示 longitude (纬度)
lat 表示 latitude (经度)
x,y 表示屏幕上的只是一个任意位置的坐标点

转换算法

1、地理坐标平面化

在一个小范围内（例如是方圆几公里内），我们可以假设地面是平的，而不是弯的。如果经纬度都用弧度表示，那么1纬度对应的长度是：

$$1纬度长度=R\cdot lat$$

其中 $R$ 是地球半径。 而相同经度间的距离会随着纬度的增加而减少，在 $lat$ 这一纬度下，1经度对应的长度是：

$$1经度长度=R\cdot lon\cdot \cos (lat)$$

那么，(lon,lat)这个坐标平面化后的坐标就是： $(R\cdot lon\cdot \cos (lat),R\cdot lat)$

2、向量法

由已知点和未知点组成两组向量：

由于坐标系转换是线性变换，所以两组向量有以下特性：

• （1）两向量在不同的坐标系中的长度比是相同的。

• （2）两向量在不同的坐标系中的夹角是相同的。

根据上面两个特性，我们可列出方程组：

设向量1为$(d{x}_1,d{y}_1)$，$(dlo{n}_1,dla{t}_1)$，向量2为 $(d{x}_2,d{y}_2)，(dlo{n}_2,dla{t}_2)$，

其中

$d{x}_1=x_2-x_1$，$d{y}_1=y_2-y_1$，$dlo{n}_1=lo{n}_2-lo{n}_1$，$dla{t}_1=la{t}_2-la{t}_1$

$d{x}_2=x-x_1$ ，$d{y}_2=y-y_1$ ，$dlo{n}_2=lon-lo{n}_1$，$dla{t}_2=lat-la{t}_1$，

然后

$k_1=norm(d{x}_1,d{y}_1)$

$k_2=norm(dlo{n}_1,dla{t}_1)$

$k_3=norm(d{x}_2,d{y}_2)$

$k_4=norm(dlo{n}_2,dla{t}_2)$

下面我们给出方程组：

1. 根据前文中提到的 两向量在不同的坐标系中的长度比是相同的 可得到

$$\frac{k_1}{k_2}=\frac{k_3}{k_4}$$

本式当然可以写成：

$$\frac{\sqrt{d{x}_1^2+d{y}_1^2}}{\sqrt{dlo{n}_1^2+dla{t}_1^2}}=\frac{\sqrt{d{x}_2^2+d{y}_2^2}}{\sqrt{dlo{n}_2^2+dla{t}_2^2}}$$

2. 根据前文中提到的 两向量在不同的坐标系中的夹角是相同的

我们可得出以下四个式子：

$$①\frac{d{x}_1}{k_1}=\frac{d{x}_2}{k_3}（通过x求夹角cos值）$$

$$②\frac{d{y}_1}{k_1}=\frac{d{y}_2}{k_3}（通过y求夹角sin值）$$

$$③\frac{dlo{n}_1}{k_2}=\frac{dlo{n}_2}{k_4}（通过经度求夹角cos值）$$

$$④\frac{dla{t}_1}{k_2}=\frac{dla{t}_2}{k_4}（通过纬度求夹角sin值）$$

由 ① 乘以 ③ 可得：

$$⑤\frac{d{x}_1\cdot dlo{n}_1}{k1\cdot k_2}=\frac{d{x}_2\cdot dlo{n}_2}{k_3\cdot k_4}$$

由 ② 乘以 ④ 可得：

$$⑥\frac{d{y}_1\cdot dla{t}_1}{k1\cdot k_2}=\frac{d{y}_2\cdot dla{t}_2}{k_3\cdot k_4}$$

将 ⑤ 与 ⑥ 相加，即可得原文中提到的复合在一起的式子：

$$\frac{d{x}_1\cdot dlo{n}_1+d{y}_1\cdot dla{t}_1}{k1\cdot k_2}=\frac{d{x}_2\cdot dlo{n}_2+d{y}_2\cdot dla{t}_2}{k_3\cdot k_4}$$

通过解上面的方程组，我们就能得到未知和屏幕坐标或未知的地理坐标。

为什么呢？别看推导过程中代数符号（变量名）很多，其实不确定的值只有：

$$(x,y)和(lon,lat)$$

故，接下来就简单了：

• 将$(x,y)$带入方程组就可以得到$(lon,lat)$

• 反过来，将$(lon,lat)$带入方程组就可以得到$(x,y)$

这里需要注意的是：

处于分母位置的 $k_1$、$k_2$、$k_3$、$k_4$ 都不能为零

转换为编程中的除零异常就是需要注意的是：

• 参考的两点不能完全相等
• 进行计算的$(x,y)$或$(lon,lat)$不能与第一个参考点相同

对于第二句话，由于类库使用者调用本函数时，不会注意传参顺序，故你可要求他要计算的点不应该为两个参考点中任意一个。实际工程中，对于这个问题，你可以让他在调用这个函数时，选取两个实际中无法到达的两个参考点，这样就可以随意输入值了。

屏幕坐标转地理坐标(Java实现）

由于原文中已给出了详尽的C#代码，这里我只给出自己的关于屏幕坐标转地理坐标的Java实现：

1.首先定义包含$(x,y)$ 和 $(lon,lat)$ 的数据存储的类

public class XYLonLatModle {

    private double x;

    private double y;

    private double longitude;

    private double latitude;

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

    public double getLongitude() {
        return longitude;
    }

    public void setLongitude(double longitude) {
        this.longitude = longitude;
    }

    public double getLatitude() {
        return latitude;
    }

    public void setLatitude(double latitude) {
        this.latitude = latitude;
    }

    public String getWgsString() {
        return latitude + "," + longitude;
    }
}

然后为了构建这个 XYLonLatModle 更加方便，我们再写一个 Builder 类。

public final class XYLonLatModleBuilder {
    private double x;
    private double y;
    private double longitude;
    private double latitude;

    private XYLonLatModleBuilder() {
    }

    public static XYLonLatModleBuilder aXYLonLatModle() {
        return new XYLonLatModleBuilder();
    }

    public XYLonLatModleBuilder withX(double x) {
        this.x = x;
        return this;
    }

    public XYLonLatModleBuilder withY(double y) {
        this.y = y;
        return this;
    }

    public XYLonLatModleBuilder withOriginalXY() {
        this.x = 0;
        this.y = 0;
        return this;
    }

    public XYLonLatModleBuilder withXyString(String xyString){
        String[] strings = xyString.split(",");
        this.x = Double.parseDouble(strings[0]);
        this.y = Double.parseDouble(strings[1]);
        return this;
    }

    public XYLonLatModleBuilder withLongitude(double longitude) {
        this.longitude = longitude;
        return this;
    }

    public XYLonLatModleBuilder withLatitude(double latitude) {
        this.latitude = latitude;
        return this;
    }

    public XYLonLatModleBuilder withLatitudeLongitudeString(String latLngString) {
        String[] strings = latLngString.split(",");
        this.latitude = Double.parseDouble(strings[0]);
        this.longitude = Double.parseDouble(strings[1]);
        return this;
    }

    public XYLonLatModle build() {
         XYLonLatModle xYLonLatModle = new  XYLonLatModle();
        xYLonLatModle.setX(x);
        xYLonLatModle.setY(y);
        xYLonLatModle.setLongitude(longitude);
        xYLonLatModle.setLatitude(latitude);
        return xYLonLatModle;
    }
}

2.创建工具类根据两个参照点和当前的$(x,y)$ 计算 $(lon,lat)$

public class XYLongitudeLatitudeConvertUtil {

    public static double norm(double a, double b) {
        return Math.sqrt(a * a + b * b);
    }

    /**
     * x y 坐标转 经纬度
     *
     * @param x
     * @param y
     * @param reference1
     * @param reference2
     * @return
     */
    public static XYLonLatModle vectorMapXyToLatLng(double x, double y, XYLonLatModle reference1, XYLonLatModle reference2) {

        double x1 = reference1.getX();
        double y1 = reference1.getY();
        double lon1 = reference1.getLongitude();
        double lat1 = reference1.getLatitude();

        double x2 = reference2.getX();
        double y2 = reference2.getY();
        double lon2 = reference2.getLongitude();
        double lat2 = reference2.getLatitude();

        double lon_cos = Math.cos(lat2 * Math.PI / 180);

        double m = (lon2 - lon1) * lon_cos;
        double n = (lat2 - lat1);

        double dx1 = x2 - x1;
        double dy1 = y2 - y1;
        double dx2 = x - x1;
        double dy2 = y - y1;

        double a = (dx2 * dx2 + dy2 * dy2) * (m * m + n * n) / (dx1 * dx1 + dy1 * dy1);

        double norm = norm(m, n);
        double v = dx1 * dx2 + dy2 * dy1;
        double sqrt = Math.sqrt(a);
        double b = v * norm * sqrt / (norm(dx1, dy1) * norm(dx2, dy2));

        double c = Math.sqrt(b * b * n * n - (m * m + n * n) * (b * b - a * m * m));

        double q1 = (b * n + c) / (m * m + n * n);
        double q2 = (b * n - c) / (m * m + n * n);

        double p1 = (b - q1 * n) / m;
        double p2 = (b - q2 * n) / m;

        double lon_1 = p1 / lon_cos + lon1;
        double lat_1 = q1 + lat1;
        double lon_2 = p2 / lon_cos + lon1;
        double lat_2 = q2 + lat1;

        double judge1 = (lon_1 - lon1) * (lat2 - lat1) - (lat_1 - lat1) * (lon2 - lon1);
        double judge2 = (lon_2 - lon1) * (lat2 - lat1) - (lat_2 - lat1) * (lon2 - lon1);
        double judge = (x - x1) * (y2 - y1) - (y - y1) * (x2 - x1);

        double lon = 0;
        double lat = 0;
        if (judge * judge1 < 0) {
            lon = lon_1;
            lat = lat_1;
        } else {
            lon = lon_2;
            lat = lat_2;
        }

        XYLonLatModle xyLonLatModle = XYLonLatModleBuilder.aXYLonLatModle().withX(x).withY(y).withLongitude(lon).withLatitude(lat).build();
        return xyLonLatModle;
    }

}

本方法未用到任何jar包依赖，直接使用的Java基本语法，故不需要给出import

最简易的调用就是用屏幕中的零点和一个较大的点来作参考：

XYLonLatModle originalPoint = XYLonLatModleBuilder.aXYLonLatModle()
        .withOriginalXY()
        .withLatitudeLongitudeString("20.156,52.369")
        .build();
XYLonLatModle anotherPoint = XYLonLatModleBuilder.aXYLonLatModle()
        .withXyString("5,5")
        .withLatitudeLongitudeString("20.157,52.370")
        .build();
XYLonLatModle xyLonLatModle = XYLongitudeLatitudeConvertUtil.vectorMapXyToLatLng(x, y, originalPoint, anotherPoint);