jsts-rails 0.1.0 → 0.2.0

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

@@ -0,0 +1,47 @@
+/* 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.
+ */
+
+
+
+/**
+ * @constructor
+ */
+jsts.geomgraph.index.EdgeSetIntersector = function() {
+
+};
+
+
+/**
+ * Computes all self-intersections between edges in a set of edges, allowing
+ * client to choose whether self-intersections are computed.
+ *
+ * @param {javascript.util.List}
+ *          edges a list of edges to test for intersections.
+ * @param {SegmentIntersector}
+ *          si the SegmentIntersector to use.
+ * @param {boolean}
+ *          testAllSegments true if self-intersections are to be tested as well.
+ */
+jsts.geomgraph.index.EdgeSetIntersector.prototype.computeIntersections = function(
+    edges, si, testAllSegments) {
+  throw new jsts.error.AbstractMethodInvocationError();
+};
+
+
+/**
+ * Computes all mutual intersections between two sets of edges.
+ *
+ * @param {javascript.util.List}
+ *          edges0 a list of edges to test for intersections.
+ * @param {javascript.util.List}
+ *          edges1 a list of edges to test for intersections.
+ * @param {SegmentIntersector}
+ *          si the SegmentIntersector to use.
+ */
+jsts.geomgraph.index.EdgeSetIntersector.prototype.computeIntersections2 = function(
+    edges0, edges1, si) {
+  throw new jsts.error.AbstractMethodInvocationError();
+};

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

@@ -0,0 +1,298 @@
+/* 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() {
+
+  var ArrayList = javascript.util.ArrayList;
+
+  /**
+   * Computes the intersection of line segments, and adds the intersection to
+   * the edges containing the segments.
+   *
+   * @param {LineIntersector}
+   *          li
+   * @param {boolean}
+   *          includeProper
+   * @param {boolean}
+   *          recordIsolated
+   * @constructor
+   */
+  jsts.geomgraph.index.SegmentIntersector = function(li, includeProper, recordIsolated) {
+    this.li = li;
+    this.includeProper = includeProper;
+    this.recordIsolated = recordIsolated;
+  };
+
+
+  /**
+   * @param {number}
+   *          i1
+   * @param {number}
+   *          i2
+   * @return {boolean}
+   */
+  jsts.geomgraph.index.SegmentIntersector.isAdjacentSegments = function(i1, i2) {
+    return Math.abs(i1 - i2) === 1;
+  };
+
+
+  /**
+   * @type {boolean}
+   * @private
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype._hasIntersection = false;
+
+
+  /**
+   * @type {boolean}
+   * @private
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.hasProper = false;
+
+
+  /**
+   * @type {boolean}
+   * @private
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.hasProperInterior = false;
+
+
+  /**
+   * the proper intersection point found
+   *
+   * @type {Coordinate}
+   * @private
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.properIntersectionPoint = null;
+
+
+  /**
+   * @type {LineIntersector}
+   * @private
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.li = null;
+
+
+  /**
+   * @type {boolean}
+   * @private
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.includeProper = null;
+
+
+  /**
+   * @type {boolean}
+   * @private
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.recordIsolated = null;
+
+
+  /**
+   * @type {boolean}
+   * @private
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.isSelfIntersection = null;
+
+
+  /**
+   * @type {number}
+   * @private
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.numIntersections = 0;
+
+
+  /**
+   * testing only
+   *
+   * @type {number}
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.numTests = 0;
+
+
+  /**
+   * @type {Array.<javascript.util.Collection>}
+   * @private
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.bdyNodes = null;
+
+
+  /**
+   * @param {javascript.util.Collection}
+   *          bdyNodes0
+   * @param {javascript.util.Collection}
+   *          bdyNodes1
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.setBoundaryNodes = function(bdyNodes0, bdyNodes1) {
+    this.bdyNodes = [];
+    this.bdyNodes[0] = bdyNodes0;
+    this.bdyNodes[1] = bdyNodes1;
+  };
+
+
+  /**
+   * @return {Coordinate} the proper intersection point, or <code>null</code>
+   *         if none was found.
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.getProperIntersectionPoint = function() {
+    return this.properIntersectionPoint;
+  };
+
+
+  /**
+   * @return {boolean}
+   */
+  jsts.geomgraph.index.SegmentIntersector.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.
+   *
+   * @return {boolean}
+   */
+  jsts.geomgraph.index.SegmentIntersector.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 jsts.geomgraph.index.SegmentIntersector.
+   *
+   * @return {boolean}
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.hasProperInteriorIntersection = function() {
+    return this.hasProperInterior;
+  };
+
+
+  /**
+   * 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.
+   *
+   * @param {Edge}
+   *          e0
+   * @param {int}
+   *          segIndex0
+   * @param {Edge}
+   *          e1
+   * @param {int}
+   *          segIndex1
+   * @return {boolean}
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.isTrivialIntersection = function(e0, segIndex0,
+      e1, segIndex1) {
+    if (e0 === e1) {
+      if (this.li.getIntersectionNum() === 1) {
+        if (jsts.geomgraph.index.SegmentIntersector.isAdjacentSegments(segIndex0, segIndex1))
+          return true;
+        if (e0.isClosed()) {
+          var maxSegIndex = e0.getNumPoints() - 1;
+          if ((segIndex0 === 0 && segIndex1 === maxSegIndex) ||
+              (segIndex1 === 0 && segIndex0 === maxSegIndex)) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  };
+
+
+  /**
+   * This method is called by clients of the EdgeIntersector class to test for
+   * and add intersections for two segments of the edges being intersected. Note
+   * that clients (such as MonotoneChainEdges) may choose not to intersect
+   * certain pairs of segments for efficiency reasons.
+   *
+   * @param {Edge}
+   *          e0
+   * @param {int}
+   *          segIndex0
+   * @param {Edge}
+   *          e1
+   * @param {int}
+   *          segIndex1
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.addIntersections = 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);
+    /**
+     * Always record any non-proper intersections. If includeProper is true,
+     * record any proper intersections as well.
+     */
+    if (this.li.hasIntersection()) {
+      if (this.recordIsolated) {
+        e0.setIsolated(false);
+        e1.setIsolated(false);
+      }
+      this.numIntersections++;
+      // 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;
+        if (this.includeProper || !this.li.isProper()) {
+          e0.addIntersections(this.li, segIndex0, 0);
+          e1.addIntersections(this.li, segIndex1, 1);
+        }
+        if (this.li.isProper()) {
+          this.properIntersectionPoint = this.li.getIntersection(0).clone();
+          this.hasProper = true;
+          if (!this.isBoundaryPoint(this.li, this.bdyNodes))
+            this.hasProperInterior = true;
+        }
+      }
+    }
+  };
+
+
+  /**
+   * @param {LineIntersector}
+   *          li
+   * @param {Array.<javascript.util.Collection>|javascript.util.Collection}
+   *          bdyNodes
+   * @return {boolean}
+   * @private
+   */
+  jsts.geomgraph.index.SegmentIntersector.prototype.isBoundaryPoint = function(li, bdyNodes) {
+    if (bdyNodes === null)
+      return false;
+
+    if (bdyNodes instanceof Array) {
+      if (this.isBoundaryPoint(li, bdyNodes[0]))
+        return true;
+      if (this.isBoundaryPoint(li, bdyNodes[1]))
+        return true;
+      return false;
+    } else {
+      for (var i = bdyNodes.iterator(); i.hasNext();) {
+        var node = i.next();
+        var pt = node.getCoordinate();
+        if (li.isIntersection(pt))
+          return true;
+      }
+      return false;
+    }
+  };
+
+})();

data/vendor/assets/javascripts/jsts/geomgraph/index/SimpleEdgeSetIntersector.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.
+ */
+
+/**
+ * @requires jsts/geomgraph/index/EdgeSetIntersector.js
+ */
+
+
+
+/**
+ * Finds all intersections in one or two sets of edges, using the
+ * straightforward method of comparing all segments. This algorithm is too slow
+ * for production use, but is useful for testing purposes.
+ *
+ * @constructor
+ */
+jsts.geomgraph.index.SimpleEdgeSetIntersector = function() {
+
+};
+
+jsts.geomgraph.index.SimpleEdgeSetIntersector.prototype = new jsts.geomgraph.index.EdgeSetIntersector();
+
+
+/**
+ * statistics information
+ *
+ * @type {int}
+ */
+jsts.geomgraph.index.SimpleEdgeSetIntersector.prototype.nOverlaps = 0;
+
+
+/**
+ * @param {javascript.util.List}
+ *          edges
+ * @param {SegmentIntersector}
+ *          si
+ * @param {boolean}
+ *          testAllSegments
+ */
+jsts.geomgraph.index.SimpleEdgeSetIntersector.prototype.computeIntersections = function(
+    edges, si, testAllSegments) {
+
+  if (si instanceof javascript.util.List) {
+    this.computeIntersections2.apply(this, arguments);
+    return;
+  }
+
+  this.nOverlaps = 0;
+
+  for (var i0 = edges.iterator(); i0.hasNext(); ) {
+    var edge0 = i0.next();
+    for (var i1 = edges.iterator(); i1.hasNext(); ) {
+      var edge1 = i1.next();
+      if (testAllSegments || edge0 != edge1)
+        this.computeIntersects(edge0, edge1, si);
+    }
+  }
+};
+
+
+/**
+ * @param {javascript.util.List}
+ *          edges0
+ * @param {javascript.util.List}
+ *          edges1
+ * @param {SegmentIntersector}
+ *          si
+ */
+jsts.geomgraph.index.SimpleEdgeSetIntersector.prototype.computeIntersections2 = function(
+    edges0, edges1, si) {
+  this.nOverlaps = 0;
+
+  for (var i0 = edges0.iterator(); i0.hasNext(); ) {
+    var edge0 = i0.next();
+    for (var i1 = edges1.iterator(); i1.hasNext(); ) {
+      var edge1 = i1.next();
+      this.computeIntersects(edge0, edge1, si);
+    }
+  }
+};
+
+
+/**
+ * Performs a brute-force comparison of every segment in each Edge. This has n^2
+ * performance, and is about 100 times slower than using monotone chains.
+ *
+ * @param {Edge}
+ *          e0
+ * @param {Edge}
+ *          e1
+ * @param {SegmentIntersector}
+ *          si
+ */
+jsts.geomgraph.index.SimpleEdgeSetIntersector.prototype.computeIntersects = function(
+    e0, e1, si) {
+  var pts0 = e0.getCoordinates();
+  var pts1 = e1.getCoordinates();
+  var i0, i1;
+  for (i0 = 0; i0 < pts0.length - 1; i0++) {
+    for (i1 = 0; i1 < pts1.length - 1; i1++) {
+      si.addIntersections(e0, i0, e1, i1);
+    }
+  }
+};