jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/operation/valid/TopologyValidationError.js

@@ -0,0 +1,199 @@
+/* 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.
+ */
+
+
+
+/**
+ * Contains information about the nature and location of a {@link Geometry}
+ * validation error
+ *
+ * @version 1.7
+ */
+
+/**
+ *
+ * Creates a validation error with the given type and location
+ *
+ * @param errorType
+ *          the type of the error.
+ *
+ * @param pt
+ *          the location of the error.
+ *
+ */
+jsts.operation.valid.TopologyValidationError = function(errorType, pt) {
+  this.errorType = errorType;
+  this.pt = null;
+
+  if (pt != null) {
+    this.pt = pt.clone();
+  }
+};
+
+/**
+ *
+ * Indicates that a hole of a polygon lies partially or completely in the
+ * exterior of the shell
+ *
+ */
+jsts.operation.valid.TopologyValidationError.HOLE_OUTSIDE_SHELL = 2;
+
+/**
+ *
+ * Indicates that a hole lies in the interior of another hole in the same
+ * polygon
+ *
+ */
+jsts.operation.valid.TopologyValidationError.NESTED_HOLES = 3;
+
+/**
+ *
+ * Indicates that the interior of a polygon is disjoint
+ *
+ * (often caused by set of contiguous holes splitting the polygon into two
+ * parts)
+ *
+ */
+jsts.operation.valid.TopologyValidationError.DISCONNECTED_INTERIOR = 4;
+
+/**
+ *
+ * Indicates that two rings of a polygonal geometry intersect
+ *
+ */
+jsts.operation.valid.TopologyValidationError.SELF_INTERSECTION = 5;
+
+/**
+ *
+ * Indicates that a ring self-intersects
+ *
+ */
+jsts.operation.valid.TopologyValidationError.RING_SELF_INTERSECTION = 6;
+
+/**
+ *
+ * Indicates that a polygon component of a MultiPolygon lies inside another
+ * polygonal component
+ *
+ */
+jsts.operation.valid.TopologyValidationError.NESTED_SHELLS = 7;
+
+/**
+ *
+ * Indicates that a polygonal geometry contains two rings which are identical
+ *
+ */
+jsts.operation.valid.TopologyValidationError.DUPLICATE_RINGS = 8;
+
+/**
+ *
+ * Indicates that either
+ * <ul>
+ * <li>a LineString contains a single point
+ * <li>a LinearRing contains 2 or 3 points
+ * </ul>
+ *
+ */
+jsts.operation.valid.TopologyValidationError.TOO_FEW_POINTS = 9;
+
+/**
+ *
+ * Indicates that the <code>X</code> or <code>Y</code> ordinate of
+ * a Coordinate is not a valid numeric value (e.g. {@link Double#NaN} )
+ *
+ */
+jsts.operation.valid.TopologyValidationError.INVALID_COORDINATE = 10;
+
+/**
+ *
+ * Indicates that a ring is not correctly closed
+ * (the first and the last coordinate are different)
+ *
+ */
+jsts.operation.valid.TopologyValidationError.RING_NOT_CLOSED = 11;
+
+/**
+ *
+ * Messages corresponding to error codes
+ *
+ */
+jsts.operation.valid.TopologyValidationError.prototype.errMsg = [
+'Topology Validation Error',
+'Repeated Point',
+'Hole lies outside shell',
+'Holes are nested',
+'Interior is disconnected',
+'Self-intersection',
+'Ring Self-intersection',
+'Nested shells',
+'Duplicate Rings',
+'Too few distinct points in geometry component',
+'Invalid Coordinate',
+'Ring is not closed'
+];
+
+/**
+ * Creates a validation error of the given type with a null location
+ *
+ * @param errorType
+ *          the type of the error
+ *
+ * jsts.operation.valid.TopologyValidationError(int errorType) // cannot
+ * overload constructors, use above with null as arg 2
+ *  {
+ * this(errorType, null);
+ *  }
+ */
+
+/**
+ *
+ * Returns the location of this error (on the {@link Geometry} containing the
+ * error).
+ *
+ *
+ *
+ * @return a {@link Coordinate} on the input geometry.
+ *
+ */
+jsts.operation.valid.TopologyValidationError.prototype.getCoordinate = function() {
+  return this.pt;
+};
+
+/**
+ *
+ * Gets the type of this error.
+ * @return the error type.
+ *
+ */
+jsts.operation.valid.TopologyValidationError.prototype.getErrorType = function() {
+  return this.errorType;
+};
+
+/**
+ *
+ * Gets an error message describing this error.
+ * The error message does not describe the location of the error.
+ * @return the error message.
+ *
+ */
+jsts.operation.valid.TopologyValidationError.prototype.getMessage = function() {
+  return this.errMsg[this.errorType];
+};
+
+/**
+ *
+ * Gets a message describing the type and location of this error.
+ * @return the error message.
+ *
+ */
+jsts.operation.valid.TopologyValidationError.prototype.toString = function() {
+  var locStr = '';
+  if (this.pt != null) {
+    locStr = ' at or near point ' + this.pt;
+    return this.getMessage() + locStr;
+  }
+  return locStr;
+};

data/vendor/assets/javascripts/jsts/planargraph/DirectedEdge.js

@@ -0,0 +1,232 @@
+/* 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/planargraph/DirectedEdge.java
+ * Revision: 6
+ */
+
+/**
+ * @requires jsts/planargraph/GraphComponent.js
+ */
+
+(function() {
+
+  var ArrayList = javascript.util.ArrayList;
+  var GraphComponent = jsts.planargraph.GraphComponent;
+
+  /**
+   * Represents a directed edge in a {@link PlanarGraph}. A DirectedEdge may or
+   * may not have a reference to a parent {@link Edge} (some applications of
+   * planar graphs may not require explicit Edge objects to be created). Usually
+   * a client using a <code>PlanarGraph</code> will subclass
+   * <code>DirectedEdge</code> to add its own application-specific data and
+   * methods.
+   *
+   * Constructs a DirectedEdge connecting the <code>from</code> node to the
+   * <code>to</code> node.
+   *
+   * @param directionPt
+   *          specifies this DirectedEdge's direction vector (determined by the
+   *          vector from the <code>from</code> node to
+   *          <code>directionPt</code>).
+   * @param edgeDirection
+   *          whether this DirectedEdge's direction is the same as or opposite
+   *          to that of the parent Edge (if any).
+   */
+  var DirectedEdge = function(from, to, directionPt, edgeDirection) {
+    if (from === undefined) {
+      return;
+    }
+
+    this.from = from;
+    this.to = to;
+    this.edgeDirection = edgeDirection;
+    this.p0 = from.getCoordinate();
+    this.p1 = directionPt;
+    var dx = this.p1.x - this.p0.x;
+    var dy = this.p1.y - this.p0.y;
+    this.quadrant = jsts.geomgraph.Quadrant.quadrant(dx, dy);
+    this.angle = Math.atan2(dy, dx);
+  };
+
+  DirectedEdge.prototype = new GraphComponent();
+
+  /**
+   * Returns a List containing the parent Edge (possibly null) for each of the
+   * given DirectedEdges.
+   */
+  DirectedEdge.toEdges = function(dirEdges) {
+    var edges = new ArrayList();
+    for (var i = dirEdges.iterator(); i.hasNext();) {
+      edges.add((i.next()).parentEdge);
+    }
+    return edges;
+  };
+
+  DirectedEdge.prototype.parentEdge = null;
+  DirectedEdge.prototype.from = null;
+  DirectedEdge.prototype.to = null;
+  DirectedEdge.prototype.p0 = null;
+  DirectedEdge.prototype.p1 = null;
+  DirectedEdge.prototype.sym = null; // optional
+  DirectedEdge.prototype.edgeDirection = null;
+  DirectedEdge.prototype.quadrant = null;
+  DirectedEdge.prototype.angle = null;
+
+  /**
+   * Returns this DirectedEdge's parent Edge, or null if it has none.
+   */
+  DirectedEdge.prototype.getEdge = function() {
+    return this.parentEdge;
+  };
+
+  /**
+   * Associates this DirectedEdge with an Edge (possibly null, indicating no
+   * associated Edge).
+   */
+  DirectedEdge.prototype.setEdge = function(parentEdge) {
+    this.parentEdge = parentEdge;
+  };
+
+  /**
+   * Returns 0, 1, 2, or 3, indicating the quadrant in which this DirectedEdge's
+   * orientation lies.
+   */
+  DirectedEdge.prototype.getQuadrant = function() {
+    return this.quadrant;
+  };
+
+  /**
+   * Returns a point to which an imaginary line is drawn from the from-node to
+   * specify this DirectedEdge's orientation.
+   */
+  DirectedEdge.prototype.getDirectionPt = function() {
+    return this.p1;
+  };
+
+  /**
+   * Returns whether the direction of the parent Edge (if any) is the same as
+   * that of this Directed Edge.
+   */
+  DirectedEdge.prototype.getEdgeDirection = function() {
+    return this.edgeDirection;
+  };
+
+  /**
+   * Returns the node from which this DirectedEdge leaves.
+   */
+  DirectedEdge.prototype.getFromNode = function() {
+    return this.from;
+  };
+
+  /**
+   * Returns the node to which this DirectedEdge goes.
+   */
+  DirectedEdge.prototype.getToNode = function() {
+    return this.to;
+  };
+
+  /**
+   * Returns the coordinate of the from-node.
+   */
+  DirectedEdge.prototype.getCoordinate = function() {
+    return this.from.getCoordinate();
+  };
+
+  /**
+   * Returns the angle that the start of this DirectedEdge makes with the
+   * positive x-axis, in radians.
+   */
+  DirectedEdge.prototype.getAngle = function() {
+    return this.angle;
+  };
+
+  /**
+   * Returns the symmetric DirectedEdge -- the other DirectedEdge associated
+   * with this DirectedEdge's parent Edge.
+   */
+  DirectedEdge.prototype.getSym = function() {
+    return this.sym;
+  };
+
+  /**
+   * Sets this DirectedEdge's symmetric DirectedEdge, which runs in the opposite
+   * direction.
+   */
+  DirectedEdge.prototype.setSym = function(sym) {
+    this.sym = sym;
+  };
+
+  /**
+   * Removes this directed edge from its containing graph.
+   */
+  DirectedEdge.prototype.remove = function() {
+    this.sym = null;
+    this.parentEdge = null;
+  };
+
+  /**
+   * Tests whether this directed edge has been removed from its containing graph
+   *
+   * @return <code>true</code> if this directed edge is removed.
+   */
+  DirectedEdge.prototype.isRemoved = function() {
+    return this.parentEdge == null;
+  };
+
+  /**
+   * Returns 1 if this DirectedEdge has a greater angle with the positive x-axis
+   * than b", 0 if the DirectedEdges are collinear, and -1 otherwise.
+   * <p>
+   * Using the obvious algorithm of simply computing the angle is not robust,
+   * since the angle calculation is susceptible to roundoff. A robust algorithm
+   * is:
+   * <ul>
+   * <li>first compare the quadrants. If the quadrants are different, it it
+   * trivial to determine which vector is "greater".
+   * <li>if the vectors lie in the same quadrant, the robust
+   * {@link CGAlgorithms#computeOrientation(Coordinate, Coordinate, Coordinate)}
+   * function can be used to decide the relative orientation of the vectors.
+   * </ul>
+   */
+  DirectedEdge.prototype.compareTo = function(obj) {
+    var de = obj;
+    return this.compareDirection(de);
+  };
+
+  /**
+   * Returns 1 if this DirectedEdge has a greater angle with the positive x-axis
+   * than b", 0 if the DirectedEdges are collinear, and -1 otherwise.
+   * <p>
+   * Using the obvious algorithm of simply computing the angle is not robust,
+   * since the angle calculation is susceptible to roundoff. A robust algorithm
+   * is:
+   * <ul>
+   * <li>first compare the quadrants. If the quadrants are different, it it
+   * trivial to determine which vector is "greater".
+   * <li>if the vectors lie in the same quadrant, the robust
+   * {@link CGAlgorithms#computeOrientation(Coordinate, Coordinate, Coordinate)}
+   * function can be used to decide the relative orientation of the vectors.
+   * </ul>
+   */
+  DirectedEdge.prototype.compareDirection = function(e) {
+    // if the rays are in different quadrants, determining the ordering is
+    // trivial
+    if (this.quadrant > e.quadrant)
+      return 1;
+    if (this.quadrant < e.quadrant)
+      return -1;
+    // vectors are in the same quadrant - check relative orientation of
+    // direction vectors
+    // this is > e if it is CCW of e
+    return jsts.algorithm.CGAlgorithms.computeOrientation(e.p0, e.p1, this.p1);
+  };
+
+  jsts.planargraph.DirectedEdge = DirectedEdge;
+
+})();

data/vendor/assets/javascripts/jsts/planargraph/DirectedEdgeStar.js

@@ -0,0 +1,168 @@
+/* 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/planargraph/DirectedEdge.java
+ * Revision: 6
+ */
+
+
+(function() {
+
+  var ArrayList = javascript.util.ArrayList;
+
+  /**
+   * A sorted collection of {@link DirectedEdge}s which leave a {@link Node} in
+   * a {@link PlanarGraph}.
+   *
+   * Constructs a DirectedEdgeStar with no edges.
+   */
+  var DirectedEdgeStar = function() {
+    this.outEdges = new ArrayList();
+  };
+
+
+  /**
+   * The underlying list of outgoing DirectedEdges
+   */
+  DirectedEdgeStar.prototype.outEdges = null;
+
+  DirectedEdgeStar.prototype.sorted = false;
+
+  /**
+   * Adds a new member to this DirectedEdgeStar.
+   */
+  DirectedEdgeStar.prototype.add = function(de) {
+    this.outEdges.add(de);
+    this.sorted = false;
+  };
+  /**
+   * Drops a member of this DirectedEdgeStar.
+   */
+  DirectedEdgeStar.prototype.remove = function(de) {
+    this.outEdges.remove(de);
+  };
+  /**
+   * Returns an Iterator over the DirectedEdges, in ascending order by angle
+   * with the positive x-axis.
+   */
+  DirectedEdgeStar.prototype.iterator = function() {
+    this.sortEdges();
+    return this.outEdges.iterator();
+  };
+
+  /**
+   * Returns the number of edges around the Node associated with this
+   * DirectedEdgeStar.
+   */
+  DirectedEdgeStar.prototype.getDegree = function() {
+    return this.outEdges.size();
+  };
+
+  /**
+   * Returns the coordinate for the node at wich this star is based
+   */
+  DirectedEdgeStar.prototype.getCoordinate = function() {
+    var it = iterator();
+    if (!it.hasNext())
+      return null;
+    var e = it.next();
+    return e.getCoordinate();
+  };
+
+  /**
+   * Returns the DirectedEdges, in ascending order by angle with the positive
+   * x-axis.
+   */
+  DirectedEdgeStar.prototype.getEdges = function() {
+    this.sortEdges();
+    return this.outEdges;
+  };
+
+  /**
+   * @private
+   */
+  DirectedEdgeStar.prototype.sortEdges = function() {
+    if (!this.sorted) {
+      var array = this.outEdges.toArray();
+      array.sort(function(a,b) { return a.compareTo(b);});
+      this.outEdges = javascript.util.Arrays.asList(array);
+      this.sorted = true;
+    }
+  };
+
+  /**
+   * Returns the zero-based index of the given Edge, after sorting in ascending
+   * order by angle with the positive x-axis.
+   */
+  DirectedEdgeStar.prototype.getIndex = function(edge) {
+    if (edge instanceof jsts.planargraph.DirectedEdge) {
+      return this.getIndex2(edge);
+    } else if (typeof (edge) === 'number') {
+      return this.getIndex3(edge);
+    }
+
+    this.sortEdges();
+    for (var i = 0; i < this.outEdges.size(); i++) {
+      var de = this.outEdges.get(i);
+      if (de.getEdge() == edge)
+        return i;
+    }
+    return -1;
+  };
+
+  /**
+   * Returns the zero-based index of the given DirectedEdge, after sorting in
+   * ascending order by angle with the positive x-axis.
+   */
+  DirectedEdgeStar.prototype.getIndex2 = function(dirEdge) {
+    this.sortEdges();
+    for (var i = 0; i < this.outEdges.size(); i++) {
+      var de = this.outEdges.get(i);
+      if (de == dirEdge)
+        return i;
+    }
+    return -1;
+  };
+
+  /**
+   * Returns value of i modulo the number of edges in this DirectedEdgeStar
+   * (i.e. the remainder when i is divided by the number of edges)
+   *
+   * @param i
+   *          an integer (positive, negative or zero).
+   */
+  DirectedEdgeStar.prototype.getIndex3 = function(i) {
+    var modi = toInt(i % this.outEdges.size());
+    // I don't think modi can be 0 (assuming i is positive) [Jon Aquino
+    // 10/28/2003]
+    if (modi < 0)
+      modi += this.outEdges.size();
+    return modi;
+  };
+
+  /**
+   * Returns the {@link DirectedEdge} on the left-hand (CCW) side of the given
+   * {@link DirectedEdge} (which must be a member of this DirectedEdgeStar).
+   */
+  DirectedEdgeStar.prototype.getNextEdge = function(dirEdge) {
+    var i = this.getIndex(dirEdge);
+    return this.outEdges.get(getIndex(i + 1));
+  };
+
+  /**
+   * Returns the {@link DirectedEdge} on the right-hand (CW) side of the given
+   * {@link DirectedEdge} (which must be a member of this DirectedEdgeStar).
+   */
+  DirectedEdgeStar.prototype.getNextCWEdge = function(dirEdge) {
+    var i = this.getIndex(dirEdge);
+    return this.outEdges.get(getIndex(i - 1));
+  };
+
+  jsts.planargraph.DirectedEdgeStar = DirectedEdgeStar;
+
+})();