# Find Destination (Lat,Lng) Given Distance & Bearing

Here, I will be posting a C# implementation to find a destination (latitude, longitude) given distance and bearing. This will be continuation from my previous post. Just add the method to the skeleton class GLatLng.

```public GLatLng DestinationPoint(double dist, double brng, DistanceType dType)
{
dist = dist / R;
brng = Math.PI * brng / 180;
<p>    double lat2 = Math.Asin(Math.Sin(lat1) * Math.Cos(dist) + Math.Cos(lat1) * Math.Sin(dist) * Math.Cos(brng));
double lon2 = lon1 + Math.Atan2(Math.Sin(brng) * Math.Sin(dist) * Math.Cos(lat1), Math.Cos(dist) - Math.Sin(lat1) * Math.Sin(lat2));
<p>    lon2 = (lon2 + 3 * Math.PI) % (2 * Math.PI) - Math.PI;
<p>    GLatLng newLatLng = new GLatLng(lat2, lon2);
return newLatLng;
} // end DestinationPoint
public GLatLng RhumbDestinationPoint(double dist, double brng, DistanceType dType)
{
double d = dist / R;
double lat2 = lat1 + d * Math.Cos(brng);
double dLat = lat2 - lat1;
double dPhi = Math.Log(Math.Tan(lat2 / 2 + Math.PI / 4) / Math.Tan(lat1 / 2 + Math.PI / 4));
double q = Math.Cos(lat1);
if (dPhi != 0) q = dLat / dPhi;  // E-W line gives dPhi=0
double dLon = d * Math.Sin(brng) / q;
if (Math.Abs(lat2) &gt; Math.PI / 2) lat2 = (lat2 &gt; 0) ? Math.PI - lat2 : -(Math.PI - lat2);
double lon2 = (lon1 + dLon + 3 * Math.PI) % (2 * Math.PI) - Math.PI;
} // end RhumbDestinationPoint
```

# Calculate Distance & Bearing Between Geolocation

Recently, I toyed with “nearby” services based on geolocation. In this post, I will be sharing C# implementation to calculate distance and bearing between geolocation.

```using System;

namespace GMap
{
public enum DistanceType : int
{
Miles = 0,
Kilometers = 1
}

public class GLatLng
{
public const double EarthRadiusInMiles = 3956.0;
public const double EarthRadiusInKilometers = 6367.0;

private double latitude;
private double longitude;

public GLatLng(double latitude, double longitude)
{
this.latitude = latitude;
this.longitude = longitude;
}

public double DegreeToRadian(double angle) { return Math.PI * angle / 180.0; }

public double RadianToDegree(double angle) { return 180.0 * angle / Math.PI; }

public double Latitude
{
get { return this.latitude; }
set { this.latitude = value; }
}
public double Longitude
{
get { return this.longitude; }
set { this.longitude = value; }
}
} // end class GLatLng
}
```

The following is the method to calculate the distance. You can choose the distance type between miles or kilometers. This uses haversine formula which give great-circle distances between two points on a sphere from their longitudes and latitudes.

```public double DistanceTo(double lat, double lng, DistanceType dType)
{
double a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) + Math.Cos(DegreeToRadian(this.latitude)) * Math.Cos(DegreeToRadian(lat)) * Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
double c = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a));
double distance = c * R;

return Math.Round(distance, 2);
} // end DistanceTo
```

The second way to calculate the distance is based on the rhumb line which generally longer than great-circle routes.

```public double RhumbDistanceTo(double lat, double lng, DistanceType dType)
{
double dLat = DegreeToRadian(lat - this.latitude);
double dLon = DegreeToRadian(Math.Abs(lng - this.longitude));

double dPhi = Math.Log(Math.Tan(lat2 / 2 + Math.PI / 4) / Math.Tan(lat1 / 2 + Math.PI / 4));
double q = Math.Cos(lat1);
if (dPhi != 0) q = dLat / dPhi;  // E-W line gives dPhi=0
// if dLon over 180° take shorter rhumb across 180° meridian:
if (dLon > Math.PI) dLon = 2 * Math.PI - dLon;
double dist = Math.Sqrt(dLat * dLat + q * q * dLon * dLon) * R;

return dist;
} // end RhumbDistanceTo
```

Next methods calculate the bearing between geolocation. Similar to distance there are 2 ways to calculate the bearing.

```
public double RhumbBearingTo(double lat, double lng)
{
double dLon = DegreeToRadian(lng - this.longitude);

double dPhi = Math.Log(Math.Tan(lat2 / 2 + Math.PI / 4) / Math.Tan(lat1 / 2 + Math.PI / 4));
if (Math.Abs(dLon) > Math.PI) dLon = (dLon > 0) ? -(2 * Math.PI - dLon) : (2 * Math.PI + dLon);
double brng = Math.Atan2(dLon, dPhi);

return (RadianToDegree(brng) + 360) % 360;
} // end RhumbBearingTo

public double BearingTo(double lat, double lng)
{