jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/algorithm/MCPointInRing.js

@@ -0,0 +1,124 @@
+/* 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/index/chain/MonotoneChainSelectAction.js
+ */
+
+/**
+ * Implements {@link PointInRing} using {@link MonotoneChain}s and a
+ * {@link Bintree} index to increase performance.
+ *
+ * @see IndexedPointInAreaLocator for more general functionality
+ */
+jsts.algorithm.MCPointInRing = function(ring) {
+  this.ring = ring;
+  this.tree = null;
+  this.crossings = 0;
+  this.interval = new jsts.index.bintree.Interval();
+  this.buildIndex();
+};
+
+/**
+ *
+ * @param {jsts.geom.Coordinate}
+ *          p the input coordinate.
+ * @return {jsts.algorithm.MCPointInRing.MCSelecter}
+ * @constructor
+ */
+jsts.algorithm.MCPointInRing.MCSelecter = function(p,parent) {
+  this.parent = parent; //To be used instead of inner-class function calls
+  this.p = p;
+};
+
+jsts.algorithm.MCPointInRing.MCSelecter.prototype = new jsts.index.chain.MonotoneChainSelectAction;
+jsts.algorithm.MCPointInRing.MCSelecter.prototype.constructor = jsts.algorithm.MCPointInRing.MCSelecter;
+
+jsts.algorithm.MCPointInRing.MCSelecter.prototype.select2 = function(ls) {
+  this.parent.testLineSegment.apply(this.parent, [this.p, ls]);
+  //this.testLineSegment(this.p, ls);
+};
+
+jsts.algorithm.MCPointInRing.prototype.buildIndex = function() {
+  this.tree = new jsts.index.bintree.Bintree();
+
+  var pts = jsts.geom.CoordinateArrays.removeRepeatedPoints(this.ring
+      .getCoordinates());
+
+  var mcList = jsts.index.chain.MonotoneChainBuilder.getChains(pts);
+
+  for (var i = 0; i < mcList.length; i++) {
+    var mc = mcList[i];
+    var mcEnv = mc.getEnvelope();
+    this.interval.min = mcEnv.getMinY();
+    this.interval.max = mcEnv.getMaxY();
+    this.tree.insert(this.interval, mc);
+  }
+};
+
+jsts.algorithm.MCPointInRing.prototype.isInside = function(pt) {
+  this.crossings = 0;
+
+  // test all segments intersected by ray from pt in positive x direction
+  var rayEnv = new jsts.geom.Envelope(-Number.MAX_VALUE, Number.MAX_VALUE, pt.y,
+      pt.y);
+
+  this.interval.min = pt.y;
+  this.interval.max = pt.y;
+
+  var segs = this.tree.query(this.interval);
+
+  var mcSelecter = new jsts.algorithm.MCPointInRing.MCSelecter(pt, this);
+
+  for (var i = segs.iterator(); i.hasNext();) {
+    var mc = i.next();
+    this.testMonotoneChain(rayEnv, mcSelecter, mc);
+  }
+
+  /*
+   *  p is inside if number of crossings is odd.
+   */
+  if ((this.crossings % 2) == 1) {
+    return true;
+  }
+  return false;
+
+};
+
+jsts.algorithm.MCPointInRing.prototype.testMonotoneChain = function(rayEnv,
+    mcSelecter, mc) {
+  mc.select(rayEnv, mcSelecter);
+};
+
+jsts.algorithm.MCPointInRing.prototype.testLineSegment = function(p, seg) {
+  var xInt, x1, y1, x2, y2, p1, p2;
+
+  /*
+   *  Test if segment crosses ray from test point in positive x direction.
+   */
+  p1 = seg.p0;
+  p2 = seg.p1;
+
+  x1 = p1.x - p.x;
+  y1 = p1.y - p.y;
+  x2 = p2.x - p.x;
+  y2 = p2.y - p.y;
+
+  if (((y1 > 0) && (y2 <= 0)) || ((y2 > 0) && (y1 <= 0))) {
+    /*
+     *  segment straddles x axis, so compute intersection.
+     */
+    xInt = jsts.algorithm.RobustDeterminant.signOfDet2x2(x1, y1, x2, y2) /
+        (y2 - y1);
+    // xsave = xInt;
+    /*
+     *  crosses ray if strictly positive intersection.
+     */
+    if (0.0 < xInt) {
+      this.crossings++;
+    }
+  }
+};

data/vendor/assets/javascripts/jsts/algorithm/PointLocator.js

@@ -0,0 +1,247 @@
+/* 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 topological ({@link Location}) of a single point to a
+ * {@link Geometry}. A {@link BoundaryNodeRule} may be specified to control the
+ * evaluation of whether the point lies on the boundary or not The default rule
+ * is to use the the <i>SFS Boundary Determination Rule</i>
+ * <p>
+ * Notes:
+ * <ul>
+ * <li>{@link LinearRing}s do not enclose any area - points inside the ring
+ * are still in the EXTERIOR of the ring.
+ * </ul>
+ * Instances of this class are not reentrant.
+ *
+ * @constructor
+ */
+jsts.algorithm.PointLocator = function(boundaryRule) {
+  this.boundaryRule = boundaryRule ? boundaryRule
+      : jsts.algorithm.BoundaryNodeRule.OGC_SFS_BOUNDARY_RULE;
+};
+
+
+/**
+ * default is to use OGC SFS rule
+ *
+ * @type {BoundaryNodeRule}
+ * @private
+ */
+jsts.algorithm.PointLocator.prototype.boundaryRule = null;
+
+
+/**
+ * true if the point lies in or on any Geometry element
+ *
+ * @type {boolean}
+ * @private
+ */
+jsts.algorithm.PointLocator.prototype.isIn = null;
+
+
+/**
+ * the number of sub-elements whose boundaries the point lies in
+ *
+ * @type {int}
+ * @private
+ */
+jsts.algorithm.PointLocator.prototype.numBoundaries = null;
+
+
+/**
+ * Convenience method to test a point for intersection with a Geometry
+ *
+ * @param {Coordinate}
+ *          p the coordinate to test.
+ * @param {Geometry}
+ *          geom the Geometry to test.
+ * @return {boolean} <code>true</code> if the point is in the interior or
+ *         boundary of the Geometry.
+ */
+jsts.algorithm.PointLocator.prototype.intersects = function(p, geom) {
+  return this.locate(p, geom) !== jsts.geom.Location.EXTERIOR;
+};
+
+
+/**
+ * Computes the topological relationship ({@link Location}) of a single point
+ * to a Geometry. It handles both single-element and multi-element Geometries.
+ * The algorithm for multi-part Geometries takes into account the SFS Boundary
+ * Determination Rule.
+ *
+ * @param {Coordinate}
+ *          p the coordinate to test.
+ * @param {Geometry}
+ *          geom the Geometry to test.
+ * @return {int} the {@link Location} of the point relative to the input
+ *         Geometry.
+ */
+jsts.algorithm.PointLocator.prototype.locate = function(p, geom) {
+  if (geom.isEmpty())
+    return jsts.geom.Location.EXTERIOR;
+
+  if (geom instanceof jsts.geom.Point) {
+    return this.locate2(p, geom);
+  } else if (geom instanceof jsts.geom.LineString) {
+    return this.locate3(p, geom);
+  } else if (geom instanceof jsts.geom.Polygon) {
+    return this.locate4(p, geom);
+  }
+
+  this.isIn = false;
+  this.numBoundaries = 0;
+  this.computeLocation(p, geom);
+  if (this.boundaryRule.isInBoundary(this.numBoundaries))
+    return jsts.geom.Location.BOUNDARY;
+  if (this.numBoundaries > 0 || this.isIn)
+    return jsts.geom.Location.INTERIOR;
+
+  return jsts.geom.Location.EXTERIOR;
+};
+
+
+/**
+ * @param {Coordinate}
+ *          p the coordinate to test.
+ * @param {Geometry}
+ *          geom the Geometry to test.
+ * @private
+ */
+jsts.algorithm.PointLocator.prototype.computeLocation = function(p, geom) {
+  if (geom instanceof jsts.geom.Point || geom instanceof jsts.geom.LineString ||
+      geom instanceof jsts.geom.Polygon) {
+    this.updateLocationInfo(this.locate(p, geom));
+  } else if (geom instanceof jsts.geom.MultiLineString) {
+    var ml = geom;
+    for (var i = 0; i < ml.getNumGeometries(); i++) {
+      var l = ml.getGeometryN(i);
+      this.updateLocationInfo(this.locate(p, l));
+    }
+  } else if (geom instanceof jsts.geom.MultiPolygon) {
+    var mpoly = geom;
+    for (var i = 0; i < mpoly.getNumGeometries(); i++) {
+      var poly = mpoly.getGeometryN(i);
+      this.updateLocationInfo(this.locate(p, poly));
+    }
+  } else if (geom instanceof jsts.geom.MultiPoint || geom instanceof jsts.geom.GeometryCollection) {
+    for (var i = 0; i < geom.getNumGeometries(); i++) {
+      var part = geom.getGeometryN(i);
+      if (part !== geom) {
+        this.computeLocation(p, part);
+      }
+    }
+  }
+};
+
+
+/**
+ * @param {int}
+ *          loc
+ * @return {int}
+ * @private
+ */
+jsts.algorithm.PointLocator.prototype.updateLocationInfo = function(loc) {
+  if (loc === jsts.geom.Location.INTERIOR)
+    this.isIn = true;
+  if (loc === jsts.geom.Location.BOUNDARY)
+    this.numBoundaries++;
+};
+
+
+/**
+ * @param {Coordinate}
+ *          p the coordinate to test.
+ * @param {Point}
+ *          pt the Point to test.
+ * @return {int}
+ * @private
+ */
+jsts.algorithm.PointLocator.prototype.locate2 = function(p, pt) {
+  // no point in doing envelope test, since equality test is just as fast
+
+  var ptCoord = pt.getCoordinate();
+  if (ptCoord.equals2D(p))
+    return jsts.geom.Location.INTERIOR;
+  return jsts.geom.Location.EXTERIOR;
+};
+
+
+/**
+ * @param {Coordinate}
+ *          p the coordinate to test.
+ * @param {LineString}
+ *          l the LineString to test.
+ * @return {int}
+ * @private
+ */
+jsts.algorithm.PointLocator.prototype.locate3 = function(p, l) {
+  // bounding-box check
+  if (!l.getEnvelopeInternal().intersects(p))
+    return jsts.geom.Location.EXTERIOR;
+
+  var pt = l.getCoordinates();
+  if (!l.isClosed()) {
+    if (p.equals(pt[0]) || p.equals(pt[pt.length - 1])) {
+      return jsts.geom.Location.BOUNDARY;
+    }
+  }
+  if (jsts.algorithm.CGAlgorithms.isOnLine(p, pt))
+    return jsts.geom.Location.INTERIOR;
+  return jsts.geom.Location.EXTERIOR;
+};
+
+
+/**
+ * @param {Coordinate}
+ *          p the coordinate to test.
+ * @param {LinearRing}
+ *          ring the LinearRing to test.
+ * @return {int}
+ * @private
+ */
+jsts.algorithm.PointLocator.prototype.locateInPolygonRing = function(p, ring) {
+  // bounding-box check
+  if (!ring.getEnvelopeInternal().intersects(p))
+    return jsts.geom.Location.EXTERIOR;
+
+  return jsts.algorithm.CGAlgorithms
+      .locatePointInRing(p, ring.getCoordinates());
+};
+
+
+/**
+ * @param {Coordinate}
+ *          p the coordinate to test.
+ * @param {Polygon}
+ *          poly the LinearRing to test.
+ * @return {int}
+ * @private
+ */
+jsts.algorithm.PointLocator.prototype.locate4 = function(p, poly) {
+  if (poly.isEmpty())
+    return jsts.geom.Location.EXTERIOR;
+
+  var shell = poly.getExteriorRing();
+
+  var shellLoc = this.locateInPolygonRing(p, shell);
+  if (shellLoc === jsts.geom.Location.EXTERIOR)
+    return jsts.geom.Location.EXTERIOR;
+  if (shellLoc === jsts.geom.Location.BOUNDARY)
+    return jsts.geom.Location.BOUNDARY;
+  // now test if the point lies in or on the holes
+  for (var i = 0; i < poly.getNumInteriorRing(); i++) {
+    var hole = poly.getInteriorRingN(i);
+    var holeLoc = this.locateInPolygonRing(p, hole);
+    if (holeLoc === jsts.geom.Location.INTERIOR)
+      return jsts.geom.Location.EXTERIOR;
+    if (holeLoc === jsts.geom.Location.BOUNDARY)
+      return jsts.geom.Location.BOUNDARY;
+  }
+  return jsts.geom.Location.INTERIOR;
+};

data/vendor/assets/javascripts/jsts/algorithm/RayCrossingCounter.js

@@ -0,0 +1,215 @@
+/* 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.
+ */
+
+
+
+/**
+ * Counts the number of segments crossed by a horizontal ray extending to the
+ * right from a given point, in an incremental fashion. This can be used to
+ * determine whether a point lies in a {@link Polygonal} geometry. The class
+ * determines the situation where the point lies exactly on a segment. When
+ * being used for Point-In-Polygon determination, this case allows
+ * short-circuiting the evaluation.
+ * <p>
+ * This class handles polygonal geometries with any number of shells and holes.
+ * The orientation of the shell and hole rings is unimportant. In order to
+ * compute a correct location for a given polygonal geometry, it is essential
+ * that <b>all</b> segments are counted which
+ * <ul>
+ * <li>touch the ray
+ * <li>lie in in any ring which may contain the point
+ * </ul>
+ * The only exception is when the point-on-segment situation is detected, in
+ * which case no further processing is required. The implication of the above
+ * rule is that segments which can be a priori determined to <i>not</i> touch
+ * the ray (i.e. by a test of their bounding box or Y-extent) do not need to be
+ * counted. This allows for optimization by indexing.
+ *
+ * @constructor
+ */
+jsts.algorithm.RayCrossingCounter = function(p) {
+  this.p = p;
+};
+
+
+/**
+ * Determines the {@link Location} of a point in a ring. This method is an
+ * exemplar of how to use this class.
+ *
+ * @param {Coordinate}
+ *          p the point to test.
+ * @param {Coordinate[]}
+ *          ring an array of Coordinates forming a ring.
+ * @return {int} the location of the point in the ring.
+ */
+jsts.algorithm.RayCrossingCounter.locatePointInRing = function(p, ring) {
+  var counter = new jsts.algorithm.RayCrossingCounter(p);
+
+  for (var i = 1; i < ring.length; i++) {
+    var p1 = ring[i];
+    var p2 = ring[i - 1];
+    counter.countSegment(p1, p2);
+    if (counter.isOnSegment())
+      return counter.getLocation();
+  }
+  return counter.getLocation();
+};
+
+
+/**
+ * @type {Coordinate}
+ * @private
+ */
+jsts.algorithm.RayCrossingCounter.prototype.p = null;
+
+
+/**
+ * @type {int}
+ * @private
+ */
+jsts.algorithm.RayCrossingCounter.prototype.crossingCount = 0;
+
+
+/**
+ * true if the test point lies on an input segment
+ *
+ * @type {boolean}
+ * @private
+ */
+jsts.algorithm.RayCrossingCounter.prototype.isPointOnSegment = false;
+
+
+/**
+ * Counts a segment
+ *
+ * @param {Coordinate}
+ *          p1 an endpoint of the segment.
+ * @param {Coordinate}
+ *          p2 another endpoint of the segment.
+ */
+jsts.algorithm.RayCrossingCounter.prototype.countSegment = function(p1, p2) {
+  /**
+   * For each segment, check if it crosses a horizontal ray running from the
+   * test point in the positive x direction.
+   */
+
+  // check if the segment is strictly to the left of the test point
+  if (p1.x < this.p.x && p2.x < this.p.x)
+    return;
+
+  // check if the point is equal to the current ring vertex
+  if (this.p.x == p2.x && this.p.y === p2.y) {
+    this.isPointOnSegment = true;
+    return;
+  }
+  /**
+   * For horizontal segments, check if the point is on the segment. Otherwise,
+   * horizontal segments are not counted.
+   */
+  if (p1.y === this.p.y && p2.y === this.p.y) {
+    var minx = p1.x;
+    var maxx = p2.x;
+    if (minx > maxx) {
+      minx = p2.x;
+      maxx = p1.x;
+    }
+    if (this.p.x >= minx && this.p.x <= maxx) {
+      this.isPointOnSegment = true;
+    }
+    return;
+  }
+  /**
+   * Evaluate all non-horizontal segments which cross a horizontal ray to the
+   * right of the test pt. To avoid double-counting shared vertices, we use the
+   * convention that
+   * <ul>
+   * <li>an upward edge includes its starting endpoint, and excludes its final
+   * endpoint
+   * <li>a downward edge excludes its starting endpoint, and includes its final
+   * endpoint
+   * </ul>
+   */
+  if (((p1.y > this.p.y) && (p2.y <= this.p.y)) || ((p2.y > this.p.y) && (p1.y <= this.p.y))) {
+    // translate the segment so that the test point lies on the origin
+    var x1 = p1.x - this.p.x;
+    var y1 = p1.y - this.p.y;
+    var x2 = p2.x - this.p.x;
+    var y2 = p2.y - this.p.y;
+
+    /**
+     * The translated segment straddles the x-axis. Compute the sign of the
+     * ordinate of intersection with the x-axis. (y2 != y1, so denominator will
+     * never be 0.0)
+     */
+    // double xIntSign = RobustDeterminant.signOfDet2x2(x1, y1, x2, y2) / (y2
+    // - y1);
+    // MD - faster & more robust computation?
+    var xIntSign = jsts.algorithm.RobustDeterminant.signOfDet2x2(x1, y1, x2, y2);
+    if (xIntSign === 0.0) {
+      this.isPointOnSegment = true;
+      return;
+    }
+    if (y2 < y1)
+      xIntSign = -xIntSign;
+    // xsave = xInt;
+
+    // System.out.println("xIntSign(" + x1 + ", " + y1 + ", " + x2 + ", " + y2
+    // + " = " + xIntSign);
+    // The segment crosses the ray if the sign is strictly positive.
+    if (xIntSign > 0.0) {
+      this.crossingCount++;
+    }
+  }
+};
+
+
+/**
+ * Reports whether the point lies exactly on one of the supplied segments. This
+ * method may be called at any time as segments are processed. If the result of
+ * this method is <tt>true</tt>, no further segments need be supplied, since
+ * the result will never change again.
+ *
+ * @return {boolean} true if the point lies exactly on a segment.
+ */
+jsts.algorithm.RayCrossingCounter.prototype.isOnSegment = function() {
+  return jsts.geom.isPointOnSegment;
+};
+
+
+/**
+ * Gets the {@link Location} of the point relative to the ring, polygon or
+ * multipolygon from which the processed segments were provided.
+ * <p>
+ * This method only determines the correct location if <b>all</b> relevant
+ * segments must have been processed.
+ *
+ * @return {int} the Location of the point.
+ */
+jsts.algorithm.RayCrossingCounter.prototype.getLocation = function() {
+  if (this.isPointOnSegment)
+    return jsts.geom.Location.BOUNDARY;
+
+  // The point is in the interior of the ring if the number of X-crossings is
+  // odd.
+  if ((this.crossingCount % 2) === 1) {
+    return jsts.geom.Location.INTERIOR;
+  }
+  return jsts.geom.Location.EXTERIOR;
+};
+
+
+/**
+ * Tests whether the point lies in or on the ring, polygon or multipolygon from
+ * which the processed segments were provided.
+ * <p>
+ * This method only determines the correct location if <b>all</b> relevant
+ * segments must have been processed.
+ *
+ * @return {boolean} true if the point lies in or on the supplied polygon.
+ */
+jsts.algorithm.RayCrossingCounter.prototype.isPointInPolygon = function() {
+  return this.getLocation() !== jsts.geom.Location.EXTERIOR;
+};