使用Google Map和用户定义函数时获得不同的距离

时间:2011-10-08 10:08:43

标签: android

我希望得到两个纬度和经度之间的距离,单位为米/公里。所以我使用以下功能。它给了我与谷歌地图不同的结果。

你能帮我解决我的问题吗?我不明白这是什么问题?

代码

   float[] results = {0};

   android.location.Location.distanceBetween(lat1, lon1, lat2, lon2, results);

当前纬度= 23.012281666666663 当前经度= 72.51798333333333

目标纬度= 23.1120487 目标纬度= 72.5766759

它在Meter中得出此结果= 12579.679,而在谷歌地图中,​​它给出的结果= 17.9 Km

我不明白为什么这两个会给出不同的结果。

3 个答案:

答案 0 :(得分:4)

此图解释了为什么你得到12.5和17.6公里


enter image description here


要计算行驶距离(17.6 km),您需要使用directions API

答案 1 :(得分:1)

您可以使用此 2功能来查找距离

* 注意: *如果你无法正确获得距离,那么尝试将MILLION var设置为1,因为在我的情况下,我将lat-long值乘以1E6,因此必须除以它。

public double calcdist() {
            int MILLION = 1000000;
            int EARTH_RADIUS_KM = 6371;

            double lat1 = la1 / MILLION;
            double lon1 = lo1 / MILLION;
            double lat2 = la2 / MILLION;
            double lon2 = lo2 / MILLION;

            double lat1Rad = Math.toRadians(lat1);
            double lat2Rad = Math.toRadians(lat2);
            double deltaLonRad = Math.toRadians(lon2 - lon1);

            double dist = Math
                    .acos(Math.sin(lat1Rad) * Math.sin(lat2Rad) + Math.cos(lat1Rad)
                            * Math.cos(lat2Rad) * Math.cos(deltaLonRad))
                    * EARTH_RADIUS_KM;
            return dist;

        }

private float round(float dist, int i) {
        float p1 = (float) Math.pow(10, i);
        dist = dist * p1;
        float tmp = Math.round(dist);
        return (float) tmp / p1;
    }

然后将它们用作

float tempdist = (float) calcdist();
dist = round(tempdist, 2);

答案 2 :(得分:0)

嘿,我在这里找到了一个源代码,而人们说它会返回正确的公路距离。我没试过,但你可以尝试告诉我它是否真的有效。 的 GPSSample.java

我不知道你是如何传递Lat - Long值的。请尝试一下这整个示例代码。

并在android.location.Location.java中为此编写的代码如下所示..如果您希望可以直接在您的应用中使用此代码。

private static void computeDistanceAndBearing(double lat1,
                    double lon1, double lat2, double lon2, float[] results) {
                // Based on http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf
                // using the "Inverse Formula" (section 4)

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