Calculating correct longitude when it's over |180|?

Question

I'm trying to develop a "formula" to correct the lat-lng values.

I'm using vue-leaflet but when you pan outside the "first" world you get big numbers. Over +180 or under -180.

For example: when I pan to America to the right (east direction), I get as lng 215. In my mind, I would just correct it with 215-360=-145

The same is for when I pan to east russia to the left (west direction) and I get for example -222. Now I need to calculate -222+360=138

However, since the world is indefinite the user could pan to the 8th world and I had to adjust the values.

Is it possible to calculate the right longitude? (and another requirement is when the user is in the first world, 24 lng should still be 24 lng.

Answer 1

An answer that avoids conditionals and function calls:

longitude = (longitude % 360 + 540) % 360 - 180

I wrote a quick microbenchmark at https://jsperf.com/longitude-normalisation and the conditional code seems to be faster (in Chrome on my machine) for 'reasonable' ranges of input values. In general you probably shouldn't be worrying in advance about performance in small calculations like this, giving more weight to readability and consistency with the rest of your codebase.

Probably more important in this case is the question of whether your code could ever come across extreme input values (1e10, Infinity etc.). If so, the looping implementation could end up running really slowly or silently hanging your program. This might occur with calculations performed near the poles, e.g. trying to pan east or west by some distance (rather than angle) from a pole could easily result in an infinite longitude.

Answer 2

You need to repeatedly add (or subtract) 360 to your value until it lies in the range of -180 - 180. So usually a pair of loops like:

lon = -187;
while(lon < -180){
  lon +=360;
}
while (lon > 180){
  lon -= 360;
}

Answer 3

One-liner:

normalized = remainder(longitude, 360);

Explanation: You want to know what remains after you disregard full rotations (360°).

This process is called normalizing.

Example (cpp.sh)

Answer 4

If the programming language you're using supports the % (mod) operator on floating point numbers (like Python and Ruby), I'd recommend using that. Otherwise, some other languages (like C and C++) allow you to use fmod().

(Whichever mod operator you use, make sure ahead of time that it will do mod operations on floating-point numbers, and that it'll always give you non-negative answers. Otherwise you'll get a nasty surprise later when many of your lat/lon points are not correct.)

Use it like this:

# Put the longitude in the range of [0,360):
longitude %= 360

# Put the longitude in the range of [-180,180):
if longitude >= 180:
    longitude -= 360

If you'd prefer to do it all in one line:

# Put the longitude in the range of [-180,180):
longitude = (longitude + 180) % 360 - 180

These approaches have no loops, so they'll normalize longitude values without needing to repeatedly add or subtract, no matter how many times your observation has circled around the earth.

Edit:

Hmmm... I just noticed that Javascript doesn't seem to handle % with negative values like I thought it would.

In that case, try this one-liner:

longitude = (longitude + 36180) % 360 - 180

The 36180 we're adding is 36,000 + 180. The 36,000 is to move a negative value into the positive domain, and the 180 is to shift it over so that when it is modded by 360, it'll be in the range of [0,360). The - 180 part shifts it back to the range of [-180,180).

Here's another one-liner, one that doesn't rely on 36,000 being big enough:

longitude = (longitude % 360 + 360 + 180) % 360 - 180

The longitude % 360 + 360 part will ensure the value stays in the positive domain when it's later modded by 360. The + 180 part shifts it over so that when it later gets 180 subtracted from it (with - 180), it'll be in the desired range of [-180,180).

Answer 5

Another option: longitude = atan2(cos(long), sin(long))