jsts-rails 0.1.0 → 0.2.0

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

@@ -0,0 +1,118 @@
+/* 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.
+ */
+
+
+
+/**
+ * @param {Coordinate}
+ *          p00
+ * @param {Coordinate}
+ *          p01
+ * @param {Coordinate}
+ *          p10
+ * @param {Coordinate}
+ *          p11
+ * @constructor
+ */
+jsts.algorithm.CentralEndpointIntersector = function(p00, p01, p10, p11) {
+  this.pts = [p00, p01, p10, p11];
+  this.compute();
+};
+
+
+/**
+ * @param {Coordinate}
+ *          p00
+ * @param {Coordinate}
+ *          p01
+ * @param {Coordinate}
+ *          p10
+ * @param {Coordinate}
+ *          p11
+ * @return {Coordinate}
+ */
+jsts.algorithm.CentralEndpointIntersector.getIntersection = function(p00, p01,
+    p10, p11) {
+  var intor = new jsts.algorithm.CentralEndpointIntersector(p00, p01, p10, p11);
+  return intor.getIntersection();
+};
+
+
+/**
+ * @type {Coordinate[]}
+ * @private
+ */
+jsts.algorithm.CentralEndpointIntersector.prototype.pts = null;
+
+
+/**
+ * @type {Coordinate}
+ * @private
+ */
+jsts.algorithm.CentralEndpointIntersector.prototype.intPt = null;
+
+
+/**
+ * @private
+ */
+jsts.algorithm.CentralEndpointIntersector.prototype.compute = function() {
+  var centroid = jsts.algorithm.CentralEndpointIntersector.average(this.pts);
+  this.intPt = this.findNearestPoint(centroid, this.pts);
+};
+
+
+/**
+ * @return {Coordinate}
+ */
+jsts.algorithm.CentralEndpointIntersector.prototype.getIntersection = function() {
+  return this.intPt;
+};
+
+
+/**
+ * @param {Coordinate[]}
+ *          pts
+ * @return {Coordinate}
+ * @private
+ */
+jsts.algorithm.CentralEndpointIntersector.average = function(pts) {
+  var avg = new jsts.geom.Coordinate();
+  var i, n = pts.length;
+  for (i = 0; i < n; i++) {
+    avg.x += pts[i].x;
+    avg.y += pts[i].y;
+  }
+  if (n > 0) {
+    avg.x /= n;
+    avg.y /= n;
+  }
+  return avg;
+};
+
+
+/**
+ * Determines a point closest to the given point.
+ *
+ * @param {Coordinate}
+ *          p the point to compare against.
+ * @param {Coordinate[]}
+ *          pts
+ * @return {Coordinate} the point closest to the input point p.
+ * @private
+ */
+jsts.algorithm.CentralEndpointIntersector.prototype.findNearestPoint = function(
+    p, pts) {
+  var minDist = Number.MAX_VALUE;
+  var i, result = null, dist;
+  for (i = 0; i < pts.length; i++) {
+    dist = p.distance(pts[i]);
+    if (dist < minDist) {
+      minDist = dist;
+      result = pts[i];
+    }
+  }
+  return result;
+};

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

@@ -0,0 +1,225 @@
+/**
+ * Computes the centroid of an area geometry.
+ * <h2>Algorithm</h2>
+ * Based on the usual algorithm for calculating the centroid as a weighted sum
+ * of the centroids of a decomposition of the area into (possibly overlapping)
+ * triangles. The algorithm has been extended to handle holes and
+ * multi-polygons. See
+ * <code>http://www.faqs.org/faqs/graphics/algorithms-faq/</code> for further
+ * details of the basic approach. The code has also be extended to handle
+ * degenerate (zero-area) polygons. In this case, the centroid of the line
+ * segments in the polygon will be returned.
+ *
+ * @version 1.7
+ */
+jsts.algorithm.CentroidArea = function() {
+  this.basePt = null;
+  this.triangleCent3 = new jsts.geom.Coordinate();
+  this.centSum = new jsts.geom.Coordinate();
+  this.cg3 = new jsts.geom.Coordinate();
+};
+
+
+/**
+ * the point all triangles are based at
+ *
+ * @type {jsts.geom.Coordinate}
+ * @private
+ */
+jsts.algorithm.CentroidArea.prototype.basePt = null;
+
+
+/**
+ * temporary variable to hold centroid of triangle
+ *
+ * @type {jsts.geom.Coordinate}
+ * @private
+ */
+jsts.algorithm.CentroidArea.prototype.triangleCent3 = null;
+
+
+/**
+ * Partial area sum
+ *
+ * @type {double}
+ * @private
+ */
+jsts.algorithm.CentroidArea.prototype.areasum2 = 0;
+
+
+/**
+ * partial centroid sum
+ *
+ * @type {jsts.geom.Coordinate}
+ * @private
+ */
+jsts.algorithm.CentroidArea.prototype.cg3 = null;
+
+
+/**
+ * // data for linear centroid computation, if needed
+ *
+ * @type {jsts.geom.Coordinate}
+ * @private
+ */
+jsts.algorithm.CentroidArea.prototype.centSum = null;
+
+
+/**
+ * @type {double}
+ * @private
+ */
+jsts.algorithm.CentroidArea.prototype.totalLength = 0.0;
+
+
+/**
+ * Adds the area defined by a Geometry to the centroid total. If the geometry
+ * has no area it does not contribute to the centroid.
+ *
+ * @param geom
+ *          the geometry to add.
+ */
+jsts.algorithm.CentroidArea.prototype.add = function(geom) {
+  if (geom instanceof jsts.geom.Polygon) {
+    var poly = geom;
+    this.setBasePoint(poly.getExteriorRing().getCoordinateN(0));
+    this.add3(poly);
+  } else if (geom instanceof jsts.geom.GeometryCollection || geom instanceof jsts.geom.MultiPolygon) {
+    var gc = geom;
+    for (var i = 0; i < gc.getNumGeometries(); i++) {
+      this.add(gc.getGeometryN(i));
+    }
+  } else if (geom instanceof Array) {
+    this.add2(geom);
+  }
+};
+
+
+/**
+ * Adds the area defined by an array of coordinates. The array must be a ring;
+ * i.e. end with the same coordinate as it starts with.
+ *
+ * @param ring
+ *          an array of {@link Coordinate} s.
+ */
+jsts.algorithm.CentroidArea.prototype.add2 = function(ring) {
+  this.setBasePoint(ring[0]);
+  this.addShell(ring);
+};
+
+jsts.algorithm.CentroidArea.prototype.getCentroid = function() {
+  var cent = new jsts.geom.Coordinate();
+  if (Math.abs(this.areasum2) > 0.0) {
+    cent.x = this.cg3.x / 3 / this.areasum2;
+    cent.y = this.cg3.y / 3 / this.areasum2;
+  } else {
+    // if polygon was degenerate, compute linear centroid instead
+    cent.x = this.centSum.x / this.totalLength;
+    cent.y = this.centSum.y / this.totalLength;
+  }
+  return cent;
+};
+
+
+/**
+ * @private
+ */
+jsts.algorithm.CentroidArea.prototype.setBasePoint = function(basePt) {
+  if (this.basePt == null)
+    this.basePt = basePt;
+};
+
+
+/**
+ * @private
+ */
+jsts.algorithm.CentroidArea.prototype.add3 = function(poly) {
+  this.addShell(poly.getExteriorRing().getCoordinates());
+  for (var i = 0; i < poly.getNumInteriorRing(); i++) {
+    this.addHole(poly.getInteriorRingN(i).getCoordinates());
+  }
+};
+
+
+/**
+ * @private
+ */
+jsts.algorithm.CentroidArea.prototype.addShell = function(pts) {
+  var isPositiveArea = !jsts.algorithm.CGAlgorithms.isCCW(pts);
+  for (var i = 0; i < pts.length - 1; i++) {
+    this.addTriangle(this.basePt, pts[i], pts[i + 1], isPositiveArea);
+  }
+  this.addLinearSegments(pts);
+};
+
+
+/**
+ * @private
+ */
+jsts.algorithm.CentroidArea.prototype.addHole = function(pts) {
+  var isPositiveArea = jsts.algorithm.CGAlgorithms.isCCW(pts);
+  for (var i = 0; i < pts.length - 1; i++) {
+    this.addTriangle(this.basePt, pts[i], pts[i + 1], isPositiveArea);
+  }
+  this.addLinearSegments(pts);
+};
+
+
+/**
+ * @private
+ */
+jsts.algorithm.CentroidArea.prototype.addTriangle = function(p0, p1, p2,
+    isPositiveArea) {
+  var sign = (isPositiveArea) ? 1.0 : -1.0;
+  jsts.algorithm.CentroidArea.centroid3(p0, p1, p2, this.triangleCent3);
+  var area2 = jsts.algorithm.CentroidArea.area2(p0, p1, p2);
+  this.cg3.x += sign * area2 * this.triangleCent3.x;
+  this.cg3.y += sign * area2 * this.triangleCent3.y;
+  this.areasum2 += sign * area2;
+};
+
+
+/**
+ * Returns three times the centroid of the triangle p1-p2-p3. The factor of 3 is
+ * left in to permit division to be avoided until later.
+ *
+ * @private
+ */
+jsts.algorithm.CentroidArea.centroid3 = function(p1, p2, p3, c) {
+  c.x = p1.x + p2.x + p3.x;
+  c.y = p1.y + p2.y + p3.y;
+  return;
+};
+
+
+/**
+ * Returns twice the signed area of the triangle p1-p2-p3, positive if a,b,c are
+ * oriented ccw, and negative if cw.
+ *
+ * @private
+ */
+jsts.algorithm.CentroidArea.area2 = function(p1, p2, p3) {
+  return (p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y);
+};
+
+
+/**
+ * Adds the linear segments defined by an array of coordinates to the linear
+ * centroid accumulators. This is done in case the polygon(s) have zero-area, in
+ * which case the linear centroid is computed instead.
+ *
+ * @param pts
+ *          an array of {@link Coordinate} s.
+ * @private
+ */
+jsts.algorithm.CentroidArea.prototype.addLinearSegments = function(pts) {
+  for (var i = 0; i < pts.length - 1; i++) {
+    var segmentLen = pts[i].distance(pts[i + 1]);
+    this.totalLength += segmentLen;
+
+    var midx = (pts[i].x + pts[i + 1].x) / 2;
+    this.centSum.x += segmentLen * midx;
+    var midy = (pts[i].y + pts[i + 1].y) / 2;
+    this.centSum.y += segmentLen * midy;
+  }
+};

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

@@ -0,0 +1,85 @@
+/**
+ * Computes the centroid of a linear geometry.
+ * <h2>Algorithm</h2>
+ * Compute the average of the midpoints of all line segments weighted by the
+ * segment length.
+ *
+ * @version 1.7
+ */
+jsts.algorithm.CentroidLine = function() {
+  this.centSum = new jsts.geom.Coordinate();
+};
+
+
+/**
+ * @type {jsts.geom.Coordinate}
+ * @private
+ */
+jsts.algorithm.CentroidLine.prototype.centSum = null;
+
+
+/**
+ * @type {double}
+ * @private
+ */
+jsts.algorithm.CentroidLine.prototype.totalLength = 0.0;
+
+
+/**
+ * Adds the linear components of by a Geometry to the centroid total. If the
+ * geometry has no linear components it does not contribute to the centroid,
+ *
+ * @param geom
+ *          the geometry to add.
+ */
+jsts.algorithm.CentroidLine.prototype.add = function(geom) {
+  if (geom instanceof Array) {
+    this.add2.apply(this, arguments);
+    return;
+  }
+
+  if (geom instanceof jsts.geom.LineString) {
+    this.add(geom.getCoordinates());
+  } else if (geom instanceof jsts.geom.Polygon) {
+    var poly = geom;
+    // add linear components of a polygon
+    this.add(poly.getExteriorRing().getCoordinates());
+    for (var i = 0; i < poly.getNumInteriorRing(); i++) {
+      this.add(poly.getInteriorRingN(i).getCoordinates());
+    }
+  } else if (geom instanceof jsts.geom.GeometryCollection ||
+      geom instanceof jsts.geom.MultiPoint ||
+      geom instanceof jsts.geom.MultiLineString ||
+      geom instanceof jsts.geom.MultiPolygon) {
+    var gc = geom;
+    for (var i = 0; i < gc.getNumGeometries(); i++) {
+      this.add(gc.getGeometryN(i));
+    }
+  }
+};
+
+jsts.algorithm.CentroidLine.prototype.getCentroid = function() {
+  var cent = new jsts.geom.Coordinate();
+  cent.x = this.centSum.x / this.totalLength;
+  cent.y = this.centSum.y / this.totalLength;
+  return cent;
+};
+
+
+/**
+ * Adds the length defined by an array of coordinates.
+ *
+ * @param pts
+ *          an array of {@link Coordinate} s.
+ */
+jsts.algorithm.CentroidLine.prototype.add2 = function(pts) {
+  for (var i = 0; i < pts.length - 1; i++) {
+    var segmentLen = pts[i].distance(pts[i + 1]);
+    this.totalLength += segmentLen;
+
+    var midx = (pts[i].x + pts[i + 1].x) / 2;
+    this.centSum.x += segmentLen * midx;
+    var midy = (pts[i].y + pts[i + 1].y) / 2;
+    this.centSum.y += segmentLen * midy;
+  }
+};

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

@@ -0,0 +1,77 @@
+/* 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 centroid of a point geometry.
+ * <h2>Algorithm</h2>
+ * Compute the average of all points.
+ *
+ * @version 1.7
+ */
+jsts.algorithm.CentroidPoint = function() {
+  this.centSum = new jsts.geom.Coordinate();
+};
+
+
+/**
+ * @type {int}
+ * @private
+ */
+jsts.algorithm.CentroidPoint.prototype.ptCount = 0;
+
+
+/**
+ * @type {jsts.geom.Coordinate}
+ * @private
+ */
+jsts.algorithm.CentroidPoint.prototype.centSum = null;
+
+
+/**
+ * Adds the point(s) defined by a Geometry to the centroid total. If the
+ * geometry is not of dimension 0 it does not contribute to the centroid.
+ *
+ * @param {Geometry}
+ *          geom the geometry to add.
+ */
+jsts.algorithm.CentroidPoint.prototype.add = function(geom) {
+  if (geom instanceof jsts.geom.Point) {
+    this.add2(geom.getCoordinate());
+  } else if (geom instanceof jsts.geom.GeometryCollection ||
+      geom instanceof jsts.geom.MultiPoint ||
+      geom instanceof jsts.geom.MultiLineString ||
+      geom instanceof jsts.geom.MultiPolygon) {
+    var gc = geom;
+    for (var i = 0; i < gc.getNumGeometries(); i++) {
+      this.add(gc.getGeometryN(i));
+    }
+  }
+};
+
+
+/**
+ * Adds the length defined by an array of coordinates.
+ *
+ * @param {jsts.geom.Coordinate}
+ *          pts an array of {@link Coordinate}s.
+ */
+jsts.algorithm.CentroidPoint.prototype.add2 = function(pt) {
+  this.ptCount += 1;
+  this.centSum.x += pt.x;
+  this.centSum.y += pt.y;
+};
+
+
+/**
+ * @return {jsts.geom.Coordinate}
+ */
+jsts.algorithm.CentroidPoint.prototype.getCentroid = function() {
+  var cent = new jsts.geom.Coordinate();
+  cent.x = this.centSum.x / this.ptCount;
+  cent.y = this.centSum.y / this.ptCount;
+  return cent;
+};