jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/operation/polygonize/Polygonizer.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/Polygonizer.java
+ * Revision: 6
+ */
+
+/**
+ * @requires jsts/geom/GeometryComponentFilter.js
+ * @requires jsts/geom/LineString.js
+ * @requires jsts/operation/polygonize/EdgeRing.js
+ * @requires jsts/operation/polygonize/PolygonizeGraph.js
+ */
+
+(function() {
+
+  var ArrayList = javascript.util.ArrayList;
+  var GeometryComponentFilter = jsts.geom.GeometryComponentFilter;
+  var LineString = jsts.geom.LineString;
+  var EdgeRing = jsts.operation.polygonize.EdgeRing;
+  var PolygonizeGraph = jsts.operation.polygonize.PolygonizeGraph;
+
+
+  /**
+   * Polygonizes a set of {@link Geometry}s which contain linework that
+   * represents the edges of a planar graph. All types of Geometry are accepted
+   * as input; the constituent linework is extracted as the edges to be
+   * polygonized. The processed edges must be correctly noded; that is, they
+   * must only meet at their endpoints. The Polygonizer will run on incorrectly
+   * noded input but will not form polygons from non-noded edges, and will
+   * report them as errors.
+   * <p>
+   * The Polygonizer reports the follow kinds of errors:
+   * <ul>
+   * <li><b>Dangles</b> - edges which have one or both ends which are not
+   * incident on another edge endpoint
+   * <li><b>Cut Edges</b> - edges which are connected at both ends but which
+   * do not form part of polygon
+   * <li><b>Invalid Ring Lines</b> - edges which form rings which are invalid
+   * (e.g. the component lines contain a self-intersection)
+   * </ul>
+   *
+   * Create a polygonizer with the same {@link GeometryFactory} as the input
+   * {@link Geometry}s
+   */
+  var Polygonizer = function() {
+    var that = this;
+
+    /**
+     * Adds every linear element in a {@link Geometry} into the polygonizer graph.
+     */
+    var LineStringAdder = function() {
+
+    };
+
+    LineStringAdder.prototype = new GeometryComponentFilter();
+
+    LineStringAdder.prototype.filter = function(g) {
+      if (g instanceof LineString)
+        that.add(g);
+    };
+
+    this.lineStringAdder = new LineStringAdder();
+    this.dangles = new ArrayList();
+    this.cutEdges = new ArrayList();
+    this.invalidRingLines = new ArrayList();
+  };
+
+
+
+  // default factory
+  Polygonizer.prototype.lineStringAdder = null;
+
+  Polygonizer.prototype.graph = null;
+  // initialize with empty collections, in case nothing is computed
+  Polygonizer.prototype.dangles = null;
+  Polygonizer.prototype.cutEdges = null;
+  Polygonizer.prototype.invalidRingLines = null;
+
+  Polygonizer.prototype.holeList = null;
+  Polygonizer.prototype.shellList = null;
+  Polygonizer.prototype.polyList = null;
+
+
+  /**
+   * Adds a collection of geometries to the edges to be polygonized. May be
+   * called multiple times. Any dimension of Geometry may be added; the
+   * constituent linework will be extracted and used.
+   *
+   * @param geomList
+   *          a list of {@link Geometry} s with linework to be polygonized.
+   */
+  Polygonizer.prototype.add = function(geomList) {
+    if (geomList instanceof jsts.geom.LineString) {
+      return this.add3(geomList);
+    } else if (geomList instanceof jsts.geom.Geometry) {
+      return this.add2(geomList);
+    }
+
+    for (var i = geomList.iterator(); i.hasNext();) {
+      var geometry = i.next();
+      this.add2(geometry);
+    }
+  };
+
+  /**
+   * Add a {@link Geometry} to the edges to be polygonized. May be called
+   * multiple times. Any dimension of Geometry may be added; the constituent
+   * linework will be extracted and used
+   *
+   * @param g
+   *          a {@link Geometry} with linework to be polygonized.
+   */
+  Polygonizer.prototype.add2 = function(g) {
+    g.apply(this.lineStringAdder);
+  };
+
+  /**
+   * Adds a linestring to the graph of polygon edges.
+   *
+   * @param line
+   *          the {@link LineString} to add.
+   */
+  Polygonizer.prototype.add3 = function(line) {
+    // create a new graph using the factory from the input Geometry
+    if (this.graph == null)
+      this.graph = new PolygonizeGraph(line.getFactory());
+    this.graph.addEdge(line);
+  };
+
+  /**
+   * Gets the list of polygons formed by the polygonization.
+   *
+   * @return a collection of {@link Polygon} s.
+   */
+  Polygonizer.prototype.getPolygons = function() {
+    this.polygonize();
+    return this.polyList;
+  };
+
+  /**
+   * Gets the list of dangling lines found during polygonization.
+   *
+   * @return a collection of the input {@link LineString} s which are dangles.
+   */
+  Polygonizer.prototype.getDangles = function() {
+    this.polygonize();
+    return this.dangles;
+  };
+
+  /**
+   * Gets the list of cut edges found during polygonization.
+   *
+   * @return a collection of the input {@link LineString} s which are cut edges.
+   */
+  Polygonizer.prototype.getCutEdges = function() {
+    this.polygonize();
+    return this.cutEdges;
+  };
+
+  /**
+   * Gets the list of lines forming invalid rings found during polygonization.
+   *
+   * @return a collection of the input {@link LineString} s which form invalid
+   *         rings.
+   */
+  Polygonizer.prototype.getInvalidRingLines = function() {
+    this.polygonize();
+    return this.invalidRingLines;
+  };
+
+  /**
+   * Performs the polygonization, if it has not already been carried out.
+   */
+  Polygonizer.prototype.polygonize = function() {
+    // check if already computed
+    if (this.polyList != null)
+      return;
+    this.polyList = new ArrayList();
+
+    // if no geometries were supplied it's possible that graph is null
+    if (this.graph == null)
+      return;
+
+    this.dangles = this.graph.deleteDangles();
+    this.cutEdges = this.graph.deleteCutEdges();
+    var edgeRingList = this.graph.getEdgeRings();
+
+    var validEdgeRingList = new ArrayList();
+    this.invalidRingLines = new ArrayList();
+    this.findValidRings(edgeRingList, validEdgeRingList, this.invalidRingLines);
+
+    this.findShellsAndHoles(validEdgeRingList);
+    Polygonizer.assignHolesToShells(this.holeList, this.shellList);
+
+    this.polyList = new ArrayList();
+    for (var i = this.shellList.iterator(); i.hasNext();) {
+      var er = i.next();
+      this.polyList.add(er.getPolygon());
+    }
+  };
+
+  /**
+   * @private
+   */
+  Polygonizer.prototype.findValidRings = function(edgeRingList,
+      validEdgeRingList, invalidRingList) {
+    for (var i = edgeRingList.iterator(); i.hasNext();) {
+      var er = i.next();
+      if (er.isValid())
+        validEdgeRingList.add(er);
+      else
+        invalidRingList.add(er.getLineString());
+    }
+  };
+
+  /**
+   * @private
+   */
+  Polygonizer.prototype.findShellsAndHoles = function(edgeRingList) {
+    this.holeList = new ArrayList();
+    this.shellList = new ArrayList();
+    for (var i = edgeRingList.iterator(); i.hasNext();) {
+      var er = i.next();
+      if (er.isHole())
+        this.holeList.add(er);
+      else
+        this.shellList.add(er);
+    }
+  };
+
+  /**
+   * @private
+   */
+  Polygonizer.assignHolesToShells = function(holeList, shellList) {
+    for (var i = holeList.iterator(); i.hasNext();) {
+      var holeER = i.next();
+      Polygonizer.assignHoleToShell(holeER, shellList);
+    }
+  };
+
+  /**
+   * @private
+   */
+  Polygonizer.assignHoleToShell = function(holeER, shellList) {
+    var shell = EdgeRing.findEdgeRingContaining(holeER, shellList);
+    if (shell != null)
+      shell.addHole(holeER.getRing());
+  };
+
+
+  jsts.operation.polygonize.Polygonizer = Polygonizer;
+
+})();

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

@@ -0,0 +1,140 @@
+/* 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/util/Assert.js
+   */
+
+  var ArrayList = javascript.util.ArrayList;
+
+
+  /**
+   * An EdgeEndBuilder creates EdgeEnds for all the "split edges" created by the
+   * intersections determined for an Edge.
+   *
+   * Computes the {@link EdgeEnd}s which arise from a noded {@link Edge}.
+   *
+   * @constructor
+   */
+  jsts.operation.relate.EdgeEndBuilder = function() {
+
+  };
+
+
+  jsts.operation.relate.EdgeEndBuilder.prototype.computeEdgeEnds = function(edges) {
+    if (arguments.length == 2) {
+      this.computeEdgeEnds2.apply(this, arguments);
+      return;
+    }
+
+    var l = new ArrayList();
+    for (var i = edges; i.hasNext();) {
+      var e = i.next();
+      this.computeEdgeEnds2(e, l);
+    }
+    return l;
+  };
+
+
+  /**
+   * Creates stub edges for all the intersections in this Edge (if any) and
+   * inserts them into the graph.
+   */
+  jsts.operation.relate.EdgeEndBuilder.prototype.computeEdgeEnds2 = function(edge, l) {
+    var eiList = edge.getEdgeIntersectionList();
+    // ensure that the list has entries for the first and last point of the edge
+    eiList.addEndpoints();
+
+    var it = eiList.iterator();
+    var eiPrev = null;
+    var eiCurr = null;
+    // no intersections, so there is nothing to do
+    if (!it.hasNext())
+      return;
+    var eiNext = it.next();
+    do {
+      eiPrev = eiCurr;
+      eiCurr = eiNext;
+      eiNext = null;
+      if (it.hasNext())
+        eiNext = it.next();
+
+      if (eiCurr !== null) {
+        this.createEdgeEndForPrev(edge, l, eiCurr, eiPrev);
+        this.createEdgeEndForNext(edge, l, eiCurr, eiNext);
+      }
+
+    } while (eiCurr !== null);
+  };
+
+
+  /**
+   * Create a EdgeStub for the edge before the intersection eiCurr. The previous
+   * intersection is provided in case it is the endpoint for the stub edge.
+   * Otherwise, the previous point from the parent edge will be the endpoint.
+   * <br>
+   * eiCurr will always be an EdgeIntersection, but eiPrev may be null.
+   *
+   * @private
+   */
+  jsts.operation.relate.EdgeEndBuilder.prototype.createEdgeEndForPrev = function(edge, l, eiCurr,
+      eiPrev) {
+
+    var iPrev = eiCurr.segmentIndex;
+    if (eiCurr.dist === 0.0) {
+      // if at the start of the edge there is no previous edge
+      if (iPrev === 0)
+        return;
+      iPrev--;
+    }
+    var pPrev = edge.getCoordinate(iPrev);
+    // if prev intersection is past the previous vertex, use it instead
+    if (eiPrev !== null && eiPrev.segmentIndex >= iPrev)
+      pPrev = eiPrev.coord;
+
+    var label = new jsts.geomgraph.Label(edge.getLabel());
+    // since edgeStub is oriented opposite to it's parent edge, have to flip
+    // sides
+    // for edge label
+    label.flip();
+    var e = new jsts.geomgraph.EdgeEnd(edge, eiCurr.coord, pPrev, label);
+    // e.print(System.out); System.out.println();
+    l.add(e);
+  };
+
+
+  /**
+   * Create a StubEdge for the edge after the intersection eiCurr. The next
+   * intersection is provided in case it is the endpoint for the stub edge.
+   * Otherwise, the next point from the parent edge will be the endpoint. <br>
+   * eiCurr will always be an EdgeIntersection, but eiNext may be null.
+   *
+   * @private
+   */
+  jsts.operation.relate.EdgeEndBuilder.prototype.createEdgeEndForNext = function(edge, l, eiCurr,
+      eiNext) {
+
+    var iNext = eiCurr.segmentIndex + 1;
+    // if there is no next edge there is nothing to do
+    if (iNext >= edge.getNumPoints() && eiNext === null)
+      return;
+
+    var pNext = edge.getCoordinate(iNext);
+
+    // if the next intersection is in the same segment as the current, use it as
+    // the endpoint
+    if (eiNext !== null && eiNext.segmentIndex === eiCurr.segmentIndex)
+      pNext = eiNext.coord;
+
+    var e = new jsts.geomgraph.EdgeEnd(edge, eiCurr.coord, pNext,
+        new jsts.geomgraph.Label(edge.getLabel()));
+    l.add(e);
+  };
+
+
+})();

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

@@ -0,0 +1,183 @@
+/* Copyright (c) 2011 by The Authors.
+
+/**
+ * @requires jsts/geomgraph/EdgeEnd.js
+ */
+
+
+
+/**
+ * A collection of {@link EdgeEnd}s which obey the following invariant:
+ * They originate at the same node and have the same direction.
+ *
+ * @augments {jsts.geomgraph.EdgeEnd}
+ * @constructor
+ */
+jsts.operation.relate.EdgeEndBundle = function() {
+  this.edgeEnds = [];
+
+  var e = arguments[0] instanceof jsts.geomgraph.EdgeEnd ? arguments[0] : arguments[1];
+
+  var edge = e.getEdge();
+  var coord = e.getCoordinate();
+  var dirCoord = e.getDirectedCoordinate();
+  var label = new jsts.geomgraph.Label(e.getLabel());
+
+  jsts.geomgraph.EdgeEnd.call(this, edge, coord,
+      dirCoord, label);
+
+  this.insert(e);
+};
+
+jsts.operation.relate.EdgeEndBundle.prototype = new jsts.geomgraph.EdgeEnd();
+
+
+/**
+ * @private
+ */
+jsts.operation.relate.EdgeEndBundle.prototype.edgeEnds = null;
+
+
+
+jsts.operation.relate.EdgeEndBundle.prototype.getLabel = function() {
+  return this.label;
+};
+jsts.operation.relate.EdgeEndBundle.prototype.getEdgeEnds = function() {
+  return this.edgeEnds;
+};
+
+jsts.operation.relate.EdgeEndBundle.prototype.insert = function(e) {
+  // Assert: start point is the same
+  // Assert: direction is the same
+  this.edgeEnds.push(e);
+};
+
+
+/**
+ * This computes the overall edge label for the set of edges in this
+ * EdgeStubBundle. It essentially merges the ON and side labels for each edge.
+ * These labels must be compatible
+ */
+jsts.operation.relate.EdgeEndBundle.prototype.computeLabel = function(
+    boundaryNodeRule) {
+  // create the label. If any of the edges belong to areas,
+  // the label must be an area label
+  var isArea = false;
+  for (var i = 0; i < this.edgeEnds.length; i++) {
+    var e = this.edgeEnds[i];
+    if (e.getLabel().isArea())
+      isArea = true;
+  }
+  if (isArea)
+    this.label = new jsts.geomgraph.Label(jsts.geom.Location.NONE, jsts.geom.Location.NONE,
+        jsts.geom.Location.NONE);
+  else
+    this.label = new jsts.geomgraph.Label(jsts.geom.Location.NONE);
+
+  // compute the On label, and the side labels if present
+  for (var i = 0; i < 2; i++) {
+    this.computeLabelOn(i, boundaryNodeRule);
+    if (isArea)
+      this.computeLabelSides(i);
+  }
+};
+
+
+/**
+ * Compute the overall ON location for the list of EdgeStubs. (This is
+ * essentially equivalent to computing the self-overlay of a single Geometry)
+ * edgeStubs can be either on the boundary (eg Polygon edge) OR in the interior
+ * (e.g. segment of a LineString) of their parent Geometry. In addition,
+ * GeometryCollections use a {@link BoundaryNodeRule} to determine whether a
+ * segment is on the boundary or not. Finally, in GeometryCollections it can
+ * occur that an edge is both on the boundary and in the interior (e.g. a
+ * LineString segment lying on top of a Polygon edge.) In this case the Boundary
+ * is given precendence. <br>
+ * These observations result in the following rules for computing the ON
+ * location:
+ * <ul>
+ * <li> if there are an odd number of Bdy edges, the attribute is Bdy
+ * <li> if there are an even number >= 2 of Bdy edges, the attribute is Int
+ * <li> if there are any Int edges, the attribute is Int
+ * <li> otherwise, the attribute is NULL.
+ * </ul>
+ *
+ * @private
+ */
+jsts.operation.relate.EdgeEndBundle.prototype.computeLabelOn = function(
+    geomIndex, boundaryNodeRule) {
+  // compute the ON location value
+  var boundaryCount = 0;
+  var foundInterior = false;
+
+  for (var i = 0; i < this.edgeEnds.length; i++) {
+    var e = this.edgeEnds[i];
+    var loc = e.getLabel().getLocation(geomIndex);
+    if (loc == jsts.geom.Location.BOUNDARY)
+      boundaryCount++;
+    if (loc == jsts.geom.Location.INTERIOR)
+      foundInterior = true;
+  }
+  var loc = jsts.geom.Location.NONE;
+  if (foundInterior)
+    loc = jsts.geom.Location.INTERIOR;
+  if (boundaryCount > 0) {
+    loc = jsts.geomgraph.GeometryGraph.determineBoundary(boundaryNodeRule,
+        boundaryCount);
+  }
+  this.label.setLocation(geomIndex, loc);
+
+};
+
+
+/**
+ * Compute the labelling for each side
+ *
+ * @private
+ */
+jsts.operation.relate.EdgeEndBundle.prototype.computeLabelSides = function(
+    geomIndex) {
+  this.computeLabelSide(geomIndex, jsts.geomgraph.Position.LEFT);
+  this.computeLabelSide(geomIndex, jsts.geomgraph.Position.RIGHT);
+};
+
+
+/**
+ * To compute the summary label for a side, the algorithm is: FOR all edges IF
+ * any edge's location is INTERIOR for the side, side location = INTERIOR ELSE
+ * IF there is at least one EXTERIOR attribute, side location = EXTERIOR ELSE
+ * side location = NULL <br>
+ * Note that it is possible for two sides to have apparently contradictory
+ * information i.e. one edge side may indicate that it is in the interior of a
+ * geometry, while another edge side may indicate the exterior of the same
+ * geometry. This is not an incompatibility - GeometryCollections may contain
+ * two Polygons that touch along an edge. This is the reason for
+ * Interior-primacy rule above - it results in the summary label having the
+ * Geometry interior on <b>both</b> sides.
+ *
+ * @private
+ */
+jsts.operation.relate.EdgeEndBundle.prototype.computeLabelSide = function(
+    geomIndex, side) {
+  for (var i = 0; i < this.edgeEnds.length; i++) {
+    var e = this.edgeEnds[i];
+    if (e.getLabel().isArea()) {
+      var loc = e.getLabel().getLocation(geomIndex, side);
+      if (loc === jsts.geom.Location.INTERIOR) {
+        this.label.setLocation(geomIndex, side, jsts.geom.Location.INTERIOR);
+        return;
+      } else if (loc === jsts.geom.Location.EXTERIOR)
+        this.label.setLocation(geomIndex, side, jsts.geom.Location.EXTERIOR);
+    }
+  }
+};
+
+
+/**
+ * Update the IM with the contribution for the computed label for the EdgeStubs.
+ *
+ * @private
+ */
+jsts.operation.relate.EdgeEndBundle.prototype.updateIM = function(im) {
+  jsts.geomgraph.Edge.updateIM(this.label, im);
+};