## Uses of Class
com.bbn.openmap.geo.Geo

Packages that use Geo
com.bbn.openmap.geo: Package that contains classes to do calculations in lat/lon space.
com.bbn.openmap.layer.test: Provides a test layer for OpenMap.
com.bbn.openmap.omGraphics: Provides geographically based graphics classes.

Uses of Geo in com.bbn.openmap.geo

Fields in com.bbn.openmap.geo declared as Geo
`protected Geo` `Rotation.g`
`protected Geo` `RibbonIterator.v1`
`protected Geo` `RibbonIterator.v2`
`protected Geo` `RibbonIterator.gc`
`protected Geo` `RibbonIterator.point`
`protected Geo[]` `GeoSegment.Impl.seg`
`protected Geo` `GeoPoint.Impl.point`
`static Geo` `Geo.north` North pole.
`protected Geo` `BoundaryCrossing.geo` The Geo location of the crossing.

Methods in com.bbn.openmap.geo that return Geo
`Geo` `Rotation.rotate(Geo v)`
`static Geo` `Rotation.rotate(Geo v1, double angle, Geo v2, Geo ret)` Static method that does what creating a Rotation object can calling rotate() on it does.
`Geo` `Ribbon.get(int which)` Get the Geo for the Ribbon.
`static Geo` `Intersection.getIntersectionGeo(float lat1, float lon1, float lat2, float lon2, float lat3, float lon3, float lat4, float lon4)` Returns a Geo representing the interection of two great circles defined by the arcs (lat1, lon1) to (lat2, lon2) and (lat2, lon2) to (lat4, lon4).
`static Geo` `Intersection.segIntersection(Geo a, Geo b, Geo c)`
`static Geo` `Intersection.center(Geo[] poly)` Returns the center of the polygon poly.
`static Geo` `Intersection.center(Geo[] poly, Geo ret)` Returns the center of the polygon poly.
`static Geo` `Intersection.center(GeoArray poly)` Returns the center of the polygon poly.
`static Geo` `Intersection.center(GeoArray poly, Geo ret)` Returns the center of the polygon poly.
`static Geo[]` `Intersection.getSegIntersection(Geo p1, Geo p2, Geo p3, Geo p4)` Find the intersection(s) between [p1-p2] and [p3-p4]
`static Geo` `Intersection.isSegmentNearPoly(GeoSegment segment, GeoArray r, double near)` Where is a segment within range of a region?
`static Geo` `Intersection.isSegmentNearPoly(Geo s1, Geo s2, GeoArray r, double near)` Is a segment, represented by endpoints 's1' and 's2', withing a range 'near' of region 'r'?
`static Geo` `Intersection.isPolyNearPoly(GeoArray s, GeoArray r, double near)` Is one region's boundary within 'near' range of a region? Note: good practice is s describes a smaller area than r.
`static Geo` `Intersection.segmentsIntersect(Geo a1, Geo a2, Geo b1, Geo b2)`
`static Geo` `Intersection.segmentsIntersectOrNear(Geo a1, Geo a2, Geo b1, Geo b2, double r)`
`static Geo` `Intersection.segmentsIntersectOrNear(Geo a1, Geo a2, Geo b1, Geo b2, double r, Geo ret)`
`Geo[]` `GeoSegment.getSeg()`
`Geo[]` `GeoSegment.Impl.getSeg()`
`Geo` `GeoPoint.getPoint()` return the current point as a Geo object
`Geo` `GeoPoint.Impl.getPoint()`
`Geo[]` `GeoPath.Impl.SegIt.getSeg()` GSegment method.
`Geo` `GeoPath.Impl.PointIt.getPoint()`
`Geo` `GeoArray.get(int i)` Get a Geo represented by the index i.
`Geo` `GeoArray.get(int i, Geo ret)` Load the values for Geo at index i into ret.
`Geo[]` `GeoArray.toPointArray()` Convert the GeoArray to an array of Geos.
`Geo[]` `GeoArray.Adapter.toPointArray()` Convert the GeoArray to an array of Geos.
`Geo` `GeoArray.Float.get(int i)`
`Geo` `GeoArray.Float.get(int i, Geo ret)`
`Geo` `GeoArray.Double.get(int i)`
`Geo` `GeoArray.Double.get(int i, Geo ret)`
`static Geo` `Geo.makeGeoRadians(double latr, double lonr)`
`static Geo` `Geo.makeGeoDegrees(double latd, double lond)`
`static Geo` `Geo.makeGeo(double x, double y, double z)`
`static Geo` `Geo.makeGeo(Geo p)`
`Geo` `Geo.midPoint(Geo g2)` Find the midpoint Geo between this one and another on a Great Circle line between the two.
`Geo` `Geo.midPoint(Geo g2, Geo ret)` Find the midpoint Geo between this one and another on a Great Circle line between the two.
`Geo` `Geo.interpolate(Geo g2, double x)`
`Geo` `Geo.interpolate(Geo g2, double x, Geo ret)`
`Geo` `Geo.scale(double s)` Multiply this by s.
`Geo` `Geo.scale(double s, Geo ret)` Multiply this by s.
`Geo` `Geo.normalize()` Returns a unit length vector parallel to this.
`Geo` `Geo.normalize(Geo ret)` Returns a unit length vector parallel to this.
`Geo` `Geo.cross(Geo b)` Vector cross product.
`Geo` `Geo.cross(Geo b, Geo ret)` Vector cross product.
`Geo` `Geo.crossNormalize(Geo b)` Eqvivalent to `this.cross(b).normalize()`.
`Geo` `Geo.crossNormalize(Geo b, Geo ret)` Eqvivalent to `this.cross(b).normalize()`.
`static Geo` `Geo.crossNormalize(Geo a, Geo b, Geo ret)` Eqvivalent to `this.cross(b).normalize()`.
`Geo` `Geo.add(Geo b)` Returns this + b.
`Geo` `Geo.add(Geo b, Geo ret)`
`Geo` `Geo.subtract(Geo b)` Returns this - b.
`Geo` `Geo.subtract(Geo b, Geo ret)` Returns this - b.
`Geo` `Geo.antipode()` Returns the point opposite this point on the earth.
`Geo` `Geo.antipode(Geo ret)` Returns the point opposite this point on the earth.
`Geo` `Geo.intersect(Geo q, Geo r)` Find the intersection of the great circle between this and q and the great circle normal to r.
`Geo` `Geo.intersect(Geo q, Geo r, Geo ret)` Find the intersection of the great circle between this and q and the great circle normal to r.
`static Geo[]` `Geo.computeCorridor(Geo[] path, double radius)` alias for computeCorridor(path, radius, radians(10), true) *
`static Geo[]` `Geo.computeCorridor(Geo[] path, double radius, double err, boolean capp)` Wrap a fixed-distance corridor around an (open) path, as specified by an array of Geo.
`static Geo[]` `Geo.approximateArc(Geo pc, Geo p0, Geo p1, double err)` compute a polygonal approximation of an arc centered at pc, beginning at p0 and ending at p1, going clockwise and including the two end points.
`Geo[]` `Geo.approximateArc(Geo p0, Geo p1, double err)`
`Geo` `Geo.geoAt(double distance, double azimuth)` Deprecated. use #offset(double, double)
`Geo` `Geo.offset(double distance, double azimuth)` Returns a Geo that is distance (radians), and azimuth (radians) away from this.
`Geo` `Geo.offset(double distance, double azimuth, Geo ret)` Returns a Geo that is distance (radians), and azimuth (radians) away from this.
`static Geo` `Geo.offset(Geo origin, double distance, double azimuth)`
`static Geo` `Geo.offset(Geo origin, double distance, double azimuth, Geo ret)`
`static Geo[]` `Geo.posToGa(java.lang.String coords)` convert a String containing space-separated pairs of comma-separated decimal lat-lon pairs into a Geo array.
`static Geo[]` `Geo.posToGa(java.lang.String[] coords)` Convert an array of strings with comma-separated decimal lat,lon pairs into a Geo array
`static Geo[]` `Geo.removeDups(Geo[] ga)` Return a Geo array with the duplicates removed.
`static Geo[]` `Geo.LLaToGa(float[] lla)` Convert a float array of alternating lat and lon pairs into a Geo array.
`static Geo[]` `Geo.LLaToGa(float[] lla, boolean isDegrees)` Convert a float array of alternating lat and lon pairs into a Geo array.
`static Geo[]` `Geo.LLaToGa(double[] lla)` Convert a double array of alternating lat and lon pairs into a Geo array.
`static Geo[]` `Geo.LLaToGa(double[] lla, boolean isDegrees)` Convert a double array of alternating lat and lon pairs into a Geo array.
`static Geo[]` `Geo.closeGa(Geo[] ga)` return a Geo array where the first and last elements are the same, thus closing the path, by adding a point if needed.
`static Geo[]` `ConvexHull.hull(Geo[] geos)` Using Graham's scan.
`protected static Geo` `ConvexHull.findHighest(Geo[] geos)`
`Geo` `ConvexHull.PivotAngleComparator.getPivot()`
`Geo` `BoundingCircle.getCenter()` Returns a Geo representing the center of the circle.
`Geo` `BoundingCircle.Impl.getCenter()`
`Geo` `BoundaryCrossing.getGeo()`

Methods in com.bbn.openmap.geo with parameters of type Geo
`Geo` `Rotation.rotate(Geo v)`
`static Geo` `Rotation.rotate(Geo v1, double angle, Geo v2, Geo ret)` Static method that does what creating a Rotation object can calling rotate() on it does.
`static float` `Intersection.pointCircleDistanceNM(Geo p1, Geo p2, Geo center)` Calculates the great circle distance from the point (lat, lon) to the great circle containing the points (lat1, lon1) and (lat2, lon2).
`static double` `Intersection.pointCircleDistance(Geo p1, Geo p2, Geo center)` Calculates the great circle distance from the point (lat, lon) to the great circle containing the points (lat1, lon1) and (lat2, lon2).
`static boolean` `Intersection.isOnSegment(Geo a, Geo b, Geo i)` Point i is on the great circle defined by the points a and b.
`static boolean` `Intersection.isOnSegment(Geo a, Geo b, Geo i, double withinRad)` Returns true if i is on the great circle between a and b and between them, false otherwise.
`static Geo` `Intersection.segIntersection(Geo a, Geo b, Geo c)`
`static boolean` `Intersection.segIntersects(Geo p1, Geo p2, Geo p3, Geo p4)` Test if [p1-p2] and [p3-p4] intersect
`static double` `Intersection.pointSegDistance(Geo a, Geo b, Geo c)` Returns the distance in radians between the point c and the point of intersection of the great circle passing through c and perpendicular to great circle segment between a and b.
`static boolean` `Intersection.intersectsCircle(Geo p1, Geo p2, Geo center, double radius)` Returns true or false depending on whether the great circle seg from point p1 to point p2 intersects the circle of radius (radians) around center.
`static Geo` `Intersection.center(Geo[] poly)` Returns the center of the polygon poly.
`static Geo` `Intersection.center(Geo[] poly, Geo ret)` Returns the center of the polygon poly.
`static Geo` `Intersection.center(GeoArray poly, Geo ret)` Returns the center of the polygon poly.
`static boolean` `Intersection.isPointInPolygon(Geo x, GeoArray poly)` Determines whether `x` is inside `poly`.
`static boolean` `Intersection.isPointInPolygon(Geo x, float[] poly, boolean polyInDegrees)` Ask if a Geo point is in a polygon.
`static Geo[]` `Intersection.getSegIntersection(Geo p1, Geo p2, Geo p3, Geo p4)` Find the intersection(s) between [p1-p2] and [p3-p4]
`static boolean` `Intersection.isSegmentNearRadialRegion(GeoSegment segment, Geo rCenter, double rRadius, double near)` Does the segment come within near radians of the region defined by rCenter at rRadius?
`static boolean` `Intersection.isSegmentNearRadialRegion(Geo s1, Geo s2, Geo rCenter, double rRadius, double near)` Does the segment come within near radians of the region defined by rCenter at rRadius?
`static boolean` `Intersection.isSegmentNearPolyRegion(Geo s1, Geo s2, GeoArray r, double near)` Does the segment s1-s2 come within near radians of the region defined by the polygon in r[*]? Catches segments within poly region and returns after first hit, which is why it returns boolean.
`static Geo` `Intersection.isSegmentNearPoly(Geo s1, Geo s2, GeoArray r, double near)` Is a segment, represented by endpoints 's1' and 's2', withing a range 'near' of region 'r'?
`static java.util.List` `Intersection.segmentNearPoly(Geo s1, Geo s2, GeoArray r, double near)` Where is a segment, represented by endpoints 's1' and 's2', withing a range 'near' of region 'r'?
`static boolean` `Intersection.isPointNearPoly(Geo s, GeoArray r, double near)` Does the point s come within 'near' radians of the boarder of the region defined by the polygon in r[*]?
`static Geo` `Intersection.segmentsIntersect(Geo a1, Geo a2, Geo b1, Geo b2)`
`static Geo` `Intersection.segmentsIntersectOrNear(Geo a1, Geo a2, Geo b1, Geo b2, double r)`
`static Geo` `Intersection.segmentsIntersectOrNear(Geo a1, Geo a2, Geo b1, Geo b2, double r, Geo ret)`
`boolean` `GeoRegion.isPointInside(Geo point)` Is the Geo inside the region?
`boolean` `GeoRegion.Impl.isPointInside(Geo p)`
`protected void` `GeoPath.Impl.setPoints(Geo[] points)` Method for subclasses to set pts and length of Geos.
`Geo` `GeoArray.get(int i, Geo ret)` Load the values for Geo at index i into ret.
`boolean` `GeoArray.equals(int index, Geo comp)`
`void` `GeoArray.Mutable.set(int i, Geo g)` Set the values for the provided index to the values represented by g.
`void` `GeoArray.Float.set(int i, Geo g)`
`Geo` `GeoArray.Float.get(int i, Geo ret)`
`boolean` `GeoArray.Float.equals(int index, Geo comp)`
`void` `GeoArray.Double.set(int i, Geo g)`
`Geo` `GeoArray.Double.get(int i, Geo ret)`
`boolean` `GeoArray.Double.equals(int index, Geo comp)`
`static Geo` `Geo.makeGeo(Geo p)`
`void` `Geo.initialize(Geo g)` Initialize this Geo to match another.
`Geo` `Geo.midPoint(Geo g2)` Find the midpoint Geo between this one and another on a Great Circle line between the two.
`Geo` `Geo.midPoint(Geo g2, Geo ret)` Find the midpoint Geo between this one and another on a Great Circle line between the two.
`Geo` `Geo.interpolate(Geo g2, double x)`
`Geo` `Geo.interpolate(Geo g2, double x, Geo ret)`
`double` `Geo.dot(Geo b)` Dot product.
`static double` `Geo.dot(Geo a, Geo b)` Dot product.
`Geo` `Geo.scale(double s, Geo ret)` Multiply this by s.
`Geo` `Geo.normalize(Geo ret)` Returns a unit length vector parallel to this.
`Geo` `Geo.cross(Geo b)` Vector cross product.
`Geo` `Geo.cross(Geo b, Geo ret)` Vector cross product.
`double` `Geo.crossLength(Geo b)` Eqvivalent to this.cross(b).length().
`Geo` `Geo.crossNormalize(Geo b)` Eqvivalent to `this.cross(b).normalize()`.
`Geo` `Geo.crossNormalize(Geo b, Geo ret)` Eqvivalent to `this.cross(b).normalize()`.
`static Geo` `Geo.crossNormalize(Geo a, Geo b, Geo ret)` Eqvivalent to `this.cross(b).normalize()`.
`Geo` `Geo.add(Geo b)` Returns this + b.
`Geo` `Geo.add(Geo b, Geo ret)`
`Geo` `Geo.subtract(Geo b)` Returns this - b.
`Geo` `Geo.subtract(Geo b, Geo ret)` Returns this - b.
`boolean` `Geo.equals(Geo v2)`
`double` `Geo.distance(Geo v2)` Angular distance, in radians between this and v2.
`static double` `Geo.distance(Geo v1, Geo v2)` Angular distance, in radians between v1 and v2.
`double` `Geo.distanceKM(Geo v2)` Distance in kilometers.
`static double` `Geo.distanceKM(Geo v1, Geo v2)` Distance in kilometers.
`double` `Geo.distanceNM(Geo v2)` Distance in nautical miles.
`static double` `Geo.distanceNM(Geo v1, Geo v2)` Distance in nautical miles.
`double` `Geo.azimuth(Geo v2)` Azimuth in radians from this to v2.
`static double` `Geo.angle(Geo p0, Geo p1, Geo p2)` Given 3 points on a sphere, p0, p1, p2, return the angle between them in radians.
`boolean` `Geo.isInside(Geo v2, double radius, Geo p)` Is the point, p, within radius radians of the great circle segment between this and v2?
`static boolean` `Geo.isInside(Geo v1, Geo v2, double radius, Geo p1, Geo p2)` do the segments v1-v2 and p1-p2 come within radius (radians) of each other?
`boolean` `Geo.inBubble(Geo v2, double forwardRadius, double backRadius, Geo p)` Is Geo p inside the time bubble along the great circle segment from this to v2 looking forward forwardRadius and backward backwardRadius.
`Geo` `Geo.antipode(Geo ret)` Returns the point opposite this point on the earth.
`Geo` `Geo.intersect(Geo q, Geo r)` Find the intersection of the great circle between this and q and the great circle normal to r.
`Geo` `Geo.intersect(Geo q, Geo r, Geo ret)` Find the intersection of the great circle between this and q and the great circle normal to r.
`static Geo[]` `Geo.computeCorridor(Geo[] path, double radius)` alias for computeCorridor(path, radius, radians(10), true) *
`static Geo[]` `Geo.computeCorridor(Geo[] path, double radius, double err, boolean capp)` Wrap a fixed-distance corridor around an (open) path, as specified by an array of Geo.
`static Geo[]` `Geo.approximateArc(Geo pc, Geo p0, Geo p1, double err)` compute a polygonal approximation of an arc centered at pc, beginning at p0 and ending at p1, going clockwise and including the two end points.
`Geo[]` `Geo.approximateArc(Geo p0, Geo p1, double err)`
`Geo` `Geo.offset(double distance, double azimuth, Geo ret)` Returns a Geo that is distance (radians), and azimuth (radians) away from this.
`static Geo` `Geo.offset(Geo origin, double distance, double azimuth)`
`static Geo` `Geo.offset(Geo origin, double distance, double azimuth, Geo ret)`
`static double[]` `Geo.GaToLLa(Geo[] ga, double[] lla)` Convert a Geo array into a floating point lat lon array (alternating lat and lon values).
`static float[]` `Geo.GaToLLa(Geo[] ga, float[] lla)` Convert a Geo array into a floating point lat lon array (alternating lat and lon values).
`static float[]` `Geo.GaToLLa(Geo[] ga)` Convert a Geo array into a floating point lat lon array (alternating lat and lon values)
`static Geo[]` `Geo.removeDups(Geo[] ga)` Return a Geo array with the duplicates removed.
`static Geo[]` `Geo.closeGa(Geo[] ga)` return a Geo array where the first and last elements are the same, thus closing the path, by adding a point if needed.
`static GeoRegion` `ConvexHull.getRegion(Geo[] geos)` Using Graham's scan.
`static Geo[]` `ConvexHull.hull(Geo[] geos)` Using Graham's scan.
`protected static Geo` `ConvexHull.findHighest(Geo[] geos)`
`boolean` `BoundingCircle.intersects(Geo g, double radius)`
`protected void` `BoundingCircle.Impl.init(Geo[] region)` Works by computing the centroid, then finding the largest radius.
`protected void` `BoundingCircle.Impl.init(Geo center, double radius)`
`boolean` `BoundingCircle.Impl.intersects(Geo g, double r)`

Constructors in com.bbn.openmap.geo with parameters of type Geo
`Rotation(Geo g, double angle)`
`RibbonIterator(Geo v1, Geo v2, double radius)` Return an iterator that returns Ribbons along the great circle between v1 and v2.
`Ribbon(Geo x, Geo gc, double radius)` Create a Ribbon at the point x along the great circle who's normal is gc, and radius is the distance appart in radians.
`RadialRegion(Geo center, double radius)`
`RadialRegion(Geo[] region)`
`GeoSegment.Impl(Geo[] segment)` Create a GeoSegment.Impl with an array of 2 Geos.
`GeoRegion.Impl(Geo[] coords)`
`GeoPoint.Impl(Geo p)`
`GeoPath.Impl(Geo[] geos)` Create a path from Geos.
`GeoArray.Float(Geo[] geos)`
`GeoArray.Double(Geo[] geos)`
`Geo(Geo geo)` Construct a Geo from another Geo.
`ConvexHull.PivotAngleComparator(Geo pivot)`
`BoundingCircle.Impl(Geo center, double radius)`
`BoundingCircle.Impl(Geo[] gs)`
`BoundaryCrossing(Geo p, GeoRegion r, boolean goinin)` Creates the BoundaryCrossing.

Uses of Geo in com.bbn.openmap.layer.test

Methods in com.bbn.openmap.layer.test that return Geo
`Geo[]` `GeoIntersectionLayer.OMLineSegment.getSeg()`

Uses of Geo in com.bbn.openmap.omGraphics

Methods in com.bbn.openmap.omGraphics with parameters of type Geo
`OMText` `OMDistance.createLabel(Geo g1, Geo g2, float dist, float cumulativeDist, Length distanceUnits)` Get an OMText label for a segments between the given lat/lon points whose given distance and cumulative distance is specified.
`float` `OMDistance.getDist(Geo g1, Geo g2)` Return the distance between that lat/lons defined in radians.

Copyright (C) BBNT Solutions LLC; See http://openmap.bbn.com/ for details