jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/operation/buffer/BufferParameters.js

@@ -0,0 +1,328 @@
+/* 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 the parameters which describe how a buffer should be constructed.
+ *
+ * @constructor
+ */
+jsts.operation.buffer.BufferParameters = function(quadrantSegments,
+    endCapStyle, joinStyle, mitreLimit) {
+  if (quadrantSegments)
+    this.setQuadrantSegments(quadrantSegments);
+  if (endCapStyle)
+    this.setEndCapStyle(endCapStyle);
+  if (joinStyle)
+    this.setJoinStyle(joinStyle);
+  if (mitreLimit)
+    this.setMitreLimit(mitreLimit);
+};
+
+
+/**
+ * Specifies a round line buffer end cap style.
+ *
+ * @type {int}
+ */
+jsts.operation.buffer.BufferParameters.CAP_ROUND = 1;
+
+
+/**
+ * Specifies a flat line buffer end cap style.
+ *
+ * @type {int}
+ */
+jsts.operation.buffer.BufferParameters.CAP_FLAT = 2;
+
+
+/**
+ * Specifies a square line buffer end cap style.
+ *
+ * @type {int}
+ */
+jsts.operation.buffer.BufferParameters.CAP_SQUARE = 3;
+
+
+/**
+ * Specifies a round join style.
+ *
+ * @type {int}
+ */
+jsts.operation.buffer.BufferParameters.JOIN_ROUND = 1;
+
+
+/**
+ * Specifies a mitre join style.
+ */
+jsts.operation.buffer.BufferParameters.JOIN_MITRE = 2;
+
+
+/**
+ * Specifies a bevel join style.
+ *
+ * @type {int}
+ */
+jsts.operation.buffer.BufferParameters.JOIN_BEVEL = 3;
+
+
+/**
+ * The default number of facets into which to divide a fillet of 90 degrees. A
+ * value of 8 gives less than 2% max error in the buffer distance. For a max
+ * error of < 1%, use QS = 12. For a max error of < 0.1%, use QS = 18.
+ *
+ * @type {int}
+ */
+jsts.operation.buffer.BufferParameters.DEFAULT_QUADRANT_SEGMENTS = 8;
+
+
+/**
+ * The default mitre limit Allows fairly pointy mitres.
+ *
+ * @type {double}
+ */
+jsts.operation.buffer.BufferParameters.DEFAULT_MITRE_LIMIT = 5.0;
+
+
+/**
+ * @type {int}
+ * @private
+ */
+jsts.operation.buffer.BufferParameters.prototype.quadrantSegments = jsts.operation.buffer.BufferParameters.DEFAULT_QUADRANT_SEGMENTS;
+
+
+/**
+ * @type {int}
+ * @private
+ */
+jsts.operation.buffer.BufferParameters.prototype.endCapStyle = jsts.operation.buffer.BufferParameters.CAP_ROUND;
+
+
+/**
+ * @type {int}
+ * @private
+ */
+jsts.operation.buffer.BufferParameters.prototype.joinStyle = jsts.operation.buffer.BufferParameters.JOIN_ROUND;
+
+
+/**
+ * @type {double}
+ * @private
+ */
+jsts.operation.buffer.BufferParameters.prototype.mitreLimit = jsts.operation.buffer.BufferParameters.DEFAULT_MITRE_LIMIT;
+
+/**
+ * @type {boolean}
+ * @private
+ */
+jsts.operation.buffer.BufferParameters.prototype._isSingleSided = false;
+
+/**
+ * Gets the number of quadrant segments which will be used
+ *
+ * @return the number of quadrant segments.
+ */
+jsts.operation.buffer.BufferParameters.prototype.getQuadrantSegments = function() {
+  return this.quadrantSegments;
+};
+
+
+/**
+ * Sets the number of segments used to approximate a angle fillet
+ *
+ * @param {int}
+ *          quadrantSegments the number of segments in a fillet for a quadrant.
+ */
+jsts.operation.buffer.BufferParameters.prototype.setQuadrantSegments = function(
+    quadrantSegments) {
+  this.quadrantSegments = quadrantSegments;
+};
+
+
+/**
+ * Sets the number of line segments used to approximate an angle fillet.
+ * <ul>
+ * <li>If <tt>quadSegs</tt> >= 1, joins are round, and <tt>quadSegs</tt>
+ * indicates the number of segments to use to approximate a quarter-circle.
+ * <li>If <tt>quadSegs</tt> = 0, joins are bevelled (flat)
+ * <li>If <tt>quadSegs</tt> < 0, joins are mitred, and the value of qs
+ * indicates the mitre ration limit as
+ *
+ * <pre>
+ * mitreLimit= |
+ * <tt>
+ * quadSegs
+ * </tt>
+ * |
+ * </pre>
+ *
+ * </ul>
+ * For round joins, <tt>quadSegs</tt> determines the maximum error in the
+ * approximation to the true buffer curve. The default value of 8 gives less
+ * than 2% max error in the buffer distance. For a max error of < 1%, use QS =
+ * 12. For a max error of < 0.1%, use QS = 18. The error is always less than the
+ * buffer distance (in other words, the computed buffer curve is always inside
+ * the true curve).
+ *
+ * @param quadrantSegments
+ *          the number of segments in a fillet for a quadrant.
+ */
+jsts.operation.buffer.BufferParameters.prototype.setQuadrantSegments = function(
+    quadSegs) {
+  this.quadrantSegments = quadSegs;
+
+  /**
+   * Indicates how to construct fillets. If qs >= 1, fillet is round, and qs
+   * indicates number of segments to use to approximate a quarter-circle. If qs =
+   * 0, fillet is bevelled flat (i.e. no filleting is performed) If qs < 0,
+   * fillet is mitred, and absolute value of qs indicates maximum length of
+   * mitre according to
+   *
+   * mitreLimit = |qs|
+   */
+  if (this.quadrantSegments === 0)
+    this.joinStyle = jsts.operation.buffer.BufferParameters.JOIN_BEVEL;
+  if (this.quadrantSegments < 0) {
+    this.joinStyle = jsts.operation.buffer.BufferParameters.JOIN_MITRE;
+    this.mitreLimit = Math.abs(this.quadrantSegments);
+  }
+
+  if (quadSegs <= 0) {
+    this.quadrantSegments = 1;
+  }
+
+  /**
+   * If join style was set by the quadSegs value, use the default for the actual
+   * quadrantSegments value.
+   */
+  if (this.joinStyle !== jsts.operation.buffer.BufferParameters.JOIN_ROUND) {
+    this.quadrantSegments = jsts.operation.buffer.BufferParameters.DEFAULT_QUADRANT_SEGMENTS;
+  }
+};
+
+
+/**
+ * Computes the maximum distance error due to a given level of approximation to
+ * a true arc.
+ *
+ * @param quadSegs
+ *          the number of segments used to approximate a quarter-circle.
+ * @return the error of approximation.
+ */
+jsts.operation.buffer.BufferParameters.bufferDistanceError = function(quadSegs) {
+  var alpha = Math.PI / 2.0 / quadSegs;
+  return 1 - Math.cos(alpha / 2.0);
+};
+
+
+/**
+ * Gets the end cap style.
+ *
+ * @return the end cap style.
+ */
+jsts.operation.buffer.BufferParameters.prototype.getEndCapStyle = function() {
+  return this.endCapStyle;
+};
+
+
+/**
+ * Specifies the end cap style of the generated buffer. The styles supported are
+ * {@link #CAP_ROUND}, {@link #CAP_BUTT}, and {@link #CAP_SQUARE}. The
+ * default is CAP_ROUND.
+ *
+ * @param {int}
+ *          endCapStyle the end cap style to specify.
+ */
+jsts.operation.buffer.BufferParameters.prototype.setEndCapStyle = function(
+    endCapStyle) {
+  this.endCapStyle = endCapStyle;
+};
+
+
+/**
+ * Gets the join style
+ *
+ * @return the join style code.
+ */
+jsts.operation.buffer.BufferParameters.prototype.getJoinStyle = function() {
+  return this.joinStyle;
+};
+
+
+/**
+ * Sets the join style for outside (reflex) corners between line segments.
+ * Allowable values are {@link JOIN_ROUND} (which is the default),
+ * {@link JOIN_MITRE} and {link JOIN_BEVEL}.
+ *
+ * @param joinStyle
+ *          the code for the join style.
+ */
+jsts.operation.buffer.BufferParameters.prototype.setJoinStyle = function(
+    joinStyle) {
+  this.joinStyle = joinStyle;
+};
+
+
+/**
+ * Gets the mitre ratio limit.
+ *
+ * @return the limit value.
+ */
+jsts.operation.buffer.BufferParameters.prototype.getMitreLimit = function() {
+  return this.mitreLimit;
+};
+
+
+/**
+ * Sets the limit on the mitre ratio used for very sharp corners. The mitre
+ * ratio is the ratio of the distance from the corner to the end of the mitred
+ * offset corner. When two line segments meet at a sharp angle, a miter join
+ * will extend far beyond the original geometry. (and in the extreme case will
+ * be infinitely far.) To prevent unreasonable geometry, the mitre limit allows
+ * controlling the maximum length of the join corner. Corners with a ratio which
+ * exceed the limit will be beveled.
+ *
+ * @param mitreLimit
+ *          the mitre ratio limit.
+ */
+jsts.operation.buffer.BufferParameters.prototype.setMitreLimit = function(
+    mitreLimit) {
+  this.mitreLimit = mitreLimit;
+};
+
+
+/**
+ * Sets whether the computed buffer should be single-sided. A single-sided
+ * buffer is constructed on only one side of each input line.
+ * <p>
+ * The side used is determined by the sign of the buffer distance:
+ * <ul>
+ * <li>a positive distance indicates the left-hand side
+ * <li>a negative distance indicates the right-hand side
+ * </ul>
+ * The single-sided buffer of point geometries is the same as the regular
+ * buffer.
+ * <p>
+ * The End Cap Style for single-sided buffers is always ignored, and forced to
+ * the equivalent of <tt>CAP_FLAT</tt>.
+ *
+ * @param isSingleSided
+ *          true if a single-sided buffer should be constructed.
+ */
+jsts.operation.buffer.BufferParameters.prototype.setSingleSided = function(
+    isSingleSided) {
+  this._isSingleSided = isSingleSided;
+};
+
+
+/**
+ * Tests whether the buffer is to be generated on a single side only.
+ *
+ * @return true if the generated buffer is to be single-sided.
+ */
+jsts.operation.buffer.BufferParameters.prototype.isSingleSided = function() {
+  return this._isSingleSided;
+};

data/vendor/assets/javascripts/jsts/operation/buffer/BufferSubgraph.js

@@ -0,0 +1,296 @@
+/* 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.
+ */
+
+/**
+ * A connected subset of the graph of {@link DirectedEdge}s and {@link Node}s.
+ * Its edges will generate either
+ * <ul>
+ * <li> a single polygon in the complete buffer, with zero or more holes, or
+ * <li> one or more connected holes
+ * </ul>
+ *
+ *
+ * @constructor
+ */
+jsts.operation.buffer.BufferSubgraph = function() {
+  this.dirEdgeList = new javascript.util.ArrayList();
+  this.nodes = new javascript.util.ArrayList();
+
+  this.finder = new jsts.operation.buffer.RightmostEdgeFinder();
+};
+
+/**
+ * @type {RightmostEdgeFinder}
+ * @private
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.finder = null;
+/**
+ * @type {Array}
+ * @private
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.dirEdgeList = null;
+/**
+ * @type {Array}
+ * @private
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.nodes = null;
+/**
+ * @type {Coordinate}
+ * @private
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.rightMostCoord = null;
+/**
+ * @type {Envelope}
+ * @private
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.env = null;
+
+
+jsts.operation.buffer.BufferSubgraph.prototype.getDirectedEdges = function() {
+  return this.dirEdgeList;
+};
+jsts.operation.buffer.BufferSubgraph.prototype.getNodes = function() {
+  return this.nodes;
+};
+
+/**
+ * Computes the envelope of the edges in the subgraph. The envelope is cached
+ * after being computed.
+ *
+ * @return the envelope of the graph.
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.getEnvelope = function() {
+  if (this.env === null) {
+    var edgeEnv = new jsts.geom.Envelope();
+    for (var it = this.dirEdgeList.iterator(); it.hasNext(); ) {
+      var dirEdge = it.next();
+      var pts = dirEdge.getEdge().getCoordinates();
+      for (var j = 0; j < pts.length - 1; j++) {
+        edgeEnv.expandToInclude(pts[j]);
+      }
+    }
+    this.env = edgeEnv;
+  }
+  return this.env;
+};
+
+/**
+ * Gets the rightmost coordinate in the edges of the subgraph
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.getRightmostCoordinate = function() {
+  return this.rightMostCoord;
+};
+
+/**
+ * Creates the subgraph consisting of all edges reachable from this node. Finds
+ * the edges in the graph and the rightmost coordinate.
+ *
+ * @param node
+ *          a node to start the graph traversal from.
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.create = function(node) {
+  this.addReachable(node);
+  this.finder.findEdge(this.dirEdgeList);
+  this.rightMostCoord = this.finder.getCoordinate();
+};
+
+/**
+ * Adds all nodes and edges reachable from this node to the subgraph. Uses an
+ * explicit stack to avoid a large depth of recursion.
+ *
+ * @param node
+ *          a node known to be in the subgraph.
+ * @private
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.addReachable = function(
+    startNode) {
+  var nodeStack = [];
+  nodeStack.push(startNode);
+  while (nodeStack.length !== 0) {
+    var node = nodeStack.pop();
+    this.add(node, nodeStack);
+  }
+};
+
+/**
+ * Adds the argument node and all its out edges to the subgraph
+ *
+ * @param node
+ *          the node to add.
+ * @param nodeStack
+ *          the current set of nodes being traversed.
+ * @private
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.add = function(node, nodeStack) {
+  node.setVisited(true);
+  this.nodes.add(node);
+  for (var i = node.getEdges().iterator(); i.hasNext(); ) {
+    var de = i.next();
+    this.dirEdgeList.add(de);
+    var sym = de.getSym();
+    var symNode = sym.getNode();
+    /**
+     * NOTE: this is a depth-first traversal of the graph. This will cause a
+     * large depth of recursion. It might be better to do a breadth-first
+     * traversal.
+     */
+    if (!symNode.isVisited())
+      nodeStack.push(symNode);
+  }
+};
+
+jsts.operation.buffer.BufferSubgraph.prototype.clearVisitedEdges = function() {
+  for (var it = this.dirEdgeList.iterator(); it.hasNext(); ) {
+    var de = it.next();
+    de.setVisited(false);
+  }
+};
+
+jsts.operation.buffer.BufferSubgraph.prototype.computeDepth = function(
+    outsideDepth) {
+  this.clearVisitedEdges();
+  // find an outside edge to assign depth to
+  var de = this.finder.getEdge();
+  var n = de.getNode();
+  var label = de.getLabel();
+  // right side of line returned by finder is on the outside
+  de.setEdgeDepths(jsts.geomgraph.Position.RIGHT, outsideDepth);
+  this.copySymDepths(de);
+
+  this.computeDepths(de);
+};
+
+/**
+ * Compute depths for all dirEdges via breadth-first traversal of nodes in graph
+ *
+ * @param startEdge
+ *          edge to start processing with.
+ * @private
+ */
+// <FIX> MD - use iteration & queue rather than recursion, for speed and
+// robustness
+jsts.operation.buffer.BufferSubgraph.prototype.computeDepths = function(
+    startEdge) {
+  var nodesVisited = [];
+  var nodeQueue = [];
+
+  var startNode = startEdge.getNode();
+  nodeQueue.push(startNode);
+  nodesVisited.push(startNode);
+  startEdge.setVisited(true);
+
+  while (nodeQueue.length !== 0) {
+    var n = nodeQueue.shift();
+    nodesVisited.push(n);
+    // compute depths around node, starting at this edge since it has depths
+    // assigned
+    this.computeNodeDepth(n);
+
+    // add all adjacent nodes to process queue,
+    // unless the node has been visited already
+    for (var i = n.getEdges().iterator(); i.hasNext(); ) {
+      var de = i.next();
+      var sym = de.getSym();
+      if (sym.isVisited())
+        continue;
+      var adjNode = sym.getNode();
+      if (nodesVisited.indexOf(adjNode) === -1) {
+        nodeQueue.push(adjNode);
+        nodesVisited.push(adjNode);
+      }
+    }
+  }
+};
+
+/**
+ * @private
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.computeNodeDepth = function(n) {
+  // find a visited dirEdge to start at
+  var startEdge = null;
+  for (var i = n.getEdges().iterator(); i.hasNext(); ) {
+    var de = i.next();
+    if (de.isVisited() || de.getSym().isVisited()) {
+      startEdge = de;
+      break;
+    }
+  }
+  // MD - testing Result: breaks algorithm
+  // if (startEdge == null) return;
+
+  // only compute string append if assertion would fail
+  if (startEdge == null)
+    throw new jsts.error.TopologyError(
+        'unable to find edge to compute depths at ' + n.getCoordinate());
+
+  n.getEdges().computeDepths(startEdge);
+
+  // copy depths to sym edges
+  for (var i = n.getEdges().iterator(); i.hasNext(); ) {
+    var de = i.next();
+    de.setVisited(true);
+    this.copySymDepths(de);
+  }
+};
+
+/**
+ * @private
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.copySymDepths = function(de) {
+  var sym = de.getSym();
+  sym.setDepth(jsts.geomgraph.Position.LEFT, de
+      .getDepth(jsts.geomgraph.Position.RIGHT));
+  sym.setDepth(jsts.geomgraph.Position.RIGHT, de
+      .getDepth(jsts.geomgraph.Position.LEFT));
+};
+
+/**
+ * Find all edges whose depths indicates that they are in the result area(s).
+ * Since we want polygon shells to be oriented CW, choose dirEdges with the
+ * interior of the result on the RHS. Mark them as being in the result. Interior
+ * Area edges are the result of dimensional collapses. They do not form part of
+ * the result area boundary.
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.findResultEdges = function() {
+  for (var it = this.dirEdgeList.iterator(); it.hasNext(); ) {
+    var de = it.next();
+    /**
+     * Select edges which have an interior depth on the RHS
+     * and an exterior depth on the LHS.
+     * Note that because of weird rounding effects there may be
+     * edges which have negative depths!  Negative depths
+     * count as "outside".
+     */
+    // <FIX> - handle negative depths
+    if (de.getDepth(jsts.geomgraph.Position.RIGHT) >= 1 &&
+        de.getDepth(jsts.geomgraph.Position.LEFT) <= 0 &&
+        !de.isInteriorAreaEdge()) {
+      de.setInResult(true);
+    }
+  }
+};
+
+/**
+ * BufferSubgraphs are compared on the x-value of their rightmost Coordinate.
+ * This defines a partial ordering on the graphs such that:
+ * <p>
+ * g1 >= g2 <==> Ring(g2) does not contain Ring(g1)
+ * <p>
+ * where Polygon(g) is the buffer polygon that is built from g.
+ * <p>
+ * This relationship is used to sort the BufferSubgraphs so that shells are
+ * guaranteed to be built before holes.
+ */
+jsts.operation.buffer.BufferSubgraph.prototype.compareTo = function(o) {
+  var graph = o;
+  if (this.rightMostCoord.x < graph.rightMostCoord.x) {
+    return -1;
+  }
+  if (this.rightMostCoord.x > graph.rightMostCoord.x) {
+    return 1;
+  }
+  return 0;
+};