jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/geom/LineSegment.js

@@ -0,0 +1,275 @@
+/* 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/geom/Coordinate.js
+ */
+
+/**
+ * Represents a line segment defined by two {@link Coordinate}s. Provides
+ * methods to compute various geometric properties and relationships of line
+ * segments.
+ * <p>
+ * This class is designed to be easily mutable (to the extent of having its
+ * contained points public). This supports a common pattern of reusing a single
+ * LineSegment object as a way of computing segment properties on the segments
+ * defined by arrays or lists of {@link Coordinate}s.
+ *
+ * @param {Coordinate}
+ *          p0
+ * @param {Coordinate}
+ *          p1
+ * @constructor
+ */
+jsts.geom.LineSegment = function(p0, p1) {
+  if (p0 === undefined) {
+    this.p0 = new jsts.geom.Coordinate();
+    this.p1 = new jsts.geom.Coordinate();
+    return;
+  }
+
+  this.p0 = p0;
+  this.p1 = p1;
+};
+
+
+/**
+ * @type {Coordinate}
+ */
+jsts.geom.LineSegment.prototype.p0 = null;
+
+
+/**
+ * @type {Coordinate}
+ */
+jsts.geom.LineSegment.prototype.p1 = null;
+
+/**
+ * Computes the length of the line segment.
+ *
+ * @return {number} the length of the line segment.
+ */
+jsts.geom.LineSegment.prototype.getLength = function() {
+  return this.p0.distance(this.p1);
+};
+
+/**
+ * Tests whether the segment is horizontal.
+ *
+ * @return {boolean} <code>true</code> if the segment is horizontal.
+ */
+jsts.geom.LineSegment.prototype.isHorizontal = function() {
+  return this.p0.y === this.p1.y;
+};
+/**
+ * Tests whether the segment is vertical.
+ *
+ * @return {boolean} <code>true</code> if the segment is vertical.
+ */
+jsts.geom.LineSegment.prototype.isVertical = function() {
+  return this.p0.x === this.p1.x;
+};
+
+
+/**
+ * Reverses the direction of the line segment.
+ */
+jsts.geom.LineSegment.prototype.reverse = function()
+{
+  var temp = this.p0;
+  this.p0 = this.p1;
+  this.p1 = temp;
+};
+
+/**
+ * Computes the Projection Factor for the projection of the point p onto this
+ * LineSegment. The Projection Factor is the constant r by which the vector for
+ * this segment must be multiplied to equal the vector for the projection of
+ * <tt>p<//t> on the line
+ * defined by this segment.
+ * <p>
+ * The projection factor returned will be in the range <tt>(-inf, +inf)</tt>.
+ *
+ * @param {Coordinate} p the point to compute the factor for.
+ * @return {double} the projection factor for the point.
+ */
+jsts.geom.LineSegment.prototype.projectionFactor = function(p) {
+  if (p.equals(this.p0))
+    return 0.0;
+  if (p.equals(this.p1))
+    return 1.0;
+  // Otherwise, use comp.graphics.algorithms Frequently Asked Questions method
+  /*            AC dot AB
+                 r = ---------
+                       ||AB||^2
+              r has the following meaning:
+              r=0 P = A
+              r=1 P = B
+              r<0 P is on the backward extension of AB
+              r>1 P is on the forward extension of AB
+              0<r<1 P is interior to AB
+      */
+  var dx = this.p1.x - this.p0.x;
+  var dy = this.p1.y - this.p0.y;
+  var len2 = dx * dx + dy * dy;
+  var r = ((p.x - this.p0.x) * dx + (p.y - this.p0.y) * dy) / len2;
+  return r;
+};
+
+
+/**
+ * Computes the closest point on this line segment to another point.
+ *
+ * @param {Coordinate}
+ *          p the point to find the closest point to.
+ * @return {Coordinate} a Coordinate which is the closest point on the line
+ *         segment to the point p.
+ */
+jsts.geom.LineSegment.prototype.closestPoint = function(p) {
+  var factor = this.projectionFactor(p);
+  if (factor > 0 && factor < 1) {
+    return this.project(p);
+  }
+  var dist0 = this.p0.distance(p);
+  var dist1 = this.p1.distance(p);
+  if (dist0 < dist1)
+    return this.p0;
+  return this.p1;
+};
+
+
+/**
+ * Computes the closest points on two line segments.
+ *
+ * @param {LineSegment}
+ *          line the segment to find the closest point to.
+ * @return {[]} a pair of Coordinates which are the closest points on the line
+ *         segments.
+ */
+jsts.geom.LineSegment.prototype.closestPoints = function(line) {
+  // test for intersection
+  var intPt = this.intersection(line);
+  if (intPt !== null) {
+    return [intPt, intPt];
+  }
+
+  /**
+   * if no intersection closest pair contains at least one endpoint. Test each
+   * endpoint in turn.
+   */
+  var closestPt = [];
+  var minDistance = Number.MAX_VALUE;
+  var dist;
+
+  var close00 = this.closestPoint(line.p0);
+  minDistance = close00.distance(line.p0);
+  closestPt[0] = close00;
+  closestPt[1] = line.p0;
+
+  var close01 = this.closestPoint(line.p1);
+  dist = close01.distance(line.p1);
+  if (dist < minDistance) {
+    minDistance = dist;
+    closestPt[0] = close01;
+    closestPt[1] = line.p1;
+  }
+
+  var close10 = line.closestPoint(this.p0);
+  dist = close10.distance(this.p0);
+  if (dist < minDistance) {
+    minDistance = dist;
+    closestPt[0] = this.p0;
+    closestPt[1] = close10;
+  }
+
+  var close11 = line.closestPoint(this.p1);
+  dist = close11.distance(this.p1);
+  if (dist < minDistance) {
+    minDistance = dist;
+    closestPt[0] = this.p1;
+    closestPt[1] = close11;
+  }
+
+  return closestPt;
+};
+
+
+/**
+ * Computes an intersection point between two line segments, if there is one.
+ * There may be 0, 1 or many intersection points between two segments. If there
+ * are 0, null is returned. If there is 1 or more, exactly one of them is
+ * returned (chosen at the discretion of the algorithm). If more information is
+ * required about the details of the intersection, the
+ * {@link RobustLineIntersector} class should be used.
+ *
+ * @param {LineSegment}
+ *          line a line segment.
+ * @return {Coordinate} an intersection point, or <code>null</code> if there
+ *         is none.
+ *
+ * @see RobustLineIntersector
+ */
+jsts.geom.LineSegment.prototype.intersection = function(line) {
+  var li = new jsts.algorithm.RobustLineIntersector();
+  li.computeIntersection(this.p0, this.p1, line.p0, line.p1);
+  if (li.hasIntersection())
+    return li.getIntersection(0);
+  return null;
+};
+
+
+/**
+ * Compute the projection of a point onto the line determined by this line
+ * segment.
+ * <p>
+ * Note that the projected point may lie outside the line segment. If this is
+ * the case, the projection factor will lie outside the range [0.0, 1.0].
+ *
+ * @param {Coordinate}
+ *          p
+ * @return {Coordinate}
+ */
+jsts.geom.LineSegment.prototype.project = function(p) {
+  if (p.equals(this.p0) || p.equals(this.p1))
+    return new jsts.geom.Coordinate(p);
+
+  var r = this.projectionFactor(p);
+  var coord = new jsts.geom.Coordinate();
+  coord.x = this.p0.x + r * (this.p1.x - this.p0.x);
+  coord.y = this.p0.y + r * (this.p1.y - this.p0.y);
+  return coord;
+};
+
+jsts.geom.LineSegment.prototype.setCoordinates = function(ls) {
+  if (ls instanceof jsts.geom.Coordinate) {
+    this.setCoordinates2.apply(this, arguments);
+    return;
+  }
+
+  this.setCoordinates2(ls.p0, ls.p1);
+};
+
+jsts.geom.LineSegment.prototype.setCoordinates2 = function(p0, p1) {
+  this.p0.x = p0.x;
+  this.p0.y = p0.y;
+  this.p1.x = p1.x;
+  this.p1.y = p1.y;
+};
+
+/**
+ * Computes the distance between this line segment and a given point.
+ *
+ * @param {jsts.geom.Coordinate}
+ *          p the coordinate.
+ * @return {number}
+ *          the distance from this segment to the given point.
+ */
+jsts.geom.LineSegment.prototype.distance = function(p)
+{
+  return jsts.algorithm.CGAlgorithms.distancePointLine(p, this.p0, this.p1);
+};
+
+// TODO: port rest

data/vendor/assets/javascripts/jsts/geom/LineString.js

@@ -0,0 +1,299 @@
+/* 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/geom/Geometry.js
+   * @requires jsts/geom/Dimension.js
+   */
+
+  var Dimension = jsts.geom.Dimension;
+
+  /**
+   * @extends jsts.geom.Geometry
+   * @constructor
+   */
+  jsts.geom.LineString = function(points, factory) {
+    this.factory = factory;
+    this.points = points || [];
+  };
+
+  jsts.geom.LineString.prototype = new jsts.geom.Geometry();
+  jsts.geom.LineString.constructor = jsts.geom.LineString;
+
+  /**
+   * @type {jsts.geom.Coordinate[]}
+   * @private
+   */
+  jsts.geom.LineString.prototype.points = null;
+
+  /**
+   * @return {jsts.geom.Coordinate[]} this LineString's internal coordinate
+   *         array.
+   */
+  jsts.geom.LineString.prototype.getCoordinates = function() {
+    return this.points;
+  };
+
+  jsts.geom.LineString.prototype.getCoordinateSequence = function() {
+    return this.points;
+  };
+
+
+  /**
+   * @return {jsts.geom.Coordinate} The n'th coordinate of this
+   *         jsts.geom.LineString.
+   * @param {int}
+   *          n index.
+   */
+  jsts.geom.LineString.prototype.getCoordinateN = function(n) {
+    return this.points[n];
+  };
+
+
+  /**
+   * @return {jsts.geom.Coordinate} The first coordinate of this LineString or
+   *         null if empty.
+   */
+  jsts.geom.LineString.prototype.getCoordinate = function() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    return this.getCoordinateN(0);
+  };
+
+
+  /**
+   * @return {number} LineStrings are always 1-dimensional.
+   */
+  jsts.geom.LineString.prototype.getDimension = function() {
+    return 1;
+  };
+
+
+  /**
+   * @return {number} dimension of the boundary of this jsts.geom.LineString.
+   */
+  jsts.geom.LineString.prototype.getBoundaryDimension = function() {
+    if (this.isClosed()) {
+      return Dimension.FALSE;
+    }
+    return 0;
+  };
+
+
+  /**
+   * @return {Boolean} true if empty.
+   */
+  jsts.geom.LineString.prototype.isEmpty = function() {
+    return this.points.length === 0;
+  };
+
+  jsts.geom.LineString.prototype.getNumPoints = function() {
+    return this.points.length;
+  };
+
+  jsts.geom.LineString.prototype.getPointN = function(n) {
+    return this.getFactory().createPoint(this.points[n]);
+  };
+
+
+  jsts.geom.LineString.prototype.getStartPoint = function() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    return this.getPointN(0);
+  };
+
+  jsts.geom.LineString.prototype.getEndPoint = function() {
+    if (this.isEmpty()) {
+      return null;
+    }
+    return this.getPointN(this.getNumPoints() - 1);
+  };
+
+
+  /**
+   * @return {Boolean} true if LineString is Closed.
+   */
+  jsts.geom.LineString.prototype.isClosed = function() {
+    if (this.isEmpty()) {
+      return false;
+    }
+    return this.getCoordinateN(0).equals2D(
+        this.getCoordinateN(this.points.length - 1));
+  };
+
+
+  /**
+   * @return {Boolean} true if LineString is a Ring.
+   */
+  jsts.geom.LineString.prototype.isRing = function() {
+    return this.isClosed() && this.isSimple();
+  };
+
+
+  /**
+   * @return {String} String representation of LineString type.
+   */
+  jsts.geom.LineString.prototype.getGeometryType = function() {
+    return 'LineString';
+  };
+
+
+  /**
+   * Returns the length of this <code>LineString</code>
+   *
+   * @return the length of the linestring.
+   */
+  jsts.geom.LineString.prototype.getLength = function() {
+    return jsts.algorithm.CGAlgorithms.computeLength(this.points);
+  };
+
+  /**
+   * Gets the boundary of this geometry. The boundary of a lineal geometry is
+   * always a zero-dimensional geometry (which may be empty).
+   *
+   * @return {Geometry} the boundary geometry.
+   * @see Geometry#getBoundary
+   */
+  jsts.geom.LineString.prototype.getBoundary = function() {
+    return (new jsts.operation.BoundaryOp(this)).getBoundary();
+  };
+
+
+  jsts.geom.LineString.prototype.computeEnvelopeInternal = function() {
+    if (this.isEmpty()) {
+      return new jsts.geom.Envelope();
+    }
+
+    var env = new jsts.geom.Envelope();
+    this.points.forEach(function(component) {
+      env.expandToInclude(component);
+    });
+
+    return env;
+  };
+
+
+  /**
+   * @param {Geometry}
+   *          other Geometry to compare this LineString to.
+   * @param {double}
+   *          tolerance Tolerance.
+   * @return {Boolean} true if equal.
+   */
+  jsts.geom.LineString.prototype.equalsExact = function(other, tolerance) {
+    if (!this.isEquivalentClass(other)) {
+      return false;
+    }
+
+    if (this.points.length !== other.points.length) {
+      return false;
+    }
+
+    if (this.isEmpty() && other.isEmpty()) {
+      return true;
+    }
+
+    return this.points
+        .reduce(function(equal, point, i) {
+          return equal &&
+              jsts.geom.Geometry.prototype.equal(point, other.points[i],
+                  tolerance);
+        });
+  };
+
+  jsts.geom.LineString.prototype.isEquivalentClass = function(other) {
+    return other instanceof jsts.geom.LineString;
+  };
+
+  jsts.geom.LineString.prototype.compareToSameClass = function(o) {
+    var line = o;
+    // MD - optimized implementation
+    var i = 0, il = this.points.length;
+    var j = 0, jl = line.points.length;
+    while (i < il && j < jl) {
+      var comparison = this.points[i].compareTo(line.points[j]);
+      if (comparison !== 0) {
+        return comparison;
+      }
+      i++;
+      j++;
+    }
+    if (i < il) {
+      return 1;
+    }
+    if (j < jl) {
+      return -1;
+    }
+    return 0;
+  };
+
+  jsts.geom.LineString.prototype.apply = function(filter) {
+    if (filter instanceof jsts.geom.GeometryFilter ||
+        filter instanceof jsts.geom.GeometryComponentFilter) {
+      filter.filter(this);
+    } else if (filter instanceof jsts.geom.CoordinateFilter) {
+      for (var i = 0, len = this.points.length; i < len; i++) {
+        filter.filter(this.points[i]);
+      }
+    } else if (filter instanceof jsts.geom.CoordinateSequenceFilter) {
+      this.apply2.apply(this, arguments);
+    }
+  };
+
+  jsts.geom.LineString.prototype.apply2 = function(filter) {
+    if (this.points.length === 0)
+      return;
+    for (var i = 0; i < this.points.length; i++) {
+      filter.filter(this.points, i);
+      if (filter.isDone())
+        break;
+    }
+    if (filter.isGeometryChanged()) {
+      // TODO: call geometryChanged(); when ported
+    }
+  };
+
+  jsts.geom.LineString.prototype.clone = function() {
+    var points = [];
+
+    for (var i = 0, len = this.points.length; i < len; i++) {
+      points.push(this.points[i].clone());
+    }
+
+    return this.factory.createLineString(points);
+  };
+
+  /**
+   * Normalizes a LineString. A normalized linestring has the first point which
+   * is not equal to it's reflected point less than the reflected point.
+   */
+  jsts.geom.LineString.prototype.normalize = function() {
+    var i, il, j, ci, cj, len;
+
+    len = this.points.length;
+    il = parseInt(len / 2);
+
+    for (i = 0; i < il; i++) {
+      j = len - 1 - i;
+      // skip equal points on both ends
+      ci = this.points[i];
+      cj = this.points[j];
+      if (!ci.equals(cj)) {
+        if (ci.compareTo(cj) > 0) {
+          this.points.reverse();
+        }
+        return;
+      }
+    }
+  };
+
+  jsts.geom.LineString.prototype.CLASS_NAME = 'jsts.geom.LineString';
+
+})();