jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/geomgraph/EdgeEndStar.js

@@ -0,0 +1,322 @@
+/* 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/geom/Location.js
+ */
+
+
+
+/**
+ * A EdgeEndStar is an ordered list of EdgeEnds around a node. They are
+ * maintained in CCW order (starting with the positive x-axis) around the node
+ * for efficient lookup and topology building.
+ *
+ * @constructor
+ */
+jsts.geomgraph.EdgeEndStar = function() {
+  this.edgeMap = new javascript.util.TreeMap();
+  this.edgeList = null;
+  this.ptInAreaLocation = [jsts.geom.Location.NONE, jsts.geom.Location.NONE];
+};
+
+
+/**
+ * A map which maintains the edges in sorted order around the node
+ *
+ * NOTE: In In JSTS a JS object replaces TreeMap. Sorting is done when needed.
+ *
+ * @protected
+ */
+jsts.geomgraph.EdgeEndStar.prototype.edgeMap = null;
+
+
+/**
+ * A list of all outgoing edges in the result, in CCW order
+ *
+ * @protected
+ */
+jsts.geomgraph.EdgeEndStar.prototype.edgeList = null;
+
+
+/**
+ * The location of the point for this star in Geometry i Areas
+ *
+ * @private
+ */
+jsts.geomgraph.EdgeEndStar.prototype.ptInAreaLocation = null;
+
+
+/**
+ * Insert a EdgeEnd into this EdgeEndStar
+ */
+jsts.geomgraph.EdgeEndStar.prototype.insert = function(e) {
+  throw new jsts.error.AbstractMethodInvocationError();
+};
+
+
+/**
+ * Insert an EdgeEnd into the map, and clear the edgeList cache, since the list
+ * of edges has now changed
+ *
+ * @protected
+ */
+jsts.geomgraph.EdgeEndStar.prototype.insertEdgeEnd = function(e, obj) {
+  this.edgeMap.put(e, obj);
+  this.edgeList = null; // edge list has changed - clear the cache
+};
+
+
+/**
+ * @return the coordinate for the node this star is based at.
+ */
+jsts.geomgraph.EdgeEndStar.prototype.getCoordinate = function() {
+  var it = this.iterator();
+  if (!it.hasNext())
+    return null;
+  var e = it.next();
+  return e.getCoordinate();
+};
+jsts.geomgraph.EdgeEndStar.prototype.getDegree = function() {
+  return this.edgeMap.size();
+};
+
+
+/**
+ * Iterator access to the ordered list of edges is optimized by copying the map
+ * collection to a list. (This assumes that once an iterator is requested, it is
+ * likely that insertion into the map is complete).
+ */
+jsts.geomgraph.EdgeEndStar.prototype.iterator = function() {
+  return this.getEdges().iterator();
+};
+
+jsts.geomgraph.EdgeEndStar.prototype.getEdges = function() {
+  if (this.edgeList === null) {
+    this.edgeList = new javascript.util.ArrayList(this.edgeMap.values());
+  }
+  return this.edgeList;
+};
+
+jsts.geomgraph.EdgeEndStar.prototype.getNextCW = function(ee) {
+  this.getEdges();
+  var i = this.edgeList.indexOf(ee);
+  var iNextCW = i - 1;
+  if (i === 0)
+    iNextCW = this.edgeList.length - 1;
+  return this.edgeList[iNextCW];
+};
+
+jsts.geomgraph.EdgeEndStar.prototype.computeLabelling = function(geomGraph) {
+  this.computeEdgeEndLabels(geomGraph[0].getBoundaryNodeRule());
+  this.propagateSideLabels(0);
+  this.propagateSideLabels(1);
+
+  /**
+   * If there are edges that still have null labels for a geometry this must be
+   * because there are no area edges for that geometry incident on this node. In
+   * this case, to label the edge for that geometry we must test whether the
+   * edge is in the interior of the geometry. To do this it suffices to
+   * determine whether the node for the edge is in the interior of an area. If
+   * so, the edge has location INTERIOR for the geometry. In all other cases
+   * (e.g. the node is on a line, on a point, or not on the geometry at all) the
+   * edge has the location EXTERIOR for the geometry.
+   * <p>
+   * Note that the edge cannot be on the BOUNDARY of the geometry, since then
+   * there would have been a parallel edge from the Geometry at this node also
+   * labelled BOUNDARY and this edge would have been labelled in the previous
+   * step.
+   * <p>
+   * This code causes a problem when dimensional collapses are present, since it
+   * may try and determine the location of a node where a dimensional collapse
+   * has occurred. The point should be considered to be on the EXTERIOR of the
+   * polygon, but locate() will return INTERIOR, since it is passed the original
+   * Geometry, not the collapsed version.
+   *
+   * If there are incident edges which are Line edges labelled BOUNDARY, then
+   * they must be edges resulting from dimensional collapses. In this case the
+   * other edges can be labelled EXTERIOR for this Geometry.
+   *
+   * MD 8/11/01 - NOT TRUE! The collapsed edges may in fact be in the interior
+   * of the Geometry, which means the other edges should be labelled INTERIOR
+   * for this Geometry. Not sure how solve this... Possibly labelling needs to
+   * be split into several phases: area label propagation, symLabel merging,
+   * then finally null label resolution.
+   */
+  var hasDimensionalCollapseEdge = [false, false];
+  for (var it = this.iterator(); it.hasNext();) {
+    var e = it.next();
+    var label = e.getLabel();
+    for (var geomi = 0; geomi < 2; geomi++) {
+      if (label.isLine(geomi) &&
+          label.getLocation(geomi) === jsts.geom.Location.BOUNDARY)
+        hasDimensionalCollapseEdge[geomi] = true;
+    }
+  }
+  for (var it = this.iterator(); it.hasNext();) {
+    var e = it.next();
+    var label = e.getLabel();
+    for (var geomi = 0; geomi < 2; geomi++) {
+      if (label.isAnyNull(geomi)) {
+        var loc = jsts.geom.Location.NONE;
+        if (hasDimensionalCollapseEdge[geomi]) {
+          loc = jsts.geom.Location.EXTERIOR;
+        } else {
+          var p = e.getCoordinate();
+          loc = this.getLocation(geomi, p, geomGraph);
+        }
+        label.setAllLocationsIfNull(geomi, loc);
+      }
+    }
+  }
+};
+
+
+/**
+ * @private
+ */
+jsts.geomgraph.EdgeEndStar.prototype.computeEdgeEndLabels = function(
+    boundaryNodeRule) {
+  // Compute edge label for each EdgeEnd
+  for (var it = this.iterator(); it.hasNext();) {
+    var ee = it.next();
+    ee.computeLabel(boundaryNodeRule);
+  }
+};
+
+
+/**
+ * @private
+ */
+jsts.geomgraph.EdgeEndStar.prototype.getLocation = function(geomIndex, p, geom) {
+  // compute location only on demand
+  if (this.ptInAreaLocation[geomIndex] === jsts.geom.Location.NONE) {
+    this.ptInAreaLocation[geomIndex] = jsts.algorithm.locate.SimplePointInAreaLocator
+        .locate(p, geom[geomIndex].getGeometry());
+  }
+  return this.ptInAreaLocation[geomIndex];
+};
+
+jsts.geomgraph.EdgeEndStar.prototype.isAreaLabelsConsistent = function(
+    geomGraph) {
+  this.computeEdgeEndLabels(geomGraph.getBoundaryNodeRule());
+  return this.checkAreaLabelsConsistent(0);
+};
+
+
+/**
+ * @private
+ */
+jsts.geomgraph.EdgeEndStar.prototype.checkAreaLabelsConsistent = function(
+    geomIndex) {
+  // Since edges are stored in CCW order around the node,
+  // As we move around the ring we move from the right to the left side of the
+  // edge
+  var edges = this.getEdges();
+  // if no edges, trivially consistent
+  if (edges.size() <= 0)
+    return true;
+  // initialize startLoc to location of last L side (if any)
+  var lastEdgeIndex = edges.size() - 1;
+  var startLabel = edges.get(lastEdgeIndex).getLabel();
+  var startLoc = startLabel
+      .getLocation(geomIndex, jsts.geomgraph.Position.LEFT);
+  jsts.util.Assert.isTrue(startLoc != jsts.geom.Location.NONE,
+      'Found unlabelled area edge');
+
+  var currLoc = startLoc;
+  for (var it = this.iterator(); it.hasNext();) {
+    var e = it.next();
+    var label = e.getLabel();
+    // we assume that we are only checking a area
+    jsts.util.Assert.isTrue(label.isArea(geomIndex), 'Found non-area edge');
+    var leftLoc = label.getLocation(geomIndex, jsts.geomgraph.Position.LEFT);
+    var rightLoc = label.getLocation(geomIndex, jsts.geomgraph.Position.RIGHT);
+    // check that edge is really a boundary between inside and outside!
+    if (leftLoc === rightLoc) {
+      return false;
+    }
+
+    if (rightLoc !== currLoc) {
+      return false;
+    }
+    currLoc = leftLoc;
+  }
+  return true;
+};
+
+
+/**
+ * @private
+ */
+jsts.geomgraph.EdgeEndStar.prototype.propagateSideLabels = function(geomIndex) {
+  // Since edges are stored in CCW order around the node,
+  // As we move around the ring we move from the right to the left side of the
+  // edge
+  var startLoc = jsts.geom.Location.NONE;
+
+  // initialize loc to location of last L side (if any)
+  for (var it = this.iterator(); it.hasNext();) {
+    var e = it.next();
+    var label = e.getLabel();
+    if (label.isArea(geomIndex) &&
+        label.getLocation(geomIndex, jsts.geomgraph.Position.LEFT) !== jsts.geom.Location.NONE)
+      startLoc = label.getLocation(geomIndex, jsts.geomgraph.Position.LEFT);
+  }
+
+  // no labelled sides found, so no labels to propagate
+  if (startLoc === jsts.geom.Location.NONE)
+    return;
+
+  var currLoc = startLoc;
+  for (var it = this.iterator(); it.hasNext();) {
+    var e = it.next();
+    var label = e.getLabel();
+    // set null ON values to be in current location
+    if (label.getLocation(geomIndex, jsts.geomgraph.Position.ON) === jsts.geom.Location.NONE)
+      label.setLocation(geomIndex, jsts.geomgraph.Position.ON, currLoc);
+    // set side labels (if any)
+    if (label.isArea(geomIndex)) {
+      var leftLoc = label.getLocation(geomIndex, jsts.geomgraph.Position.LEFT);
+      var rightLoc = label
+          .getLocation(geomIndex, jsts.geomgraph.Position.RIGHT);
+      // if there is a right location, that is the next location to propagate
+      if (rightLoc !== jsts.geom.Location.NONE) {
+        if (rightLoc !== currLoc)
+          throw new jsts.error.TopologyError('side location conflict', e
+              .getCoordinate());
+        if (leftLoc === jsts.geom.Location.NONE) {
+          jsts.util.Assert.shouldNeverReachHere('found single null side (at ' +
+              e.getCoordinate() + ')');
+        }
+        currLoc = leftLoc;
+      } else {
+        /**
+         * RHS is null - LHS must be null too. This must be an edge from the
+         * other geometry, which has no location labelling for this geometry.
+         * This edge must lie wholly inside or outside the other geometry (which
+         * is determined by the current location). Assign both sides to be the
+         * current location.
+         */
+        jsts.util.Assert.isTrue(label.getLocation(geomIndex,
+            jsts.geomgraph.Position.LEFT) === jsts.geom.Location.NONE,
+            'found single null side');
+        label.setLocation(geomIndex, jsts.geomgraph.Position.RIGHT, currLoc);
+        label.setLocation(geomIndex, jsts.geomgraph.Position.LEFT, currLoc);
+      }
+    }
+  }
+};
+
+jsts.geomgraph.EdgeEndStar.prototype.findIndex = function(eSearch) {
+  this.iterator(); // force edgelist to be computed
+  for (var i = 0; i < this.edgeList.size(); i++) {
+    var e = this.edgeList.get(i);
+    if (e === eSearch)
+      return i;
+  }
+  return -1;
+};

data/vendor/assets/javascripts/jsts/geomgraph/EdgeIntersection.js

@@ -0,0 +1,122 @@
+/* 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.
+ */
+
+
+
+/**
+ * @param {Coordinate}
+ *          coord
+ * @param {int}
+ *          segmentIndex
+ * @param {double}
+ *          dist
+ * @constructor
+ */
+jsts.geomgraph.EdgeIntersection = function(coord, segmentIndex, dist) {
+  this.coord = new jsts.geom.Coordinate(coord);
+  this.segmentIndex = segmentIndex;
+  this.dist = dist;
+};
+
+
+/**
+ * the point of intersection
+ *
+ * @type {Coordinate}
+ */
+jsts.geomgraph.EdgeIntersection.prototype.coord = null;
+
+
+/**
+ * the index of the containing line segment in the parent edge
+ *
+ * @type {int}
+ */
+jsts.geomgraph.EdgeIntersection.prototype.segmentIndex = null;
+
+
+/**
+ * the edge distance of this point along the containing line segment
+ *
+ * @type {double}
+ */
+jsts.geomgraph.EdgeIntersection.prototype.dist = null;
+
+
+/**
+ * @return {Coordinate}
+ */
+jsts.geomgraph.EdgeIntersection.prototype.getCoordinate = function() {
+  return this.coord;
+};
+
+
+/**
+ * @return {int}
+ */
+jsts.geomgraph.EdgeIntersection.prototype.getSegmentIndex = function() {
+  return this.segmentIndex;
+};
+
+
+/**
+ * @return {double}
+ */
+jsts.geomgraph.EdgeIntersection.prototype.getDistance = function() {
+  return this.dist;
+};
+
+
+/**
+ * @param {EdgeIntersection}
+ *          other
+ * @return {int}
+ */
+jsts.geomgraph.EdgeIntersection.prototype.compareTo = function(other) {
+  return this.compare(other.segmentIndex, other.dist);
+};
+
+
+/**
+ * @param {int}
+ *          segmentIndex
+ * @param {double}
+ *          dist
+ * @return {int} -1 this EdgeIntersection is located before the argument
+ *         location.
+ * @return {int} 0 this EdgeIntersection is at the argument location.
+ * @return {int} 1 this EdgeIntersection is located after the argument location.
+ */
+jsts.geomgraph.EdgeIntersection.prototype.compare = function(segmentIndex, dist) {
+  if (this.segmentIndex < segmentIndex)
+    return -1;
+  if (this.segmentIndex > segmentIndex)
+    return 1;
+  if (this.dist < dist)
+    return -1;
+  if (this.dist > dist)
+    return 1;
+  return 0;
+};
+
+
+/**
+ * @param {int}
+ *          maxSegmentIndex
+ * @return {boolean}
+ */
+jsts.geomgraph.EdgeIntersection.prototype.isEndPoint = function(maxSegmentIndex) {
+  if (this.segmentIndex === 0 && this.dist === 0.0)
+    return true;
+  if (this.segmentIndex === maxSegmentIndex)
+    return true;
+  return false;
+};
+
+jsts.geomgraph.EdgeIntersection.prototype.toString = function() {
+  return '' + this.segmentIndex + this.dist;
+};
+

data/vendor/assets/javascripts/jsts/geomgraph/EdgeIntersectionList.js

@@ -0,0 +1,146 @@
+/* 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/geomgraph/EdgeIntersection.js
+   */
+
+  var EdgeIntersection = jsts.geomgraph.EdgeIntersection;
+  var TreeMap = javascript.util.TreeMap;
+
+  /**
+   * @constructor
+   * @name jsts.geomgraph.EdgeIntersectionList
+   */
+  jsts.geomgraph.EdgeIntersectionList = function(edge) {
+    this.nodeMap = new TreeMap();
+    this.edge = edge;
+  };
+
+
+
+  /**
+   * @type {javascript.util.Map}
+   * @private
+   */
+  jsts.geomgraph.EdgeIntersectionList.prototype.nodeMap = null;
+
+
+  /**
+   * the parent edge
+   *
+   * @type {Edge}
+   */
+  jsts.geomgraph.EdgeIntersectionList.prototype.edge = null;
+
+  jsts.geomgraph.EdgeIntersectionList.prototype.isIntersection = function(pt) {
+    for (var it = this.iterator(); it.hasNext(); ) {
+      var ei = it.next();
+      if (ei.coord.equals(pt)) {
+       return true;
+      }
+    }
+    return false;
+  };
+
+
+  /**
+   * Adds an intersection into the list, if it isn't already there. The input
+   * segmentIndex and dist are expected to be normalized.
+   *
+   * @param {Coordinate}
+   *          intPt
+   * @param {int}
+   *          segmentIndex
+   * @param {double}
+   *          dist
+   * @return {EdgeIntersection} the EdgeIntersection found or added.
+   */
+  jsts.geomgraph.EdgeIntersectionList.prototype.add = function(intPt, segmentIndex, dist) {
+    var eiNew = new EdgeIntersection(intPt, segmentIndex, dist);
+    var ei = this.nodeMap.get(eiNew);
+    if (ei !== null) {
+      return ei;
+    }
+    this.nodeMap.put(eiNew, eiNew);
+    return eiNew;
+  };
+
+  /**
+   * Returns an iterator of {@link EdgeIntersection}s
+   *
+   * @return an Iterator of EdgeIntersections.
+   */
+  jsts.geomgraph.EdgeIntersectionList.prototype.iterator = function() {
+    return this.nodeMap.values().iterator();
+  };
+
+
+  /**
+   * Adds entries for the first and last points of the edge to the list
+   */
+  jsts.geomgraph.EdgeIntersectionList.prototype.addEndpoints = function() {
+    var maxSegIndex = this.edge.pts.length - 1;
+    this.add(this.edge.pts[0], 0, 0.0);
+    this.add(this.edge.pts[maxSegIndex], maxSegIndex, 0.0);
+  };
+
+  /**
+   * Creates new edges for all the edges that the intersections in this
+   * list split the parent edge into.
+   * Adds the edges to the input list (this is so a single list
+   * can be used to accumulate all split edges for a Geometry).
+   *
+   * @param edgeList a list of EdgeIntersections.
+   */
+  jsts.geomgraph.EdgeIntersectionList.prototype.addSplitEdges = function(edgeList)
+  {
+    // ensure that the list has entries for the first and last point of the edge
+    this.addEndpoints();
+
+    var it = this.iterator();
+    // there should always be at least two entries in the list
+    var eiPrev = it.next();
+    while (it.hasNext()) {
+      var ei = it.next();
+      var newEdge = this.createSplitEdge(eiPrev, ei);
+      edgeList.add(newEdge);
+
+      eiPrev = ei;
+    }
+  };
+  /**
+   * Create a new "split edge" with the section of points between
+   * (and including) the two intersections.
+   * The label for the new edge is the same as the label for the parent edge.
+   */
+  jsts.geomgraph.EdgeIntersectionList.prototype.createSplitEdge = function(ei0,  ei1)  {
+    var npts = ei1.segmentIndex - ei0.segmentIndex + 2;
+
+    var lastSegStartPt = this.edge.pts[ei1.segmentIndex];
+    // if the last intersection point is not equal to the its segment start pt,
+    // add it to the points list as well.
+    // (This check is needed because the distance metric is not totally reliable!)
+    // The check for point equality is 2D only - Z values are ignored
+    var useIntPt1 = ei1.dist > 0.0 || ! ei1.coord.equals2D(lastSegStartPt);
+    if (! useIntPt1) {
+      npts--;
+    }
+
+    var pts = [];
+    var ipt = 0;
+    pts[ipt++] = new jsts.geom.Coordinate(ei0.coord);
+    for (var i = ei0.segmentIndex + 1; i <= ei1.segmentIndex; i++) {
+      pts[ipt++] = this.edge.pts[i];
+    }
+    if (useIntPt1) pts[ipt] = ei1.coord;
+    return new jsts.geomgraph.Edge(pts, new jsts.geomgraph.Label(this.edge.label));
+  };
+
+})();
+