jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/operation/overlay/snap/LineStringSnapper.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.
+ */
+
+
+/**
+ * Snaps the vertices and segments of a {@link LineString} to a set of target
+ * snap vertices. A snap distance tolerance is used to control where snapping is
+ * performed.
+ * <p>
+ * The implementation handles empty geometry and empty snap vertex sets.
+ *
+ */
+
+(function() {
+  /**
+   * Constructs a new LineStringSnapper based on provided arguments
+   *
+   * @constructor
+   */
+  var LineStringSnapper = function() {
+    this.snapTolerance = 0.0;
+    this.seg = new jsts.geom.LineSegment();
+    this.allowSnappingToSourceVertices = false;
+    this.isClosed = false;
+    this.srcPts = [];
+
+    if (arguments[0] instanceof jsts.geom.LineString) {
+      this.initFromLine.apply(this, arguments);
+    } else {
+      this.initFromPoints.apply(this, arguments);
+    }
+  };
+
+  /**
+   * Creates a new snapper using the points in the given {@link LineString} as
+   * source snap points.
+   *
+   * @param {jsts.geom.LineString}
+   *          srcLine a LineString to snap (may be empty).
+   * @param {Number}
+   *          snapTolerance the snap tolerance to use.
+   */
+  LineStringSnapper.prototype.initFromLine = function(srcLine, snapTolerance) {
+    this.initFromPoints(srcLine.getCoordinates(), snapTolerance);
+  };
+
+  /**
+   * Creates a new snapper using the given points as source points to be
+   * snapped.
+   *
+   * @param {Array{jsts.geom.Coordinate}}
+   *          srcPts the points to snap
+   * @param {Number}
+   *          snapTolerance the snap tolerance to use.
+   */
+  LineStringSnapper.prototype.initFromPoints = function(srcPts, snapTolerance) {
+    this.srcPts = srcPts;
+    this.isClosed = this.calcIsClosed(srcPts);
+    this.snapTolerance = snapTolerance;
+  };
+
+  LineStringSnapper.prototype.setAllowSnappingToSourceVertices = function(
+      allowSnappingToSourceVertices) {
+    this.allowSnappingToSourceVertices = allowSnappingToSourceVertices;
+  };
+
+  LineStringSnapper.prototype.calcIsClosed = function(pts) {
+    if (pts.length <= 1) {
+      return false;
+    }
+
+    return pts[0].equals(pts[pts.length - 1]);
+  };
+
+  /**
+   * Snaps the vertices and segments of the source LineString to the given set
+   * of snap vertices.
+   *
+   * @param {Array{Coordinate}}
+   *          snapPts the vertices to snap to
+   * @return {Array{Coordinate}} a list of the snapped points
+   */
+  LineStringSnapper.prototype.snapTo = function(snapPts) {
+    var coordList = new jsts.geom.CoordinateList(this.srcPts);
+    this.snapVertices(coordList, snapPts);
+    this.snapSegments(coordList, snapPts);
+
+    return coordList.toCoordinateArray();
+  };
+
+  /**
+   * Snap source vertices to vertices in the target.
+   *
+   * @param {jsts.geom.CoordinateList}
+   *          srcCoords the points to snap.
+   * @param {Array{Coordinate}}
+   *          snapPts the points to snap to
+   */
+  LineStringSnapper.prototype.snapVertices = function(srcCoords, snapPts) {
+    // try snapping vertices
+    // if src is a ring then don't snap final vertex
+    var end = this.isClosed ? srcCoords.size() - 1 : srcCoords.size(), i = 0, srcPt, snapVert;
+    for (i; i < end; i++) {
+      srcPt = srcCoords.get(i);
+      snapVert = this.findSnapForVertex(srcPt, snapPts);
+      if (snapVert !== null) {
+        // update src with snap pt
+        srcCoords.set(i, new jsts.geom.Coordinate(snapVert));
+        // keep final closing point in synch (rings only)
+        if (i === 0 && this.isClosed)
+          srcCoords.set(srcCoords.size() - 1, new jsts.geom.Coordinate(snapVert));
+      }
+    }
+  };
+
+  LineStringSnapper.prototype.findSnapForVertex = function(pt, snapPts) {
+    var i = 0, il = snapPts.length;
+    for (i = 0; i < il; i++) {
+      // if point is already equal to a src pt, don't snap
+      if (pt.equals(snapPts[i])) {
+        return null;
+      }
+
+      if (pt.distance(snapPts[i]) < this.snapTolerance) {
+        return snapPts[i];
+      }
+    }
+    return null;
+  };
+
+  /**
+   * Snap segments of the source to nearby snap vertices. Source segments are
+   * "cracked" at a snap vertex. A single input segment may be snapped several
+   * times to different snap vertices.
+   * <p>
+   * For each distinct snap vertex, at most one source segment is snapped to.
+   * This prevents "cracking" multiple segments at the same point, which would
+   * likely cause topology collapse when being used on polygonal linework.
+   *
+   * @param {jsts.geom.CoordinateList}
+   *          srcCoords the coordinates of the source linestring to be snapped.
+   * @param {Array{jsts.geom.Coordinate}}
+   *          snapPts the target snap vertices
+   */
+  LineStringSnapper.prototype.snapSegments = function(srcCoords, snapPts) {
+    // guard against empty input
+    if (snapPts.length === 0) {
+      return;
+    }
+
+    var distinctPtCount = snapPts.length, i, snapPt, index;
+
+    // check for duplicate snap pts when they are sourced from a linear ring.
+    // TODO: Need to do this better - need to check *all* snap points for dups
+    // (using a Set?)
+    if (snapPts.length>1 && snapPts[0].equals2D(snapPts[snapPts.length - 1])) {
+      distinctPtCount = snapPts.length - 1;
+    }
+
+    i = 0;
+    for (i; i < distinctPtCount; i++) {
+      snapPt = snapPts[i];
+      index = this.findSegmentIndexToSnap(snapPt, srcCoords);
+      /**
+       * If a segment to snap to was found, "crack" it at the snap pt. The new
+       * pt is inserted immediately into the src segment list, so that
+       * subsequent snapping will take place on the modified segments. Duplicate
+       * points are not added.
+       */
+      if (index >= 0) {
+        srcCoords.add(index + 1, new jsts.geom.Coordinate(snapPt), false);
+      }
+    }
+  };
+
+  /**
+   * Finds a src segment which snaps to (is close to) the given snap point.
+   * <p>
+   * Only a single segment is selected for snapping. This prevents multiple
+   * segments snapping to the same snap vertex, which would almost certainly
+   * cause invalid geometry to be created. (The heuristic approach to snapping
+   * used here is really only appropriate when snap pts snap to a unique spot on
+   * the src geometry.)
+   * <p>
+   * Also, if the snap vertex occurs as a vertex in the src coordinate list, no
+   * snapping is performed.
+   *
+   * @param {jsts.geom.Coordinate}
+   *          snapPt the point to snap to.
+   * @param {jsts.geom.CoordinateList}
+   *          srcCoords the source segment coordinates.
+   * @return {Number} the index of the snapped segment.
+   * @return {Number} -1 if no segment snaps to the snap point.
+   */
+  LineStringSnapper.prototype.findSegmentIndexToSnap = function(snapPt,
+      srcCoords) {
+    var minDist = Number.MAX_VALUE, snapIndex = -1, i = 0, dist;
+    for (i; i < srcCoords.size() - 1; i++) {
+      this.seg.p0 = srcCoords.get(i);
+      this.seg.p1 = srcCoords.get(i + 1);
+
+      /**
+       * Check if the snap pt is equal to one of the segment endpoints.
+       *
+       * If the snap pt is already in the src list, don't snap at all.
+       */
+      if (this.seg.p0.equals(snapPt) || this.seg.p1.equals(snapPt)) {
+        if (this.allowSnappingToSourceVertices) {
+          continue;
+        } else {
+          return -1;
+        }
+      }
+
+      dist = this.seg.distance(snapPt);
+      if (dist < this.snapTolerance && dist < minDist) {
+        minDist = dist;
+        snapIndex = i;
+      }
+    }
+    return snapIndex;
+  };
+
+  jsts.operation.overlay.snap.LineStringSnapper = LineStringSnapper;
+})();

data/vendor/assets/javascripts/jsts/operation/overlay/snap/SnapIfNeededOverlayOp.js

@@ -0,0 +1,85 @@
+/* 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/operation/overlay/OverlayOp.js
+   * @requires jsts/operation/overlay/snap/SnapOverlayOp.js
+   */
+
+  var OverlayOp = jsts.operation.overlay.OverlayOp;
+  var SnapOverlayOp = jsts.operation.overlay.snap.SnapOverlayOp;
+
+  /**
+   * Performs an overlay operation using snapping and enhanced precision to
+   * improve the robustness of the result. This class only uses snapping if an
+   * error is detected when running the standard JTS overlay code. Errors
+   * detected include thrown exceptions (in particular,
+   * {@link TopologyException}) and invalid overlay computations.
+   */
+  var SnapIfNeededOverlayOp = function(g1, g2) {
+    this.geom = [];
+    this.geom[0] = g1;
+    this.geom[1] = g2;
+  };
+
+  SnapIfNeededOverlayOp.overlayOp = function(g0, g1, opCode) {
+    var op = new SnapIfNeededOverlayOp(g0, g1);
+    return op.getResultGeometry(opCode);
+  };
+
+  SnapIfNeededOverlayOp.intersection = function(g0, g1) {
+    return overlayOp(g0, g1, OverlayOp.INTERSECTION);
+  };
+
+  SnapIfNeededOverlayOp.union = function(g0, g1) {
+    return overlayOp(g0, g1, OverlayOp.UNION);
+  };
+
+  SnapIfNeededOverlayOp.difference = function(g0, g1) {
+    return overlayOp(g0, g1, OverlayOp.DIFFERENCE);
+  };
+
+  SnapIfNeededOverlayOp.symDifference = function(g0, g1) {
+    return overlayOp(g0, g1, OverlayOp.SYMDIFFERENCE);
+  };
+
+  /**
+   * @private
+   * @type {Array.<jsts.geom.Geometry}
+   */
+  SnapIfNeededOverlayOp.prototype.geom = null;
+
+
+  SnapIfNeededOverlayOp.prototype.getResultGeometry = function(opCode) {
+    var result = null;
+    var isSuccess = false;
+    var savedException = null;
+    try {
+      result = OverlayOp.overlayOp(this.geom[0], this.geom[1], opCode);
+      var isValid = true;
+      if (isValid)
+        isSuccess = true;
+
+    } catch (ex) {
+      savedException = ex;
+    }
+    if (!isSuccess) {
+      // this may still throw an exception
+      // if so, throw the original exception since it has the input coordinates
+      try {
+        result = SnapOverlayOp.overlayOp(this.geom[0], this.geom[1], opCode);
+      } catch (ex) {
+        throw savedException;
+      }
+    }
+    return result;
+  };
+
+  jsts.operation.overlay.snap.SnapIfNeededOverlayOp = SnapIfNeededOverlayOp;
+
+})();

data/vendor/assets/javascripts/jsts/operation/overlay/snap/SnapOverlayOp.js

@@ -0,0 +1,134 @@
+/* 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/operation/overlay/snap/SnapOverlayOp.java
+ * Revision: 150
+ */
+
+/**
+ * @requires jsts/operation/overlay/snap/GeometrySnapper.js
+ * @requires jsts/operation/overlay/OverlayOp.js
+ * TODO: reenable when ported: requires jsts/precision/CommonBitsRemover.js
+ */
+
+/**
+ * Performs an overlay operation using snapping and enhanced precision to
+ * improve the robustness of the result. This class <i>always</i> uses
+ * snapping. This is less performant than the standard JTS overlay code, and may
+ * even introduce errors which were not present in the original data. For this
+ * reason, this class should only be used if the standard overlay code fails to
+ * produce a correct result.
+ */
+
+(function() {
+
+  var OverlayOp = jsts.operation.overlay.OverlayOp;
+  var GeometrySnapper = jsts.operation.overlay.snap.GeometrySnapper;
+
+  /**
+   * @constructor
+   */
+  var SnapOverlayOp = function(g1, g2) {
+    this.geom = [];
+    this.geom[0] = g1;
+    this.geom[1] = g2;
+    this.computeSnapTolerance();
+  };
+
+  SnapOverlayOp.overlayOp = function(g0, g1, opCode) {
+    var op = new SnapOverlayOp(g0, g1);
+    return op.getResultGeometry(opCode);
+  };
+
+  SnapOverlayOp.intersection = function(g0, g1) {
+    return this.overlayOp(g0, g1, OverlayOp.INTERSECTION);
+  };
+
+  SnapOverlayOp.union = function(g0, g1) {
+    return this.overlayOp(g0, g1, OverlayOp.UNION);
+  };
+
+  SnapOverlayOp.difference = function(g0, g1) {
+    return overlayOp(g0, g1, OverlayOp.DIFFERENCE);
+  };
+
+  SnapOverlayOp.symDifference = function(g0, g1) {
+    return overlayOp(g0, g1, OverlayOp.SYMDIFFERENCE);
+  };
+
+
+  SnapOverlayOp.prototype.geom = null;
+  SnapOverlayOp.prototype.snapTolerance = null;
+
+  /**
+   * @private
+   */
+  SnapOverlayOp.prototype.computeSnapTolerance = function() {
+    this.snapTolerance = GeometrySnapper.computeOverlaySnapTolerance(
+        this.geom[0], this.geom[1]);
+  };
+
+  SnapOverlayOp.prototype.getResultGeometry = function(opCode) {
+    var prepGeom = this.snap(this.geom);
+    var result = OverlayOp.overlayOp(prepGeom[0], prepGeom[1], opCode);
+    return this.prepareResult(result);
+  };
+
+  /**
+   * @private
+   */
+  SnapOverlayOp.prototype.selfSnap = function(geom) {
+    var snapper0 = new GeometrySnapper(geom);
+    var snapGeom = snapper0.snapTo(geom, this.snapTolerance);
+    return snapGeom;
+  };
+
+  /**
+   * @private
+   */
+  SnapOverlayOp.prototype.snap = function(geom) {
+    // TODO: CommonBitsRemover isn't ported yet...
+    var remGeom = geom;//this.removeCommonBits(geom);
+
+    var snapGeom = GeometrySnapper.snap(remGeom[0], remGeom[1],
+        this.snapTolerance);
+
+    return snapGeom;
+  };
+
+  /**
+   * @private
+   */
+  SnapOverlayOp.prototype.prepareResult = function(geom) {
+ // TODO: CommonBitsRemover isn't ported yet...
+    //this.cbr.addCommonBits(geom);
+    return geom;
+  };
+
+  /**
+   * @private
+   * @type {CommonBitsRemover}
+   */
+  SnapOverlayOp.prototype.cbr = null;
+
+  /**
+   * @private
+   */
+  SnapOverlayOp.prototype.removeCommonBits = function(geom) {
+    this.cbr = new jsts.precision.CommonBitsRemover();
+    this.cbr.add(this.geom[0]);
+    this.cbr.add(this.geom[1]);
+    var remGeom = [];
+    remGeom[0] = cbr.removeCommonBits(this.geom[0].clone());
+    remGeom[1] = cbr.removeCommonBits(this.geom[1].clone());
+    return remGeom;
+  };
+
+  jsts.operation.overlay.snap.SnapOverlayOp = SnapOverlayOp;
+
+})();

data/vendor/assets/javascripts/jsts/operation/polygonize/EdgeRing.js

@@ -0,0 +1,259 @@
+/* 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/operation/polygonize/EdgeRing.java
+ * Revision: 109
+ */
+
+(function() {
+
+  /**
+   * Represents a ring of {@link PolygonizeDirectedEdge}s which form a ring of
+   * a polygon. The ring may be either an outer shell or a hole.
+   */
+  var EdgeRing = function(factory) {
+    this.deList = new javascript.util.ArrayList();
+
+    this.factory = factory;
+  };
+
+
+
+  /**
+   * Find the innermost enclosing shell EdgeRing containing the argument
+   * EdgeRing, if any. The innermost enclosing ring is the <i>smallest</i>
+   * enclosing ring. The algorithm used depends on the fact that: <br>
+   * ring A contains ring B iff envelope(ring A) contains envelope(ring B) <br>
+   * This routine is only safe to use if the chosen point of the hole is known
+   * to be properly contained in a shell (which is guaranteed to be the case if
+   * the hole does not touch its shell)
+   *
+   * @param {EdgeRing}
+   *          testEr
+   * @param {List}
+   *          shellList
+   *
+   * @return containing EdgeRing, if there is one.
+   * @return null if no containing EdgeRing is found.
+   */
+  EdgeRing.findEdgeRingContaining = function(testEr, shellList) {
+    var testRing = testEr.getRing();
+    var testEnv = testRing.getEnvelopeInternal();
+    var testPt = testRing.getCoordinateN(0);
+
+    var minShell = null;
+    var minEnv = null;
+    for (var it = shellList.iterator(); it.hasNext();) {
+      var tryShell = it.next();
+      var tryRing = tryShell.getRing();
+      var tryEnv = tryRing.getEnvelopeInternal();
+      if (minShell != null)
+        minEnv = minShell.getRing().getEnvelopeInternal();
+      var isContained = false;
+      // the hole envelope cannot equal the shell envelope
+      if (tryEnv.equals(testEnv))
+        continue;
+
+      testPt = jsts.geom.CoordinateArrays.ptNotInList(
+          testRing.getCoordinates(), tryRing.getCoordinates());
+      if (tryEnv.contains(testEnv) &&
+          jsts.algorithm.CGAlgorithms.isPointInRing(testPt, tryRing
+              .getCoordinates()))
+        isContained = true;
+      // check if this new containing ring is smaller than the current minimum
+      // ring
+      if (isContained) {
+        if (minShell == null || minEnv.contains(tryEnv)) {
+          minShell = tryShell;
+        }
+      }
+    }
+    return minShell;
+  };
+
+  /**
+   * Finds a point in a list of points which is not contained in another list of
+   * points
+   *
+   * @param {Coordinate[]}
+   *          testPts the {@link Coordinate}s to test.
+   * @param {Coordinate[]}
+   *          pts an array of {@link Coordinate}s to test the input points
+   *          against.
+   * @return a {@link Coordinate} from <code>testPts</code> which is not in
+   *         <code>pts</code>,.
+   * @return null if there is no coordinate not in the list.
+   */
+  EdgeRing.ptNotInList = function(testPts, pts) {
+    for (var i = 0; i < testPts.length; i++) {
+      var testPt = testPts[i];
+      if (!isInList(testPt, pts))
+        return testPt;
+    }
+    return null;
+  };
+
+  /**
+   * Tests whether a given point is in an array of points. Uses a value-based
+   * test.
+   *
+   * @param {Coordinate}
+   *          pt a {@link Coordinate} for the test point.
+   * @param {Coordinate[]}
+   *          pts an array of {@link Coordinate}s to test.
+   * @return <code>true</code> if the point is in the array.
+   */
+  EdgeRing.isInList = function(pt, pts) {
+    for (var i = 0; i < pts.length; i++) {
+      if (pt.equals(pts[i]))
+        return true;
+    }
+    return false;
+  }
+
+  EdgeRing.prototype.factory = null;
+
+  EdgeRing.prototype.deList = null;
+
+  // cache the following data for efficiency
+  EdgeRing.prototype.ring = null;
+
+  EdgeRing.prototype.ringPts = null;
+  EdgeRing.prototype.holes = null;
+
+  /**
+   * Adds a {@link DirectedEdge} which is known to form part of this ring.
+   *
+   * @param de
+   *          the {@link DirectedEdge} to add.
+   */
+  EdgeRing.prototype.add = function(de) {
+    this.deList.add(de);
+  };
+
+  /**
+   * Tests whether this ring is a hole. Due to the way the edges in the
+   * polyongization graph are linked, a ring is a hole if it is oriented
+   * counter-clockwise.
+   *
+   * @return <code>true</code> if this ring is a hole.
+   */
+  EdgeRing.prototype.isHole = function() {
+    var ring = this.getRing();
+    return jsts.algorithm.CGAlgorithms.isCCW(ring.getCoordinates());
+  };
+
+  /**
+   * Adds a hole to the polygon formed by this ring.
+   *
+   * @param hole
+   *          the {@link LinearRing} forming the hole.
+   */
+  EdgeRing.prototype.addHole = function(hole) {
+    if (this.holes == null)
+      this.holes = new javascript.util.ArrayList();
+    this.holes.add(hole);
+  };
+
+  /**
+   * Computes the {@link Polygon} formed by this ring and any contained holes.
+   *
+   * @return the {@link Polygon} formed by this ring and its holes.
+   */
+  EdgeRing.prototype.getPolygon = function() {
+    var holeLR = null;
+    if (this.holes != null) {
+      holeLR = [];
+      for (var i = 0; i < this.holes.size(); i++) {
+        holeLR[i] = this.holes.get(i);
+      }
+    }
+    var poly = this.factory.createPolygon(this.ring, holeLR);
+    return poly;
+  };
+
+  /**
+   * Tests if the {@link LinearRing} ring formed by this edge ring is
+   * topologically valid.
+   *
+   * @return true if the ring is valid.
+   */
+  EdgeRing.prototype.isValid = function() {
+    this.getCoordinates();
+    if (this.ringPts.length <= 3)
+      return false;
+    this.getRing();
+    return this.ring.isValid();
+  };
+
+  /**
+   * Computes the list of coordinates which are contained in this ring. The
+   * coordinatea are computed once only and cached.
+   *
+   * @return an array of the {@link Coordinate} s in this ring.
+   */
+  EdgeRing.prototype.getCoordinates = function() {
+    if (this.ringPts == null) {
+      var coordList = new jsts.geom.CoordinateList();
+      for (var i = this.deList.iterator(); i.hasNext();) {
+        var de = i.next();
+        var edge = de.getEdge();
+        EdgeRing.addEdge(edge.getLine().getCoordinates(), de.getEdgeDirection(),
+            coordList);
+      }
+      this.ringPts = coordList.toCoordinateArray();
+    }
+    return this.ringPts;
+  };
+
+  /**
+   * Gets the coordinates for this ring as a {@link LineString}. Used to return
+   * the coordinates in this ring as a valid geometry, when it has been detected
+   * that the ring is topologically invalid.
+   *
+   * @return a {@link LineString} containing the coordinates in this ring.
+   */
+  EdgeRing.prototype.getLineString = function() {
+    this.getCoordinates();
+    return this.factory.createLineString(this.ringPts);
+  };
+
+  /**
+   * Returns this ring as a {@link LinearRing}, or null if an Exception occurs
+   * while creating it (such as a topology problem). Details of problems are
+   * written to standard output.
+   */
+  EdgeRing.prototype.getRing = function() {
+    if (this.ring != null)
+      return this.ring;
+    this.getCoordinates();
+    if (this.ringPts.length < 3)
+      console.log(this.ringPts);
+    try {
+      this.ring = this.factory.createLinearRing(this.ringPts);
+    } catch (ex) {
+      console.log(this.ringPts);
+    }
+    return this.ring;
+  };
+
+  EdgeRing.addEdge = function(coords, isForward, coordList) {
+    if (isForward) {
+      for (var i = 0; i < coords.length; i++) {
+        coordList.add(coords[i], false);
+      }
+    } else {
+      for (var i = coords.length - 1; i >= 0; i--) {
+        coordList.add(coords[i], false);
+      }
+    }
+  };
+
+  jsts.operation.polygonize.EdgeRing = EdgeRing;
+
+})();