jsts-rails 0.1.0 → 0.2.0

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

@@ -0,0 +1,228 @@
+/* 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 Quadtree is a spatial index structure for efficient querying of 2D
+ * rectangles. If other kinds of spatial objects need to be indexed they can be
+ * represented by their envelopes
+ * <p>
+ * The quadtree structure is used to provide a primary filter for range
+ * rectangle queries. The query() method returns a list of all objects which
+ * <i>may</i> intersect the query rectangle. Note that it may return objects
+ * which do not in fact intersect. A secondary filter is required to test for
+ * exact intersection. Of course, this secondary filter may consist of other
+ * tests besides intersection, such as testing other kinds of spatial
+ * relationships.
+ *
+ * <p>
+ * This implementation does not require specifying the extent of the inserted
+ * items beforehand. It will automatically expand to accomodate any extent of
+ * dataset.
+ * <p>
+ * This data structure is also known as an <i>MX-CIF quadtree</i> following the
+ * usage of Samet and others.
+ *
+ * @constructor
+ */
+jsts.index.quadtree.Quadtree = function() {
+  this.root = new jsts.index.quadtree.Root();
+
+  /**
+   * minExtent is the minimum envelope extent of all items inserted into the
+   * tree so far. It is used as a heuristic value to construct non-zero
+   * envelopes for features with zero X and/or Y extent. Start with a non-zero
+   * extent, in case the first feature inserted has a zero extent in both
+   * directions. This value may be non-optimal, but only one feature will be
+   * inserted with this value.
+   */
+  this.minExtent = 1.0;
+};
+
+/**
+ * Ensure that the envelope for the inserted item has non-zero extents. Use the
+ * current minExtent to pad the envelope, if necessary
+ */
+
+
+/**
+ * Ensures an extent is not zero.
+ *
+ * @param {jsts.geom.Envelope}
+ *          itemEnv The envelope to check.
+ * @param {Number}
+ *          minExtent the minimum width/height to expand the extent with if it
+ *          is zero.
+ * @return {jsts.geom.Envelope} A valid extent.
+ */
+jsts.index.quadtree.Quadtree.ensureExtent = function(itemEnv, minExtent) {
+  var minx, maxx, miny, maxy;
+
+  minx = itemEnv.getMinX();
+  maxx = itemEnv.getMaxX();
+  miny = itemEnv.getMinY();
+  maxy = itemEnv.getMaxY();
+
+  // has a non-zero extent
+  if (minx !== maxx && miny !== maxy) {
+    return itemEnv;
+  }
+
+  // pad one or both extents
+  if (minx === maxx) {
+    minx = minx - (minExtent / 2.0);
+    maxx = minx + (minExtent / 2.0);
+  }
+
+  if (miny === maxy) {
+    miny = miny - (minExtent / 2.0);
+    maxy = miny + (minExtent / 2.0);
+  }
+
+  return new jsts.geom.Envelope(minx, maxx, miny, maxy);
+};
+
+
+/**
+ * Returns the depth of the tree.
+ *
+ * @return {Number} the depth.
+ */
+jsts.index.quadtree.Quadtree.prototype.depth = function() {
+  return this.root.depth();
+};
+
+
+/**
+ * Returns the number of items in the tree.
+ *
+ * @return {Number} the number of items in the tree.
+ */
+jsts.index.quadtree.Quadtree.prototype.size = function() {
+  return this.root.size();
+};
+
+
+/**
+ * Inserts an item to the tree
+ *
+ * @param {jsts.geom.Envelope}
+ *          itemEnv The envelope.
+ * @param {Object}
+ *          item The item.
+ */
+jsts.index.quadtree.Quadtree.prototype.insert = function(itemEnv, item) {
+  this.collectStats(itemEnv);
+  var insertEnv = jsts.index.quadtree.Quadtree.ensureExtent(itemEnv,
+      this.minExtent);
+  this.root.insert(insertEnv, item);
+};
+
+
+/**
+ * Removes a single item from the tree
+ *
+ * @param {jsts.geom.Envelope}
+ *          itemEnv the envelope of the item to be removed.
+ * @param {Object}
+ *          item the item to remove.
+ * @return {Boolean} <code>true</true> if the item was found (and removed).
+ */
+jsts.index.quadtree.Quadtree.prototype.remove = function(itemEnv, item) {
+  var posEnv = jsts.index.quadtree.Quadtree.ensureExtent(itemEnv,
+      this.minExtent);
+  return this.root.remove(posEnv, item);
+};
+
+
+/**
+ * Querys the quadtree.
+ *
+ * Calls appropriate function depending on arguments
+ */
+jsts.index.quadtree.Quadtree.prototype.query = function() {
+  if (arguments.length === 1) {
+    return jsts.index.quadtree.Quadtree.prototype.queryByEnvelope.apply(this,
+        arguments);
+  } else {
+    jsts.index.quadtree.Quadtree.prototype.queryWithVisitor.apply(this,
+        arguments);
+  }
+};
+
+
+/**
+ * Queries the tree and returns items which may lie in the given search
+ * envelope. Precisely, the items that are returned are all items in the tree
+ * whose envelope <b>may</b> intersect the search Envelope. Note that some
+ * items with non-intersecting envelopes may be returned as well; the client is
+ * responsible for filtering these out. In most situations there will be many
+ * items in the tree which do not intersect the search envelope and which are
+ * not returned - thus providing improved performance over a simple linear scan.
+ *
+ * @param {jsts.geom.Envelope}
+ *          searchEnv the envelope of the desired query area.
+ * @return {Array} an array of items which may intersect the search envelope.
+ */
+jsts.index.quadtree.Quadtree.prototype.queryByEnvelope = function(searchEnv) {
+  var visitor = new jsts.index.ArrayListVisitor();
+  this.query(searchEnv, visitor);
+
+  return visitor.getItems();
+};
+
+
+/**
+ * Queries the tree and visits items which may lie in the given search envelope.
+ * Precisely, the items that are visited are all items in the tree whose
+ * envelope <b>may</b> intersect the search Envelope. Note that some items with
+ * non-intersecting envelopes may be visited as well; the client is responsible
+ * for filtering these out. In most situations there will be many items in the
+ * tree which do not intersect the search envelope and which are not visited -
+ * thus providing improved performance over a simple linear scan.
+ *
+ * @param {jsts.geom.Envelope}
+ *          searchEnv the envelope of the desired query area.
+ * @param {jsts.index.Visitor}
+ *          visitor a visitor object which is passed the visited items.
+ */
+jsts.index.quadtree.Quadtree.prototype.queryWithVisitor = function(searchEnv,
+    visitor) {
+  this.root.visit(searchEnv, visitor);
+};
+
+
+/**
+ * Returns an array of all items in the quadtree.
+ *
+ * @return {Array} An array of all items in the quadtree.
+ */
+jsts.index.quadtree.Quadtree.prototype.queryAll = function() {
+  var foundItems = [];
+  foundItems = this.root.addAllItems(foundItems);
+  return foundItems;
+};
+
+
+/**
+ * Checks wheter a width and height of an envelope is above zero and sets
+ * minExtent if the widht or height is less than the current min extent
+ *
+ * @param {jsts.geom.Envelope}
+ *          itemEnv The envelope.
+ */
+jsts.index.quadtree.Quadtree.prototype.collectStats = function(itemEnv) {
+  var delX = itemEnv.getWidth();
+  if (delX < this.minExtent && delX > 0.0) {
+    this.minExtent = delX;
+  }
+
+  var delY = itemEnv.getHeight();
+  if (delY < this.minExtent && delY > 0.0) {
+    this.minExtent = delY;
+  }
+};

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

@@ -0,0 +1,105 @@
+/* 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.
+*/
+
+
+
+/**
+ * QuadRoot is the root of a single Quadtree. It is centred at the origin, and
+ * does not have a defined extent.
+ *
+ * @constructor
+ */
+jsts.index.quadtree.Root = function() {
+  jsts.index.quadtree.NodeBase.prototype.constructor.apply(this, arguments);
+
+  // the root quad is centred at the origin.
+  this.origin = new jsts.geom.Coordinate(0.0, 0.0);
+};
+
+jsts.index.quadtree.Root.prototype = new jsts.index.quadtree.NodeBase();
+
+
+/**
+ * Insert an item into the quadtree this is the root of.
+ *
+ * @param {jsts.geom.Envelope}
+ *          itemEnv the item envelope.
+ * @param {Object}
+ *          item the item to insert.
+ */
+jsts.index.quadtree.Root.prototype.insert = function(itemEnv, item) {
+  var index = this.getSubnodeIndex(itemEnv, this.origin);
+
+  // if index is -1, itemEnv must cross the X or Y axis.
+  if (index === -1) {
+    this.add(item);
+    return;
+  }
+  /**
+   * the item must be contained in one quadrant, so insert it into the tree for
+   * that quadrant (which may not yet exist)
+   */
+  var node = this.subnode[index];
+  /**
+   * If the subquad 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.getEnvelope().contains(itemEnv)) {
+    var largerNode = jsts.index.quadtree.Node.createExpanded(node, itemEnv);
+    this.subnode[index] = largerNode;
+  }
+  /**
+   * At this point we have a subquad which exists and must contain contains the
+   * env for the item. Insert the item into the tree.
+   */
+  this.insertContained(this.subnode[index], itemEnv, item);
+};
+
+
+/**
+ * insert an item which is known to be contained in the tree rooted at the given
+ * QuadNode root. Lower levels of the tree will be created if necessary to hold
+ * the item.
+ *
+ * @param {jsts.index.quadtree.Node}
+ *          tree the root-node of the tree.
+ * @param {jsts.geom.Envelope}
+ *          itemEnv the envelope.
+ * @param {Object}
+ *          item the item to insert.
+ */
+jsts.index.quadtree.Root.prototype.insertContained = function(tree, itemEnv,
+    item) {
+  /**
+   * Do NOT create a new quad for zero-area envelopes - this would lead to
+   * infinite recursion. Instead, use a heuristic of simply returning the
+   * smallest existing quad containing the query
+   */
+  var isZeroX, isZeroY, node;
+  isZeroX = jsts.index.IntervalSize.isZeroWidth(itemEnv.getMinX(),
+      itemEnv.getMaxX());
+  isZeroY = jsts.index.IntervalSize.isZeroWidth(itemEnv.getMinY(),
+      itemEnv.getMaxY());
+
+  if (isZeroX || isZeroY) {
+    node = tree.find(itemEnv);
+  } else {
+    node = tree.getNode(itemEnv);
+  }
+  node.add(item);
+};
+
+
+/**
+ * Checks if the root is a search match.
+ *
+ * @param {jsts.geom.Envelope} searchEnv the envelope.
+ * @return {Boolean} Always returns true for a root node.
+ */
+jsts.index.quadtree.Root.prototype.isSearchMatch = function(searchEnv) {
+  return true;
+};

data/vendor/assets/javascripts/jsts/index/strtree/AbstractNode.js

@@ -0,0 +1,107 @@
+/* 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 the STR tree. The children of this node are either more nodes
+ * (AbstractNodes) or real data (ItemBoundables). If this node contains real data
+ * (rather than nodes), then we say that this node is a "leaf node".
+ *
+ * @requires jsts/index/strtree/Boundable.js
+ */
+
+
+
+/**
+ * Constructs an AbstractNode at the given level in the tree
+ * @param {Integer} level 0 if this node is a leaf, 1 if a parent of a leaf, and so on; the
+ * root node will have the highest level.
+ *
+ * @extends {Boundable}
+ * @constructor
+ * @interface
+ */
+jsts.index.strtree.AbstractNode = function(level) {
+  this.level = level;
+  this.childBoundables = [];
+};
+
+jsts.index.strtree.AbstractNode.prototype = new jsts.index.strtree.Boundable();
+jsts.index.strtree.AbstractNode.constructor = jsts.index.strtree.AbstractNode;
+
+/**
+ * @type {Array}
+ * @private
+ */
+jsts.index.strtree.AbstractNode.prototype.childBoundables = null;
+
+
+/**
+ * @type {Object}
+ * @private
+ */
+jsts.index.strtree.AbstractNode.prototype.bounds = null;
+
+
+/**
+ * @type {number}
+ * @private
+ */
+jsts.index.strtree.AbstractNode.prototype.level = null;
+
+
+/**
+ * Returns either child {@link AbstractNodes}, or if this is a leaf node, real data (wrapped
+ * in {@link ItemBoundables}).
+ *
+ * @return {Array}
+ */
+jsts.index.strtree.AbstractNode.prototype.getChildBoundables = function() {
+  return this.childBoundables;
+};
+
+
+/**
+ * Returns a representation of space that encloses this Boundable,
+ * preferably not much bigger than this Boundable's boundary yet fast to
+ * test for intersection with the bounds of other Boundables. The class of
+ * object returned depends on the subclass of AbstractSTRtree.
+ *
+ * @return an Envelope (for STRtrees), an Interval (for SIRtrees), or other
+ *         object (for other subclasses of AbstractSTRtree).
+ * @see AbstractSTRtree.IntersectsOp
+ */
+jsts.index.strtree.AbstractNode.prototype.computeBounds = function() {
+  throw new jsts.error.AbstractMethodInvocationError();
+};
+
+jsts.index.strtree.AbstractNode.prototype.getBounds = function() {
+  if (this.bounds === null) {
+    this.bounds = this.computeBounds();
+  }
+  return this.bounds;
+};
+
+
+/**
+ * Returns 0 if this node is a leaf, 1 if a parent of a leaf, and so on; the
+ * root node will have the highest level
+ *
+ * @return {number}
+ */
+jsts.index.strtree.AbstractNode.prototype.getLevel = function() {
+  return this.level;
+};
+
+
+/**
+ * Adds either an AbstractNode, or if this is a leaf node, a data object
+ * (wrapped in an ItemBoundable)
+ *
+ * @param {jsts.index.strtree.Boundable} childBoundable
+ */
+jsts.index.strtree.AbstractNode.prototype.addChildBoundable = function(childBoundable) {
+  this.childBoundables.push(childBoundable);
+};

data/vendor/assets/javascripts/jsts/index/strtree/AbstractSTRtree.js

@@ -0,0 +1,594 @@
+/* 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.
+ */
+
+/**
+ * Base class for STRtree and SIRtree. STR-packed R-trees are described in:
+ * P. Rigaux, Michel Scholl and Agnes Voisard. Spatial Databases With
+ * Application To GIS. Morgan Kaufmann, San Francisco, 2002.
+ * <p>
+ * This implementation is based on Boundables rather than just AbstractNodes,
+ * because the STR algorithm operates on both nodes and
+ * data, both of which are treated here as Boundables.
+ *
+ * @see STRtree
+ * @see SIRtree
+ */
+
+
+
+/**
+ * Constructs an AbstractSTRtree with the specified maximum number of child
+ * nodes that a node may have
+ *
+ * @param {Integer}
+ *          nodeCapacity
+ *
+ * @constuctor
+ */
+jsts.index.strtree.AbstractSTRtree = function(nodeCapacity) {
+  if (nodeCapacity === undefined)
+    return;
+
+  this.itemBoundables = [];
+
+  jsts.util.Assert.isTrue(nodeCapacity > 1, 'Node capacity must be greater than 1');
+  this.nodeCapacity = nodeCapacity;
+};
+
+
+
+/**
+ * A test for intersection between two bounds, necessary because subclasses of
+ * AbstractSTRtree have different implementations of bounds.
+ *
+ * @interface
+ * @constructor
+ * @public
+ */
+jsts.index.strtree.AbstractSTRtree.IntersectsOp = function() {
+
+};
+
+
+/**
+ * For STRtrees, the bounds will be Envelopes; for SIRtrees, Intervals; for
+ * other subclasses of AbstractSTRtree, some other class.
+ *
+ * @param {Object}
+ *          aBounds the bounds of one spatial object.
+ * @param {Object}
+ *          bBounds the bounds of another spatial object.
+ * @return {boolean} whether the two bounds intersect.
+ */
+jsts.index.strtree.AbstractSTRtree.IntersectsOp.prototype.intersects = function(
+    aBounds, bBounds) {
+  throw new jsts.error.AbstractMethodInvocationError();
+};
+
+
+/**
+ * @type {jsts.index.strtree.AbstractNode}
+ * @protected
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.root = null;
+
+
+/**
+ * @type {boolean}
+ * @private
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.built = false;
+
+
+/**
+ * @type {Array}
+ * @private
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.itemBoundables = null;
+
+
+/**
+ * @type {number}
+ * @private
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.nodeCapacity = null;
+
+
+/**
+ * Creates parent nodes, grandparent nodes, and so forth up to the root node,
+ * for the data that has been inserted into the tree. Can only be called once,
+ * and thus can be called only after all of the data has been inserted into the
+ * tree.
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.build = function() {
+  jsts.util.Assert.isTrue(!this.built);
+  this.root = this.itemBoundables.length === 0 ? this.createNode(0) : this
+      .createHigherLevels(this.itemBoundables, -1);
+  this.built = true;
+};
+
+
+/**
+ * @param {number}
+ *          level
+ * @return {jsts.index.strtree.AbstractNode}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.createNode = function(level) {
+  throw new jsts.error.AbstractMethodInvocationError();
+};
+
+
+/**
+ * Sorts the childBoundables then divides them into groups of size M, where M is
+ * the node capacity.
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.createParentBoundables = function(
+    childBoundables, newLevel) {
+  jsts.util.Assert.isTrue(!(childBoundables.length === 0));
+  var parentBoundables = [];
+  parentBoundables.push(this.createNode(newLevel));
+  var sortedChildBoundables = [];
+  for (var i = 0; i < childBoundables.length; i++) {
+    sortedChildBoundables.push(childBoundables[i]);
+  }
+  sortedChildBoundables.sort(this.getComparator());
+  for (var i = 0; i < sortedChildBoundables.length; i++) {
+    var childBoundable = sortedChildBoundables[i];
+    if (this.lastNode(parentBoundables).getChildBoundables().length === this
+        .getNodeCapacity()) {
+      parentBoundables.push(this.createNode(newLevel));
+    }
+    this.lastNode(parentBoundables).addChildBoundable(childBoundable);
+  }
+  return parentBoundables;
+};
+
+
+/**
+ * @param {Array}
+ *          nodes
+ * @return {jsts.index.strtree.AbstractNode}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.lastNode = function(nodes) {
+  return nodes[nodes.length - 1];
+};
+
+
+/**
+ * @param {number}
+ *          a
+ * @param {number}
+ *          b
+ * @return {number}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.compareDoubles = function(a, b) {
+  return a > b ? 1 : a < b ? -1 : 0;
+};
+
+
+/**
+ * Creates the levels higher than the given level
+ *
+ * @param {Array}
+ *          boundablesOfALevel the level to build on.
+ * @param {number}
+ *          level the level of the Boundables, or -1 if the boundables are item
+ *          boundables (that is, below level 0).
+ * @return {jsts.index.strtree.AbstractNode} the root, which may be a ParentNode
+ *         or a LeafNode.
+ * @private
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.createHigherLevels = function(
+    boundablesOfALevel, level) {
+  jsts.util.Assert.isTrue(!(boundablesOfALevel.length === 0));
+  var parentBoundables = this.createParentBoundables(boundablesOfALevel,
+      level + 1);
+  if (parentBoundables.length === 1) {
+    return parentBoundables[0];
+  }
+  return this.createHigherLevels(parentBoundables, level + 1);
+};
+
+
+/**
+ * @return {jsts.index.strtree.AbstractNode}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.getRoot = function() {
+  if (!this.built)
+    this.build();
+  return this.root;
+};
+
+
+/**
+ * Returns the maximum number of child nodes that a node may have
+ *
+ * return {number}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.getNodeCapacity = function() {
+  return this.nodeCapacity;
+};
+
+
+/**
+ * @return {number}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.size = function() {
+  if (arguments.length === 1) {
+    return this.size2(arguments[0]);
+  }
+
+  if (!this.built) {
+    this.build();
+  }
+  if (this.itemBoundables.length === 0) {
+    return 0;
+  }
+  return this.size2(root);
+};
+
+/**
+ * @param {jsts.index.strtree.AbstractNode=}
+ *          [node].
+ * @return {number}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.size2 = function(node) {
+  var size = 0;
+  var childBoundables = node.getChildBoundables();
+  for (var i = 0; i < childBoundables.length; i++) {
+    var childBoundable = childBoundables[i];
+    if (childBoundable instanceof jsts.index.strtree.AbstractNode) {
+      size += this.size(childBoundable);
+    } else if (childBoundable instanceof jsts.index.strtree.ItemBoundable) {
+      size += 1;
+    }
+  }
+  return size;
+};
+
+
+/**
+ * @return {number}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.depth = function() {
+  if (arguments.length === 1) {
+    return this.depth2(arguments[0]);
+  }
+
+  if (!this.built) {
+    this.build();
+  }
+  if (this.itemBoundables.length === 0) {
+    return 0;
+  }
+  return this.depth2(root);
+};
+
+/**
+ * @param {jsts.index.strtree.AbstractNode}
+ *          [node].
+ * @return {number}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.depth2 = function() {
+  var maxChildDepth = 0;
+  var childBoundables = node.getChildBoundables();
+  for (var i = 0; i < childBoundables.length; i++) {
+    var childBoundable = childBoundables[i];
+    if (childBoundable instanceof jsts.index.strtree.AbstractNode) {
+      var childDepth = this.depth(childBoundable);
+      if (childDepth > maxChildDepth)
+        maxChildDepth = childDepth;
+    }
+  }
+  return maxChildDepth + 1;
+};
+
+
+/**
+ *
+ * @param {Object}
+ *          bounds
+ * @param {Object}
+ *          item
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.insert = function(bounds, item) {
+  jsts.util.Assert.isTrue(!this.built, 'Cannot insert items into an STR packed R-tree after it has been built.');
+  this.itemBoundables.push(new jsts.index.strtree.ItemBoundable(bounds, item));
+};
+
+/**
+ * Also builds the tree, if necessary.
+ *
+ * @param {Object}
+ *          searchBounds
+ * @param {jsts.index.ItemVisitor}
+ *          [visitor].
+ * @param {jsts.index.strtree.AbstractNode}
+ *          [node].
+ * @param {Array}
+ *          [matches].
+ * @return {Array}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.query = function(searchBounds) {
+  if (arguments.length > 1) {
+    this.query2.apply(this, arguments);
+  }
+
+  if (!this.built) {
+    this.build();
+  }
+  var matches = [];
+  if (this.itemBoundables.length === 0) {
+    jsts.util.Assert.isTrue(this.root.getBounds() === null);
+    return matches;
+  }
+  if (this.getIntersectsOp().intersects(this.root.getBounds(), searchBounds)) {
+    this.query3(searchBounds, this.root, matches);
+  }
+  return matches;
+};
+
+jsts.index.strtree.AbstractSTRtree.prototype.query2 = function(searchBounds,
+    visitor) {
+  if (arguments.length > 2) {
+    this.query3.apply(this, arguments);
+  }
+
+  if (!this.built) {
+    this.build();
+  }
+  if (this.itemBoundables.length === 0) {
+    jsts.util.Assert.isTrue(this.root.getBounds() === null);
+  }
+  if (this.getIntersectsOp().intersects(this.root.getBounds(), searchBounds)) {
+    this.query4(searchBounds, this.root, visitor);
+  }
+};
+
+/**
+ * @private
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.query3 = function(searchBounds,
+    node, matches) {
+  if (!(arguments[2] instanceof Array)) {
+    this.query4.apply(this, arguments);
+  }
+
+  var childBoundables = node.getChildBoundables();
+  for (var i = 0; i < childBoundables.length; i++) {
+    var childBoundable = childBoundables[i];
+    if (!this.getIntersectsOp().intersects(childBoundable.getBounds(),
+        searchBounds)) {
+      continue;
+    }
+    if (childBoundable instanceof jsts.index.strtree.AbstractNode) {
+      this.query3(searchBounds, childBoundable, matches);
+    } else if (childBoundable instanceof jsts.index.strtree.ItemBoundable) {
+      matches.push(childBoundable.getItem());
+    } else {
+      jsts.util.Assert.shouldNeverReachHere();
+    }
+  }
+};
+
+/**
+ * @private
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.query4 = function(searchBounds,
+    node, visitor) {
+  var childBoundables = node.getChildBoundables();
+  for (var i = 0; i < childBoundables.length; i++) {
+    var childBoundable = childBoundables[i];
+    if (!this.getIntersectsOp().intersects(childBoundable.getBounds(),
+        searchBounds)) {
+      continue;
+    }
+    if (childBoundable instanceof jsts.index.strtree.AbstractNode) {
+      this.query4(searchBounds, childBoundable, visitor);
+    } else if (childBoundable instanceof jsts.index.strtree.ItemBoundable) {
+      visitor.visitItem(childBoundable.getItem());
+    } else {
+      jsts.util.Assert.shouldNeverReachHere();
+    }
+  }
+};
+
+/**
+ * @return {jsts.index.strtree.AbstractSTRtree.IntersectOp}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.getIntersectsOp = function() {
+  throw new jsts.error.AbstractMethodInvocationError();
+};
+
+// TODO: port rest
+
+/**
+ * Gets a tree structure (as a nested list) corresponding to the structure of
+ * the items and nodes in this tree.
+ * <p>
+ * The returned {@link List}s contain either {@link Object} items, or Lists
+ * which correspond to subtrees of the tree Subtrees which do not contain any
+ * items are not included.
+ * <p>
+ * Builds the tree if necessary.
+ *
+ * @return {Array} a List of items and/or Lists.
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.itemsTree = function() {
+  if (arguments.length === 1) {
+    return this.itemsTree2.apply(this, arguments);
+  }
+
+  if (!this.built) {
+    this.build();
+  }
+
+  var valuesTree = this.itemsTree2(this.root);
+  if (valuesTree === null)
+    return [];
+  return valuesTree;
+};
+
+jsts.index.strtree.AbstractSTRtree.prototype.itemsTree2 = function(node) {
+  var valuesTreeForNode = [];
+  var childBoundables = node.getChildBoundables();
+  for (var i = 0; i < childBoundables.length; i++) {
+    var childBoundable = childBoundables[i];
+    if (childBoundable instanceof jsts.index.strtree.AbstractNode) {
+      var valuesTreeForChild = this.itemsTree(childBoundable);
+      // only add if not null (which indicates an item somewhere in this tree
+      if (valuesTreeForChild != null)
+        valuesTreeForNode.push(valuesTreeForChild);
+    } else if (childBoundable instanceof jsts.index.strtree.ItemBoundable) {
+      valuesTreeForNode.push(childBoundable.getItem());
+    } else {
+      jsts.util.Assert.shouldNeverReachHere();
+    }
+  }
+  if (valuesTreeForNode.length <= 0)
+    return null;
+  return valuesTreeForNode;
+};
+
+/**
+ * Removes an item from the tree. (Builds the tree, if necessary.)
+ *
+ * @param {Object}
+ *          searchBounds
+ * @param {jsts.index.strtree.AbstractNode}
+ *          [node].
+ * @param {Object]
+ *          item}
+ * @return {boolean}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.remove = function(searchBounds,
+    item) {
+  // TODO: argument switch
+
+
+  if (!this.built) {
+    this.build();
+  }
+  if (this.itemBoundables.length === 0) {
+    jsts.util.Assert.isTrue(this.root.getBounds() == null);
+  }
+  if (this.getIntersectsOp().intersects(this.root.getBounds(), searchBounds)) {
+    return this.remove2(searchBounds, this.root, item);
+  }
+  return false;
+};
+
+jsts.index.strtree.AbstractSTRtree.prototype.remove2 = function(searchBounds,
+    node, item) {
+  // first try removing item from this node
+  var found = this.removeItem(node, item);
+  if (found)
+    return true;
+
+  var childToPrune = null;
+  // next try removing item from lower nodes
+  var childBoundables = node.getChildBoundables();
+  for (var i = 0; i < childBoundables.length; i++) {
+    var childBoundable = childBoundables[i];
+    if (!this.getIntersectsOp().intersects(childBoundable.getBounds(),
+        searchBounds)) {
+      continue;
+    }
+    if (childBoundable instanceof jsts.index.strtree.AbstractNode) {
+      found = this.remove(searchBounds, childBoundable, item);
+      // if found, record child for pruning and exit
+      if (found) {
+        childToPrune = childBoundable;
+        break;
+      }
+    }
+  }
+  // prune child if possible
+  if (childToPrune != null) {
+    if (childToPrune.getChildBoundables().length === 0) {
+      childBoundables.splice(childBoundables.indexOf(childToPrune), 1);
+    }
+  }
+  return found;
+};
+
+
+
+/**
+ *
+ * @param {jsts.index.strtree.AbstractNode}
+ *          node
+ * @param {Object}
+ *          item
+ * @return {boolean}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.removeItem = function(node, item) {
+  var childToRemove = null;
+  var childBoundables = node.getChildBoundables();
+  for (var i = 0; i < childBoundables.length; i++) {
+    var childBoundable = childBoundables[i];
+    if (childBoundable instanceof jsts.index.strtree.ItemBoundable) {
+      if (childBoundable.getItem() === item)
+        childToRemove = childBoundable;
+    }
+  }
+  if (childToRemove !== null) {
+    childBoundables.splice(childBoundables.indexOf(childToRemove), 1);
+    return true;
+  }
+  return false;
+};
+
+
+jsts.index.strtree.AbstractSTRtree.prototype.boundablesAtLevel = function(level) {
+  if (arguments.length > 1) {
+    this.boundablesAtLevel2.apply(this, arguments);
+    return;
+  }
+
+  var boundables = [];
+  this.boundablesAtLevel2(level, this.root, boundables);
+  return boundables;
+};
+
+/**
+ * @param {number}
+ *          level
+ * @param {jsts.index.strtree.AbstractNode}
+ *          [top].
+ * @param {Array}
+ *          [boundables].
+ * @return {?Array}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.boundablesAtLevel2 = function(
+    level, top, boundables) {
+  jsts.util.Assert.isTrue(level > -2);
+  if (top.getLevel() === level) {
+    boundables.add(top);
+    return;
+  }
+  var childBoundables = node.getChildBoundables();
+  for (var i = 0; i < childBoundables.length; i++) {
+    var boundable = childBoundables[i];
+    if (boundable instanceof jsts.index.strtree.AbstractNode) {
+      this.boundablesAtLevel(level, boundable, boundables);
+    } else {
+      jsts.util.Assert.isTrue(boundable instanceof jsts.index.strtree.ItemBoundable);
+      if (level === -1) {
+        boundables.add(boundable);
+      }
+    }
+  }
+  return;
+};
+
+
+/**
+ * @return {Comparator}
+ */
+jsts.index.strtree.AbstractSTRtree.prototype.getComparator = function() {
+  throw new jsts.error.AbstractMethodInvocationError();
+};