jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/noding/snapround/MCIndexPointSnapper.js

@@ -0,0 +1,96 @@
+/* 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/noding/snapround/MCIndexPointSnapper.java
+ * Revision: 486
+ */
+
+/**
+ * @requires jsts/index/chain/MonotoneChainSelectAction.js
+ */
+
+(function() {
+
+  var HotPixelSnapAction = function(hotPixel, parentEdge, vertexIndex) {
+    this.hotPixel = hotPixel;
+    this.parentEdge = parentEdge;
+    this.vertexIndex = vertexIndex;
+  };
+
+  HotPixelSnapAction.prototype = new jsts.index.chain.MonotoneChainSelectAction();
+  HotPixelSnapAction.constructor = HotPixelSnapAction;
+
+  HotPixelSnapAction.prototype.hotPixel = null;
+  HotPixelSnapAction.prototype.parentEdge = null;
+  HotPixelSnapAction.prototype.vertexIndex = null;
+  HotPixelSnapAction.prototype._isNodeAdded = false;
+
+  HotPixelSnapAction.prototype.isNodeAdded = function() {
+    return this._isNodeAdded;
+  };
+
+  HotPixelSnapAction.prototype.select = function(mc, startIndex) {
+    var ss = mc.getContext();
+    // don't snap a vertex to itself
+    if (this.parentEdge !== null) {
+      if (ss === this.parentEdge && startIndex === this.vertexIndex)
+        return;
+    }
+    // isNodeAdded = SimpleSnapRounder.addSnappedNode(hotPixel, ss, startIndex);
+    this._isNodeAdded = this.hotPixel.addSnappedNode(ss, startIndex);
+  };
+
+
+  /**
+   * "Snaps" all {@link SegmentString}s in a {@link SpatialIndex} containing
+   * {@link MonotoneChain}s to a given {@link HotPixel}.
+   */
+  jsts.noding.snapround.MCIndexPointSnapper = function(index) {
+    this.index = index;
+  };
+
+  jsts.noding.snapround.MCIndexPointSnapper.prototype.index = null;
+
+  /**
+   * Snaps (nodes) all interacting segments to this hot pixel. The hot pixel may
+   * represent a vertex of an edge, in which case this routine uses the
+   * optimization of not noding the vertex itself
+   *
+   * @param hotPixel
+   *          the hot pixel to snap to.
+   * @param parentEdge
+   *          the edge containing the vertex, if applicable, or
+   *          <code>null.</code>
+   * @param vertexIndex
+   *          the index of the vertex, if applicable, or -1.
+   * @return <code>true</code> if a node was added for this pixel.
+   */
+  jsts.noding.snapround.MCIndexPointSnapper.prototype.snap = function(hotPixel,
+      parentEdge, vertexIndex) {
+    if (arguments.length === 1) {
+      this.snap2.apply(this, arguments);
+      return;
+    }
+
+    var pixelEnv = hotPixel.getSafeEnvelope();
+    var hotPixelSnapAction = new HotPixelSnapAction(hotPixel, parentEdge,
+        vertexIndex);
+
+    this.index.query(pixelEnv, {
+      visitItem: function(testChain) {
+        testChain.select(pixelEnv, hotPixelSnapAction);
+      }
+    });
+    return hotPixelSnapAction.isNodeAdded();
+  };
+
+  jsts.noding.snapround.MCIndexPointSnapper.prototype.snap2 = function(hotPixel) {
+    return this.snap(hotPixel, null, -1);
+  };
+
+})();

data/vendor/assets/javascripts/jsts/noding/snapround/MCIndexSnapRounder.js

@@ -0,0 +1,147 @@
+/* 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/noding/snapround/MCIndexSnapRounder.java
+ * Revision: 486
+ */
+
+/**
+ * @requires jsts/algorithm/RobustLineIntersector.js
+ * @requires jsts/noding/Noder.js
+ */
+
+/**
+ * Uses Snap Rounding to compute a rounded, fully noded arrangement from a set
+ * of {@link SegmentString}s. Implements the Snap Rounding technique described
+ * in papers by Hobby, Guibas & Marimont, and Goodrich et al. Snap Rounding
+ * assumes that all vertices lie on a uniform grid; hence the precision model of
+ * the input must be fixed precision, and all the input vertices must be rounded
+ * to that precision.
+ * <p>
+ * This implementation uses a monotone chains and a spatial index to speed up
+ * the intersection tests.
+ * <p>
+ * This implementation appears to be fully robust using an integer precision
+ * model. It will function with non-integer precision models, but the results
+ * are not 100% guaranteed to be correctly noded.
+ */
+jsts.noding.snapround.MCIndexSnapRounder = function(pm) {
+  this.pm = pm;
+  this.li = new jsts.algorithm.RobustLineIntersector();
+  this.li.setPrecisionModel(pm);
+  this.scaleFactor = pm.getScale();
+};
+
+jsts.noding.snapround.MCIndexSnapRounder.prototype = new jsts.noding.Noder();
+jsts.noding.snapround.MCIndexSnapRounder.constructor = jsts.noding.snapround.MCIndexSnapRounder;
+
+
+jsts.noding.snapround.MCIndexSnapRounder.prototype.pm = null;
+jsts.noding.snapround.MCIndexSnapRounder.prototype.li = null;
+jsts.noding.snapround.MCIndexSnapRounder.prototype.scaleFactor = null;
+jsts.noding.snapround.MCIndexSnapRounder.prototype.noder = null;
+jsts.noding.snapround.MCIndexSnapRounder.prototype.pointSnapper = null;
+jsts.noding.snapround.MCIndexSnapRounder.prototype.nodedSegStrings = null;
+
+jsts.noding.snapround.MCIndexSnapRounder.prototype.getNodedSubstrings = function() {
+  return jsts.noding.NodedSegmentString
+      .getNodedSubstrings(this.nodedSegStrings);
+};
+
+jsts.noding.snapround.MCIndexSnapRounder.prototype.computeNodes = function(
+    inputSegmentStrings) {
+  this.nodedSegStrings = inputSegmentStrings;
+  this.noder = new jsts.noding.MCIndexNoder();
+  this.pointSnapper = new jsts.noding.snapround.MCIndexPointSnapper(this.noder
+      .getIndex());
+  this.snapRound(inputSegmentStrings, this.li);
+};
+
+/**
+ * @private
+ */
+jsts.noding.snapround.MCIndexSnapRounder.prototype.snapRound = function(
+    segStrings, li) {
+  var intersections = this.findInteriorIntersections(segStrings, li);
+  this.computeIntersectionSnaps(intersections);
+  this.computeVertexSnaps(segStrings);
+};
+
+/**
+ * Computes all interior intersections in the collection of
+ * {@link SegmentString}s, and returns their
+ *
+ * @link Coordinate}s.
+ *
+ * Does NOT node the segStrings.
+ *
+ * @return a list of Coordinates for the intersections.
+ * @private
+ */
+jsts.noding.snapround.MCIndexSnapRounder.prototype.findInteriorIntersections = function(
+    segStrings, li) {
+  var intFinderAdder = new jsts.noding.IntersectionFinderAdder(li);
+  this.noder.setSegmentIntersector(intFinderAdder);
+  this.noder.computeNodes(segStrings);
+  return intFinderAdder.getInteriorIntersections();
+};
+
+/**
+ * Computes nodes introduced as a result of snapping segments to snap points
+ * (hot pixels)
+ *
+ * @private
+ */
+jsts.noding.snapround.MCIndexSnapRounder.prototype.computeIntersectionSnaps = function(
+    snapPts) {
+  for (var it = snapPts.iterator(); it.hasNext();) {
+    var snapPt = it.next();
+    var hotPixel = new jsts.noding.snapround.HotPixel(snapPt, this.scaleFactor,
+        this.li);
+    this.pointSnapper.snap(hotPixel);
+  }
+};
+
+/**
+ * Computes nodes introduced as a result of snapping segments to vertices of
+ * other segments
+ *
+ * @param edges
+ *          the list of segment strings to snap together.
+ */
+jsts.noding.snapround.MCIndexSnapRounder.prototype.computeVertexSnaps = function(
+    edges) {
+  if (edges instanceof jsts.noding.NodedSegmentString) {
+    this.computeVertexSnaps2.apply(this, arguments);
+    return;
+  }
+
+  for (var i0 = edges.iterator(); i0.hasNext();) {
+    var edge0 = i0.next();
+    this.computeVertexSnaps(edge0);
+  }
+};
+
+/**
+ * Performs a brute-force comparison of every segment in each
+ * {@link SegmentString}. This has n^2 performance.
+ *
+ * @private
+ */
+jsts.noding.snapround.MCIndexSnapRounder.prototype.computeVertexSnaps2 = function(
+    e) {
+  var pts0 = e.getCoordinates();
+  for (var i = 0; i < pts0.length - 1; i++) {
+    var hotPixel = new jsts.noding.snapround.HotPixel(pts0[i],
+        this.scaleFactor, this.li);
+    var isNodeAdded = this.pointSnapper.snap(hotPixel, e, i);
+    // if a node is created for a vertex, that vertex must be noded too
+    if (isNodeAdded) {
+      e.addIntersection(pts0[i], i);
+    }
+  }
+};

data/vendor/assets/javascripts/jsts/operation/BoundaryOp.js

@@ -0,0 +1,166 @@
+
+
+/**
+ * Computes the boundary of a {@link Geometry}.
+ * Allows specifying the {@link BoundaryNodeRule} to be used.
+ * This operation will always return a {@link Geometry} of the appropriate
+ * dimension for the boundary (even if the input geometry is empty).
+ * The boundary of zero-dimensional geometries (Points) is
+ * always the empty {@link GeometryCollection}.
+ *
+ * @author Martin Davis
+ * @version 1.7
+ */
+
+jsts.operation.BoundaryOp = function(geom, bnRule) {
+  this.geom = geom;
+  this.geomFact = geom.getFactory();
+  this.bnRule = bnRule || jsts.algorithm.BoundaryNodeRule.MOD2_BOUNDARY_RULE;
+};
+
+
+/**
+   * @type {Geometry}
+   * @private
+   */
+jsts.operation.BoundaryOp.prototype.geom = null;
+
+
+/**
+   * @type {GeometryFactory}
+   * @private
+   */
+jsts.operation.BoundaryOp.prototype.geomFact = null;
+
+
+/**
+   * @type {BoundaryNodeRule}
+   * @private
+   */
+jsts.operation.BoundaryOp.prototype.bnRule = null;
+
+
+/**
+   * @return {Geometry}
+   */
+jsts.operation.BoundaryOp.prototype.getBoundary = function()  {
+  if (this.geom instanceof jsts.geom.LineString) return this.boundaryLineString(this.geom);
+  if (this.geom instanceof jsts.geom.MultiLineString) return this.boundaryMultiLineString(this.geom);
+  return this.geom.getBoundary();
+};
+
+
+/**
+   * @return {MultiPoint}
+   * @private
+   */
+jsts.operation.BoundaryOp.prototype.getEmptyMultiPoint = function()  {
+  return this.geomFact.createMultiPoint(null);
+};
+
+
+/**
+   * @param {MultiLineString} mLine
+   * @return {Geometry}
+   * @private
+   */
+jsts.operation.BoundaryOp.prototype.boundaryMultiLineString = function(mLine)  {
+  if (this.geom.isEmpty()) {
+    return this.getEmptyMultiPoint();
+  }
+
+  var bdyPts = this.computeBoundaryCoordinates(mLine);
+
+  // return Point or MultiPoint
+  if (bdyPts.length == 1) {
+    return this.geomFact.createPoint(bdyPts[0]);
+  }
+  // this handles 0 points case as well
+  return this.geomFact.createMultiPoint(bdyPts);
+};
+
+
+/**
+   * @type {Array}
+   * @private
+   */
+jsts.operation.BoundaryOp.prototype.endpoints = null;
+
+
+/**
+   * @param {MultiLineString} mLine
+   * @return {Array.<Coordinate>}
+   * @private
+   */
+jsts.operation.BoundaryOp.prototype.computeBoundaryCoordinates = function(mLine)  {
+  var i, line, endpoint, bdyPts = [];
+
+  this.endpoints = [];
+  for (i = 0; i < mLine.getNumGeometries(); i++) {
+    line = mLine.getGeometryN(i);
+    if (line.getNumPoints() == 0)
+      continue;
+    this.addEndpoint(line.getCoordinateN(0));
+    this.addEndpoint(line.getCoordinateN(line.getNumPoints() - 1));
+  }
+
+  for (i = 0; i < this.endpoints.length; i++) {
+    endpoint = this.endpoints[i];
+    if (this.bnRule.isInBoundary(endpoint.count)) {
+      bdyPts.push(endpoint.coordinate);
+    }
+  }
+
+  return bdyPts;
+};
+
+
+/**
+   * @param {Coordinate} pt
+   * @private
+   */
+jsts.operation.BoundaryOp.prototype.addEndpoint = function(pt) {
+  var i, endpoint, found = false;
+  for (i = 0; i < this.endpoints.length; i++) {
+    endpoint = this.endpoints[i];
+    if (endpoint.coordinate.equals(pt)) {
+      found = true;
+      break;
+    }
+  }
+
+  if (!found) {
+    endpoint = {};
+    endpoint.coordinate = pt;
+    endpoint.count = 0;
+    this.endpoints.push(endpoint);
+  }
+
+  endpoint.count++;
+};
+
+
+/**
+   * @param {LineString} line
+   * @return {Geometry}
+   * @private
+   */
+jsts.operation.BoundaryOp.prototype.boundaryLineString = function(line)  {
+  if (this.geom.isEmpty()) {
+    return this.getEmptyMultiPoint();
+  }
+
+  if (line.isClosed()) {
+    // check whether endpoints of valence 2 are on the boundary or not
+    var closedEndpointOnBoundary = this.bnRule.isInBoundary(2);
+    if (closedEndpointOnBoundary) {
+      return line.getStartPoint();
+    }
+    else {
+      return this.geomFact.createMultiPoint(null);
+    }
+  }
+  return this.geomFact.createMultiPoint([line.getStartPoint(),
+        line.getEndPoint()]
+  );
+};

data/vendor/assets/javascripts/jsts/operation/GeometryGraphOperation.js

@@ -0,0 +1,90 @@
+/* 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.
+ */
+
+
+
+/**
+ * The base class for operations that require {@link GeometryGraph}s.
+ *
+ * @param {Geometry}
+ *          g0
+ * @param {Geometry}
+ *          g1
+ * @param {BoundaryNodeRule}
+ *          boundaryNodeRule
+ * @constructor
+ */
+jsts.operation.GeometryGraphOperation = function(g0, g1, boundaryNodeRule) {
+  this.li = new jsts.algorithm.RobustLineIntersector();
+  this.arg = [];
+
+  if (g0 === undefined) {
+    return;
+  }
+
+  if (g1 === undefined) {
+    this.setComputationPrecision(g0.getPrecisionModel());
+
+    this.arg[0] = new jsts.geomgraph.GeometryGraph(0, g0);
+    return;
+  }
+
+  boundaryNodeRule = boundaryNodeRule ||
+      jsts.algorithm.BoundaryNodeRule.OGC_SFS_BOUNDARY_RULE;
+
+  // use the most precise model for the result
+  if (g0.getPrecisionModel().compareTo(g1.getPrecisionModel()) >= 0)
+    this.setComputationPrecision(g0.getPrecisionModel());
+  else
+    this.setComputationPrecision(g1.getPrecisionModel());
+
+  this.arg[0] = new jsts.geomgraph.GeometryGraph(0, g0, boundaryNodeRule);
+  this.arg[1] = new jsts.geomgraph.GeometryGraph(1, g1, boundaryNodeRule);
+};
+
+
+/**
+ * @type {LineIntersector}
+ * @protected
+ */
+jsts.operation.GeometryGraphOperation.prototype.li = null;
+
+
+/**
+ * @type {PrecisionModel}
+ * @protected
+ */
+jsts.operation.GeometryGraphOperation.prototype.resultPrecisionModel = null;
+
+
+/**
+ * The operation args into an array so they can be accessed by index
+ *
+ * @type {GeometryGraph[]}
+ * @protected
+ */
+jsts.operation.GeometryGraphOperation.prototype.arg = null;
+
+
+/**
+ * @param {int}
+ *          i
+ * @return {Geometry}
+ */
+jsts.operation.GeometryGraphOperation.prototype.getArgGeometry = function(i) {
+  return arg[i].getGeometry();
+};
+
+
+/**
+ * @param {PrecisionModel}
+ *          pm
+ * @protected
+ */
+jsts.operation.GeometryGraphOperation.prototype.setComputationPrecision = function(pm) {
+  this.resultPrecisionModel = pm;
+  this.li.setPrecisionModel(this.resultPrecisionModel);
+};