jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/noding/IntersectionAdder.js

@@ -0,0 +1,198 @@
+/* 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/noding/SegmentIntersector.js
+ */
+
+/**
+ * Computes the intersections between two line segments in {@link SegmentString}s
+ * and adds them to each string. The {@link SegmentIntersector} is passed to a
+ * {@link Noder}. The {@link addIntersections} method is called whenever the
+ * {@link Noder} detects that two SegmentStrings <i>might</i> intersect. This
+ * class is an example of the <i>Strategy</i> pattern.
+ *
+ * @constructor
+ */
+jsts.noding.IntersectionAdder = function(li) {
+  this.li = li;
+};
+
+jsts.noding.IntersectionAdder.prototype = new jsts.noding.SegmentIntersector();
+jsts.noding.IntersectionAdder.constructor = jsts.noding.IntersectionAdder;
+
+
+jsts.noding.IntersectionAdder.isAdjacentSegments = function(i1, i2) {
+  return Math.abs(i1 - i2) === 1;
+};
+
+/**
+ * These variables keep track of what types of intersections were found during
+ * ALL edges that have been intersected.
+ */
+/**
+ * @type {boolean}
+ * @private
+ */
+jsts.noding.IntersectionAdder.prototype._hasIntersection = false;
+/**
+ * @type {boolean}
+ * @private
+ */
+jsts.noding.IntersectionAdder.prototype.hasProper = false;
+/**
+ * @type {boolean}
+ * @private
+ */
+jsts.noding.IntersectionAdder.prototype.hasProperInterior = false;
+/**
+ * @type {boolean}
+ * @private
+ */
+jsts.noding.IntersectionAdder.prototype.hasInterior = false;
+
+// the proper intersection point found
+
+/**
+ * @type {Coordinate}
+ * @private
+ */
+jsts.noding.IntersectionAdder.prototype.properIntersectionPoint = null;
+
+/**
+ * @type {LineIntersector}
+ * @private
+ */
+jsts.noding.IntersectionAdder.prototype.li = null;
+/**
+ * @type {boolean}
+ * @private
+ */
+jsts.noding.IntersectionAdder.prototype.isSelfIntersection = null;
+
+jsts.noding.IntersectionAdder.prototype.numIntersections = 0;
+jsts.noding.IntersectionAdder.prototype.numInteriorIntersections = 0;
+jsts.noding.IntersectionAdder.prototype.numProperIntersections = 0;
+
+// testing only
+jsts.noding.IntersectionAdder.prototype.numTests = 0;
+
+
+jsts.noding.IntersectionAdder.prototype.getLineIntersector = function() {
+  return this.li;
+};
+
+/**
+ * @return the proper intersection point, or <code>null</code> if none was
+ *         found.
+ */
+jsts.noding.IntersectionAdder.prototype.getProperIntersectionPoint = function() {
+  return this.properIntersectionPoint;
+};
+
+jsts.noding.IntersectionAdder.prototype.hasIntersection = function() {
+  return this._hasIntersection;
+};
+/**
+ * A proper intersection is an intersection which is interior to at least two
+ * line segments. Note that a proper intersection is not necessarily in the
+ * interior of the entire Geometry, since another edge may have an endpoint
+ * equal to the intersection, which according to SFS semantics can result in the
+ * point being on the Boundary of the Geometry.
+ */
+jsts.noding.IntersectionAdder.prototype.hasProperIntersection = function() {
+  return this.hasProper;
+};
+/**
+ * A proper interior intersection is a proper intersection which is <b>not</b>
+ * contained in the set of boundary nodes set for this SegmentIntersector.
+ */
+jsts.noding.IntersectionAdder.prototype.hasProperInteriorIntersection = function() {
+  return this.hasProperInterior;
+};
+/**
+ * An interior intersection is an intersection which is in the interior of some
+ * segment.
+ */
+jsts.noding.IntersectionAdder.prototype.hasInteriorIntersection = function() {
+  return this.hasInterior;
+};
+
+/**
+ * A trivial intersection is an apparent self-intersection which in fact is
+ * simply the point shared by adjacent line segments. Note that closed edges
+ * require a special check for the point shared by the beginning and end
+ * segments.
+ *
+ * @private
+ */
+jsts.noding.IntersectionAdder.prototype.isTrivialIntersection = function(e0,
+    segIndex0, e1, segIndex1) {
+  if (e0 == e1) {
+    if (this.li.getIntersectionNum() == 1) {
+      if (jsts.noding.IntersectionAdder
+          .isAdjacentSegments(segIndex0, segIndex1))
+        return true;
+      if (e0.isClosed()) {
+        var maxSegIndex = e0.size() - 1;
+        if ((segIndex0 === 0 && segIndex1 === maxSegIndex) ||
+            (segIndex1 === 0 && segIndex0 === maxSegIndex)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+};
+
+/**
+ * This method is called by clients of the {@link SegmentIntersector} class to
+ * process intersections for two segments of the {@link SegmentString}s being
+ * intersected. Note that some clients (such as {@link MonotoneChain}s) may
+ * optimize away this call for segment pairs which they have determined do not
+ * intersect (e.g. by an disjoint envelope test).
+ */
+jsts.noding.IntersectionAdder.prototype.processIntersections = function(e0,
+    segIndex0, e1, segIndex1) {
+  if (e0 === e1 && segIndex0 === segIndex1)
+    return;
+  this.numTests++;
+  var p00 = e0.getCoordinates()[segIndex0];
+  var p01 = e0.getCoordinates()[segIndex0 + 1];
+  var p10 = e1.getCoordinates()[segIndex1];
+  var p11 = e1.getCoordinates()[segIndex1 + 1];
+
+  this.li.computeIntersection(p00, p01, p10, p11);
+  if (this.li.hasIntersection()) {
+    this.numIntersections++;
+    if (this.li.isInteriorIntersection()) {
+      this.numInteriorIntersections++;
+      this.hasInterior = true;
+    }
+    // if the segments are adjacent they have at least one trivial intersection,
+    // the shared endpoint. Don't bother adding it if it is the
+    // only intersection.
+    if (!this.isTrivialIntersection(e0, segIndex0, e1, segIndex1)) {
+      this._hasIntersection = true;
+      e0.addIntersections(this.li, segIndex0, 0);
+      e1.addIntersections(this.li, segIndex1, 1);
+      if (this.li.isProper()) {
+        this.numProperIntersections++;
+        this.hasProper = true;
+        this.hasProperInterior = true;
+      }
+    }
+  }
+};
+
+/**
+ * Always process all intersections
+ *
+ * @return false always.
+ */
+jsts.noding.IntersectionAdder.prototype.isDone = function() {
+  return false;
+};

data/vendor/assets/javascripts/jsts/noding/IntersectionFinderAdder.js

@@ -0,0 +1,79 @@
+/* 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.
+ */
+
+/**
+ * Port source:
+ * /jts/jts/java/src/com/vividsolutions/jts/noding/IntersectionFinderAdder.java
+ * Revision: 108
+ */
+
+/**
+ * Finds proper and interior intersections in a set of SegmentStrings,
+ * and adds them as nodes.
+ */
+
+/**
+ * Creates an intersection finder which finds all proper intersections
+ *
+ * @param li
+ *          the LineIntersector to use.
+ */
+jsts.noding.IntersectionFinderAdder = function(li) {
+  this.li = li;
+  this.interiorIntersections = new javascript.util.ArrayList();
+};
+
+jsts.noding.IntersectionFinderAdder.prototype = new jsts.noding.SegmentIntersector();
+jsts.noding.IntersectionFinderAdder.constructor = jsts.noding.IntersectionFinderAdder;
+
+
+jsts.noding.IntersectionFinderAdder.prototype.li = null;
+jsts.noding.IntersectionFinderAdder.prototype.interiorIntersections = null;
+
+
+jsts.noding.IntersectionFinderAdder.prototype.getInteriorIntersections = function() {
+  return this.interiorIntersections;
+};
+
+/**
+ * This method is called by clients of the {@link SegmentIntersector} class to
+ * process intersections for two segments of the {@link SegmentString}s being
+ * intersected. Note that some clients (such as {@link MonotoneChain}s) may
+ * optimize away this call for segment pairs which they have determined do not
+ * intersect (e.g. by an disjoint envelope test).
+ */
+jsts.noding.IntersectionFinderAdder.prototype.processIntersections = function(
+    e0, segIndex0, e1, segIndex1) {
+  // don't bother intersecting a segment with itself
+  if (e0 === e1 && segIndex0 === segIndex1)
+    return;
+
+  var p00 = e0.getCoordinates()[segIndex0];
+  var p01 = e0.getCoordinates()[segIndex0 + 1];
+  var p10 = e1.getCoordinates()[segIndex1];
+  var p11 = e1.getCoordinates()[segIndex1 + 1];
+
+  this.li.computeIntersection(p00, p01, p10, p11);
+
+  if (this.li.hasIntersection()) {
+    if (this.li.isInteriorIntersection()) {
+      for (var intIndex = 0; intIndex < this.li.getIntersectionNum(); intIndex++) {
+        this.interiorIntersections.add(this.li.getIntersection(intIndex));
+      }
+      e0.addIntersections(this.li, segIndex0, 0);
+      e1.addIntersections(this.li, segIndex1, 1);
+    }
+  }
+};
+
+/**
+ * Always process all intersections
+ *
+ * @return false always.
+ */
+jsts.noding.IntersectionFinderAdder.prototype.isDone = function() {
+  return false;
+};

data/vendor/assets/javascripts/jsts/noding/MCIndexNoder.js

@@ -0,0 +1,147 @@
+/* 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.
+ */
+
+(function() {
+
+  /**
+   * @requires jsts/noding/SinglePassNoder.js
+   * @requires jsts/index/strtree/STRtree.js
+   * @requires jsts/noding/NodedSegmentString.js
+   * @requires jsts/index/chain/MonotoneChainBuilder.js
+   * @requires jsts/index/chain/MonotoneChainOverlapAction.js
+   */
+
+  var MonotoneChainOverlapAction = jsts.index.chain.MonotoneChainOverlapAction;
+  var SinglePassNoder = jsts.noding.SinglePassNoder;
+  var STRtree = jsts.index.strtree.STRtree;
+  var NodedSegmentString = jsts.noding.NodedSegmentString;
+  var MonotoneChainBuilder = jsts.index.chain.MonotoneChainBuilder;
+
+  /**
+   * @constructor
+   * @private
+   */
+  var SegmentOverlapAction = function(si) {
+    this.si = si;
+
+  };
+  SegmentOverlapAction.prototype = new MonotoneChainOverlapAction();
+  SegmentOverlapAction.constructor = SegmentOverlapAction;
+
+  /**
+   * @type {SegmentIntersector}
+   * @private
+   */
+  SegmentOverlapAction.prototype.si = null;
+
+  SegmentOverlapAction.prototype.overlap = function(mc1, start1, mc2, start2) {
+    var ss1 = mc1.getContext();
+    var ss2 = mc2.getContext();
+    this.si.processIntersections(ss1, start1, ss2, start2);
+  };
+
+  /**
+   * @constructor
+   */
+  jsts.noding.MCIndexNoder = function() {
+    this.monoChains = [];
+    this.index = new STRtree();
+  };
+
+  jsts.noding.MCIndexNoder.prototype = new SinglePassNoder();
+  jsts.noding.MCIndexNoder.constructor = jsts.noding.MCIndexNoder;
+
+  /**
+   * @type {Array}
+   * @private
+   */
+  jsts.noding.MCIndexNoder.prototype.monoChains = null;
+  /**
+   * @type {SpatialIndex}
+   * @private
+   */
+  jsts.noding.MCIndexNoder.prototype.index = null;
+  /**
+   * @type {number}
+   * @private
+   */
+  jsts.noding.MCIndexNoder.prototype.idCounter = 0;
+
+  /**
+   * @type {Array}
+   * @private
+   */
+  jsts.noding.MCIndexNoder.prototype.nodedSegStrings = null;
+  /**
+   * statistics
+   *
+   * @type {number}
+   * @private
+   */
+  jsts.noding.MCIndexNoder.prototype.nOverlaps = 0;
+
+
+  jsts.noding.MCIndexNoder.prototype.getMonotoneChains = function() {
+    return this.monoChains;
+  };
+
+  jsts.noding.MCIndexNoder.prototype.getIndex = function() {
+    return this.index;
+  };
+
+  jsts.noding.MCIndexNoder.prototype.getNodedSubstrings = function() {
+    return NodedSegmentString.getNodedSubstrings(this.nodedSegStrings);
+  };
+
+  jsts.noding.MCIndexNoder.prototype.computeNodes = function(inputSegStrings) {
+    this.nodedSegStrings = inputSegStrings;
+    for (var i = inputSegStrings.iterator(); i.hasNext(); ) {
+      this.add(i.next());
+    }
+    this.intersectChains();
+  };
+
+  /**
+   * @private
+   */
+  jsts.noding.MCIndexNoder.prototype.intersectChains = function() {
+    var overlapAction = new SegmentOverlapAction(this.segInt);
+
+    for (var i = 0; i < this.monoChains.length; i++) {
+      var queryChain = this.monoChains[i];
+      var overlapChains = this.index.query(queryChain.getEnvelope());
+      for (var j = 0; j < overlapChains.length; j++) {
+        var testChain = overlapChains[j];
+        /**
+         * following test makes sure we only compare each pair of chains once
+         * and that we don't compare a chain to itself
+         */
+        if (testChain.getId() > queryChain.getId()) {
+          queryChain.computeOverlaps(testChain, overlapAction);
+          this.nOverlaps++;
+        }
+        // short-circuit if possible
+        if (this.segInt.isDone())
+          return;
+      }
+    }
+  };
+
+  /**
+   * @private
+   */
+  jsts.noding.MCIndexNoder.prototype.add = function(segStr) {
+    var segChains = MonotoneChainBuilder.getChains(segStr.getCoordinates(),
+        segStr);
+    for (var i = 0; i < segChains.length; i++) {
+      var mc = segChains[i];
+      mc.setId(this.idCounter++);
+      this.index.insert(mc.getEnvelope(), mc);
+      this.monoChains.push(mc);
+    }
+  };
+
+})();

data/vendor/assets/javascripts/jsts/noding/NodableSegmentString.js

@@ -0,0 +1,35 @@
+/* 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/noding/SegmentString.js
+ */
+
+
+
+/**
+ * An interface for classes which support adding nodes to a segment string.
+ *
+ * @interface
+ */
+jsts.noding.NodableSegmentString = function() {
+
+};
+
+
+jsts.noding.NodableSegmentString.prototype = new jsts.noding.SegmentString();
+
+
+/**
+ * Adds an intersection node for a given point and segment to this segment
+ * string.
+ *
+ * @param {Coordinate}
+ *          intPt the location of the intersection.
+ * @param {number}
+ *          segmentIndex the index of the segment containing the intersection.
+ */
+jsts.noding.NodableSegmentString.prototype.addIntersection = jsts.abstractFunc;