jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts.js

@@ -1,2 +1,199 @@
 //= require javascript.util
 //= require jsts-original
+//= require jsts/util/AssertionFailedException
+//= require jsts/util/Assert
+//= require jsts/geom/CoordinateArrays
+//= require jsts/geom/CoordinateFilter
+//= require jsts/util/UniqueCoordinateArrayFilter
+//= require jsts/geom/CoordinateList
+//= require jsts/geom/Dimension
+//= require jsts/geom/Location
+//= require jsts/geom/Geometry
+//= require jsts/geom/GeometryCollection
+//= require jsts/geom/GeometryFilter
+//= require jsts/geom/GeometryComponentFilter
+//= require jsts/geom/IntersectionMatrix
+//= require jsts/geom/Coordinate
+//= require jsts/geom/Envelope
+//= require jsts/geom/GeometryFactory
+//= require jsts/geom/LineString
+//= require jsts/geom/MultiLineString
+//= require jsts/geom/LinearRing
+//= require jsts/geom/LineSegment
+//= require jsts/geom/Point
+//= require jsts/geom/MultiPoint
+//= require jsts/geom/Polygon
+//= require jsts/geom/MultiPolygon
+//= require jsts/geom/PrecisionModel
+//= require jsts/geom/Triangle
+//= require jsts/geom/util/GeometryCombiner
+//= require jsts/geom/util/GeometryExtracter
+//= require jsts/geom/util/GeometryTransformer
+//= require jsts/geom/util/LinearComponentExtracter
+//= require jsts/geom/util/PointExtracter
+//= require jsts/geom/util/PolygonExtracter
+//= require jsts/algorithm/BoundaryNodeRule
+//= require jsts/algorithm/CentralEndpointIntersector
+//= require jsts/algorithm/CentroidArea
+//= require jsts/algorithm/CentroidLine
+//= require jsts/algorithm/CentroidPoint
+//= require jsts/algorithm/CGAlgorithms
+//= require jsts/algorithm/ConvexHull
+//= require jsts/algorithm/HCoordinate
+//= require jsts/algorithm/LineIntersector
+//= require jsts/algorithm/PointLocator
+//= require jsts/algorithm/RayCrossingCounter
+//= require jsts/algorithm/RobustDeterminant
+//= require jsts/algorithm/RobustLineIntersector
+//= require jsts/algorithm/locate/SimplePointInAreaLocator
+//= require jsts/planargraph/GraphComponent
+//= require jsts/planargraph/Edge
+//= require jsts/planargraph/DirectedEdge
+//= require jsts/planargraph/DirectedEdgeStar
+//= require jsts/planargraph/Node
+//= require jsts/planargraph/NodeMap
+//= require jsts/planargraph/PlanarGraph
+//= require jsts/index/ArrayListVisitor
+//= require jsts/index/DoubleBits
+//= require jsts/index/IntervalSize
+//= require jsts/index/ItemVisitor
+//= require jsts/index/SpatialIndex
+//= require jsts/index/chain/MonotoneChain
+//= require jsts/index/chain/MonotoneChainBuilder
+//= require jsts/index/chain/MonotoneChainOverlapAction
+//= require jsts/index/chain/MonotoneChainSelectAction
+
+// This file is included here because MCPointInRing.MCSelected requires MonotoneChainSelectAction
+//= require jsts/algorithm/MCPointInRing
+
+//= require jsts/index/kdtree/KdNode
+//= require jsts/index/kdtree/KdTree
+//= require jsts/index/quadtree/Key
+//= require jsts/index/quadtree/NodeBase
+//= require jsts/index/quadtree/Node
+//= require jsts/index/quadtree/Quadtree
+//= require jsts/index/quadtree/Root
+//= require jsts/index/strtree/Boundable
+//= require jsts/index/strtree/AbstractNode
+//= require jsts/index/strtree/AbstractSTRtree
+//= require jsts/index/strtree/Interval
+//= require jsts/index/strtree/ItemBoundable
+//= require jsts/index/strtree/SIRtree
+//= require jsts/index/strtree/STRtree
+//= require jsts/index/bintree/Interval
+//= require jsts/index/bintree/NodeBase
+//= require jsts/index/bintree/Key
+//= require jsts/index/bintree/Node
+//= require jsts/index/bintree/Root
+//= require jsts/index/bintree/Bintree
+//= require jsts/noding/SegmentIntersector
+//= require jsts/noding/InteriorIntersectionFinder
+//= require jsts/noding/IntersectionAdder
+//= require jsts/noding/IntersectionFinderAdder
+//= require jsts/noding/SegmentString
+//= require jsts/noding/BasicSegmentString
+//= require jsts/noding/NodableSegmentString
+//= require jsts/noding/NodedSegmentString
+//= require jsts/noding/Noder
+//= require jsts/noding/NodingValidator
+//= require jsts/noding/SinglePassNoder
+//= require jsts/noding/MCIndexNoder
+//= require jsts/noding/FastNodingValidator
+//= require jsts/noding/Octant
+//= require jsts/noding/OrientedCoordinateArray
+//= require jsts/noding/ScaledNoder
+//= require jsts/noding/SegmentNode
+//= require jsts/noding/SegmentNodeList
+//= require jsts/noding/SegmentPointComparator
+//= require jsts/noding/snapround/HotPixel
+//= require jsts/noding/snapround/MCIndexPointSnapper
+//= require jsts/noding/snapround/MCIndexSnapRounder
+//= require jsts/geomgraph/Position
+//= require jsts/geomgraph/Depth
+//= require jsts/geomgraph/GraphComponent
+//= require jsts/geomgraph/Node
+//= require jsts/geomgraph/NodeFactory
+//= require jsts/geomgraph/NodeMap
+//= require jsts/geomgraph/Edge
+//= require jsts/geomgraph/EdgeEnd
+//= require jsts/geomgraph/DirectedEdge
+//= require jsts/geomgraph/EdgeEndStar
+//= require jsts/geomgraph/DirectedEdgeStar
+//= require jsts/geomgraph/EdgeRing
+//= require jsts/geomgraph/EdgeIntersection
+//= require jsts/geomgraph/EdgeIntersectionList
+//= require jsts/geomgraph/EdgeList
+//= require jsts/geomgraph/EdgeNodingValidator
+//= require jsts/geomgraph/PlanarGraph
+//= require jsts/geomgraph/GeometryGraph
+//= require jsts/geomgraph/Label
+//= require jsts/geomgraph/Quadrant
+//= require jsts/geomgraph/TopologyLocation
+//= require jsts/geomgraph/index/EdgeSetIntersector
+//= require jsts/geomgraph/index/SegmentIntersector
+//= require jsts/geomgraph/index/SimpleEdgeSetIntersector
+//= require jsts/geomgraph/index/SimpleMCSweepLineIntersector
+//= require jsts/io/OpenLayersParser
+//= require jsts/io/WKTParser
+//= require jsts/io/WKTReader
+//= require jsts/io/WKTWriter
+//= require jsts/operation/BoundaryOp
+//= require jsts/operation/GeometryGraphOperation
+//= require jsts/operation/IsSimpleOp
+//= require jsts/operation/buffer/BufferBuilder
+//= require jsts/operation/buffer/BufferInputLineSimplifier
+//= require jsts/operation/buffer/BufferOp
+//= require jsts/operation/buffer/BufferParameters
+//= require jsts/operation/buffer/BufferSubgraph
+//= require jsts/operation/buffer/OffsetCurveBuilder
+//= require jsts/operation/buffer/OffsetCurveSetBuilder
+//= require jsts/operation/buffer/OffsetSegmentGenerator
+//= require jsts/operation/buffer/OffsetSegmentString
+//= require jsts/operation/buffer/RightmostEdgeFinder
+//= require jsts/operation/buffer/SubgraphDepthLocater
+//= require jsts/operation/distance/ConnectedElementLocationFilter
+//= require jsts/operation/distance/DistanceOp
+//= require jsts/operation/distance/GeometryLocation
+//= require jsts/operation/overlay/LineBuilder
+//= require jsts/operation/overlay/OverlayNodeFactory
+//= require jsts/operation/overlay/PolygonBuilder
+//= require jsts/operation/overlay/MaximalEdgeRing
+//= require jsts/operation/overlay/MinimalEdgeRing
+//= require jsts/operation/overlay/LineBuilder
+//= require jsts/operation/overlay/PointBuilder
+//= require jsts/operation/overlay/OverlayOp
+//= require jsts/operation/overlay/snap/LineStringSnapper
+//= require jsts/operation/overlay/snap/GeometrySnapper
+//= require jsts/operation/overlay/snap/SnapOverlayOp
+//= require jsts/operation/overlay/snap/SnapIfNeededOverlayOp
+//= require jsts/operation/polygonize/EdgeRing
+//= require jsts/operation/polygonize/PolygonizeDirectedEdge
+//= require jsts/operation/polygonize/PolygonizeEdge
+//= require jsts/operation/polygonize/PolygonizeGraph
+//= require jsts/operation/polygonize/Polygonizer
+//= require jsts/operation/relate/EdgeEndBuilder
+//= require jsts/operation/relate/EdgeEndBundle
+//= require jsts/operation/relate/EdgeEndBundleStar
+//= require jsts/operation/relate/RelateComputer
+//= require jsts/operation/relate/RelateNode
+//= require jsts/operation/relate/RelateNodeFactory
+//= require jsts/operation/relate/RelateNodeGraph
+//= require jsts/operation/relate/RelateOp
+//= require jsts/operation/union/CascadedPolygonUnion
+//= require jsts/operation/union/PointGeometryUnion
+//= require jsts/operation/union/UnaryUnionOp
+//= require jsts/operation/union/UnionInteracting
+//= require jsts/operation/valid/IsValidOp
+//= require jsts/operation/valid/TopologyValidationError
+//= require jsts/operation/valid/ConsistentAreaTester
+//= require jsts/operation/valid/IndexedNestedRingTester
+//= require jsts/operation/valid/ConnectedInteriorTester
+//= require jsts/simplify/LineSegmentIndex
+//= require jsts/triangulate/DelaunayTriangulationBuilder
+//= require jsts/triangulate/VoronoiDiagramBuilder
+//= require jsts/triangulate/IncrementalDelaunayTriangulator
+//= require jsts/triangulate/quadedge/LastFoundQuadEdgeLocator
+//= require jsts/triangulate/quadedge/QuadEdge
+//= require jsts/triangulate/quadedge/QuadEdgeSubdivision
+//= require jsts/triangulate/quadedge/TrianglePredicate
+//= require jsts/triangulate/quadedge/Vertex

data/vendor/assets/javascripts/jsts/algorithm/Angle.js

@@ -0,0 +1,387 @@
+/* Copyright (c) 2011 by The Authors.
+ * Published under the LGPL 2.1 license.
+ * See /license-notice.txt for the full text of the license notice.
+ * See /license.txt for the full text of the license.
+ */
+
+
+
+/**
+ * Utility functions for working with angles.
+ * Unless otherwise noted, methods in this class express angles in radians.
+ *
+ * @requires jsts/algorithm/CGAlgorithms.js
+ *
+ * @constructor
+ */
+jsts.algorithm.Angle = function() {
+
+};
+
+
+/**
+ * Pi*2
+ */
+jsts.algorithm.Angle.PI_TIMES_2 = 2.0 * Math.PI;
+
+
+/**
+ * Pi/2
+ */
+jsts.algorithm.Angle.PI_OVER_2 = Math.PI / 2.0;
+
+
+/**
+ * Pi/4
+ */
+jsts.algorithm.Angle.PI_OVER_4 = Math.PI / 4.0;
+
+
+/**
+ * Constant representing counterclockwise orientation
+ */
+jsts.algorithm.Angle.COUNTERCLOCKWISE = jsts.algorithm.CGAlgorithms.prototype.COUNTERCLOCKWISE;
+
+
+/**
+ * Constant representing clockwise orientation
+ */
+jsts.algorithm.Angle.CLOCKWISE = jsts.algorithm.CGAlgorithms.prototype.CLOCKWISE;
+
+
+/**
+ * Constant representing no orientation
+ */
+jsts.algorithm.Angle.NONE = jsts.algorithm.CGAlgorithms.prototype.COLLINEAR;
+
+
+/**
+ * Converts from radians to degrees.
+ *
+ * @param {Number}
+ *        radians an angle in radians.
+ * @return {Number}
+ *         the angle in degrees.
+ */
+jsts.algorithm.Angle.toDegrees = function(radians) {
+  return (radians * 180) / Math.PI;
+};
+
+
+/**
+ * Converts from degrees to radians.
+ *
+ * @param {Number}
+ *        angleDegrees an angle in degrees.
+ * @return {Number}
+ *         the angle in radians.
+ */
+jsts.algorithm.Angle.toRadians = function(angleDegrees) {
+  return (angleDegrees * Math.PI) / 180.0;
+};
+
+
+/**
+ * Returns the angle
+ * Calls correct angle* depending on argument
+ *
+ * @return {Number}
+ *          The angle in radians.
+ */
+jsts.algorithm.Angle.angle = function() {
+  if (arguments.length === 1) {
+    return jsts.algorithm.Angle.angleFromOrigo(arguments[0]);
+  }else {
+    return jsts.algorithm.Angle.angleBetweenCoords(arguments[0], arguments[1]);
+  }
+};
+
+
+/**
+ * Returns the angle of the vector from p0 to p1,
+ * relative to the positive X-axis.
+ * The angle is normalized to be in the range [ -Pi, Pi ].
+ *
+ * @param {jsts.geom.Coordinate}
+ *        p0 a coordinate.
+ * @param {jsts.geom.Coordinate}
+ *        p1 a coordinate.
+ * @return {Number}
+ *         the normalized angle (in radians) that p0-p1 makes with the positive
+ *         x-axis.
+ */
+jsts.algorithm.Angle.angleBetweenCoords = function(p0, p1) {
+  var dx, dy;
+  dx = p1.x - p0.x;
+  dy = p1.y - p0.y;
+  return Math.atan2(dy, dx);
+};
+
+
+/**
+ * Returns the angle that the vector from (0,0) to p,
+ * relative to the positive X-axis.
+ * The angle is normalized to be in the range ( -Pi, Pi ].
+ *
+ * @param {jsts.geom.Coordinate}
+ *        p a coordinate.
+ * @return {Number}
+ *         the normalized angle (in radians) that p makes with the positive
+ *         x-axis.
+ */
+jsts.algorithm.Angle.angleFromOrigo = function(p) {
+  return Math.atan2(p.y, p.x);
+};
+
+
+/**
+ * Tests whether the angle between p0-p1-p2 is acute.
+ * An angle is acute if it is less than 90 degrees.
+ * <p>
+ * Note: this implementation is not precise (determistic) for angles very close to 90 degrees.
+ *
+ * @param {jsts.geom.Coordinate}
+ *        p0 an endpoint of the angle.
+ * @param {jsts.geom.Coordinate}
+ *        p1 the base of the angle.
+ * @param {jsts.geom.Coordinate}
+ *        p2 the other endpoint of the angle.
+ * @return {Boolean}
+ *         true if the angle is acute.
+ */
+jsts.algorithm.Angle.isAcute = function(p0, p1, p2) {
+  var dx0, dy0, dx1, dy1, dotprod;
+
+  //relies on fact that A dot B is positive if A ang B is acute
+  dx0 = p0.x - p1.x;
+  dy0 = p0.y - p1.y;
+  dx1 = p2.x - p1.x;
+  dy1 = p2.y - p1.y;
+  dotprod = dx0 * dx1 + dy0 * dy1;
+  return dotprod > 0;
+};
+
+
+/**
+ * Tests whether the angle between p0-p1-p2 is obtuse.
+ * An angle is obtuse if it is greater than 90 degrees.
+ * <p>
+ * Note: this implementation is not precise (determistic) for angles very close to 90 degrees.
+ *
+ * @param {jsts.geom.Coordinate}
+ *        p0 an endpoint of the angle.
+ * @param {jsts.geom.Coordinate}
+ *        p1 the base of the angle.
+ * @param {jsts.geom.Coordinate}
+ *        p2 the other endpoint of the angle.
+ * @return {Boolean}
+ *         true if the angle is obtuse.
+ */
+jsts.algorithm.Angle.isObtuse = function(p0, p1, p2) {
+  var dx0, dy0, dx1, dy1, dotprod;
+
+  //relies on fact that A dot B is negative iff A ang B is obtuse
+  dx0 = p0.x - p1.x;
+  dy0 = p0.y - p1.y;
+  dx1 = p2.x - p1.x;
+  dy1 = p2.y - p1.y;
+  dotprod = dx0 * dx1 + dy0 * dy1;
+  return dotprod < 0;
+};
+
+
+/**
+ * Returns the unoriented smallest angle between two vectors.
+ * The computed angle will be in the range [0, Pi).
+ *
+ * @param {jsts.geom.Coordinate}
+ *        tip1 the tip of one vector.
+ * @param {jsts.geom.Coordinate}
+ *        tail the tail of each vector.
+ * @param {jsts.geom.Coordinate}
+ *        tip2 the tip of the other vector.
+ * @return {Number}
+ *         the angle between tail-tip1 and tail-tip2.
+ */
+jsts.algorithm.Angle.angleBetween = function(tip1, tail, tip2) {
+  var a1, a2;
+  a1 = jsts.algorithm.Angle.angle(tail, tip1);
+  a2 = jsts.algorithm.Angle.angle(tail, tip2);
+
+  return jsts.algorithm.Angle.diff(a1, a2);
+};
+
+
+/**
+ * Returns the oriented smallest angle between two vectors.
+ * The computed angle will be in the range (-Pi, Pi].
+ * A positive result corresponds to a counterclockwise rotation
+ * from v1 to v2;
+ * a negative result corresponds to a clockwise rotation.
+ *
+ * @param {jsts.geom.Coordinate}
+ *        tip1 the tip of v1.
+ * @param {jsts.geom.Coordinate}
+ *        tail the tail of each vector.
+ * @param {jsts.geom.Coordinate}
+ *        tip2 the tip of v2.
+ * @return {Number}
+ *         the angle between v1 and v2, relative to v1.
+ */
+jsts.algorithm.Angle.angleBetweenOriented = function(tip1, tail, tip2) {
+  var a1, a2, angDel;
+
+  a1 = jsts.algorithm.Angle.angle(tail, tip1);
+  a2 = jsts.algorithm.Angle.angle(tail, tip2);
+  angDel = a2 - a1;
+
+  // normalize, maintaining orientation
+  if (angDel <= -Math.PI) {
+    return angDel + jsts.algorithm.Angle.PI_TIMES_2;
+  }
+  if (angDel > Math.PI) {
+    return angDel - jsts.algorithm.Angle.PI_TIMES_2;
+  }
+  return angDel;
+};
+
+
+/**
+ * Computes the interior angle between two segments of a ring. The ring is
+ * assumed to be oriented in a clockwise direction. The computed angle will be
+ * in the range [0, 2Pi]
+ *
+ * @param {jsts.geom.Coordinate}
+ *        p0 a point of the ring.
+ * @param {jsts.geom.Coordinate}
+ *        p1 the next point of the ring.
+ * @param {jsts.geom.Coordinate}
+ *        p2 the next point of the ring.
+ * @return {Number}
+ *         the interior angle based at <code>p1.</code>
+ */
+jsts.algorithm.Angle.interiorAngle = function(p0, p1, p2) {
+  var anglePrev, angleNext;
+
+  anglePrev = jsts.algorithm.Angle.angle(p1, p0);
+  angleNext = jsts.algorithm.Angle.angle(p1, p2);
+  return Math.abs(angleNext - anglePrev);
+};
+
+
+/**
+ * Returns whether an angle must turn clockwise or counterclockwise
+ * to overlap another angle.
+ *
+ * @param {Number}
+ *        ang1 an angle (in radians).
+ * @param {Number}
+ *        ang2 an angle (in radians).
+ * @return {Number}
+ *         whether a1 must turn CLOCKWISE, COUNTERCLOCKWISE or NONE to
+ *         overlap a2.
+ */
+jsts.algorithm.Angle.getTurn = function(ang1, ang2) {
+  var crossproduct = Math.sin(ang2 - ang1);
+
+  if (crossproduct > 0) {
+    return jsts.algorithm.Angle.COUNTERCLOCKWISE;
+  }
+  if (crossproduct < 0) {
+    return jsts.algorithm.Angle.CLOCKWISE;
+  }
+  return jsts.algorithm.Angle.NONE;
+};
+
+
+/**
+ * Computes the normalized value of an angle, which is the
+ * equivalent angle in the range ( -Pi, Pi ].
+ *
+ * @param {Number}
+ *        angle the angle to normalize.
+ * @return {Number}
+ *         an equivalent angle in the range (-Pi, Pi].
+ */
+jsts.algorithm.Angle.normalize = function(angle) {
+  while (angle > Math.PI) {
+    angle -= jsts.algorithm.Angle.PI_TIMES_2;
+  }
+  while (angle <= -Math.PI) {
+    angle += jsts.algorithm.Angle.PI_TIMES_2;
+  }
+  return angle;
+};
+
+
+/**
+ * Computes the normalized positive value of an angle, which is the
+ * equivalent angle in the range [ 0, 2*Pi ).
+ * E.g.:
+ * <ul>
+ * <li>normalizePositive(0.0) = 0.0
+ * <li>normalizePositive(-PI) = PI
+ * <li>normalizePositive(-2PI) = 0.0
+ * <li>normalizePositive(-3PI) = PI
+ * <li>normalizePositive(-4PI) = 0
+ * <li>normalizePositive(PI) = PI
+ * <li>normalizePositive(2PI) = 0.0
+ * <li>normalizePositive(3PI) = PI
+ * <li>normalizePositive(4PI) = 0.0
+ * </ul>
+ *
+ * @param {Number}
+ *        angle the angle to normalize, in radians.
+ * @return {Number}
+ *         an equivalent positive angle.
+ */
+jsts.algorithm.Angle.normalizePositive = function(angle) {
+  if (angle < 0.0) {
+    while (angle < 0.0) {
+      angle += jsts.algorithm.Angle.PI_TIMES_2;
+    }
+    // in case round-off error bumps the value over
+    if (angle >= jsts.algorithm.Angle.PI_TIMES_2) {
+      angle = 0.0;
+    }
+  }
+  else {
+    while (angle >= jsts.algorithm.Angle.PI_TIMES_2) {
+      angle -= jsts.algorithm.Angle.PI_TIMES_2;
+    }
+    // in case round-off error bumps the value under
+    if (angle < 0.0) {
+      angle = 0.0;
+    }
+  }
+  return angle;
+};
+
+
+/**
+ * Computes the unoriented smallest difference between two angles.
+ * The angles are assumed to be normalized to the range [-Pi, Pi].
+ * The result will be in the range [0, Pi].
+ *
+ * @param {Number}
+ *        ang1 the angle of one vector (in [-Pi, Pi] ).
+ * @param {Number}
+ *        ang2 the angle of the other vector (in range [-Pi, Pi] ).
+ * @return {Number}
+ *         the angle (in radians) between the two vectors (in range [0, Pi] ).
+ */
+jsts.algorithm.Angle.diff = function(ang1, ang2) {
+  var delAngle;
+
+  if (ang1 < ang2) {
+    delAngle = ang2 - ang1;
+  } else {
+    delAngle = ang1 - ang2;
+  }
+
+  if (delAngle > Math.PI) {
+    delAngle = (2 * Math.PI) - delAngle;
+  }
+
+  return delAngle;
+};