你提到的平面斜率计算方法确实不适用于经纬度坐标——地球是近似椭球体，经纬度是球面坐标系，直接用平面几何会在距离稍远时出现明显误差，还会遇到经度范围（-180到180）、纬度范围（-90到90）的问题。下面是更专业的实现思路和代码：

核心思路：球面几何与大地测量学方法 #

要在起点的线段两侧生成垂直点，本质是在球面上，以起点为原点，沿着与原线段垂直的两个方位角，移动指定距离length得到目标点。具体步骤：

1. 计算原线段（start到end）的方位角（即从start指向end的方向角，范围0-360度）。
2. 垂直方向的方位角：原方位角加90度（右侧）、减90度（左侧），注意角度取模360确保在有效范围。
3. 使用大地测量学公式（比如Vincenty公式，比Haversine更精确），根据起点坐标、目标方位角、移动距离，计算出目标点的经纬度。

实现代码（Java） #

首先需要实现方位角计算和Vincenty逆/正算方法，这里给出完整的工具类示例：

import java.math.BigDecimal;
import java.math.RoundingMode;

public class GeodeticUtils {
    // 地球椭球体参数（WGS84，通用GPS坐标系）
    private static final double a = 6378137.0; // 长半轴
    private static final double b = 6356752.314245; // 短半轴
    private static final double f = (a - b) / a; // 扁率

    /**
     * 计算两点间的方位角（从start到end的方向，单位：度）
     */
    public static double calculateBearing(Coordinate start, Coordinate end) {
        double lat1 = Math.toRadians(start.lat);
        double lon1 = Math.toRadians(start.lon);
        double lat2 = Math.toRadians(end.lat);
        double lon2 = Math.toRadians(end.lon);

        double dLon = lon2 - lon1;
        double y = Math.sin(dLon) * Math.cos(lat2);
        double x = Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(dLon);
        double bearing = Math.atan2(y, x);
        bearing = Math.toDegrees(bearing);
        // 转换为0-360度范围
        return (bearing + 360) % 360;
    }

    /**
     * 从起点出发，沿指定方位角移动指定距离，计算目标坐标
     * @param start 起点坐标（lat：纬度，lon：经度）
     * @param bearing 方位角（度，0-360）
     * @param distance 移动距离（米）
     * @return 目标坐标
     */
    public static Coordinate moveAlongBearing(Coordinate start, double bearing, double distance) {
        double lat1 = Math.toRadians(start.lat);
        double lon1 = Math.toRadians(start.lon);
        double brng = Math.toRadians(bearing);
        double s = distance;

        double tanU1 = (1 - f) * Math.tan(lat1);
        double cosU1 = 1 / Math.sqrt(1 + tanU1 * tanU1);
        double sinU1 = tanU1 * cosU1;

        double sigma1 = Math.atan2(tanU1, Math.cos(brng));
        double sinAlpha = cosU1 * Math.sin(brng);
        double cosSqAlpha = 1 - sinAlpha * sinAlpha;
        double uSq = cosSqAlpha * (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 sigma = s / (b * A);
        double sigmaP = 2 * Math.PI;
        double cos2SigmaM = 0;
        double sinSigma = 0;
        double cosSigma = 0;

        // 迭代计算sigma
        while (Math.abs(sigma - sigmaP) > 1e-12) {
            cos2SigmaM = Math.cos(2 * sigma1 + sigma);
            sinSigma = Math.sin(sigma);
            cosSigma = Math.cos(sigma);
            double deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)
                    - B / 6 * cos2SigmaM * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2SigmaM * cos2SigmaM)));
            sigmaP = sigma;
            sigma = s / (b * A) + deltaSigma;
        }

        // 计算目标点纬度
        double tmp = sinU1 * sinSigma - cosU1 * cosSigma * Math.cos(brng);
        double lat2 = Math.atan2(sinU1 * cosSigma + cosU1 * sinSigma * Math.cos(brng),
                (1 - f) * Math.sqrt(sinAlpha * sinAlpha + tmp * tmp));
        // 计算目标点经度
        double lambda = Math.atan2(sinSigma * Math.sin(brng), cosU1 * cosSigma - sinU1 * sinSigma * Math.cos(brng));
        double C = f / 16 * cosSqAlpha * (4 + f * (4 - 3 * cosSqAlpha));
        double L = lambda - (1 - C) * f * sinAlpha
                * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)));
        double lon2 = lon1 + L;

        // 转换为度并修正范围
        lat2 = Math.toDegrees(lat2);
        lon2 = Math.toDegrees(lon2);
        lon2 = (lon2 + 180) % 360 - 180; // 确保经度在-180到180之间

        return new Coordinate(round(lat2, 6), round(lon2, 6));
    }

    // 辅助方法：保留指定小数位
    private static double round(double value, int places) {
        if (places < 0) throw new IllegalArgumentException();
        BigDecimal bd = BigDecimal.valueOf(value);
        bd = bd.setScale(places, RoundingMode.HALF_UP);
        return bd.doubleValue();
    }

    // 坐标类（假设你已有这个类，这里补充定义）
    public static class Coordinate {
        public double lat; // 纬度（-90到90）
        public double lon; // 经度（-180到180）

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

    // 你的业务方法：生成起点两侧的垂直点
    public static Coordinate getPerpendicularPoint(Coordinate start, Coordinate end, double length) {
        // 计算原线段的方位角
        double bearing = calculateBearing(start, end);
        // 计算垂直方位角（右侧：+90度，左侧：-90度，这里通过length正负区分）
        double perpBearing = length > 0 ? (bearing + 90) % 360 : (bearing - 90 + 360) % 360;
        // 移动的距离取绝对值
        double distance = Math.abs(length);
        return moveAlongBearing(start, perpBearing, distance);
    }
}

关键说明 #

• 坐标系选择：代码使用WGS84椭球体，这是GPS和大多数地图服务的标准坐标系，确保兼容性。
• 精度优势：Vincenty公式考虑了地球的椭球形状，计算精度远高于平面假设和Haversine公式，适合长距离计算。
• 角度处理：方位角计算后会修正到0-360度范围，经度最终会修正到-180到180度，避免坐标越界问题。
• 调用方式：和你原来的思路类似，调用getPerpendicularPoint(start, end, length)得到右侧点，调用getPerpendicularPoint(start, end, -length)得到左侧点。

对比你之前的方法：平面斜率计算只适用于极小范围（比如城市内部几百米），一旦距离增大或者靠近极地，误差会急剧放大，甚至出现坐标超出经纬度范围的情况，而球面几何方法完全解决了这些问题。

内容的提问来源于stack exchange，提问作者guy_sensei