Question

我想知道Google地图使用哪种算法来计算2点之间的方向？谷歌曾经提到过它吗？

p / s：我问谷歌使用的算法找到2点之间的最短路线。

Answer 1

据我所知，Google从未公开声明它使用P2P查询的算法。尽管在查询时间方面来自文献的现有技术是Abraham等人提出的Hub标记算法。 http://link.springer.com/chapter/10.1007/978-3-642-20662-7_20。最近发布了一份通过并且写得非常好的该领域调查作为Microsoft技术报告http://research.microsoft.com/pubs/207102/MSR-TR-2014-4.pdf。

简短版本是......

Hub标记算法为静态道路网络提供最快的查询，但需要运行大量的ram（18 GiB）。

Transit节点路由稍慢，但它只需要大约2 GiB的内存并且预处理时间更短。

收缩层次结构在快速预处理时间，低空间要求（0.4 GiB）和快速查询时间之间提供了良好的折衷。

没有一种算法完全支配......

Peter Sanders的Google技术演讲可能会引起人们的兴趣

https://www.youtube.com/watch?v=-0ErpE8tQbw

安德鲁·戈德堡的这次演讲

https://www.youtube.com/watch?v=WPrkc78XLhw

KIT的Peter Sanders研究组网站提供了收缩层次结构的开源实现。 http://algo2.iti.kit.edu/english/routeplanning.php

Answer 2

如果你的意思是谷歌地图方向api和2点之间的最短路线，那么这是一个可以使用dijktstra算法解决的图论理论问题。这是一个带有回溯的DFS。

Answer 3

你应该总是检查android源代码，看看这样的疑问。

基于http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf

 private static void computeDistanceAndBearing(double lat1, double lon1,
        double lat2, double lon2, float[] results) {


        int MAXITERS = 20;
        // Convert lat/long to radians
        lat1 *= Math.PI / 180.0;
        lat2 *= Math.PI / 180.0;
        lon1 *= Math.PI / 180.0;
        lon2 *= Math.PI / 180.0;

        double a = 6378137.0; // WGS84 major axis
        double b = 6356752.3142; // WGS84 semi-major axis
        double f = (a - b) / a;
        double aSqMinusBSqOverBSq = (a * a - b * b) / (b * b);

        double L = lon2 - lon1;
        double A = 0.0;
        double U1 = Math.atan((1.0 - f) * Math.tan(lat1));
        double U2 = Math.atan((1.0 - f) * Math.tan(lat2));

        double cosU1 = Math.cos(U1);
        double cosU2 = Math.cos(U2);
        double sinU1 = Math.sin(U1);
        double sinU2 = Math.sin(U2);
        double cosU1cosU2 = cosU1 * cosU2;
        double sinU1sinU2 = sinU1 * sinU2;

        double sigma = 0.0;
        double deltaSigma = 0.0;
        double cosSqAlpha = 0.0;
        double cos2SM = 0.0;
        double cosSigma = 0.0;
        double sinSigma = 0.0;
        double cosLambda = 0.0;
        double sinLambda = 0.0;

        double lambda = L; // initial guess
        for (int iter = 0; iter < MAXITERS; iter++) {
            double lambdaOrig = lambda;
            cosLambda = Math.cos(lambda);
            sinLambda = Math.sin(lambda);
            double t1 = cosU2 * sinLambda;
            double t2 = cosU1 * sinU2 - sinU1 * cosU2 * cosLambda;
            double sinSqSigma = t1 * t1 + t2 * t2; // (14)
            sinSigma = Math.sqrt(sinSqSigma);
            cosSigma = sinU1sinU2 + cosU1cosU2 * cosLambda; // (15)
            sigma = Math.atan2(sinSigma, cosSigma); // (16)
            double sinAlpha = (sinSigma == 0) ? 0.0 :
                cosU1cosU2 * sinLambda / sinSigma; // (17)
            cosSqAlpha = 1.0 - sinAlpha * sinAlpha;
            cos2SM = (cosSqAlpha == 0) ? 0.0 :
                cosSigma - 2.0 * sinU1sinU2 / cosSqAlpha; // (18)

            double uSquared = cosSqAlpha * aSqMinusBSqOverBSq; // defn
            A = 1 + (uSquared / 16384.0) * // (3)
                (4096.0 + uSquared *
                 (-768 + uSquared * (320.0 - 175.0 * uSquared)));
            double B = (uSquared / 1024.0) * // (4)
                (256.0 + uSquared *
                 (-128.0 + uSquared * (74.0 - 47.0 * uSquared)));
            double C = (f / 16.0) *
                cosSqAlpha *
                (4.0 + f * (4.0 - 3.0 * cosSqAlpha)); // (10)
            double cos2SMSq = cos2SM * cos2SM;
            deltaSigma = B * sinSigma * // (6)
                (cos2SM + (B / 4.0) *
                 (cosSigma * (-1.0 + 2.0 * cos2SMSq) -
                  (B / 6.0) * cos2SM *
                  (-3.0 + 4.0 * sinSigma * sinSigma) *
                  (-3.0 + 4.0 * cos2SMSq)));

            lambda = L +
                (1.0 - C) * f * sinAlpha *
                (sigma + C * sinSigma *
                 (cos2SM + C * cosSigma *
                  (-1.0 + 2.0 * cos2SM * cos2SM))); // (11)

            double delta = (lambda - lambdaOrig) / lambda;
            if (Math.abs(delta) < 1.0e-12) {
                break;
            }
        }

        float distance = (float) (b * A * (sigma - deltaSigma));
        results[0] = distance;
        if (results.length > 1) {
            float initialBearing = (float) Math.atan2(cosU2 * sinLambda,
                cosU1 * sinU2 - sinU1 * cosU2 * cosLambda);
            initialBearing *= 180.0 / Math.PI;
            results[1] = initialBearing;
            if (results.length > 2) {
                float finalBearing = (float) Math.atan2(cosU1 * sinLambda,
                    -sinU1 * cosU2 + cosU1 * sinU2 * cosLambda);
                finalBearing *= 180.0 / Math.PI;
                results[2] = finalBearing;
            }
        }
    }

Answer 4

google maps api中的geometry library提供了算法，您可以在source code中找到它。

我不确定谷歌地图是否使用相同的算法。

算法很简单：

function toRadians(deg){
    return deg * (Math.PI / 180);
}

function getDistance(from, to) {
    var c = toRadians(from.lat()),
        d = toRadians(to.lat());
    return 2 * Math.asin(Math.sqrt(Math.pow(Math.sin((c - d) / 2), 2) + Math.cos(c) * Math.cos(d) * Math.pow(Math.sin((toRadians(from.lng()) - toRadians(to.lng())) / 2), 2))) * 6378137;

}

这两行代码会产生相同的结果：

console.log(google.maps.geometry.spherical.computeDistanceBetween(new google.maps.LatLng(39.915, 116.404), new google.maps.LatLng(38.8871, 113.3113)));

console.log(getDistance(new google.maps.LatLng(39.915, 116.404), new google.maps.LatLng(38.8871, 113.3113)));

Answer 5

Google地图正在使用Dijkstra的最短路径算法。它计算成对的元素或所谓的节点之间的连接。节点之间的连接称为边。每个边缘都有一个权重。一条边的权重可以代表距离，时间或任何对其连接的节点对之间的“连接”建模的对象。这些权重对于Dijkstra的算法至关重要。这样，您可以找到节点之间的最短路径。特别是，您可以找到从一个节点（称为“源节点”）到所有其他节点的最短路径，从而生成最短路径树。

Answer 6

Google 地图使用了一些非常复杂的算法。它可能是任何启发式，例如 A*；但是，它绝对不是 Dijkstra 算法。我的发现；

1] 很多时候它显示流量较少的路径，随着时间的推移而变化，但 Dijkstra 算法在所有情况下都会给出一条路径。

2] 我和我的朋友们正在参观某个地方；我们都同时启动了谷歌地图。如果谷歌地图给出了最佳最短路径，那么我们的地图一定为我们提供了相同的路径；但它没有发生。这意味着他们没有使用任何精确的算法。

Udacity 数据结构和算法 nanodegree 声称 Google 正在使用类似于 A* 算法的算法；但是，它需要引用。您也可以访问quora discussion

Google地图使用哪种算法来计算2点之间的方向？

6 个答案: