jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/noding/NodedSegmentString.js

@@ -0,0 +1,235 @@
+/* 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/noding/NodedSegmentString.java
+ * Revision: 478
+ */
+
+/**
+ * @requires jsts/noding/NodableSegmentString.js
+ */
+
+/**
+ * Represents a list of contiguous line segments, and supports noding the
+ * segments. The line segments are represented by an array of {@link Coordinate}s.
+ * Intended to optimize the noding of contiguous segments by reducing the number
+ * of allocated objects. SegmentStrings can carry a context object, which is
+ * useful for preserving topological or parentage information. All noded
+ * substrings are initialized with the same context object.
+ *
+ * Creates a new segment string from a list of vertices.
+ *
+ * @param pts
+ *          the vertices of the segment string.
+ * @param data
+ *          the user-defined data of this segment string (may be null).
+ *
+ * @constructor
+ */
+jsts.noding.NodedSegmentString = function(pts, data) {
+  this.nodeList = new jsts.noding.SegmentNodeList(this);
+
+  this.pts = pts;
+  this.data = data;
+};
+jsts.noding.NodedSegmentString.prototype = new jsts.noding.NodableSegmentString();
+jsts.noding.NodedSegmentString.constructor = jsts.noding.NodedSegmentString;
+
+
+/**
+ * Gets the {@link SegmentString}s which result from splitting this string at node points.
+ *
+ * @param {javascript.util.Collection}
+ *          segStrings a Collection of NodedSegmentStrings.
+ * @param {javascript.util.Collection} resultEdgelist
+ *          a List which will collect the NodedSegmentStrings representing the
+ *          substrings.
+ * @return {Array} a Collection of NodedSegmentStrings representing the
+ *         substrings.
+ */
+jsts.noding.NodedSegmentString.getNodedSubstrings = function(segStrings) {
+  if (arguments.length === 2) {
+    jsts.noding.NodedSegmentString.getNodedSubstrings2.apply(this, arguments);
+    return;
+  }
+
+  var resultEdgelist = new javascript.util.ArrayList();
+  jsts.noding.NodedSegmentString.getNodedSubstrings2(segStrings, resultEdgelist);
+  return resultEdgelist;
+};
+
+
+/**
+ * Adds the noded {@link SegmentString}s which result from splitting this string at node points.
+ *
+ * @param {javascript.util.Collection} segStrings
+ *          a Collection of NodedSegmentStrings.
+ * @param {javascript.util.Collection} resultEdgelist
+ *          a List which will collect the NodedSegmentStrings representing the
+ *          substrings.
+ */
+jsts.noding.NodedSegmentString.getNodedSubstrings2 = function(segStrings,
+    resultEdgelist) {
+  for (var i = segStrings.iterator(); i.hasNext(); ) {
+    var ss = i.next();
+    ss.getNodeList().addSplitEdges(resultEdgelist);
+  }
+};
+
+
+/**
+ * @type {jsts.noding.SegmentNodeList}
+ * @private
+ */
+jsts.noding.NodedSegmentString.prototype.nodeList = null;
+
+
+/**
+ * @type {Array.<jsts.geom.Coordinate>}
+ * @private
+ */
+jsts.noding.NodedSegmentString.prototype.pts = null;
+
+
+/**
+ * @type {Object}
+ * @private
+ */
+jsts.noding.NodedSegmentString.prototype.data = null;
+
+
+jsts.noding.NodedSegmentString.prototype.getData = function() {
+  return this.data;
+};
+jsts.noding.NodedSegmentString.prototype.setData = function(data) {
+  this.data = data;
+};
+jsts.noding.NodedSegmentString.prototype.getNodeList = function() {
+  return this.nodeList;
+};
+jsts.noding.NodedSegmentString.prototype.size = function() {
+  return this.pts.length;
+};
+jsts.noding.NodedSegmentString.prototype.getCoordinate = function(i) {
+  return this.pts[i];
+};
+jsts.noding.NodedSegmentString.prototype.getCoordinates = function() {
+  return this.pts;
+};
+
+jsts.noding.NodedSegmentString.prototype.isClosed = function() {
+  return this.pts[0].equals(this.pts[this.pts.length - 1]);
+};
+
+
+/**
+ * Gets the octant of the segment starting at vertex <code>index</code>.
+ *
+ * @param index
+ *          the index of the vertex starting the segment. Must not be the last
+ *          index in the vertex list.
+ * @return the octant of the segment at the vertex.
+ */
+jsts.noding.NodedSegmentString.prototype.getSegmentOctant = function(index) {
+  if (index === this.pts.length - 1)
+    return -1;
+  return this.safeOctant(this.getCoordinate(index), this.getCoordinate(index + 1));
+};
+
+
+/**
+ * @private
+ */
+jsts.noding.NodedSegmentString.prototype.safeOctant = function(p0, p1) {
+  if (p0.equals2D(p1))
+    return 0;
+  return jsts.noding.Octant.octant(p0, p1);
+};
+
+
+/**
+ * Adds EdgeIntersections for one or both intersections found for a segment of
+ * an edge to the edge intersection list.
+ */
+jsts.noding.NodedSegmentString.prototype.addIntersections = function(li,
+    segmentIndex, geomIndex) {
+  for (var i = 0; i < li.getIntersectionNum(); i++) {
+    this.addIntersection(li, segmentIndex, geomIndex, i);
+  }
+};
+
+
+/**
+ * Add an SegmentNode for intersection intIndex. An intersection that falls
+ * exactly on a vertex of the SegmentString is normalized to use the higher of
+ * the two possible segmentIndexes
+ */
+jsts.noding.NodedSegmentString.prototype.addIntersection = function(li,
+    segmentIndex, geomIndex, intIndex) {
+
+  if (li instanceof jsts.geom.Coordinate) {
+    this.addIntersection2.apply(this, arguments);
+    return;
+  }
+
+  var intPt = new jsts.geom.Coordinate(li.getIntersection(intIndex));
+  this.addIntersection2(intPt, segmentIndex);
+};
+
+
+/**
+ * Adds an intersection node for a given point and segment to this segment
+ * string.
+ *
+ * @param {jsts.geom.Coordinate} intPt
+ *          the location of the intersection.
+ * @param segmentIndex
+ *          the index of the segment containing the intersection.
+ */
+jsts.noding.NodedSegmentString.prototype.addIntersection2 = function(intPt,
+    segmentIndex) {
+  this.addIntersectionNode(intPt, segmentIndex);
+};
+
+
+/**
+ * Adds an intersection node for a given point and segment to this segment
+ * string. If an intersection already exists for this exact location, the
+ * existing node will be returned.
+ *
+ * @param {jsts.geom.Coordinate} intPt
+ *          the location of the intersection.
+ * @param segmentIndex
+ *          the index of the segment containing the intersection.
+ * @return {SegmentNode} the intersection node for the point.
+ */
+jsts.noding.NodedSegmentString.prototype.addIntersectionNode = function(intPt,
+    segmentIndex) {
+  var normalizedSegmentIndex = segmentIndex;
+  // 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)) {
+      // Debug.println("normalized distance");
+      normalizedSegmentIndex = nextSegIndex;
+    }
+  }
+  /**
+   * Add the intersection point to edge intersection list.
+   */
+  var ei = this.nodeList.add(intPt, normalizedSegmentIndex);
+  return ei;
+};
+
+jsts.noding.NodedSegmentString.prototype.toString = function() {
+  var geometryFactory = new jsts.geom.GeometryFactory();
+  return new jsts.io.WKTWriter().write(geometryFactory.createLineString(this.pts));
+};

data/vendor/assets/javascripts/jsts/noding/Noder.js

@@ -0,0 +1,41 @@
+/* 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() {
+
+  /**
+   * Computes all intersections between segments in a set of
+   * {@link SegmentString}s. Intersections found are represented as
+   * {@link SegmentNode}s and added to the {@link SegmentString}s in which
+   * they occur. As a final step in the noding a new set of segment strings
+   * split at the nodes may be returned.
+   *
+   * @interface
+   */
+  jsts.noding.Noder = function() {
+
+  };
+
+
+  /**
+   * Computes the noding for a collection of {@link SegmentString}s. Some
+   * Noders may add all these nodes to the input SegmentStrings; others may only
+   * add some or none at all.
+   *
+   * @param {Array}
+   *          segStrings a collection of {@link SegmentString}s to node.
+   */
+  jsts.noding.Noder.prototype.computeNodes = jsts.abstractFunc;
+
+  /**
+   * Returns a {@link Collection} of fully noded {@link SegmentString}s. The
+   * SegmentStrings have the same context as their parent.
+   *
+   * @return {Array} a Collection of SegmentStrings.
+   */
+  jsts.noding.Noder.prototype.getNodedSubstrings = jsts.abstractFunc;
+
+})();

data/vendor/assets/javascripts/jsts/noding/NodingValidator.js

@@ -0,0 +1,5 @@
+/* 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.
+ */

data/vendor/assets/javascripts/jsts/noding/Octant.js

@@ -0,0 +1,84 @@
+/* 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.
+ */
+
+
+
+/**
+ * Methods for computing and working with octants of the Cartesian plane
+ * Octants are numbered as follows:
+ * <pre>
+ *  \2|1/
+ * 3 \|/ 0
+ * ---+--
+ * 4 /|\ 7
+ *  /5|6\
+ * <pre>
+ * If line segments lie along a coordinate axis, the octant is the lower of the two
+ * possible values.
+ *
+ * @constructor
+ */
+jsts.noding.Octant = function() {
+  throw jsts.error.AbstractMethodInvocationError();
+};
+
+
+/**
+ * Returns the octant of a directed line segment (specified as x and y
+ * displacements, which cannot both be 0).
+ */
+jsts.noding.Octant.octant = function(dx,  dy)  {
+  if (dx instanceof jsts.geom.Coordinate) {
+    return jsts.noding.Octant.octant2.apply(this, arguments);
+  }
+
+  if (dx === 0.0 && dy === 0.0)
+    throw new jsts.error.IllegalArgumentError('Cannot compute the octant for point ( ' + dx + ', ' + dy + ' )');
+
+  var adx = Math.abs(dx);
+  var ady = Math.abs(dy);
+
+  if (dx >= 0) {
+    if (dy >= 0) {
+      if (adx >= ady)
+        return 0;
+      else
+        return 1;
+    }
+    else { // dy < 0
+      if (adx >= ady)
+        return 7;
+      else
+        return 6;
+    }
+  }
+  else { // dx < 0
+    if (dy >= 0) {
+      if (adx >= ady)
+        return 3;
+      else
+        return 2;
+    }
+    else { // dy < 0
+      if (adx >= ady)
+        return 4;
+      else
+        return 5;
+    }
+  }
+};
+
+
+/**
+ * Returns the octant of a directed line segment from p0 to p1.
+ */
+jsts.noding.Octant.octant2 = function(p0,  p1)  {
+  var dx = p1.x - p0.x;
+  var dy = p1.y - p0.y;
+  if (dx === 0.0 && dy === 0.0)
+    throw new jsts.error.IllegalArgumentError('Cannot compute the octant for two identical points ' + p0);
+  return jsts.noding.Octant.octant(dx, dy);
+};

data/vendor/assets/javascripts/jsts/noding/OrientedCoordinateArray.js

@@ -0,0 +1,94 @@
+/* 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.
+ */
+
+
+/**
+ * Allows comparing {@link Coordinate} arrays in an orientation-independent way.
+ *
+ * Creates a new {@link OrientedCoordinateArray} for the given
+ * {@link Coordinate} array.
+ *
+ * @param pts
+ *          the coordinates to orient.
+ */
+jsts.noding.OrientedCoordinateArray = function(pts) {
+  this.pts = pts;
+  this._orientation = jsts.noding.OrientedCoordinateArray.orientation(pts);
+};
+
+
+/**
+ * @type {Array.<Coordinate>}
+ * @private
+ */
+jsts.noding.OrientedCoordinateArray.prototype.pts = null;
+
+
+/**
+ * @type {boolean}
+ * @private
+ */
+jsts.noding.OrientedCoordinateArray.prototype._orientation = undefined;
+
+
+/**
+ * Computes the canonical orientation for a coordinate array.
+ *
+ * @param {Array.
+ *          <Coordinate>} pts the array to test.
+ * @return <code>true</code> if the points are oriented forwards.
+ * @return <code>false</code if the points are oriented in reverse.
+ * @private
+ */
+jsts.noding.OrientedCoordinateArray.orientation = function(pts) {
+  return jsts.geom.CoordinateArrays.increasingDirection(pts) === 1;
+};
+
+/**
+ * Compares two {@link OrientedCoordinateArray}s for their relative order
+ *
+ * @return -1 this one is smaller.
+ * @return 0 the two objects are equal.
+ * @return 1 this one is greater.
+ */
+
+jsts.noding.OrientedCoordinateArray.prototype.compareTo = function(o1) {
+  var oca = o1;
+  var comp = jsts.noding.OrientedCoordinateArray.compareOriented(this.pts,
+      this._orientation, oca.pts, oca._orientation);
+  return comp;
+};
+
+
+/**
+ * @private
+ */
+jsts.noding.OrientedCoordinateArray.compareOriented = function(pts1,
+    orientation1, pts2, orientation2) {
+  var dir1 = orientation1 ? 1 : -1;
+  var dir2 = orientation2 ? 1 : -1;
+  var limit1 = orientation1 ? pts1.length : -1;
+  var limit2 = orientation2 ? pts2.length : -1;
+
+  var i1 = orientation1 ? 0 : pts1.length - 1;
+  var i2 = orientation2 ? 0 : pts2.length - 1;
+  var comp = 0;
+  while (true) {
+    var compPt = pts1[i1].compareTo(pts2[i2]);
+    if (compPt !== 0)
+      return compPt;
+    i1 += dir1;
+    i2 += dir2;
+    var done1 = i1 === limit1;
+    var done2 = i2 === limit2;
+    if (done1 && !done2)
+      return -1;
+    if (!done1 && done2)
+      return 1;
+    if (done1 && done2)
+      return 0;
+  }
+};