# Measuring the distance between two coordinates in PHP-ThrowExceptions

Exception or error:

Hi I have the need to calculate the distance between two points having the lat and long.

I would like to avoid any call to external API.

I tried to implement the Haversine Formula in PHP:

Here is the code:

``````class CoordDistance
{
public \$lat_a = 0;
public \$lon_a = 0;
public \$lat_b = 0;
public \$lon_b = 0;

public \$measure_unit = 'kilometers';

public \$measure_state = false;

public \$measure = 0;

public \$error = '';

public function DistAB()

{
\$delta_lat = \$this->lat_b - \$this->lat_a ;
\$delta_lon = \$this->lon_b - \$this->lon_a ;

\$alpha    = \$delta_lat/2;
\$beta     = \$delta_lon/2;
\$c        = asin(min(1, sqrt(\$a)));
\$distance = round(\$distance, 4);

\$this->measure = \$distance;

}
}
``````

Testing it with some given points which have public distances I don’t get a reliable result.

I don’t understand if there is an error in the original formula or in my implementation

How to solve:

Not long ago I wrote an example of the haversine formula, and published it on my website:

``````/**
* Calculates the great-circle distance between two points, with
* the Haversine formula.
* @param float \$latitudeFrom Latitude of start point in [deg decimal]
* @param float \$longitudeFrom Longitude of start point in [deg decimal]
* @param float \$latitudeTo Latitude of target point in [deg decimal]
* @param float \$longitudeTo Longitude of target point in [deg decimal]
* @return float Distance between points in [m] (same as earthRadius)
*/
function haversineGreatCircleDistance(
\$latitudeFrom, \$longitudeFrom, \$latitudeTo, \$longitudeTo, \$earthRadius = 6371000)
{
// convert from degrees to radians

\$latDelta = \$latTo - \$latFrom;
\$lonDelta = \$lonTo - \$lonFrom;

\$angle = 2 * asin(sqrt(pow(sin(\$latDelta / 2), 2) +
cos(\$latFrom) * cos(\$latTo) * pow(sin(\$lonDelta / 2), 2)));
}
``````

➽ Note that you get the distance back in the same unit as you pass in with the parameter `\$earthRadius`. The default value is 6371000 meters so the result will be in [m] too. To get the result in miles, you could e.g. pass 3959 miles as `\$earthRadius` and the result would be in [mi]. In my opinion it is a good habit to stick with the SI units, if there is no particular reason to do otherwise.

Edit:

As TreyA correctly pointed out, the Haversine formula has weaknesses with antipodal points because of rounding errors (though it is stable for small distances). To get around them, you could use the Vincenty formula instead.

``````/**
* Calculates the great-circle distance between two points, with
* the Vincenty formula.
* @param float \$latitudeFrom Latitude of start point in [deg decimal]
* @param float \$longitudeFrom Longitude of start point in [deg decimal]
* @param float \$latitudeTo Latitude of target point in [deg decimal]
* @param float \$longitudeTo Longitude of target point in [deg decimal]
* @return float Distance between points in [m] (same as earthRadius)
*/
public static function vincentyGreatCircleDistance(
\$latitudeFrom, \$longitudeFrom, \$latitudeTo, \$longitudeTo, \$earthRadius = 6371000)
{
// convert from degrees to radians

\$lonDelta = \$lonTo - \$lonFrom;
\$a = pow(cos(\$latTo) * sin(\$lonDelta), 2) +
pow(cos(\$latFrom) * sin(\$latTo) - sin(\$latFrom) * cos(\$latTo) * cos(\$lonDelta), 2);
\$b = sin(\$latFrom) * sin(\$latTo) + cos(\$latFrom) * cos(\$latTo) * cos(\$lonDelta);

\$angle = atan2(sqrt(\$a), \$b);
}
``````

I found this code which is giving me reliable results.

``````function distance(\$lat1, \$lon1, \$lat2, \$lon2, \$unit) {

\$theta = \$lon1 - \$lon2;
\$dist = acos(\$dist);
\$miles = \$dist * 60 * 1.1515;
\$unit = strtoupper(\$unit);

if (\$unit == "K") {
return (\$miles * 1.609344);
} else if (\$unit == "N") {
return (\$miles * 0.8684);
} else {
return \$miles;
}
}
``````

results :

``````echo distance(32.9697, -96.80322, 29.46786, -98.53506, "M") . " Miles<br>";
echo distance(32.9697, -96.80322, 29.46786, -98.53506, "K") . " Kilometers<br>";
echo distance(32.9697, -96.80322, 29.46786, -98.53506, "N") . " Nautical Miles<br>";
``````

It’s just addition to @martinstoeckli and @Janith Chinthana answers. For those who curious about which algorithm is fastest i wrote the performance test. Best performance result shows optimized function from codexworld.com:

``````/**
* Optimized algorithm from http://www.codexworld.com
*
* @param float \$latitudeFrom
* @param float \$longitudeFrom
* @param float \$latitudeTo
* @param float \$longitudeTo
*
* @return float [km]
*/
function codexworldGetDistanceOpt(\$latitudeFrom, \$longitudeFrom, \$latitudeTo, \$longitudeTo)
{
//Calculate distance from latitude and longitude
\$theta = \$longitudeFrom - \$longitudeTo;

return acos(\$dist) / \$rad * 60 *  1.853;
}
``````

Here is test results:

``````Test name       Repeats         Result          Performance
codexworld-opt  10000           0.084952 sec    +0.00%
codexworld      10000           0.104127 sec    -22.57%
custom          10000           0.107419 sec    -26.45%
custom2         10000           0.111576 sec    -31.34%
custom1         10000           0.136691 sec    -60.90%
vincenty        10000           0.165881 sec    -95.26%
``````

Here the simple and perfect code for calculating the distance between two latitude and longitude. The following code have been found from here – http://www.codexworld.com/distance-between-two-addresses-google-maps-api-php/

``````\$latitudeFrom = '22.574864';
\$longitudeFrom = '88.437915';

\$latitudeTo = '22.568662';
\$longitudeTo = '88.431918';

//Calculate distance from latitude and longitude
\$theta = \$longitudeFrom - \$longitudeTo;
\$dist = acos(\$dist);
\$miles = \$dist * 60 * 1.1515;

\$distance = (\$miles * 1.609344).' km';
``````

For the ones who like shorter and faster(not calling deg2rad()).

``````function circle_distance(\$lat1, \$lon1, \$lat2, \$lon2) {
}
``````

Try this gives awesome results

``````function getDistance(\$point1_lat, \$point1_long, \$point2_lat, \$point2_long, \$unit = 'km', \$decimals = 2) {
// Calculate the distance in degrees

// Convert the distance in degrees to the chosen unit (kilometres, miles or nautical miles)
switch(\$unit) {
case 'km':
\$distance = \$degrees * 111.13384; // 1 degree = 111.13384 km, based on the average diameter of the Earth (12,735 km)
break;
case 'mi':
\$distance = \$degrees * 69.05482; // 1 degree = 69.05482 miles, based on the average diameter of the Earth (7,913.1 miles)
break;
case 'nmi':
\$distance =  \$degrees * 59.97662; // 1 degree = 59.97662 nautic miles, based on the average diameter of the Earth (6,876.3 nautical miles)
}
return round(\$distance, \$decimals);
}
``````

Quite old question, but for those interested in a PHP code that returns the same results as Google Maps, the following does the job:

``````/**
* Computes the distance between two coordinates.
*
* Implementation based on reverse engineering of
*
* @param float \$lat1 Latitude from the first point.
* @param float \$lng1 Longitude from the first point.
* @param float \$lat2 Latitude from the second point.
* @param float \$lng2 Longitude from the second point.
*
* @return float Distance in meters.
*/
function computeDistance(\$lat1, \$lng1, \$lat2, \$lng2, \$radius = 6378137)
{
static \$x = M_PI / 180;
\$lat1 *= \$x; \$lng1 *= \$x;
\$lat2 *= \$x; \$lng2 *= \$x;
\$distance = 2 * asin(sqrt(pow(sin((\$lat1 - \$lat2) / 2), 2) + cos(\$lat1) * cos(\$lat2) * pow(sin((\$lng1 - \$lng2) / 2), 2)));

}
``````

I’ve tested with various coordinates and it works perfectly.

I think it should be faster then some alternatives too. But didn’t tested that.

Hint: Google Maps uses 6378137 as Earth radius. So using it with other algorithms might work as well.

For exact values do it like that:

``````public function DistAB()
{
\$delta_lat = \$this->lat_b - \$this->lat_a ;
\$delta_lon = \$this->lon_b - \$this->lon_a ;

\$a = pow(sin(\$delta_lat/2), 2);
\$c = 2 * atan2(sqrt(\$a), sqrt(1-\$a));

\$distance = 2 * \$earth_radius * \$c;
\$distance = round(\$distance, 4);

\$this->measure = \$distance;
}
``````

Hmm I think that should do it…

Edit:

For formulars and at least JS-implementations try: http://www.movable-type.co.uk/scripts/latlong.html

Dare me… I forgot to deg2rad all the values in the circle-functions…

Hello here Code For Get Distance and Time Using Two Different Lat and Long

``````\$url ="https://maps.googleapis.com/maps/api/distancematrix/json?units=imperial&origins=16.538048,80.613266&destinations=23.0225,72.5714";

\$ch = curl_init();
// Disable SSL verification

curl_setopt(\$ch, CURLOPT_SSL_VERIFYPEER, false);
// Will return the response, if false it print the response
curl_setopt(\$ch, CURLOPT_RETURNTRANSFER, true);
// Set the url
curl_setopt(\$ch, CURLOPT_URL,\$url);
// Execute
\$result=curl_exec(\$ch);
// Closing
curl_close(\$ch);

\$result_array=json_decode(\$result);
print_r(\$result_array);
``````

You can check Example Below Link get time between two different locations using latitude and longitude in php

Try this function out to calculate distance between to points of latitude and longitude

``````function calculateDistanceBetweenTwoPoints(\$latitudeOne='', \$longitudeOne='', \$latitudeTwo='', \$longitudeTwo='',\$distanceUnit ='',\$round=false,\$decimalPoints='')
{
if (empty(\$decimalPoints))
{
\$decimalPoints = '3';
}
if (empty(\$distanceUnit)) {
\$distanceUnit = 'KM';
}
\$distanceUnit = strtolower(\$distanceUnit);
\$pointDifference = \$longitudeOne - \$longitudeTwo;
\$toAcos = acos(\$toSin);

\$toMiles  =  \$toRad2Deg * 60 * 1.1515;
\$toKilometers = \$toMiles * 1.609344;
\$toNauticalMiles = \$toMiles * 0.8684;
\$toMeters = \$toKilometers * 1000;
\$toFeets = \$toMiles * 5280;
\$toYards = \$toFeets / 3;

switch (strtoupper(\$distanceUnit))
{
case 'ML'://miles
\$toMiles  = (\$round == true ? round(\$toMiles) : round(\$toMiles, \$decimalPoints));
return \$toMiles;
break;
case 'KM'://Kilometers
\$toKilometers  = (\$round == true ? round(\$toKilometers) : round(\$toKilometers, \$decimalPoints));
return \$toKilometers;
break;
case 'MT'://Meters
\$toMeters  = (\$round == true ? round(\$toMeters) : round(\$toMeters, \$decimalPoints));
return \$toMeters;
break;
case 'FT'://feets
\$toFeets  = (\$round == true ? round(\$toFeets) : round(\$toFeets, \$decimalPoints));
return \$toFeets;
break;
case 'YD'://yards
\$toYards  = (\$round == true ? round(\$toYards) : round(\$toYards, \$decimalPoints));
return \$toYards;
break;
case 'NM'://Nautical miles
\$toNauticalMiles  = (\$round == true ? round(\$toNauticalMiles) : round(\$toNauticalMiles, \$decimalPoints));
return \$toNauticalMiles;
break;
}

}
``````

Then use the fucntion as

``````echo calculateDistanceBetweenTwoPoints('11.657740','77.766270','11.074820','77.002160','ML',true,5);
``````

Hope it helps

The multiplier is changed at every coordinate because of the great circle distance theory as written here :

http://en.wikipedia.org/wiki/Great-circle_distance

and you can calculate the nearest value using this formula described here:

http://en.wikipedia.org/wiki/Great-circle_distance#Worked_example

the key is converting each degree – minute – second value to all degree value:

``````N 36°7.2', W 86°40.2'  N = (+) , W = (-), S = (-), E = (+)
referencing the Greenwich meridian and Equator parallel

(phi)     36.12° = 36° + 7.2'/60'

(lambda)  -86.67° = 86° + 40.2'/60'
``````

``````\$my_latitude = "";