jsts-rails 0.1.0 → 0.2.0

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

@@ -0,0 +1,230 @@
+/* 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/Geometry.js
+   */
+
+  var Geometry = jsts.geom.Geometry;
+  var TreeSet = javascript.util.TreeSet;
+  var Arrays = javascript.util.Arrays;
+
+  /**
+   * @constructor
+   * @extends jsts.geom.Geometry
+   */
+  jsts.geom.GeometryCollection = function(geometries, factory) {
+    this.geometries = geometries || [];
+    this.factory = factory;
+  };
+
+  jsts.geom.GeometryCollection.prototype = new Geometry();
+  jsts.geom.GeometryCollection.constructor = jsts.geom.GeometryCollection;
+
+  /**
+   * @return {boolean}
+   */
+  jsts.geom.GeometryCollection.prototype.isEmpty = function() {
+    for (var i = 0, len = this.geometries.length; i < len; i++) {
+      var geometry = this.getGeometryN(i);
+
+      if (!geometry.isEmpty()) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  jsts.geom.Geometry.prototype.getArea = function() {
+    var area = 0.0;
+
+    for (var i = 0, len = this.geometries.length; i < len; i++) {
+      area += this.getGeometryN(i).getArea();
+    }
+
+    return area;
+  };
+
+  jsts.geom.Geometry.prototype.getLength = function() {
+    var length = 0.0;
+
+    for (var i = 0, len = this.geometries.length; i < len; i++) {
+      length += this.getGeometryN(i).getLength();
+    }
+
+    return length;
+  };
+
+
+  /**
+   * @return {Coordinate}
+   */
+  jsts.geom.GeometryCollection.prototype.getCoordinate = function() {
+    if (this.isEmpty())
+      return null;
+
+    return this.getGeometryN(0).getCoordinate();
+  };
+
+
+  /**
+   * Collects all coordinates of all subgeometries into an Array.
+   *
+   * Note that while changes to the coordinate objects themselves may modify the
+   * Geometries in place, the returned Array as such is only a temporary
+   * container which is not synchronized back.
+   *
+   * @return {Coordinate[]} the collected coordinates.
+   */
+  jsts.geom.GeometryCollection.prototype.getCoordinates = function() {
+    var coordinates = [];
+    var k = -1;
+    for (var i = 0, len = this.geometries.length; i < len; i++) {
+      var geometry = this.getGeometryN(i);
+
+      var childCoordinates = geometry.getCoordinates();
+      for (var j = 0; j < childCoordinates.length; j++) {
+        k++;
+        coordinates[k] = childCoordinates[j];
+      }
+    }
+    return coordinates;
+  };
+
+
+  /**
+   * @return {int}
+   */
+  jsts.geom.GeometryCollection.prototype.getNumGeometries = function() {
+    return this.geometries.length;
+  };
+
+
+  /**
+   * @param {int}
+   *          n
+   * @return {Geometry}
+   */
+  jsts.geom.GeometryCollection.prototype.getGeometryN = function(n) {
+    var geometry = this.geometries[n];
+    if (geometry instanceof jsts.geom.Coordinate) {
+      geometry = new jsts.geom.Point(geometry);
+    }
+    return geometry;
+  };
+
+
+  /**
+   * @param {Geometry}
+   *          other
+   * @param {double}
+   *          tolerance
+   * @return {boolean}
+   */
+  jsts.geom.GeometryCollection.prototype.equalsExact = function(other,
+      tolerance) {
+    if (!this.isEquivalentClass(other)) {
+      return false;
+    }
+    if (this.geometries.length !== other.geometries.length) {
+      return false;
+    }
+    for (var i = 0, len = this.geometries.length; i < len; i++) {
+      var geometry = this.getGeometryN(i);
+
+      if (!geometry.equalsExact(other.getGeometryN(i), tolerance)) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  /**
+   * Creates and returns a full copy of this {@link GeometryCollection} object.
+   * (including all coordinates contained by it).
+   *
+   * @return a clone of this instance.
+   */
+  jsts.geom.GeometryCollection.prototype.clone = function() {
+    var geometries = [];
+    for (var i = 0, len = this.geometries.length; i < len; i++) {
+      geometries.push(this.geometries[i].clone());
+    }
+    return this.factory.createGeometryCollection(geometries);
+  };
+
+  jsts.geom.GeometryCollection.prototype.normalize = function() {
+    for (var i = 0, len = this.geometries.length; i < len; i++) {
+      this.getGeometryN(i).normalize();
+    }
+    // TODO: might need to supply comparison function
+    this.geometries.sort();
+  };
+
+  jsts.geom.GeometryCollection.prototype.compareToSameClass = function(o) {
+    var theseElements = new TreeSet(Arrays.asList(this.geometries));
+    var otherElements = new TreeSet(Arrays.asList(o.geometries));
+    return this.compare(theseElements, otherElements);
+  };
+
+  jsts.geom.GeometryCollection.prototype.apply = function(filter) {
+    if (filter instanceof jsts.geom.GeometryFilter ||
+        filter instanceof jsts.geom.GeometryComponentFilter) {
+      filter.filter(this);
+      for (var i = 0, len = this.geometries.length; i < len; i++) {
+        this.getGeometryN(i).apply(filter);
+      }
+    } else if (filter instanceof jsts.geom.CoordinateFilter) {
+      for (var i = 0, len = this.geometries.length; i < len; i++) {
+        this.getGeometryN(i).apply(filter);
+      }
+    } else if (filter instanceof jsts.geom.CoordinateSequenceFilter) {
+      this.apply2.apply(this, arguments);
+    }
+  };
+
+  jsts.geom.GeometryCollection.prototype.apply2 = function(filter) {
+    if (this.geometries.length == 0)
+      return;
+    for (var i = 0; i < this.geometries.length; i++) {
+      this.geometries[i].apply(filter);
+      if (filter.isDone()) {
+        break;
+      }
+    }
+    if (filter.isGeometryChanged()) {
+      // TODO: call this.geometryChanged(); when ported
+    }
+  };
+
+  jsts.geom.GeometryCollection.prototype.getDimension = function() {
+    var dimension = jsts.geom.Dimension.FALSE;
+    for (var i = 0, len = this.geometries.length; i < len; i++) {
+      var geometry = this.getGeometryN(i);
+      dimension = Math.max(dimension, geometry.getDimension());
+    }
+    return dimension;
+  };
+
+  /**
+   * @protected
+   */
+  jsts.geom.GeometryCollection.prototype.computeEnvelopeInternal = function() {
+    var envelope = new jsts.geom.Envelope();
+    for (var i = 0, len = this.geometries.length; i < len; i++) {
+      var geometry = this.getGeometryN(i);
+      envelope.expandToInclude(geometry.getEnvelopeInternal());
+    }
+    return envelope;
+  };
+
+  jsts.geom.GeometryCollection.prototype.CLASS_NAME = 'jsts.geom.GeometryCollection';
+
+})();
+
+// TODO: port rest

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

@@ -0,0 +1,36 @@
+/* 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
+ * <code>GeometryComponentFilter</code> filter to the <code>Geometry</code>.
+ * The filter is applied to every component of the <code>Geometry</code> which
+ * is itself a <code>Geometry</code> and which does not itself contain any
+ * components. (For instance, all the {@link LinearRing}s in {@link Polygon}s
+ * are visited, but in a {@link MultiPolygon} the {@link Polygon}s themselves
+ * are not visited.) Thus the only classes of Geometry which must be handled as
+ * arguments to {@link #filter} are {@link LineString}s, {@link LinearRing}s
+ * and {@link Point}s.
+ * <p>
+ * A <code>GeometryComponentFilter</code> filter can either record information
+ * about the <code>Geometry</code> or change the <code>Geometry</code> in
+ * some way. <code>GeometryComponentFilter</code> is an example of the
+ * Gang-of-Four Visitor pattern.
+ */
+jsts.geom.GeometryComponentFilter = function() {
+};
+
+
+/**
+ * Performs an operation with or on <code>geom</code>.
+ *
+ * @param {Geometry}
+ *          geom a <code>Geometry</code> to which the filter is applied.
+ */
+jsts.geom.GeometryComponentFilter.prototype.filter = function(geom) {
+  throw new jsts.error.AbstractMethodInvocationError();
+};

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

@@ -0,0 +1,263 @@
+/* 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.
+ */
+
+/**
+ * Supplies a set of utility methods for building Geometry objects from lists
+ * of Coordinates.
+ *
+ * Note that the factory constructor methods do <b>not</b> change the input
+ * coordinates in any way.
+ *
+ * In particular, they are not rounded to the supplied <tt>PrecisionModel</tt>.
+ * It is assumed that input Coordinates meet the given precision.
+ */
+
+/**
+ * @requires jsts/geom/PrecisionModel.js
+ */
+
+/**
+ * Constructs a GeometryFactory that generates Geometries having a floating
+ * PrecisionModel and a spatial-reference ID of 0.
+ *
+ * @constructor
+ */
+jsts.geom.GeometryFactory = function(precisionModel) {
+  this.precisionModel = precisionModel || new jsts.geom.PrecisionModel();
+};
+
+jsts.geom.GeometryFactory.prototype.precisionModel = null;
+
+jsts.geom.GeometryFactory.prototype.getPrecisionModel = function() {
+  return this.precisionModel;
+};
+
+
+/**
+ * Creates a Point using the given Coordinate; a null Coordinate will create an
+ * empty Geometry.
+ *
+ * @param {Coordinate}
+ *          coordinate Coordinate to base this Point on.
+ * @return {Point} A new Point.
+ */
+jsts.geom.GeometryFactory.prototype.createPoint = function(coordinate) {
+  var point = new jsts.geom.Point(coordinate, this);
+
+  return point;
+};
+
+
+/**
+ * Creates a LineString using the given Coordinates; a null or empty array will
+ * create an empty LineString. Consecutive points must not be equal.
+ *
+ * @param {Coordinate[]}
+ *          coordinates an array without null elements, or an empty array, or
+ *          null.
+ * @return {LineString} A new LineString.
+ */
+jsts.geom.GeometryFactory.prototype.createLineString = function(coordinates) {
+  var lineString = new jsts.geom.LineString(coordinates, this);
+
+  return lineString;
+};
+
+
+/**
+ * Creates a LinearRing using the given Coordinates; a null or empty array will
+ * create an empty LinearRing. The points must form a closed and simple
+ * linestring. Consecutive points must not be equal.
+ *
+ * @param {Coordinate[]}
+ *          coordinates an array without null elements, or an empty array, or
+ *          null.
+ * @return {LinearRing} A new LinearRing.
+ */
+jsts.geom.GeometryFactory.prototype.createLinearRing = function(coordinates) {
+  var linearRing = new jsts.geom.LinearRing(coordinates, this);
+
+  return linearRing;
+};
+
+
+/**
+ * Constructs a <code>Polygon</code> with the given exterior boundary and
+ * interior boundaries.
+ *
+ * @param {LinearRing}
+ *          shell the outer boundary of the new <code>Polygon</code>, or
+ *          <code>null</code> or an empty <code>LinearRing</code> if the
+ *          empty geometry is to be created.
+ * @param {LinearRing[]}
+ *          holes the inner boundaries of the new <code>Polygon</code>, or
+ *          <code>null</code> or empty <code>LinearRing</code> s if the
+ *          empty geometry is to be created.
+ * @return {Polygon} A new Polygon.
+ */
+jsts.geom.GeometryFactory.prototype.createPolygon = function(shell, holes) {
+  var polygon = new jsts.geom.Polygon(shell, holes, this);
+
+  return polygon;
+};
+
+
+jsts.geom.GeometryFactory.prototype.createMultiPoint = function(points) {
+  if (points && points[0] instanceof jsts.geom.Coordinate) {
+    var converted = [];
+    var i;
+    for (i = 0; i < points.length; i++) {
+      converted.push(this.createPoint(points[i]));
+    }
+    points = converted;
+  }
+
+  return new jsts.geom.MultiPoint(points, this);
+};
+
+jsts.geom.GeometryFactory.prototype.createMultiLineString = function(
+    lineStrings) {
+  return new jsts.geom.MultiLineString(lineStrings, this);
+};
+
+jsts.geom.GeometryFactory.prototype.createMultiPolygon = function(polygons) {
+  return new jsts.geom.MultiPolygon(polygons, this);
+};
+
+
+/**
+ * Build an appropriate <code>Geometry</code>, <code>MultiGeometry</code>,
+ * or <code>GeometryCollection</code> to contain the <code>Geometry</code>s
+ * in it. For example:<br>
+ *
+ * <ul>
+ * <li> If <code>geomList</code> contains a single <code>Polygon</code>,
+ * the <code>Polygon</code> is returned.
+ * <li> If <code>geomList</code> contains several <code>Polygon</code>s, a
+ * <code>MultiPolygon</code> is returned.
+ * <li> If <code>geomList</code> contains some <code>Polygon</code>s and
+ * some <code>LineString</code>s, a <code>GeometryCollection</code> is
+ * returned.
+ * <li> If <code>geomList</code> is empty, an empty
+ * <code>GeometryCollection</code> is returned
+ * </ul>
+ *
+ * Note that this method does not "flatten" Geometries in the input, and hence
+ * if any MultiGeometries are contained in the input a GeometryCollection
+ * containing them will be returned.
+ *
+ * @param geomList
+ *          the <code>Geometry</code>s to combine.
+ * @return {Geometry} a <code>Geometry</code> of the "smallest", "most
+ *         type-specific" class that can contain the elements of
+ *         <code>geomList</code> .
+ */
+jsts.geom.GeometryFactory.prototype.buildGeometry = function(geomList) {
+
+  /**
+   * Determine some facts about the geometries in the list
+   */
+  var geomClass = null;
+  var isHeterogeneous = false;
+  var hasGeometryCollection = false;
+  for (var i = geomList.iterator(); i.hasNext();) {
+    var geom = i.next();
+
+    var partClass = geom.CLASS_NAME;
+
+    if (geomClass === null) {
+      geomClass = partClass;
+    }
+    if (!(partClass === geomClass)) {
+      isHeterogeneous = true;
+    }
+    if (geom.isGeometryCollectionBase())
+      hasGeometryCollection = true;
+  }
+
+  /**
+   * Now construct an appropriate geometry to return
+   */
+  // for the empty geometry, return an empty GeometryCollection
+  if (geomClass === null) {
+    return this.createGeometryCollection(null);
+  }
+  if (isHeterogeneous || hasGeometryCollection) {
+    return this.createGeometryCollection(geomList.toArray());
+  }
+  // at this point we know the collection is hetereogenous.
+  // Determine the type of the result from the first Geometry in the list
+  // this should always return a geometry, since otherwise an empty collection
+  // would have already been returned
+  var geom0 = geomList.get(0);
+  var isCollection = geomList.size() > 1;
+  if (isCollection) {
+    if (geom0 instanceof jsts.geom.Polygon) {
+      return this.createMultiPolygon(geomList.toArray());
+    } else if (geom0 instanceof jsts.geom.LineString) {
+      return this.createMultiLineString(geomList.toArray());
+    } else if (geom0 instanceof jsts.geom.Point) {
+      return this.createMultiPoint(geomList.toArray());
+    }
+    jsts.util.Assert.shouldNeverReachHere('Unhandled class: ' + geom0);
+  }
+  return geom0;
+};
+
+jsts.geom.GeometryFactory.prototype.createGeometryCollection = function(
+    geometries) {
+  return new jsts.geom.GeometryCollection(geometries, this);
+};
+
+/**
+ * Creates a {@link Geometry} with the same extent as the given envelope. The
+ * Geometry returned is guaranteed to be valid. To provide this behaviour, the
+ * following cases occur:
+ * <p>
+ * If the <code>Envelope</code> is:
+ * <ul>
+ * <li>null : returns an empty {@link Point}
+ * <li>a point : returns a non-empty {@link Point}
+ * <li>a line : returns a two-point {@link LineString}
+ * <li>a rectangle : returns a {@link Polygon}> whose points are (minx, miny),
+ * (minx, maxy), (maxx, maxy), (maxx, miny), (minx, miny).
+ * </ul>
+ *
+ * @param {jsts.geom.Envelope}
+ *          envelope the <code>Envelope</code> to convert.
+ * @return {jsts.geom.Geometry} an empty <code>Point</code> (for null
+ *         <code>Envelope</code>s), a <code>Point</code> (when min x = max
+ *         x and min y = max y) or a <code>Polygon</code> (in all other cases).
+ */
+jsts.geom.GeometryFactory.prototype.toGeometry = function(envelope) {
+  // null envelope - return empty point geometry
+  if (envelope.isNull()) {
+    return this.createPoint(null);
+  }
+
+  // point?
+  if (envelope.getMinX() === envelope.getMaxX() &&
+      envelope.getMinY() === envelope.getMaxY()) {
+    return this.createPoint(new jsts.geom.Coordinate(envelope.getMinX(),
+        envelope.getMinY()));
+  }
+
+  // vertical or horizontal line?
+  if (envelope.getMinX() === envelope.getMaxX() ||
+      envelope.getMinY() === envelope.getMaxY()) {
+    return this.createLineString([
+        new jsts.geom.Coordinate(envelope.getMinX(), envelope.getMinY()),
+        new jsts.geom.Coordinate(envelope.getMaxX(), envelope.getMaxY())]);
+  }
+
+  // create a CW ring for the polygon
+  return this.createPolygon(this.createLinearRing([
+      new jsts.geom.Coordinate(envelope.getMinX(), envelope.getMinY()),
+      new jsts.geom.Coordinate(envelope.getMinX(), envelope.getMaxY()),
+      new jsts.geom.Coordinate(envelope.getMaxX(), envelope.getMaxY()),
+      new jsts.geom.Coordinate(envelope.getMaxX(), envelope.getMinY()),
+      new jsts.geom.Coordinate(envelope.getMinX(), envelope.getMinY())]), null);
+};