jsts-rails 0.1.0 → 0.2.0

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

@@ -0,0 +1,160 @@
+/* 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 an (1-dimensional) closed interval on the Real number line.
+ *
+ */
+(function() {
+  /**
+   * Constructs a new Interval and initializes it if arguments is provided
+   *
+   * @constructor
+   * @param {None}
+   *          If no argument is specified, it will be initialized with 0.0, 0.0.
+   * @param {Number},
+   *          { Number } min, max It can be initialized with min <-> max.
+   * @param {jsts.index.bintree.Interval}
+   *          It can also be initialized with another interval.
+   */
+  var Interval = function() {
+    this.min = 0.0;
+    this.max = 0.0;
+
+    if (arguments.length === 1) {
+      var interval = arguments[0];
+      this.init(interval.min, interval.max);
+    }else if (arguments.length === 2) {
+      this.init(arguments[0], arguments[1]);
+    }
+  };
+
+  /**
+   * Initializes the interval
+   *
+   * @param {Number}
+   *          min
+   * @param {Number}
+   *          max
+   */
+  Interval.prototype.init = function(min, max) {
+    this.min = min;
+    this.max = max;
+    if (min > max) {
+      this.min = max;
+      this.max = min;
+    }
+  };
+
+  Interval.prototype.getMin = function() {
+    return this.min;
+  };
+
+  Interval.prototype.getMax = function() {
+    return this.max;
+  };
+
+  Interval.prototype.getWidth = function() {
+    return (this.max - this.min);
+  };
+
+  /**
+   * Expands this interval to include another interval
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          interval the interval to include.
+   */
+  Interval.prototype.expandToInclude = function(interval) {
+    if (interval.max > this.max) {
+      this.max = interval.max;
+    }
+    if (interval.min < this.min) {
+      this.min = interval.min;
+    }
+  };
+
+  /**
+   * Checks if this interval overlaps. Calls correct overlaps- function based on
+   * arguments
+   *
+   * @return {Boolean} true if the interval overlaps.
+   */
+  Interval.prototype.overlaps = function() {
+    if (arguments.length === 1) {
+      return this.overlapsInterval.apply(this, arguments);
+    }else {
+      return this.overlapsMinMax.apply(this, arguments);
+    }
+  };
+
+  /**
+   * Checks if this inteval overlaps another interval
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          interval the interval to check.
+   * @return {Boolean} true if the interval overlaps.
+   */
+  Interval.prototype.overlapsInterval = function(interval) {
+    return this.overlaps(interval.min, interval.max);
+  };
+
+  /**
+   * Checks if this inteval overlaps the specified min/max values
+   *
+   * @param {Number}
+   *          min minimum.
+   * @param {Number}
+   *          max maximum.
+   * @return {Boolean} true if the interval overlaps.
+   */
+  Interval.prototype.overlapsMinMax = function(min, max) {
+    if (this.min > max || this.max < min) {
+      return false;
+    }
+    return true;
+  };
+
+  /**
+   * Checks if this interval contains an interval, min -max pair or a point
+   *
+   * @return {Boolean} true if this interval contains the specified argument.
+   */
+  Interval.prototype.contains = function() {
+    var interval;
+    if (arguments[0] instanceof jsts.index.bintree.Interval) {
+      interval = arguments[0];
+      return this.containsMinMax(interval.min, interval.max);
+    }else if (arguments.length === 1) {
+      return this.containsPoint(arguments[0]);
+    }else {
+      return this.containsMinMax(arguments[0], arguments[1]);
+    }
+  };
+
+  /**
+   * Checks if this interval contains the min- and max-point provided
+   *
+   * @param {Number}
+   *          min the minpoint.
+   * @param {Number}
+   *          max the maxpoint.
+   */
+  Interval.prototype.containsMinMax = function(min, max) {
+    return (min >= this.min && max <= this.max);
+  };
+
+  /**
+   * Checks if this interval contains the specified point
+   *
+   * @param {Number}
+   *          p the point to check.
+   */
+  Interval.prototype.containsPoint = function(p) {
+    return (p >= this.min && p <= this.max);
+  };
+
+  jsts.index.bintree.Interval = Interval;
+})();

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

@@ -0,0 +1,110 @@
+/* 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 tree. 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
+ */
+(function() {
+
+  /**
+   * @requires jsts/index/bintree/Interval.js
+   * @requires jsts/index/DoubleBits.js
+   */
+
+  var DoubleBits = jsts.index.DoubleBits;
+  var Interval = jsts.index.bintree.Interval;
+
+  /**
+   * Constructs a new Key
+   *
+   * @constructor
+   * @param {jsts.index.bintree.Interval}
+   *          interval the interval to compute the key from.
+   */
+  var Key = function(interval) {
+    this.pt = 0.0;
+    this.level = 0;
+
+    this.computeKey(interval);
+  };
+
+  /**
+   * Computes the level for an interval
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          interval the interval.
+   * @results {Number} the calculated level
+   */
+  Key.computeLevel = function(interval) {
+    var dx = interval.getWidth(), level;
+
+    level = DoubleBits.exponent(dx) + 1;
+    return level;
+  };
+
+  /**
+   * Returns the point
+   *
+   * @return {Number} point.
+   */
+  Key.prototype.getPoint = function() {
+    return this.pt;
+  };
+
+  /**
+   * Returns the level
+   *
+   * @return {Number} level.
+   */
+  Key.prototype.getLevel = function() {
+    return this.level;
+  };
+
+  /**
+   * Returns the interval
+   *
+   * @return {jsts.index.bintree.Interval}
+   */
+  Key.prototype.getInterval = function() {
+    return this.interval;
+  };
+
+  /**
+   * Calculates the key
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          itemInterval the interval.
+   */
+  Key.prototype.computeKey = function(itemInterval) {
+    this.level = Key.computeLevel(itemInterval);
+    this.interval = new Interval();
+    this.computeInterval(this.level, itemInterval);
+    // MD - would be nice to have a non-iterative form of this algorithm
+    while (!this.interval.contains(itemInterval)) {
+      this.level += 1;
+      this.computeInterval(this.level, itemInterval);
+    }
+  };
+
+  /**
+   * Computes the interval
+   *
+   * @param {Number}
+   *          level the level.
+   * @param {jsts.index.bintree.Interval}
+   *          itemInterval an interval.
+   */
+  Key.prototype.computeInterval = function(level, itemInterval) {
+    var size = DoubleBits.powerOf2(level);
+
+    this.pt = Math.floor(itemInterval.getMin() / size) * size;
+    this.interval.init(this.pt, this.pt + size);
+  };
+
+  jsts.index.bintree.Key = Key;
+})();

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

@@ -0,0 +1,204 @@
+/* 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 Bintree}.
+ */
+(function() {
+
+  /**
+   * @requires jsts/index/bintree/NodeBase.js
+   * @requires jsts/index/bintree/Interval.js
+   * @requires jsts/index/bintree/Key.js
+   */
+
+  var NodeBase = jsts.index.bintree.NodeBase;
+  var Key = jsts.index.bintree.Key;
+  var Interval = jsts.index.bintree.Interval;
+
+  /**
+   * Constructs a new Node
+   *
+   * @constructor
+   */
+  var Node = function(interval, level) {
+    /**
+     * subnodes are numbered as follows:
+     *
+     * 0 | 1
+     */
+    this.items = new javascript.util.ArrayList();
+    this.subnode = [null, null];
+    this.interval = interval;
+    this.level = level;
+    this.centre = (interval.getMin() + interval.getMax()) / 2;
+  };
+  Node.prototype = new NodeBase();
+  Node.constructor = Node;
+
+  /**
+   * Creates a node from a specified interval
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          itemInterval the interval.
+   * @return {jsts.index.bintree.Node} the created node.
+   */
+  Node.createNode = function(itemInterval) {
+    var key, node;
+
+    key = new Key(itemInterval);
+    node = new Node(key.getInterval(), key.getLevel());
+    return node;
+  };
+
+  /**
+   * Creates an expanded node
+   *
+   * @param {jsts.index.bintree.Node}
+   *          node the node.
+   * @param {jsts.index.bintree.Interval}
+   *          addInterval the interval to add.
+   * @return {jsts.index.bintree.Node} the expanded node.
+   */
+  Node.createExpanded = function(node, addInterval) {
+    var expandInt, largerNode;
+    expandInt = new Interval(addInterval);
+    if (node !== null) {
+      expandInt.expandToInclude(node.interval);
+    }
+
+    largerNode = Node.createNode(expandInt);
+
+    if (node !== null) {
+      largerNode.insert(node);
+    }
+
+    return largerNode;
+  };
+
+  Node.prototype.getInterval = function() {
+    return this.interval;
+  };
+
+  /**
+   * Checks if the input interval matches any items in this node
+   *
+   * @return {Boolean} true if there is a search match.
+   */
+  Node.prototype.isSearchMatch = function(itemInterval) {
+    return itemInterval.overlaps(this.interval);
+  };
+
+  /**
+   * Returns the subnode containing the envelope. Creates the node if it does
+   * not already exist.
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          serachInterval the interval.
+   * @return {jsts.index.bintree.Node} the node.
+   */
+  Node.prototype.getNode = function(searchInterval) {
+    var subnodeIndex = NodeBase.getSubnodeIndex(searchInterval, this.centre), node;
+    // if index is -1 searchEnv is not contained in a subnode
+    if (subnodeIndex != -1) {
+      // create the node if it does not exist
+      node = this.getSubnode(subnodeIndex);
+      // recursively search the found/created node
+      return node.getNode(searchInterval);
+    } else {
+      return this;
+    }
+  };
+
+  /**
+   * Returns the smallest <i>existing</i> node containing the envelope.
+   *
+   * @param {jsts.index.bintree.Interval}
+   *          searchInterval the interval.
+   * @return {jsts.index.bintree.Node} the smallest node contained.
+   */
+  Node.prototype.find = function(searchInterval) {
+    var subnodeIndex = NodeBase.getSubnodeIndex(searchInterval, this.centre), node;
+    if (subnodeIndex === -1) {
+      return this;
+    }
+
+    if (this.subnode[subnodeIndex] !== null) {
+      // query lies in subnode, so search it
+      node = this.subnode[subnodeIndex];
+      return node.find(searchInterval);
+    }
+    // no existing subnode, so return this one anyway
+    return this;
+  };
+
+  /**
+   * Inserts a node as a child node (at some level) in this node
+   *
+   * @param {jsts.index.bintree.Node}
+   *          node the node to insert.
+   */
+  Node.prototype.insert = function(node) {
+    //Assert.isTrue(interval == null || interval.contains(node.interval));
+
+    var index = NodeBase.getSubnodeIndex(node.interval, this.centre), childNode;
+    if (node.level === this.level - 1) {
+      this.subnode[index] = node;
+    } else {
+      // the node is not a direct child, so make a new child node to contain it
+      // and recursively insert the node
+      childNode = this.createSubnode(index);
+      childNode.insert(node);
+      this.subnode[index] = childNode;
+    }
+  };
+
+  /**
+   * get the subnode for the index. If it doesn't exist, create it
+   *
+   * @param {Number}
+   *          index
+   * @return {jsts.index.bintree.Node} the found or created node.
+   */
+  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 to create the subnode at.
+   * @return {jsts.index.bintree.Node} the created node.
+   */
+  Node.prototype.createSubnode = function(index) {
+    // create a new subnode in the appropriate interval
+
+    var min, max, subInt, node;
+
+    min = 0.0;
+    max = 0.0;
+
+    switch (index) {
+    case 0:
+      min = this.interval.getMin();
+      max = this.centre;
+      break;
+    case 1:
+      min = this.centre;
+      max = this.interval.getMax();
+      break;
+    }
+    subInt = new Interval(min, max);
+    node = new Node(subInt, this.level - 1);
+    return node;
+  };
+
+  jsts.index.bintree.Node = Node;
+})();