jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/geomgraph/index/SimpleMCSweepLineIntersector.js

@@ -0,0 +1,29 @@
+/* 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/geomgraph/index/EdgeSetIntersector.js
+ */
+
+
+
+/**
+ * Finds all intersections in one or two sets of edges,
+ * using an x-axis sweepline algorithm in conjunction with Monotone Chains.
+ * While still O(n^2) in the worst case, this algorithm
+ * drastically improves the average-case time.
+ * The use of MonotoneChains as the items in the index
+ * seems to offer an improvement in performance over a sweep-line alone.
+ * @constructor
+ */
+jsts.geomgraph.index.SimpleMCSweepLineIntersector = function() {
+  throw new jsts.error.NotImplementedError();
+};
+
+
+jsts.geomgraph.index.SimpleMCSweepLineIntersector.prototype = new jsts.geomgraph.index.EdgeSetIntersector();
+
+// TODO: port

data/vendor/assets/javascripts/jsts/index/ArrayListVisitor.js

@@ -0,0 +1,37 @@
+/* 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 array-visitor
+ *
+ * @constructor
+ */
+jsts.index.ArrayListVisitor = function() {
+  this.items = [];
+};
+
+
+/**
+ * Visits an item
+ *
+ * @param {Object}
+ *          item the item to visit.
+ */
+jsts.index.ArrayListVisitor.prototype.visitItem = function(item) {
+  this.items.push(item);
+};
+
+
+/**
+ * Returns all visited items
+ *
+ * @return {Array} An array with all visited items.
+ */
+jsts.index.ArrayListVisitor.prototype.getItems = function() {
+  return this.items;
+};

data/vendor/assets/javascripts/jsts/index/DoubleBits.js

@@ -0,0 +1,132 @@
+/* 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.
+ */
+
+
+
+/**
+ * DoubleBits manipulates Double numbers by using bit manipulation and bit-field
+ * extraction. For some operations (such as determining the exponent) this is
+ * more accurate than using mathematical operations (which suffer from round-off
+ * error).
+ * <p>
+ * The algorithms and constants in this class apply only to IEEE-754
+ * double-precision floating point format.
+ *
+ * NOTE: Since the only numberformat in JavaScript is IEEE-754 the code in
+ * DoubleBits could not be easily ported.
+ *
+ * Instead, using algorithms found here:
+ * http://www.merlyn.demon.co.uk/js-exact.htm
+ *
+ * @constructor
+ */
+jsts.index.DoubleBits = function() {
+
+};
+
+
+/**
+ * Calculates the power of two for a number
+ *
+ * @param {Number}
+ *          exp value to pow.
+ * @return {Number} the pow'ed value.
+ */
+jsts.index.DoubleBits.powerOf2 = function(exp) {
+  // TODO: Make sure the accuracy of this is sufficient (why else would JTS have
+  // this in DoubleBits?)
+  return Math.pow(2, exp);
+};
+
+
+/**
+ * Calculates the exponent-part of the bit-pattern for a number
+ *
+ * @param {Number}
+ *          d the IEEE-754-value to calculate the exponent for.
+ * @return {Number} the exponent part of the bit-mask.
+ */
+jsts.index.DoubleBits.exponent = function(d) {
+  return jsts.index.DoubleBits.CVTFWD(64, d) - 1023;
+};
+
+
+/**
+ * Calculates the exponent of the bit-pattern for a number. Uses code from:
+ * http://www.merlyn.demon.co.uk/js-exact.htm
+ *
+ * @param {Number}
+ *          NumW 32 or 64 to denote the number of bits.
+ * @param {Number}
+ *          Qty the number to calculate the bit pattern for.
+ * @return {Number} The integer value of the exponent.
+ */
+jsts.index.DoubleBits.CVTFWD = function(NumW, Qty) {
+  var Sign, Expo, Mant, Bin, nb01 = ''; // , OutW = NumW/4
+  var Inf = {
+    32: {
+      d: 0x7F,
+      c: 0x80,
+      b: 0,
+      a: 0
+    },
+    64: {
+      d: 0x7FF0,
+      c: 0,
+      b: 0,
+      a: 0
+    }
+  };
+  var ExW = {
+    32: 8,
+    64: 11
+  }[NumW], MtW = NumW - ExW - 1;
+
+  if (!Bin) {
+    Sign = Qty < 0 || 1 / Qty < 0; // OK for +-0
+    if (!isFinite(Qty)) {
+      Bin = Inf[NumW];
+      if (Sign) {
+        Bin.d += 1 << (NumW / 4 - 1);
+      }
+      Expo = Math.pow(2, ExW) - 1;
+      Mant = 0;
+    }
+  }
+
+  if (!Bin) {
+    Expo = {
+      32: 127,
+      64: 1023
+    }[NumW];
+    Mant = Math.abs(Qty);
+    while (Mant >= 2) {
+      Expo++;
+      Mant /= 2;
+    }
+    while (Mant < 1 && Expo > 0) {
+      Expo--;
+      Mant *= 2;
+    }
+    if (Expo <= 0) {
+      Mant /= 2;
+      nb01 = 'Zero or Denormal';
+    }
+    if (NumW === 32 && Expo > 254) {
+      nb01 = 'Too big for Single';
+      Bin = {
+        d: Sign ? 0xFF : 0x7F,
+        c: 0x80,
+        b: 0,
+        a: 0
+      };
+      Expo = Math.pow(2, ExW) - 1;
+      Mant = 0;
+    }
+  }
+
+  return Expo;
+};

data/vendor/assets/javascripts/jsts/index/IntervalSize.js

@@ -0,0 +1,55 @@
+/* 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.
+*/
+
+
+
+/**
+ * Provides a test for whether an interval is so small it should be considered
+ * as zero for the purposes of inserting it into a binary tree. The reason this
+ * check is necessary is that round-off error can cause the algorithm used to
+ * subdivide an interval to fail, by computing a midpoint value which does not
+ * lie strictly between the endpoints.
+ *
+ * @constructor
+ */
+jsts.index.IntervalSize = function() {
+
+};
+
+
+/**
+ * This value is chosen to be a few powers of 2 less than the number of bits
+ * available in the double representation (i.e. 53). This should allow enough
+ * extra precision for simple computations to be correct, at least for
+ * comparison purposes.
+ */
+jsts.index.IntervalSize.MIN_BINARY_EXPONENT = -50;
+
+
+/**
+ * Computes whether the interval [min, max] is effectively zero width. I.e. the
+ * width of the interval is so much less than the location of the interval that
+ * the midpoint of the interval cannot be represented precisely.
+ *
+ * @param {Number}
+ *          min the min-value in the interval.
+ * @param {Number}
+ *          max the max-value in the interval.
+ * @return {Boolean} true if the interval should be considered zero.
+ */
+jsts.index.IntervalSize.isZeroWidth = function(min, max) {
+  var width = max - min;
+  if (width === 0.0) {
+    return true;
+  }
+
+  var maxAbs, scaledInterval, level;
+  maxAbs = Math.max(Math.abs(min), Math.abs(max));
+  scaledInterval = width / maxAbs;
+
+  level = jsts.index.DoubleBits.exponent(scaledInterval);
+  return level <= jsts.index.IntervalSize.MIN_BINARY_EXPONENT;
+};

data/vendor/assets/javascripts/jsts/index/ItemVisitor.js

@@ -0,0 +1,23 @@
+/* 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 visitor for items in an index.
+ *
+ * @interface
+ */
+jsts.index.ItemVisitor = function() {
+
+};
+
+
+/**
+ * @param {Object} item
+ * @public
+ */
+jsts.index.ItemVisitor.prototype.visitItem = function() {
+  throw new jsts.error.AbstractMethodInvocationError();
+};

data/vendor/assets/javascripts/jsts/index/SpatialIndex.js

@@ -0,0 +1,67 @@
+/* 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 basic operations supported by classes
+ * implementing spatial index algorithms.
+ * <p>
+ * A spatial index typically provides a primary filter for range rectangle queries.
+ * A secondary filter is required to test for exact intersection.
+ * The secondary filter may consist of other kinds of tests,
+ * such as testing other spatial relationships.
+ *
+ * @version 1.7
+ */
+
+
+
+/**
+ * @interface
+ */
+jsts.index.SpatialIndex = function() {
+
+};
+
+
+/**
+ * Adds a spatial item with an extent specified by the given {@link Envelope} to the index
+ *
+ * @param {jsts.geom.Envelope} itemEnv
+ * @param {Object} item
+ * @public
+ */
+jsts.index.SpatialIndex.prototype.insert = function(itemEnv, item) {
+  throw new jsts.error.AbstractMethodInvocationError();
+};
+
+
+/**
+ * Queries the index for all items whose extents intersect the given search {@link Envelope}
+ * and applies an {@link ItemVisitor} to them (if provided).
+ * Note that some kinds of indexes may also return objects which do not in fact
+ * intersect the query envelope.
+ *
+ * @param {jsts.geom.Envelope} searchEnv the envelope to query for.
+ * @param {jsts.index.ItemVisitor=} [visitor] a visitor object to apply to the items found.
+ * @return {?Array} a list of the items found by the query.
+ * @public
+ */
+jsts.index.SpatialIndex.prototype.query = function(searchEnv, visitor) {
+  throw new jsts.error.AbstractMethodInvocationError();
+};
+
+
+/**
+ * Removes a single item from the tree.
+ *
+ * @param {jsts.geom.Envelope} itemEnv the Envelope of the item to remove.
+ * @param {Object} item the item to remove.
+ * @return {boolean} <code>true</code> if the item was found.
+ * @public
+ */
+jsts.index.SpatialIndex.prototype.remove = function(itemEnv, item) {
+  throw new jsts.error.AbstractMethodInvocationError();
+};

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

@@ -0,0 +1,224 @@
+/* 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 <code>BinTree</code> (or "Binary Interval Tree") is a 1-dimensional
+ * version of a quadtree. It indexes 1-dimensional intervals (which may be the
+ * projection of 2-D objects on an axis). It supports range searching (where the
+ * range may be a single point). This structure is dynamic - new items can be
+ * added at any time, and it will support deletion of items (although this is
+ * not currently implemented).
+ * <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>
+ * The bintree structure is used to provide a primary filter for interval
+ * queries. The query() method returns a list of all objects which <i>may</i>
+ * intersect the query interval. 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 index is different to the Interval Tree of Edelsbrunner or the Segment
+ * Tree of Bentley.
+ */
+(function() {
+
+  /**
+   * @requires jsts/index/bintree/Root.js
+   * @requires jsts/index/bintree/Interval.js
+   */
+
+  var Interval = jsts.index.bintree.Interval;
+  var Root = jsts.index.bintree.Root;
+
+  /**
+   * Constructs a new Bintree
+   *
+   * @constructor
+   */
+  var Bintree = function() {
+    this.root = new Root();
+
+    /**
+     * Statistics
+     *
+     * minExtent is the minimum extent of all items inserted into the tree so
+     * far. It is used as a heuristic value to construct non-zero extents for
+     * features with zero 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 Interval for the inserted item has non-zero extents. Use
+   * the current minExtent to pad it, if necessary
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          itemInterval the interval.
+   * @param {Number}
+   *          minExtent used to pad the extent if necessary.
+   */
+  Bintree.ensureExtent = function(itemInterval, minExtent) {
+    var min, max;
+
+    min = itemInterval.getMin();
+    max = itemInterval.getMax();
+
+    // has a non-zero extent
+    if (min !== max) {
+      return itemInterval;
+    }
+
+    // pad extent
+    if (min === max) {
+      min = min - (minExtent / 2.0);
+      max = min + (minExtent / 2.0);
+    }
+
+    return new Interval(min, max);
+  };
+
+  /**
+   * Calculates the depth of the tree
+   *
+   * @return {Number} the depth.
+   */
+  Bintree.prototype.depth = function() {
+    if (this.root !== null) {
+      return this.root.depth();
+    }
+    return 0;
+  };
+
+  /**
+   * Calculates the size of the tree
+   *
+   * @return {Number} the size.
+   */
+  Bintree.prototype.size = function() {
+    if (this.root !== null) {
+      return this.root.size();
+    }
+    return 0;
+  };
+
+
+  /**
+   * Compute the total number of nodes in the tree
+   *
+   * @return {Number} the number of nodes in the tree.
+   */
+  Bintree.prototype.nodeSize = function() {
+    if (this.root !== null) {
+      return this.root.nodeSize();
+    }
+    return 0;
+  };
+
+  /**
+   * Inserts an object in the tree
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          itemInterval the interval for the item.
+   * @param {Object}
+   *          item the item to insert.
+   */
+  Bintree.prototype.insert = function(itemInterval, item) {
+    this.collectStats(itemInterval);
+    var insertInterval = Bintree.ensureExtent(itemInterval, this.minExtent);
+    this.root.insert(insertInterval, item);
+  };
+
+  /**
+   * Removes a single item from the tree.
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          itemInterval the Interval of the item to be removed.
+   * @param {Object}
+   *          item the item to remove.
+   * @return {Boolean} <code>true</code> if the item was found (and thus
+   *         removed).
+   */
+  Bintree.prototype.remove = function(itemInterval, item) {
+    var insertInterval = Bintree.ensureExtent(itemInterval, this.minExtent);
+    return this.root.remove(insertInterval, item);
+  };
+
+  Bintree.prototype.iterator = function() {
+    var foundItems = new javascript.util.ArrayList();
+    this.root.addAllItems(foundItems);
+    return foundItems.iterator();
+  };
+
+  /**
+   * Queries the tree by Interval or number
+   *
+   * @param {Number}
+   *          x OR {jsts.index.bintree.Interval} x.
+   * @return {javascript.util.ArrayList} the found items.
+   */
+  Bintree.prototype.query = function() {
+    if (arguments.length === 2) {
+      this.queryAndAdd(arguments[0], arguments[1]);
+    } else {
+      var x = arguments[0];
+      if (!x instanceof Interval) {
+        x = new Interval(x, x);
+      }
+
+      return this.queryInterval(x);
+    }
+  };
+
+  /**
+   * Queries the tree to find all candidate items which may overlap the query
+   * interval. If the query interval is <tt>null</tt>, all items in the tree
+   * are found.
+   *
+   * min and max may be the same value
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          interval the interval to query by.
+   */
+  Bintree.prototype.queryInterval = function(interval) {
+    /**
+     * the items that are matched are all items in intervals which overlap the
+     * query interval
+     */
+    var foundItems = new javascript.util.ArrayList();
+    this.query(interval, foundItems);
+    return foundItems;
+  };
+
+  /**
+   * 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.ArrayList}
+   *          resultItems the candidate items found.
+   */
+  Bintree.prototype.queryAndAdd = function(interval, foundItems) {
+    this.root.addAllItemsFromOverlapping(interval, foundItems);
+  };
+
+  Bintree.prototype.collectStats = function(interval) {
+    var del = interval.getWidth();
+    if (del < this.minExtent && del > 0.0) {
+      this.minExtent = del;
+    }
+  };
+
+  jsts.index.bintree.Bintree = Bintree;
+})();