jsts-rails 0.1.0 → 0.2.0

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

@@ -0,0 +1,291 @@
+/* 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/GraphComponent.js
+ */
+
+
+
+/**
+ * @param {Coordinate[]}
+ *          pts
+ * @param {Label}
+ *          label
+ * @augments jsts.geomgraph.GraphComponent
+ * @constructor
+ */
+jsts.geomgraph.Edge = function(pts, label) {
+  this.pts = pts;
+  this.label = label;
+  this.eiList = new jsts.geomgraph.EdgeIntersectionList(this);
+  this.depth = new jsts.geomgraph.Depth();
+};
+
+jsts.geomgraph.Edge.prototype = new jsts.geomgraph.GraphComponent();
+jsts.geomgraph.Edge.constructor = jsts.geomgraph.Edge;
+
+/**
+ * Updates an IM from the label for an edge. Handles edges from both L and A
+ * geometries.
+ */
+jsts.geomgraph.Edge.updateIM = function(label, im) {
+  im.setAtLeastIfValid(label.getLocation(0, jsts.geomgraph.Position.ON), label
+      .getLocation(1, jsts.geomgraph.Position.ON), 1);
+  if (label.isArea()) {
+    im.setAtLeastIfValid(label.getLocation(0, jsts.geomgraph.Position.LEFT),
+        label.getLocation(1, jsts.geomgraph.Position.LEFT), 2);
+    im.setAtLeastIfValid(label.getLocation(0, jsts.geomgraph.Position.RIGHT),
+        label.getLocation(1, jsts.geomgraph.Position.RIGHT), 2);
+  }
+};
+
+
+/**
+ * @private
+ */
+jsts.geomgraph.Edge.prototype.pts = null;
+
+
+/**
+ * @private
+ */
+jsts.geomgraph.Edge.prototype.env = null;
+
+
+/**
+ * @private
+ */
+jsts.geomgraph.Edge.prototype.name = null;
+
+
+/**
+ * @type {MonotoneChainEdge}
+ * @private
+ */
+jsts.geomgraph.Edge.prototype.mce = null;
+
+
+/**
+ * @private
+ */
+jsts.geomgraph.Edge.prototype._isIsolated = true;
+
+
+/**
+ * @type {Depth}
+ * @private
+ */
+jsts.geomgraph.Edge.prototype.depth = null;
+
+
+/**
+ * // the change in area depth from the R to L side of this edge
+ */
+jsts.geomgraph.Edge.prototype.depthDelta = 0;
+
+
+/**
+ * @type {jsts.geomgraph.EdgeIntersectionList}
+ * @private
+ */
+jsts.geomgraph.Edge.prototype.eiList = null;
+
+
+/**
+ * @return {int}
+ */
+jsts.geomgraph.Edge.prototype.getNumPoints = function() {
+  return this.pts.length;
+};
+
+
+jsts.geomgraph.Edge.prototype.getEnvelope = function() {
+  // compute envelope lazily
+  if (this.env === null) {
+    this.env = new jsts.geom.Envelope();
+    for (var i = 0; i < this.pts.length; i++) {
+      this.env.expandToInclude(pts[i]);
+    }
+  }
+  return env;
+};
+
+jsts.geomgraph.Edge.prototype.getDepth = function() {
+  return this.depth;
+};
+
+/**
+ * The depthDelta is the change in depth as an edge is crossed from R to L
+ *
+ * @return the change in depth as the edge is crossed from R to L.
+ */
+jsts.geomgraph.Edge.prototype.getDepthDelta = function() {
+  return this.depthDelta;
+};
+jsts.geomgraph.Edge.prototype.setDepthDelta = function(depthDelta) {
+  this.depthDelta = depthDelta;
+};
+
+/**
+ * @return {Coordinate[]}
+ */
+jsts.geomgraph.Edge.prototype.getCoordinates = function() {
+  return this.pts;
+};
+
+
+/**
+ * @param {int}
+ *          i
+ * @return {Coordinate}
+ */
+jsts.geomgraph.Edge.prototype.getCoordinate = function(i) {
+  if (i === undefined) {
+    if (this.pts.length > 0) {
+      return this.pts[0];
+    } else {
+      return null;
+    }
+  }
+
+  return this.pts[i];
+};
+
+
+/**
+ * @return {boolean}
+ */
+jsts.geomgraph.Edge.prototype.isClosed = function() {
+  return this.pts[0].equals(this.pts[this.pts.length - 1]);
+};
+
+
+jsts.geomgraph.Edge.prototype.setIsolated = function(isIsolated) {
+  this._isIsolated = isIsolated;
+};
+jsts.geomgraph.Edge.prototype.isIsolated = function() {
+  return this._isIsolated;
+};
+
+
+/**
+ * Adds EdgeIntersections for one or both intersections found for a segment of
+ * an edge to the edge intersection list.
+ *
+ * @param {LineIntersector}
+ *          li
+ * @param {int}
+ *          segmentIndex
+ * @param {int}
+ *          geomIndex
+ */
+jsts.geomgraph.Edge.prototype.addIntersections = function(li, segmentIndex,
+    geomIndex) {
+  for (var i = 0; i < li.getIntersectionNum(); i++) {
+    this.addIntersection(li, segmentIndex, geomIndex, i);
+  }
+};
+
+
+/**
+ * Add an EdgeIntersection for intersection intIndex. An intersection that falls
+ * exactly on a vertex of the edge is normalized to use the higher of the two
+ * possible segmentIndexes
+ *
+ * @param {LineIntersector}
+ *          li
+ * @param {int}
+ *          segmentIndex
+ * @param {int}
+ *          geomIndex
+ * @param {int}
+ *          intIndex
+ */
+jsts.geomgraph.Edge.prototype.addIntersection = function(li, segmentIndex,
+    geomIndex, intIndex) {
+  var intPt = new jsts.geom.Coordinate(li.getIntersection(intIndex));
+  var normalizedSegmentIndex = segmentIndex;
+  var dist = li.getEdgeDistance(geomIndex, intIndex);
+  // normalize the intersection point location
+  var nextSegIndex = normalizedSegmentIndex + 1;
+  if (nextSegIndex < this.pts.length) {
+    var nextPt = this.pts[nextSegIndex];
+
+    // Normalize segment index if intPt falls on vertex
+    // The check for point equality is 2D only - Z values are ignored
+    if (intPt.equals2D(nextPt)) {
+      normalizedSegmentIndex = nextSegIndex;
+      dist = 0.0;
+    }
+  }
+  /**
+   * Add the intersection point to edge intersection list.
+   */
+  var ei = this.eiList.add(intPt, normalizedSegmentIndex, dist);
+};
+
+
+/**
+ * @return {int}
+ */
+jsts.geomgraph.Edge.prototype.getMaximumSegmentIndex = function() {
+  return this.pts.length - 1;
+};
+
+jsts.geomgraph.Edge.prototype.getEdgeIntersectionList = function() {
+  return this.eiList;
+};
+
+jsts.geomgraph.Edge.prototype.isClosed = function()
+{
+  return this.pts[0].equals(this.pts[this.pts.length - 1]);
+};
+/**
+ * An Edge is collapsed if it is an Area edge and it consists of
+ * two segments which are equal and opposite (eg a zero-width V).
+ */
+jsts.geomgraph.Edge.prototype.isCollapsed = function()
+{
+  if (! this.label.isArea()) return false;
+  if (this.pts.length != 3) return false;
+  if (this.pts[0].equals(this.pts[2])) return true;
+  return false;
+};
+jsts.geomgraph.Edge.prototype.getCollapsedEdge = function()
+{
+  var newPts = [];
+  newPts[0] = this.pts[0];
+  newPts[1] = this.pts[1];
+  var newe = new jsts.geomgraph.Edge(newPts, jsts.geomgraph.Label.toLineLabel(this.label));
+  return newe;
+};
+
+
+/**
+ * Update the IM with the contribution for this component. A component only
+ * contributes if it has a labelling for both parent geometries
+ */
+jsts.geomgraph.Edge.prototype.computeIM = function(im) {
+  jsts.geomgraph.Edge.updateIM(this.label, im);
+};
+
+/**
+ * @return true if the coordinate sequences of the Edges are identical.
+ */
+jsts.geomgraph.Edge.prototype.isPointwiseEqual = function(e)
+{
+  if (this.pts.length != e.pts.length) return false;
+
+  for (var i = 0; i < this.pts.length; i++) {
+    if (! this.pts[i].equals2D(e.pts[i])) {
+       return false;
+    }
+  }
+  return true;
+};
+
+// TODO: port rest..

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

@@ -0,0 +1,188 @@
+/* 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 Assert = jsts.util.Assert;
+
+  /**
+   * Models the end of an edge incident on a node. EdgeEnds have a direction
+   * determined by the direction of the ray from the initial point to the next
+   * point. EdgeEnds are comparable under the ordering "a has a greater angle
+   * with the x-axis than b". This ordering is used to sort EdgeEnds around a
+   * node.
+   *
+   * @param {Edge}
+   *          edge
+   * @param {Coordinate}
+   *          p0
+   * @param {Coordinate}
+   *          p1
+   * @param {Label}
+   *          label
+   * @constructor
+   */
+  jsts.geomgraph.EdgeEnd = function(edge, p0, p1, label) {
+    this.edge = edge;
+    if (p0 && p1) {
+      this.init(p0, p1);
+    }
+    if (label) {
+      this.label = label || null;
+    }
+  };
+
+  /**
+   * the parent edge of this edge end
+   *
+   * @type {Edge}
+   * @protected
+   */
+  jsts.geomgraph.EdgeEnd.prototype.edge = null;
+
+
+  /**
+   * @type {Label}
+   * @protected
+   */
+  jsts.geomgraph.EdgeEnd.prototype.label = null;
+
+
+  /**
+   * the node this edge end originates at
+   *
+   * @type {Node}
+   * @private
+   */
+  jsts.geomgraph.EdgeEnd.prototype.node = null;
+
+
+  /**
+   * points of initial line segment
+   *
+   * @type {Coordinate}
+   * @private
+   */
+  jsts.geomgraph.EdgeEnd.prototype.p0 = null;
+  jsts.geomgraph.EdgeEnd.prototype.p1 = null;
+
+
+  /**
+   * the direction vector for this edge from its starting point
+   *
+   * @type {double}
+   * @private
+   */
+  jsts.geomgraph.EdgeEnd.prototype.dx = null;
+  jsts.geomgraph.EdgeEnd.prototype.dy = null;
+
+
+  /**
+   * @type {int}
+   * @private
+   */
+  jsts.geomgraph.EdgeEnd.prototype.quadrant = null;
+
+
+  /**
+   * @param {Coordinate}
+   *          p0
+   * @param {Coordinate}
+   *          p1
+   * @protected
+   */
+  jsts.geomgraph.EdgeEnd.prototype.init = function(p0, p1) {
+    this.p0 = p0;
+    this.p1 = p1;
+    this.dx = p1.x - p0.x;
+    this.dy = p1.y - p0.y;
+    this.quadrant = jsts.geomgraph.Quadrant.quadrant(this.dx, this.dy);
+    Assert.isTrue(!(this.dx === 0 && this.dy === 0),
+        'EdgeEnd with identical endpoints found');
+  };
+
+  jsts.geomgraph.EdgeEnd.prototype.getEdge = function() {
+    return this.edge;
+  };
+
+  jsts.geomgraph.EdgeEnd.prototype.getLabel = function() {
+    return this.label;
+  };
+
+  jsts.geomgraph.EdgeEnd.prototype.getCoordinate = function() {
+    return this.p0;
+  };
+
+  jsts.geomgraph.EdgeEnd.prototype.getDirectedCoordinate = function() {
+    return this.p1;
+  };
+
+  jsts.geomgraph.EdgeEnd.prototype.getQuadrant = function() {
+    return this.quadrant;
+  };
+
+  jsts.geomgraph.EdgeEnd.prototype.getDx = function() {
+    return this.dx;
+  };
+
+  jsts.geomgraph.EdgeEnd.prototype.getDy = function() {
+    return this.dy;
+  };
+
+
+  jsts.geomgraph.EdgeEnd.prototype.setNode = function(node) {
+    this.node = node;
+  };
+
+  jsts.geomgraph.EdgeEnd.prototype.getNode = function() {
+    return this.node;
+  };
+
+  jsts.geomgraph.EdgeEnd.prototype.compareTo = function(e) {
+    return this.compareDirection(e);
+  };
+
+
+  /**
+   * Implements the total order relation:
+   * <p>
+   * a has a greater angle with the positive x-axis than b
+   * <p>
+   * Using the obvious algorithm of simply computing the angle is not robust,
+   * since the angle calculation is obviously susceptible to roundoff. A robust
+   * algorithm is: - first compare the quadrant. If the quadrants are different,
+   * it it trivial to determine which vector is "greater". - if the vectors lie
+   * in the same quadrant, the computeOrientation function can be used to decide
+   * the relative orientation of the vectors.
+   *
+   * @param {EdgeEnd}
+   *          e
+   * @return {number}
+   */
+  jsts.geomgraph.EdgeEnd.prototype.compareDirection = function(e) {
+    if (this.dx === e.dx && this.dy === e.dy)
+      return 0;
+    // if the rays are in different quadrants, determining the ordering is
+    // trivial
+    if (this.quadrant > e.quadrant)
+      return 1;
+    if (this.quadrant < e.quadrant)
+      return -1;
+    // vectors are in the same quadrant - check relative orientation of
+    // direction vectors
+    // this is > e if it is CCW of e
+    return jsts.algorithm.CGAlgorithms.computeOrientation(e.p0, e.p1, this.p1);
+  };
+
+  jsts.geomgraph.EdgeEnd.prototype.computeLabel = function(boundaryNodeRule) {
+  // subclasses should override this if they are using labels
+  };
+
+})();