Datum (SpaceBase 2.1)

java.lang.Object
- co.paralleluniverse.geodesy.Datum

```
public class Datum
extends Object
```
A geodesic datum.

Field Summary

Fields
Modifier and Type Field and Description

static Datum WGS84
The WGS84 Datum.

Fields
Modifier and Type	Field and Description
`static Datum`	`WGS84` The WGS84 `Datum`.

Constructor Summary

Constructors
Constructor and Description
`Datum(String name, double a, double f)` Creates a datum.
`Datum(String name, double a, double f, double k, double dx, double dy, double dz, double rx, double ry, double rz)` Creates a datum.

Method Summary

Methods
Modifier and Type	Method and Description
`double`	`bearing(double origLat, double origLng, double targetLat, double targetLng)` Computes the bearing (forward azimuth) from one coordinate to the other.
`double`	`bearing(GeoLocation origin, GeoLocation target)` Computes the bearing (forward azimuth) from one coordinate to the other.
`double`	`destEast(double lat0, double lng0, double distance)` Computes the longitude of the destination point when starting at the given location and traveling due east for a given distance (or west if distance is negative).
`GeoLocation`	`destEast(GeoLocation origin, double distance)` Computes the destination coordinate when starting at the given location and traveling due east for a given distance (or west if the distance is negative)
`GeoLocation`	`destination(double lat0, double lng0, double h0, double bearing, double distance)` Computes the destination coordinate when starting at the given location and traveling along a given bearing for a given distance.
`GeoLocation`	`destination(GeoLocation origin, double bearing, double distance)` Computes the destination coordinate when starting at the given location and traveling along a given bearing for a given distance.
`double`	`destNorth(double lat0, double distance)` Computes the latitude of the destination point when starting at the given latitude and traveling due north for a given distance (or south if distance is negative).
`GeoLocation`	`destNorth(GeoLocation origin, double distance)` Computes the destination coordinate when starting at the given location and traveling due North for a given distance (or south if distance is negative).
`GeoLocation`	`destVincenty(double lat0, double lng0, double h0, double bearing, double distance)` Computes the destination coordinate when starting at the given location and traveling along a given bearing for a given distance, using the Vincenty formula.
`GeoLocation`	`destVincenty(GeoLocation origin, double bearing, double distance)` Computes the exact destination coordinate when starting at the given location and traveling along a given bearing for a given distance, using the Vincenty formula.
`double`	`distance(double lat1, double lng1, double h1, double lat2, double lng2, double h2)` Computes the approximate geodesic great-circle distance between two coordinates.
`double`	`distance(GeoLocation loc1, GeoLocation loc2)` Computes the approximate geodesic great-circle distance between two coordinates.
`double`	`distanceEast(double lat, double lng1, double alt1, double lng2, double alt2)` Computes the approximate geodesic great-circle East-West distance between the longitudes of the given locations at a given latitude.
`double`	`distanceEast(double lat1, double lng1, double alt1, double lat2, double lng2, double alt2)` Computes the approximate geodesic great-circle East-West distance between the longitudes of the given locations at their mean latitude.
`double`	`distanceEast(GeoLocation loc1, GeoLocation loc2)` Computes the approximate geodesic great-circle East-West distance between the longitudes of the given locations at their mean latitude.
`double`	`distanceHaversine(double lat1, double lng1, double h1, double lat2, double lng2, double h2)` Computes the approximate geodesic great-circle distance between two coordinates using the Haversine formula.
`double`	`distanceHaversine(GeoLocation loc1, GeoLocation loc2)` Computes the approximate geodesic great-circle distance between two coordinates Haversine formula.
`double`	`distanceNorth(double lat1, double alt1, double lat2, double alt2)` Computes the approximate geodesic great-circle North-South distance between two latitudes.
`double`	`distanceNorth(GeoLocation loc1, GeoLocation loc2)` Computes the approximate geodesic great-circle North-South distance between the latitudes of the given locations.
`double`	`distanceVincenty(double lat1, double lng1, double lat2, double lng2)` Computes the exact geodesic great-circle distance between two coordinates using the Vincenty formula.
`double`	`distanceVincenty(GeoLocation loc1, GeoLocation loc2)` Computes the exact geodesic great-circle distance between two coordinates Vincenty formula.
`GeoLocation`	`ecefToGeo(ECEFLocation ecf)` Translates a location given in ECEF coordinates into geographic coordinates.
`ECEFAcceleration`	`from(Datum datum, ECEFAcceleration ecf)` Translates an acceleration vector in ECEF coordinates from the given datum to this datum
`ECEFLocation`	`from(Datum datum, ECEFLocation ecf)` Translates the ECEF coordinates of a location on a the given datum to a location on this datum
`ECEFVelocity`	`from(Datum datum, ECEFVelocity ecf)` Translates a velocity vector in ECEF coordinates from the given datum to this datum
`GeoLocation`	`from(Datum datum, GeoLocation loc)` Translates the geographic coordinates of a location on a given datum to a location on this datum
`CartLocation`	`fromGeo(CoordinateSystem cs, GeoLocation geo)`
`ECEFAcceleration`	`fromWGS84(ECEFAcceleration ecfW84)` Translates an acceleration vector in ECEF coordinates from the WGS84 datum to this datum
`ECEFLocation`	`fromWGS84(ECEFLocation ecfW84)` Translates the ECEF coordinates of a location on a the WGS84 datum to a location on this datum
`ECEFVelocity`	`fromWGS84(ECEFVelocity ecfW84)` Translates a velocity vector in ECEF coordinates from the WGS84 datum to this datum
`ECEFLocation`	`geoToECEF(GeoLocation geo)` Translates a location given in geographic coordinates into ECEF coordinates
`UTMLocation`	`geoToUTM(GeoLocation geo)` Translates a location in geographic coordinates to UTM coordinates
`UTMLocation`	`geoToUTM(GeoLocation geo, int zone)` Translates a location in geographic coordinates to UTM coordinates, forcing a given UTM zone.
`double`	`getA()` The large axis of the ellipsoid (in meters)
`double`	`getF()` The oblateness factor
`double`	`getM(double lat)` Computes the meridional radius at the given latitude.
`double`	`getMeanRadius(double lat)` Computes the mean radius at the given latitude.
`double`	`getMeanRadius(double lat, double bearing)` Computes the mean radius at the given latitude along a given bearing
`double`	`getMeanRadius(double lat1, double lng1, double lat2, double lng2)` Computes a mean radius that tries to serve as a good approximation of the ellipsoid’s radius for the two given coordinate.
`double`	`getMeanRadius(GeoLocation loc1, GeoLocation loc2)` Computes a mean radius that tries to serve as a good approximation of the ellipsoid’s radius for the two given coordinate.
`double`	`getN(double lat)` Computes the normal radius at the given latitude.
`int`	`getUTMZone(GeoLocation geo)` Computes the UTM zone of a given geographic location
`double`	`intersectLat(double d, double lat0, double lat)` Intersects given latitude lat with the spherical circle centered on latitude lat0 of spherical radius d.
`GeoLocation`	`toGeo(CoordinateSystem cs, CartLocation loc)`
`String`	`toString()`
`ECEFAcceleration`	`toWGS84(ECEFAcceleration ecf)` Translates an acceleration vector in ECEF coordinates from this datum to the WGS84
`ECEFLocation`	`toWGS84(ECEFLocation ecf)` Translates the ECEF coordinates of a location on this datum to a location on the WGS84 datum
`ECEFVelocity`	`toWGS84(ECEFVelocity ecf)` Translates a velocity vector in ECEF coordinates from this datum to the WGS84
`GeoLocation`	`utmToGeo(UTMLocation utm)` Translates a location given in UTM coordinates to geographic coordinates.

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

- Field Detail
  - WGS84
```
public static final Datum WGS84
```
    The WGS84 Datum.
- Constructor Detail
  - Datum
```
public Datum(String name,
     double a,
     double f)
```
    Creates a datum.
    
    Parameters:
    name - the name of the datum.
    a - the large axis radius of the ellipsoid (in meters)
    f - The oblateness factor of the Datum
  - Datum
```
public Datum(String name,
     double a,
     double f,
     double k,
     double dx,
     double dy,
     double dz,
     double rx,
     double ry,
     double rz)
```
    Creates a datum.
    
    Parameters:
    name - the name of the datum.
    a - the large axis radius of the ellipsoid (in meters)
    f - the oblateness factor of the Datum
    k - the Bursa-Wolfe scale (with respect to WGS84)
    dx - the Bursa-Wolfe X translation (with respect to WGS84)
    dy - the Bursa-Wolfe Y translation (with respect to WGS84)
    dz - the Bursa-Wolfe Z translation (with respect to WGS84)
    rx - the Bursa-Wolfe X rotation (with respect to WGS84)
    ry - the Bursa-Wolfe Y rotation (with respect to WGS84)
    rz - the Bursa-Wolfe Z rotation (with respect to WGS84)
- Method Detail
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getA
```
public double getA()
```
    The large axis of the ellipsoid (in meters)
  - getF
```
public double getF()
```
    The oblateness factor
  - getN
```
public double getN(double lat)
```
    Computes the normal radius at the given latitude.
    
    Parameters:
    lat - the latitude in radians
    
    Returns:
    the Normal radius at the given latitude in meters
  - getM
```
public double getM(double lat)
```
    Computes the meridional radius at the given latitude.
    
    Parameters:
    lat - the latitude in radians.
    
    Returns:
    the meridional radius at the given latitude in meters
  - getMeanRadius
```
public double getMeanRadius(double lat)
```
    Computes the mean radius at the given latitude. This is the geometric mean of the normal and meridional radii.
    
    Parameters:
    lat - the latitude in radians.
    
    Returns:
    the mean radius at the given latitude in meters
  - getMeanRadius
```
public double getMeanRadius(double lat,
                   double bearing)
```
    Computes the mean radius at the given latitude along a given bearing
    
    Parameters:
    lat - the latitude in radians
    bearing - the bearing (forward azimuth) from North, clockwise in radians
    
    Returns:
    the mean radius in meters
  - getMeanRadius
```
public double getMeanRadius(GeoLocation loc1,
                   GeoLocation loc2)
```
    Computes a mean radius that tries to serve as a good approximation of the ellipsoid’s radius for the two given coordinate.
    
    Parameters:
    loc1 - the first location
    loc2 - the second location
    
    Returns:
    a mean radius that tries to serve as a good approximation of the ellipsoid’s radius for the two given coordinate.
  - getMeanRadius
```
public double getMeanRadius(double lat1,
                   double lng1,
                   double lat2,
                   double lng2)
```
    Computes a mean radius that tries to serve as a good approximation of the ellipsoid’s radius for the two given coordinate.
    
    Parameters:
    lat1 - the latitude of the first location in radians
    lng1 - the longitude of the first location in radians
    lat2 - the latitude of the second location in radians
    lng2 - the longitude of the second location in radians
    
    Returns:
    a mean radius that tries to serve as a good approximation of the ellipsoid’s radius for the two given coordinate.
  - distance
```
public double distance(GeoLocation loc1,
              GeoLocation loc2)
```
    Computes the approximate geodesic great-circle distance between two coordinates. This method uses a spherical approximation of the ellipsoid with the radius obtained with getMeanRadius(loc1, loc2).
    
    Parameters:
    loc1 - the first location
    loc2 - the second location
    
    Returns:
    the approximate geodesic great-circle between the two coordinates in meters
  - distance
```
public double distance(double lat1,
              double lng1,
              double h1,
              double lat2,
              double lng2,
              double h2)
```
    Computes the approximate geodesic great-circle distance between two coordinates. This method uses a spherical approximation of the ellipsoid with the radius obtained with getMeanRadius(lat1, lng1, lat2, lng2).
    
    Parameters:
    lat1 - the latitude of the first location in radians
    lng1 - the longitude of the first location in radians
    h1 - the altitude of the first location above/below sea-level in meters
    lat2 - the latitude of the second location in radians
    lng2 - the longitude of the second location in radians
    h2 - the altitude of the second location above/below sea-level in meters
    
    Returns:
    the approximate geodesic great-circle distance between the two coordinates in meters
  - distanceHaversine
```
public double distanceHaversine(GeoLocation loc1,
                       GeoLocation loc2)
```
    Computes the approximate geodesic great-circle distance between two coordinates Haversine formula. This method uses a spherical approximation of the ellipsoid with the radius obtained with getMeanRadius(loc1, loc2). This method is slower but more exact than distance().
    
    Parameters:
    loc1 - the first location
    loc2 - the second location
    
    Returns:
    the approximate geodesic great-circle between the two coordinates in meters
  - distanceHaversine
```
public double distanceHaversine(double lat1,
                       double lng1,
                       double h1,
                       double lat2,
                       double lng2,
                       double h2)
```
    Computes the approximate geodesic great-circle distance between two coordinates using the Haversine formula. This method uses a spherical approximation of the ellipsoid with the radius obtained with getMeanRadius(lat1, lng1, lat2, lng2). This method is slower but more exact than distance().
    
    Parameters:
    lat1 - the latitude of the first location in radians
    lng1 - the longitude of the first location in radians
    h1 - the altitude of the first location above/below sea-level in meters
    lat2 - the latitude of the second location in radians
    lng2 - the longitude of the second location in radians
    h2 - the altitude of the second location above/below sea-level in meters
    
    Returns:
    the approximate geodesic great-circle distance between the two coordinates in meters
  - bearing
```
public double bearing(GeoLocation origin,
             GeoLocation target)
```
    Computes the bearing (forward azimuth) from one coordinate to the other. The bearing is given from the North, clockwise in radians. Note that bearing(a, b) is not necessarily -bearing(b, a).
    
    Parameters:
    origin - the origin coordinate
    target - the target coordinate
    
    Returns:
    the bearing in radians, measured clockwise from the North
  - bearing
```
public double bearing(double origLat,
             double origLng,
             double targetLat,
             double targetLng)
```
    Computes the bearing (forward azimuth) from one coordinate to the other. The bearing is given from the North, clockwise in radians. Note that bearing(a, b) is not necessarily -bearing(b, a).
    
    Parameters:
    origLat - the latitude of the origin coordinate in radians
    origLng - the longitude of the origin coordinate in radians
    targetLat - the latitude of the target coordinate in radians
    targetLng - the longitude of the target coordinate in radians
    
    Returns:
    the bearing in radians, measured clockwise from the North
  - destination
```
public GeoLocation destination(GeoLocation origin,
                      double bearing,
                      double distance)
```
    Computes the destination coordinate when starting at the given location and traveling along a given bearing for a given distance.
    
    Parameters:
    origin - the location of the starting point
    bearing - the bearing (forward azimuth) of travel, in radians, measured clockwise from the North
    distance - the distance to travel in meters
    
    Returns:
    the location of the destination
  - destination
```
public GeoLocation destination(double lat0,
                      double lng0,
                      double h0,
                      double bearing,
                      double distance)
```
    Computes the destination coordinate when starting at the given location and traveling along a given bearing for a given distance.
    
    Parameters:
    lat0 - the latitude of the starting point in radians
    lng0 - the longitude of the starting point in radians
    h0 - the altitude of the starting point
    bearing - the bearing (forward azimuth) of travel, in radians, measured clockwise from the North
    distance - the distance to travel in meters
    
    Returns:
    the location of the destination
  - distanceVincenty
```
public double distanceVincenty(GeoLocation loc1,
                      GeoLocation loc2)
```
    Computes the exact geodesic great-circle distance between two coordinates Vincenty formula. This method uses a spherical approximation of the ellipsoid with the radius obtained with getMeanRadius(loc1, loc2). This method is much slower but much more exact than either distance() or distanceHaversine().
    
    Parameters:
    loc1 - the first location
    loc2 - the second location
    
    Returns:
    the approximate geodesic great-circle between the two coordinates in meters
  - distanceVincenty
```
public double distanceVincenty(double lat1,
                      double lng1,
                      double lat2,
                      double lng2)
```
    Computes the exact geodesic great-circle distance between two coordinates using the Vincenty formula. This method uses a spherical approximation of the ellipsoid with the radius obtained with getMeanRadius(lat1, lng1, lat2, lng2). This method is much slower but much more exact than either distance() or distanceHaversine().
    
    Parameters:
    lat1 - the latitude of the first location in radians
    lng1 - the longitude of the first location in radians
    lat2 - the latitude of the second location in radians
    lng2 - the longitude of the second location in radians
    
    Returns:
    the approximate geodesic great-circle distance between the two coordinates in meters
  - destVincenty
```
public GeoLocation destVincenty(GeoLocation origin,
                       double bearing,
                       double distance)
```
    Computes the exact destination coordinate when starting at the given location and traveling along a given bearing for a given distance, using the Vincenty formula. This method is much slower, but much more exact that destination().
    
    Parameters:
    origin - the location of the starting point
    bearing - the bearing (forward azimuth) of travel, in radians, measured clockwise from the North
    distance - the distance to travel in meters
    
    Returns:
    the location of the destination
  - destVincenty
```
public GeoLocation destVincenty(double lat0,
                       double lng0,
                       double h0,
                       double bearing,
                       double distance)
```
    Computes the destination coordinate when starting at the given location and traveling along a given bearing for a given distance, using the Vincenty formula. This method is much slower, but much more exact that destination().
    
    Parameters:
    lat0 - the latitude of the starting point in radians
    lng0 - the longitude of the starting point in radians
    h0 - the altitude of the starting point
    bearing - the bearing (forward azimuth) of travel, in radians, measured clockwise from the North
    distance - the distance to travel in meters
    
    Returns:
    the location of the destination
  - destNorth
```
public GeoLocation destNorth(GeoLocation origin,
                    double distance)
```
    Computes the destination coordinate when starting at the given location and traveling due North for a given distance (or south if distance is negative).
    
    Parameters:
    origin - the location of the starting point
    distance - the distance to travel in meters
    
    Returns:
    the location of the destination
  - destNorth
```
public double destNorth(double lat0,
               double distance)
```
    Computes the latitude of the destination point when starting at the given latitude and traveling due north for a given distance (or south if distance is negative).
    
    Parameters:
    lat0 - the latitude of the starting point, in radians
    distance - the distance to travel in meters
    
    Returns:
    the latitude of the destination in radians
  - destEast
```
public GeoLocation destEast(GeoLocation origin,
                   double distance)
```
    Computes the destination coordinate when starting at the given location and traveling due east for a given distance (or west if the distance is negative)
    
    Parameters:
    origin - the location of the starting point
    distance - the distance to travel in meters
    
    Returns:
    the location of the destination
  - destEast
```
public double destEast(double lat0,
              double lng0,
              double distance)
```
    Computes the longitude of the destination point when starting at the given location and traveling due east for a given distance (or west if distance is negative).
    
    Parameters:
    lat0 - the latitude of the starting point, in radians
    lng0 - the latitude of the starting point, in radians
    distance - the distance to travel in meters
    
    Returns:
    the longitude of the destination in radians
  - distanceNorth
```
public double distanceNorth(GeoLocation loc1,
                   GeoLocation loc2)
```
    Computes the approximate geodesic great-circle North-South distance between the latitudes of the given locations. This method uses a spherical approximation of the ellipsoid with the radius obtained with getMeanRadius(loc1, loc2). The result is not a magnitude - it is positive if loc2 is north of loc1, and negative if loc2 is south of loc1.
    
    Parameters:
    loc1 - the first location
    loc2 - the second location
    
    Returns:
    the approximate distance in meters between the latitudes of the given locations. Positive if loc2 is north of loc1, negative if the other way around.
  - distanceNorth
```
public double distanceNorth(double lat1,
                   double alt1,
                   double lat2,
                   double alt2)
```
    Computes the approximate geodesic great-circle North-South distance between two latitudes. This method uses a spherical approximation of the ellipsoid with the radius obtained with getMeanRadius(loc1, loc2). The result is not a magnitude - it is positive if loc2 is north of loc1, and negative if loc2 is south of loc1.
    
    Parameters:
    lat1 - the latitude first location in radians
    alt1 - the altitude first location above/below sea-level in meters
    lat2 - the latitude second location in radians
    alt2 - the altitude second location above/below sea-level in meters
    
    Returns:
    the approximate distance in meters between the latitudes of the given locations. Positive if lat2 is north of lat1, negative if the other way around.
  - distanceEast
```
public double distanceEast(GeoLocation loc1,
                  GeoLocation loc2)
```
    Computes the approximate geodesic great-circle East-West distance between the longitudes of the given locations at their mean latitude. This method uses a spherical approximation of the ellipsoid with the radius obtained with getMeanRadius(loc1, loc2). The result is not a magnitude - it is positive if loc2 is east of loc1, and negative if loc2 is west of loc1.
    
    Parameters:
    loc1 - the first location
    loc2 - the second location
    
    Returns:
    the approximate distance in meters between the longitudes of the given locations at their mean latitude. Positive if loc2 is east of loc1, negative if the other way around.
  - distanceEast
```
public double distanceEast(double lat1,
                  double lng1,
                  double alt1,
                  double lat2,
                  double lng2,
                  double alt2)
```
    Computes the approximate geodesic great-circle East-West distance between the longitudes of the given locations at their mean latitude. This method uses a spherical approximation of the ellipsoid with the radius obtained with getMeanRadius(loc1, loc2). The result is not a magnitude - it is positive if lng2 is east of lng1, and negative if lng2 is west of lng1.
    
    Parameters:
    lat1 - the latitude of the first location in radians
    lng1 - the longitude of the first location in radians
    alt1 - the altitude of the first location above/below sea level in meters
    lat2 - the latitude of the second location in radians
    lng2 - the longitude of the second location in radians
    alt2 - the altitude of the second location above/below sea level in meters
    
    Returns:
    the approximate distance in meters between the longitudes of the given locations at their mean latitude. Positive if lng2 is east of lng1, negative if the other way around.
  - distanceEast
```
public double distanceEast(double lat,
                  double lng1,
                  double alt1,
                  double lng2,
                  double alt2)
```
    Computes the approximate geodesic great-circle East-West distance between the longitudes of the given locations at a given latitude. This method uses a spherical approximation of the ellipsoid with the radius obtained with getMeanRadius(loc1, loc2). The result is not a magnitude - it is positive if lng2 is east of lng1, and negative if lng2 is west of lng1.
    
    Parameters:
    lat - the latitude of the both locations in radians
    lng1 - the longitude of the first location in radians
    alt1 - the altitude of the first location above/below sea level in meters
    lng2 - the longitude of the second location in radians
    alt2 - the altitude of the second location above/below sea level in meters
    
    Returns:
    the approximate distance in meters between the longitudes of the given locations at their mean latitude. Positive if lng2 is east of lng1, negative if the other way around.
  - intersectLat
```
public double intersectLat(double d,
                  double lat0,
                  double lat)
```
    Intersects given latitude lat with the spherical circle centered on latitude lat0 of spherical radius d.
    The intersections’ longitudes, given a return value X are: lon0 + X and lon0 - X, with lon0 being the circle’s center’s longitude.
    
    Parameters:
    d - The circle’s radius
    lat - The latitude to intersect
    lat0 - The latitude of the circle’s center
    
    Returns:
  - from
```
public GeoLocation from(Datum datum,
               GeoLocation loc)
```
    Translates the geographic coordinates of a location on a given datum to a location on this datum
    
    Parameters:
    datum - the datum of the given location
    loc - the location to translate
    
    Returns:
    the location on this datum
  - geoToECEF
```
public ECEFLocation geoToECEF(GeoLocation geo)
```
    Translates a location given in geographic coordinates into ECEF coordinates
    
    Parameters:
    geo - the location in geographic coordinates.
    
    Returns:
    the location in ECEF coordinates.
  - ecefToGeo
```
public GeoLocation ecefToGeo(ECEFLocation ecf)
```
    Translates a location given in ECEF coordinates into geographic coordinates.
    
    Parameters:
    ecf - the location in ECEF coordinates.
    
    Returns:
    the location in geographic coordinates.
  - fromWGS84
```
public ECEFLocation fromWGS84(ECEFLocation ecfW84)
```
    Translates the ECEF coordinates of a location on a the WGS84 datum to a location on this datum
    
    Parameters:
    ecfW84 - the location to translate, on the WGS84 datum
    
    Returns:
    the location on this datum
  - fromWGS84
```
public ECEFVelocity fromWGS84(ECEFVelocity ecfW84)
```
    Translates a velocity vector in ECEF coordinates from the WGS84 datum to this datum
    
    Parameters:
    ecfW84 - the vector relative to the WGS84 datum
    
    Returns:
    the vector relative to this datum
  - fromWGS84
```
public ECEFAcceleration fromWGS84(ECEFAcceleration ecfW84)
```
    Translates an acceleration vector in ECEF coordinates from the WGS84 datum to this datum
    
    Parameters:
    ecfW84 - the vector relative to the WGS84 datum
    
    Returns:
    the vector relative to this datum
  - toWGS84
```
public ECEFLocation toWGS84(ECEFLocation ecf)
```
    Translates the ECEF coordinates of a location on this datum to a location on the WGS84 datum
    
    Parameters:
    ecf - the location to translate, on this datum
    
    Returns:
    the location on the WGS84 datum
  - toWGS84
```
public ECEFVelocity toWGS84(ECEFVelocity ecf)
```
    Translates a velocity vector in ECEF coordinates from this datum to the WGS84
    
    Parameters:
    ecf - the vector relative to this datum
    
    Returns:
    the vector relative to the WGS84 datum
  - toWGS84
```
public ECEFAcceleration toWGS84(ECEFAcceleration ecf)
```
    Translates an acceleration vector in ECEF coordinates from this datum to the WGS84
    
    Parameters:
    ecf - the vector relative to this datum
    
    Returns:
    the vector relative to the WGS84 datum
  - from
```
public ECEFLocation from(Datum datum,
                ECEFLocation ecf)
```
    Translates the ECEF coordinates of a location on a the given datum to a location on this datum
    
    Parameters:
    datum - the datum of the given location
    ecf - the location to translate, on the given datum
    
    Returns:
    the location on this datum
  - from
```
public ECEFVelocity from(Datum datum,
                ECEFVelocity ecf)
```
    Translates a velocity vector in ECEF coordinates from the given datum to this datum
    
    Parameters:
    datum - the datum of the given vector
    ecf - the vector relative to the given datum
    
    Returns:
    the vector relative to this datum
  - from
```
public ECEFAcceleration from(Datum datum,
                    ECEFAcceleration ecf)
```
    Translates an acceleration vector in ECEF coordinates from the given datum to this datum
    
    Parameters:
    datum - the datum of the given vector
    ecf - the vector relative to the given datum
    
    Returns:
    the vector relative to this datum
  - geoToUTM
```
public UTMLocation geoToUTM(GeoLocation geo)
```
    Translates a location in geographic coordinates to UTM coordinates
    
    Parameters:
    geo - the location
    
    Returns:
    the UTM coordinates of the given location
  - getUTMZone
```
public int getUTMZone(GeoLocation geo)
```
    Computes the UTM zone of a given geographic location
    
    Parameters:
    geo - the location
    
    Returns:
    the UTM zone of the given location
  - geoToUTM
```
public UTMLocation geoToUTM(GeoLocation geo,
                   int zone)
```
    Translates a location in geographic coordinates to UTM coordinates, forcing a given UTM zone. This method allows expanding UTM regions.
    
    Parameters:
    geo -
    zone - the UTM zone of the result
    
    Returns:
    the UTM zone of the given location in the given zone
  - utmToGeo
```
public GeoLocation utmToGeo(UTMLocation utm)
```
    Translates a location given in UTM coordinates to geographic coordinates.
    
    Parameters:
    utm - the location
    
    Returns:
    the geographic coordinates of the location
  - toGeo
```
public GeoLocation toGeo(CoordinateSystem cs,
                CartLocation loc)
```
  - fromGeo
```
public CartLocation fromGeo(CoordinateSystem cs,
                   GeoLocation geo)
```

Class Datum

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

WGS84

Constructor Detail

Datum

Datum

Method Detail

toString

getA

getF

getN

getM

getMeanRadius

getMeanRadius

getMeanRadius

getMeanRadius

distance

distance

distanceHaversine

distanceHaversine

bearing

bearing

destination

destination

distanceVincenty

distanceVincenty

destVincenty

destVincenty

destNorth

destNorth

destEast

destEast

distanceNorth

distanceNorth

distanceEast

distanceEast

distanceEast

intersectLat

from

geoToECEF

ecefToGeo

fromWGS84

fromWGS84

fromWGS84

toWGS84

toWGS84

toWGS84

from

from

from

geoToUTM

getUTMZone

geoToUTM

utmToGeo

toGeo

fromGeo