Gettting Different Distance When Using the Google Map and User defined Function

Question

I want to get the Distance between two latitude and longitude in meter / km . So i am using the below function . It gives me the different result than the google Map.

Can you help me to solve my problem ? i dont understand What is the Problem ?

Code

   float[] results = {0};

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

Current Latitude = 23.012281666666663 Current Longitude = 72.51798333333333

Destination Latitude = 23.1120487 Destination Latitude = 72.5766759

It gives this Result = 12579.679 in Meter, while in google map it gives this result = 17.9 Km

I do not understand why this two gives the different result.

Answer 1

This diagram explains why you get 12.5 and 17.6 kms

---

---

To calculate the driving distance (17.6 km) , you need to use the directions API

Answer 2

You can use this 2 function to find the distance

*NOTE:*If you cant get the distance correctly then try setting the MILLION var to 1 cause in my case i have multiplied the lat-long values with 1E6 so have to divide with it.

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;

        }

and

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

then use them as

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

Answer 3

Hey I found one source code here and People arround says it will return the correct distance travelling by road. I haven't try this but you may try and tell me if it really works. GPSSample.java

I dont know how you are passing the Lat - Long Values..Please Try this whole sample code once.

and the code written in android.location.Location.java for this is as below..if you wish can directly use this in your app.

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