Algorithm for offsetting latitude/longitude by some amount of meters

Question

I'm looking for an algorithm which when given a latitude and longitude pair and a vector translation in meters in Cartesian coordinates (x,y) would give me a new coordinate.

Sort of like a reverse Haversine. I could also work with a distance and a heading transformation, but this would probably be slower and not as accurate. Ideally, the algorithm should be fast as I'm working on an embedded system. Accuracy is not critical, within 10 meters would be good.

Answer 1

If your displacements aren't too great (less than a few kilometers) and you're not right at the poles, use the quick and dirty estimate that 111,111 meters (111.111 km) in the y direction is 1 degree (of latitude) and 111,111 * cos(latitude) meters in the x direction is 1 degree (of longitude).

Answer 2

As Liedman says in his answer Williams’s aviation formulas are an invaluable source, and to keep the accuracy within 10 meters for displacements up to 1 km you’ll probably need to use the more complex of these.

But if you’re willing to accept errors above 10m for points offset more than approx 200m you may use a simplified flat earth calculation. I think the errors still will be less than 50m for offsets up to 1km.

 //Position, decimal degrees
 lat = 51.0
 lon = 0.0

 //Earth’s radius, sphere
 R=6378137

 //offsets in meters
 dn = 100
 de = 100

 //Coordinate offsets in radians
 dLat = dn/R
 dLon = de/(R*Cos(Pi*lat/180))

 //OffsetPosition, decimal degrees
 latO = lat + dLat * 180/Pi
 lonO = lon + dLon * 180/Pi 

This should return:

 latO = 51,00089832
 lonO = 0,001427437

Answer 3

I find that Aviation Formulary, here is great for these types of formulas and algorithms. For your problem, check out the "lat/long given radial and distance":here

Note that this algorithm might be a bit too complex for your use, if you want to keep use of trigonometry functions low, etc.

Answer 4

I created a simple custom map on Google Maps that illustrates the estimation algorithm mentioned by the accepted answer (1/111111 == one meter). Feel free to see and play with it here:

https://drive.google.com/open?id=1XWlZ8BM00PIZ4qk43DieoJjcXjK4z7xe&usp=sharing

To give more context - this map shows the coordinates 0,0 and then shows two more pins which are 1 meter north and 1 meter east of 0,0.

Answer 5

It might make sense to project the point first. You could make something like this pseudo-code:

falt_coordinate = latlon_to_utm(original_koordinate)
new_flat_coordinate = flat_coordinate + (x,y)
result_coordinate = utm_to_latlon(new_flat_coordinate)

where (x,y) is the desired offset.

You don't need to use utm, any flat coordinate system, that makes sense in your area will do.

What software are you working with?

Answer 6

Here is the Python code for @whuber's answer

from math import cos, radians

def meters_to_lat_lon_displacement(m, origin_latitude):
    lat = m / 111111
    lon = m / (111111 * cos(radians(origin_latitude)))
    return lat, lon

Here is the R code:

deg2rad = function(deg) {(deg * pi) / (180)}

meters_to_lat_lon_displacement = function(m, origin_latitude){
  lat = m / 111111
  lon = m / (111111 * cos((deg2rad(origin_latitude))))
  return(list(lat=lat,lon=lon))
}

Answer 7

Here is Swift version used on kodisha answer on SO:

extension CLLocationCoordinate2D {
  
  func earthRadius() -> CLLocationDistance {
    let earthRadiusInMetersAtSeaLevel = 6378137.0
    let earthRadiusInMetersAtPole = 6356752.314
    
    let r1 = earthRadiusInMetersAtSeaLevel
    let r2 = earthRadiusInMetersAtPole
    let beta = latitude
    
    let earthRadiuseAtGivenLatitude = (
      ( pow(pow(r1, 2) * cos(beta), 2) + pow(pow(r2, 2) * sin(beta), 2) ) /
        ( pow(r1 * cos(beta), 2) + pow(r2 * sin(beta), 2) )
    )
    .squareRoot()
    
    return earthRadiuseAtGivenLatitude
  }
  
  func locationByAdding(
    distance: CLLocationDistance,
    bearing: CLLocationDegrees
  ) -> CLLocationCoordinate2D {
    let latitude = self.latitude
    let longitude = self.longitude
    
    let earthRadiusInMeters = self.earthRadius()
    let brng = bearing.degreesToRadians
    var lat = latitude.degreesToRadians
    var lon = longitude.degreesToRadians
    
    lat = asin(
      sin(lat) * cos(distance / earthRadiusInMeters) +
        cos(lat) * sin(distance / earthRadiusInMeters) * cos(brng)
    )
    lon += atan2(
      sin(brng) * sin(distance / earthRadiusInMeters) * cos(lat),
      cos(distance / earthRadiusInMeters) - sin(lat) * sin(lat)
    )
    
    let newCoordinate = CLLocationCoordinate2D(
      latitude: lat.radiansToDegrees,
      longitude: lon.radiansToDegrees
    )
    
    return newCoordinate
  }
}

extension FloatingPoint {
  var degreesToRadians: Self { self * .pi / 180 }
  var radiansToDegrees: Self { self * 180 / .pi }
}

Answer 8

If your displacements aren't too great (less than a few kilometers) and you're not right at the poles, use the quick and dirty estimate that 111,111 meters (111.111 km) in the y direction is 1 degree (of latitude) and 111,111 * cos(latitude) meters in the x direction is 1 degree (of longitude).

This is just an estimate and is not good enough as it starts changing as we go towards the poles (not just at the poles).

The more accurate formula is as below

# Meters per degree at given latitude
meters_per_degree_lat = (111132.92 - 559.82 * np.cos(2 * lat0_rad) +
                             1.175 * np.cos(4 * lat0_rad) - 0.0023 * np.cos(6 * lat0_rad))

meters_per_degree_lon = (111412.84 * np.cos(lat0_rad) -
                            93.5 * np.cos(3 * lat0_rad) + 0.118 * np.cos(5 * lat0_rad))

Reference

Length of Degree @ https://en.wikipedia.org/wiki/Geographic_coordinate_system

whubers more detailed answer @ https://gis.stackexchange.com/a/75535/61719

Answer 9

Vincenty's direct formula should do the job.