Geo

java.lang.Object
- org.transitime.utils.Geo

```
public class Geo
extends java.lang.Object
```
Some possibly handle geometric conversions.

Author:

SkiBu Smith

Field Summary

Fields
Modifier and Type Field and Description

static float KPH_TO_MPS

static float MPH_TO_MPS

static float MPS_TO_MPH

static double RADIUS_OF_EARTH_IN_METERS

Fields
Modifier and Type	Field and Description
`static float`	`KPH_TO_MPS`
`static float`	`MPH_TO_MPS`
`static float`	`MPS_TO_MPH`
`static double`	`RADIUS_OF_EARTH_IN_METERS`

Constructor Summary

Constructors
Constructor and Description

Geo()

Constructors
Constructor and Description
`Geo()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static float`	`converKmPerHrToMetersPerSecond(float kmPerHr)`
`static double`	`distance(Location l1, Location l2)` Returns the distance between two locations.
`static double`	`distance(Location loc, Vector vector)` Determines the distance between a location and a vector.
`static java.lang.String`	`distanceFormat(double arg)` For formatting distances in meters to consistent 2 decimal places.
`static double`	`distanceHaversine(Location l1, Location l2)` Returns the distance between two locations.
`static double`	`distanceIfMatch(Location loc, Vector vector)` Same as distance() but returns NaN if the location is not along the vector.
`static java.lang.String`	`format(double arg)` For formatting latitudes and longitudes to consistent 5 decimal places
`static java.lang.String`	`headingFormat(float arg)` Outputs heading in degrees with just a single digit past the decimal point.
`static boolean`	`headingOK(float vehicleHeading, float segmentheading, float allowableDelta)` Returns true if the heading specified by vehicleHeading is within the allowableDelta of segmentHeading.
`static void`	`main(java.lang.String[] args)` Just for debugging
`static double`	`matchDistanceAlongVector(Location loc, Vector vector)` Determines best match of location to the vector.
`static Location`	`offset(Location l, double deltaX, double deltaY)` Returns the Location l offset by deltaX and deltaY.
`static java.lang.String`	`oneDigitFormat(double value)` Outputs arg with just a single digit.
`static Location`	`rightOffsetBeginningLoc(Location l1, Location l2, double distance)` For determining an offset path that is the distance away from the original path.
`static Location`	`rightOffsetEndLoc(Location l1, Location l2, double distance)` Just like rightOffsetBeginningLoc() except offsets l2 instead of l1.
`static Location`	`rightOffsetVertex(Location l1, Location vertex, Location l2, double distance)` For shifting a path to the right.
`static java.lang.String`	`speedFormat(float arg)` Outputs speed in m/s with just a single digit past the decimal point.

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

- Field Detail
  - KPH_TO_MPS
```
public static final float KPH_TO_MPS
```
    See Also:
    
    Constant Field Values
  - MPH_TO_MPS
```
public static final float MPH_TO_MPS
```
    See Also:
    
    Constant Field Values
  - MPS_TO_MPH
```
public static final float MPS_TO_MPH
```
    See Also:
    
    Constant Field Values
  - RADIUS_OF_EARTH_IN_METERS
```
public static final double RADIUS_OF_EARTH_IN_METERS
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - Geo
```
public Geo()
```
- Method Detail
  - format
```
public static java.lang.String format(double arg)
```
    For formatting latitudes and longitudes to consistent 5 decimal places
  - distanceFormat
```
public static java.lang.String distanceFormat(double arg)
```
    For formatting distances in meters to consistent 2 decimal places. Appends "m" to indicate units.
    
    Parameters:
    
    arg -
    
    Returns:
  - oneDigitFormat
```
public static java.lang.String oneDigitFormat(double value)
```
    Outputs arg with just a single digit. No other formatting is done. Useful when want to output speed or heading but don't want to include units.
    
    Parameters:
    
    value -
    
    Returns:
  - headingFormat
```
public static java.lang.String headingFormat(float arg)
```
    Outputs heading in degrees with just a single digit past the decimal point. Appends "deg" to indicate units.
    
    Parameters:
    
    arg -
    
    Returns:
  - speedFormat
```
public static java.lang.String speedFormat(float arg)
```
    Outputs speed in m/s with just a single digit past the decimal point. Appends "m/s" to indicate units.
    
    Parameters:
    
    arg -
    
    Returns:
  - converKmPerHrToMetersPerSecond
```
public static float converKmPerHrToMetersPerSecond(float kmPerHr)
```
  - distanceHaversine
```
public static double distanceHaversine(Location l1,
                                       Location l2)
```
    Returns the distance between two locations. Uses the "haversine" formula to calculate the great-circle distance between two points. Therefore it is quite accurate, even over longer distances. But it requires more trigonometric calculations so runs slower than distance(). Difference in speed is approximately a factor of 3-4, but it should be noted that it still runs very fast. On an old laptop running in Eclipse took 400msec for calculating 1 million distances. So talking about 2.5 million distance calculations per second!
    
    Parameters:
    
    l1 -
    
    l2 -
    
    Returns:
  - distance
```
public static double distance(Location l1,
                              Location l2)
```
    Returns the distance between two locations. This method is quicker than distanceHaversine() because it just uses Pythagoras theorem and assumes a equirectangular projection. But it should be fine for relatively small distances, such as would get with a city.
    
    Parameters:
    
    l1 -
    
    l2 -
    
    Returns:
  - offset
```
public static Location offset(Location l,
                              double deltaX,
                              double deltaY)
```
    Returns the Location l offset by deltaX and deltaY.
    
    Parameters:
    
    l -
    
    deltaX -
    
    deltaY -
    
    Returns:
  - distance
```
public static double distance(Location loc,
                              Vector vector)
```
    Determines the distance between a location and a vector. Looks for a line between the location that is orthogonal to the line representing the vector. If the intersection with the line would actually be before or after the vector then the distance from the location to the corresponding end point of the vector is returned. But if the intersection of the orthogonal line to the vector line is within the vector then the length of the orthogonal line is returned. There are other algorithms that can be more efficient, but they are for Cartesian space. See http://geomalgorithms.com/a02-_lines.html for an example. But since using latitudes & longitudes on a sphere need to do things differently. Instead, need to just use distances between locations.
    
    Parameters:
    
    vector -
    
    loc -
  - distanceIfMatch
```
public static double distanceIfMatch(Location loc,
                                     Vector vector)
```
    Same as distance() but returns NaN if the location is not along the vector. In other words, if closest match to the vector is beyond the beginning or end of the vector then it is not considered along the vector and NaN is returned.
    
    Parameters:
    
    loc -
    
    vector -
    
    Returns:
    
    Distance from loc to vector if loc matches to vector. Otherwise, NaN.
  - matchDistanceAlongVector
```
public static double matchDistanceAlongVector(Location loc,
                                              Vector vector)
```
    Determines best match of location to the vector. Returns the distance along the vector to that match. Uses same basic algorithm as distance().
    
    Parameters:
    
    loc -
    
    vector -
    
    Returns:
  - rightOffsetVertex
```
public static Location rightOffsetVertex(Location l1,
                                         Location vertex,
                                         Location l2,
                                         double distance)
```
    For shifting a path to the right. This is useful when the path data is simply centerline street data, where the stopPaths for the different directions overlap each other. By displacing the stopPaths to the right a bit they don't overlap when zoomed in. This method takes in three locations that define two vectors and hence the vertex that needs to be relocated. This method determines a stub line that goes from the vertex parameter to the new offset location. The stub line should be such that when connecting all the new vertexes they new stopPaths will be the distance specified from the old path. The result will often not be exactly the distance away from the original vertex because if the angle between the vectors is greater than 180 degrees than the stub would need to be longer than the distance specified in order for the new stopPaths to be the distance away from the old stopPaths. But this would be problematic because really sharp turns could cause the stub to be incredibly long. Therefore it is limited to 1.5 of distance.
    
    Parameters:
    
    l1 -
    
    vertex -
    
    l2 -
    
    distance - to offset location l1 to the right. If negative then offset to the left.
    
    Returns:
    
    New vertex that is roughly the distance away from the specified vertex.
  - rightOffsetBeginningLoc
```
public static Location rightOffsetBeginningLoc(Location l1,
                                               Location l2,
                                               double distance)
```
    For determining an offset path that is the distance away from the original path. Useful for when centerline data used for shapes. This allows the stopPaths in the different directions to not completely overlap. This method is for determining the offset for a first or last point of a set of points that define a shape/path.
    
    Parameters:
    
    l1 - for specifying vector
    
    l2 - for specifying vector
    
    distance - to offset location l1 to the right. If negative then offset to the left.
    
    Returns:
  - rightOffsetEndLoc
```
public static Location rightOffsetEndLoc(Location l1,
                                         Location l2,
                                         double distance)
```
    Just like rightOffsetBeginningLoc() except offsets l2 instead of l1.
    
    Parameters:
    
    l1 - for specifying vector
    
    l2 - for specifying vector
    
    distance - to offset location l1 to the right. If negative then offset to the left.
    
    Returns:
  - main
```
public static void main(java.lang.String[] args)
```
    Just for debugging
    
    Parameters:
    
    args -
  - headingOK
```
public static boolean headingOK(float vehicleHeading,
                                float segmentheading,
                                float allowableDelta)
```
    Returns true if the heading specified by vehicleHeading is within the allowableDelta of segmentHeading. All angles are expressed in degrees.
    
    Parameters:
    
    vehicleHeading - Heading of vehicle. If Float.NaN then method will return true
    
    segmentheading -
    
    allowableDelta -
    
    Returns:

Class Geo

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

KPH_TO_MPS

MPH_TO_MPS

MPS_TO_MPH

RADIUS_OF_EARTH_IN_METERS

Constructor Detail

Geo

Method Detail

format

distanceFormat

oneDigitFormat

headingFormat

speedFormat

converKmPerHrToMetersPerSecond

distanceHaversine

distance

offset

distance

distanceIfMatch

matchDistanceAlongVector

rightOffsetVertex

rightOffsetBeginningLoc

rightOffsetEndLoc

main

headingOK