jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/operation/valid/ConnectedInteriorTester.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.
+ */
+
+/**
+ * This class tests that the interior of an area {@link Geometry} (
+ * {@link Polygon} or {@link MultiPolygon} ) is connected. This can happen if:
+ * <ul>
+ * <li>a shell self-intersects
+ * <li>one or more holes form a connected chain touching a shell at two
+ * different points
+ * <li>one or more holes form a ring around a subset of the interior
+ * </ul>
+ * If a disconnected situation is found the location of the problem is recorded.
+ *
+ * @version 1.7
+ * @constructor
+ */
+jsts.operation.valid.ConnectedInteriorTester = function(geomGraph) {
+  this.geomGraph = geomGraph;
+  this.geometryFactory = new jsts.geom.GeometryFactory();
+
+  // save a coordinate for any disconnected interior found
+  // the coordinate will be somewhere on the ring surrounding the disconnected
+  // interior
+  this.disconnectedRingcoord = null;
+};
+
+/**
+ * @param {jsts.geom.Coordinate[]}
+ *          coord A coordinate array.
+ * @param {jsts.geom.Coordinate}
+ *          pt
+ * @return {jsts.geom.Coordinate}
+ */
+jsts.operation.valid.ConnectedInteriorTester.findDifferentPoint = function(
+    coord, pt) {
+  var i = 0, il = coord.length;
+  for (i; i < il; i++) {
+    if (!coord[i].equals(pt))
+      return coord[i];
+  }
+  return null;
+};
+
+/**
+ * Returns the coordinate for a disconnected interior
+ *
+ * @return {jsts.geom.Coordinate} the coordinate.
+ */
+jsts.operation.valid.ConnectedInteriorTester.prototype.getCoordinate = function() {
+  return this.disconnectedRingcoord;
+};
+
+/**
+ * @return {Boolean}
+ */
+jsts.operation.valid.ConnectedInteriorTester.prototype.isInteriorsConnected = function() {
+  // node the edges, in case holes touch the shell
+  var splitEdges = new javascript.util.ArrayList();
+  this.geomGraph.computeSplitEdges(splitEdges);
+
+  // form the edges into rings
+  var graph = new jsts.geomgraph.PlanarGraph(
+      new jsts.operation.overlay.OverlayNodeFactory());
+  graph.addEdges(splitEdges);
+
+  this.setInteriorEdgesInResult(graph);
+  graph.linkResultDirectedEdges();
+
+  var edgeRings = this.buildEdgeRings(graph.getEdgeEnds());
+
+  /**
+   *
+   * Mark all the edges for the edgeRings corresponding to the shells
+   *
+   * of the input polygons. Note only ONE ring gets marked for each shell.
+   *
+   */
+
+  this.visitShellInteriors(this.geomGraph.getGeometry(), graph);
+
+
+  /**
+   *
+   * If there are any unvisited shell edges
+   *
+   * (i.e. a ring which is not a hole and which has the interior
+   *
+   * of the parent area on the RHS)
+   *
+   * this means that one or more holes must have split the interior of the
+   *
+   * polygon into at least two pieces. The polygon is thus invalid.
+   *
+   */
+
+  return !this.hasUnvisitedShellEdge(edgeRings);
+};
+
+jsts.operation.valid.ConnectedInteriorTester.prototype.setInteriorEdgesInResult = function(
+    graph) {
+  var it = graph.getEdgeEnds().iterator(), de;
+
+  while (it.hasNext()) {
+    de = it.next();
+    if (de.getLabel().getLocation(0, jsts.geomgraph.Position.RIGHT) == jsts.geom.Location.INTERIOR) {
+      de.setInResult(true);
+    }
+  }
+};
+
+/**
+ *
+ * Form DirectedEdges in graph into Minimal EdgeRings. (Minimal Edgerings must
+ * be used, because only they are guaranteed to provide a correct isHole
+ * computation)
+ *
+ */
+jsts.operation.valid.ConnectedInteriorTester.prototype.buildEdgeRings = function(
+    dirEdges) {
+  var edgeRings = new javascript.util.ArrayList();
+  for (var it = dirEdges.iterator(); it.hasNext();) {
+
+    var de = it.next();
+
+    // if this edge has not yet been processed
+    if (de.isInResult()
+
+    && de.getEdgeRing() == null) {
+
+      var er = new jsts.operation.overlay.MaximalEdgeRing(de,
+          this.geometryFactory);
+      er.linkDirectedEdgesForMinimalEdgeRings();
+
+      var minEdgeRings = er.buildMinimalRings();
+
+      var i = 0, il = minEdgeRings.length;
+      for (i; i < il; i++) {
+        edgeRings.add(minEdgeRings[i]);
+      }
+    }
+  }
+
+  return edgeRings;
+};
+
+/**
+ *
+ * Mark all the edges for the edgeRings corresponding to the shells of the input
+ * polygons. Only ONE ring gets marked for each shell - if there are others
+ * which remain unmarked this indicates a disconnected interior.
+ *
+ */
+jsts.operation.valid.ConnectedInteriorTester.prototype.visitShellInteriors = function(
+    g, graph) {
+  if (g instanceof jsts.geom.Polygon) {
+    var p = g;
+    this.visitInteriorRing(p.getExteriorRing(), graph);
+  }
+
+  if (g instanceof jsts.geom.MultiPolygon) {
+    var mp = g;
+    for (var i = 0; i < mp.getNumGeometries(); i++) {
+      var p = mp.getGeometryN(i);
+      this.visitInteriorRing(p.getExteriorRing(), graph);
+    }
+  }
+};
+
+jsts.operation.valid.ConnectedInteriorTester.prototype.visitInteriorRing = function(
+    ring, graph) {
+
+  var pts = ring.getCoordinates();
+  var pt0 = pts[0];
+
+  /**
+   *
+   * Find first point in coord list different to initial point. Need special
+   * check since the first point may be repeated.
+   *
+   */
+  var pt1 = jsts.operation.valid.ConnectedInteriorTester.findDifferentPoint(
+      pts, pt0);
+  var e = graph.findEdgeInSameDirection(pt0, pt1);
+  var de = graph.findEdgeEnd(e);
+  var intDe = null;
+
+  if (de.getLabel().getLocation(0, jsts.geomgraph.Position.RIGHT) == jsts.geom.Location.INTERIOR) {
+    intDe = de;
+  } else if (de.getSym().getLabel().getLocation(0,
+      jsts.geomgraph.Position.RIGHT) == jsts.geom.Location.INTERIOR) {
+    intDe = de.getSym();
+  }
+
+  this.visitLinkedDirectedEdges(intDe);
+};
+
+jsts.operation.valid.ConnectedInteriorTester.prototype.visitLinkedDirectedEdges = function(
+    start) {
+  var startDe = start;
+  var de = start;
+  do {
+    de.setVisited(true);
+    de = de.getNext();
+  } while (de != startDe);
+};
+
+/**
+ *
+ * Check if any shell ring has an unvisited edge. A shell ring is a ring which
+ * is not a hole and which has the interior of the parent area on the RHS. (Note
+ * that there may be non-hole rings with the interior on the LHS, since the
+ * interior of holes will also be polygonized into CW rings by the
+ * linkAllDirectedEdges() step)
+ *
+ * @return {Boolean} true if there is an unvisited edge in a non-hole ring.
+ */
+
+jsts.operation.valid.ConnectedInteriorTester.prototype.hasUnvisitedShellEdge = function(
+    edgeRings) {
+  for (var i = 0; i < edgeRings.size(); i++) {
+    var er = edgeRings.get(i);
+
+    // don't check hole rings
+    if (er.isHole()) {
+      continue;
+    }
+
+    var edges = er.getEdges();
+    var de = edges[0];
+
+    // don't check CW rings which are holes
+    // (MD - this check may now be irrelevant)
+    if (de.getLabel().getLocation(0, jsts.geomgraph.Position.RIGHT) != jsts.geom.Location.INTERIOR) {
+      continue;
+    }
+
+    /**
+     *
+     * the edgeRing is CW ring which surrounds the INT of the area, so check all
+     *
+     * edges have been visited. If any are unvisited, this is a disconnected
+     * part of the interior
+     *
+     */
+
+    for (var j = 0; j < edges.length; j++) {
+      de = edges[j];
+      if (!de.isVisited()) {
+        disconnectedRingcoord = de.getCoordinate();
+        return true;
+      }
+    }
+  }
+  return false;
+};

data/vendor/assets/javascripts/jsts/operation/valid/ConsistentAreaTester.js

@@ -0,0 +1,127 @@
+/* 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.
+ */
+
+/**
+ * Checks that a {@link GeometryGraph} representing an area
+ * (a {@link Polygon} or {@link MultiPolygon} )
+ * has consistent semantics for area geometries.
+ * This check is required for any reasonable polygonal model
+ * (including the OGC-SFS model, as well as models which allow ring self-intersection at single points)
+ * <p>
+ * Checks include:
+ * <ul>
+ * <li>test for rings which properly intersect
+ * (but not for ring self-intersection, or intersections at vertices)
+ * <li>test for consistent labelling at all node points
+ * (this detects vertex intersections with invalid topology,
+ * i.e. where the exterior side of an edge lies in the interior of the area)
+ * <li>test for duplicate rings
+ * </ul>
+ * If an inconsistency is found the location of the problem
+ * is recorded and is available to the caller.
+ *
+ * @version 1.7
+ */
+
+
+/**
+ *
+ * Creates a new tester for consistent areas.
+ *
+ *
+ *
+ * @param geomGraph
+ *          the topology graph of the area geometry.
+ *
+ */
+jsts.operation.valid.ConsistentAreaTester = function(geomGraph) {
+  this.geomGraph = geomGraph;
+  this.li = new jsts.algorithm.RobustLineIntersector();
+  this.nodeGraph = new jsts.operation.relate.RelateNodeGraph();
+  this.invalidPoint = null;
+};
+
+/**
+ *
+ * @return the intersection point, or <code>null</code> if none was found.
+ *
+ */
+jsts.operation.valid.ConsistentAreaTester.prototype.getInvalidPoint = function() {
+  return this.invalidPoint;
+};
+
+/**
+ *
+ * Check all nodes to see if their labels are consistent with area topology.
+ *
+ * @return <code>true</code> if this area has a consistent node labelling.
+ *
+ */
+jsts.operation.valid.ConsistentAreaTester.prototype.isNodeConsistentArea = function() {
+  /**
+   *
+   * To fully check validity, it is necessary to compute ALL intersections,
+   * including self-intersections within a single edge.
+   *
+   */
+  var intersector = this.geomGraph.computeSelfNodes(this.li, true);
+  if (intersector.hasProperIntersection()) {
+    this.invalidPoint = intersector.getProperIntersectionPoint();
+    return false;
+  }
+
+  this.nodeGraph.build(this.geomGraph);
+  return this.isNodeEdgeAreaLabelsConsistent();
+};
+
+/**
+ *
+ * Check all nodes to see if their labels are consistent. If any are not, return
+ * false
+ *
+ * @return <code>true</code> if the edge area labels are consistent at this
+ *         node.
+ *
+ */
+jsts.operation.valid.ConsistentAreaTester.prototype.isNodeEdgeAreaLabelsConsistent = function() {
+  for (var nodeIt = this.nodeGraph.getNodeIterator(); nodeIt.hasNext();) {
+    var node = nodeIt.next();
+    if (!node.getEdges().isAreaLabelsConsistent(this.geomGraph)) {
+      this.invalidPoint = node.getCoordinate().clone();
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ *
+ * Checks for two duplicate rings in an area. Duplicate rings are rings that are
+ * topologically equal (that is, which have the same sequence of points up to
+ * point order). If the area is topologically consistent (determined by calling
+ * the <code>isNodeConsistentArea</code>, duplicate rings can be found by
+ * checking for EdgeBundles which contain more than one EdgeEnd. (This is
+ * because topologically consistent areas cannot have two rings sharing the same
+ * line segment, unless the rings are equal). The start point of one of the
+ * equal rings will be placed in invalidPoint.
+ *
+ * @return true if this area Geometry is topologically consistent but has two
+ *         duplicate rings.
+ *
+ */
+jsts.operation.valid.ConsistentAreaTester.prototype.hasDuplicateRings = function() {
+  for (var nodeIt = this.nodeGraph.getNodeIterator(); nodeIt.hasNext();) {
+    var node = nodeIt.next();
+    for (var i = node.getEdges().iterator(); i.hasNext();) {
+      var eeb = i.next();
+      if (eeb.getEdgeEnds().length > 1) {
+        invalidPoint = eeb.getEdge().getCoordinate(0);
+        return true;
+      }
+    }
+  }
+  return false;
+};

data/vendor/assets/javascripts/jsts/operation/valid/IndexedNestedRingTester.js

@@ -0,0 +1,89 @@
+/* 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.
+ */
+
+/**
+ *
+ * Tests whether any of a set of {@link LinearRing}s are nested inside another
+ * ring in the set, using a spatial index to speed up the comparisons.
+ *
+ * @version 1.7
+ */
+
+jsts.operation.valid.IndexedNestedRingTester = function(graph) {
+  this.graph = graph;
+  this.rings = new javascript.util.ArrayList();
+  this.totalEnv = new jsts.geom.Envelope();
+  this.index = null;
+  this.nestedPt = null;
+};
+
+jsts.operation.valid.IndexedNestedRingTester.prototype.getNestedPoint = function() {
+  return this.nestedPt;
+};
+
+jsts.operation.valid.IndexedNestedRingTester.prototype.add = function(ring) {
+  this.rings.add(ring);
+  this.totalEnv.expandToInclude(ring.getEnvelopeInternal());
+};
+
+jsts.operation.valid.IndexedNestedRingTester.prototype.isNonNested = function() {
+  this.buildIndex();
+  for (var i = 0; i < this.rings.size(); i++) {
+    var innerRing = this.rings.get(i);
+    var innerRingPts = innerRing.getCoordinates();
+    var results = this.index.query(innerRing.getEnvelopeInternal());
+
+    for (var j = 0; j < results.length; j++) {
+      var searchRing = results[j];
+      var searchRingPts = searchRing.getCoordinates();
+
+      if (innerRing == searchRing) {
+        continue;
+      }
+
+      if (!innerRing.getEnvelopeInternal().intersects(
+          searchRing.getEnvelopeInternal())) {
+        continue;
+      }
+
+      var innerRingPt = jsts.operation.valid.IsValidOp.findPtNotNode(
+          innerRingPts, searchRing, this.graph);
+
+      /**
+       *
+       * If no non-node pts can be found, this means that the searchRing touches
+       * ALL of the innerRing vertices. This indicates an invalid polygon, since
+       * either the two holes create a disconnected interior, or they touch in
+       * an infinite number of points (i.e. along a line segment). Both of these
+       * cases are caught by other tests, so it is safe to simply skip this
+       * situation here.
+       */
+
+      if (innerRingPt == null) {
+        continue;
+      }
+
+      var isInside = jsts.algorithm.CGAlgorithms.isPointInRing(innerRingPt,
+          searchRingPts);
+
+      if (isInside) {
+        this.nestedPt = innerRingPt;
+        return false;
+      }
+    }
+  }
+  return true;
+};
+
+jsts.operation.valid.IndexedNestedRingTester.prototype.buildIndex = function() {
+  this.index = new jsts.index.strtree.STRtree();
+
+  for (var i = 0; i < this.rings.size(); i++) {
+    var ring = this.rings.get(i);
+    var env = ring.getEnvelopeInternal();
+    this.index.insert(env, ring);
+  }
+};