Skip navigation links
NASA World Wind
gov.nasa.worldwind.geom

## Class LatLon

• Direct Known Subclasses:
Position, SurfacePolygon.Vertex

```public class LatLon
extends Object```
Represents a point on the two-dimensional surface of a globe. Latitude is the degrees North and ranges between [-90, 90], while longitude refers to degrees East, and ranges between (-180, 180].

Instances of `LatLon` are immutable.

• ### Field Summary

Fields
Modifier and Type Field and Description
`Angle` `latitude`
`Angle` `longitude`
`protected static double` `NEAR_ZERO_THRESHOLD`
A near zero threshold used in some of the rhumb line calculations where floating point calculations cause errors.
`static LatLon` `ZERO`
• ### Constructor Summary

Constructors
Constructor and Description
```LatLon(Angle latitude, Angle longitude)```
Constructs a new `LatLon` from two angles.
`LatLon(LatLon latLon)`
• ### Method Summary

All Methods
Modifier and Type Method and Description
`LatLon` `add(LatLon that)`
`LatLon` `add(Position that)`
`double[]` `asDegreesArray()`
Returns an array of this object's latitude and longitude in degrees.
`double[]` `asRadiansArray()`
Returns an array of this object's latitude and longitude in radians.
`static List<LatLon>` ```computeShiftedLocations(Globe globe, LatLon oldLocation, LatLon newLocation, Iterable<? extends LatLon> locations)```
`static List<LatLon>` ```computeShiftedLocations(Position oldLocation, Position newLocation, Iterable<? extends LatLon> locations)```
Computes a new set of locations translated from a specified location to a new location.
`static List<LatLon>` ```cutLocationsAlongDateLine(Iterable<? extends LatLon> locations, String pole, Globe globe)```
Divides a sequence of geographic locations that encloses a pole along the international dateline.
`static double` ```ellipsoidalDistance(LatLon p1, LatLon p2, double equatorialRadius, double polarRadius)```
Computes the distance between two points on an ellipsoid iteratively.
`static Angle` ```ellipsoidalForwardAzimuth(LatLon p1, LatLon p2, double equatorialRadius, double polarRadius)```
Compute the forward azimuth between two positions
`static boolean` ```equals(LatLon a, LatLon b)```
`boolean` `equals(Object o)`
`static LatLon` ```fromDegrees(double latitude, double longitude)```
Factory method for obtaining a new `LatLon` from two angles expressed in degrees.
`static LatLon` ```fromRadians(double latitude, double longitude)```
Factor method for obtaining a new `LatLon` from two angles expressed in radians.
`static Angle` ```getAverageDistance(Globe globe, LatLon center, Iterable<? extends LatLon> locations)```
Computes the average distance between a specified center point and a list of locations.
`static Angle` `getAverageDistance(Iterable<? extends LatLon> locations)`
Compute the average rhumb distance between locations.
`static LatLon` ```getCenter(Globe globe, Iterable<? extends LatLon> locations)```
Computes the average location of a specified list of locations.
`static LatLon` `getCenter(Iterable<? extends LatLon> locations)`
Computes the average location of a specified list of locations.
`Angle` `getLatitude()`
Obtains the latitude of this `LatLon`.
`Angle` `getLongitude()`
Obtains the longitude of this `LatLon`.
`static LatLon[]` `greatCircleArcExtremeLocations(Iterable<? extends LatLon> locations)`
Returns two locations with the most extreme latitudes on the sequence of great circle arcs defined by each pair of locations in the specified iterable.
`static LatLon[]` ```greatCircleArcExtremeLocations(LatLon begin, LatLon end)```
Returns two locations with the most extreme latitudes on the great circle arc defined by, and limited to, the two locations.
`static Angle` ```greatCircleAzimuth(LatLon p1, LatLon p2)```
Computes the azimuth angle (clockwise from North) that points from the first location to the second location.
`static Angle` ```greatCircleDistance(LatLon p1, LatLon p2)```
Computes the great circle angular distance between two locations.
`static LatLon` ```greatCircleEndPosition(LatLon p, Angle greatCircleAzimuth, Angle pathLength)```
Computes the location on a great circle arc with the given starting location, azimuth, and arc distance.
`static LatLon` ```greatCircleEndPosition(LatLon p, double greatCircleAzimuthRadians, double pathLengthRadians)```
Computes the location on a great circle arc with the given starting location, azimuth, and arc distance.
`static LatLon[]` ```greatCircleExtremeLocations(LatLon location, Angle azimuth)```
Returns two locations with the most extreme latitudes on the great circle with the given starting location and azimuth.
`int` `hashCode()`
`static LatLon` ```interpolate(double amount, LatLon value1, LatLon value2)```
Returns the linear interpolation of `value1` and `value2`, treating the geographic locations as simple 2D coordinate pairs.
`static LatLon` ```interpolate(String pathType, double amount, LatLon value1, LatLon value2)```
Returns an interpolated location between `value1` and `value2`, according to the specified path type.
`static LatLon` ```interpolateGreatCircle(double amount, LatLon value1, LatLon value2)```
Returns the an interpolated location along the great-arc between `value1` and `value2`.
`static LatLon` ```interpolateRhumb(double amount, LatLon value1, LatLon value2)```
Returns the an interpolated location along the rhumb line between `value1` and `value2`.
`static LatLon` ```intersectionWithMeridian(LatLon p1, LatLon p2, Angle meridian)```
Determine where a line between two locations crosses a given meridian.
`static LatLon` ```intersectionWithMeridian(LatLon p1, LatLon p2, Angle meridian, Globe globe)```
Determine where a line between two locations crosses a given meridian.
`static Angle` ```linearAzimuth(LatLon p1, LatLon p2)```
Computes the azimuth angle (clockwise from North) of a linear path two locations.
`static Angle` ```linearDistance(LatLon p1, LatLon p2)```
Computes the length of the linear path between two locations.
`static LatLon` ```linearEndPosition(LatLon p, Angle linearAzimuth, Angle pathLength)```
Computes the location on a linear path given a starting location, azimuth, and arc distance along the line.
`static String` `locationsContainPole(Iterable<? extends LatLon> locations)`
Determines if a sequence of geographic locations encloses either the North or South pole.
`static boolean` `locationsCrossDateLine(Iterable<? extends LatLon> locations)`
`static boolean` ```locationsCrossDateline(LatLon p1, LatLon p2)```
`static List<LatLon>` `makeDatelineCrossingLocationsPositive(Iterable<? extends LatLon> locations)`
Transform the negative longitudes of a dateline-spanning location list to positive values that maintain the relationship with the other locations in the list.
`LatLon` `parseLatLon(String latLonString)`
Parses a string containing latitude and longitude coordinates in either Degrees-minutes-seconds or decimal degrees.
`static Angle` ```pathDistance(String pathType, LatLon value1, LatLon value2)```
Returns the length of the path between `value1` and `value2`, according to the specified path type.
`static List<List<LatLon>>` `repeatLocationsAroundDateline(Iterable<? extends LatLon> locations)`
Returns a list containing two copies of a sequence of geographic locations that cross the dateline: one that extends across the -180 longitude boundary and one that extends across the +180 longitude boundary.
`static Angle` ```rhumbAzimuth(LatLon p1, LatLon p2)```
Computes the azimuth angle (clockwise from North) of a rhumb line (a line of constant heading) between two locations.
`static Angle` ```rhumbDistance(LatLon p1, LatLon p2)```
Computes the length of the rhumb line between two locations.
`static LatLon` ```rhumbEndPosition(LatLon p, Angle rhumbAzimuth, Angle pathLength)```
Computes the location on a rhumb line with the given starting location, rhumb azimuth, and arc distance along the line.
`static LatLon` ```rhumbEndPosition(LatLon p, double rhumbAzimuthRadians, double pathLengthRadians)```
Computes the location on a rhumb line with the given starting location, rhumb azimuth, and arc distance along the line.
`LatLon` `subtract(LatLon that)`
`LatLon` `subtract(Position that)`
`String` `toString()`
• ### Methods inherited from class java.lang.Object

`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`
• ### Field Detail

• #### latitude

`public final Angle latitude`
• #### longitude

`public final Angle longitude`
• #### NEAR_ZERO_THRESHOLD

`protected static final double NEAR_ZERO_THRESHOLD`
A near zero threshold used in some of the rhumb line calculations where floating point calculations cause errors.
See Also:
Constant Field Values
• #### ZERO

`public static final LatLon ZERO`
• ### Constructor Detail

• #### LatLon

```public LatLon(Angle latitude,
Angle longitude)```
Constructs a new `LatLon` from two angles. Neither angle may be null.
Parameters:
`latitude` - latitude
`longitude` - longitude
Throws:
`IllegalArgumentException` - if `latitude` or `longitude` is null
• #### LatLon

`public LatLon(LatLon latLon)`
• ### Method Detail

• #### add

`public LatLon add(LatLon that)`
• #### add

`public LatLon add(Position that)`
• #### asDegreesArray

`public double[] asDegreesArray()`
Returns an array of this object's latitude and longitude in degrees.
Returns:
the array of latitude and longitude, arranged in that order.
• #### asRadiansArray

`public double[] asRadiansArray()`
Returns an array of this object's latitude and longitude in radians.
Returns:
the array of latitude and longitude, arranged in that order.
• #### computeShiftedLocations

```public static List<LatLon> computeShiftedLocations(Globe globe,
LatLon oldLocation,
LatLon newLocation,
Iterable<? extends LatLon> locations)```
• #### computeShiftedLocations

```public static List<LatLon> computeShiftedLocations(Position oldLocation,
Position newLocation,
Iterable<? extends LatLon> locations)```
Computes a new set of locations translated from a specified location to a new location.
Parameters:
`oldLocation` - the original reference location.
`newLocation` - the new reference location.
`locations` - the locations to translate.
Returns:
the translated locations, or null if the locations could not be translated.
Throws:
`IllegalArgumentException` - if any argument is null.
• #### cutLocationsAlongDateLine

```public static List<LatLon> cutLocationsAlongDateLine(Iterable<? extends LatLon> locations,
String pole,
Globe globe)```
Divides a sequence of geographic locations that encloses a pole along the international dateline. This method determines where the locations cross the dateline, and inserts locations to the pole, and then back to the intersection position. This allows the shape to be "unrolled" when projected in a lat-lon projection.
Parameters:
`locations` - Locations to cut at dateline. This list is not modified.
`pole` - Pole contained by locations, either AVKey.NORTH or AVKey.SOUTH.
`globe` - Current globe, or null to treat geographic coordinates as linear for the purpose of computing the dateline intersection.
Returns:
New location list with locations added to correctly handle dateline intersection.
Throws:
`IllegalArgumentException` - if the locations are null or if the pole is null.
• #### ellipsoidalDistance

```public static double ellipsoidalDistance(LatLon p1,
LatLon p2,
double equatorialRadius,
double polarRadius)```
Computes the distance between two points on an ellipsoid iteratively.

NOTE: This method was copied from the UniData NetCDF Java library. http://www.unidata.ucar.edu/software/netcdf-java/

Algorithm from U.S. National Geodetic Survey, FORTRAN program "inverse," subroutine "INVER1," by L. PFEIFER and JOHN G. GERGEN. See http://www.ngs.noaa.gov/TOOLS/Inv_Fwd/Inv_Fwd.html

Original documentation: SOLUTION OF THE GEODETIC INVERSE PROBLEM AFTER T.VINCENTY MODIFIED RAINSFORD'S METHOD WITH HELMERT'S ELLIPTICAL TERMS EFFECTIVE IN ANY AZIMUTH AND AT ANY DISTANCE SHORT OF ANTIPODAL STANDPOINT/FOREPOINT MUST NOT BE THE GEOGRAPHIC POLE

Requires close to 1.4 E-5 seconds wall clock time per call on a 550 MHz Pentium with Linux 7.2.

The algorithm used is iterative and will iterate only 10 times if it does not converge.

Parameters:
`p1` - first position
`p2` - second position
`equatorialRadius` - the equatorial radius of the globe in meters
`polarRadius` - the polar radius of the globe in meters
Returns:
distance in meters between the two points
• #### ellipsoidalForwardAzimuth

```public static Angle ellipsoidalForwardAzimuth(LatLon p1,
LatLon p2,
double equatorialRadius,
double polarRadius)```
Compute the forward azimuth between two positions
Parameters:
`p1` - first position
`p2` - second position
`equatorialRadius` - the equatorial radius of the globe in meters
`polarRadius` - the polar radius of the globe in meters
Returns:
the azimuth
• #### equals

```public static boolean equals(LatLon a,
LatLon b)```
• #### equals

`public boolean equals(Object o)`
Overrides:
`equals` in class `Object`
• #### fromDegrees

```public static LatLon fromDegrees(double latitude,
double longitude)```
Factory method for obtaining a new `LatLon` from two angles expressed in degrees.
Parameters:
`latitude` - in degrees
`longitude` - in degrees
Returns:
a new `LatLon` from the given angles, which are expressed as degrees
• #### fromRadians

```public static LatLon fromRadians(double latitude,
double longitude)```
Factor method for obtaining a new `LatLon` from two angles expressed in radians.
Parameters:
`latitude` - in radians
`longitude` - in radians
Returns:
a new `LatLon` from the given angles, which are expressed as radians
• #### getAverageDistance

```public static Angle getAverageDistance(Globe globe,
LatLon center,
Iterable<? extends LatLon> locations)```
Computes the average distance between a specified center point and a list of locations.
Parameters:
`globe` - the globe to use for the computations.
`center` - the center point.
`locations` - the locations.
Returns:
the average distance.
Throws:
`IllegalArgumentException` - if any of the specified globe, center or locations are null.
• #### getAverageDistance

`public static Angle getAverageDistance(Iterable<? extends LatLon> locations)`
Compute the average rhumb distance between locations.
Parameters:
`locations` - Locations of which to compute average.
Returns:
Average rhumb line distance between locations, as an angular distance.
• #### getCenter

```public static LatLon getCenter(Globe globe,
Iterable<? extends LatLon> locations)```
Computes the average location of a specified list of locations.
Parameters:
`globe` - the globe to use for the computations.
`locations` - the locations.
Returns:
the average of the locations.
Throws:
`IllegalArgumentException` - if either the specified globe or locations is null.
• #### getCenter

`public static LatLon getCenter(Iterable<? extends LatLon> locations)`
Computes the average location of a specified list of locations.
Parameters:
`locations` - the locations.
Returns:
the average of the locations.
Throws:
`IllegalArgumentException` - if the specified locations is null.
• #### getLatitude

`public final Angle getLatitude()`
Obtains the latitude of this `LatLon`.
Returns:
this `LatLon`'s latitude
• #### getLongitude

`public final Angle getLongitude()`
Obtains the longitude of this `LatLon`.
Returns:
this `LatLon`'s longitude
• #### greatCircleArcExtremeLocations

`public static LatLon[] greatCircleArcExtremeLocations(Iterable<? extends LatLon> locations)`
Returns two locations with the most extreme latitudes on the sequence of great circle arcs defined by each pair of locations in the specified iterable. This method uses a spherical model, not elliptical.
Parameters:
`locations` - the pairs of locations defining a sequence of great circle arcs.
Returns:
two locations with the most extreme latitudes on the great circle arcs.
Throws:
`IllegalArgumentException` - if `locations` is null.
• #### greatCircleArcExtremeLocations

```public static LatLon[] greatCircleArcExtremeLocations(LatLon begin,
LatLon end)```
Returns two locations with the most extreme latitudes on the great circle arc defined by, and limited to, the two locations. This method uses a spherical model, not elliptical.
Parameters:
`begin` - beginning location on the great circle arc.
`end` - ending location on the great circle arc.
Returns:
two locations with the most extreme latitudes on the great circle arc.
Throws:
`IllegalArgumentException` - if either `begin` or `end` are null.
• #### greatCircleAzimuth

```public static Angle greatCircleAzimuth(LatLon p1,
LatLon p2)```
Computes the azimuth angle (clockwise from North) that points from the first location to the second location. This angle can be used as the starting azimuth for a great circle arc that begins at the first location, and passes through the second location. This method uses a spherical model, not elliptical.
Parameters:
`p1` - LatLon of the first location
`p2` - LatLon of the second location
Returns:
Angle that points from the first location to the second location.
• #### greatCircleDistance

```public static Angle greatCircleDistance(LatLon p1,
LatLon p2)```
Computes the great circle angular distance between two locations. The return value gives the distance as the angle between the two positions on the pi radius circle. In radians, this angle is also the arc length of the segment between the two positions on that circle. To compute a distance in meters from this value, multiply it by the radius of the globe. This method uses a spherical model, not elliptical.
Parameters:
`p1` - LatLon of the first location
`p2` - LatLon of the second location
Returns:
the angular distance between the two locations. In radians, this value is the arc length on the radius pi circle.
• #### greatCircleEndPosition

```public static LatLon greatCircleEndPosition(LatLon p,
Angle greatCircleAzimuth,
Angle pathLength)```
Computes the location on a great circle arc with the given starting location, azimuth, and arc distance. This method uses a spherical model, not elliptical.
Parameters:
`p` - LatLon of the starting location
`greatCircleAzimuth` - great circle azimuth angle (clockwise from North)
`pathLength` - arc distance to travel
Returns:
LatLon location on the great circle arc.
• #### greatCircleEndPosition

```public static LatLon greatCircleEndPosition(LatLon p,
double greatCircleAzimuthRadians,
double pathLengthRadians)```
Computes the location on a great circle arc with the given starting location, azimuth, and arc distance. This method uses a spherical model, not elliptical.
Parameters:
`p` - LatLon of the starting location
`greatCircleAzimuthRadians` - great circle azimuth angle (clockwise from North), in radians
`pathLengthRadians` - arc distance to travel, in radians
Returns:
LatLon location on the great circle arc.
• #### greatCircleExtremeLocations

```public static LatLon[] greatCircleExtremeLocations(LatLon location,
Angle azimuth)```
Returns two locations with the most extreme latitudes on the great circle with the given starting location and azimuth. This method uses a spherical model, not elliptical.
Parameters:
`location` - location on the great circle.
`azimuth` - great circle azimuth angle (clockwise from North).
Returns:
two locations where the great circle has its extreme latitudes.
Throws:
`IllegalArgumentException` - if either `location` or `azimuth` are null.
• #### hashCode

`public int hashCode()`
Overrides:
`hashCode` in class `Object`
• #### interpolate

```public static LatLon interpolate(double amount,
LatLon value1,
LatLon value2)```
Returns the linear interpolation of `value1` and `value2`, treating the geographic locations as simple 2D coordinate pairs.
Parameters:
`amount` - the interpolation factor
`value1` - the first location.
`value2` - the second location.
Returns:
the linear interpolation of `value1` and `value2`.
Throws:
`IllegalArgumentException` - if either location is null.
• #### interpolate

```public static LatLon interpolate(String pathType,
double amount,
LatLon value1,
LatLon value2)```
Returns an interpolated location between `value1` and `value2`, according to the specified path type. If the path type is `AVKey.GREAT_CIRCLE` this returns an interpolated value on the great arc that spans the two locations (see `interpolateGreatCircle(double, LatLon, LatLon)`). If the path type is `AVKey.RHUMB_LINE` or `AVKey.LOXODROME` this returns an interpolated value on the rhumb line that spans the two locations (see `interpolateRhumb(double, LatLon, LatLon)`. Otherwise, this returns the linear interpolation of the two locations (see `interpolate(double, LatLon, LatLon)`.
Parameters:
`pathType` - the path type used to interpolate between geographic locations.
`amount` - the interpolation factor
`value1` - the first location.
`value2` - the second location.
Returns:
an interpolated location between `value1` and `value2`, according to the specified path type.
Throws:
`IllegalArgumentException` - if the path type or either location is null.
• #### interpolateGreatCircle

```public static LatLon interpolateGreatCircle(double amount,
LatLon value1,
LatLon value2)```
Returns the an interpolated location along the great-arc between `value1` and `value2`. The interpolation factor `amount` defines the weight given to each value, and is clamped to the range [0, 1]. If `a` is 0 or less, this returns `value1`. If `amount` is 1 or more, this returns `value2`. Otherwise, this returns the location on the great-arc between `value1` and `value2` corresponding to the specified interpolation factor. This method uses a spherical model, not elliptical.
Parameters:
`amount` - the interpolation factor
`value1` - the first location.
`value2` - the second location.
Returns:
an interpolated location along the great-arc between `value1` and `value2`.
Throws:
`IllegalArgumentException` - if either location is null.
• #### interpolateRhumb

```public static LatLon interpolateRhumb(double amount,
LatLon value1,
LatLon value2)```
Returns the an interpolated location along the rhumb line between `value1` and `value2`. The interpolation factor `amount` defines the weight given to each value, and is clamped to the range [0, 1]. If `a` is 0 or less, this returns `value1`. If `amount` is 1 or more, this returns `value2`. Otherwise, this returns the location on the rhumb line between `value1` and `value2` corresponding to the specified interpolation factor. This method uses a spherical model, not elliptical.
Parameters:
`amount` - the interpolation factor
`value1` - the first location.
`value2` - the second location.
Returns:
an interpolated location along the rhumb line between `value1` and `value2`
Throws:
`IllegalArgumentException` - if either location is null.
• #### intersectionWithMeridian

```public static LatLon intersectionWithMeridian(LatLon p1,
LatLon p2,
Angle meridian)```
Determine where a line between two locations crosses a given meridian. The intersection test is performed by treating geographic coordinates as linear and computing the intersection of the linear segment with the vertical line indicated by the meridian. This computation correctly handles intersections with either side of the antimeridian.
Parameters:
`p1` - The first location.
`p2` - The second location.
`meridian` - The line of constant longitude to intersect with.
Returns:
The intersection location along the meridian.
Throws:
`IllegalArgumentException` - if either location is null, or if the meridian is null.
• #### intersectionWithMeridian

```public static LatLon intersectionWithMeridian(LatLon p1,
LatLon p2,
Angle meridian,
Globe globe)```
Determine where a line between two locations crosses a given meridian. The intersection test is performed by intersecting a line in Cartesian space between the two positions with a plane through the meridian. Thus, it is most suitable for working with positions that are fairly close together as the calculation does not take into account great circle or rhumb paths.
Parameters:
`p1` - The first location.
`p2` - The second location.
`meridian` - The line of constant longitude to intersect with.
`globe` - Globe used to compute intersection, or null to treat geographic coordinates as linear for the purpose of computing the intersection.
Returns:
The intersection location along the meridian.
Throws:
`IllegalArgumentException` - if either location is null, or if the meridian is null.
• #### linearAzimuth

```public static Angle linearAzimuth(LatLon p1,
LatLon p2)```
Computes the azimuth angle (clockwise from North) of a linear path two locations.
Parameters:
`p1` - LatLon of the first location
`p2` - LatLon of the second location
Returns:
azimuth Angle of a linear path between the two locations.
• #### linearDistance

```public static Angle linearDistance(LatLon p1,
LatLon p2)```
Computes the length of the linear path between two locations. The return value gives the distance as the angular distance between the two positions on the pi radius circle. In radians, this angle is also the arc length of the segment between the two positions on that circle. To compute a distance in meters from this value, multiply it by the radius of the globe.
Parameters:
`p1` - LatLon of the first location
`p2` - LatLon of the second location
Returns:
the arc length of the line between the two locations. In radians, this value is the arc length on the radius pi circle.
• #### linearEndPosition

```public static LatLon linearEndPosition(LatLon p,
Angle linearAzimuth,
Angle pathLength)```
Computes the location on a linear path given a starting location, azimuth, and arc distance along the line. A linear path is determined by treating latitude and longitude as a rectangular grid. This type of path is a straight line in the equidistant cylindrical map projection (also called equirectangular).
Parameters:
`p` - LatLon of the starting location
`linearAzimuth` - azimuth angle (clockwise from North)
`pathLength` - arc distance to travel
Returns:
LatLon location on the line.
• #### locationsContainPole

`public static String locationsContainPole(Iterable<? extends LatLon> locations)`
Determines if a sequence of geographic locations encloses either the North or South pole. The sequence is treated as a closed loop. (If the first and last positions are not equal the loop will be closed for purposes of this computation.)
Parameters:
`locations` - The locations to test.
Returns:
AVKey.NORTH if the North Pole is enclosed, AVKey.SOUTH if the South Pole is enclosed, or null if neither pole is enclosed.
Throws:
`IllegalArgumentException` - if the locations are null.
• #### locationsCrossDateLine

`public static boolean locationsCrossDateLine(Iterable<? extends LatLon> locations)`
• #### locationsCrossDateline

```public static boolean locationsCrossDateline(LatLon p1,
LatLon p2)```
• #### makeDatelineCrossingLocationsPositive

`public static List<LatLon> makeDatelineCrossingLocationsPositive(Iterable<? extends LatLon> locations)`
Transform the negative longitudes of a dateline-spanning location list to positive values that maintain the relationship with the other locations in the list. Negative longitudes are transformed to values greater than 180 degrees, as though longitude spanned [0, 360] rather than [-180, 180]. This enables arithmetic operations to be performed on the locations without having to take into account the longitude jump at the dateline.
Parameters:
`locations` - the locations to transform. This list is not modified.
Returns:
a new list of locations transformed as described above.
Throws:
`IllegalArgumentException` - if the location list is null.
• #### parseLatLon

`public LatLon parseLatLon(String latLonString)`
Parses a string containing latitude and longitude coordinates in either Degrees-minutes-seconds or decimal degrees. The latitude must precede the longitude and the angles must be separated by a comma.
Parameters:
`latLonString` - a string containing the comma separated latitude and longitude in either DMS or decimal degrees.
Returns:
a `LatLon` instance with the parsed angles.
Throws:
`IllegalArgumentException` - if `latLonString` is null.
`NumberFormatException` - if the string does not form a latitude, longitude pair.
• #### pathDistance

```public static Angle pathDistance(String pathType,
LatLon value1,
LatLon value2)```
Returns the length of the path between `value1` and `value2`, according to the specified path type. If the path type is `AVKey.GREAT_CIRCLE` this returns the length of the great arc that spans the two locations (see `greatCircleDistance(LatLon, LatLon)`). If the path type is `AVKey.RHUMB_LINE` or `AVKey.LOXODROME` this returns the length of the rhumb line that spans the two locations (see `rhumbDistance(LatLon, LatLon)`). Otherwise, this returns the linear distance between the two locations (see `linearDistance(LatLon, LatLon)`).
Parameters:
`pathType` - the path type used to interpolate between geographic locations.
`value1` - the first location.
`value2` - the second location.
Returns:
an length of the path between `value1` and `value2`, according to the specified path type.
Throws:
`IllegalArgumentException` - if the path type or either location is null.
• #### repeatLocationsAroundDateline

`public static List<List<LatLon>> repeatLocationsAroundDateline(Iterable<? extends LatLon> locations)`
Returns a list containing two copies of a sequence of geographic locations that cross the dateline: one that extends across the -180 longitude boundary and one that extends across the +180 longitude boundary. If the sequence does not cross the dateline this returns a list containing a copy of the original list.
Parameters:
`locations` - The locations to repeat.
Returns:
A list containing two new location lists, one copy for either side of the dateline.
Throws:
`IllegalArgumentException` - if the locations are null.
• #### rhumbAzimuth

```public static Angle rhumbAzimuth(LatLon p1,
LatLon p2)```
Computes the azimuth angle (clockwise from North) of a rhumb line (a line of constant heading) between two locations. This method uses a spherical model, not elliptical.
Parameters:
`p1` - LatLon of the first location
`p2` - LatLon of the second location
Returns:
azimuth Angle of a rhumb line between the two locations.
• #### rhumbDistance

```public static Angle rhumbDistance(LatLon p1,
LatLon p2)```
Computes the length of the rhumb line between two locations. The return value gives the distance as the angular distance between the two positions on the pi radius circle. In radians, this angle is also the arc length of the segment between the two positions on that circle. To compute a distance in meters from this value, multiply it by the radius of the globe. This method uses a spherical model, not elliptical.
Parameters:
`p1` - LatLon of the first location
`p2` - LatLon of the second location
Returns:
the arc length of the rhumb line between the two locations. In radians, this value is the arc length on the radius pi circle.
• #### rhumbEndPosition

```public static LatLon rhumbEndPosition(LatLon p,
Angle rhumbAzimuth,
Angle pathLength)```
Computes the location on a rhumb line with the given starting location, rhumb azimuth, and arc distance along the line. This method uses a spherical model, not elliptical.
Parameters:
`p` - LatLon of the starting location
`rhumbAzimuth` - rhumb azimuth angle (clockwise from North)
`pathLength` - arc distance to travel
Returns:
LatLon location on the rhumb line.
• #### rhumbEndPosition

```public static LatLon rhumbEndPosition(LatLon p,
double rhumbAzimuthRadians,
double pathLengthRadians)```
Computes the location on a rhumb line with the given starting location, rhumb azimuth, and arc distance along the line. This method uses a spherical model, not elliptical.
Parameters:
`p` - LatLon of the starting location
`rhumbAzimuthRadians` - rhumb azimuth angle (clockwise from North), in radians
`pathLengthRadians` - arc distance to travel, in radians
Returns:
LatLon location on the rhumb line.
• #### subtract

`public LatLon subtract(LatLon that)`
• #### subtract

`public LatLon subtract(Position that)`
• #### toString

`public String toString()`
Overrides:
`toString` in class `Object`
Skip navigation links
NASA World Wind