jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/index/bintree/NodeBase.js

@@ -0,0 +1,220 @@
+/* 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.
+ */
+
+/**
+ * The base class for nodes in a {@link Bintree}.
+ */
+(function() {
+
+  /**
+   * Constructs a new NodeBase
+   *
+   * @constructor
+   */
+  var NodeBase = function() {
+    this.items = new javascript.util.ArrayList();
+
+    /**
+     * subnodes are numbered as follows:
+     *
+     * 0 | 1
+     */
+    this.subnode = [null, null];
+  };
+
+  /**
+   * Returns the index of the subnode that wholely contains the given interval.
+   * If none does, returns -1.
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          interval the interval.
+   * @param {Number}
+   *          centre
+   */
+  NodeBase.getSubnodeIndex = function(interval, centre) {
+    var subnodeIndex = -1;
+    if (interval.min >= centre) {
+      subnodeIndex = 1;
+    }
+    if (interval.max <= centre) {
+      subnodeIndex = 0;
+    }
+    return subnodeIndex;
+  };
+
+  /**
+   * Gets the items
+   *
+   * @return {javascript.util.ArrayList}
+   */
+  NodeBase.prototype.getItems = function() {
+    return this.items;
+  };
+
+  /**
+   * Adds an item
+   *
+   * @param {Object}
+   *          item the item to add.
+   */
+  NodeBase.prototype.add = function(item) {
+    this.items.add(item);
+  };
+
+  /**
+   * Adds all items from this tree to the provided items
+   *
+   * @param {javascript.util.ArrayList}
+   *          items the list to add to.
+   * @return {javscript.util.ArrayList} the input list filled with items.
+   */
+  NodeBase.prototype.addAllItems = function(items) {
+    // TODO: Check if addAll really takes an ordinary javascript array
+    items.addAll(this.items);
+    var i = 0, il = 2;
+    for (i; i < il; i++) {
+      if (this.subnode[i] !== null) {
+        this.subnode[i].addAllItems(items);
+      }
+    }
+    return items;
+  };
+
+  /**
+   * Adds items in the tree which potentially overlap the query interval to the
+   * given collection. If the query interval is <tt>null</tt>, add all items
+   * in the tree.
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          interval a query nterval, or null.
+   * @param {javascript.util.Collection}
+   *          resultItems the candidate items found.
+   */
+  NodeBase.prototype.addAllItemsFromOverlapping = function(interval,
+      resultItems) {
+    if (interval !== null && !this.isSearchMatch(interval)) {
+      return;
+    }
+
+    // some of these may not actually overlap - this is allowed by the bintree
+    // contract
+    resultItems.addAll(this.items);
+
+    if (this.subnode[0] !== null) {
+      this.subnode[0].addAllItemsFromOverlapping(interval, resultItems);
+    }
+
+    if (this.subnode[1] !== null) {
+      this.subnode[1].addAllItemsFromOverlapping(interval, resultItems);
+    }
+  };
+
+  /**
+   * Removes a single item from this subtree.
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          itemInterval the envelope containing the item.
+   * @param {Object}
+   *          item the item to remove.
+   * @return <code>true</code> if the item was found and removed.
+   */
+  NodeBase.prototype.remove = function(itemInterval, item) {
+    if (!this.isSearchMatch(itemInterval)) {
+      return false;
+    }
+
+    var found = false, i = 0, il = 2;
+    for (i; i < il; i++) {
+      if (this.subnode[i] !== null) {
+        found = this.subnode[i].remove(itemInterval, item);
+        if (found) {
+          // trim subtree if empty
+          if (this.subnode[i].isPrunable()) {
+            this.subnode[i] = null;
+          }
+          break;
+        }
+      }
+    }
+
+    // if item was found lower down, don't need to search for it here
+    if (found) {
+      return found;
+    }
+
+    // otherwise, try and remove the item from the list of items in this node
+    found = this.items.remove(item);
+    return found;
+  };
+
+  /**
+   * Checks if this tree has any children or items
+   *
+   * @return {Boolean} true if it has children or items (or both).
+   */
+  NodeBase.prototype.isPrunable = function() {
+    return !(this.hasChildren() || this.hasItems());
+  };
+
+  /**
+   * Checks if this tree has any children
+   *
+   * @return {Boolean} true if it has children.
+   */
+  NodeBase.prototype.hasChildren = function() {
+    var i = 0, il = 2;
+    for (i; i < il; i++) {
+      if (this.subnode[i] !== null) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  /**
+   * Checks i this node has any items
+   *
+   * @return {Boolean} true if it has items.
+   */
+  NodeBase.prototype.hasItems = function() {
+    return !this.items.isEmpty();
+  };
+
+  NodeBase.prototype.depth = function() {
+    var maxSubDepth = 0, i = 0, il = 2, sqd;
+    for (i; i < il; i++) {
+      if (this.subnode[i] !== null) {
+        sqd = this.subnode[i].depth();
+        if (sqd > maxSubDepth) {
+          maxSubDepth = sqd;
+        }
+      }
+    }
+    return maxSubDepth + 1;
+  };
+
+  NodeBase.prototype.size = function() {
+    var subSize = 0, i = 0, il = 2;
+    for (i; i < il; i++) {
+      if (this.subnode[i] !== null) {
+        subSize += this.subnode[i].size();
+      }
+    }
+    return subSize + this.items.size();
+  };
+
+  NodeBase.prototype.nodeSize = function() {
+    var subSize = 0, i = 0, il = 2;
+    for (i; i < il; i++) {
+      if (this.subnode[i] !== null) {
+        subSize += this.subnode[i].nodeSize();
+      }
+    }
+    return subSize + 1;
+  };
+
+  jsts.index.bintree.NodeBase = NodeBase;
+})();

data/vendor/assets/javascripts/jsts/index/bintree/Root.js

@@ -0,0 +1,113 @@
+/* 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.
+ */
+
+/**
+ * The root node of a single {@link Bintree}. It is centred at the origin, and
+ * does not have a defined extent.
+ */
+(function() {
+
+  /**
+   * @requires jsts/index/bintree/NodeBase.js
+   * @requires jsts/index/bintree/Node.js
+   */
+
+  var Node = jsts.index.bintree.Node;
+  var NodeBase = jsts.index.bintree.NodeBase;
+
+  /**
+   * Constructs a new Root
+   *
+   * @constructor
+   */
+  var Root = function() {
+    /**
+     * subnodes are numbered as follows:
+     *
+     * 0 | 1
+     */
+    this.subnode = [null, null];
+    this.items = new javascript.util.ArrayList();
+  };
+  Root.prototype = new jsts.index.bintree.NodeBase();
+  Root.constructor = Root;
+
+  // the singleton root node is centred at the origin.
+  Root.origin = 0.0;
+
+  /**
+   * Insert an item into the tree this is the root of.
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          itemInterval the interval of the item.
+   * @param {Object}
+   *          item the item to insert.
+   */
+  Root.prototype.insert = function(itemInterval, item) {
+    var index = NodeBase.getSubnodeIndex(itemInterval, Root.origin), node, largerNode;
+    // if index is -1, itemEnv must contain the origin.
+    if (index === -1) {
+      this.add(item);
+      return;
+    }
+
+    /**
+     * the item must be contained in one interval, so insert it into the tree
+     * for that interval (which may not yet exist)
+     */
+    node = this.subnode[index];
+
+    /**
+     * If the subnode doesn't exist or this item is not contained in it, have to
+     * expand the tree upward to contain the item.
+     */
+
+    if (node === null || !node.getInterval().contains(itemInterval)) {
+      largerNode = Node.createExpanded(node, itemInterval);
+      this.subnode[index] = largerNode;
+    }
+
+    /**
+     * At this point we have a subnode which exists and must contain contains
+     * the env for the item. Insert the item into the tree.
+     */
+    this.insertContained(this.subnode[index], itemInterval, item);
+  };
+
+  /**
+   * insert an item which is known to be contained in the tree rooted at the
+   * given Node. Lower levels of the tree will be created if necessary to hold
+   * the item.
+   *
+   * @param {jsts.index.bintree.Node}
+   *          tree the subtree.
+   * @param {jsts.index.bintree.Interval}
+   *          itemInterval the interval.
+   * @param {Object}
+   *          item the item to insert.
+   */
+  Root.prototype.insertContained = function(tree, itemInterval, item) {
+    var isZeroArea, node;
+    /**
+     * Do NOT create a new node for zero-area intervals - this would lead to
+     * infinite recursion. Instead, use a heuristic of simply returning the
+     * smallest existing node containing the query
+     */
+    isZeroArea = jsts.index.IntervalSize.isZeroWidth(itemInterval
+        .getMin(), itemInterval.getMax());
+    node = isZeroArea ? tree.find(itemInterval) : tree.getNode(itemInterval);
+    node.add(item);
+  };
+
+  /**
+   * The root node matches all searches
+   */
+  Root.prototype.isSearchMatch = function(interval) {
+    return true;
+  };
+
+  jsts.index.bintree.Root = Root;
+})();

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

@@ -0,0 +1,244 @@
+/* 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.
+ */
+
+/**
+ * Monotone Chains are a way of partitioning the segments of a linestring to
+ * allow for fast searching of intersections. They have the following
+ * properties:
+ * <ol>
+ * <li>the segments within a monotone chain never intersect each other
+ * <li>the envelope of any contiguous subset of the segments in a monotone
+ * chain is equal to the envelope of the endpoints of the subset.
+ * </ol>
+ * Property 1 means that there is no need to test pairs of segments from within
+ * the same monotone chain for intersection.
+ * <p>
+ * Property 2 allows an efficient binary search to be used to find the
+ * intersection points of two monotone chains. For many types of real-world
+ * data, these properties eliminate a large number of segment comparisons,
+ * producing substantial speed gains.
+ * <p>
+ * One of the goals of this implementation of MonotoneChains is to be as space
+ * and time efficient as possible. One design choice that aids this is that a
+ * MonotoneChain is based on a subarray of a list of points. This means that new
+ * arrays of points (potentially very large) do not have to be allocated.
+ * <p>
+ *
+ * MonotoneChains support the following kinds of queries:
+ * <ul>
+ * <li>Envelope select: determine all the segments in the chain which intersect
+ * a given envelope
+ * <li>Overlap: determine all the pairs of segments in two chains whose
+ * envelopes overlap
+ * </ul>
+ *
+ * This implementation of MonotoneChains uses the concept of internal iterators
+ * to return the resultsets for the above queries. This has time and space
+ * advantages, since it is not necessary to build lists of instantiated objects
+ * to represent the segments returned by the query. However, it does mean that
+ * the queries are not thread-safe.
+ *
+ * @constructor
+ */
+jsts.index.chain.MonotoneChain = function(pts, start, end, context) {
+  this.pts = pts;
+  this.start = start;
+  this.end = end;
+  this.context = context;
+};
+
+/**
+ * @type {Array.<jsts.geom.Coordinate>}
+ * @private
+ */
+jsts.index.chain.MonotoneChain.prototype.pts = null;
+/**
+ * @type {number}
+ * @private
+ */
+jsts.index.chain.MonotoneChain.prototype.start = null;
+/**
+ * @type {number}
+ * @private
+ */
+jsts.index.chain.MonotoneChain.prototype.end = null;
+/**
+ * @type {Envelope}
+ * @private
+ */
+jsts.index.chain.MonotoneChain.prototype.env = null;
+/**
+ * user-defined information
+ *
+ * @type {Object}
+ * @private
+ */
+jsts.index.chain.MonotoneChain.prototype.context = null;
+/**
+ * useful for optimizing chain comparisons
+ *
+ * @type {number}
+ * @private
+ */
+jsts.index.chain.MonotoneChain.prototype.id = null;
+
+jsts.index.chain.MonotoneChain.prototype.setId = function(id) {
+  this.id = id;
+};
+jsts.index.chain.MonotoneChain.prototype.getId = function() {
+  return this.id;
+};
+
+jsts.index.chain.MonotoneChain.prototype.getContext = function() {
+  return this.context;
+};
+
+jsts.index.chain.MonotoneChain.prototype.getEnvelope = function() {
+  if (this.env == null) {
+    var p0 = this.pts[this.start];
+    var p1 = this.pts[this.end];
+    this.env = new jsts.geom.Envelope(p0, p1);
+  }
+  return this.env;
+};
+
+jsts.index.chain.MonotoneChain.prototype.getStartIndex = function() {
+  return this.start;
+};
+jsts.index.chain.MonotoneChain.prototype.getEndIndex = function() {
+  return this.end;
+};
+
+jsts.index.chain.MonotoneChain.prototype.getLineSegment = function(index, ls) {
+  ls.p0 = this.pts[index];
+  ls.p1 = this.pts[index + 1];
+};
+/**
+ * Return the subsequence of coordinates forming this chain. Allocates a new
+ * array to hold the Coordinates
+ */
+jsts.index.chain.MonotoneChain.prototype.getCoordinates = function() {
+  var coord = [];
+  var index = 0;
+  for (var i = this.start; i <= this.end; i++) {
+    coord[index++] = this.pts[i];
+  }
+  return coord;
+};
+
+/**
+ * Determine all the line segments in the chain whose envelopes overlap the
+ * searchEnvelope, and process them.
+ * <p>
+ * The monotone chain search algorithm attempts to optimize performance by not
+ * calling the select action on chain segments which it can determine are not in
+ * the search envelope. However, it *may* call the select action on segments
+ * which do not intersect the search envelope. This saves on the overhead of
+ * checking envelope intersection each time, since clients may be able to do
+ * this more efficiently.
+ *
+ * @param {Envelope}
+ *          searchEnv the search envelope.
+ * @param {MonotoneChainSelectAction}
+ *          mcs the select action to execute on selected segments.
+ */
+jsts.index.chain.MonotoneChain.prototype.select = function(searchEnv, mcs) {
+  this.computeSelect2(searchEnv, this.start, this.end, mcs);
+};
+
+/**
+ * @private
+ */
+jsts.index.chain.MonotoneChain.prototype.computeSelect2 = function(searchEnv,
+    start0, end0, mcs) {
+  var p0 = this.pts[start0];
+  var p1 = this.pts[end0];
+  mcs.tempEnv1.init(p0, p1);
+
+  // terminating condition for the recursion
+  if (end0 - start0 === 1) {
+    mcs.select(this, start0);
+    return;
+  }
+  // nothing to do if the envelopes don't overlap
+  if (!searchEnv.intersects(mcs.tempEnv1))
+    return;
+
+  // the chains overlap, so split each in half and iterate (binary search)
+  var mid = parseInt((start0 + end0) / 2);
+
+  // Assert: mid != start or end (since we checked above for end - start <= 1)
+  // check terminating conditions before recursing
+  if (start0 < mid) {
+    this.computeSelect2(searchEnv, start0, mid, mcs);
+  }
+  if (mid < end0) {
+    this.computeSelect2(searchEnv, mid, end0, mcs);
+  }
+};
+
+/**
+ * Determine all the line segments in two chains which may overlap, and process
+ * them.
+ * <p>
+ * The monotone chain search algorithm attempts to optimize performance by not
+ * calling the overlap action on chain segments which it can determine do not
+ * overlap. However, it *may* call the overlap action on segments which do not
+ * actually interact. This saves on the overhead of checking intersection each
+ * time, since clients may be able to do this more efficiently.
+ *
+ * @param {MonotoneChain}
+ *          searchEnv the search envelope.
+ * @param {MonotoneChainOverlapAction}
+ *          mco the overlap action to execute on selected segments.
+ */
+jsts.index.chain.MonotoneChain.prototype.computeOverlaps = function(mc, mco) {
+  if (arguments.length === 6) {
+    return this.computeOverlaps2.apply(this, arguments);
+  }
+  this.computeOverlaps2(this.start, this.end, mc, mc.start, mc.end, mco);
+};
+
+/**
+ * @private
+ */
+jsts.index.chain.MonotoneChain.prototype.computeOverlaps2 = function(start0,
+    end0, mc, start1, end1, mco) {
+  var p00 = this.pts[start0];
+  var p01 = this.pts[end0];
+  var p10 = mc.pts[start1];
+  var p11 = mc.pts[end1];
+  // Debug.println("computeIntersectsForChain:" + p00 + p01 + p10 + p11);
+  // terminating condition for the recursion
+  if (end0 - start0 === 1 && end1 - start1 === 1) {
+    mco.overlap(this, start0, mc, start1);
+    return;
+  }
+  // nothing to do if the envelopes of these chains don't overlap
+  mco.tempEnv1.init(p00, p01);
+  mco.tempEnv2.init(p10, p11);
+  if (!mco.tempEnv1.intersects(mco.tempEnv2))
+    return;
+
+  // the chains overlap, so split each in half and iterate (binary search)
+  var mid0 = parseInt((start0 + end0) / 2);
+  var mid1 = parseInt((start1 + end1) / 2);
+
+  // Assert: mid != start or end (since we checked above for end - start <= 1)
+  // check terminating conditions before recursing
+  if (start0 < mid0) {
+    if (start1 < mid1)
+      this.computeOverlaps2(start0, mid0, mc, start1, mid1, mco);
+    if (mid1 < end1)
+      this.computeOverlaps2(start0, mid0, mc, mid1, end1, mco);
+  }
+  if (mid0 < end0) {
+    if (start1 < mid1)
+      this.computeOverlaps2(mid0, end0, mc, start1, mid1, mco);
+    if (mid1 < end1)
+      this.computeOverlaps2(mid0, end0, mc, mid1, end1, mco);
+  }
+};