jsts-rails 0.1.0 → 0.2.0

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

@@ -0,0 +1,69 @@
+/* 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() {
+
+  /**
+   * Models an OGC SFS <code>LinearRing</code>. A LinearRing is a LineString
+   * which is both closed and simple. In other words, the first and last
+   * coordinate in the ring must be equal, and the interior of the ring must not
+   * self-intersect. Either orientation of the ring is allowed.
+   * <p>
+   * A ring must have either 0 or 4 or more points. The first and last points
+   * must be equal (in 2D). If these conditions are not met, the constructors
+   * throw an {@link IllegalArgumentException}
+   *
+   * @requires jsts/geom/LineString.js
+   */
+
+
+  /**
+   * @extends jsts.geom.LineString
+   * @constructor
+   */
+  jsts.geom.LinearRing = function(points, factory) {
+    jsts.geom.LineString.apply(this, arguments);
+  };
+  jsts.geom.LinearRing.prototype = new jsts.geom.LineString();
+  jsts.geom.LinearRing.constructor = jsts.geom.LinearRing;
+
+
+  /**
+   * Returns <code>Dimension.FALSE</code>, since by definition LinearRings do
+   * not have a boundary.
+   *
+   * @return {int} Dimension.FALSE.
+   */
+  jsts.geom.LinearRing.prototype.getBoundaryDimension = function() {
+    return jsts.geom.Dimension.FALSE;
+  };
+
+
+  /**
+   * Returns <code>true</code>, since by definition LinearRings are always
+   * simple.
+   *
+   * @return {Boolean} <code>true.</code>
+   *
+   * @see Geometry#isSimple
+   */
+  jsts.geom.LinearRing.prototype.isSimple = function() {
+    return true;
+  };
+
+
+  /**
+   * @return {String} String representation of LinearRing type.
+   */
+  jsts.geom.LinearRing.prototype.getGeometryType = function() {
+    return 'LinearRing';
+  };
+
+  jsts.geom.LinearRing.MINIMUM_VALID_SIZE = 4;
+
+  jsts.geom.LinearRing.prototype.CLASS_NAME = 'jsts.geom.LinearRing';
+
+})();

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

@@ -0,0 +1,83 @@
+/* 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.
+ */
+
+
+
+/**
+ * Constants representing the different topological locations which can occur in
+ * a {@link Geometry}. The constants are also used as the row and column
+ * indices of DE-9IM {@link IntersectionMatrix}es.
+ *
+ * @constructor
+ */
+jsts.geom.Location = function() {
+};
+
+
+/**
+ * The location value for the interior of a geometry. Also, DE-9IM row index of
+ * the interior of the first geometry and column index of the interior of the
+ * second geometry.
+ *
+ * @const
+ * @type {number}
+ */
+jsts.geom.Location.INTERIOR = 0;
+
+
+/**
+ * The location value for the boundary of a geometry. Also, DE-9IM row index of
+ * the boundary of the first geometry and column index of the boundary of the
+ * second geometry.
+ *
+ * @const
+ * @type {number}
+ */
+jsts.geom.Location.BOUNDARY = 1;
+
+
+/**
+ * The location value for the exterior of a geometry. Also, DE-9IM row index of
+ * the exterior of the first geometry and column index of the exterior of the
+ * second geometry.
+ *
+ * @const
+ * @type {number}
+ */
+jsts.geom.Location.EXTERIOR = 2;
+
+
+/**
+ * Used for uninitialized location values.
+ *
+ * @const
+ * @type {number}
+ */
+jsts.geom.Location.NONE = -1;
+
+
+/**
+ * Converts the location value to a location symbol, for example,
+ * <code>EXTERIOR => 'e'</code> .
+ *
+ * @param {number}
+ *          locationValue either EXTERIOR, BOUNDARY, INTERIOR or NONE.
+ * @return {string} either 'e', 'b', 'i' or '-'.
+ */
+jsts.geom.Location.toLocationSymbol = function(locationValue) {
+  switch (locationValue) {
+    case jsts.geom.Location.EXTERIOR:
+      return 'e';
+    case jsts.geom.Location.BOUNDARY:
+      return 'b';
+    case jsts.geom.Location.INTERIOR:
+      return 'i';
+    case jsts.geom.Location.NONE:
+      return '-';
+  }
+  throw new jsts.IllegalArgumentError('Unknown location value: ' +
+      locationValue);
+};

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

@@ -0,0 +1,47 @@
+/* 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/geom/GeometryCollection.js
+   */
+
+  /**
+   * @constructor
+   * @extends jsts.geom.GeometryCollection
+   */
+  jsts.geom.MultiLineString = function(geometries, factory) {
+    this.geometries = geometries || [];
+    this.factory = factory;
+  };
+
+  jsts.geom.MultiLineString.prototype = new jsts.geom.GeometryCollection();
+  jsts.geom.MultiLineString.constructor = jsts.geom.MultiLineString;
+
+  jsts.geom.MultiLineString.prototype.getBoundary = function() {
+    return (new jsts.operation.BoundaryOp(this)).getBoundary();
+  };
+
+
+  /**
+   * @param {Geometry}
+   *          other
+   * @param {double}
+   *          tolerance
+   * @return {boolean}
+   */
+  jsts.geom.MultiLineString.prototype.equalsExact = function(other, tolerance) {
+    if (!this.isEquivalentClass(other)) {
+      return false;
+    }
+    return jsts.geom.GeometryCollection.prototype.equalsExact.call(this, other,
+        tolerance);
+  };
+
+  jsts.geom.MultiLineString.prototype.CLASS_NAME = 'jsts.geom.MultiLineString';
+
+})();

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

@@ -0,0 +1,64 @@
+/* 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/GeometryCollection.js
+ */
+
+(function() {
+
+  /**
+   * @requires jsts/geom/GeometryCollection.js
+   */
+
+  /**
+   * @constructor
+   * @extends jsts.geom.GeometryCollection
+   */
+  jsts.geom.MultiPoint = function(points, factory) {
+    this.geometries = points || [];
+    this.factory = factory;
+  };
+
+  jsts.geom.MultiPoint.prototype = new jsts.geom.GeometryCollection();
+  jsts.geom.MultiPoint.constructor = jsts.geom.MultiPoint;
+
+
+
+  /**
+   * Gets the boundary of this geometry. Zero-dimensional geometries have no
+   * boundary by definition, so an empty GeometryCollection is returned.
+   *
+   * @return {Geometry} an empty GeometryCollection.
+   * @see Geometry#getBoundary
+   */
+  jsts.geom.MultiPoint.prototype.getBoundary = function() {
+    return this.getFactory().createGeometryCollection(null);
+  };
+
+  jsts.geom.MultiPoint.prototype.getGeometryN = function(n) {
+    return this.geometries[n];
+  };
+
+
+  /**
+   * @param {Geometry}
+   *          other
+   * @param {double}
+   *          tolerance
+   * @return {boolean}
+   */
+  jsts.geom.MultiPoint.prototype.equalsExact = function(other, tolerance) {
+    if (!this.isEquivalentClass(other)) {
+      return false;
+    }
+    return jsts.geom.GeometryCollection.prototype.equalsExact.call(this, other,
+        tolerance);
+  };
+
+  jsts.geom.MultiPoint.prototype.CLASS_NAME = 'jsts.geom.MultiPoint';
+
+})();

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

@@ -0,0 +1,64 @@
+/* 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/geom/GeometryCollection.js
+   */
+
+  /**
+   * @constructor
+   * @extends jsts.geom.GeometryCollection
+   */
+  jsts.geom.MultiPolygon = function(geometries, factory) {
+    this.geometries = geometries || [];
+    this.factory = factory;
+  };
+
+  jsts.geom.MultiPolygon.prototype = new jsts.geom.GeometryCollection();
+  jsts.geom.MultiPolygon.constructor = jsts.geom.MultiPolygon;
+
+  /**
+   * Computes the boundary of this geometry
+   *
+   * @return {Geometry} a lineal geometry (which may be empty).
+   * @see Geometry#getBoundary
+   */
+  jsts.geom.MultiPolygon.prototype.getBoundary = function() {
+    if (this.isEmpty()) {
+      return this.getFactory().createMultiLineString(null);
+    }
+    var allRings = [];
+    for (var i = 0; i < this.geometries.length; i++) {
+      var polygon = this.geometries[i];
+      var rings = polygon.getBoundary();
+      for (var j = 0; j < rings.getNumGeometries(); j++) {
+        allRings.push(rings.getGeometryN(j));
+      }
+    }
+    return this.getFactory().createMultiLineString(allRings);
+  };
+
+
+  /**
+   * @param {Geometry}
+   *          other
+   * @param {double}
+   *          tolerance
+   * @return {boolean}
+   */
+  jsts.geom.MultiPolygon.prototype.equalsExact = function(other, tolerance) {
+    if (!this.isEquivalentClass(other)) {
+      return false;
+    }
+    return jsts.geom.GeometryCollection.prototype.equalsExact.call(this, other,
+        tolerance);
+  };
+
+  jsts.geom.MultiPolygon.prototype.CLASS_NAME = 'jsts.geom.MultiPolygon';
+
+})();

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

@@ -0,0 +1,197 @@
+/* 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/Coordinate.js
+ * @requires jsts/geom/Geometry.js
+ */
+
+
+
+/**
+ * @constructor
+ * @extends jsts.geom.Geometry
+ */
+jsts.geom.Point = function(coordinate, factory) {
+  this.factory = factory;
+
+  if (coordinate === undefined)
+    return;
+
+  this.coordinate = coordinate;
+};
+
+jsts.geom.Point.prototype = new jsts.geom.Geometry();
+jsts.geom.Point.constructor = jsts.geom.Point;
+
+
+jsts.geom.Point.CLASS_NAME = 'jsts.geom.Point';
+
+
+jsts.geom.Point.prototype.coordinate = null;
+
+
+/**
+ * @return {number} x-axis value of this Point.
+ */
+jsts.geom.Point.prototype.getX = function() {
+  return this.coordinate.x;
+};
+
+
+/**
+ * @return {number} y-axis value of this Point.
+ */
+jsts.geom.Point.prototype.getY = function() {
+  return this.coordinate.y;
+};
+
+jsts.geom.Point.prototype.getCoordinate = function() {
+  return this.coordinate;
+};
+
+
+/**
+ * @return {Coordinate[]} this Point as coordinate array.
+ */
+jsts.geom.Point.prototype.getCoordinates = function() {
+  return this.isEmpty() ? [] : [this.coordinate];
+};
+
+jsts.geom.Point.prototype.isEmpty = function() {
+  return this.coordinate === null;
+};
+
+jsts.geom.Point.prototype.equalsExact = function(other, tolerance) {
+  if (!this.isEquivalentClass(other)) {
+    return false;
+  }
+  if (this.isEmpty() && other.isEmpty()) {
+    return true;
+  }
+  return this.equal(other.getCoordinate(), this.getCoordinate(), tolerance);
+};
+
+
+/**
+ * @return {number} number of coordinates (0 or 1).
+ */
+jsts.geom.Point.prototype.getNumPoints = function() {
+  return this.isEmpty() ? 0 : 1;
+};
+
+
+/**
+ * @return {boolean} Point is always simple.
+ */
+jsts.geom.Point.prototype.isSimple = function() {
+  return true;
+};
+
+
+/**
+ * Gets the boundary of this geometry. Zero-dimensional geometries have no
+ * boundary by definition, so an empty GeometryCollection is returned.
+ *
+ * @return {GeometryCollection} an empty GeometryCollection.
+ * @see Geometry#getBoundary
+ */
+jsts.geom.Point.prototype.getBoundary = function() {
+  return new jsts.geom.GeometryCollection(null);
+};
+
+
+/**
+ * @return {Envelope} Envelope of this point.
+ */
+jsts.geom.Point.prototype.computeEnvelopeInternal = function() {
+  if (this.isEmpty()) {
+    return new jsts.geom.Envelope();
+  }
+  return new jsts.geom.Envelope(this.coordinate);
+};
+
+jsts.geom.Point.prototype.apply = function(filter) {
+  if (filter instanceof jsts.geom.GeometryFilter || filter instanceof jsts.geom.GeometryComponentFilter) {
+    filter.filter(this);
+  } else if (filter instanceof jsts.geom.CoordinateFilter) {
+    if (this.isEmpty()) { return; }
+    filter.filter(this.getCoordinate());
+  }
+
+};
+
+jsts.geom.Point.prototype.clone = function() {
+  return new jsts.geom.Point(this.coordinate.clone(), this.factory);
+};
+
+
+/**
+ * @return {number} Always 0.
+ */
+jsts.geom.Point.prototype.getDimension = function() {
+  return 0;
+};
+
+
+/**
+ * @return {number} Always Dimension.FALSE.
+ */
+jsts.geom.Point.prototype.getBoundaryDimension = function() {
+  return jsts.geom.Dimension.FALSE;
+};
+
+
+/**
+ * @return {Point} Reversed point is a cloned point.
+ */
+jsts.geom.Point.prototype.reverse = function() {
+  return this.clone();
+};
+
+
+/**
+ * A Point is valid iff:
+ * <ul>
+ * <li>the coordinate which defines it is a valid coordinate (i.e does not have
+ * an NaN X or Y ordinate)
+ * </ul>
+ *
+ * @return {boolean} true iff the Point is valid.
+ */
+jsts.geom.Point.prototype.isValid = function() {
+  if (!jsts.operation.valid.IsValidOp.isValid(this.getCoordinate())) {
+    return false;
+  }
+  return true;
+};
+
+
+/**
+ *
+ */
+jsts.geom.Point.prototype.normalize = function() {
+  // a Point is always in normalized form
+};
+
+jsts.geom.Point.prototype.compareToSameClass = function(other) {
+  var point = other;
+  return this.getCoordinate().compareTo(point.getCoordinate());
+};
+
+/**
+ * @return {string} String representation of Point type.
+ */
+jsts.geom.Point.prototype.getGeometryType = function() {
+  return 'Point';
+};
+
+jsts.geom.Point.prototype.hashCode = function() {
+  return 'Point_' + this.coordinate.hashCode();
+};
+
+jsts.geom.Point.prototype.CLASS_NAME = 'jsts.geom.Point';