GPS WGS-84 坐标转 GCJ-02、BD-09 坐标

2024-06-27

很久之前的代码了，当时在一些小地方用到，也没有用到具体的项目中，零零散散的放着，不知道该归类到什么地方，现在直接写到文章里面，给自己做一个留档。

有 TypeScript 和 Java 两个版本，Java 版本其实也是参考了 JavaScript 版本转换过来的。

代码基本上都是抄的，但是太久了，已经不知道抄的是谁的了，当时也没有具体的注释代码来源，现在也懒得去溯源了。Java 版本至少是2017年或更以前的时候抄出来的。

TypeScript 版本

//转换常数
const x_pi = 3.14159265358979324 * 3000.0 / 180.0;
const pi = 3.14159265358979324;
const a = 6378245.0;
const ee = 0.00669342162296594323;

export type LngLat = {
  lng: number;
  lat: number;
}

function transformLon(x: number, y: number) {
  let ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(Math.abs(x));
  ret += (20.0 * Math.sin(6.0 * x * pi) + 20.0 * Math.sin(2.0 * x * pi)) * 2.0 / 3.0;
  ret += (20.0 * Math.sin(x * pi) + 40.0 * Math.sin(x / 3.0 * pi)) * 2.0 / 3.0;
  ret += (150.0 * Math.sin(x / 12.0 * pi) + 300.0 * Math.sin(x / 30.0 * pi)) * 2.0 / 3.0;
  return ret;
}

function transformLat(x: number, y: number) {
  let ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(Math.abs(x));
  ret += (20.0 * Math.sin(6.0 * x * pi) + 20.0 * Math.sin(2.0 * x * pi)) * 2.0 / 3.0;
  ret += (20.0 * Math.sin(y * pi) + 40.0 * Math.sin(y / 3.0 * pi)) * 2.0 / 3.0;
  ret += (160.0 * Math.sin(y / 12.0 * pi) + 320 * Math.sin(y * pi / 30.0)) * 2.0 / 3.0;
  return ret;
}

function outOfChina(lat: number, lng: number) {
  if (lng < 72.004 || lng > 137.8347)
    return true;
  return lat < 0.8293 || lat > 55.8271;
}

/*
 * WGS-84：是国际标准，GPS坐标（Google Earth使用、或者GPS模块、天地图）
 * GCJ-02：中国坐标偏移标准，Google Map、高德、腾讯使用
 * BD-09：百度坐标偏移标准，Baidu Map使用
*/

/**
 * WGS-84 到 GCJ-02 的转换（即 GPS 加偏）
 * @param wgLat 纬度
 * @param wgLng 经度
 */
export function wgs_gcj(wgLat: number, wgLng: number) {
  const point: any = {};
  if (outOfChina(wgLat, wgLng)) {
    point.lat = wgLat;
    point.lng = wgLng;
    return point as LngLat;
  }
  let dLat = transformLat(wgLng - 105.0, wgLat - 35.0);
  let dLon = transformLon(wgLng - 105.0, wgLat - 35.0);
  let radLat = wgLat / 180.0 * pi;
  let magic = Math.sin(radLat);
  magic = 1 - ee * magic * magic;
  let sqrtMagic = Math.sqrt(magic);
  dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * pi);
  dLon = (dLon * 180.0) / (a / sqrtMagic * Math.cos(radLat) * pi);
  let lat = wgLat + dLat;
  let lon = wgLng + dLon;
  point.lat = lat;
  point.lng = lon;
  return point as LngLat;
}


/**
 * BD-09 转 GCJ-02 的转换
 * @param bdLat 纬度
 * @param bdLng 经度
 * */
export function bd_gcj(bdLat: number, bdLng: number) {
  const point: any = {};
  const x = bdLng - 0.0065;
  const y = bdLat - 0.006;
  const z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * x_pi);
  const theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * x_pi);
  point.lat = z * Math.sin(theta);
  point.lng = z * Math.cos(theta);
  return point as LngLat;
}


/**
 * GCJ-02 转 BD-09 的转换
 * @param ggLat 纬度
 * @param ggLng 经度
 * */
export function gcj_bd(ggLat: number, ggLng: number) {
  const point: any = {};
  const x = ggLng;
  const y = ggLat;
  const z = Math.sqrt(x * x + y * y) + 0.00002 * Math.sin(y * x_pi);
  const theta = Math.atan2(y, x) + 0.000003 * Math.cos(x * x_pi);
  point.lat = z * Math.sin(theta) + 0.006;
  point.lon = z * Math.cos(theta) + 0.0065;
  return point as LngLat;
}


/**
 * GCJ-02 到 WGS-84 的转换
 * @param wgLat 纬度
 * @param wgLng 经度
 */
export function gcj_wgs(wgLat: number, wgLng: number) {
  const point: any = {};
  if (outOfChina(wgLat, wgLng)) {
    point.lat = wgLat;
    point.lng = wgLng;
    return point as LngLat;
  }
  let dLat = transformLat(wgLng - 105.0, wgLat - 35.0);
  let dLon = transformLon(wgLng - 105.0, wgLat - 35.0);
  const radLat = wgLat / 180.0 * pi;
  let magic = Math.sin(radLat);
  magic = 1 - ee * magic * magic;
  const sqrtMagic = Math.sqrt(magic);
  dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * pi);
  dLon = (dLon * 180.0) / (a / sqrtMagic * Math.cos(radLat) * pi);
  const lat = dLat;
  const lon = dLon;
  point.lat = lat;
  point.lng = lon;
  return point as LngLat;
}

/**
 * GPS坐标 转高德地图坐标
 * @param gpsLngLatOrLng [经度, 纬度] 或者 经度
 * @param gpsLat 纬度
 */
export function gpsToGaode(gpsLngLatOrLng: [number, number] | number, gpsLat: number | undefined = undefined): [number, number] {
  if (Array.isArray(gpsLngLatOrLng)) {
    if (gpsLngLatOrLng.length === 2) {
      const lngLat = wgs_gcj(gpsLngLatOrLng[1], gpsLngLatOrLng[0]);
      return [lngLat.lng, lngLat.lat];
    } else {
      return [0, 0];
    }
  }
  if (gpsLat === undefined || gpsLat === null) {
    return [0, 0];
  }
  const lngLat = wgs_gcj(gpsLat, gpsLngLatOrLng);
  return [lngLat.lng, lngLat.lat];
}

/**
 * BD-09坐标 转高德地图坐标
 * @param bdLngLatOrLng [经度, 纬度] 或者 经度
 * @param bdLat 纬度
 */
export function bdToGaode(bdLngLatOrLng: [number, number] | number, bdLat: number | undefined = undefined): [number, number] {
  if (Array.isArray(bdLngLatOrLng)) {
    if (bdLngLatOrLng.length === 2) {
      const lngLat = bd_gcj(bdLngLatOrLng[1], bdLngLatOrLng[0]);
      return [lngLat.lng, lngLat.lat];
    } else {
      return [0, 0];
    }
  }
  if (bdLat === undefined || bdLat === null) {
    return [0, 0];
  }
  const lngLat = bd_gcj(bdLat, bdLngLatOrLng);
  return [lngLat.lng, lngLat.lat];
}

/**
 * GPS坐标 转高德地图坐标
 * @param gpsLng 经度
 * @param gpsLat 纬度
 */
export function gpsToGaode2(gpsLng: number, gpsLat: number): [number, number] {
  const lngLat = wgs_gcj(gpsLat, gpsLng)
  return [lngLat.lng, lngLat.lat];
}

Java 版本

import java.text.NumberFormat;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class LatLon {
    private static final NumberFormat df = NumberFormat.getInstance();
    private static final double r = 6378137;
    private static final double b = 6356752.314245;
    private static final double f = 1 / 298.257223563;
    private double lat;// gps纬度
    private double lon;// gps经度

    public LatLon(double lat, double lon) {
        this.lat = lat;
        this.lon = lon;
    }

    public LatLon(String lat, String lon) {
        df.setMaximumFractionDigits(6);

        this.lat = DMS.parseDMS(lat);
        this.lon = DMS.parseDMS(lon);
        // System.out.println(df.format(this.lat));
        // System.out.println(df.format(this.lon));
        // double lon = DMS.parseDMS(String.valueOf(110.297241));
        // System.out.println(lon);
        // System.out.println("dms:" + DMS.toLon(lon, "dms", 2));
        // System.out.println("dm:" + DMS.toLon(lon, "dm", 3));
        // System.out.println();
        //
        // lon = DMS.parseDMS(String.valueOf("25°16′28.2″N"));
        // System.out.println(lon);
        // System.out.println("dm:" + DMS.toLat(lon, "dm", 3));
        // System.out.println("d:" + DMS.toLat(lon, "d", 5));
    }

    public static void main(String[] args) {

        LatLon latLon5 = new LatLon(22.66283814, 114.0263974);
        LatLon latLon6 = new LatLon(22.6614933, 114.0272899);
        System.out.println("以经纬度计算======"+latLon5.toString() + latLon6.toString());
        System.out.println(latLon5.getDistance1(latLon6)+"m");
        
        
        
        
        
        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println();
        LatLon latLon1 = new LatLon(24.327077, 109.418335);
        LatLon latLon2 = new LatLon(25.274504, 110.297241);
        
        System.out.println("以GPS坐标计算======"+latLon1.toString() + latLon2.toString());
        System.out.println(latLon1.getDistance1(latLon2));
        System.out.println(latLon1.getDistance2(latLon2));
        System.out.println(latLon1.getDistance3(latLon2));
        
        System.out.println();
        System.out.println("GPS转经纬度："+DMS.toLat(24.327077, "dms", 2)+"    "+DMS.toLon(109.418335, "dms", 2));
        System.out.println("GPS转经纬度："+DMS.toLat(25.274504, "dms", 2)+"    "+DMS.toLon(110.297241, "dms", 2));

        System.out.println();
        LatLon latLon3 = new LatLon("24°19′37.48″N", "109°25′06.01″E");
        LatLon latLon4 = new LatLon("25°16′28.21″N", "110°17′50.07″E");
        System.out.println("以经纬度计算======"+latLon3.toString() + latLon4.toString());
        System.out.println(latLon3.getDistance1(latLon4));
        double ca = Math.abs(latLon1.getDistance1(latLon2)-latLon3.getDistance1(latLon4));
        System.out.println("以经纬度和GPS坐标计算的差值(米)："+ca);
        
        System.out.println();
        System.out.println();
        System.out.println();
        latLon3 = new LatLon("24°19′37.48\"N", "109°25′06.01\"E");
        System.out.println(latLon3);
        
        latLon3 = new LatLon("24°19′37.48N", "109°25′06.01E");
        System.out.println(latLon3);

    }

    public double getLat() {
        return lat;
    }

    public void setLat(double lat) {
        this.lat = lat;
    }

    public double getLon() {
        return lon;
    }

    public void setLon(double lon) {
        this.lon = lon;
    }

    @Override
    public String toString() {
        return "LatLon [lat=" + lat + ", lon=" + lon + "]";
    }

    /**
     * 原理解析http://www.movable-type.co.uk/scripts/latlong-vincenty.html
     * 算法源码https://github.com/chrisveness/geodesy 文森特解决方案在椭球上的测地线
     * 椭圆模型地球上的点之间的距离和方位
     * 
     * @param latLon
     * @return
     */
    public double getDistance1(LatLon latLon) {
        if (this.getLon() == -180) {
            this.setLon(180);
        }
        double a = LatLon.r;// 6378137;
        double b = LatLon.b;// 6356752.314245;
        double f = LatLon.f;// 1 / 298.257223563;
        double φ1 = Math.toRadians(this.getLat()), λ1 = Math.toRadians(this.getLon());
        double φ2 = Math.toRadians(latLon.getLat()), λ2 = Math.toRadians(latLon.getLon());

        double L = λ2 - λ1;
        double tanU1 = (1 - f) * Math.tan(φ1), cosU1 = 1 / Math.sqrt((1 + tanU1 * tanU1)), sinU1 = tanU1 * cosU1;
        double tanU2 = (1 - f) * Math.tan(φ2), cosU2 = 1 / Math.sqrt((1 + tanU2 * tanU2)), sinU2 = tanU2 * cosU2;

        double sinλ, cosλ, sinSqσ, sinσ = 0, cosσ = 0, σ = 0, sinα, cosSqα = 0, cos2σM = 0, C;

        double λ = L, λʹ, iterations = 0;
        do {
            sinλ = Math.sin(λ);
            cosλ = Math.cos(λ);
            sinSqσ = (cosU2 * sinλ) * (cosU2 * sinλ)
                    + (cosU1 * sinU2 - sinU1 * cosU2 * cosλ) * (cosU1 * sinU2 - sinU1 * cosU2 * cosλ);
            if (sinSqσ == 0)
                break; // co-incident points
            sinσ = Math.sqrt(sinSqσ);
            cosσ = sinU1 * sinU2 + cosU1 * cosU2 * cosλ;
            σ = Math.atan2(sinσ, cosσ);
            sinα = cosU1 * cosU2 * sinλ / sinσ;
            cosSqα = 1 - sinα * sinα;
            cos2σM = (cosSqα != 0) ? (cosσ - 2 * sinU1 * sinU2 / cosSqα) : 0; // equatorial
                                                                                // line:
                                                                                // cosSqα=0
                                                                                // (§6)
            C = f / 16 * cosSqα * (4 + f * (4 - 3 * cosSqα));
            λʹ = λ;
            λ = L + (1 - C) * f * sinα * (σ + C * sinσ * (cos2σM + C * cosσ * (-1 + 2 * cos2σM * cos2σM)));
            if (Math.abs(λ) > Math.PI)
                throw new Error("λ > π");
        } while (Math.abs(λ - λʹ) > 1e-12 && ++iterations < 1000);
        if (iterations >= 1000)
            throw new Error("Formula failed to converge");

        double uSq = cosSqα * (a * a - b * b) / (b * b);
        double A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
        double B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
        double Δσ = B * sinσ * (cos2σM + B / 4 * (cosσ * (-1 + 2 * cos2σM * cos2σM)
                - B / 6 * cos2σM * (-3 + 4 * sinσ * sinσ) * (-3 + 4 * cos2σM * cos2σM)));

        double s = b * A * (σ - Δσ);

        // double α1 = Math.atan2(cosU2 * sinλ, cosU1 * sinU2 - sinU1 * cosU2 *
        // cosλ);
        // double α2 = Math.atan2(cosU1 * sinλ, -sinU1 * cosU2 + cosU1 * sinU2 *
        // cosλ);
        //
        // α1 = (α1 + 2 * Math.PI) % (2 * Math.PI); // normalise to 0..360
        // α2 = (α2 + 2 * Math.PI) % (2 * Math.PI); // normalise to 0..360
        // System.out.println(s);
        // System.out.println(s==0 ? null : Math.toDegrees(α1));
        // System.out.println(s==0 ? null : Math.toDegrees(α2));
        // System.out.println(iterations);
        return s;
    }

    /**
     * 原理解析http://www.movable-type.co.uk/scripts/latlong.html
     * 算法源码https://github.com/chrisveness/geodesy 计算纬度/经度点之间的距离
     * 
     * @param latLon
     * @return
     */
    public double getDistance2(LatLon latLon) {
        // a = sin²(Δφ/2) + cos(φ1)⋅cos(φ2)⋅sin²(Δλ/2)
        // tanδ = √(a) / √(1−a)
        // see mathforum.org/library/drmath/view/51879.html for derivation

        double R = LatLon.r;// 6378137;
        double φ1 = Math.toRadians(this.getLat()), λ1 = Math.toRadians(this.getLon());
        double φ2 = Math.toRadians(latLon.getLat()), λ2 = Math.toRadians(latLon.getLon());
        double Δφ = φ2 - φ1;
        double Δλ = λ2 - λ1;

        double a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2)
                + Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δλ / 2) * Math.sin(Δλ / 2);
        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
        double d = R * c;

        return d;
    }

    /**
     * http://blog.csdn.net/woaixinxin123/article/details/45935439
     * 建议使用getDistance2(LatLon latLon)， 虽然他们的结果是一样的，但是getDistance1(LatLon
     * latLon)和getDistance2(LatLon latLon)出自同一网站
     * 
     * @param latLon
     * @return
     */
    @Deprecated
    public double getDistance3(LatLon latLon) {
        double r = LatLon.r;// 6378137;
        double radw1 = Math.toRadians(this.getLat());
        double radw2 = Math.toRadians(latLon.getLat());
        double a = radw1 - radw2;
        double b = Math.toRadians(this.getLon()) - Math.toRadians(latLon.getLon());
        double s = 2 * Math.asin(Math
                .sqrt(Math.pow(Math.sin(a / 2), 2) + Math.cos(radw1) * Math.cos(radw2) * Math.pow(Math.sin(b / 2), 2)));
        s = s * r;
        return s;
    }

    public double bearingTo(LatLon latLon) {
        // tanθ = sinΔλ⋅cosφ2 / cosφ1⋅sinφ2 − sinφ1⋅cosφ2⋅cosΔλ
        // see mathforum.org/library/drmath/view/55417.html for derivation

        double φ1 = Math.toRadians(this.getLat()), φ2 = Math.toRadians(latLon.getLat());
        double Δλ = Math.toRadians(latLon.getLon() - this.getLon());
        double y = Math.sin(Δλ) * Math.cos(φ2);
        double x = Math.cos(φ1) * Math.sin(φ2) - Math.sin(φ1) * Math.cos(φ2) * Math.cos(Δλ);
        double θ = Math.atan2(y, x);

        return (Math.toDegrees(θ) + 360) % 360;
    };
}

class DMS {
    private static final NumberFormat df = NumberFormat.getInstance();

    public static double parseDMS(String dmsStr) {
        // strip off any sign or compass dir"n & split out separate d/m/s
        String[] dms = dmsStr.trim().replace("^-", "").replace("[NSEW]$i", "").split("[^0-9.,]+");
        if (dms[dms.length - 1].equals("")) {
            String[] dms2 = new String[dms.length - 1];
            System.arraycopy(dms, 0, dms2, 0, dms2.length);
            ;// dms.splice(dms.length-1); // from trailing symbol
            dms = dms2;
        }

        if (dms.length == 0)
            return 0;

        // and convert to decimal degrees...
        double deg;
        switch (dms.length) {
        case 3: // interpret 3-part result as d/m/s
            deg = parseDouble(dms[0]) / 1 + parseDouble(dms[1]) / 60 + parseDouble(dms[2]) / 3600;

            break;
        case 2: // interpret 2-part result as d/m
            deg = parseDouble(dms[0]) / 1 + parseDouble(dms[1]) / 60;
            System.out.println(deg);
            break;
        case 1: // just d (possibly decimal) or non-separated dddmmss
            deg = parseDouble(dms[0]);
            // check for fixed-width unseparated format eg 0033709W
            // if (/[NS]/i.test(dmsStr)) deg = "0" + deg; // - normalise N/S to
            // 3-digit degrees
            // if (/[0-9]{7}/.test(deg)) deg = deg.slice(0,3)/1 +
            // deg.slice(3,5)/60 + deg.slice(5)/3600;
            break;
        default:
            return 0;
        }
        Pattern pattern = Pattern.compile("/^-|[WS]$/i");
        Matcher matcher = pattern.matcher(dmsStr);
        if (matcher.find()) {
            deg = -deg;
            // if (/^-|[WS]$/i.test(dmsStr.trim())) deg = -deg; // take "-",
            // west and south as -ve
        }

        return deg;
    };

    public static double parseDouble(String string) {
        try {
            return Double.parseDouble(string);
        } catch (Exception e) {

        }
        return 0;
    }

    public static String toDMS(double deg, String format, int dp) {
        // default values
        if (format == null) {
            format = "dms";
        }
        if (dp == 0) {
            if (format.equals("d") || format.equals("deg")) {
                dp = 4;
            } else if (format.equals("dm") || format.equals("deg+min")) {
                dp = 2;
            } else if (format.equals("dms") || format.equals("deg+min+sec")) {
                dp = 0;
            } else {
                dp = 0;
            }
        }

        deg = Math.abs(deg); // (unsigned result ready for appending compass
                                // dir"n)
        double d, m, s;
        String dms = null, dd = "00", mm = "00", ss = "00";

        df.setMaximumFractionDigits(dp);
        df.setMinimumFractionDigits(dp);
        if (format.equals("d") || format.equals("deg")) {
            d = parseDouble(df.format(deg)); // round/right-pad degrees
            if (d < 100)
                dd = "0" + df.format(d); // left-pad with leading zeros (note
                                            // may include
            // decimals)
            if (d < 10)
                dd = "0" + df.format(d);
            dms = dd + "°";
        } else if (format.equals("dm") || format.equals("deg+min")) {
            d = Math.floor(deg); // get component deg
            m = parseDouble(df.format((deg * 60) % 60)); // get component min &
            // round/right-pad
            mm = df.format(m);
            if (m == 60) {
                mm = "0";
                m = 0;
                d++;
            } // check for rounding up
            df.setMaximumFractionDigits(0);
            dd = ("000" + df.format(d));
            dd = dd.substring(dd.length() - 3);// slice(-3); // left-pad with
                                                // leading zeros
            if (m < 10)
                mm = "0" + df.format(d); // left-pad with leading zeros (note
                                            // may include
            // decimals)
            dms = dd + "°" + mm + "′";
        } else if (format.equals("dms") || format.equals("deg+min+sec")) {
            d = Math.floor(deg); // get component deg
            m = Math.floor((deg * 3600) / 60) % 60; // get component min
            s = parseDouble(df.format(deg * 3600 % 60));// (deg * 3600 %
                                                        // 60).toFixed(dp); //
                                                        // get component sec &
            // round/right-pad
            ss = df.format(s);
            if (s == 60) {
                ss = df.format(0);
                s = 0;
                m++;
            } // check for rounding up
            if (m == 60) {
                m = 0;
                mm = "0";
                d++;
            } // check for rounding up
            dd = ("000" + (int) d);
            dd = dd.substring(dd.length() - 3); // left-pad with leading zeros
            mm = ("00" + (int) m);
            mm = mm.substring(mm.length() - 2); // left-pad with leading zeros
            if (s < 10)
                ss = "0" + df.format(s); // left-pad with leading zeros (note
                                            // may include
            // decimals)
            dms = dd + "°" + mm + "′" + ss + "″";
        } else {
            dp = 0;
            System.out.println(309);
        }

        return dms;
    };

    public static String toLat(double deg, String format, int dp) {
        String lat = toDMS(deg, format, dp);
        return lat == null ? "–" : lat.substring(1) + (deg < 0 ? "S" : "N"); // knock
                                                                                // off
                                                                                // initial
                                                                                // "0"
                                                                                // for
                                                                                // lat!
    };

    public static String toLon(double deg, String format, int dp) {
        String lon = toDMS(deg, format, dp);
        return lon == null ? "–" : lon + (deg < 0 ? "W" : "E");
    };

    public static String toBrng(double deg, String format, int dp) {
        deg = (deg + 360) % 360; // normalise -ve values to 180°..360°
        String brng = toDMS(deg, format, dp);
        return brng == null ? "–" : brng.replace("360", "0"); // just in case
                                                                // rounding took
                                                                // us up to
                                                                // 360°!
    };

}

TypeScript 版本

Java 版本

参考文档