jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/operation/relate/RelateNode.js

@@ -0,0 +1,46 @@
+/* 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/Node.js
+ */
+
+
+
+/**
+ * A RelateNode is a Node that maintains a list of EdgeStubs for the edges that
+ * are incident on it.
+ *
+ * Represents a node in the topological graph used to compute spatial
+ * relationships.
+ *
+ * @augments {Node}
+ * @constructor
+ */
+jsts.operation.relate.RelateNode = function(coord, edges) {
+  jsts.geomgraph.Node.apply(this, arguments);
+};
+
+jsts.operation.relate.RelateNode.prototype = new jsts.geomgraph.Node();
+
+
+/**
+ * Update the IM with the contribution for this component. A component only
+ * contributes if it has a labelling for both parent geometries
+ *
+ * @protected
+ */
+jsts.operation.relate.RelateNode.prototype.computeIM = function(im) {
+  im.setAtLeastIfValid(this.label.getLocation(0), this.label.getLocation(1), 0);
+};
+
+
+/**
+ * Update the IM with the contribution for the EdgeEnds incident on this node.
+ */
+jsts.operation.relate.RelateNode.prototype.updateIMFromEdges = function(im) {
+  this.edges.updateIM(im);
+};

data/vendor/assets/javascripts/jsts/operation/relate/RelateNodeFactory.js

@@ -0,0 +1,25 @@
+/* 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.
+ */
+
+
+
+/**
+ * Used by the {@link NodeMap} in a {@link RelateNodeGraph} to create
+ * {@link RelateNode}s.
+ *
+ * @augments {jsts.geomgraph.NodeFactory}
+ * @constructor
+ */
+jsts.operation.relate.RelateNodeFactory = function() {
+
+};
+
+jsts.operation.relate.RelateNodeFactory.prototype = new jsts.geomgraph.NodeFactory();
+
+jsts.operation.relate.RelateNodeFactory.prototype.createNode = function(coord) {
+  return new jsts.operation.relate.RelateNode(coord,
+      new jsts.operation.relate.EdgeEndBundleStar());
+};

data/vendor/assets/javascripts/jsts/operation/relate/RelateNodeGraph.js

@@ -0,0 +1,118 @@
+/* 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/geom/Location.js
+   * @requires jsts/util/Assert.js
+   */
+
+  var Location = jsts.geom.Location;
+
+  /**
+   * Implements the simple graph of Nodes and EdgeEnd which is all that is
+   * required to determine topological relationships between Geometries. Also
+   * supports building a topological graph of a single Geometry, to allow
+   * verification of valid topology.
+   * <p>
+   * It is <b>not</b> necessary to create a fully linked PlanarGraph to
+   * determine relationships, since it is sufficient to know how the Geometries
+   * interact locally around the nodes. In fact, this is not even feasible,
+   * since it is not possible to compute exact intersection points, and hence
+   * the topology around those nodes cannot be computed robustly. The only Nodes
+   * that are created are for improper intersections; that is, nodes which occur
+   * at existing vertices of the Geometries. Proper intersections (e.g. ones
+   * which occur between the interior of line segments) have their topology
+   * determined implicitly, without creating a Node object to represent them.
+   *
+   * @constructor
+   */
+  jsts.operation.relate.RelateNodeGraph = function() {
+    this.nodes = new jsts.geomgraph.NodeMap(
+        new jsts.operation.relate.RelateNodeFactory());
+  };
+
+
+  /**
+   * @private
+   */
+  jsts.operation.relate.RelateNodeGraph.prototype.nodes = null;
+
+
+  jsts.operation.relate.RelateNodeGraph.prototype.build = function(geomGraph) {
+    // compute nodes for intersections between previously noded edges
+    this.computeIntersectionNodes(geomGraph, 0);
+    /**
+     * Copy the labelling for the nodes in the parent Geometry. These override
+     * any labels determined by intersections.
+     */
+    this.copyNodesAndLabels(geomGraph, 0);
+
+    /**
+     * Build EdgeEnds for all intersections.
+     */
+    var eeBuilder = new jsts.operation.relate.EdgeEndBuilder();
+    var eeList = eeBuilder.computeEdgeEnds(geomGraph.getEdgeIterator());
+    this.insertEdgeEnds(eeList);
+  };
+
+
+  /**
+   * Insert nodes for all intersections on the edges of a Geometry. Label the
+   * created nodes the same as the edge label if they do not already have a
+   * label. This allows nodes created by either self-intersections or mutual
+   * intersections to be labelled. Endpoint nodes will already be labelled from
+   * when they were inserted.
+   * <p>
+   * Precondition: edge intersections have been computed.
+   */
+  jsts.operation.relate.RelateNodeGraph.prototype.computeIntersectionNodes = function(geomGraph,
+      argIndex) {
+    for (var edgeIt = geomGraph.getEdgeIterator(); edgeIt.hasNext();) {
+      var e = edgeIt.next();
+      var eLoc = e.getLabel().getLocation(argIndex);
+      for (var eiIt = e.getEdgeIntersectionList().iterator(); eiIt.hasNext();) {
+        var ei = eiIt.next();
+        var n = this.nodes.addNode(ei.coord);
+        if (eLoc === Location.BOUNDARY)
+          n.setLabelBoundary(argIndex);
+        else {
+          if (n.getLabel().isNull(argIndex))
+            n.setLabel(argIndex, Location.INTERIOR);
+        }
+      }
+    }
+  };
+
+
+  /**
+   * Copy all nodes from an arg geometry into this graph. The node label in the
+   * arg geometry overrides any previously computed label for that argIndex.
+   * (E.g. a node may be an intersection node with a computed label of BOUNDARY,
+   * but in the original arg Geometry it is actually in the interior due to the
+   * Boundary Determination Rule)
+   */
+  jsts.operation.relate.RelateNodeGraph.prototype.copyNodesAndLabels = function(geomGraph, argIndex) {
+    for (var nodeIt = geomGraph.getNodeIterator(); nodeIt.hasNext();) {
+      var graphNode = nodeIt.next();
+      var newNode = this.nodes.addNode(graphNode.getCoordinate());
+      newNode.setLabel(argIndex, graphNode.getLabel().getLocation(argIndex));
+    }
+  };
+
+  jsts.operation.relate.RelateNodeGraph.prototype.insertEdgeEnds = function(ee) {
+    for (var i = ee.iterator(); i.hasNext();) {
+      var e = i.next();
+      this.nodes.add(e);
+    }
+  };
+
+  jsts.operation.relate.RelateNodeGraph.prototype.getNodeIterator = function() {
+    return this.nodes.iterator();
+  };
+
+})();

data/vendor/assets/javascripts/jsts/operation/relate/RelateOp.js

@@ -0,0 +1,75 @@
+/* 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.
+ */
+
+
+
+/**
+ * Implements the SFS <tt>relate()</tt> operation on two {@link Geometry}s.
+ * This class supports specifying a custom {@link BoundaryNodeRule} to be used
+ * during the relate computation.
+ * <p>
+ * <b>Note:</b> custom Boundary Node Rules do not (currently) affect the
+ * results of other Geometry methods (such as {@link Geometry#getBoundary}. The
+ * results of these methods may not be consistent with the relationship computed
+ * by a custom Boundary Node Rule.
+ *
+ * Creates a new Relate operation with a specified Boundary Node Rule.
+ *
+ * @param g0
+ *          a Geometry to relate.
+ * @param g1
+ *          another Geometry to relate.
+ * @param boundaryNodeRule
+ *          the Boundary Node Rule to use.
+ *
+ * @extends {jsts.operation.GeometryGraphOperation}
+ * @constructor
+ */
+jsts.operation.relate.RelateOp = function() {
+  jsts.operation.GeometryGraphOperation.apply(this, arguments);
+  this._relate = new jsts.operation.relate.RelateComputer(this.arg);
+};
+
+jsts.operation.relate.RelateOp.prototype = new jsts.operation.GeometryGraphOperation();
+
+
+/**
+ * Computes the {@link IntersectionMatrix} for the spatial relationship between
+ * two {@link Geometry}s using a specified Boundary Node Rule.
+ *
+ * @param a
+ *          a Geometry to test.
+ * @param b
+ *          a Geometry to test.
+ * @param boundaryNodeRule
+ *          the Boundary Node Rule to use.
+ * @return the IntersectonMatrix for the spatial relationship between the input
+ *         geometries.
+ */
+jsts.operation.relate.RelateOp.relate = function(a, b, boundaryNodeRule) {
+  var relOp = new jsts.operation.relate.RelateOp(a, b, boundaryNodeRule);
+  var im = relOp.getIntersectionMatrix();
+  return im;
+};
+
+
+/**
+ * @type {RelateComputer}
+ * @private
+ */
+jsts.operation.relate.RelateOp.prototype._relate = null;
+
+
+/**
+ * Gets the IntersectionMatrix for the spatial relationship between the input
+ * geometries.
+ *
+ * @return the IntersectonMatrix for the spatial relationship between the input
+ *         geometries.
+ */
+jsts.operation.relate.RelateOp.prototype.getIntersectionMatrix = function() {
+  return this._relate.computeIM();
+};

data/vendor/assets/javascripts/jsts/operation/union/CascadedPolygonUnion.js

@@ -0,0 +1,319 @@
+/* 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.
+ */
+/**
+ * Provides an efficient method of unioning a collection of
+ * {@link Polygonal} geometrys.
+ * This algorithm is faster and likely more robust than
+ * the simple iterated approach of
+ * repeatedly unioning each polygon to a result geometry.
+ * <p>
+ * The <tt>buffer(0)</tt> trick is sometimes faster, but can be less robust and
+ * can sometimes take an exceptionally long time to complete.
+ * This is particularly the case where there is a high degree of overlap
+ * between the polygons.  In this case, <tt>buffer(0)</tt> is forced to compute
+ * with <i>all</i> line segments from the outset,
+ * whereas cascading can eliminate many segments
+ * at each stage of processing.
+ * The best case for buffer(0) is the trivial case
+ * where there is <i>no</i> overlap between the input geometries.
+ * However, this case is likely rare in practice.
+ *
+ */
+
+
+
+/**
+ * Creates a new instance to union
+ * the given collection of {@link Geometry}s.
+ *
+ * @param {Array.<jsts.geom.Geometry>} geoms a collection of {@link Polygonal} {@link Geometry}s.
+ * @constructor
+ */
+jsts.operation.union.CascadedPolygonUnion = function(polys) {
+  this.inputPolys = polys;
+};
+
+
+/**
+ * Computes the union of
+ * a collection of {@link Polygonal} {@link Geometry}s.
+ *
+ * @param {Array.<jsts.geom.Geometry>} polys a collection of {@link Polygonal} {@link Geometry}s.
+ * @return {jsts.geom.Geometry}
+ * @public
+ */
+jsts.operation.union.CascadedPolygonUnion.union = function(polys) {
+  var op = new jsts.operation.union.CascadedPolygonUnion(polys);
+  return op.union();
+};
+
+
+/**
+ * @type {Array.<jsts.geom.Geometry>}
+ */
+jsts.operation.union.CascadedPolygonUnion.prototype.inputPolys;
+
+
+/**
+ * @type {jsts.geom.GeometryFactory}
+ */
+jsts.operation.union.CascadedPolygonUnion.prototype.geomFactory = null;
+
+
+/**
+ * The effectiveness of the index is somewhat sensitive
+ * to the node capacity.
+ * Testing indicates that a smaller capacity is better.
+ * For an STRtree, 4 is probably a good number (since
+ * this produces 2x2 "squares").
+ *
+ * @type {number}
+ * @const
+ */
+jsts.operation.union.CascadedPolygonUnion.prototype.STRTREE_NODE_CAPACITY = 4;
+
+
+/**
+ * Computes the union of the input geometries.
+ *
+ * @return {?jsts.geom.Geometry} the union of the input geometries, null if no input geometries were provided.
+ * @public
+ */
+jsts.operation.union.CascadedPolygonUnion.prototype.union = function() {
+  if (this.inputPolys.length === 0) {
+    return null;
+  }
+  this.geomFactory = this.inputPolys[0].getFactory();
+
+  /**
+   * A spatial index to organize the collection
+   * into groups of close geometries.
+   * This makes unioning more efficient, since vertices are more likely
+   * to be eliminated on each round.
+   */
+
+  var index = new jsts.index.strtree.STRtree(this.STRTREE_NODE_CAPACITY);
+  for (var i = 0, l = this.inputPolys.length; i < l; i++) {
+    var item = this.inputPolys[i];
+    index.insert(item.getEnvelopeInternal(), item);
+  }
+  var itemTree = index.itemsTree();
+  var unionAll = this.unionTree(itemTree);
+  return unionAll;
+};
+
+
+/**
+ *
+ * @param {Array.<jsts.geom.Geometry>} geomTree
+ * @return {jsts.geom.Geometry}
+ * @private
+ */
+jsts.operation.union.CascadedPolygonUnion.prototype.unionTree = function(geomTree) {
+  /**
+   * Recursively unions all subtrees in the list into single geometries.
+   * The result is a list of Geometrys only
+   */
+  var geoms = this.reduceToGeometries(geomTree);
+  var union = this.binaryUnion(geoms);
+  return union;
+};
+
+
+//TODO: Implement experimental methods?
+
+
+/**
+ * Unions a list of geometries
+ * by treating the list as a flattened binary tree,
+ * and performing a cascaded union on the tree.
+ *
+ * Unions a section of a list using a recursive binary union on each half
+ * of the section.
+ *
+ * @param {Array.<jsts.geom.Geometry>} geoms
+ * @param {number=} [start].
+ * @param {number=} [end].
+ * @return {jsts.geom.Geometry} the union of the list section.
+ * @private
+ */
+jsts.operation.union.CascadedPolygonUnion.prototype.binaryUnion = function(geoms, start, end) {
+  start = start || 0;
+  end = end || geoms.length;
+
+  if (end - start <= 1) {
+    var g0 = this.getGeometry(geoms, start);
+    return this.unionSafe(g0, null);
+  }
+  else if (end - start === 2) {
+    return this.unionSafe(this.getGeometry(geoms, start), this.getGeometry(geoms, start + 1));
+  }
+  else {
+    // recurse on both halves of the list
+    var mid = parseInt((end + start) / 2);
+    var g0 = this.binaryUnion(geoms, start, mid);
+    var g1 = this.binaryUnion(geoms, mid, end);
+    return this.unionSafe(g0, g1);
+  }
+};
+
+
+/**
+ *
+ * @param {Array.<jsts.geom.Geometry>} list
+ * @param {number} index
+ * @return {jsts.geom.Geometry}
+ * @private
+ */
+jsts.operation.union.CascadedPolygonUnion.prototype.getGeometry = function(list, index) {
+  if (index >= list.length) {
+    return null;
+  }
+  return list[index];
+};
+
+
+/**
+ * Reduces a tree of geometries to a list of geometries
+ * by recursively unioning the subtrees in the list.
+ *
+ * @param {Array} geomTree a tree-structured list of geometries.
+ * @return {Array.<jsts.geom.Geometry>} a list of Geometrys.
+ * @private
+ */
+jsts.operation.union.CascadedPolygonUnion.prototype.reduceToGeometries = function(geomTree) {
+  var geoms = [];
+  for (var i = 0, l = geomTree.length; i < l; i++) {
+    var o = geomTree[i],
+        geom = null;
+    if (o instanceof Array) {
+      geom = this.unionTree(o);
+    }
+    else if (o instanceof jsts.geom.Geometry) {
+      geom = o;
+    }
+    geoms.push(geom);
+  }
+  return geoms;
+};
+
+
+/**
+ * Computes the union of two geometries,
+ * either of both of which may be null.
+ *
+ * @param {jsts.geom.Geometry} g0 a Geometry.
+ * @param {jsts.geom.Geometry} g1 a Geometry.
+ * @return {?jsts.geom.Geometry} the union of the input(s),
+ *                               null if both inputs are null.
+ * @private
+ */
+jsts.operation.union.CascadedPolygonUnion.prototype.unionSafe = function(g0, g1) {
+  if (g0 === null && g1 === null) {
+    return null;
+  }
+  if (g0 === null) {
+    return g1.clone();
+  }
+  if (g1 === null) {
+    return g0.clone();
+  }
+
+  //what if both are null?  Maybe return empty GC?
+
+  return this.unionOptimized(g0, g1);
+};
+
+
+/**
+ * @param {jsts.geom.Geometry} g0 a Geometry.
+ * @param {jsts.geom.Geometry} g1 a Geometry.
+ * @return {jsts.geom.Geometry} the union of the input(s).
+ * @private
+ */
+jsts.operation.union.CascadedPolygonUnion.prototype.unionOptimized = function(g0, g1) {
+  var g0Env = g0.getEnvelopeInternal(),
+      g1Env = g1.getEnvelopeInternal();
+
+  if (!g0Env.intersects(g1Env)) {
+    var combo = jsts.geom.util.GeometryCombiner.combine(g0, g1);
+    return combo;
+  }
+
+  if (g0.getNumGeometries <= 1 && g1.getNumGeometries <= 1) {
+    return this.unionActual(g0, g1);
+  }
+
+  var commonEnv = g0Env.intersection(g1Env);
+  return this.unionUsingEnvelopeIntersection(g0, g1, commonEnv);
+};
+
+
+/**
+ * Unions two polygonal geometries.
+ * The case of MultiPolygons is optimized to union only
+ * the polygons which lie in the intersection of the two geometry's envelopes.
+ * Polygons outside this region can simply be combined with the union result,
+ * which is potentially much faster.
+ * This case is likely to occur often during cascaded union, and may also
+ * occur in real world data (such as unioning data for parcels on different street blocks).
+ *
+ * @param {jsts.geom.Geometry} g0 a polygonal geometry.
+ * @param {jsts.geom.Geometry} g1 a polygonal geometry.
+ * @param {jsts.geom.Envelope} common the intersection of the envelopes of the inputs.
+ * @return {jsts.geom.Geometry} the union of the inputs.
+ * @private
+ */
+jsts.operation.union.CascadedPolygonUnion.prototype.unionUsingEnvelopeIntersection = function(g0, g1, common) {
+  var disjointPolys = new javascript.util.ArrayList();
+  var g0Int = this.extractByEnvelope(common, g0, disjointPolys);
+  var g1Int = this.extractByEnvelope(common, g1, disjointPolys);
+
+  var union = this.unionActual(g0Int, g1Int);
+
+  disjointPolys.add(union);
+  var overallUnion = jsts.geom.util.GeometryCombiner.combine(disjointPolys);
+
+  return overallUnion;
+};
+
+
+/**
+ *
+ * @param {jsts.geom.Envelope} env
+ * @param {jsts.geom.Geometry} geom
+ * @param {Array.<jsts.geom.Geometry>} disjointGeoms
+ * @return {jsts.geom.Geometry}
+ * @private
+ */
+jsts.operation.union.CascadedPolygonUnion.prototype.extractByEnvelope = function(env, geom, disjointGeoms) {
+  var intersectingGeoms = new javascript.util.ArrayList();
+
+  for (var i = 0; i < geom.getNumGeometries(); i++) {
+    var elem = geom.getGeometryN(i);
+    if (elem.getEnvelopeInternal().intersects(env)) {
+      intersectingGeoms.add(elem);
+    }
+    else {
+      disjointGeoms.add(elem);
+    }
+  }
+
+  return this.geomFactory.buildGeometry(intersectingGeoms);
+};
+
+
+/**
+ * Encapsulates the actual unioning of two polygonal geometries.
+ *
+ * @param {jsts.geom.Geometry} g0
+ * @param {jsts.geom.Geometry} g1
+ * @return {jsts.geom.Geometry}
+ * @private
+ */
+jsts.operation.union.CascadedPolygonUnion.prototype.unionActual = function(g0, g1) {
+  return g0.union(g1);
+};