jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/noding/ScaledNoder.js

@@ -0,0 +1,105 @@
+/* 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/ScaledNoder.java
+ * Revision: 478
+ */
+
+jsts.noding.ScaledNoder = function(noder, scaleFactor, offsetX, offsetY) {
+  this.offsetX = offsetX ? offsetX : 0;
+  this.offsetY = offsetY ? offsetY : 0;
+
+  this.noder = noder;
+  this.scaleFactor = scaleFactor;
+
+  // no need to scale if input precision is already integral
+  this.isScaled = !this.isIntegerPrecision();
+};
+
+jsts.noding.ScaledNoder.prototype = new jsts.noding.Noder();
+jsts.noding.ScaledNoder.constructor = jsts.noding.ScaledNoder;
+
+jsts.noding.ScaledNoder.prototype.noder = null;
+jsts.noding.ScaledNoder.prototype.scaleFactor = undefined;
+jsts.noding.ScaledNoder.prototype.offsetX = undefined;
+jsts.noding.ScaledNoder.prototype.offsetY = undefined;
+jsts.noding.ScaledNoder.prototype.isScaled = false;
+
+jsts.noding.ScaledNoder.prototype.isIntegerPrecision = function() {
+  return this.scaleFactor === 1.0;
+};
+
+jsts.noding.ScaledNoder.prototype.getNodedSubstrings = function() {
+  var splitSS = this.noder.getNodedSubstrings();
+  if (this.isScaled)
+    this.rescale(splitSS);
+  return splitSS;
+};
+
+jsts.noding.ScaledNoder.prototype.computeNodes = function(inputSegStrings) {
+  var intSegStrings = inputSegStrings;
+  if (this.isScaled)
+    intSegStrings = this.scale(inputSegStrings);
+  this.noder.computeNodes(intSegStrings);
+};
+
+/**
+ * @private
+ */
+jsts.noding.ScaledNoder.prototype.scale = function(segStrings) {
+  if (segStrings instanceof Array) {
+    return this.scale2(segStrings);
+  }
+
+  var transformed = new javascript.util.ArrayList();
+  for (var i = segStrings.iterator(); i.hasNext();) {
+    var ss = i.next();
+    transformed.add(new jsts.noding.NodedSegmentString(this.scale(ss
+        .getCoordinates()), ss.getData()));
+  }
+
+  return transformed;
+};
+
+/**
+ * @private
+ */
+jsts.noding.ScaledNoder.prototype.scale2 = function(pts) {
+  var roundPts = [];
+  for (var i = 0; i < pts.length; i++) {
+    roundPts[i] = new jsts.geom.Coordinate(Math
+        .round((pts[i].x - this.offsetX) * this.scaleFactor), Math
+        .round((pts[i].y - this.offsetY) * this.scaleFactor));
+  }
+  var roundPtsNoDup = jsts.geom.CoordinateArrays.removeRepeatedPoints(roundPts);
+  return roundPtsNoDup;
+};
+
+/**
+ * @private
+ */
+jsts.noding.ScaledNoder.prototype.rescale = function(segStrings) {
+  if (segStrings instanceof Array) {
+    this.rescale2(segStrings);
+    return;
+  }
+
+  for (var i = segStrings.iterator(); i.hasNext();) {
+    var ss = i.next();
+    this.rescale(ss.getCoordinates());
+  }
+};
+
+/**
+ * @private
+ */
+jsts.noding.ScaledNoder.prototype.rescale2 = function(pts) {
+  for (var i = 0; i < pts.length; i++) {
+    pts[i].x = pts[i].x / this.scaleFactor + this.offsetX;
+    pts[i].y = pts[i].y / this.scaleFactor + this.offsetY;
+  }
+};

data/vendor/assets/javascripts/jsts/noding/SegmentIntersector.js

@@ -0,0 +1,45 @@
+/* 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.
+ */
+
+/**
+ * Processes possible intersections detected by a {@link Noder}. The
+ * {@link SegmentIntersector} is passed to a {@link Noder}. The
+ * {@link addIntersections} method is called whenever the {@link Noder} detects
+ * that two SegmentStrings <i>might</i> intersect. This class may be used
+ * either to find all intersections, or to detect the presence of an
+ * intersection. In the latter case, Noders may choose to short-circuit their
+ * computation by calling the {@link isDone} method. This class is an example of
+ * the <i>Strategy</i> pattern.
+ *
+ * @interface
+ */
+jsts.noding.SegmentIntersector = function() {
+
+};
+
+/**
+ * This method is called by clients of the {@link SegmentIntersector} interface
+ * to process intersections for two segments of the {@link SegmentString}s
+ * being intersected.
+ *
+ * @param {SegmentString}
+ *          e0
+ * @param {number}
+ *          segIndex0
+ * @param {SegmentString}
+ *          e1
+ * @param {number}
+ *          segIndex0
+ */
+jsts.noding.SegmentIntersector.prototype.processIntersections = jsts.abstractFunc;
+
+/**
+ * Reports whether the client of this class needs to continue testing all
+ * intersections in an arrangement.
+ *
+ * @return {boolean} true if there is no need to continue testing segments.
+ */
+jsts.noding.SegmentIntersector.prototype.isDone = jsts.abstractFunc;

data/vendor/assets/javascripts/jsts/noding/SegmentNode.js

@@ -0,0 +1,70 @@
+/* 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/SegmentNode.java
+ * Revision: 478
+ */
+
+/**
+ * Represents an intersection point between two {@link SegmentString}s.
+ *
+ * @constructor
+ */
+jsts.noding.SegmentNode = function(segString,  coord,  segmentIndex,  segmentOctant) {
+  this.segString = segString;
+  this.coord = new jsts.geom.Coordinate(coord);
+  this.segmentIndex = segmentIndex;
+  this.segmentOctant = segmentOctant;
+  this._isInterior = ! coord.equals2D(segString.getCoordinate(segmentIndex));
+};
+
+
+/**
+ * @type {NodedSegmentString}
+ * @private
+ */
+jsts.noding.SegmentNode.prototype.segString = null;
+jsts.noding.SegmentNode.prototype.coord = null;   // the point of intersection
+jsts.noding.SegmentNode.prototype.segmentIndex = null;   // the index of the containing line segment in the parent edge
+jsts.noding.SegmentNode.prototype.segmentOctant = null;
+jsts.noding.SegmentNode.prototype._isInterior = null;
+
+/**
+ * Gets the {@link Coordinate} giving the location of this node.
+ *
+ * @return the coordinate of the node.
+ */
+jsts.noding.SegmentNode.prototype.getCoordinate = function() {
+  return this.coord;
+};
+
+
+jsts.noding.SegmentNode.prototype.isInterior = function() { return this._isInterior; };
+
+jsts.noding.SegmentNode.prototype.isEndPoint = function(maxSegmentIndex)  {
+  if (this.segmentIndex === 0 && ! this._isInterior) return true;
+  if (this.segmentIndex === this.maxSegmentIndex) return true;
+  return false;
+};
+
+
+/**
+   * @return -1 this SegmentNode is located before the argument location.
+   * @return 0 this SegmentNode is at the argument location.
+   * @return 1 this SegmentNode is located after the argument location.
+   */
+jsts.noding.SegmentNode.prototype.compareTo = function(obj)  {
+  var other = obj;
+
+  if (this.segmentIndex < other.segmentIndex) return -1;
+  if (this.segmentIndex > other.segmentIndex) return 1;
+
+  if (this.coord.equals2D(other.coord)) return 0;
+
+  return jsts.noding.SegmentPointComparator.compare(this.segmentOctant, this.coord, other.coord);
+};
+

data/vendor/assets/javascripts/jsts/noding/SegmentNodeList.js

@@ -0,0 +1,262 @@
+/* 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/SegmentNodeList.java
+ * Revision: 478
+ */
+
+
+/**
+ * A list of the {@link SegmentNode}s present along a noded
+ * {@link SegmentString}.
+ *
+ * @constructor
+ */
+jsts.noding.SegmentNodeList = function(edge) {
+  this.nodeMap = new javascript.util.TreeMap();
+
+  this.edge = edge;
+};
+
+
+/**
+ * @type {javascript.util.TreeMap}
+ * @private
+ */
+jsts.noding.SegmentNodeList.prototype.nodeMap = null;
+
+/**
+ * returns an iterator of SegmentNodes
+ */
+jsts.noding.SegmentNodeList.prototype.iterator = function() {
+  return this.nodeMap.values().iterator();
+};
+
+
+/**
+ * the parent edge
+ *
+ * @type {NodedSegmentString}
+ * @private
+ */
+jsts.noding.SegmentNodeList.prototype.edge = null;
+
+
+jsts.noding.SegmentNodeList.prototype.getEdge = function() {
+  return this.edge;
+};
+
+
+/**
+ * Adds an intersection into the list, if it isn't already there. The input
+ * segmentIndex and dist are expected to be normalized.
+ *
+ * @return the SegmentIntersection found or added.
+ */
+jsts.noding.SegmentNodeList.prototype.add = function(intPt, segmentIndex) {
+  var eiNew = new jsts.noding.SegmentNode(this.edge, intPt, segmentIndex,
+      this.edge.getSegmentOctant(segmentIndex));
+  var ei = this.nodeMap.get(eiNew);
+  if (ei !== null) {
+    jsts.util.Assert.isTrue(ei.coord.equals2D(intPt),
+        'Found equal nodes with different coordinates');
+    return ei;
+  }
+  // node does not exist, so create it
+  this.nodeMap.put(eiNew, eiNew);
+  return eiNew;
+};
+
+
+/**
+ * Adds nodes for the first and last points of the edge
+ *
+ * @private
+ */
+jsts.noding.SegmentNodeList.prototype.addEndpoints = function() {
+  var maxSegIndex = this.edge.size() - 1;
+  this.add(this.edge.getCoordinate(0), 0);
+  this.add(this.edge.getCoordinate(maxSegIndex), maxSegIndex);
+};
+
+
+/**
+ * Adds nodes for any collapsed edge pairs. Collapsed edge pairs can be caused
+ * by inserted nodes, or they can be pre-existing in the edge vertex list. In
+ * order to provide the correct fully noded semantics, the vertex at the base of
+ * a collapsed pair must also be added as a node.
+ *
+ * @private
+ */
+jsts.noding.SegmentNodeList.prototype.addCollapsedNodes = function() {
+  var collapsedVertexIndexes = [];
+
+  this.findCollapsesFromInsertedNodes(collapsedVertexIndexes);
+  this.findCollapsesFromExistingVertices(collapsedVertexIndexes);
+
+  // node the collapses
+  for (var i = 0; i < collapsedVertexIndexes.length; i++) {
+    var vertexIndex = collapsedVertexIndexes[i];
+    this.add(this.edge.getCoordinate(vertexIndex), vertexIndex);
+  }
+};
+
+
+/**
+ * Adds nodes for any collapsed edge pairs which are pre-existing in the vertex
+ * list.
+ *
+ * @private
+ */
+jsts.noding.SegmentNodeList.prototype.findCollapsesFromExistingVertices = function(
+    collapsedVertexIndexes) {
+  for (var i = 0; i < this.edge.size() - 2; i++) {
+    var p0 = this.edge.getCoordinate(i);
+    var p1 = this.edge.getCoordinate(i + 1);
+    var p2 = this.edge.getCoordinate(i + 2);
+    if (p0.equals2D(p2)) {
+      // add base of collapse as node
+      collapsedVertexIndexes.push(i + 1);
+    }
+  }
+};
+
+
+/**
+ * Adds nodes for any collapsed edge pairs caused by inserted nodes Collapsed
+ * edge pairs occur when the same coordinate is inserted as a node both before
+ * and after an existing edge vertex. To provide the correct fully noded
+ * semantics, the vertex must be added as a node as well.
+ *
+ * @private
+ */
+jsts.noding.SegmentNodeList.prototype.findCollapsesFromInsertedNodes = function(
+    collapsedVertexIndexes) {
+  var collapsedVertexIndex = [null];
+  var it = this.iterator();
+  // there should always be at least two entries in the list, since the
+  // endpoints are nodes
+  var eiPrev = it.next();
+  while (it.hasNext()) {
+    var ei = it.next();
+    var isCollapsed = this.findCollapseIndex(eiPrev, ei, collapsedVertexIndex);
+    if (isCollapsed)
+      collapsedVertexIndexes.push(collapsedVertexIndex[0]);
+
+    eiPrev = ei;
+  }
+};
+
+
+/**
+ * @private
+ */
+jsts.noding.SegmentNodeList.prototype.findCollapseIndex = function(ei0, ei1,
+    collapsedVertexIndex) {
+  // only looking for equal nodes
+  if (!ei0.coord.equals2D(ei1.coord))
+    return false;
+
+  var numVerticesBetween = ei1.segmentIndex - ei0.segmentIndex;
+  if (!ei1.isInterior()) {
+    numVerticesBetween--;
+  }
+
+  // if there is a single vertex between the two equal nodes, this is a collapse
+  if (numVerticesBetween === 1) {
+    collapsedVertexIndex[0] = ei0.segmentIndex + 1;
+    return true;
+  }
+  return false;
+};
+
+
+/**
+ * Creates new edges for all the edges that the intersections in this list split
+ * the parent edge into. Adds the edges to the provided argument list (this is
+ * so a single list can be used to accumulate all split edges for a set of
+ * {@link SegmentString}s).
+ *
+ * @param {Array}
+ *          edgeList
+ */
+jsts.noding.SegmentNodeList.prototype.addSplitEdges = function(edgeList) {
+  // ensure that the list has entries for the first and last point of the edge
+  this.addEndpoints();
+  this.addCollapsedNodes();
+
+  var it = this.iterator();
+  // there should always be at least two entries in the list, since the
+  // endpoints are nodes
+  var eiPrev = it.next();
+  while (it.hasNext()) {
+    var ei = it.next();
+    var newEdge = this.createSplitEdge(eiPrev, ei);
+    edgeList.add(newEdge);
+    eiPrev = ei;
+  }
+};
+
+
+/**
+ * Checks the correctness of the set of split edges corresponding to this edge.
+ *
+ * @param {Array}
+ *          splitEdges the split edges for this edge (in order).
+ * @private
+ */
+jsts.noding.SegmentNodeList.prototype.checkSplitEdgesCorrectness = function(
+    splitEdges) {
+  var edgePts = edge.getCoordinates();
+
+  // check that first and last points of split edges are same as endpoints of
+  // edge
+  var split0 = splitEdges[0];
+  var pt0 = split0.getCoordinate(0);
+  if (!pt0.equals2D(edgePts[0]))
+    throw new Error('bad split edge start point at ' + pt0);
+
+  var splitn = splitEdges[splitEdges.length - 1];
+  var splitnPts = splitn.getCoordinates();
+  var ptn = splitnPts[splitnPts.length - 1];
+  if (!ptn.equals2D(edgePts[edgePts.length - 1]))
+    throw new Error('bad split edge end point at ' + ptn);
+};
+
+
+/**
+ * Create a new "split edge" with the section of points between (and including)
+ * the two intersections. The label for the new edge is the same as the label
+ * for the parent edge.
+ *
+ * @private
+ */
+jsts.noding.SegmentNodeList.prototype.createSplitEdge = function(ei0, ei1) {
+  var npts = ei1.segmentIndex - ei0.segmentIndex + 2;
+
+  var lastSegStartPt = this.edge.getCoordinate(ei1.segmentIndex);
+  // if the last intersection point is not equal to the its segment start pt,
+  // add it to the points list as well.
+  // (This check is needed because the distance metric is not totally reliable!)
+  // The check for point equality is 2D only - Z values are ignored
+  var useIntPt1 = ei1.isInterior() || !ei1.coord.equals2D(lastSegStartPt);
+  if (!useIntPt1) {
+    npts--;
+  }
+
+  var pts = [];
+  // pts.length = npts;
+  var ipt = 0;
+  pts[ipt++] = new jsts.geom.Coordinate(ei0.coord);
+  for (var i = ei0.segmentIndex + 1; i <= ei1.segmentIndex; i++) {
+    pts[ipt++] = this.edge.getCoordinate(i);
+  }
+  if (useIntPt1)
+    pts[ipt] = ei1.coord;
+
+  return new jsts.noding.NodedSegmentString(pts, this.edge.getData());
+};