jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/index/chain/MonotoneChainBuilder.js

@@ -0,0 +1,106 @@
+/* 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.
+ */
+
+/**
+ * Constructs {@link MonotoneChain}s for sequences of {@link Coordinate}s.
+ *
+ * @constructor
+ */
+jsts.index.chain.MonotoneChainBuilder = function() {
+
+};
+
+jsts.index.chain.MonotoneChainBuilder.toIntArray = function(list) {
+  var array = [];
+  for (var i = 0; i < list.length; i++) {
+    array[i] = list[i];
+  }
+  return array;
+};
+
+jsts.index.chain.MonotoneChainBuilder.getChains = function(pts) {
+  if (arguments.length === 2) {
+    return jsts.index.chain.MonotoneChainBuilder.getChains2.apply(this, arguments);
+  }
+
+  return jsts.index.chain.MonotoneChainBuilder.getChains2(pts, null);
+};
+
+/**
+ * Return a list of the {@link MonotoneChain}s for the given list of
+ * coordinates.
+ */
+jsts.index.chain.MonotoneChainBuilder.getChains2 = function(pts, context) {
+  var mcList = [];
+  var startIndex = jsts.index.chain.MonotoneChainBuilder
+      .getChainStartIndices(pts);
+  for (var i = 0; i < startIndex.length - 1; i++) {
+    var mc = new jsts.index.chain.MonotoneChain(pts, startIndex[i],
+        startIndex[i + 1], context);
+    mcList.push(mc);
+  }
+  return mcList;
+};
+
+/**
+ * Return an array containing lists of start/end indexes of the monotone chains
+ * for the given list of coordinates. The last entry in the array points to the
+ * end point of the point array, for use as a sentinel.
+ */
+jsts.index.chain.MonotoneChainBuilder.getChainStartIndices = function(pts) {
+  // find the startpoint (and endpoints) of all monotone chains in this edge
+  var start = 0;
+  var startIndexList = [];
+  startIndexList.push(start);
+  do {
+    var last = jsts.index.chain.MonotoneChainBuilder.findChainEnd(pts, start);
+    startIndexList.push(last);
+    start = last;
+  } while (start < pts.length - 1);
+  // copy list to an array of ints, for efficiency
+  var startIndex = jsts.index.chain.MonotoneChainBuilder
+      .toIntArray(startIndexList);
+  return startIndex;
+};
+
+/**
+ * Finds the index of the last point in a monotone chain starting at a given
+ * point. Any repeated points (0-length segments) will be included in the
+ * monotone chain returned.
+ *
+ * @return the index of the last point in the monotone chain starting at
+ *         <code>start</code>.
+ * @private
+ */
+jsts.index.chain.MonotoneChainBuilder.findChainEnd = function(pts, start) {
+  var safeStart = start;
+  // skip any zero-length segments at the start of the sequence
+  // (since they cannot be used to establish a quadrant)
+  while (safeStart < pts.length - 1 &&
+      pts[safeStart].equals2D(pts[safeStart + 1])) {
+    safeStart++;
+  }
+  // check if there are NO non-zero-length segments
+  if (safeStart >= pts.length - 1) {
+    return pts.length - 1;
+  }
+  // determine overall quadrant for chain (which is the starting quadrant)
+  var chainQuad = jsts.geomgraph.Quadrant.quadrant(pts[safeStart],
+      pts[safeStart + 1]);
+  var last = start + 1;
+  while (last < pts.length) {
+    // skip zero-length segments, but include them in the chain
+    if (!pts[last - 1].equals2D(pts[last])) {
+      // compute quadrant for next possible segment in chain
+      var quad = jsts.geomgraph.Quadrant.quadrant(pts[last - 1],
+          pts[last]);
+      if (quad !== chainQuad)
+        break;
+    }
+    last++;
+  }
+  return last - 1;
+};

data/vendor/assets/javascripts/jsts/index/chain/MonotoneChainOverlapAction.js

@@ -0,0 +1,56 @@
+/* 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.
+ */
+
+/**
+ * @requires jsts/geom/Envelope.js
+ * @requires jsts/geom/LineSegment.js
+ */
+
+/**
+ * The action for the internal iterator for performing overlap queries on a
+ * MonotoneChain
+ *
+ * @constructor
+ */
+jsts.index.chain.MonotoneChainOverlapAction = function() {
+  this.tempEnv1 = new jsts.geom.Envelope();
+  this.tempEnv2 = new jsts.geom.Envelope();
+  this.overlapSeg1 = new jsts.geom.LineSegment();
+  this.overlapSeg2 = new jsts.geom.LineSegment();
+};
+
+// these envelopes are used during the MonotoneChain search process
+jsts.index.chain.MonotoneChainOverlapAction.prototype.tempEnv1 = null;
+jsts.index.chain.MonotoneChainOverlapAction.prototype.tempEnv2 = null;
+
+jsts.index.chain.MonotoneChainOverlapAction.prototype.overlapSeg1 = null;
+jsts.index.chain.MonotoneChainOverlapAction.prototype.overlapSeg2 = null;
+
+/**
+ * This function can be overridden if the original chains are needed
+ *
+ * @param start1
+ *          the index of the start of the overlapping segment from mc1.
+ * @param start2
+ *          the index of the start of the overlapping segment from mc2.
+ */
+jsts.index.chain.MonotoneChainOverlapAction.prototype.overlap = function(mc1,
+    start1, mc2, start2) {
+  this.mc1.getLineSegment(start1, this.overlapSeg1);
+  this.mc2.getLineSegment(start2, this.overlapSeg2);
+  this.overlap2(this.overlapSeg1, this.overlapSeg2);
+};
+
+/**
+ * This is a convenience function which can be overridden to obtain the actual
+ * line segments which overlap
+ *
+ * @param seg1
+ * @param seg2
+ */
+jsts.index.chain.MonotoneChainOverlapAction.prototype.overlap2 = function(seg1,
+    seg2) {
+};

data/vendor/assets/javascripts/jsts/index/chain/MonotoneChainSelectAction.js

@@ -0,0 +1,44 @@
+/* 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.
+ */
+
+/**
+ * @requires jsts/geom/Envelope.js
+ * @requires jsts/geom/LineSegment.js
+ */
+
+/**
+ * The action for the internal iterator for performing envelope select queries
+ * on a MonotoneChain
+ *
+ * @constructor
+ */
+jsts.index.chain.MonotoneChainSelectAction = function() {
+  this.tempEnv1 = new jsts.geom.Envelope();
+  this.selectedSegment = new jsts.geom.LineSegment();
+};
+
+
+
+jsts.index.chain.MonotoneChainSelectAction.prototype.tempEnv1 = null;
+
+jsts.index.chain.MonotoneChainSelectAction.prototype.selectedSegment = null;
+
+/**
+ * This function can be overridden if the original chain is needed.
+ */
+jsts.index.chain.MonotoneChainSelectAction.prototype.select = function(mc,
+    start) {
+  mc.getLineSegment(start, this.selectedSegment);
+  this.select2(this.selectedSegment);
+};
+
+/**
+ * This is a convenience function which can be overridden to obtain the actual
+ * line segment which is selected.
+ *
+ * @param seg
+ */
+jsts.index.chain.MonotoneChainSelectAction.prototype.select2 = function(seg) {};

data/vendor/assets/javascripts/jsts/index/kdtree/KdNode.js

@@ -0,0 +1,171 @@
+/* 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.
+ */
+
+
+
+/**
+ * A node of a {@link KdTree}, which represents one or more points in the same
+ * location.
+ *
+ * Creates a new KdNode. Will call appropriate *initialize-function depending on
+ * arguments.
+ *
+ * @constructor
+ */
+jsts.index.kdtree.KdNode = function() {
+  this.left = null;
+  this.right = null;
+  this.count = 1;
+
+  if (arguments.length === 2) {
+    this.initializeFromCoordinate.apply(this, arguments[0], arguments[1]);
+  } else if (arguments.length === 3) {
+    this.initializeFromXY.apply(this, arguments[0], arguments[1], arguments[2]);
+  }
+};
+
+
+/**
+ * Creates a new KdNode.
+ *
+ * @param {Number}
+ *          x coordinate of point.
+ * @param {Number}
+ *          y coordinate of point.
+ * @param {Object}
+ *          data a data objects to associate with this node.
+ */
+jsts.index.kdtree.KdNode.prototype.initializeFromXY = function(x, y, data) {
+  this.p = new jsts.geom.Coordinate(x, y);
+  this.data = data;
+};
+
+
+/**
+ * Creates a new KdNode.
+ *
+ * @param {jsts.geom.Coordinate}
+ *          p point location of new node.
+ * @param {Object}
+ *          data a data objects to associate with this node.
+ */
+jsts.index.kdtree.KdNode.prototype.initializeFromCoordinate = function(p, data) {
+  this.p = p;
+  this.data = data;
+};
+
+
+/**
+ * Returns the X coordinate of the node
+ *
+ * @return {Number} X coordinate of the node.
+ */
+jsts.index.kdtree.KdNode.prototype.getX = function() {
+  return this.p.x;
+};
+
+
+/**
+ * Returns the Y coordinate of the node
+ *
+ * @return {Number} Y coordinate of the node.
+ */
+jsts.index.kdtree.KdNode.prototype.getY = function() {
+  return this.p.y;
+};
+
+
+/**
+ * Returns the location of this node
+ *
+ * @return {jsts.geom.Coordinate} location of this node.
+ */
+jsts.index.kdtree.KdNode.prototype.getCoordinate = function() {
+  return this.p;
+};
+
+
+/**
+ * Gets the user data object associated with this node.
+ *
+ * @return {Object} The data of this node.
+ */
+jsts.index.kdtree.KdNode.prototype.getData = function() {
+  return this.data;
+};
+
+
+/**
+ * Returns the left node of the tree
+ *
+ * @return {jsts.index.kdtree.KdNode} The left node of the tree.
+ */
+jsts.index.kdtree.KdNode.prototype.getLeft = function() {
+  return this.left;
+};
+
+
+/**
+ * Returns the right node of the tree
+ *
+ * @return {jsts.index.kdtree.KdNode} The right node of the tree.
+ */
+jsts.index.kdtree.KdNode.prototype.getRight = function() {
+  return this.right;
+};
+
+
+/**
+ * Increments the count by 1
+ */
+jsts.index.kdtree.KdNode.prototype.increment = function() {
+  this.count += 1;
+};
+
+
+/**
+ * Returns the number of inserted points that are coincident at this location.
+ *
+ * @return {Number} Number of inserted points that this node represents.
+ */
+jsts.index.kdtree.KdNode.prototype.getCount = function() {
+  return this.count;
+};
+
+
+/**
+ * Tests whether more than one point with this value have been inserted (up to
+ * the tolerance)
+ *
+ * @return {Boolean} true if more than one point have been inserted with this
+ *         value.
+ */
+jsts.index.kdtree.KdNode.prototype.isRepeated = function() {
+  return count > 1;
+};
+
+
+/**
+ * Sets the left node value
+ *
+ * @param {jsts.index.kdtree.KdNode}
+ *          left The node to be inserted as left.
+ */
+jsts.index.kdtree.KdNode.prototype.setLeft = function(left) {
+  this.left = left;
+};
+
+
+/**
+ * Sets the right node value
+ *
+ * @param {jsts.index.kdtree.KdNode}
+ *          right The node to be inserted as right.
+ */
+jsts.index.kdtree.KdNode.prototype.setRight = function(right) {
+  this.right = right;
+};

data/vendor/assets/javascripts/jsts/index/kdtree/KdTree.js

@@ -0,0 +1,218 @@
+/* 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.
+ */
+
+
+
+/**
+ * An implementation of a 2-D KD-Tree. KD-trees provide fast range searching on
+ * point data.
+ * <p>
+ * This implementation supports detecting and snapping points which are closer
+ * than a given tolerance value. If the same point (up to tolerance) is inserted
+ * more than once a new node is not created but the count of the existing node
+ * is incremented.
+ *
+ * Creates a new instance of a KdTree, specifying a snapping distance tolerance.
+ * Points which lie closer than the tolerance to a point already in the tree
+ * will be treated as identical to the existing point.
+ *
+ * @param {Number}
+ *          tolerance (optional) the tolerance distance for considering two
+ *          points equal.
+ *
+ * @constructor
+ */
+jsts.index.kdtree.KdTree = function(tolerance) {
+  var tol = 0.0;
+  if (tolerance !== undefined) {
+    tol = tolerance;
+  }
+
+  this.root = null;
+  this.last = null;
+  this.numberOfNodes = 0;
+  this.tolerance = tol;
+};
+
+
+/**
+ * Inserts a new point in the kd-tree.
+ *
+ * Will call correct *insert function depending on arguments
+ *
+ * @return {jsts.index.kdtree.KdNode} The kd-node containing the point.
+ */
+jsts.index.kdtree.KdTree.prototype.insert = function() {
+  if (arguments.length === 1) {
+    return this.insertCoordinate.apply(this, arguments[0]);
+  } else {
+    return this.insertWithData.apply(this, arguments[0], arguments[1]);
+  }
+};
+
+
+/**
+ * Inserts a new point in the kd-tree, with no data.
+ *
+ * @param {jsts.geom.Coordinate}
+ *          p the point to insert.
+ * @return {jsts.index.kdtree.KdNode} the kdnode containing the point.
+ */
+jsts.index.kdtree.KdTree.prototype.insertCoordinate = function(p) {
+  return this.insertWithData(p, null);
+};
+
+
+/**
+ * Inserts a new point into the kd-tree.
+ *
+ * @param {jsts.geom.Coordinate}
+ *          p the point to insert.
+ * @param {Object}
+ *          data a data item for the point.
+ * @return {jsts.index.kdtree.KdNode} returns a new KdNode if a new point is
+ *         inserted, else an existing node is returned with its counter
+ *         incremented. This can be checked by testing returnedNode.getCount() >
+ *         1.
+ */
+jsts.index.kdtree.KdTree.prototype.insertWithData = function(p, data) {
+  if (this.root === null) {
+    this.root = new jsts.index.kdtree.KdNode(p, data);
+    return this.root;
+  }
+
+  var currentNode = this.root, leafNode = this.root, isOddLevel = true, isLessThan = true;
+
+  // traverse the tree first cutting the plane left-right the top-bottom
+  while (currentNode !== last) {
+    if (isOddLevel) {
+      isLessThan = p.x < currentNode.getX();
+    } else {
+      isLessThan = p.y < currentNode.getY();
+    }
+    leafNode = currentNode;
+    if (isLessThan) {
+      currentNode = currentNode.getLeft();
+    } else {
+      currentNode = currentNode.getRight();
+    }
+
+    // test if point is already a node
+    if (currentNode !== null) {
+      var isInTolerance = p.distance(currentNode.getCoordinate()) <= this.tolerance;
+
+      // check if point is already in tree (up to tolerance) and if so simply
+      // return existing node
+      if (isInTolerance) {
+        currentNode.increment();
+        return currentNode;
+      }
+    }
+    isOddLevel = !isOddLevel;
+  }
+
+  // no node found, add new leaf node to tree
+  this.numberOfNodes = numberOfNodes + 1;
+  var node = new jsts.index.kdtree.KdNode(p, data);
+  node.setLeft(this.last);
+  node.setRight(this.last);
+  if (isLessThan) {
+    leafNode.setLeft(node);
+  } else {
+    leafNode.setRight(node);
+  }
+  return node;
+};
+
+
+/**
+ * Query's the tree
+ *
+ * @param {jsts.index.kdtree.KdNode}
+ *          currentNode the current node.
+ * @param {jsts.index.kdtree.KdNode}
+ *          bottomNode the bottom node.
+ * @param {jsts.geom.Envelope}
+ *          queryEnv the query-envelope.
+ * @param {Boolean}
+ *          odd true if the level is odd.
+ * @param {Array}
+ *          result the array to fill the result with.
+ */
+jsts.index.kdtree.KdTree.prototype.queryNode = function(currentNode,
+    bottomNode, queryEnv, odd, result) {
+  if (currentNode === bottomNode) {
+    return;
+  }
+
+  var min, max, discriminant;
+  if (odd) {
+    min = queryEnv.getMinX();
+    max = queryEnv.getMaxX();
+    discriminant = currentNode.getX();
+  } else {
+    min = queryEnv.getMinY();
+    max = queryEnv.getMaxY();
+    discriminant = currentNode.getY();
+  }
+
+  var searchLeft = min < discriminant;
+  var searchRight = discriminant <= max;
+
+  if (searchLeft) {
+    this.queryNode(currentNode.getLeft(), bottomNode, queryEnv, !odd, result);
+  }
+
+  if (queryEnv.contains(currentNode.getCoordinate())) {
+    result.add(currentNode);
+  }
+
+  if (searchRight) {
+    this.queryNode(currentNode.getRight(), bottomNode, queryEnv, !odd, result);
+  }
+};
+
+
+/**
+ * Will call the correct *query-function depending on arguments
+ *
+ * @return {Array{jsts.index.KdNode}} The found nodes.
+ */
+jsts.index.kdtree.KdTree.prototype.query = function() {
+  if (arguments.length === 1) {
+    return this.queryByEnvelope.apply(this, arguments[0]);
+  } else {
+    return this.queryWithArray.apply(this, arguments[0], arguments[1]);
+  }
+};
+
+
+/**
+ * Performs a range search of the points in the index.
+ *
+ * @param {jsts.geom.Envelope}
+ *          queryEnv the range rectangle to query.
+ * @return {Array} a list of the KdNodes found.
+ */
+jsts.index.kdtree.KdTree.prototype.queryByEnvelope = function(queryEnv) {
+  var result = [];
+  this.queryNode(this.root, this.last, queryEnv, true, result);
+  return result;
+};
+
+
+/**
+ * Performs a range search of the points in the index.
+ *
+ * @param {jsts.geom.Envelope}
+ *          queryEnv the range rectangle to query.
+ * @param {Array}
+ *          result a list to accumulate the result nodes into.
+ */
+jsts.index.kdtree.KdTree.prototype.queryWithArray = function(queryEnv, result) {
+  this.queryNode(this.root, this.last, queryEnv, true, result);
+};