BEARING-DIFFERENCE (BEARING1 BEARING2)
Returns the difference between BEARING1 and BEARING2. The result will be in the range [-pi,+pi). Note: this is more correct than simply taking (- BEARING1 BEARING2).
BEARINGS (POINT1 POINT2 POINT3)
Returns the final bearing of travel from POINT1 to POINT2, the relative bearing required to then travel on to POINT3, and the initial bearing of travel from POINT2 to POINT3.
CLOSEST-POINT (POINT POINTS &KEY (KEY #'IDENTITY))
Returns the closest point of the given list of POINTS to the given reference POINT. POINTS must not be empty. If KEY is supplied, it will be applied to each item of POINTS, and is expected to return the point to be used for comparison with the reference POINT. In this case, it is the original item from POINTS--which may be a non-point, and not the return value from KEY--that is returned.
COERCE-POINT (POINT POINT-TYPE COORDINATE-TYPE)
Coerces POINT to be an instance of POINT-TYPE with coordinates of COORDINATE-TYPE.
Given a bearing in radians, returns a symbol describing its direction.
Given a relative bearing in radians in the range [-pi,+pi), returns two symbols describing its direction (LEFT, NIL, RIGHT) and absolute angle (STRAIGHT, OBTUSE, RIGHT, ACUTE, REVERSE). Note that angle descriptions are approximate and intended for human consumption.
DISTANCE-BETWEEN (POINT1 POINT2)
Returns the distance from point1 to point2.
DOUGLAS-PEUCKER (POINTS THRESHOLD-DISTANCE &OPTIONAL SLOW-AND-ACCURATE-P)
Simplifies the polyline expressed by POINTS. The result is a vector, parallel to POINTS, of either NIL (the corresponding point has been discarded), T (the corresponding point is an endpoint), or a DISTANCE (the distance between the point and the "parent" line it extended from internally; longer means more prominent). When SLOW-AND-ACCURATE-P is true, distance calculations from points to line segments are made more precise by finding the approximate closest point on the line segment, using the slow, O(log2 n) CLOSEST-POINT-ON method (to an accuracy of THRESHOLD-DISTANCE). Otherwise, a faster method is used, which is accurate e.g. on a Spokane<-->Portland scale but not as accurate on a Seattle<-->Washington, D.C. scale.
FINAL-BEARING (POINT1 POINT2)
Returns the final bearing to head from POINT1 to POINT2, in radians.
Given an initial bearing from POINT2 to POINT1 (REVERSE-INITIAL-BEARING), returns the final bearing to head from POINT1 to POINT2, in radians.
GOOGLE-POLYLINE (POINTS &KEY POLYLINE-STREAM LEVELS-STREAM PREROUND-P (SIMPLIFICATION-THRESHOLD (DISTANCE-METERS 1)) (ZOOM-FACTOR 2) (NUM-LEVELS 18))
Encodes the given list of POINTS with Google's encoded polyline coding. The result is two sequences of characters: POLYLINE-STREAM determines how the encoded polyline string is returned, and LEVELS-STREAM determines how the encoded point-levels string is returned. The possible values for both parameters are NIL, to return the result as a string; T, to write the result to *STANDARD-OUTPUT*; or a stream, to write the result to that stream. When both results are returned as strings, this function returns encoded polyline string and the encoded point-levels string; otherwise, it returns only a single string, or no values. PREROUND-P, when true, pre-rounds point coordinates to the Google encoded real precision of 10**-5. This yields better registration with other map features, such as streets, and may result in better polyline simplification. This is slower, but won't be noticably so with polylines that have on the order of 1000 points. SIMPLIFICATION-THRESHOLD denotes the resolution that the polyline will be simplified to. ZOOM-FACTOR is roughly the factor of magnification with each zoom-in operation of the Google Map. This should match your "zoomFactor" argument to GPolyline.fromEncoded(). NUM-LEVELS is the number of zoom-levels to encode the polyline with. Ideally, this should be equal to the number of zoom-levels your map has: G_NORMAL_MAPs have 18 zoom levels. This should match your "numLevels" argument to GPolyline.fromEncoded(). Each point must be WGS-84.
GOOGLE-POLYLINE-NON-NEGATIVE-INTEGER (N STREAM)
Encodes a non-negative integer N with Google's encoded polyline coding. The result is a sequence of characters which is written to STREAM.
GOOGLE-POLYLINE-REAL (N STREAM)
Encodes a real number N with Google's encoded polyline coding. The result is a sequence of characters which is written to STREAM.
GOOGLE-POLYLINE-SIGNED-INTEGER (N STREAM)
Encodes an integer N with Google's encoded polyline coding. The result is a sequence of characters which is written to STREAM.
GREATEST-DISTANCE (POINT1 POINT2 &REST REST-POINTS)
Returns the greatest distance between any two of the given points.
INITIAL-BEARING (POINT1 POINT2)
Returns the initial bearing to head from point1 to point2, in radians.
INTERPOLATE-BETWEEN-POINTS (POINT1 POINT2 PROPORTION)
Returns the point that occurs PROPORTION of the distance between POINT1 and POINT2.
Normalizes the RADIANS to the range [0,2pi).
POINT-EQUAL (P1 P2)
Returns whether the two given points are within one millionth of a degree of each other in both latitude and longitude.
POINT-FROM-POINT-IN-DIRECTION (POINT INITIAL-BEARING DISTANCE)
Given a starting POINT, an INITIAL-BEARING (in radians), and a distance, returns the point you'd end up at. (POINT-FROM-POINT-IN-DIRECTION POINT INITIAL-BEARING DISTANCE) = (POINT-FROM-POINT-IN-DIRECTION POINT (FINAL-BEARING% INITIAL-BEARING) (DISTANCE- DISTANCE))
Creates a closed, non-self-intersecting polygon with POINTs given in VERTICES.
RELATIVE-BEARING (POINT1 POINT2 POINT3)
Having travelled from POINT1 to POINT2, returns the relative bearing to then travel from POINT2 to POINT3, in radians in the range [-pi,+pi).
RELATIVE-BEARING% (INITIAL-BEARING FINAL-BEARING)
Given a FINAL-BEARING from POINT1 to POINT2 and an INITIAL-BEARING from POINT2 to POINT3, returns the relative bearing in radians in the range [-pi,+pi).
Return a new sequence containing the same elements but in reverse order.
DISTANCE* (&REST DISTANCES)
DISTANCE+ (&REST DISTANCES)
DISTANCE- (&REST DISTANCES)
DISTANCE-MAX (&REST DISTANCES)
DISTANCE-MIN (&REST DISTANCES)
DISTANCE/ (&REST DISTANCES)
DISTANCE/= (&REST DISTANCES)
DISTANCE< (&REST DISTANCES)
DISTANCE<= (&REST DISTANCES)
DISTANCE= (&REST DISTANCES)
DISTANCE> (&REST DISTANCES)
DISTANCE>= (&REST DISTANCES)
GOOGLE-POLYLINE-LEVELS (DISTANCES SIMPLIFICATION-THRESHOLD ZOOM-FACTOR NUM-LEVELS STREAM)
GOOGLE-POLYLINE-POINTS (POINTS STREAM)
LINE-SEGMENT (POINT1 POINT2)
POINT-CARTESIAN (X Y Z)
POINT-DEG (LATITUDE LONGITUDE)
POINT-RAD (LATITUDE LONGITUDE)
SPHERE-CENTRAL-ANGLE (POINT1 POINT2)
ASSOC* (ITEM ALIST &KEY (KEY #'IDENTITY) (TEST #'EQL) (DEFAULT 'NIL))
Like ASSOC, but returns the CDR of the matching entry, or DEFAULT if there was no match. (ASSOC* ...) is a SETF-able place. e.g. (defparameter *test-alist* '()) => *TEST-ALIST* (assoc* 'a *test-alist*) => NIL (push 1 (assoc* 'a *test-alist*)) => (1) (push 2 (assoc* 'a *test-alist*)) => (2 1) (assoc* 'a *test-alist*) => (2 1) *test-alist* => ((A 2 1)) (setf (assoc* 'b *test-alist*) 'notalist) => NOTALIST (setf (assoc* 'a *test-alist*) 'notalist) => NOTALIST (assoc* 'a *test-alist*) => NOTALIST *test-alist* => ((B . NOTALIST) (A . NOTALIST))
COMPOSE (&REST FUNCTIONS)
Returns the composition of a sequence of functions (designated by FUNCTIONS), yielding a new function. The new function passes all its arguments to the last given function. Each other given function gets called, from last to first, with the values of the call of its successive function. The new function returns all the values returned by the first given function. For single-argument functions a and b, and single-value functions b and c: (FUNCALL (COMPOSE a b c) x y z) == (a (b (c x y z))) For any function f: (COMPOSE f) == f For any values x, y, and z: COMPOSE == VALUES (FUNCALL (COMPOSE)) => ; no value (FUNCALL (COMPOSE) x) => x (FUNCALL (COMPOSE) x y z) => x y z
Given a function which takes any number of numbers and returns any number of numbers, returns a modified version which instead takes any number of numbers or distances (coercing to meters) and returns distance values.
CARTESIAN->SPHERICAL-COORDS (X Y Z)
NSORT (SEQUENCE PREDICATE &KEY (KEY NIL KEY-SPEC-P))
NSTABLE-SORT (SEQUENCE PREDICATE &KEY (KEY NIL KEY-SPEC-P))
SORT (SEQUENCE PREDICATE &KEY (KEY NIL KEY-SPEC-P))
STABLE-SORT (SEQUENCE PREDICATE &KEY (KEY NIL KEY-SPEC-P))
DEFDISTANCE-UNIT (PLURAL-NAME MULTIPLIER REFERENCE-UNIT)
Define that one distance unit "plural-name" equals "multiplier" "reference-unit"s, where plural-name and reference-unit are the plural names of units of length, as symbols, and multiplier is a side-effect-free Lisp expression evaluating to a constant number. Where NAME is the given plural-name, defines a constructor function DISTANCE-NAME and an accessor method NAME (which depend on similarly-named constructors and accessors of the reference unit).
LAMBDA* (ARGS &BODY BODY)
Creates a function. Takes an extended, rather than an ordinary, lambda list.
Returns the bounding box of the given object, as a RECTANGLES:RECTANGLE. The resulting rectangle must list two coordinates for each sequence: latitude and longitude, both in degrees.
CLOSEST-POINT-ON (OBJECT POINT &OPTIONAL PRECISION)
Returns the point on the OBJECT closest to the POINT, to the given accuracy (default 1dm).
CONTAINS? (CONTAINING-OBJ OBJ)
Returns whether OBJ is contained within CONTAINING-OBJ.
INTERSECTION (LINE1 LINE2)
Returns a new point where the two given lines intersect, or nil if they do not, or if they have infinite intersections.
Coerces the given spherical or cartesian point to a cartesian-coordinate POINT. For spherical points, the radius of the sphere is assumed to be 1.
Coerces the given spherical or cartesian point to a spherical-coordinate POINT. For cartesian points, the altitude is lost.
POINT-EQL (POINT1 POINT2)
Returns whether the two given points express the exact same value.
Returns a value that is unique for POINT for the predicate #'EQUALP.
Returns a distance whose value is expressed by a number of type RATIONAL.
Returns a point-cartesian based on a rational-type number, like RATIONAL.
Returns the slope of the given line, as a number (or nil for infinity).
Alternative representation as a sequence of LINE-SEGMENTs.
The radians latitude of each vertex of POINTS, in sequence, as a double float. Included for optimizations.
The radians longitude of each vertex of POINTS, in sequence, as a double float. Included for optimizations.
The POINTs comprising this polygon.