jsts-rails 0.1.0 → 0.2.0

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

@@ -0,0 +1,109 @@
+/* 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 dynamic list of the vertices in a constructed offset curve. Automatically
+ * removes adjacent vertices which are closer than a given tolerance.
+ * @constructor
+ */
+jsts.operation.buffer.OffsetSegmentString = function() {
+  this.ptList = [];
+};
+
+
+/**
+ * @private
+ */
+jsts.operation.buffer.OffsetSegmentString.prototype.ptList = null;
+
+
+/**
+ * @private
+ */
+jsts.operation.buffer.OffsetSegmentString.prototype.precisionModel = null;
+
+
+/**
+ * The distance below which two adjacent points on the curve are considered to
+ * be coincident. This is chosen to be a small fraction of the offset distance.
+ *
+ * @private
+ */
+jsts.operation.buffer.OffsetSegmentString.prototype.minimimVertexDistance = 0.0;
+
+
+jsts.operation.buffer.OffsetSegmentString.prototype.setPrecisionModel = function(
+    precisionModel) {
+  this.precisionModel = precisionModel;
+};
+
+jsts.operation.buffer.OffsetSegmentString.prototype.setMinimumVertexDistance = function(
+    minimimVertexDistance) {
+  this.minimimVertexDistance = minimimVertexDistance;
+};
+
+jsts.operation.buffer.OffsetSegmentString.prototype.addPt = function(pt) {
+  var bufPt = new jsts.geom.Coordinate(pt);
+  this.precisionModel.makePrecise(bufPt);
+  // don't add duplicate (or near-duplicate) points
+  if (this.isRedundant(bufPt))
+    return;
+  this.ptList.push(bufPt);
+};
+
+jsts.operation.buffer.OffsetSegmentString.prototype.addPts = function(pt,
+    isForward) {
+  if (isForward) {
+    for (var i = 0; i < pt.length; i++) {
+      this.addPt(pt[i]);
+    }
+  } else {
+    for (var i = pt.length - 1; i >= 0; i--) {
+      this.addPt(pt[i]);
+    }
+  }
+};
+
+
+/**
+ * Tests whether the given point is redundant relative to the previous point in
+ * the list (up to tolerance).
+ *
+ * @param pt
+ * @return true if the point is redundant.
+ * @private
+ */
+jsts.operation.buffer.OffsetSegmentString.prototype.isRedundant = function(pt) {
+  if (this.ptList.length < 1)
+    return false;
+  var lastPt = this.ptList[this.ptList.length - 1];
+  var ptDist = pt.distance(lastPt);
+  if (ptDist < this.minimimVertexDistance)
+    return true;
+  return false;
+};
+
+jsts.operation.buffer.OffsetSegmentString.prototype.closeRing = function() {
+  if (this.ptList.length < 1)
+    return;
+  var startPt = new jsts.geom.Coordinate(this.ptList[0]);
+  var lastPt = this.ptList[this.ptList.length - 1];
+  var last2Pt = null;
+  if (this.ptList.length >= 2)
+    last2Pt = this.ptList[this.ptList.length - 2];
+  if (startPt.equals(lastPt))
+    return;
+  this.ptList.push(startPt);
+};
+
+jsts.operation.buffer.OffsetSegmentString.prototype.reverse = function() {
+
+};
+
+jsts.operation.buffer.OffsetSegmentString.prototype.getCoordinates = function() {
+  return this.ptList;
+};

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

@@ -0,0 +1,164 @@
+/* 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 RightmostEdgeFinder find the DirectedEdge in a list which has the highest
+ * coordinate, and which is oriented L to R at that point. (I.e. the right side
+ * is on the RHS of the edge.)
+ *
+ * @constructor
+ */
+jsts.operation.buffer.RightmostEdgeFinder = function() {};
+// private Coordinate extremeCoord;
+jsts.operation.buffer.RightmostEdgeFinder.prototype.minIndex = -1;
+jsts.operation.buffer.RightmostEdgeFinder.prototype.minCoord = null;
+jsts.operation.buffer.RightmostEdgeFinder.prototype.minDe = null;
+jsts.operation.buffer.RightmostEdgeFinder.prototype.orientedDe = null;
+
+
+jsts.operation.buffer.RightmostEdgeFinder.prototype.getEdge = function() {
+  return this.orientedDe;
+};
+jsts.operation.buffer.RightmostEdgeFinder.prototype.getCoordinate = function() {
+  return this.minCoord;
+};
+
+jsts.operation.buffer.RightmostEdgeFinder.prototype.findEdge = function(
+    dirEdgeList) {
+  /**
+   * Check all forward DirectedEdges only. This is still general, because each
+   * edge has a forward DirectedEdge.
+   */
+  for (var i = dirEdgeList.iterator(); i.hasNext();) {
+    var de = i.next();
+    if (!de.isForward())
+      continue;
+    this.checkForRightmostCoordinate(de);
+  }
+
+  /**
+   * If the rightmost point is a node, we need to identify which of the incident
+   * edges is rightmost.
+   */
+  jsts.util.Assert.isTrue(this.minIndex !== 0 ||
+      this.minCoord.equals(this.minDe.getCoordinate()),
+      'inconsistency in rightmost processing');
+  if (this.minIndex === 0) {
+    this.findRightmostEdgeAtNode();
+  } else {
+    this.findRightmostEdgeAtVertex();
+  }
+  /**
+   * now check that the extreme side is the R side. If not, use the sym instead.
+   */
+  this.orientedDe = this.minDe;
+  var rightmostSide = this.getRightmostSide(this.minDe, this.minIndex);
+  if (rightmostSide == jsts.geomgraph.Position.LEFT) {
+    this.orientedDe = this.minDe.getSym();
+  }
+};
+/**
+ * @private
+ */
+jsts.operation.buffer.RightmostEdgeFinder.prototype.findRightmostEdgeAtNode = function() {
+  var node = this.minDe.getNode();
+  var star = node.getEdges();
+  this.minDe = star.getRightmostEdge();
+  // the DirectedEdge returned by the previous call is not
+  // necessarily in the forward direction. Use the sym edge if it isn't.
+  if (!this.minDe.isForward()) {
+    this.minDe = this.minDe.getSym();
+    this.minIndex = this.minDe.getEdge().getCoordinates().length - 1;
+  }
+};
+/**
+ * @private
+ */
+jsts.operation.buffer.RightmostEdgeFinder.prototype.findRightmostEdgeAtVertex = function() {
+  /**
+   * The rightmost point is an interior vertex, so it has a segment on either
+   * side of it. If these segments are both above or below the rightmost point,
+   * we need to determine their relative orientation to decide which is
+   * rightmost.
+   */
+  var pts = this.minDe.getEdge().getCoordinates();
+  jsts.util.Assert.isTrue(this.minIndex > 0 && this.minIndex < pts.length,
+      'rightmost point expected to be interior vertex of edge');
+  var pPrev = pts[this.minIndex - 1];
+  var pNext = pts[this.minIndex + 1];
+  var orientation = jsts.algorithm.CGAlgorithms.computeOrientation(
+      this.minCoord, pNext, pPrev);
+  var usePrev = false;
+  // both segments are below min point
+  if (pPrev.y < this.minCoord.y && pNext.y < this.minCoord.y &&
+      orientation === jsts.algorithm.CGAlgorithms.COUNTERCLOCKWISE) {
+    usePrev = true;
+  } else if (pPrev.y > this.minCoord.y && pNext.y > this.minCoord.y &&
+      orientation === jsts.algorithm.CGAlgorithms.CLOCKWISE) {
+    usePrev = true;
+  }
+  // if both segments are on the same side, do nothing - either is safe
+  // to select as a rightmost segment
+  if (usePrev) {
+    this.minIndex = this.minIndex - 1;
+  }
+};
+/**
+ * @private
+ */
+jsts.operation.buffer.RightmostEdgeFinder.prototype.checkForRightmostCoordinate = function(
+    de) {
+  var coord = de.getEdge().getCoordinates();
+  for (var i = 0; i < coord.length - 1; i++) {
+    // only check vertices which are the start or end point of a non-horizontal
+    // segment
+    // <FIX> MD 19 Sep 03 - NO! we can test all vertices, since the rightmost
+    // must have a non-horiz segment adjacent to it
+    if (this.minCoord === null || coord[i].x > this.minCoord.x) {
+      this.minDe = de;
+      this.minIndex = i;
+      this.minCoord = coord[i];
+    }
+    // }
+  }
+};
+/**
+ * @private
+ */
+jsts.operation.buffer.RightmostEdgeFinder.prototype.getRightmostSide = function(
+    de, index) {
+  var side = this.getRightmostSideOfSegment(de, index);
+  if (side < 0)
+    side = this.getRightmostSideOfSegment(de, index - 1);
+  if (side < 0) {
+    // reaching here can indicate that segment is horizontal
+    // Assert.shouldNeverReachHere("problem with finding rightmost side of
+    // segment at " + de.getCoordinate());
+    // testing only
+    this.minCoord = null;
+    this.checkForRightmostCoordinate(de);
+  }
+  return side;
+};
+
+/**
+ * @private
+ */
+jsts.operation.buffer.RightmostEdgeFinder.prototype.getRightmostSideOfSegment = function(
+    de, i) {
+  var e = de.getEdge();
+  var coord = e.getCoordinates();
+
+  if (i < 0 || i + 1 >= coord.length)
+    return -1;
+  if (coord[i].y == coord[i + 1].y)
+    return -1; // indicates edge is parallel to x-axis
+
+  var pos = jsts.geomgraph.Position.LEFT;
+  if (coord[i].y < coord[i + 1].y)
+    pos = jsts.geomgraph.Position.RIGHT;
+  return pos;
+};

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

@@ -0,0 +1,220 @@
+/* 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.
+ */
+
+/**
+ * Locates a subgraph inside a set of subgraphs, in order to determine the
+ * outside depth of the subgraph. The input subgraphs are assumed to have had
+ * depths already calculated for their edges.
+ *
+ * @constructor
+ */
+jsts.operation.buffer.SubgraphDepthLocater = function(subgraphs) {
+  this.subgraphs = [];
+  this.seg = new jsts.geom.LineSegment();
+
+  this.subgraphs = subgraphs;
+};
+
+jsts.operation.buffer.SubgraphDepthLocater.prototype.subgraphs = null;
+jsts.operation.buffer.SubgraphDepthLocater.prototype.seg = null;
+
+
+jsts.operation.buffer.SubgraphDepthLocater.prototype.getDepth = function(p) {
+  var stabbedSegments = this.findStabbedSegments(p);
+  // if no segments on stabbing line subgraph must be outside all others.
+  if (stabbedSegments.length === 0)
+    return 0;
+  stabbedSegments.sort();
+  var ds = stabbedSegments[0];
+  return ds.leftDepth;
+};
+
+/**
+ * Finds all non-horizontal segments intersecting the stabbing line. The
+ * stabbing line is the ray to the right of stabbingRayLeftPt.
+ *
+ * @param stabbingRayLeftPt
+ *          the left-hand origin of the stabbing line.
+ * @return a List of {@link DepthSegments} intersecting the stabbing line.
+ * @private
+ */
+jsts.operation.buffer.SubgraphDepthLocater.prototype.findStabbedSegments = function(
+    stabbingRayLeftPt) {
+
+  if (arguments.length === 3) {
+    this.findStabbedSegments2.apply(this, arguments);
+    return;
+  }
+
+  var stabbedSegments = [];
+  for (var i = 0; i < this.subgraphs.length; i++) {
+    var bsg = this.subgraphs[i];
+
+    // optimization - don't bother checking subgraphs which the ray does not
+    // intersect
+    var env = bsg.getEnvelope();
+    if (stabbingRayLeftPt.y < env.getMinY() ||
+        stabbingRayLeftPt.y > env.getMaxY())
+      continue;
+
+    this.findStabbedSegments2(stabbingRayLeftPt, bsg.getDirectedEdges(),
+        stabbedSegments);
+  }
+  return stabbedSegments;
+};
+
+/**
+ * Finds all non-horizontal segments intersecting the stabbing line in the list
+ * of dirEdges. The stabbing line is the ray to the right of stabbingRayLeftPt.
+ *
+ * @param stabbingRayLeftPt
+ *          the left-hand origin of the stabbing line.
+ * @param stabbedSegments
+ *          the current list of {@link DepthSegments} intersecting the stabbing
+ *          line.
+ * @private
+ */
+jsts.operation.buffer.SubgraphDepthLocater.prototype.findStabbedSegments2 = function(
+    stabbingRayLeftPt, dirEdges, stabbedSegments) {
+
+  if (arguments[1] instanceof jsts.geomgraph.DirectedEdge) {
+    this.findStabbedSegments3(stabbingRayLeftPt, dirEdges, stabbedSegments);
+    return;
+  }
+
+  /**
+   * Check all forward DirectedEdges only. This is still general, because each
+   * Edge has a forward DirectedEdge.
+   */
+  for (var i = dirEdges.iterator(); i.hasNext();) {
+    var de = i.next();
+    if (! de.isForward())
+      continue;
+    this.findStabbedSegments3(stabbingRayLeftPt, de, stabbedSegments);
+  }
+};
+
+/**
+ * Finds all non-horizontal segments intersecting the stabbing line in the input
+ * dirEdge. The stabbing line is the ray to the right of stabbingRayLeftPt.
+ *
+ * @param stabbingRayLeftPt
+ *          the left-hand origin of the stabbing line.
+ * @param stabbedSegments
+ *          the current list of {@link DepthSegments} intersecting the stabbing
+ *          line.
+ * @private
+ */
+jsts.operation.buffer.SubgraphDepthLocater.prototype.findStabbedSegments3 = function(
+    stabbingRayLeftPt, dirEdge, stabbedSegments) {
+  var pts = dirEdge.getEdge().getCoordinates();
+  for (var i = 0; i < pts.length - 1; i++) {
+    this.seg.p0 = pts[i];
+    this.seg.p1 = pts[i + 1];
+    // ensure segment always points upwards
+    if (this.seg.p0.y > this.seg.p1.y)
+      this.seg.reverse();
+
+    // skip segment if it is left of the stabbing line
+    var maxx = Math.max(this.seg.p0.x, this.seg.p1.x);
+    if (maxx < stabbingRayLeftPt.x)
+      continue;
+
+    // skip horizontal segments (there will be a non-horizontal one carrying the
+    // same depth info
+    if (this.seg.isHorizontal())
+      continue;
+
+    // skip if segment is above or below stabbing line
+    if (stabbingRayLeftPt.y < this.seg.p0.y || stabbingRayLeftPt.y > this.seg.p1.y)
+      continue;
+
+    // skip if stabbing ray is right of the segment
+    if (jsts.algorithm.CGAlgorithms.computeOrientation(this.seg.p0, this.seg.p1,
+        stabbingRayLeftPt) === jsts.algorithm.CGAlgorithms.RIGHT)
+      continue;
+
+    // stabbing line cuts this segment, so record it
+    var depth = dirEdge.getDepth(jsts.geomgraph.Position.LEFT);
+    // if segment direction was flipped, use RHS depth instead
+    if (!this.seg.p0.equals(pts[i]))
+      depth = dirEdge.getDepth(jsts.geomgraph.Position.RIGHT);
+    var ds = new jsts.operation.buffer.SubgraphDepthLocater.DepthSegment(this.seg, depth);
+    stabbedSegments.push(ds);
+  }
+};
+
+
+/**
+ * A segment from a directed edge which has been assigned a depth value for its
+ * sides.
+ */
+jsts.operation.buffer.SubgraphDepthLocater.DepthSegment = function(seg, depth) {
+  // input seg is assumed to be normalized
+  this.upwardSeg = new jsts.geom.LineSegment(seg);
+  // upwardSeg.normalize();
+  this.leftDepth = depth;
+};
+jsts.operation.buffer.SubgraphDepthLocater.DepthSegment.prototype.upwardSeg = null;
+jsts.operation.buffer.SubgraphDepthLocater.DepthSegment.prototype.leftDepth = null;
+
+/**
+ * Defines a comparision operation on DepthSegments which orders them left to
+ * right
+ *
+ * <pre>
+ * DS1 &lt; DS2   if   DS1.seg is left of DS2.seg
+ * DS1 &gt; DS2   if   DS1.seg is right of DS2.seg
+ * </pre>
+ *
+ * @param obj
+ * @return
+ */
+jsts.operation.buffer.SubgraphDepthLocater.DepthSegment.prototype.compareTo = function(
+    obj) {
+  var other = obj;
+  /**
+   * try and compute a determinate orientation for the segments. Test returns 1
+   * if other is left of this (i.e. this > other)
+   */
+  var orientIndex = this.upwardSeg.orientationIndex(other.upwardSeg);
+
+  /**
+   * If comparison between this and other is indeterminate, try the opposite
+   * call order. orientationIndex value is 1 if this is left of other, so have
+   * to flip sign to get proper comparison value of -1 if this is leftmost
+   */
+  if (orientIndex === 0)
+    orientIndex = -1 * other.upwardSeg.orientationIndex(upwardSeg);
+
+  // if orientation is determinate, return it
+  if (orientIndex !== 0)
+    return orientIndex;
+
+  // otherwise, segs must be collinear - sort based on minimum X value
+  return this.compareX(this.upwardSeg, other.upwardSeg);
+};
+
+/**
+ * Compare two collinear segments for left-most ordering. If segs are vertical,
+ * use vertical ordering for comparison. If segs are equal, return 0. Segments
+ * are assumed to be directed so that the second coordinate is >= to the first
+ * (e.g. up and to the right).
+ *
+ * @param seg0
+ *          a segment to compare.
+ * @param seg1
+ *          a segment to compare.
+ * @return
+ */
+jsts.operation.buffer.SubgraphDepthLocater.DepthSegment.prototype.compareX = function(
+    seg0, seg1) {
+  var compare0 = seg0.p0.compareTo(seg1.p0);
+  if (compare0 !== 0)
+    return compare0;
+  return seg0.p1.compareTo(seg1.p1);
+
+};