GeoUtil (ELKI: Environment for DeveLoping KDD-Applications Supported by Index-Structures)

java.lang.Object
- de.lmu.ifi.dbs.elki.math.GeoUtil

@Reference(authors="Ed Williams",
           title="Aviation Formulary",
           booktitle="",
           url="http://williams.best.vwh.net/avform.htm")
public final class GeoUtil
extends Object

Class with utility functions for geographic computations. The majority of formulas are adapted from:

Ed Williams
Aviation Formulary
Online: http://williams.best.vwh.net/avform.htm

TODO: add ellipsoid version of Vinentry formula.

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`EARTH_RADIUS` Earth radius approximation in km.
`static double`	`WGS84_ECCENTRICITY_SQUARED` Eccentricity squared of the WGS84 Ellipsoid
`static double`	`WGS84_FLATTENING` Flattening of the WGS84 Ellipsoid.
`static double`	`WGS84_RADIUS` Radius of the WGS84 Ellipsoid in km.

Constructor Summary

Constructors
Modifier Constructor and Description

private GeoUtil()
Dummy constructor.

Constructors
Modifier	Constructor and Description
`private`	`GeoUtil()` Dummy constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`static double`	`alongTrackDistance(double lat1, double lon1, double lat2, double lon2, double latQ, double lonQ)` The along track distance, is the distance from S to Q along the track S to E.
`static double`	`alongTrackDistance(double lat1, double lon1, double lat2, double lon2, double latQ, double lonQ, double dist1Q, double ctd)` The along track distance, is the distance from S to Q along the track S to E.
`static double`	`bearing(double latS, double lngS, double latE, double lngE)` Compute the bearing from start to end.
`static double`	`crossTrackDistance(double lat1, double lon1, double lat2, double lon2, double latQ, double lonQ)` Compute the cross-track distance.
`static double`	`crossTrackDistanceDeg(double lat1, double lon1, double lat2, double lon2, double latQ, double lonQ, double dist1Q)` Compute the cross-track distance.
`static double`	`crossTrackDistanceRad(double lat1, double lon1, double lat2, double lon2, double latQ, double lonQ)` Compute the cross-track distance.
`static double`	`crossTrackDistanceRad(double lat1, double lon1, double lat2, double lon2, double latQ, double lonQ, double dist1Q)` Compute the cross-track distance.
`static double`	`haversineFormulaDeg(double lat1, double lon1, double lat2, double lon2)` Compute the approximate on-earth-surface distance of two points using the Haversine formula Complexity: 5 trigonometric functions, 2 sqrt.
`static double`	`haversineFormulaRad(double lat1, double lon1, double lat2, double lon2)` Compute the approximate on-earth-surface distance of two points using the Haversine formula Complexity: 5 trigonometric functions, 2 sqrt.
`static double[]`	`latLngDegToXZY(double lat, double lng)` Convert Latitude-Longitude pair to X-Y-Z coordinates using a spherical approximation of the earth.
`static double[]`	`latLngDegToXZYWGS84(double lat, double lng)` Map a latitude,longitude pair to 3D X-Y-Z coordinates, using athe WGS84 ellipsoid.
`static double`	`latlngMinDistDeg(double plat, double plng, double rminlat, double rminlng, double rmaxlat, double rmaxlng)` Point to rectangle minimum distance.
`static double`	`latlngMinDistRad(double plat, double plng, double rminlat, double rminlng, double rmaxlat, double rmaxlng)` Point to rectangle minimum distance.
`static double`	`sphericalVincentyFormulaDeg(double lat1, double lon1, double lat2, double lon2)` Compute the approximate on-earth-surface distance of two points.
`static double`	`sphericalVincentyFormulaRad(double lat1, double lon1, double lat2, double lon2)` Compute the approximate on-earth-surface distance of two points.
`static double`	`xyzToLatDeg(double z)` Convert a 3D coordinate pair to the corresponding latitude.
`static double`	`xyzToLatDegWGS84(double x, double y, double z)` Convert a 3D coordinate pair to the corresponding longitude.
`static double`	`xyzToLngDeg(double x, double y)` Convert a 3D coordinate pair to the corresponding longitude.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - EARTH_RADIUS
```
public static final double EARTH_RADIUS
```
    Earth radius approximation in km.
    
    See Also:
    Constant Field Values
  - WGS84_RADIUS
```
public static final double WGS84_RADIUS
```
    Radius of the WGS84 Ellipsoid in km.
    
    See Also:
    Constant Field Values
  - WGS84_FLATTENING
```
public static final double WGS84_FLATTENING
```
    Flattening of the WGS84 Ellipsoid.
    
    See Also:
    Constant Field Values
  - WGS84_ECCENTRICITY_SQUARED
```
public static final double WGS84_ECCENTRICITY_SQUARED
```
    Eccentricity squared of the WGS84 Ellipsoid
    
    See Also:
    Constant Field Values
- Constructor Detail
  - GeoUtil
```
private GeoUtil()
```
    Dummy constructor. Do not instantiate.
- Method Detail
  - haversineFormulaDeg
```
@Reference(authors="Sinnott, R. W.",
           title="Virtues of the Haversine",
           booktitle="Sky and telescope, 68-2, 1984")
public static double haversineFormulaDeg(double lat1,
                                                        double lon1,
                                                        double lat2,
                                                        double lon2)
```
    Compute the approximate on-earth-surface distance of two points using the Haversine formula Complexity: 5 trigonometric functions, 2 sqrt. Reference:
    R. W. Sinnott,
    Virtues of the Haversine
    Sky and telescope, 68-2, 1984
    
    Parameters:
    lat1 - Latitude of first point in degree
    lon1 - Longitude of first point in degree
    lat2 - Latitude of second point in degree
    lon2 - Longitude of second point in degree
    
    Returns:
    Distance in km (approximately)
  - haversineFormulaRad
```
@Reference(authors="Sinnott, R. W.",
           title="Virtues of the Haversine",
           booktitle="Sky and telescope, 68-2, 1984")
public static double haversineFormulaRad(double lat1,
                                                        double lon1,
                                                        double lat2,
                                                        double lon2)
```
    Compute the approximate on-earth-surface distance of two points using the Haversine formula Complexity: 5 trigonometric functions, 2 sqrt. Reference:
    R. W. Sinnott,
    Virtues of the Haversine
    Sky and telescope, 68-2, 1984
    
    Parameters:
    lat1 - Latitude of first point in degree
    lon1 - Longitude of first point in degree
    lat2 - Latitude of second point in degree
    lon2 - Longitude of second point in degree
    
    Returns:
    Distance in km (approximately)
  - sphericalVincentyFormulaDeg
```
@Reference(authors="T. Vincenty",
           title="Direct and inverse solutions of geodesics on the ellipsoid with application of nested equations",
           booktitle="Survey review 23 176, 1975",
           url="http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf")
public static double sphericalVincentyFormulaDeg(double lat1,
                                                                   double lon1,
                                                                   double lat2,
                                                                   double lon2)
```
    Compute the approximate on-earth-surface distance of two points. Uses Vincenty's Formula for the spherical case, which does not require iterations. Complexity: 7 trigonometric functions, 1 sqrt. Reference:
    T. Vincenty
    Direct and inverse solutions of geodesics on the ellipsoid with application of nested equations
    Survey review 23 176, 1975
    
    Parameters:
    lat1 - Latitude of first point in degree
    lon1 - Longitude of first point in degree
    lat2 - Latitude of second point in degree
    lon2 - Longitude of second point in degree
    
    Returns:
    Distance in km (approximately)
  - sphericalVincentyFormulaRad
```
@Reference(authors="T. Vincenty",
           title="Direct and inverse solutions of geodesics on the ellipsoid with application of nested equations",
           booktitle="Survey review 23 176, 1975",
           url="http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf")
public static double sphericalVincentyFormulaRad(double lat1,
                                                                   double lon1,
                                                                   double lat2,
                                                                   double lon2)
```
    Compute the approximate on-earth-surface distance of two points. Uses Vincenty's Formula for the spherical case, which does not require iterations. Complexity: 7 trigonometric functions, 1 sqrt. Reference:
    T. Vincenty
    Direct and inverse solutions of geodesics on the ellipsoid with application of nested equations
    Survey review 23 176, 1975
    
    Parameters:
    lat1 - Latitude of first point in degree
    lon1 - Longitude of first point in degree
    lat2 - Latitude of second point in degree
    lon2 - Longitude of second point in degree
    
    Returns:
    Distance in km (approximately)
  - crossTrackDistanceDeg
```
public static double crossTrackDistanceDeg(double lat1,
                           double lon1,
                           double lat2,
                           double lon2,
                           double latQ,
                           double lonQ,
                           double dist1Q)
```
    Compute the cross-track distance.
    
    Parameters:
    lat1 - Latitude of starting point.
    lon1 - Longitude of starting point.
    lat2 - Latitude of destination point.
    lon2 - Longitude of destination point.
    latQ - Latitude of query point.
    lonQ - Longitude of query point.
    dist1Q - Distance from starting point to query point in km.
    
    Returns:
    Cross-track distance in km. May be negative - this gives the side.
  - crossTrackDistanceRad
```
public static double crossTrackDistanceRad(double lat1,
                           double lon1,
                           double lat2,
                           double lon2,
                           double latQ,
                           double lonQ,
                           double dist1Q)
```
    Compute the cross-track distance.
    
    Parameters:
    lat1 - Latitude of starting point.
    lon1 - Longitude of starting point.
    lat2 - Latitude of destination point.
    lon2 - Longitude of destination point.
    latQ - Latitude of query point.
    lonQ - Longitude of query point.
    dist1Q - Distance from starting point to query point in km.
    
    Returns:
    Cross-track distance in km. May be negative - this gives the side.
  - crossTrackDistance
```
public static double crossTrackDistance(double lat1,
                        double lon1,
                        double lat2,
                        double lon2,
                        double latQ,
                        double lonQ)
```
    Compute the cross-track distance. XTD = asin(sin(dist_1Q)*sin(crs_1Q-crs_12))
    
    Parameters:
    lat1 - Latitude of starting point.
    lon1 - Longitude of starting point.
    lat2 - Latitude of destination point.
    lon2 - Longitude of destination point.
    latQ - Latitude of query point.
    lonQ - Longitude of query point.
    
    Returns:
    Cross-track distance in km. May be negative - this gives the side.
  - crossTrackDistanceRad
```
public static double crossTrackDistanceRad(double lat1,
                           double lon1,
                           double lat2,
                           double lon2,
                           double latQ,
                           double lonQ)
```
    Compute the cross-track distance. XTD = asin(sin(dist_SQ)*sin(crs_SQ-crs_SE))
    
    Parameters:
    lat1 - Latitude of starting point.
    lon1 - Longitude of starting point.
    lat2 - Latitude of destination point.
    lon2 - Longitude of destination point.
    latQ - Latitude of query point.
    lonQ - Longitude of query point.
    
    Returns:
    Cross-track distance in km. May be negative - this gives the side.
  - alongTrackDistance
```
public static double alongTrackDistance(double lat1,
                        double lon1,
                        double lat2,
                        double lon2,
                        double latQ,
                        double lonQ)
```
    The along track distance, is the distance from S to Q along the track S to E. ATD=acos(cos(dist_1Q)/cos(XTD)) FIXME: can we get a proper sign into this?
    
    Parameters:
    lat1 - Latitude of starting point.
    lon1 - Longitude of starting point.
    lat2 - Latitude of destination point.
    lon2 - Longitude of destination point.
    latQ - Latitude of query point.
    lonQ - Longitude of query point.
    
    Returns:
    Along-track distance in km. May be negative - this gives the side.
  - alongTrackDistance
```
public static double alongTrackDistance(double lat1,
                        double lon1,
                        double lat2,
                        double lon2,
                        double latQ,
                        double lonQ,
                        double dist1Q,
                        double ctd)
```
    The along track distance, is the distance from S to Q along the track S to E. ATD=acos(cos(dist_SQ)/cos(XTD)) FIXME: can we get a proper sign into this?
    
    Parameters:
    lat1 - Latitude of starting point.
    lon1 - Longitude of starting point.
    lat2 - Latitude of destination point.
    lon2 - Longitude of destination point.
    latQ - Latitude of query point.
    lonQ - Longitude of query point.
    dist1Q - Distance S to Q
    ctd - Cross-track-distance
    
    Returns:
    Along-track distance in km. May be negative - this gives the side.
  - latlngMinDistDeg
```
public static double latlngMinDistDeg(double plat,
                      double plng,
                      double rminlat,
                      double rminlng,
                      double rmaxlat,
                      double rmaxlng)
```
    Point to rectangle minimum distance. Complexity:
    - Trivial cases (on longitude slice): no trigonometric functions.
    - Cross-track case: 10+2 trig
    - Corner case: 10+3 trig, 2 sqrt
    Parameters:
    plat - Latitude of query point.
    plng - Longitude of query point.
    rminlat - Min latitude of rectangle.
    rminlng - Min longitude of rectangle.
    rmaxlat - Max latitude of rectangle.
    rmaxlng - Max longitude of rectangle.
    
    Returns:
    Distance
  - latlngMinDistRad
```
public static double latlngMinDistRad(double plat,
                      double plng,
                      double rminlat,
                      double rminlng,
                      double rmaxlat,
                      double rmaxlng)
```
    Point to rectangle minimum distance. Complexity:
    - Trivial cases (on longitude slice): no trigonometric functions.
    - Cross-track case: 10+2 trig
    - Corner case: 10+3 trig, 2 sqrt
    Parameters:
    plat - Latitude of query point.
    plng - Longitude of query point.
    rminlat - Min latitude of rectangle.
    rminlng - Min longitude of rectangle.
    rmaxlat - Max latitude of rectangle.
    rmaxlng - Max longitude of rectangle.
    
    Returns:
    Distance
  - bearing
```
public static double bearing(double latS,
             double lngS,
             double latE,
             double lngE)
```
    Compute the bearing from start to end.
    
    Parameters:
    latS - Start latitude, in degree
    lngS - Start longitude, in degree
    latE - End latitude, in degree
    lngE - End longitude, in degree
    
    Returns:
    Bearing in radians
  - latLngDegToXZYWGS84
```
public static double[] latLngDegToXZYWGS84(double lat,
                           double lng)
```
    Map a latitude,longitude pair to 3D X-Y-Z coordinates, using athe WGS84 ellipsoid. The coordinate system is chosen such that the earth rotates around the Z axis.
    
    Parameters:
    lat - Latitude in degree
    lng - Longitude in degree
    
    Returns:
    Coordinate triple
  - latLngDegToXZY
```
public static double[] latLngDegToXZY(double lat,
                      double lng)
```
    Convert Latitude-Longitude pair to X-Y-Z coordinates using a spherical approximation of the earth. The coordinate system is chosen such that the earth rotates around the Z axis.
    
    Parameters:
    lat - Latitude in degree
    lng - Longitude in degree
    
    Returns:
    Coordinate triple
  - xyzToLatDegWGS84
```
public static double xyzToLatDegWGS84(double x,
                      double y,
                      double z)
```
    Convert a 3D coordinate pair to the corresponding longitude. Only x and y are required - z gives the latitude.
    
    Parameters:
    x - X value
    y - Y value
    
    Returns:
    Latitude
  - xyzToLatDeg
```
public static double xyzToLatDeg(double z)
```
    Convert a 3D coordinate pair to the corresponding latitude. Only the z coordinate is required.
    
    Parameters:
    z - Z value
    
    Returns:
    Latitude
  - xyzToLngDeg
```
public static double xyzToLngDeg(double x,
                 double y)
```
    Convert a 3D coordinate pair to the corresponding longitude. Only x and y are required - z gives the latitude.
    
    Parameters:
    x - X value
    y - Y value
    
    Returns:
    Latitude

Class GeoUtil

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EARTH_RADIUS

WGS84_RADIUS

WGS84_FLATTENING

WGS84_ECCENTRICITY_SQUARED

Constructor Detail

GeoUtil

Method Detail

haversineFormulaDeg

haversineFormulaRad

sphericalVincentyFormulaDeg

sphericalVincentyFormulaRad

crossTrackDistanceDeg

crossTrackDistanceRad

crossTrackDistance

crossTrackDistanceRad

alongTrackDistance

alongTrackDistance

latlngMinDistDeg

latlngMinDistRad

bearing

latLngDegToXZYWGS84

latLngDegToXZY

xyzToLatDegWGS84

xyzToLatDeg

xyzToLngDeg