jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/operation/overlay/PointBuilder.js

@@ -0,0 +1,103 @@
+/* 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;
+
+  /**
+   * Constructs {@link Point}s from the nodes of an overlay graph.
+   */
+  var PointBuilder = function(op, geometryFactory, ptLocator) {
+    this.resultPointList = new ArrayList();
+
+    this.op = op;
+    this.geometryFactory = geometryFactory;
+  };
+
+  PointBuilder.prototype.op = null;
+  PointBuilder.prototype.geometryFactory = null;
+
+  PointBuilder.prototype.resultPointList = null;
+
+  /**
+   * Computes the Point geometries which will appear in the result, given the
+   * specified overlay operation.
+   *
+   * @return a list of the Points objects in the result.
+   */
+  PointBuilder.prototype.build = function(opCode) {
+    this.extractNonCoveredResultNodes(opCode);
+    /**
+     * It can happen that connected result nodes are still covered by result
+     * geometries, so must perform this filter. (For instance, this can happen
+     * during topology collapse).
+     */
+    return this.resultPointList;
+  };
+
+  /**
+   * Determines nodes which are in the result, and creates {@link Point}s for
+   * them.
+   *
+   * This method determines nodes which are candidates for the result via their
+   * labelling and their graph topology.
+   *
+   * @param opCode
+   *          the overlay operation.
+   * @private
+   */
+  PointBuilder.prototype.extractNonCoveredResultNodes = function(opCode) {
+    // testing only
+    // if (true) return resultNodeList;
+
+    for (var nodeit = this.op.getGraph().getNodes().iterator(); nodeit
+        .hasNext();) {
+      var n = nodeit.next();
+
+      // filter out nodes which are known to be in the result
+      if (n.isInResult())
+        continue;
+      // if an incident edge is in the result, then the node coordinate is
+      // included already
+      if (n.isIncidentEdgeInResult())
+        continue;
+      if (n.getEdges().getDegree() === 0 || opCode === jsts.operation.overlay.OverlayOp.INTERSECTION) {
+
+        /**
+         * For nodes on edges, only INTERSECTION can result in edge nodes being
+         * included even if none of their incident edges are included
+         */
+        var label = n.getLabel();
+        if (jsts.operation.overlay.OverlayOp.isResultOfOp(label, opCode)) {
+          this.filterCoveredNodeToPoint(n);
+        }
+      }
+    }
+  };
+
+  /**
+   * Converts non-covered nodes to Point objects and adds them to the result.
+   *
+   * A node is covered if it is contained in another element Geometry with
+   * higher dimension (e.g. a node point might be contained in a polygon, in
+   * which case the point can be eliminated from the result).
+   *
+   * @param n
+   *          the node to test.
+   * @private
+   */
+  PointBuilder.prototype.filterCoveredNodeToPoint = function(n) {
+    var coord = n.getCoordinate();
+    if (!this.op.isCoveredByLA(coord)) {
+      var pt = this.geometryFactory.createPoint(coord);
+      this.resultPointList.add(pt);
+    }
+  };
+
+  jsts.operation.overlay.PointBuilder = PointBuilder;
+
+})();

data/vendor/assets/javascripts/jsts/operation/overlay/PolygonBuilder.js

@@ -0,0 +1,282 @@
+/* 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.
+ */
+
+/**
+ * Forms {@link Polygon}s out of a graph of {@link DirectedEdge}s. The edges
+ * to use are marked as being in the result Area.
+ * <p>
+ */
+jsts.operation.overlay.PolygonBuilder = function(geometryFactory) {
+  this.shellList = [];
+  this.geometryFactory = geometryFactory;
+};
+
+/**
+ * @private
+ */
+jsts.operation.overlay.PolygonBuilder.prototype.geometryFactory = null;
+
+/**
+ * @private
+ */
+jsts.operation.overlay.PolygonBuilder.prototype.shellList = null;
+
+
+/**
+ * Add a complete graph. The graph is assumed to contain one or more polygons,
+ * possibly with holes.
+ *
+ * @param {jsts.geomgraph.PlanarGraph}
+ *          graph
+ */
+jsts.operation.overlay.PolygonBuilder.prototype.add = function(graph) {
+  if (arguments.length === 2) {
+    this.add2.apply(this, arguments);
+    return;
+  }
+
+  this.add2(graph.getEdgeEnds(), graph.getNodes());
+};
+
+/**
+ * Add a set of edges and nodes, which form a graph. The graph is assumed to
+ * contain one or more polygons, possibly with holes.
+ */
+jsts.operation.overlay.PolygonBuilder.prototype.add2 = function(dirEdges, nodes) {
+  jsts.geomgraph.PlanarGraph.linkResultDirectedEdges(nodes);
+  var maxEdgeRings = this.buildMaximalEdgeRings(dirEdges);
+  var freeHoleList = [];
+  var edgeRings = this.buildMinimalEdgeRings(maxEdgeRings, this.shellList,
+      freeHoleList);
+  this.sortShellsAndHoles(edgeRings, this.shellList, freeHoleList);
+  this.placeFreeHoles(this.shellList, freeHoleList);
+};
+
+jsts.operation.overlay.PolygonBuilder.prototype.getPolygons = function() {
+  var resultPolyList = this.computePolygons(this.shellList);
+  return resultPolyList;
+};
+
+
+/**
+ * for all DirectedEdges in result, form them into MaximalEdgeRings
+ *
+ * @private
+ */
+jsts.operation.overlay.PolygonBuilder.prototype.buildMaximalEdgeRings = function(
+    dirEdges) {
+  var maxEdgeRings = [];
+  for (var it = dirEdges.iterator(); it.hasNext(); ) {
+    var de = it.next();
+    if (de.isInResult() && de.getLabel().isArea()) {
+      // if this edge has not yet been processed
+      if (de.getEdgeRing() == null) {
+        var er = new jsts.operation.overlay.MaximalEdgeRing(de, this.geometryFactory);
+        maxEdgeRings.push(er);
+        er.setInResult();
+        // System.out.println("max node degree = " + er.getMaxDegree());
+      }
+    }
+  }
+  return maxEdgeRings;
+};
+
+/**
+ * @private
+ */
+jsts.operation.overlay.PolygonBuilder.prototype.buildMinimalEdgeRings = function(
+    maxEdgeRings, shellList, freeHoleList) {
+  var edgeRings = [];
+  for (var i = 0; i < maxEdgeRings.length; i++) {
+    var er = maxEdgeRings[i];
+    if (er.getMaxNodeDegree() > 2) {
+      er.linkDirectedEdgesForMinimalEdgeRings();
+      var minEdgeRings = er.buildMinimalRings();
+      // at this point we can go ahead and attempt to place holes, if this
+      // EdgeRing is a polygon
+      var shell = this.findShell(minEdgeRings);
+      if (shell !== null) {
+        this.placePolygonHoles(shell, minEdgeRings);
+        shellList.push(shell);
+      } else {
+        freeHoleList = freeHoleList.concat(minEdgeRings);
+      }
+    } else {
+      edgeRings.push(er);
+    }
+  }
+  return edgeRings;
+};
+
+/**
+ * This method takes a list of MinimalEdgeRings derived from a MaximalEdgeRing,
+ * and tests whether they form a Polygon. This is the case if there is a single
+ * shell in the list. In this case the shell is returned. The other possibility
+ * is that they are a series of connected holes, in which case no shell is
+ * returned.
+ *
+ * @return {EdgeRing} the shell EdgeRing, if there is one or null, if all the
+ *         rings are holes.
+ * @private
+ */
+jsts.operation.overlay.PolygonBuilder.prototype.findShell = function(
+    minEdgeRings) {
+  var shellCount = 0;
+  var shell = null;
+  for (var i = 0; i < minEdgeRings.length; i++) {
+    var er = minEdgeRings[i];
+    if (!er.isHole()) {
+      shell = er;
+      shellCount++;
+    }
+  }
+  jsts.util.Assert.isTrue(shellCount <= 1, 'found two shells in MinimalEdgeRing list');
+  return shell;
+};
+/**
+ * This method assigns the holes for a Polygon (formed from a list of
+ * MinimalEdgeRings) to its shell. Determining the holes for a MinimalEdgeRing
+ * polygon serves two purposes:
+ * <ul>
+ * <li>it is faster than using a point-in-polygon check later on.
+ * <li>it ensures correctness, since if the PIP test was used the point chosen
+ * might lie on the shell, which might return an incorrect result from the PIP
+ * test
+ * </ul>
+ *
+ * @param {EdgeRing}
+ *          shell
+ * @param {Array}
+ *          minEdgeRings
+ * @private
+ */
+jsts.operation.overlay.PolygonBuilder.prototype.placePolygonHoles = function(
+    shell, minEdgeRings) {
+  for (var i = 0; i < minEdgeRings.length; i++) {
+    var er = minEdgeRings[i];
+    if (er.isHole()) {
+      er.setShell(shell);
+    }
+  }
+};
+/**
+ * For all rings in the input list, determine whether the ring is a shell or a
+ * hole and add it to the appropriate list. Due to the way the DirectedEdges
+ * were linked, a ring is a shell if it is oriented CW, a hole otherwise.
+ *
+ * @private
+ */
+jsts.operation.overlay.PolygonBuilder.prototype.sortShellsAndHoles = function(
+    edgeRings, shellList, freeHoleList) {
+  for (var i = 0; i < edgeRings.length; i++) {
+    var er = edgeRings[i];
+    if (er.isHole()) {
+      freeHoleList.push(er);
+    } else {
+      shellList.push(er);
+    }
+  }
+};
+/**
+ * This method determines finds a containing shell for all holes which have not
+ * yet been assigned to a shell. These "free" holes should all be <b>properly</b>
+ * contained in their parent shells, so it is safe to use the
+ * <code>findEdgeRingContaining</code> method. (This is the case because any
+ * holes which are NOT properly contained (i.e. are connected to their parent
+ * shell) would have formed part of a MaximalEdgeRing and been handled in a
+ * previous step).
+ *
+ * @throws TopologyException
+ *           if a hole cannot be assigned to a shell
+ * @private
+ */
+jsts.operation.overlay.PolygonBuilder.prototype.placeFreeHoles = function(
+    shellList, freeHoleList) {
+  for (var i = 0; i < freeHoleList.length; i++) {
+    var hole = freeHoleList[i];
+    // only place this hole if it doesn't yet have a shell
+    if (hole.getShell() == null) {
+      var shell = this.findEdgeRingContaining(hole, shellList);
+      if (shell === null)
+        throw new jsts.error.TopologyError('unable to assign hole to a shell',
+            hole.getCoordinate(0));
+      hole.setShell(shell);
+    }
+  }
+};
+
+/**
+ * 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)
+ *
+ * @return containing EdgeRing, if there is one.
+ * @return null if no containing EdgeRing is found.
+ * @private
+ */
+jsts.operation.overlay.PolygonBuilder.prototype.findEdgeRingContaining = function(
+    testEr, shellList) {
+  var testRing = testEr.getLinearRing();
+  var testEnv = testRing.getEnvelopeInternal();
+  var testPt = testRing.getCoordinateN(0);
+
+  var minShell = null;
+  var minEnv = null;
+  for (var i = 0; i < shellList.length; i++) {
+    var tryShell = shellList[i];
+    var tryRing = tryShell.getLinearRing();
+    var tryEnv = tryRing.getEnvelopeInternal();
+    if (minShell !== null)
+      minEnv = minShell.getLinearRing().getEnvelopeInternal();
+    var isContained = false;
+    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;
+};
+
+/**
+ * @private
+ */
+jsts.operation.overlay.PolygonBuilder.prototype.computePolygons = function(
+    shellList) {
+  var resultPolyList = new javascript.util.ArrayList();
+  // add Polygons for all shells
+  for (var i = 0; i < shellList.length; i++) {
+    var er = shellList[i];
+    var poly = er.toPolygon(this.geometryFactory);
+    resultPolyList.add(poly);
+  }
+  return resultPolyList;
+};
+
+/**
+ * Checks the current set of shells (with their associated holes) to see if any
+ * of them contain the point.
+ *
+ * @return {boolean}
+ */
+jsts.operation.overlay.PolygonBuilder.prototype.containsPoint = function(p) {
+  for (var i = 0; i < this.shellList.length; i++) {
+    var er = this.shellList[i];
+    if (er.containsPoint(p))
+      return true;
+  }
+  return false;
+};

data/vendor/assets/javascripts/jsts/operation/overlay/snap/GeometrySnapper.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.
+ */
+
+/**
+ * Port source:
+ * /jts/jts/java/src/com/vividsolutions/jts/operation/overlay/snap/GeometrySnapper.java
+ * Revision: 167
+ */
+
+/**
+ * @requires jsts/operation/overlay/snap/LineStringSnapper.js
+ * @requires jsts/geom/PrecisionModel.js
+ * @requires jsts/geom/util/GeometryTransformer.js
+ */
+
+/**
+ * Snaps the vertices and segments of a {@link Geometry} to another Geometry's
+ * vertices. A snap distance tolerance is used to control where snapping is
+ * performed. Snapping one geometry to another can improve robustness for
+ * overlay operations by eliminating nearly-coincident edges (which cause
+ * problems during noding and intersection calculation). Too much snapping can
+ * result in invalid topology beging created, so the number and location of
+ * snapped vertices is decided using heuristics to determine when it is safe to
+ * snap. This can result in some potential snaps being omitted, however.
+ */
+
+(function() {
+
+  var LineStringSnapper = jsts.operation.overlay.snap.LineStringSnapper;
+  var PrecisionModel = jsts.geom.PrecisionModel;
+  var TreeSet = javascript.util.TreeSet;
+
+  /**
+   * @constructor
+   */
+  var SnapTransformer = function(snapTolerance, snapPts, isSelfSnap) {
+    this.snapTolerance = snapTolerance;
+    this.snapPts = snapPts;
+    this.isSelfSnap = isSelfSnap || false;
+  };
+
+  SnapTransformer.prototype = new jsts.geom.util.GeometryTransformer();
+
+  SnapTransformer.prototype.snapTolerance = null;
+  SnapTransformer.prototype.snapPts = null;
+  SnapTransformer.prototype.isSelfSnap = false;
+
+
+  SnapTransformer.prototype.transformCoordinates = function(coords, parent) {
+    var srcPts = coords;
+    var newPts = this.snapLine(srcPts, this.snapPts);
+    return newPts;
+  };
+
+  SnapTransformer.prototype.snapLine = function(srcPts, snapPts) {
+    var snapper = new LineStringSnapper(srcPts, this.snapTolerance);
+    snapper.setAllowSnappingToSourceVertices(this.isSelfSnap);
+    return snapper.snapTo(snapPts);
+  };
+
+  /**
+   * Creates a new snapper acting on the given geometry
+   *
+   * @param srcGeom
+   *          the geometry to snap.
+   * @constructor
+   */
+  var GeometrySnapper = function(srcGeom) {
+    this.srcGeom = srcGeom;
+  };
+
+  GeometrySnapper.SNAP_PRECISION_FACTOR = 1e-9;
+
+  /**
+   * Estimates the snap tolerance for a Geometry, taking into account its
+   * precision model.
+   *
+   * @param g
+   *          a Geometry.
+   * @return the estimated snap tolerance.
+   */
+  GeometrySnapper.computeOverlaySnapTolerance = function(g) {
+    if (arguments.length === 2) {
+      return GeometrySnapper.computeOverlaySnapTolerance2.apply(this, arguments);
+    }
+
+    var snapTolerance = this.computeSizeBasedSnapTolerance(g);
+
+    /**
+     * Overlay is carried out in the precision model of the two inputs. If this
+     * precision model is of type FIXED, then the snap tolerance must reflect
+     * the precision grid size. Specifically, the snap tolerance should be at
+     * least the distance from a corner of a precision grid cell to the centre
+     * point of the cell.
+     */
+    var pm = g.getPrecisionModel();
+    if (pm.getType() == PrecisionModel.FIXED) {
+      var fixedSnapTol = (1 / pm.getScale()) * 2 / 1.415;
+      if (fixedSnapTol > snapTolerance)
+        snapTolerance = fixedSnapTol;
+    }
+    return snapTolerance;
+  };
+
+  GeometrySnapper.computeSizeBasedSnapTolerance = function(g) {
+    var env = g.getEnvelopeInternal();
+    var minDimension = Math.min(env.getHeight(), env.getWidth());
+    var snapTol = minDimension * GeometrySnapper.SNAP_PRECISION_FACTOR;
+    return snapTol;
+  };
+
+  GeometrySnapper.computeOverlaySnapTolerance2 = function(g0, g1) {
+    return Math.min(this.computeOverlaySnapTolerance(g0), this
+        .computeOverlaySnapTolerance(g1));
+  };
+
+  /**
+   * Snaps two geometries together with a given tolerance.
+   *
+   * @param g0
+   *          a geometry to snap.
+   * @param g1
+   *          a geometry to snap.
+   * @param snapTolerance
+   *          the tolerance to use.
+   * @return the snapped geometries.
+   */
+  GeometrySnapper.snap = function(g0, g1, snapTolerance) {
+    var snapGeom = [];
+    var snapper0 = new GeometrySnapper(g0);
+    snapGeom[0] = snapper0.snapTo(g1, snapTolerance);
+
+    /**
+     * Snap the second geometry to the snapped first geometry (this strategy
+     * minimizes the number of possible different points in the result)
+     */
+    var snapper1 = new GeometrySnapper(g1);
+    snapGeom[1] = snapper1.snapTo(snapGeom[0], snapTolerance);
+
+    return snapGeom;
+  };
+
+  GeometrySnapper.snapToSelf = function(g0, snapTolerance, cleanResult) {
+    var snapper0 = new GeometrySnapper(g0);
+    return snapper0.snapToSelf(snapTolerance, cleanResult);
+  };
+
+  /**
+   * @private
+   */
+  GeometrySnapper.prototype.srcGeom = null;
+
+  /**
+   * Snaps the vertices in the component {@link LineString}s of the source
+   * geometry to the vertices of the given snap geometry.
+   *
+   * @param snapGeom
+   *          a geometry to snap the source to.
+   * @return a new snapped Geometry.
+   */
+  GeometrySnapper.prototype.snapTo = function(snapGeom, snapTolerance) {
+    var snapPts = this.extractTargetCoordinates(snapGeom);
+
+    var snapTrans = new SnapTransformer(snapTolerance, snapPts);
+    return snapTrans.transform(this.srcGeom);
+  };
+
+  /**
+   * Snaps the vertices in the component {@link LineString}s of the source
+   * geometry to the vertices of the given snap geometry.
+   *
+   * @param snapGeom
+   *          a geometry to snap the source to.
+   * @return a new snapped Geometry.
+   */
+  GeometrySnapper.prototype.snapToSelf = function(snapTolerance, cleanResult) {
+    var snapPts = this.extractTargetCoordinates(srcGeom);
+
+    var snapTrans = new SnapTransformer(snapTolerance, snapPts, true);
+    var snappedGeom = snapTrans.transform(srcGeom);
+    var result = snappedGeom;
+    if (cleanResult && result instanceof Polygonal) {
+      // TODO: use better cleaning approach
+      result = snappedGeom.buffer(0);
+    }
+    return result;
+  };
+
+  GeometrySnapper.prototype.extractTargetCoordinates = function(g) {
+    // TODO: should do this more efficiently. Use CoordSeq filter to get points,
+    // KDTree for uniqueness & queries
+    var ptSet = new TreeSet();
+    var pts = g.getCoordinates();
+    for (var i = 0; i < pts.length; i++) {
+      ptSet.add(pts[i]);
+    }
+    return ptSet.toArray();
+  };
+
+  /**
+   * Computes the snap tolerance based on the input geometries.
+   *
+   * @param ringPts
+   * @return
+   */
+  GeometrySnapper.prototype.computeSnapTolerance = function(ringPts) {
+    var minSegLen = this.computeMinimumSegmentLength(ringPts);
+    // use a small percentage of this to be safe
+    var snapTol = minSegLen / 10;
+    return snapTol;
+  };
+
+  GeometrySnapper.prototype.computeMinimumSegmentLength = function(pts) {
+    var minSegLen = Number.MAX_VALUE;
+    for (var i = 0; i < pts.length - 1; i++) {
+      var segLen = pts[i].distance(pts[i + 1]);
+      if (segLen < minSegLen)
+        minSegLen = segLen;
+    }
+    return minSegLen;
+  };
+
+  jsts.operation.overlay.snap.GeometrySnapper = GeometrySnapper;
+
+})();