jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/algorithm/distance/DiscreteHausdorffDistance.js

@@ -0,0 +1,228 @@
+/* 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/algorithm/distance/DiscreteHausdorffDistance.java
+ * Revision: 6
+ */
+
+/**
+ * @requires jsts/geom/CoordinateFilter.js
+ * @requires jsts/geom/CoordinateSequenceFilter.js
+ * @requires jsts/algorithm/distance/PointPairDistance.js
+ * @requires jsts/algorithm/distance/DistanceToPoint.js
+ */
+
+(function() {
+
+  var PointPairDistance = jsts.algorithm.distance.PointPairDistance;
+  var DistanceToPoint = jsts.algorithm.distance.DistanceToPoint;
+
+  var MaxPointDistanceFilter = function(geom) {
+    this.maxPtDist = new PointPairDistance();
+    this.minPtDist = new PointPairDistance();
+    this.euclideanDist = new DistanceToPoint();
+
+    this.geom = geom;
+  };
+
+  MaxPointDistanceFilter.prototype = new jsts.geom.CoordinateFilter();
+
+  MaxPointDistanceFilter.prototype.maxPtDist = new PointPairDistance();
+  MaxPointDistanceFilter.prototype.minPtDist = new PointPairDistance();
+  MaxPointDistanceFilter.prototype.euclideanDist = new DistanceToPoint();
+  MaxPointDistanceFilter.prototype.geom;
+
+  MaxPointDistanceFilter.prototype.filter = function(pt) {
+    this.minPtDist.initialize();
+    DistanceToPoint.computeDistance(this.geom, pt, this.minPtDist);
+    this.maxPtDist.setMaximum(this.minPtDist);
+  };
+
+  MaxPointDistanceFilter.prototype.getMaxPointDistance = function() {
+    return this.maxPtDist;
+  };
+
+
+  var MaxDensifiedByFractionDistanceFilter = function(geom, fraction) {
+    this.maxPtDist = new PointPairDistance();
+    this.minPtDist = new PointPairDistance();
+
+    this.geom = geom;
+    // NOTE: Math.rint in JTS changed to Math.round
+    this.numSubSegs = Math.round(1.0 / fraction);
+  };
+
+  MaxDensifiedByFractionDistanceFilter.prototype = new jsts.geom.CoordinateSequenceFilter();
+
+  MaxDensifiedByFractionDistanceFilter.prototype.maxPtDist = new PointPairDistance();
+  MaxDensifiedByFractionDistanceFilter.prototype.minPtDist = new PointPairDistance();
+  MaxDensifiedByFractionDistanceFilter.prototype.geom;
+  MaxDensifiedByFractionDistanceFilter.prototype.numSubSegs = 0;
+
+  MaxDensifiedByFractionDistanceFilter.prototype.filter = function(seq, index) {
+    /**
+     * This logic also handles skipping Point geometries
+     */
+    if (index == 0)
+      return;
+
+    var p0 = seq[index - 1];
+    var p1 = seq[index];
+
+    var delx = (p1.x - p0.x) / this.numSubSegs;
+    var dely = (p1.y - p0.y) / this.numSubSegs;
+
+    for (var i = 0; i < this.numSubSegs; i++) {
+      var x = p0.x + i * delx;
+      var y = p0.y + i * dely;
+      var pt = new jsts.geom.Coordinate(x, y);
+      this.minPtDist.initialize();
+      DistanceToPoint.computeDistance(this.geom, pt, this.minPtDist);
+      this.maxPtDist.setMaximum(this.minPtDist);
+    }
+  };
+
+  MaxDensifiedByFractionDistanceFilter.prototype.isGeometryChanged = function() {
+    return false;
+  };
+
+  MaxDensifiedByFractionDistanceFilter.prototype.isDone = function() {
+    return false;
+  };
+
+  MaxDensifiedByFractionDistanceFilter.prototype.getMaxPointDistance = function() {
+    return this.maxPtDist;
+  };
+
+  /**
+   * An algorithm for computing a distance metric which is an approximation to
+   * the Hausdorff Distance based on a discretization of the input
+   * {@link Geometry}. The algorithm computes the Hausdorff distance restricted
+   * to discrete points for one of the geometries. The points can be either the
+   * vertices of the geometries (the default), or the geometries with line
+   * segments densified by a given fraction. Also determines two points of the
+   * Geometries which are separated by the computed distance.
+   * <p>
+   * This algorithm is an approximation to the standard Hausdorff distance.
+   * Specifically,
+   *
+   * <pre>
+   *    for all geometries a, b:    DHD(a, b) &lt;= HD(a, b)
+   * </pre>
+   *
+   * The approximation can be made as close as needed by densifying the input
+   * geometries. In the limit, this value will approach the true Hausdorff
+   * distance:
+   *
+   * <pre>
+   *    DHD(A, B, densifyFactor) -&gt; HD(A, B) as densifyFactor -&gt; 0.0
+   * </pre>
+   *
+   * The default approximation is exact or close enough for a large subset of
+   * useful cases. Examples of these are:
+   * <ul>
+   * <li>computing distance between Linestrings that are roughly parallel to
+   * each other, and roughly equal in length. This occurs in matching linear
+   * networks.
+   * <li>Testing similarity of geometries.
+   * </ul>
+   * An example where the default approximation is not close is:
+   *
+   * <pre>
+   *   A = LINESTRING (0 0, 100 0, 10 100, 10 100)
+   *   B = LINESTRING (0 100, 0 10, 80 10)
+   *
+   *   DHD(A, B) = 22.360679774997898
+   *   HD(A, B) &tilde;= 47.8
+   * </pre>
+   */
+  jsts.algorithm.distance.DiscreteHausdorffDistance = function(g0, g1) {
+    this.g0 = g0;
+    this.g1 = g1;
+
+    this.ptDist = new jsts.algorithm.distance.PointPairDistance();
+  };
+
+  jsts.algorithm.distance.DiscreteHausdorffDistance.prototype.g0 = null;
+  jsts.algorithm.distance.DiscreteHausdorffDistance.prototype.g1 = null;
+  jsts.algorithm.distance.DiscreteHausdorffDistance.prototype.ptDist = null;
+  /**
+   * Value of 0.0 indicates that no densification should take place
+   */
+  jsts.algorithm.distance.DiscreteHausdorffDistance.prototype.densifyFrac = 0.0;
+
+  jsts.algorithm.distance.DiscreteHausdorffDistance.distance = function(g0, g1,
+      densifyFrac) {
+    var dist = new jsts.algorithm.distance.DiscreteHausdorffDistance(g0, g1);
+    if (densifyFrac !== undefined)
+      dist.setDensifyFraction(densifyFrac);
+    return dist.distance();
+  };
+
+
+  /**
+   * Sets the fraction by which to densify each segment. Each segment will be
+   * (virtually) split into a number of equal-length subsegments, whose fraction
+   * of the total length is closest to the given fraction.
+   *
+   * @param densifyPercent
+   */
+  jsts.algorithm.distance.DiscreteHausdorffDistance.prototype.setDensifyFraction = function(
+      densifyFrac) {
+    if (densifyFrac > 1.0 || densifyFrac <= 0.0)
+      throw new jsts.error.IllegalArgumentError(
+          'Fraction is not in range (0.0 - 1.0]');
+
+    this.densifyFrac = densifyFrac;
+  };
+
+  jsts.algorithm.distance.DiscreteHausdorffDistance.prototype.distance = function() {
+    this.compute(this.g0, this.g1);
+    return ptDist.getDistance();
+  };
+
+  jsts.algorithm.distance.DiscreteHausdorffDistance.prototype.orientedDistance = function() {
+    this.computeOrientedDistance(this.g0, this.g1, this.ptDist);
+    return this.ptDist.getDistance();
+  };
+
+  jsts.algorithm.distance.DiscreteHausdorffDistance.prototype.getCoordinates = function() {
+    return ptDist.getCoordinates();
+  };
+
+  /**
+   *
+   * @private
+   */
+  jsts.algorithm.distance.DiscreteHausdorffDistance.prototype.compute = function(
+      g0, g1) {
+    this.computeOrientedDistance(g0, g1, this.ptDist);
+    this.computeOrientedDistance(g1, g0, this.ptDist);
+  };
+
+  /**
+   *
+   * @private
+   */
+  jsts.algorithm.distance.DiscreteHausdorffDistance.prototype.computeOrientedDistance = function(
+      discreteGeom, geom, ptDist) {
+    var distFilter = new MaxPointDistanceFilter(geom);
+    discreteGeom.apply(distFilter);
+    ptDist.setMaximum(distFilter.getMaxPointDistance());
+
+    if (this.densifyFrac > 0) {
+      var fracFilter = new MaxDensifiedByFractionDistanceFilter(geom,
+          this.densifyFrac);
+      discreteGeom.apply(fracFilter);
+      ptDist.setMaximum(fracFilter.getMaxPointDistance());
+
+    }
+  };
+
+
+})();

data/vendor/assets/javascripts/jsts/algorithm/distance/DistanceToPoint.js

@@ -0,0 +1,68 @@
+/* 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/algorithm/distance/DistanceToPoint.java
+ * Revision: 6
+ */
+
+/**
+ * @requires jsts/geom/Polygon.js
+ */
+
+/**
+ * Computes the Euclidean distance (L2 metric) from a Point to a Geometry. Also
+ * computes two points which are separated by the distance.
+ */
+jsts.algorithm.distance.DistanceToPoint = function() {
+
+};
+
+jsts.algorithm.distance.DistanceToPoint.computeDistance = function(geom, pt,
+    ptDist) {
+  if (geom instanceof jsts.geom.LineString) {
+    jsts.algorithm.distance.DistanceToPoint.computeDistance2(geom, pt, ptDist);
+  } else if (geom instanceof jsts.geom.Polygon) {
+    jsts.algorithm.distance.DistanceToPoint.computeDistance4(geom, pt, ptDist);
+  } else if (geom instanceof jsts.geom.GeometryCollection) {
+    var gc = geom;
+    for (var i = 0; i < gc.getNumGeometries(); i++) {
+      var g = gc.getGeometryN(i);
+      jsts.algorithm.distance.DistanceToPoint.computeDistance(g, pt, ptDist);
+    }
+  } else { // assume geom is Point
+    ptDist.setMinimum(geom.getCoordinate(), pt);
+  }
+};
+
+jsts.algorithm.distance.DistanceToPoint.computeDistance2 = function(line, pt,
+    ptDist) {
+  var tempSegment = new jsts.geom.LineSegment();
+
+  var coords = line.getCoordinates();
+  for (var i = 0; i < coords.length - 1; i++) {
+    tempSegment.setCoordinates(coords[i], coords[i + 1]);
+    // this is somewhat inefficient - could do better
+    var closestPt = tempSegment.closestPoint(pt);
+    ptDist.setMinimum(closestPt, pt);
+  }
+};
+
+jsts.algorithm.distance.DistanceToPoint.computeDistance3 = function(segment,
+    pt, ptDist) {
+  var closestPt = segment.closestPoint(pt);
+  ptDist.setMinimum(closestPt, pt);
+};
+
+jsts.algorithm.distance.DistanceToPoint.computeDistance4 = function(poly, pt,
+    ptDist) {
+  jsts.algorithm.distance.DistanceToPoint.computeDistance2(poly
+      .getExteriorRing(), pt, ptDist);
+  for (var i = 0; i < poly.getNumInteriorRing(); i++) {
+    jsts.algorithm.distance.DistanceToPoint.computeDistance2(poly
+        .getInteriorRingN(i), pt, ptDist);
+  }
+};

data/vendor/assets/javascripts/jsts/algorithm/distance/PointPairDistance.js

@@ -0,0 +1,104 @@
+/* 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/algorithm/distance/PointPairDistance.java
+ * Revision: 6
+ */
+
+/**
+ * @requires jsts/geom/Coordinate.js
+ */
+
+
+/**
+ * Contains a pair of points and the distance between them. Provides methods to
+ * update with a new point pair with either maximum or minimum distance.
+ */
+jsts.algorithm.distance.PointPairDistance = function() {
+  this.pt = [new jsts.geom.Coordinate(), new jsts.geom.Coordinate()];
+};
+
+jsts.algorithm.distance.PointPairDistance.prototype.pt = null;
+jsts.algorithm.distance.PointPairDistance.prototype.distance = NaN;
+jsts.algorithm.distance.PointPairDistance.prototype.isNull = true;
+
+/**
+ * Initializes the points, avoiding recomputing the distance.
+ *
+ * @param p0
+ * @param p1
+ * @param distance
+ *          the distance between p0 and p1.
+ */
+jsts.algorithm.distance.PointPairDistance.prototype.initialize = function(p0,
+    p1, distance) {
+  if (p0 === undefined) {
+    this.isNull = true;
+    return;
+  }
+
+  this.pt[0].setCoordinate(p0);
+  this.pt[1].setCoordinate(p1);
+  this.distance = distance !== undefined ? distance : p0.distance(p1);
+  this.isNull = false;
+};
+
+jsts.algorithm.distance.PointPairDistance.prototype.getDistance = function() {
+  return this.distance;
+};
+
+jsts.algorithm.distance.PointPairDistance.prototype.getCoordinates = function() {
+  return this.pt;
+};
+
+jsts.algorithm.distance.PointPairDistance.prototype.getCoordinate = function(i) {
+  return this.pt[i];
+};
+
+jsts.algorithm.distance.PointPairDistance.prototype.setMaximum = function(
+    ptDist) {
+  if (arguments.length === 2) {
+    this.setMaximum2.apply(this, arguments);
+    return;
+  }
+
+  this.setMaximum(ptDist.pt[0], ptDist.pt[1]);
+};
+
+jsts.algorithm.distance.PointPairDistance.prototype.setMaximum2 = function(p0,
+    p1) {
+  if (this.isNull) {
+    this.initialize(p0, p1);
+    return;
+  }
+  var dist = p0.distance(p1);
+  if (dist > this.distance)
+    this.initialize(p0, p1, dist);
+};
+
+jsts.algorithm.distance.PointPairDistance.prototype.setMinimum = function(
+    ptDist) {
+  if (arguments.length === 2) {
+    this.setMinimum2.apply(this, arguments);
+    return;
+  }
+
+  this.setMinimum(ptDist.pt[0], ptDist.pt[1]);
+};
+
+jsts.algorithm.distance.PointPairDistance.prototype.setMinimum2 = function(p0,
+    p1) {
+  if (this.isNull) {
+    this.initialize(p0, p1);
+    return;
+  }
+  var dist = p0.distance(p1);
+  if (dist < this.distance)
+    this.initialize(p0, p1, dist);
+};
+
+// NOTE: toString not ported

data/vendor/assets/javascripts/jsts/algorithm/locate/PointOnGeometryLocator.js

@@ -0,0 +1,7 @@
+/* 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.
+ */
+
+// TODO: port!

data/vendor/assets/javascripts/jsts/algorithm/locate/SimplePointInAreaLocator.js

@@ -0,0 +1,102 @@
+/* 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.
+ */
+
+
+
+/**
+ * Computes the location of points relative to a {@link Polygonal}
+ * {@link Geometry}, using a simple O(n) algorithm. This algorithm is suitable
+ * for use in cases where only one or a few points will be tested against a
+ * given area.
+ * <p>
+ * The algorithm used is only guaranteed to return correct results for points
+ * which are <b>not</b> on the boundary of the Geometry.
+ *
+ * @constructor
+ * @augments {PointOnGeometryLocator}
+ */
+jsts.algorithm.locate.SimplePointInAreaLocator = function(geom) {
+  this.geom = geom;
+};
+
+
+/**
+ * Determines the {@link Location} of a point in an areal {@link Geometry}.
+ * Currently this will never return a value of BOUNDARY.
+ *
+ * @param p
+ *          the point to test.
+ * @param geom
+ *          the areal geometry to test.
+ * @return the Location of the point in the geometry.
+ */
+jsts.algorithm.locate.SimplePointInAreaLocator.locate = function(p, geom) {
+  if (geom.isEmpty())
+    return jsts.geom.Location.EXTERIOR;
+
+  if (jsts.algorithm.locate.SimplePointInAreaLocator.containsPoint(p, geom))
+    return jsts.geom.Location.INTERIOR;
+  return jsts.geom.Location.EXTERIOR;
+};
+
+jsts.algorithm.locate.SimplePointInAreaLocator.containsPoint = function(p, geom) {
+  if (geom instanceof jsts.geom.Polygon) {
+    return jsts.algorithm.locate.SimplePointInAreaLocator
+        .containsPointInPolygon(p, geom);
+  } else if (geom instanceof jsts.geom.GeometryCollection ||
+      geom instanceof jsts.geom.MultiPoint ||
+      geom instanceof jsts.geom.MultiLineString ||
+      geom instanceof jsts.geom.MultiPolygon) {
+    for (var i = 0; i < geom.geometries.length; i++) {
+      var g2 = geom.geometries[i];
+      if (g2 !== geom)
+        if (jsts.algorithm.locate.SimplePointInAreaLocator.containsPoint(p, g2))
+          return true;
+    }
+  }
+  return false;
+};
+
+jsts.algorithm.locate.SimplePointInAreaLocator.containsPointInPolygon = function(
+    p, poly) {
+  if (poly.isEmpty())
+    return false;
+  var shell = poly.getExteriorRing();
+  if (!jsts.algorithm.locate.SimplePointInAreaLocator.isPointInRing(p, shell))
+    return false;
+  // now test if the point lies in or on the holes
+  for (var i = 0; i < poly.getNumInteriorRing(); i++) {
+    var hole = poly.getInteriorRingN(i);
+    if (jsts.algorithm.locate.SimplePointInAreaLocator.isPointInRing(p, hole))
+      return false;
+  }
+  return true;
+};
+
+
+/**
+ * Determines whether a point lies in a LinearRing, using the ring envelope to
+ * short-circuit if possible.
+ *
+ * @param p
+ *          the point to test.
+ * @param ring
+ *          a linear ring.
+ * @return true if the point lies inside the ring.
+ */
+jsts.algorithm.locate.SimplePointInAreaLocator.isPointInRing = function(p, ring) {
+  // short-circuit if point is not in ring envelope
+  if (!ring.getEnvelopeInternal().intersects(p))
+    return false;
+  return jsts.algorithm.CGAlgorithms.isPointInRing(p, ring.getCoordinates());
+};
+
+jsts.algorithm.locate.SimplePointInAreaLocator.prototype.geom = null;
+
+
+jsts.algorithm.locate.SimplePointInAreaLocator.prototype.locate = function(p) {
+  return jsts.algorithm.locate.SimplePointInAreaLocator.locate(p, geom);
+};