jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/geomgraph/Position.js

@@ -0,0 +1,63 @@
+/* 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() {
+
+  /**
+   * A Position indicates the position of a Location relative to a graph
+   * component (Node, Edge, or Area).
+   *
+   * @constructor
+   */
+  jsts.geomgraph.Position = function() {
+
+  };
+
+
+  /**
+   * An indicator that a Location is <i>on</i> a GraphComponent
+   *
+   * @type {int}
+   */
+  jsts.geomgraph.Position.ON = 0;
+
+
+  /**
+   * An indicator that a Location is to the <i>left</i> of a GraphComponent
+   *
+   * @type {int}
+   */
+  jsts.geomgraph.Position.LEFT = 1;
+
+
+  /**
+   * An indicator that a Location is to the <i>right</i> of a GraphComponent
+   *
+   * @type {int}
+   */
+  jsts.geomgraph.Position.RIGHT = 2;
+
+
+  /**
+   * Returns LEFT if the position is RIGHT, RIGHT if the position is LEFT, or
+   * the position otherwise.
+   *
+   * @param {int}
+   *          position
+   * @return {int}
+   */
+  jsts.geomgraph.Position.opposite = function(position) {
+    if (position === jsts.geomgraph.Position.LEFT) {
+      return jsts.geomgraph.Position.RIGHT;
+    }
+    if (position === jsts.geomgraph.Position.RIGHT) {
+      return jsts.geomgraph.Position.LEFT;
+    }
+    return position;
+  };
+
+})();

data/vendor/assets/javascripts/jsts/geomgraph/Quadrant.js

@@ -0,0 +1,143 @@
+/* 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.
+ */
+
+
+
+/**
+ * Utility functions for working with quadrants, which are numbered as follows:
+ *
+ * <pre>
+ * 1 | 0
+ * --+--
+ * 2 | 3
+ * &lt;pre&gt;
+ * @constructor
+ *
+ */
+jsts.geomgraph.Quadrant = function() {
+
+};
+
+jsts.geomgraph.Quadrant.NE = 0;
+jsts.geomgraph.Quadrant.NW = 1;
+jsts.geomgraph.Quadrant.SW = 2;
+jsts.geomgraph.Quadrant.SE = 3;
+
+
+/**
+ * Returns the quadrant of a directed line segment (specified as x and y
+ * displacements, which cannot both be 0).
+ *
+ * @throws IllegalArgumentException
+ *           if the displacements are both 0
+ */
+jsts.geomgraph.Quadrant.quadrant = function(dx, dy) {
+  if (dx instanceof jsts.geom.Coordinate) {
+    return jsts.geomgraph.Quadrant.quadrant2.apply(this, arguments);
+  }
+
+  if (dx === 0.0 && dy === 0.0)
+    throw new jsts.error.IllegalArgumentError(
+        'Cannot compute the quadrant for point ( ' + dx + ', ' + dy + ' )');
+  if (dx >= 0.0) {
+    if (dy >= 0.0)
+      return jsts.geomgraph.Quadrant.NE;
+    else
+      return jsts.geomgraph.Quadrant.SE;
+  } else {
+    if (dy >= 0.0)
+      return jsts.geomgraph.Quadrant.NW;
+    else
+      return jsts.geomgraph.Quadrant.SW;
+  }
+};
+
+
+/**
+ * Returns the quadrant of a directed line segment from p0 to p1.
+ *
+ * @throws IllegalArgumentException
+ *           if the points are equal
+ */
+jsts.geomgraph.Quadrant.quadrant2 = function(p0, p1) {
+  if (p1.x === p0.x && p1.y === p0.y)
+    throw new jsts.error.IllegalArgumentError(
+        'Cannot compute the quadrant for two identical points ' + p0);
+
+  if (p1.x >= p0.x) {
+    if (p1.y >= p0.y)
+      return jsts.geomgraph.Quadrant.NE;
+    else
+      return jsts.geomgraph.Quadrant.SE;
+  } else {
+    if (p1.y >= p0.y)
+      return jsts.geomgraph.Quadrant.NW;
+    else
+      return jsts.geomgraph.Quadrant.SW;
+  }
+};
+
+
+/**
+ * Returns true if the quadrants are 1 and 3, or 2 and 4
+ */
+jsts.geomgraph.Quadrant.isOpposite = function(quad1, quad2) {
+  if (quad1 === quad2)
+    return false;
+  var diff = (quad1 - quad2 + 4) % 4;
+  // if quadrants are not adjacent, they are opposite
+  if (diff === 2)
+    return true;
+  return false;
+};
+
+
+/**
+ * Returns the right-hand quadrant of the halfplane defined by the two
+ * quadrants, or -1 if the quadrants are opposite, or the quadrant if they are
+ * identical.
+ */
+jsts.geomgraph.Quadrant.commonHalfPlane = function(quad1, quad2) {
+  // if quadrants are the same they do not determine a unique common halfplane.
+  // Simply return one of the two possibilities
+  if (quad1 === quad2)
+    return quad1;
+  var diff = (quad1 - quad2 + 4) % 4;
+  // if quadrants are not adjacent, they do not share a common halfplane
+  if (diff === 2)
+    return -1;
+  //
+  var min = (quad1 < quad2) ? quad1 : quad2;
+  var max = (quad1 > quad2) ? quad1 : quad2;
+  // for this one case, the righthand plane is NOT the minimum index;
+  if (min === 0 && max === 3)
+    return 3;
+  // in general, the halfplane index is the minimum of the two adjacent
+  // quadrants
+  return min;
+};
+
+
+/**
+ * Returns whether the given quadrant lies within the given halfplane (specified
+ * by its right-hand quadrant).
+ */
+jsts.geomgraph.Quadrant.isInHalfPlane = function(quad, halfPlane) {
+  if (halfPlane === jsts.geomgraph.Quadrant.SE) {
+    return quad === jsts.geomgraph.Quadrant.SE ||
+        quad === jsts.geomgraph.Quadrant.SW;
+  }
+  return quad === halfPlane || quad === halfPlane + 1;
+};
+
+
+/**
+ * Returns true if the given quadrant is 0 or 1.
+ */
+jsts.geomgraph.Quadrant.isNorthern = function(quad) {
+  return quad === jsts.geomgraph.Quadrant.NE ||
+      quad === jsts.geomgraph.Quadrant.NW;
+};

data/vendor/assets/javascripts/jsts/geomgraph/TopologyLocation.js

@@ -0,0 +1,251 @@
+/* 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/geomgraph/Position.js
+ */
+
+/**
+ * A TopologyLocation is the labelling of a GraphComponent's topological
+ * relationship to a single Geometry.
+ * <p>
+ * If the parent component is an area edge, each side and the edge itself have a
+ * topological location. These locations are named
+ * <ul>
+ * <li> ON: on the edge
+ * <li> LEFT: left-hand side of the edge
+ * <li> RIGHT: right-hand side
+ * </ul>
+ * If the parent component is a line edge or node, there is a single topological
+ * relationship attribute, ON.
+ * <p>
+ * The possible values of a topological location are {Location.NONE,
+ * Location.EXTERIOR, Location.BOUNDARY, Location.INTERIOR}
+ * <p>
+ * The labelling is stored in an array location[j] where where j has the values
+ * ON, LEFT, RIGHT
+ *
+ * @constructor
+ */
+jsts.geomgraph.TopologyLocation = function() {
+  this.location = [];
+
+  if (arguments.length === 3) {
+    var on = arguments[0];
+    var left = arguments[1];
+    var right = arguments[2];
+    this.init(3);
+    this.location[jsts.geomgraph.Position.ON] = on;
+    this.location[jsts.geomgraph.Position.LEFT] = left;
+    this.location[jsts.geomgraph.Position.RIGHT] = right;
+  } else if (arguments[0] instanceof jsts.geomgraph.TopologyLocation) {
+    var gl = arguments[0];
+    this.init(gl.location.length);
+    if (gl != null) {
+      for (var i = 0; i < this.location.length; i++) {
+        this.location[i] = gl.location[i];
+      }
+    }
+  } else if (typeof arguments[0] === 'number') {
+    var on = arguments[0];
+    this.init(1);
+    this.location[jsts.geomgraph.Position.ON] = on;
+  } else if (arguments[0] instanceof Array) {
+    var location = arguments[0];
+    this.init(location.length);
+  }
+};
+
+
+/**
+ * @private
+ */
+jsts.geomgraph.TopologyLocation.prototype.location = null;
+
+
+/**
+ * @param {int}
+ *          size
+ * @private
+ */
+jsts.geomgraph.TopologyLocation.prototype.init = function(size) {
+  this.location[size - 1] = null;
+  this.setAllLocations(jsts.geom.Location.NONE);
+};
+
+
+/**
+ * @param {int}
+ *          posIndex
+ * @return {int}
+ */
+jsts.geomgraph.TopologyLocation.prototype.get = function(posIndex) {
+  if (posIndex < this.location.length)
+    return this.location[posIndex];
+  return jsts.geom.Location.NONE;
+};
+
+
+/**
+ * @return {boolean} true if all locations are NULL.
+ */
+jsts.geomgraph.TopologyLocation.prototype.isNull = function() {
+  for (var i = 0; i < this.location.length; i++) {
+    if (this.location[i] !== jsts.geom.Location.NONE)
+      return false;
+  }
+  return true;
+};
+
+
+/**
+ * @return {boolean} true if any locations are NULL.
+ */
+jsts.geomgraph.TopologyLocation.prototype.isAnyNull = function() {
+  for (var i = 0; i < this.location.length; i++) {
+    if (this.location[i] === jsts.geom.Location.NONE)
+      return true;
+  }
+  return false;
+};
+
+
+/**
+ * @param {TopologyLocation}
+ *          le
+ * @param {int}
+ *          locIndex
+ * @return {boolean}
+ */
+jsts.geomgraph.TopologyLocation.prototype.isEqualOnSide = function(le, locIndex) {
+  return this.location[locIndex] == le.location[locIndex];
+};
+
+
+/**
+ * @return {boolean}
+ */
+jsts.geomgraph.TopologyLocation.prototype.isArea = function() {
+  return this.location.length > 1;
+};
+
+
+/**
+ * @return {boolean}
+ */
+jsts.geomgraph.TopologyLocation.prototype.isLine = function() {
+  return this.location.length === 1;
+};
+
+jsts.geomgraph.TopologyLocation.prototype.flip = function() {
+  if (this.location.length <= 1)
+    return;
+  var temp = this.location[jsts.geomgraph.Position.LEFT];
+  this.location[jsts.geomgraph.Position.LEFT] = this.location[jsts.geomgraph.Position.RIGHT];
+  this.location[jsts.geomgraph.Position.RIGHT] = temp;
+};
+
+
+/**
+ * @param {int}
+ *          locValue
+ */
+jsts.geomgraph.TopologyLocation.prototype.setAllLocations = function(locValue) {
+  for (var i = 0; i < this.location.length; i++) {
+    this.location[i] = locValue;
+  }
+};
+
+
+/**
+ * @param {int}
+ *          locValue
+ */
+jsts.geomgraph.TopologyLocation.prototype.setAllLocationsIfNull = function(
+    locValue) {
+  for (var i = 0; i < this.location.length; i++) {
+    if (this.location[i] === jsts.geom.Location.NONE)
+      this.location[i] = locValue;
+  }
+};
+
+
+/**
+ * @param {int}
+ *          locIndex
+ * @param {int}
+ *          locValue
+ */
+jsts.geomgraph.TopologyLocation.prototype.setLocation = function(locIndex,
+    locValue) {
+  if (locValue !== undefined) {
+    this.location[locIndex] = locValue;
+  } else {
+    this.setLocation(jsts.geomgraph.Position.ON, locIndex);
+  }
+};
+
+
+/**
+ * @return {int[]}
+ */
+jsts.geomgraph.TopologyLocation.prototype.getLocations = function() {
+  return location;
+};
+
+
+/**
+ * @param {int}
+ *          on
+ * @param {int}
+ *          left
+ * @param {int}
+ *          right
+ */
+jsts.geomgraph.TopologyLocation.prototype.setLocations = function(on, left,
+    right) {
+  this.location[jsts.geomgraph.Position.ON] = on;
+  this.location[jsts.geomgraph.Position.LEFT] = left;
+  this.location[jsts.geomgraph.Position.RIGHT] = right;
+};
+
+
+/**
+ * @param {int}
+ *          loc
+ * @return {boolean}
+ */
+jsts.geomgraph.TopologyLocation.prototype.allPositionsEqual = function(loc) {
+  for (var i = 0; i < this.location.length; i++) {
+    if (this.location[i] !== loc)
+      return false;
+  }
+  return true;
+};
+
+
+/**
+ * merge updates only the NULL attributes of this object with the attributes of
+ * another.
+ *
+ * @param {TopologyLocation}
+ *          gl
+ */
+jsts.geomgraph.TopologyLocation.prototype.merge = function(gl) {
+  // if the src is an Area label & and the dest is not, increase the dest to be
+  // an Area
+  if (gl.location.length > this.location.length) {
+    var newLoc = [];
+    newLoc[jsts.geomgraph.Position.ON] = this.location[jsts.geomgraph.Position.ON];
+    newLoc[jsts.geomgraph.Position.LEFT] = jsts.geom.Location.NONE;
+    newLoc[jsts.geomgraph.Position.RIGHT] = jsts.geom.Location.NONE;
+    this.location = newLoc;
+  }
+  for (var i = 0; i < this.location.length; i++) {
+    if (this.location[i] === jsts.geom.Location.NONE && i < gl.location.length)
+      this.location[i] = gl.location[i];
+  }
+};