jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/geom/Coordinate.js

@@ -0,0 +1,158 @@
+/* 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() {
+
+  /**
+   * A lightweight class used to store coordinates on the 2-dimensional
+   * Cartesian plane. It is distinct from {@link Point}, which is a subclass of
+   * {@link Geometry}. Unlike objects of type {@link Point} (which contain
+   * additional information such as an envelope, a precision model, and spatial
+   * reference system information), a <code>Coordinate</code> only contains
+   * coordinate values and accessor methods.
+   *
+   * @requires jsts/geom/Geometry.js
+   */
+
+
+
+  /**
+   * @constructor
+   */
+  jsts.geom.Coordinate = function(x, y) {
+    if (typeof x === 'number') {
+      this.x = x;
+      this.y = y;
+    } else if (x instanceof jsts.geom.Coordinate) {
+      this.x = parseFloat(x.x);
+      this.y = parseFloat(x.y);
+    } else if (x === undefined || x === null) {
+      this.x = 0;
+      this.y = 0;
+    } else if (typeof x === 'string') {
+      this.x = parseFloat(x);
+      this.y = parseFloat(y);
+    }
+  };
+
+  /**
+   * Sets this <code>Coordinate</code>s (x,y,z) values to that of
+   * <code>other</code>.
+   *
+   * @param {Coordinate}
+   *          other the <code>Coordinate</code> to copy.
+   */
+  jsts.geom.Coordinate.prototype.setCoordinate = function(other) {
+    this.x = other.x;
+    this.y = other.y;
+  };
+
+
+  /**
+   * Clones this instance.
+   *
+   * @return {Coordinate} A point instance cloned from this.
+   */
+  jsts.geom.Coordinate.prototype.clone = function() {
+    return new jsts.geom.Coordinate(this.x, this.y);
+  };
+
+
+  /**
+   * Computes the 2-dimensional Euclidean distance to another location. The
+   * Z-ordinate is ignored.
+   *
+   * @param {Coordinate}
+   *          p a point.
+   * @return {number} the 2-dimensional Euclidean distance between the
+   *         locations.
+   */
+  jsts.geom.Coordinate.prototype.distance = function(p) {
+    var dx = this.x - p.x;
+    var dy = this.y - p.y;
+
+    return Math.sqrt(dx * dx + dy * dy);
+  };
+
+  /**
+   * Returns whether the planar projections of the two <code>Coordinate</code>s
+   * are equal.
+   *
+   * @param {Coordinate}
+   *          other a <code>Coordinate</code> with which to do the 2D
+   *          comparison.
+   * @return {boolean} <code>true</code> if the x- and y-coordinates are
+   *         equal; the z-coordinates do not have to be equal.
+   */
+  jsts.geom.Coordinate.prototype.equals2D = function(other) {
+    if (this.x !== other.x) {
+      return false;
+    }
+
+    if (this.y !== other.y) {
+      return false;
+    }
+
+    return true;
+  };
+
+  /**
+   * Returns <code>true</code> if <code>other</code> has the same values for
+   * the x and y ordinates. Since Coordinates are 2.5D, this routine ignores the
+   * z value when making the comparison.
+   *
+   * @param {Coordinate}
+   *          other a <code>Coordinate</code> with which to do the comparison.
+   * @return {boolean} <code>true</code> if <code>other</code> is a
+   *         <code>Coordinate</code> with the same values for the x and y
+   *         ordinates.
+   */
+  jsts.geom.Coordinate.prototype.equals = function(other) {
+    if (!other instanceof jsts.geom.Coordinate || other === undefined) {
+      return false;
+    }
+    return this.equals2D(other);
+  };
+
+  /**
+   * Compares this {@link Coordinate} with the specified {@link Coordinate} for
+   * order. This method ignores the z value when making the comparison. Returns:
+   * <UL>
+   * <LI> -1 : this.x < other.x || ((this.x == other.x) && (this.y < other.y))
+   * <LI> 0 : this.x == other.x && this.y = other.y
+   * <LI> 1 : this.x > other.x || ((this.x == other.x) && (this.y > other.y))
+   *
+   * </UL>
+   * Note: This method assumes that ordinate values are valid numbers. NaN
+   * values are not handled correctly.
+   *
+   * @param {Coordinate}
+   *          other the <code>Coordinate</code> with which this
+   *          <code>Coordinate</code> is being compared.
+   * @return {number} -1, zero, or 1 as explained above.
+   */
+  jsts.geom.Coordinate.prototype.compareTo = function(other) {
+    if (this.x < other.x) {
+      return -1;
+    }
+    if (this.x > other.x) {
+      return 1;
+    }
+    if (this.y < other.y) {
+      return -1;
+    }
+    if (this.y > other.y) {
+      return 1;
+    }
+
+    return 0;
+  };
+
+  jsts.geom.Coordinate.prototype.toString = function() {
+    return '(' + this.x + ', ' + this.y + ')';
+  };
+
+})();

data/vendor/assets/javascripts/jsts/geom/CoordinateArrays.js

@@ -0,0 +1,148 @@
+/* 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.
+ */
+
+
+
+/**
+ * @constructor
+ */
+jsts.geom.CoordinateArrays = function() {
+  throw new jsts.error.AbstractMethodInvocationError();
+};
+
+
+/**
+ * If the coordinate array argument has repeated points, constructs a new array
+ * containing no repeated points. Otherwise, returns the argument.
+ *
+ * @return {Coordinate[]}
+ * @see #hasRepeatedPoints(Coordinate[])
+ */
+jsts.geom.CoordinateArrays.removeRepeatedPoints = function(coord) {
+  var coordList;
+  if (!this.hasRepeatedPoints(coord)) {
+    return coord;
+  }
+  coordList = new jsts.geom.CoordinateList(coord, false);
+  return coordList.toCoordinateArray();
+};
+
+
+/**
+ * Returns whether #equals returns true for any two consecutive Coordinates in
+ * the given array.
+ *
+ * @param {Coordinate[]}
+ *          coord
+ * @return {boolean}
+ */
+jsts.geom.CoordinateArrays.hasRepeatedPoints = function(coord) {
+  var i;
+  for (i = 1; i < coord.length; i++) {
+    if (coord[i - 1].equals(coord[i])) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Finds a point in a list of points which is not contained in another list of points
+ * @param testPts the {@link Coordinate} s to test.
+ * @param pts an array of {@link Coordinate} s to test the input points against.
+ * @return a {@link Coordinate} from <code>testPts</code> which is not in <code>pts</code>, '
+ * or <code>null.</code>
+ */
+jsts.geom.CoordinateArrays.ptNotInList = function(testPts, pts) {
+  for (var i = 0; i < testPts.length; i++) {
+    var testPt = testPts[i];
+    if (jsts.geom.CoordinateArrays.indexOf(testPt, pts) < 0)
+        return testPt;
+  }
+  return null;
+};
+
+/**
+ * Determines which orientation of the {@link Coordinate} array is (overall)
+ * increasing. In other words, determines which end of the array is "smaller"
+ * (using the standard ordering on {@link Coordinate}). Returns an integer
+ * indicating the increasing direction. If the sequence is a palindrome, it is
+ * defined to be oriented in a positive direction.
+ *
+ * @param pts
+ *          the array of Coordinates to test.
+ * @return <code>1</code> if the array is smaller at the start or is a
+ *         palindrome, <code>-1</code> if smaller at the end.
+ */
+jsts.geom.CoordinateArrays.increasingDirection = function(pts) {
+  for (var i = 0; i < parseInt(pts.length / 2); i++) {
+    var j = pts.length - 1 - i;
+    // skip equal points on both ends
+    var comp = pts[i].compareTo(pts[j]);
+    if (comp != 0)
+      return comp;
+  }
+  // array must be a palindrome - defined to be in positive direction
+  return 1;
+};
+
+/**
+ * Returns the minimum coordinate, using the usual lexicographic comparison.
+ *
+ * @param coordinates
+ *          the array to search.
+ * @return the minimum coordinate in the array, found using
+ *         <code>compareTo.</code>
+ * @see Coordinate#compareTo(Object)
+ */
+jsts.geom.CoordinateArrays.minCoordinate = function(coordinates) {
+  var minCoord = null;
+  for (var i = 0; i < coordinates.length; i++) {
+    if (minCoord === null || minCoord.compareTo(coordinates[i]) > 0) {
+      minCoord = coordinates[i];
+    }
+  }
+  return minCoord;
+};
+
+/**
+ * Shifts the positions of the coordinates until <code>firstCoordinate</code>
+ * is first.
+ *
+ * @param coordinates
+ *          the array to rearrange.
+ * @param firstCoordinate
+ *          the coordinate to make first.
+ */
+jsts.geom.CoordinateArrays.scroll = function(coordinates, firstCoordinate) {
+  var i = jsts.geom.CoordinateArrays.indexOf(firstCoordinate, coordinates);
+  if (i < 0)
+    return;
+
+  var newCoordinates = coordinates.slice(i).concat(coordinates.slice(0, i));
+  for (i = 0; i < newCoordinates.length; i++) {
+    coordinates[i] = newCoordinates[i];
+  }
+};
+
+/**
+ * Returns the index of <code>coordinate</code> in <code>coordinates</code>.
+ * The first position is 0; the second, 1; etc.
+ *
+ * @param coordinate
+ *          the <code>Coordinate</code> to search for.
+ * @param coordinates
+ *          the array to search.
+ * @return the position of <code>coordinate</code>, or -1 if it is not found.
+ */
+jsts.geom.CoordinateArrays.indexOf = function(coordinate, coordinates) {
+  for (var i = 0; i < coordinates.length; i++) {
+    if (coordinate.equals(coordinates[i])) {
+      return i;
+    }
+  }
+  return -1;
+};

data/vendor/assets/javascripts/jsts/geom/CoordinateFilter.js

@@ -0,0 +1,29 @@
+/* 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.
+ */
+
+
+/**
+ * <code>Geometry</code> classes support the concept of applying a coordinate
+ * filter to every coordinate in the <code>Geometry</code>. A coordinate
+ * filter can either record information about each coordinate or change the
+ * coordinate in some way. Coordinate filters implement the interface
+ * <code>CoordinateFilter</code>. (<code>CoordinateFilter</code> is an
+ * example of the Gang-of-Four Visitor pattern). Coordinate filters can be used
+ * to implement such things as coordinate transformations, centroid and envelope
+ * computation, and many other functions.
+ *
+ * @interface
+ */
+jsts.geom.CoordinateFilter = function() {};
+/**
+ * Performs an operation with or on <code>coord</code>.
+ *
+ * @param coord
+ *          a <code>Coordinate</code> to which the filter is applied.
+ */
+jsts.geom.CoordinateFilter.prototype.filter = function(coord) {
+  throw new jsts.error.AbstractMethodInvocationError();
+};

data/vendor/assets/javascripts/jsts/geom/CoordinateList.js

@@ -0,0 +1,157 @@
+/* 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.
+ */
+
+
+
+/**
+ * Constructs a new list from an array of Coordinates, allowing caller to
+ * specify if repeated points are to be removed.
+ *
+ * @param {Array.<jsts.geom.Coordinate>}
+ *          coord the array of coordinates to load into the list.
+ * @param {boolean}
+ *          allowRepeated if <code>false</code>, repeated points are removed.
+ *
+ * @constructor
+ */
+jsts.geom.CoordinateList = function(coord, allowRepeated) {
+  javascript.util.ArrayList.apply(this, arguments);
+  
+  allowRepeated = (allowRepeated === undefined) ? true : allowRepeated;
+
+  if (coord !== undefined) {
+    this.add(coord, allowRepeated);
+  }
+};
+
+jsts.geom.CoordinateList.prototype = new javascript.util.ArrayList();
+
+
+// simulate overloaded methods...
+jsts.geom.CoordinateList.prototype.add = function() {
+    if (arguments.length>1) {
+        return this.addCoordinates.apply(this, arguments);
+    } else {
+        return javascript.util.ArrayList.prototype.add.apply(this, arguments);
+    }
+};
+
+/**
+ * Adds an array of coordinates to the list.
+ *
+ * @param {Array.<jsts.geom.Coordinate>}
+ *          coord The coordinates.
+ * @param {boolean}
+ *          allowRepeated if set to false, repeated coordinates are collapsed.
+ * @param {boolean}
+ *          direction if false, the array is added in reverse order.
+ * @return {boolean} true (as by general collection contract).
+ */
+jsts.geom.CoordinateList.prototype.addCoordinates = function(coord, allowRepeated,
+    direction) {
+  if (coord instanceof jsts.geom.Coordinate) {
+    return this.addCoordinate.apply(this, arguments);
+  } else if (typeof coord === 'number') {
+    return this.insertCoordinate.apply(this, arguments);
+  }
+
+  direction = direction || true;
+
+  if (direction) {
+    for (var i = 0; i < coord.length; i++) {
+      this.addCoordinate(coord[i], allowRepeated);
+    }
+  } else {
+    for (var i = coord.length - 1; i >= 0; i--) {
+      this.addCoordinate(coord[i], allowRepeated);
+    }
+  }
+  return true;
+};
+
+
+/**
+ * Adds a coordinate to the end of the list.
+ *
+ * @param {Coordinate}
+ *          coord The coordinates.
+ * @param {boolean}
+ *          allowRepeated if set to false, repeated coordinates are collapsed.
+ */
+jsts.geom.CoordinateList.prototype.addCoordinate = function(coord,
+    allowRepeated) {
+  // don't add duplicate coordinates
+  if (!allowRepeated) {
+    if (this.size() >= 1) {
+      var last = this.get(this.size() - 1);
+      if (last.equals2D(coord)) return;
+    }
+  }
+  this.add(coord);
+};
+
+/**
+ * Inserts a coordinate at the specified place in the list
+ *
+ * @param {Number}
+ *          index The index where to insert the coordinate.
+ * @param {Coordinate}
+ *          coord The coordinate.
+ * @param {boolean}
+ *          allowRepeated if set to false, repeated coordinates are collapsed.
+ */
+jsts.geom.CoordinateList.prototype.insertCoordinate = function(index, coord,
+    allowRepeated) {
+  // don't add duplicate coordinates
+  if (!allowRepeated) {
+    var before = index > 0 ? index - 1 : -1;
+    if (before !== -1 && this.get(before).equals2D(coord)) {
+      return;
+    }
+
+    var after = index < this.size() - 1 ? index + 1 : -1;
+    if (after !== -1 && this.get(after).equals2D(coord)) {
+      return;
+    }
+  }
+  this.array.splice(index, 0, coord);
+};
+
+/**
+ * Ensure this coordList is a ring, by adding the start point if necessary
+ */
+jsts.geom.CoordinateList.prototype.closeRing = function() {
+  if (this.size() > 0) {
+    this.addCoordinate(new jsts.geom.Coordinate(this.get(0)), false);
+  }
+};
+
+/**
+ * Creates a standard javascript-array from the contents of this list
+ *
+ * @return {Array}
+ *            the created array.
+ */
+jsts.geom.CoordinateList.prototype.toArray = function() {
+  var i, il, arr;
+  i = 0, il = this.size(), arr = [];
+
+  for (i; i < il; i++) {
+    arr[i] = this.get(i);
+  }
+
+  return arr;
+};
+
+/** Returns the Coordinates in this collection.
+*
+* @return the coordinates.
+*/
+jsts.geom.CoordinateList.prototype.toCoordinateArray = function() {
+  return this.toArray();
+};
+
+// TODO: port rest?