jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/io/WKTReader.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.
+ */
+
+
+
+/**
+ * Converts a geometry in Well-Known Text format to a {@link Geometry}.
+ * <p>
+ * <code>WKTReader</code> supports extracting <code>Geometry</code> objects
+ * from either {@link Reader}s or {@link String}s. This allows it to function
+ * as a parser to read <code>Geometry</code> objects from text blocks embedded
+ * in other data formats (e.g. XML).
+ * <P>
+ * <p>
+ * A <code>WKTReader</code> is parameterized by a <code>GeometryFactory</code>,
+ * to allow it to create <code>Geometry</code> objects of the appropriate
+ * implementation. In particular, the <code>GeometryFactory</code> determines
+ * the <code>PrecisionModel</code> and <code>SRID</code> that is used.
+ * <P>
+ *
+ * @constructor
+ */
+jsts.io.WKTReader = function(geometryFactory) {
+  this.geometryFactory = geometryFactory || new jsts.geom.GeometryFactory();
+  this.precisionModel = this.geometryFactory.getPrecisionModel();
+  this.parser = new jsts.io.WKTParser(this.geometryFactory);
+};
+
+
+/**
+ * Reads a Well-Known Text representation of a {@link Geometry}
+ *
+ * @param {string}
+ *          wkt a <Geometry Tagged Text> string (see the OpenGIS Simple Features
+ *          Specification).
+ * @return {jsts.geom.Geometry} a <code>Geometry</code> read from
+ *         <code>string.</code>
+ */
+jsts.io.WKTReader.prototype.read = function(wkt) {
+  var geometry = this.parser.read(wkt);
+
+  // TODO: port and use GeometryPrecisionReducer, this is a hack
+  if (this.precisionModel.getType() === jsts.geom.PrecisionModel.FIXED) {
+    this.reducePrecision(geometry);
+  }
+
+  return geometry;
+};
+
+//NOTE: this is a hack
+jsts.io.WKTReader.prototype.reducePrecision = function(geometry) {
+  var i, len;
+
+  if (geometry.coordinate) {
+    this.precisionModel.makePrecise(geometry.coordinate);
+  } else if (geometry.points) {
+    for (i = 0, len = geometry.points.length; i < len; i++) {
+      this.precisionModel.makePrecise(geometry.points[i]);
+    }
+  } else if (geometry.geometries) {
+    for (i = 0, len = geometry.geometries.length; i < len; i++) {
+      this.reducePrecision(geometry.geometries[i]);
+    }
+  }
+};

data/vendor/assets/javascripts/jsts/io/WKTWriter.js

@@ -0,0 +1,61 @@
+/* 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.
+ */
+
+
+
+/**
+ * Writes the Well-Known Text representation of a {@link Geometry}. The
+ * Well-Known Text format is defined in the <A
+ * HREF="http://www.opengis.org/techno/specs.htm"> OGC Simple Features
+ * Specification for SQL</A>.
+ * <p>
+ * The <code>WKTWriter</code> outputs coordinates rounded to the precision
+ * model. Only the maximum number of decimal places necessary to represent the
+ * ordinates to the required precision will be output.
+ * <p>
+ * The SFS WKT spec does not define a special tag for {@link LinearRing}s.
+ * Under the spec, rings are output as <code>LINESTRING</code>s.
+ *
+ * @see WKTReader
+ * @constructor
+ */
+jsts.io.WKTWriter = function() {
+  this.parser = new jsts.io.WKTParser(this.geometryFactory);
+};
+
+
+/**
+ * Converts a <code>Geometry</code> to its Well-known Text representation.
+ *
+ * @param {jsts.geom.Geometry}
+ *          geometry a <code>Geometry</code> to process.
+ * @return {string} a <Geometry Tagged Text> string (see the OpenGIS Simple
+ *         Features Specification).
+ */
+jsts.io.WKTWriter.prototype.write = function(geometry) {
+  var wkt = this.parser.write(geometry);
+
+  return wkt;
+};
+
+/**
+ * Generates the WKT for a <tt>LINESTRING</tt> specified by two
+ * {@link Coordinate}s.
+ *
+ * @param p0
+ *          the first coordinate.
+ * @param p1
+ *          the second coordinate.
+ *
+ * @return the WKT.
+ */
+jsts.io.WKTWriter.toLineString = function(p0, p1) {
+  if (arguments.length !== 2) {
+    throw new jsts.error.NotImplementedError();
+  }
+
+  return 'LINESTRING ( ' + p0.x + ' ' + p0.y + ', ' + p1.x + ' ' + p1.y + ' )';
+};

data/vendor/assets/javascripts/jsts/noding/BasicSegmentString.js

@@ -0,0 +1,87 @@
+/* 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() {
+
+  /**
+   * Represents a list of contiguous line segments, and supports noding the
+   * segments. The line segments are represented by an array of
+   * {@link Coordinate}s. Intended to optimize the noding of contiguous
+   * segments by reducing the number of allocated objects. SegmentStrings can
+   * carry a context object, which is useful for preserving topological or
+   * parentage information. All noded substrings are initialized with the same
+   * context object.
+   *
+   * Creates a new segment string from a list of vertices.
+   *
+   * @param pts
+   *          the vertices of the segment string.
+   * @param data
+   *          the user-defined data of this segment string (may be null).
+   * @constructor
+   */
+  jsts.noding.BasicSegmentString = function(pts, data) {
+    this.pts = pts;
+    this.data = data;
+  };
+  jsts.noding.BasicSegmentString.prototype = new jsts.noding.SegmentString();
+
+
+  jsts.noding.BasicSegmentString.prototype.pts = null;
+  jsts.noding.BasicSegmentString.prototype.data = null;
+
+
+  /**
+   * Gets the user-defined data for this segment string.
+   *
+   * @return the user-defined data.
+   */
+  jsts.noding.BasicSegmentString.prototype.getData = function() {
+    return this.data;
+  }
+
+  /**
+   * Sets the user-defined data for this segment string.
+   *
+   * @param data
+   *          an Object containing user-defined data.
+   */
+  jsts.noding.BasicSegmentString.prototype.setData = function(data) {
+    this.data = data;
+  };
+
+  jsts.noding.BasicSegmentString.prototype.size = function() {
+    return this.pts.length;
+  };
+
+  jsts.noding.BasicSegmentString.prototype.getCoordinate = function(i) {
+    return this.pts[i];
+  };
+
+  jsts.noding.BasicSegmentString.prototype.getCoordinates = function() {
+    return this.pts;
+  };
+
+  jsts.noding.BasicSegmentString.prototype.isClosed = function() {
+    return this.pts[0].equals(this.pts[this.pts.length - 1]);
+  };
+
+  /**
+   * Gets the octant of the segment starting at vertex <code>index</code>.
+   *
+   * @param index
+   *          the index of the vertex starting the segment. Must not be the last
+   *          index in the vertex list.
+   * @return the octant of the segment at the vertex.
+   */
+  jsts.noding.BasicSegmentString.prototype.getSegmentOctant = function(index) {
+    if (index == this.pts.length - 1)
+      return -1;
+    return jsts.noding.Octant.octant(this.getCoordinate(index), this
+        .getCoordinate(index + 1));
+  };
+
+})();

data/vendor/assets/javascripts/jsts/noding/FastNodingValidator.js

@@ -0,0 +1,127 @@
+/* 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/algorithm/RobustLineIntersector.js
+   * @requires jsts/noding/InteriorIntersectionFinder.js
+   * @requires jsts/noding/MCIndexNoder.js
+   */
+
+  var RobustLineIntersector = jsts.algorithm.RobustLineIntersector;
+  var InteriorIntersectionFinder = jsts.noding.InteriorIntersectionFinder;
+  var MCIndexNoder = jsts.noding.MCIndexNoder;
+
+  /**
+   * Validates that a collection of {@link SegmentString}s is correctly noded.
+   * Indexing is used to improve performance. In the most common use case,
+   * validation stops after a single non-noded intersection is detected. Does
+   * NOT check a-b-a collapse situations. Also does not check for
+   * endpoint-interior vertex intersections. This should not be a problem, since
+   * the noders should be able to compute intersections between vertices
+   * correctly.
+   * <p>
+   * The client may either test the {@link #isValid} condition, or request that
+   * a suitable {@link TopologyException} be thrown.
+   *
+   * Creates a new noding validator for a given set of linework.
+   *
+   * @param segStrings
+   *          a collection of {@link SegmentString} s.
+   */
+  jsts.noding.FastNodingValidator = function(segStrings) {
+    this.li = new RobustLineIntersector();
+
+    this.segStrings = segStrings;
+  };
+
+  jsts.noding.FastNodingValidator.prototype.li = null;
+
+  jsts.noding.FastNodingValidator.prototype.segStrings = null;
+  jsts.noding.FastNodingValidator.prototype.findAllIntersections = false;
+  jsts.noding.FastNodingValidator.prototype.segInt = null;
+  jsts.noding.FastNodingValidator.prototype._isValid = true;
+
+  jsts.noding.FastNodingValidator.prototype.setFindAllIntersections = function(
+      findAllIntersections) {
+    this.findAllIntersections = findAllIntersections;
+  };
+
+  jsts.noding.FastNodingValidator.prototype.getIntersections = function() {
+    return segInt.getIntersections();
+  };
+
+  /**
+   * Checks for an intersection and reports if one is found.
+   *
+   * @return true if the arrangement contains an interior intersection.
+   */
+  jsts.noding.FastNodingValidator.prototype.isValid = function() {
+    this.execute();
+    return this._isValid;
+  };
+
+  /**
+   * Returns an error message indicating the segments containing the
+   * intersection.
+   *
+   * @return an error message documenting the intersection location.
+   */
+  jsts.noding.FastNodingValidator.prototype.getErrorMessage = function() {
+    if (this._isValid)
+      return 'no intersections found';
+
+    var intSegs = this.segInt.getIntersectionSegments();
+    return 'found non-noded intersection between ' +
+        jsts.io.WKTWriter.toLineString(intSegs[0], intSegs[1]) + ' and ' +
+        jsts.io.WKTWriter.toLineString(intSegs[2], intSegs[3]);
+  };
+
+  /**
+   * Checks for an intersection and throws a TopologyException if one is found.
+   *
+   * @throws TopologyException
+   *           if an intersection is found
+   */
+  jsts.noding.FastNodingValidator.prototype.checkValid = function() {
+    this.execute();
+    if (!this._isValid)
+      throw new jsts.error.TopologyError(this.getErrorMessage(), this.segInt
+          .getInteriorIntersection());
+  };
+
+  /**
+   * @private
+   */
+  jsts.noding.FastNodingValidator.prototype.execute = function() {
+    if (this.segInt != null)
+      return;
+    this.checkInteriorIntersections();
+  };
+
+  /**
+   * @private
+   */
+  jsts.noding.FastNodingValidator.prototype.checkInteriorIntersections = function() {
+    /**
+     * MD - It may even be reliable to simply check whether end segments (of
+     * SegmentStrings) have an interior intersection, since noding should have
+     * split any true interior intersections already.
+     */
+    this._isValid = true;
+    this.segInt = new InteriorIntersectionFinder(this.li);
+    this.segInt.setFindAllIntersections(this.findAllIntersections);
+    var noder = new MCIndexNoder();
+    noder.setSegmentIntersector(this.segInt);
+    noder.computeNodes(this.segStrings);
+    if (this.segInt.hasIntersection()) {
+      this._isValid = false;
+      return;
+    }
+  };
+
+})();

data/vendor/assets/javascripts/jsts/noding/InteriorIntersectionFinder.js

@@ -0,0 +1,171 @@
+/* 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/noding/SegmentIntersector.js
+   */
+
+  var SegmentIntersector = jsts.noding.SegmentIntersector;
+  var ArrayList = javascript.util.ArrayList;
+
+  /**
+   * Finds an interior intersection in a set of {@link SegmentString}s, if one
+   * exists. Only the first intersection found is reported.
+   *
+   * Creates an intersection finder which finds an interior intersection if one
+   * exists
+   *
+   * @param li
+   *          the LineIntersector to use.
+   * @constructor
+   */
+  jsts.noding.InteriorIntersectionFinder = function(li) {
+    this.li = li;
+    this.intersections = new ArrayList();
+    this.interiorIntersection = null;
+  };
+
+  jsts.noding.InteriorIntersectionFinder.prototype = new SegmentIntersector();
+  jsts.noding.InteriorIntersectionFinder.constructor = jsts.noding.InteriorIntersectionFinder;
+
+  jsts.noding.InteriorIntersectionFinder.prototype.findAllIntersections = false;
+  jsts.noding.InteriorIntersectionFinder.prototype.isCheckEndSegmentsOnly = false;
+  jsts.noding.InteriorIntersectionFinder.prototype.li = null;
+  jsts.noding.InteriorIntersectionFinder.prototype.interiorIntersection = null;
+  jsts.noding.InteriorIntersectionFinder.prototype.intSegments = null;
+  jsts.noding.InteriorIntersectionFinder.prototype.intersections = null;
+
+
+  jsts.noding.InteriorIntersectionFinder.prototype.setFindAllIntersections = function(
+      findAllIntersections) {
+    this.findAllIntersections = findAllIntersections;
+  };
+
+  jsts.noding.InteriorIntersectionFinder.prototype.getIntersections = function() {
+    return intersections;
+  };
+
+  /**
+   * Sets whether only end segments should be tested for interior intersection.
+   * This is a performance optimization that may be used if the segments have
+   * been previously noded by an appropriate algorithm. It may be known that any
+   * potential noding failures will occur only in end segments.
+   *
+   * @param isCheckEndSegmentsOnly
+   *          whether to test only end segments.
+   */
+  jsts.noding.InteriorIntersectionFinder.prototype.setCheckEndSegmentsOnly = function(
+      isCheckEndSegmentsOnly) {
+    this.isCheckEndSegmentsOnly = isCheckEndSegmentsOnly;
+  }
+
+  /**
+   * Tests whether an intersection was found.
+   *
+   * @return true if an intersection was found.
+   */
+  jsts.noding.InteriorIntersectionFinder.prototype.hasIntersection = function() {
+    return this.interiorIntersection != null;
+  };
+
+  /**
+   * Gets the computed location of the intersection. Due to round-off, the
+   * location may not be exact.
+   *
+   * @return the coordinate for the intersection location.
+   */
+  jsts.noding.InteriorIntersectionFinder.prototype.getInteriorIntersection = function() {
+    return this.interiorIntersection;
+  };
+
+  /**
+   * Gets the endpoints of the intersecting segments.
+   *
+   * @return an array of the segment endpoints (p00, p01, p10, p11).
+   */
+  jsts.noding.InteriorIntersectionFinder.prototype.getIntersectionSegments = function() {
+    return this.intSegments;
+  };
+
+  /**
+   * This method is called by clients of the {@link SegmentIntersector} class to
+   * process intersections for two segments of the {@link SegmentString}s being
+   * intersected. Note that some clients (such as {@link MonotoneChain}s) may
+   * optimize away this call for segment pairs which they have determined do not
+   * intersect (e.g. by an disjoint envelope test).
+   */
+  jsts.noding.InteriorIntersectionFinder.prototype.processIntersections = function(
+      e0, segIndex0, e1, segIndex1) {
+    // short-circuit if intersection already found
+    if (this.hasIntersection())
+      return;
+
+    // don't bother intersecting a segment with itself
+    if (e0 == e1 && segIndex0 == segIndex1)
+      return;
+
+    /**
+     * If enabled, only test end segments (on either segString).
+     *
+     */
+    if (this.isCheckEndSegmentsOnly) {
+      var isEndSegPresent = this.isEndSegment(e0, segIndex0) ||
+          isEndSegment(e1, segIndex1);
+      if (!isEndSegPresent)
+        return;
+    }
+
+    var p00 = e0.getCoordinates()[segIndex0];
+    var p01 = e0.getCoordinates()[segIndex0 + 1];
+    var p10 = e1.getCoordinates()[segIndex1];
+    var p11 = e1.getCoordinates()[segIndex1 + 1];
+
+    this.li.computeIntersection(p00, p01, p10, p11);
+    // if (li.hasIntersection() && li.isProper()) Debug.println(li);
+
+    if (this.li.hasIntersection()) {
+      if (this.li.isInteriorIntersection()) {
+        this.intSegments = [];
+        this.intSegments[0] = p00;
+        this.intSegments[1] = p01;
+        this.intSegments[2] = p10;
+        this.intSegments[3] = p11;
+
+        this.interiorIntersection = this.li.getIntersection(0);
+        this.intersections.add(this.interiorIntersection);
+      }
+    }
+  };
+
+  /**
+   * Tests whether a segment in a {@link SegmentString} is an end segment.
+   * (either the first or last).
+   *
+   * @param segStr
+   *          a segment string.
+   * @param index
+   *          the index of a segment in the segment string.
+   * @return true if the segment is an end segment.
+   * @private
+   */
+  jsts.noding.InteriorIntersectionFinder.prototype.isEndSegment = function(
+      segStr, index) {
+    if (index == 0)
+      return true;
+    if (index >= segStr.size() - 2)
+      return true;
+    return false;
+  };
+
+  jsts.noding.InteriorIntersectionFinder.prototype.isDone = function() {
+    if (this.findAllIntersections)
+      return false;
+    return this.interiorIntersection != null;
+  };
+
+})();