Uses of Class com.bbn.openmap.geo.Geo (OpenMap API)
Date: 2016-12-09

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

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

Packages that use Geo
com.bbn.openmap.event | Provides the various event object and listener interfaces for using the MapBean.
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.
com.bbn.openmap.omGraphics.util | This package contains simple utility classes used specifically for OMGraphics.

Uses of Geo in com.bbn.openmap.event

Methods in com.bbn.openmap.event with parameters of type Geo
`protected void` | `RangeRingsMouseMode.paintCircle(Geo originGeo, double distance, java.awt.Graphics graphics, MapBean theMap)` Paints a unique circle centered on `origin` and which crosses `dest` on the given Graphics.
`protected void` | `RangeRingsMouseMode.paintLabel(Geo originGeo, double distance, java.awt.Graphics graphics, MapBean theMap)` Paints a label for the circle drawn using `dest` on the given Graphics.

Uses of Geo in com.bbn.openmap.geo

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

Methods in com.bbn.openmap.geo that return Geo
`Geo` | `Geo.add(Geo b)` Returns this + b.
`Geo` | `Geo.add(Geo b, Geo ret)`
`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.approximateArc(Geo p0, Geo p1, double err)`
`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.
`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[]` | `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[]` | `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.
`Geo` | `Geo.cross(Geo b)` Vector cross product.
`Geo` | `Geo.cross(Geo b, Geo ret)` Vector cross product.
`Geo` | `Geo.crossNormalize(Geo b)` Equivalent to `this.cross(b).normalize()`.
`Geo` | `Geo.crossNormalize(Geo b, Geo ret)` Equivalent to `this.cross(b).normalize()`.
`static Geo` | `Geo.crossNormalize(Geo a, Geo b, Geo ret)` Equivalent to `this.cross(b).normalize()`.
`protected static Geo` | `ConvexHull.findHighest(Geo[] geos)`
`Geo` | `Geo.geoAt(double distance, double azimuth)` Deprecated. use #offset(double, double)
`Geo` | `Ribbon.get(int which)` Get the Geo for the Ribbon.
`Geo` | `GeoArray.get(int i)` Get a Geo represented by the index i.
`Geo` | `GeoArray.Float.get(int i)`
`Geo` | `GeoArray.Double.get(int i)`
`Geo` | `GeoArray.get(int i, Geo ret)` Load the values for Geo at index i into ret.
`Geo` | `GeoArray.Float.get(int i, Geo ret)`
`Geo` | `GeoArray.Double.get(int i, Geo ret)`
`Geo` | `BoundingCircle.getCenter()` Returns a Geo representing the center of the circle.
`Geo` | `BoundingCircle.Impl.getCenter()`
`Geo` | `OMGeo.Pt.getGeo()`
`Geo` | `BoundaryCrossing.getGeo()`
`Geo[]` | `OMGeo.Line.getGeoArray()`
`static Geo` | `Intersection.getIntersectionGeo(double lat1, double lon1, double lat2, double lon2, double lat3, double lon3, double lat4, double lon4)` Returns a Geo representing the intersection of two great circles defined by the arcs (lat1, lon1) to (lat2, lon2) and (lat2, lon2) to (lat4, lon4).
`Geo` | `ConvexHull.PivotAngleComparator.getPivot()`
`Geo` | `OMGeo.Pt.getPoint()`
`Geo` | `GeoPoint.getPoint()` return the current point as a Geo object
`Geo` | `GeoPoint.Impl.getPoint()`
`Geo` | `GeoPath.Impl.PointIt.getPoint()`
`Geo[]` | `OMGeo.Line.getSeg()`
`Geo[]` | `GeoSegment.getSeg()`
`Geo[]` | `GeoSegment.Impl.getSeg()`
`Geo[]` | `GeoPath.Impl.SegIt.getSeg()` GSegment method.
`static Geo[]` | `Intersection.getSegIntersection(Geo p1, Geo p2, Geo p3, Geo p4)` Find the intersection(s) between [p1-p2] and [p3-p4]
`static Geo[]` | `ConvexHull.hull(Geo[] geos)` Using Graham's scan.
`static Geo[]` | `ConvexHull.hull(Geo[] geos, double tolerance)` Using Graham's scan.
`Geo` | `Geo.interpolate(Geo g2, double x)`
`Geo` | `Geo.interpolate(Geo g2, double x, Geo ret)`
`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` | `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.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.isSegmentNearPoly(GeoSegment segment, GeoArray r, double near)` Where is a segment within range of a region?
`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.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.makeGeo(double x, double y, double z)`
`static Geo` | `Geo.makeGeo(Geo p)`
`static Geo` | `Geo.makeGeoDegrees(double latd, double lond)`
`static Geo` | `Geo.makeGeoRadians(double latr, double lonr)`
`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.normalize()` Returns a unit length vector parallel to this.
`Geo` | `Geo.normalize(Geo ret)` Returns a unit length vector parallel to this.
`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.
`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` | `Geo.scale(double s)` Multiply this by s.
`Geo` | `Geo.scale(double s, Geo ret)` Multiply this by s.
`static Geo` | `Intersection.segIntersection(Geo a, Geo b, Geo c)`
`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` | `Geo.subtract(Geo b)` Returns this - b.
`Geo` | `Geo.subtract(Geo b, Geo ret)` Returns this - b.
`Geo[]` | `GeoArray.toPointArray()` Convert the GeoArray to an array of Geos.
`Geo[]` | `GeoArray.Adapter.toPointArray()` Convert the GeoArray to an array of Geos.

Methods in com.bbn.openmap.geo that return types with arguments of type Geo
`static java.util.List<Geo>` | `Intersection.polyNearPoly(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 java.util.List<Geo>` | `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 java.util.List<Geo>` | `Intersection.segmentNearPoly(GeoSegment segment, GeoArray r, double near)` Where is a segment within range of a region?

Methods in com.bbn.openmap.geo with parameters of type Geo
`Geo` | `Geo.add(Geo b)` Returns this + b.
`Geo` | `Geo.add(Geo b, Geo ret)`
`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.
`Geo` | `Geo.antipode(Geo ret)` Returns the point opposite this point on the earth.
`Geo[]` | `Geo.approximateArc(Geo p0, Geo p1, double err)`
`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.
`double` | `Geo.azimuth(Geo v2)` Azimuth in radians from v2 to this.
`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(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 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[]` | `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.
`Geo` | `Geo.cross(Geo b)` Vector cross product.
`Geo` | `Geo.cross(Geo b, Geo ret)` Vector cross product.
`double` | `Geo.crossLength(Geo b)` Equivalent to this.cross(b).length().
`Geo` | `Geo.crossNormalize(Geo b)` Equivalent to `this.cross(b).normalize()`.
`Geo` | `Geo.crossNormalize(Geo b, Geo ret)` Equivalent to `this.cross(b).normalize()`.
`static Geo` | `Geo.crossNormalize(Geo a, Geo b, Geo ret)` Equivalent to `this.cross(b).normalize()`.
`double` | `Geo.distance(Geo v2)` Angular distance, in radians between this and v2.
`double` | `GeoArray.distance(Geo geo, Geo closestPoint)` Returns the perpendicular distance to the closest point on the edge of the polygon.
`double` | `GeoArray.Adapter.distance(Geo pnt, Geo closestPoint)` Returns the perpendicular distance to the closest point on the edge of the polygon.
`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.dot(Geo b)` Dot product.
`static double` | `Geo.dot(Geo a, Geo b)` Dot product.
`boolean` | `GeoArray.equals(int index, Geo comp)`
`boolean` | `GeoArray.Float.equals(int index, Geo comp)`
`boolean` | `GeoArray.Double.equals(int index, Geo comp)`
`protected static Geo` | `ConvexHull.findHighest(Geo[] geos)`
`static float[]` | `Geo.GaToLLa(Geo[] ga)` Convert a Geo array into a floating point lat lon array (alternating lat and lon values)
`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).
`Geo` | `GeoArray.get(int i, Geo ret)` Load the values for Geo at index i into ret.
`Geo` | `GeoArray.Float.get(int i, Geo ret)`
`Geo` | `GeoArray.Double.get(int i, Geo ret)`
`static GeoRegion` | `ConvexHull.getRegion(Geo[] geos)` Using Graham's scan.
`static Geo[]` | `Intersection.getSegIntersection(Geo p1, Geo p2, Geo p3, Geo p4)` Find the intersection(s) between [p1-p2] and [p3-p4]
`static Geo[]` | `ConvexHull.hull(Geo[] geos)` Using Graham's scan.
`static Geo[]` | `ConvexHull.hull(Geo[] geos, double tolerance)` Using Graham's scan.
`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.
`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)`
`void` | `Geo.initialize(Geo g)` Initialize this Geo to match another.
`Geo` | `Geo.interpolate(Geo g2, double x)`
`Geo` | `Geo.interpolate(Geo g2, double x, Geo ret)`
`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.
`boolean` | `BoundingCircle.intersects(Geo g, double radius)`
`boolean` | `BoundingCircle.Impl.intersects(Geo g, double r)`
`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.
`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?
`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 boolean` | `Intersection.isPointInPolygon(Geo x, double[] poly, boolean polyInDegrees)` Ask if a Geo point is in a polygon.
`static boolean` | `Intersection.isPointInPolygon(Geo x, float[] poly, boolean polyInDegrees)` Ask if a Geo point is in a polygon.
`static boolean` | `Intersection.isPointInPolygon(Geo x, GeoArray poly)` Determines whether `x` is inside `poly`.
`static boolean` | `Intersection.isPointInPolygon(Geo x, GeoArray poly, Geo internal)`
`boolean` | `OMGeo.Polygon.isPointInside(Geo point)`
`boolean` | `GeoRegion.isPointInside(Geo point)` Is the Geo inside the region?
`boolean` | `GeoRegion.Impl.isPointInside(Geo p)`
`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.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 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 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.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 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.normalize(Geo ret)` Returns a unit length vector parallel to 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 double` | `Intersection.pointCircleDistance(Geo p1, Geo p2, Geo center)` Calculates the great circle distance from the point (center) to the great circle containing the points (p1) and (p2).
`static double` | `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.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 Geo[]` | `Geo.removeDups(Geo[] ga)` Return a Geo array with the duplicates removed.
`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` | `Geo.scale(double s, Geo ret)` Multiply this by s.
`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 java.util.List<Geo>` | `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 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)`
`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)`
`void` | `GeoArray.Double.set(int i, Geo g)`
`protected void` | `GeoPath.Impl.setPoints(Geo[] points)` Method for subclasses to set pts and length of Geos.
`double` | `Geo.strictAzimuth(Geo v2)` Azimuth in radians from v2 to this.
`Geo` | `Geo.subtract(Geo b)` Returns this - b.
`Geo` | `Geo.subtract(Geo b, Geo ret)` Returns this - b.

Method parameters in com.bbn.openmap.geo with type arguments of type Geo
`static double` | `Geo.area(java.util.Enumeration<Geo> vs)` Computes the area of a polygon on the surface of a unit sphere given an enumeration of its point.

Constructors in com.bbn.openmap.geo with parameters of type Geo
`BoundaryCrossing(Geo p, GeoRegion r, boolean goinin)` Creates the BoundaryCrossing.
`BoundingCircle.Impl(Geo[] gs)`
`BoundingCircle.Impl(Geo center, double radius)`
`ConvexHull.PivotAngleComparator(Geo pivot)`
`Geo(Geo geo)` Construct a Geo from another Geo.
`GeoArray.Double(Geo[] geos)`
`GeoArray.Float(Geo[] geos)`
`GeoPath.Impl(Geo[] geos)` Create a path from Geos.
`GeoPoint.Impl(Geo p)`
`GeoRegion.Impl(Geo[] coords)`
`GeoSegment.Impl(Geo[] segment)` Create a GeoSegment.Impl with an array of 2 Geos.
`OMGeo.Line(Geo[] gs)`
`OMGeo.Polygon(Geo[] gs)`
`OMGeo.Polyline(Geo[] gs)`
`OMGeo.Pt(Geo g)`
`RadialRegion(Geo[] region)`
`RadialRegion(Geo center, double radius)`
`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 apart in radians.
`RibbonIterator(Geo v1, Geo v2, double radius)` Return an iterator that returns Ribbons along the great circle between v1 and v2.
`RibbonIterator(Geo v1, Geo v2, double radius, double rotationIntervalDist)` Return an iterator that returns Ribbons along the great circle between v1 and v2.
`Rotation(Geo g, double angle)`

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, double dist, double cumulativeDist, Length distanceUnits)` Get an OMText label for a segments between the given lat/lon points whose given distance and cumulative distance is specified.
`double` | `OMDistance.getDist(Geo g1, Geo g2)` Return the distance between that lat/lons defined in radians.

Uses of Geo in com.bbn.openmap.omGraphics.util

Methods in com.bbn.openmap.omGraphics.util that return Geo
`protected Geo` | `RibbonMaker.getPolyIntersection(OMPoly poly1, OMPoly poly2)` Just return the point where the two polygons cross.

Methods in com.bbn.openmap.omGraphics.util with parameters of type Geo
`protected void` | `RibbonMaker.addShortLegPolyForIntersection(Geo g1, Geo g2, Geo g3, int ribbonSide, double dist, OMAreaList ret)` Called when it's known that one of the legs between the corner is smaller than the buffer depth.
`protected int` | `RibbonMaker.bends(Geo g1, Geo g2, Geo g3)` Method that determines which way the angle between the three points bends.
`OMGraphic` | `RibbonMaker.getArc(Geo gc, OMPoly poly1, OMPoly poly2)` Given two polylines, with the end point of poly1 being the same distance from a point as the starting point of poly2, create an arc that connects them.
`protected void` | `RibbonMaker.handlePointsForOuterRing(Geo g1, Geo g2, Geo g3, double dist, OMAreaList ret)` Takes a corner represented by the three geos, and adds OMGraphics to the OMAreaList depending on which way the corner bends - for right turns, it'll add an OMLine, OMArc and OMLine.
`protected boolean` | `RibbonMaker.tooClose(Geo pnt, double distance)` Checks to see if a point is too close to any side of the original polygon.

Method parameters in com.bbn.openmap.omGraphics.util with type arguments of type Geo
`protected OMPoly` | `RibbonMaker.getOMPolyFromGeos(java.util.List<Geo> geos)` Converts Vector of Geos to an OMPoly with linetype great_circle.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

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