jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/index/quadtree/Key.js

@@ -0,0 +1,134 @@
+/* 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 Key is a unique identifier for a node in a quadtree. It contains a
+ * lower-left point and a level number. The level number is the power of two for
+ * the size of the node envelope.
+ *
+ * @param {jsts.geom.Envelope}
+ *          itemEnv the envelope of the key.
+ *
+ * @constructor
+ */
+jsts.index.quadtree.Key = function(itemEnv) {
+  // the fields which make up the key
+  this.pt = new jsts.geom.Coordinate();
+  this.level = 0;
+  // auxiliary data which is derived from the key for use in computation
+  this.env = null;
+
+  this.computeKey(itemEnv);
+};
+
+
+/**
+ * Computes the quad-level for specified envelope
+ *
+ * @param {jsts.geom.Envelope}
+ *          env the envelope to calculate level for.
+ * @return {Number} The calculated level.
+ */
+jsts.index.quadtree.Key.computeQuadLevel = function(env) {
+  var dx, dy, dMax, level;
+
+  dx = env.getWidth();
+  dy = env.getHeight();
+  dMax = dx > dy ? dx : dy;
+  level = jsts.index.DoubleBits.exponent(dMax) + 1;
+  return level;
+};
+
+
+/**
+ * Gets the point of this key.
+ *
+ * @return {jsts.geom.Coordinate} The point.
+ */
+jsts.index.quadtree.Key.prototype.getPoint = function() {
+  return this.pt;
+};
+
+
+/**
+ * Gets the level of this key
+ *
+ * @return {Number} The level.
+ */
+jsts.index.quadtree.Key.prototype.getLevel = function() {
+  return this.level;
+};
+
+
+/**
+ * Gets the envelope of this key
+ *
+ * @return {jsts.geom.Envelope} The envelope.
+ */
+jsts.index.quadtree.Key.prototype.getEnvelope = function() {
+  return this.env;
+};
+
+
+/**
+ * Gets the centre of this key
+ *
+ * @return {jsts.geom.Coordinate} the center-point.
+ */
+jsts.index.quadtree.Key.prototype.getCentre = function() {
+  var x, y;
+  x = (this.env.getMinX() + this.env.getMaxX()) / 2;
+  y = (this.env.getMinY() + this.env.getMaxY()) / 2;
+  return new jsts.geom.Coordinate(x, y);
+};
+
+
+/**
+ * Will call appropriate computeKey* method depending on arguments.
+ */
+jsts.index.quadtree.Key.prototype.computeKey = function() {
+  if (arguments[0] instanceof jsts.geom.Envelope) {
+    this.computeKeyFromEnvelope(arguments[0]);
+  } else {
+    this.computeKeyFromLevel(arguments[0], arguments[1]);
+  }
+};
+
+
+/**
+ * Computes the key from specified envlope.
+ *
+ * @param {jsts.geom.Envelope}
+ *          env the envelope.
+ */
+jsts.index.quadtree.Key.prototype.computeKeyFromEnvelope = function(env) {
+  this.level = jsts.index.quadtree.Key.computeQuadLevel(env);
+  this.env = new jsts.geom.Envelope();
+  this.computeKey(this.level, env);
+  while (!this.env.contains(env)) {
+    this.level += 1;
+    this.computeKey(this.level, env);
+  }
+};
+
+
+/**
+ * Computes a key from a level and an envelope
+ *
+ * @param {Number}
+ *          level the level.
+ * @param {jsts.geom.Envelope}
+ *          env the envelope.
+ */
+jsts.index.quadtree.Key.prototype.computeKeyFromLevel = function(level, env) {
+  var quadSize = jsts.index.DoubleBits.powerOf2(level);
+  this.pt.x = Math.floor(env.getMinX() / quadSize) * quadSize;
+  this.pt.y = Math.floor(env.getMinY() / quadSize) * quadSize;
+  this.env.init(this.pt.x, this.pt.x + quadSize, this.pt.y, this.pt.y +
+      quadSize);
+};

data/vendor/assets/javascripts/jsts/index/quadtree/Node.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.
+ */
+
+
+
+/**
+ * Represents a node of a {@link Quadtree}. Nodes contain items which have a
+ * spatial extent corresponding to the node's position in the quadtree.
+ *
+ * @param {jsts.geom.Envelope}
+ *          env Envelope to initialize from.
+ * @param {Number}
+ *          level The level.
+ *
+ * @constructor
+ * @requires jsts/index/quadtree/NodeBase.js
+ */
+jsts.index.quadtree.Node = function(env, level) {
+  jsts.index.quadtree.NodeBase.prototype.constructor.apply(this, arguments);
+
+  this.env = env;
+  this.level = level;
+  this.centre = new jsts.geom.Coordinate();
+  this.centre.x = (env.getMinX() + env.getMaxX()) / 2;
+  this.centre.y = (env.getMinY() + env.getMaxY()) / 2;
+};
+
+jsts.index.quadtree.Node.prototype = new jsts.index.quadtree.NodeBase();
+
+
+/**
+ * Creates a node from specified envelope
+ *
+ * @param {jsts.geom.Envelope}
+ *          env the envelope.
+ * @return {jsts.index.quadtree.Node} the created node.
+ */
+jsts.index.quadtree.Node.createNode = function(env) {
+  var key, node;
+  key = new jsts.index.quadtree.Key(env);
+  node = new jsts.index.quadtree.Node(key.getEnvelope(), key.getLevel());
+
+  return node;
+};
+
+
+/**
+ * Creates an expanded node.
+ *
+ * @param {jsts.index.quadtree.Node}
+ *          node the node to create a new node from.
+ * @param {jsts.geom.Envelope}
+ *          addEnv the envelope.
+ * @return {jsts.index.quadtree.Node} the created node.
+ */
+jsts.index.quadtree.Node.createExpanded = function(node, addEnv) {
+  var expandEnv = new jsts.geom.Envelope(addEnv), largerNode;
+
+  if (node !== null) {
+    expandEnv.expandToInclude(node.env);
+  }
+
+  largerNode = jsts.index.quadtree.Node.createNode(expandEnv);
+  if (node !== null) {
+    largerNode.insertNode(node);
+  }
+
+  return largerNode;
+};
+
+
+/**
+ * Gets the envelope for this node
+ *
+ * @return {jsts.geom.Envelope} the envelope.
+ */
+jsts.index.quadtree.Node.prototype.getEnvelope = function() {
+  return this.env;
+};
+
+
+/**
+ * Checks wheter the provided envelope intersects this nodes envelope.
+ *
+ * @param {jsts.geom.Envelope}
+ *          searchEnv the envelope to search.
+ * @return {Boolean} True if searchEnv intersects this nodes envelope.
+ */
+jsts.index.quadtree.Node.prototype.isSearchMatch = function(searchEnv) {
+  return this.env.intersects(searchEnv);
+};
+
+
+/**
+ * Returns the subquad containing the envelope. Creates the subquad if it does
+ * not already exist.
+ *
+ * @param {jsts.geom.Envelope}
+ *          searchEnv the input envelope.
+ * @return {jsts.index.quadtree.Node} the node containing the searchEnv.
+ */
+jsts.index.quadtree.Node.prototype.getNode = function(searchEnv) {
+  var subnodeIndex = this.getSubnodeIndex(searchEnv, this.centre), node;
+
+  // if subquadIndex is -1 searchEnv is not contained in a subquad
+  if (subnodeIndex !== -1) {
+    // create the quad if it does not exist
+    node = this.getSubnode(subnodeIndex);
+    // recursively search the found/created quad
+    return node.getNode(searchEnv);
+  } else {
+    return this;
+  }
+};
+
+
+/**
+ * Returns the smallest <i>existing</i> node containing the envelope.
+ *
+ * @param {jsts.geom.Envelope}
+ *          searchEnv input Envelope.
+ * @return {jsts.index.quadtree.Node} the smallest node containing searchEnv.
+ */
+jsts.index.quadtree.Node.prototype.find = function(searchEnv) {
+  var subnodeIndex = this.getSubnodeIndex(searchEnv, this.centre), node;
+  if (subnodeIndex === -1) {
+    return this;
+  }
+
+  if (this.subnode[subnodeIndex] !== null) {
+    // query lies in subquad, so search it
+    node = this.subnode[subnodeIndex];
+    return node.find(searchEnv);
+  }
+
+  // no existing subquad, so return this one anyway
+  return this;
+};
+
+
+/**
+ * Inserts a child-node
+ *
+ * @param {jsts.index.quadtree.Node}
+ *          node to insert.
+ */
+jsts.index.quadtree.Node.prototype.insertNode = function(node) {
+  var index = this.getSubnodeIndex(node.env, this.centre), childNode;
+  if (node.level === this.level - 1) {
+    this.subnode[index] = node;
+  } else {
+    // the quad is not a direct child, so make a new child quad to contain it
+    // and recursively insert the quad
+    childNode = this.createSubnode(index);
+    childNode.insertNode(node);
+    this.subnode[index] = childNode;
+  }
+};
+
+
+/**
+ * get the subquad for the index. If it doesn't exist, create it
+ *
+ * @param {Number}
+ *          index the index of the subnode to get.
+ * @return {jsts.index.quadtree.Node} the specified subnode.
+ */
+jsts.index.quadtree.Node.prototype.getSubnode = function(index) {
+  if (this.subnode[index] === null) {
+    this.subnode[index] = this.createSubnode(index);
+  }
+  return this.subnode[index];
+};
+
+
+/**
+ * Creates a subnode
+ *
+ * @param {Number}
+ *          index The index (0-4) on where to create a subnode.
+ * @return {jsts.index.quadtree.Node} the created node.
+ */
+jsts.index.quadtree.Node.prototype.createSubnode = function(index) {
+  var minx = 0.0, maxx = 0.0, miny = 0.0, maxy = 0.0, sqEnv, node;
+  // create a new subquad in the appropriate quadrant
+  switch (index) {
+    case 0:
+      minx = this.env.getMinX();
+      maxx = this.centre.x;
+      miny = this.env.getMinY();
+      maxy = this.centre.y;
+      break;
+    case 1:
+      minx = this.centre.x;
+      maxx = this.env.getMaxX();
+      miny = this.env.getMinY();
+      maxy = this.centre.y;
+      break;
+    case 2:
+      minx = this.env.getMinX();
+      maxx = this.centre.x;
+      miny = this.centre.y;
+      maxy = this.env.getMaxY();
+      break;
+    case 3:
+      minx = this.centre.x;
+      maxx = this.env.getMaxX();
+      miny = this.centre.y;
+      maxy = this.env.getMaxY();
+      break;
+  }
+
+  sqEnv = new jsts.geom.Envelope(minx, maxx, miny, maxy);
+  node = new jsts.index.quadtree.Node(sqEnv, this.level - 1);
+
+  return node;
+};

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

@@ -0,0 +1,330 @@
+/* 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 Quadtree}.
+ *
+ * @constructor
+ */
+jsts.index.quadtree.NodeBase = function() {
+  /**
+   * subquads are numbered as follows:
+   *
+   * <pre>
+   *  2 | 3
+   *  --+--
+   *  0 | 1
+   * </pre>
+   */
+  this.subnode = new Array(4);
+  this.subnode[0] = null;
+  this.subnode[1] = null;
+  this.subnode[2] = null;
+  this.subnode[3] = null;
+
+  this.items = [];
+};
+
+
+/**
+ * Returns the index of the subquad that wholly contains the given envelope. If
+ * none does, returns -1.
+ *
+ * @param {jsts.geom.Envelope}
+ *          env The envelope to check.
+ * @param {jsts.geom.Coordinate}
+ *          centre The coordinate.
+ * @return {Number} The sub-index or -1.
+ */
+jsts.index.quadtree.NodeBase.prototype.getSubnodeIndex = function(env, centre) {
+  var subnodeIndex = -1;
+  if (env.getMinX() >= centre.x) {
+    if (env.getMinY() >= centre.y) {
+      subnodeIndex = 3;
+    }
+    if (env.getMaxY() <= centre.y) {
+      subnodeIndex = 1;
+    }
+  }
+  if (env.getMaxX() <= centre.x) {
+    if (env.getMinY() >= centre.y) {
+      subnodeIndex = 2;
+    }
+    if (env.getMaxY() <= centre.y) {
+      subnodeIndex = 0;
+    }
+  }
+  return subnodeIndex;
+};
+
+
+/**
+ * Returns the nodes items
+ *
+ * @return {Array} the items-array.
+ */
+jsts.index.quadtree.NodeBase.prototype.getItems = function() {
+  return this.items;
+};
+
+
+/**
+ * Checks if the node has any items
+ *
+ * @return {Boolean} true if the node has any items.
+ */
+jsts.index.quadtree.NodeBase.prototype.hasItems = function() {
+  return (this.items.length > 0);
+};
+
+
+/**
+ * Adds an item to the node
+ *
+ * @param {Object}
+ *          item the item to add.
+ */
+jsts.index.quadtree.NodeBase.prototype.add = function(item) {
+  this.items.push(item);
+};
+
+
+/**
+ * Removes a single item from this subtree.
+ *
+ * @param {jsts.geom.Envelope}
+ *          itemEnv the envelope containing the item.
+ * @param {Object}
+ *          item the item to remove.
+ * @return {Boolean} <code>true</code> if the item was found and removed.
+ */
+jsts.index.quadtree.NodeBase.prototype.remove = function(itemEnv, item) {
+  // use envelope to restrict nodes scanned
+  if (!this.isSearchMatch(itemEnv)) {
+    return false;
+  }
+
+  var found = false, i = 0;
+  for (i; i < 4; i++) {
+    if (this.subnode[i] !== null) {
+      found = this.subnode[i].remove(itemEnv, 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
+
+  if (this.items.indexOf(item) !== -1) {
+    for (var i = this.items.length - 1; i >= 0; i--) {
+      if (this.items[i] === item) {
+        this.items.splice(i, 1);
+        // break;more than once??
+      }
+    }
+
+    found = true;
+  }
+  return found;
+};
+
+
+/**
+ * @return {Boolean} <code>true</code> if the node is prunable.
+ */
+jsts.index.quadtree.NodeBase.prototype.isPrunable = function() {
+  return !(this.hasChildren() || this.hasItems());
+};
+
+
+/**
+ * @return {Boolean} <code>true</code> if the node has any children.
+ */
+jsts.index.quadtree.NodeBase.prototype.hasChildren = function() {
+  var i = 0;
+  for (i; i < 4; i++) {
+    if (this.subnode[i] !== null) {
+      return true;
+    }
+  }
+  return false;
+};
+
+
+/**
+ * @return {Boolean} <code>true</code> if the node or any subnode does not
+ *         have any items.
+ */
+jsts.index.quadtree.NodeBase.prototype.isEmpty = function() {
+  var isEmpty = true;
+  if (this.items.length > 0) {
+    isEmpty = false;
+  }
+  var i = 0;
+  for (i; i < 4; i++) {
+    if (this.subnode[i] !== null) {
+      if (!this.subnode[i].isEmpty()) {
+        isEmpty = false;
+      }
+    }
+  }
+  return isEmpty;
+};
+
+
+/**
+ * Adds all the items of the node and any subnodes
+ *
+ * @param {Array}
+ *          resultItems the array to add items to.
+ * @return {Array} a new array with original and added items.
+ */
+jsts.index.quadtree.NodeBase.prototype.addAllItems = function(resultItems) {
+  // this node may have items as well as subnodes (since items may not
+  // be wholely contained in any single subnode
+  resultItems = resultItems.concat(this.items);
+  var i = 0;
+  for (i; i < 4; i++) {
+    if (this.subnode[i] !== null) {
+      resultItems = this.subnode[i].addAllItems(resultItems);
+      // resultItems = resultItems.concat(this.subnode[i]);
+    }
+  }
+
+  return resultItems;
+};
+
+
+/**
+ *
+ * @param {jsts.geom.Envelope}
+ *          searchEnv the search-envelope.
+ * @param {Array}
+ *          resultItems the array containing original and added items.
+ */
+jsts.index.quadtree.NodeBase.prototype.addAllItemsFromOverlapping = function(
+    searchEnv, resultItems) {
+  if (!this.isSearchMatch(searchEnv)) {
+    return;
+  }
+
+  // this node may have items as well as subnodes (since items may not
+  // be wholely contained in any single subnode
+
+  resultItems = resultItems.concat(this.items);
+
+  var i = 0;
+  for (i; i < 4; i++) {
+    if (this.subnode[i] !== null) {
+      resultItems = this.subnode[i].addAllItemsFromOverlapping(searchEnv,
+          resultItems);
+    }
+  }
+};
+
+
+/**
+ * Visits the node
+ *
+ * @param {jsts.geom.Envelope}
+ *          searchEnv the search-envelope.
+ * @param {Object}
+ *          visitor the visitor.
+ */
+jsts.index.quadtree.NodeBase.prototype.visit = function(searchEnv, visitor) {
+  if (!this.isSearchMatch(searchEnv)) {
+    return;
+  }
+
+  // this node may have items as well as subnodes (since items may not
+  // be wholely contained in any single subnode
+  this.visitItems(searchEnv, visitor);
+
+  var i = 0;
+  for (i; i < 4; i++) {
+    if (this.subnode[i] !== null) {
+      this.subnode[i].visit(searchEnv, visitor);
+    }
+  }
+};
+
+
+/**
+ * Visits the items
+ *
+ * @param {jsts.geom.Envelope}
+ *          env the search envelope.
+ * @param {Object}
+ *          visitor the visitor.
+ */
+jsts.index.quadtree.NodeBase.prototype.visitItems = function(env, visitor) {
+  var i = 0, il = this.items.length;
+
+  for (i; i < il; i++) {
+    visitor.visitItem(this.items[i]);
+  }
+};
+
+
+/**
+ * Calculates the depth
+ *
+ * @return {Number} the calculated depth.
+ */
+jsts.index.quadtree.NodeBase.prototype.depth = function() {
+  var maxSubDepth = 0, i = 0, sqd;
+  for (i; i < 4; i++) {
+    if (this.subnode[i] !== null) {
+      sqd = this.subnode[i].depth();
+      if (sqd > maxSubDepth) {
+        maxSubDepth = sqd;
+      }
+    }
+  }
+  return maxSubDepth + 1;
+};
+
+
+/**
+ * Calculates the size
+ *
+ * @return {Number} the calculated size.
+ */
+jsts.index.quadtree.NodeBase.prototype.size = function() {
+  var subSize = 0, i = 0;
+  for (i; i < 4; i++) {
+    if (this.subnode[i] !== null) {
+      subSize += this.subnode[i].size();
+    }
+  }
+  return subSize + this.items.length;
+};
+
+
+/**
+ * Counts the nodes
+ *
+ * @return {Number} the size of this node.
+ */
+jsts.index.quadtree.NodeBase.prototype.getNodeCount = function() {
+  var subSize = 0, i = 0;
+  for (i; i < 4; i++) {
+    if (this.subnode[i] !== null) {
+      subSize += this.subnode[i].size();
+    }
+  }
+  return subSize + 1;
+};