jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/geomgraph/Node.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.
+ */
+
+/**
+ * @requires jsts/geomgraph/GraphComponent.js
+ */
+
+
+
+/**
+ * @constructor
+ * @param {jsts.geom.Coordinate}
+ *          coord
+ * @param {jsts.geom.EdgeEndStar}
+ *          edges
+ * @augments jsts.geomgraph.GraphComponent
+ */
+jsts.geomgraph.Node = function(coord, edges) {
+  this.coord = coord;
+  this.edges = edges;
+  this.label = new jsts.geomgraph.Label(0, jsts.geom.Location.NONE);
+};
+
+jsts.geomgraph.Node.prototype = new jsts.geomgraph.GraphComponent();
+
+
+/**
+ * only non-null if this node is precise
+ */
+jsts.geomgraph.Node.prototype.coord = null;
+jsts.geomgraph.Node.prototype.edges = null;
+
+jsts.geomgraph.Node.prototype.isIsolated = function() {
+  return (this.label.getGeometryCount() == 1);
+};
+
+jsts.geomgraph.Node.prototype.setLabel2 = function(argIndex, onLocation) {
+  if (this.label === null) {
+    this.label = new jsts.geomgraph.Label(argIndex, onLocation);
+  } else
+    this.label.setLocation(argIndex, onLocation);
+};
+
+
+/**
+ * Updates the label of a node to BOUNDARY, obeying the mod-2
+ * boundaryDetermination rule.
+ */
+jsts.geomgraph.Node.prototype.setLabelBoundary = function(argIndex) {
+  // determine the current location for the point (if any)
+  var loc = jsts.geom.Location.NONE;
+  if (this.label !== null)
+    loc = this.label.getLocation(argIndex);
+  // flip the loc
+  var newLoc;
+  switch (loc) {
+  case jsts.geom.Location.BOUNDARY:
+    newLoc = jsts.geom.Location.INTERIOR;
+    break;
+  case jsts.geom.Location.INTERIOR:
+    newLoc = jsts.geom.Location.BOUNDARY;
+    break;
+  default:
+    newLoc = jsts.geom.Location.BOUNDARY;
+    break;
+  }
+  this.label.setLocation(argIndex, newLoc);
+};
+
+
+/**
+ * Add the edge to the list of edges at this node
+ */
+jsts.geomgraph.Node.prototype.add = function(e) {
+  this.edges.insert(e);
+  e.setNode(this);
+};
+
+jsts.geomgraph.Node.prototype.getCoordinate = function() {
+  return this.coord;
+};
+jsts.geomgraph.Node.prototype.getEdges = function() {
+  return this.edges;
+};
+
+/**
+ * Tests whether any incident edge is flagged as being in the result. This test
+ * can be used to determine if the node is in the result, since if any incident
+ * edge is in the result, the node must be in the result as well.
+ *
+ * @return <code>true</code> if any indicident edge in the in the result.
+ */
+jsts.geomgraph.Node.prototype.isIncidentEdgeInResult = function() {
+  for (var it = this.getEdges().getEdges().iterator(); it.hasNext();) {
+    var de = it.next();
+    if (de.getEdge().isInResult())
+      return true;
+  }
+  return false;
+};
+
+// TODO: port rest

data/vendor/assets/javascripts/jsts/geomgraph/NodeFactory.js

@@ -0,0 +1,22 @@
+/* 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.
+ */
+
+
+
+/**
+ * @constructor
+ */
+jsts.geomgraph.NodeFactory = function() {
+
+};
+
+
+/**
+ * The basic node constructor does not allow for incident edges
+ */
+jsts.geomgraph.NodeFactory.prototype.createNode = function(coord) {
+  return new jsts.geomgraph.Node(coord, null);
+};

data/vendor/assets/javascripts/jsts/geomgraph/NodeMap.js

@@ -0,0 +1,128 @@
+/* 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.
+ */
+
+(function() {
+
+  /**
+   * @requires jsts/geom/Location.js
+   */
+
+  var Location = jsts.geom.Location;
+  var ArrayList = javascript.util.ArrayList;
+  var TreeMap = javascript.util.TreeMap;
+
+  /**
+   * A map of nodes, indexed by the coordinate of the node.
+   *
+   * @constructor
+   */
+  jsts.geomgraph.NodeMap = function(nodeFactory) {
+    this.nodeMap = new TreeMap();
+    this.nodeFact = nodeFactory;
+  };
+
+
+  /**
+   * NOTE: Seems like the index isn't functionally important, so in JSTS a JS
+   * object replaces TreeMap. Sorting is done when needed.
+   *
+   * @type {javascript.util.HashMap}
+   */
+  jsts.geomgraph.NodeMap.prototype.nodeMap = null;
+
+  jsts.geomgraph.NodeMap.prototype.nodeFact = null;
+
+
+  /**
+   * This method expects that a node has a coordinate value.
+   *
+   * In JSTS this replaces multiple overloaded methods from JTS.
+   *
+   * @param {jsts.geom.Coordinate/jsts.geomgraph.Node}
+   *          arg
+   * @return {jsts.geomgraph.Node}
+   */
+  jsts.geomgraph.NodeMap.prototype.addNode = function(arg) {
+    var node, coord;
+
+    if (arg instanceof jsts.geom.Coordinate) {
+      coord = arg;
+      node = this.nodeMap.get(coord);
+      if (node === null) {
+        node = this.nodeFact.createNode(coord);
+        this.nodeMap.put(coord, node);
+      }
+      return node;
+    } else if (arg instanceof jsts.geomgraph.Node) {
+      var n = arg;
+      coord = n.getCoordinate();
+      node = this.nodeMap.get(coord);
+      if (node === null) {
+        this.nodeMap.put(coord, n);
+        return n;
+      }
+      node.mergeLabel(n);
+      return node;
+    }
+  };
+
+
+  /**
+   * Adds a node for the start point of this EdgeEnd (if one does not already
+   * exist in this map). Adds the EdgeEnd to the (possibly new) node.
+   *
+   * @param {jsts.geomgraph.EdgeEnd}
+   *          e
+   */
+  jsts.geomgraph.NodeMap.prototype.add = function(e) {
+    var p = e.getCoordinate();
+    var n = this.addNode(p);
+    n.add(e);
+  };
+
+
+  /**
+   * @param {jsts.geom.Coordinate}
+   *          coord
+   * @return {jsts.geomgraph.Node} the node if found; null otherwise.
+   */
+  jsts.geomgraph.NodeMap.prototype.find = function(coord) {
+    return this.nodeMap.get(coord);
+  };
+
+
+  /**
+   * @return {javascript.util.Collection}
+   */
+  jsts.geomgraph.NodeMap.prototype.values = function() {
+    return this.nodeMap.values();
+  };
+
+  /**
+   * @return {javascript.util.Collection}
+   */
+  jsts.geomgraph.NodeMap.prototype.iterator = function() {
+    return this.values().iterator();
+  };
+
+
+  /**
+   * @param {number}
+   *          geomIndex
+   * @return {Array.<Node>}
+   */
+  jsts.geomgraph.NodeMap.prototype.getBoundaryNodes = function(geomIndex) {
+    var bdyNodes = new ArrayList();
+    for (var i = this.iterator(); i.hasNext();) {
+      var node = i.next();
+      if (node.getLabel().getLocation(geomIndex) === Location.BOUNDARY) {
+        bdyNodes.add(node);
+      }
+    }
+    return bdyNodes;
+  };
+
+})();

data/vendor/assets/javascripts/jsts/geomgraph/PlanarGraph.js

@@ -0,0 +1,214 @@
+/* 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.
+ */
+
+/**
+ * @requires jsts/geomgraph/NodeMap.js
+ * @requires jsts/geomgraph/NodeFactory.js
+ */
+
+(function() {
+
+  var ArrayList = javascript.util.ArrayList;
+
+  /**
+   * The computation of the <code>IntersectionMatrix</code> relies on the use
+   * of a structure called a "topology graph". The topology graph contains nodes
+   * and edges corresponding to the nodes and line segments of a
+   * <code>Geometry</code>. Each node and edge in the graph is labeled with
+   * its topological location relative to the source geometry.
+   * <P>
+   * Note that there is no requirement that points of self-intersection be a
+   * vertex. Thus to obtain a correct topology graph, <code>Geometry</code>s
+   * must be self-noded before constructing their graphs.
+   * <P>
+   * Two fundamental operations are supported by topology graphs:
+   * <UL>
+   * <LI>Computing the intersections between all the edges and nodes of a
+   * single graph
+   * <LI>Computing the intersections between the edges and nodes of two
+   * different graphs
+   * </UL>
+   *
+   * @constructor
+   */
+  jsts.geomgraph.PlanarGraph = function(nodeFactory) {
+    this.edges = new ArrayList();
+    this.edgeEndList = new ArrayList();
+    this.nodes = new jsts.geomgraph.NodeMap(nodeFactory ||
+        new jsts.geomgraph.NodeFactory());
+  };
+
+
+  /**
+   * @type {javascript.util.ArrayList}
+   * @protected
+   */
+  jsts.geomgraph.PlanarGraph.prototype.edges = null;
+
+
+  /**
+   * @type {jsts.geomgraph.NodeMap}
+   * @protected
+   */
+  jsts.geomgraph.PlanarGraph.prototype.nodes = null;
+  /**
+   * @type {javascript.util.ArrayList}
+   * @protected
+   */
+  jsts.geomgraph.PlanarGraph.prototype.edgeEndList = null;
+
+  /**
+   * For nodes in the Collection, link the DirectedEdges at the node that are in
+   * the result. This allows clients to link only a subset of nodes in the
+   * graph, for efficiency (because they know that only a subset is of
+   * interest).
+   */
+  jsts.geomgraph.PlanarGraph.linkResultDirectedEdges = function(nodes) {
+    for (var nodeit = nodes.iterator(); nodeit.hasNext();) {
+      var node = nodeit.next();
+      node.getEdges().linkResultDirectedEdges();
+    }
+  };
+
+
+  jsts.geomgraph.PlanarGraph.prototype.getEdgeIterator = function() {
+    return this.edges.iterator();
+  };
+  jsts.geomgraph.PlanarGraph.prototype.getEdgeEnds = function() {
+    return this.edgeEndList;
+  };
+
+  jsts.geomgraph.PlanarGraph.prototype.isBoundaryNode = function(geomIndex,
+      coord) {
+    var node = this.nodes.find(coord);
+    if (node === null)
+      return false;
+    var label = node.getLabel();
+    if (label !== null &&
+        label.getLocation(geomIndex) === jsts.geom.Location.BOUNDARY)
+      return true;
+    return false;
+  };
+
+  jsts.geomgraph.PlanarGraph.prototype.insertEdge = function(e) {
+    this.edges.add(e);
+  };
+
+  jsts.geomgraph.PlanarGraph.prototype.add = function(e) {
+    this.nodes.add(e);
+    this.edgeEndList.add(e);
+  };
+
+  /**
+   * @return {javascript.util.Iterator}
+   */
+  jsts.geomgraph.PlanarGraph.prototype.getNodeIterator = function() {
+    return this.nodes.iterator();
+  };
+
+  /**
+   * @return {javascript.util.Collection}
+   */
+  jsts.geomgraph.PlanarGraph.prototype.getNodes = function() {
+    return this.nodes.values();
+  };
+
+  jsts.geomgraph.PlanarGraph.prototype.addNode = function(node) {
+    return this.nodes.addNode(node);
+  };
+
+  /**
+   * Add a set of edges to the graph. For each edge two DirectedEdges will be
+   * created. DirectedEdges are NOT linked by this method.
+   *
+   * @param {javascript.util.List}
+   *          edgedToAdd
+   */
+  jsts.geomgraph.PlanarGraph.prototype.addEdges = function(edgesToAdd) {
+    // create all the nodes for the edges
+    for (var it = edgesToAdd.iterator(); it.hasNext();) {
+      var e = it.next();
+      this.edges.add(e);
+
+      var de1 = new jsts.geomgraph.DirectedEdge(e, true);
+      var de2 = new jsts.geomgraph.DirectedEdge(e, false);
+      de1.setSym(de2);
+      de2.setSym(de1);
+
+      this.add(de1);
+      this.add(de2);
+    }
+  };
+
+  jsts.geomgraph.PlanarGraph.prototype.linkResultDirectedEdges = function() {
+    for (var nodeit = this.nodes.iterator(); nodeit.hasNext();) {
+      var node = nodeit.next();
+      node.getEdges().linkResultDirectedEdges();
+    }
+  };
+
+  /**
+   * Returns the edge which starts at p0 and whose first segment is parallel to
+   * p1
+   *
+   * @return the edge, if found <code>null</code> if the edge was not found.
+   */
+  jsts.geomgraph.PlanarGraph.prototype.findEdgeInSameDirection = function(p0,
+      p1) {
+    var i = 0, il = this.edges.size(), e, eCoord;
+    for (i; i < il; i++) {
+      e = this.edges.get(i);
+      eCoord = e.getCoordinates();
+
+      if (this.matchInSameDirection(p0, p1, eCoord[0], eCoord[1])) {
+        return e;
+      }
+
+      if (this.matchInSameDirection(p0, p1, eCoord[eCoord.length - 1],
+          eCoord[eCoord.length - 2])) {
+        return e;
+      }
+    }
+    return null;
+  };
+
+  /**
+   * The coordinate pairs match if they define line segments lying in the same
+   * direction. E.g. the segments are parallel and in the same quadrant (as
+   * opposed to parallel and opposite!).
+   */
+  jsts.geomgraph.PlanarGraph.prototype.matchInSameDirection = function(p0, p1,
+      ep0, ep1) {
+    if (!p0.equals(ep0)) {
+      return false;
+    }
+
+    if (jsts.algorithm.CGAlgorithms.computeOrientation(p0, p1, ep1) === jsts.algorithm.CGAlgorithms.COLLINEAR &&
+        jsts.geomgraph.Quadrant.quadrant(p0, p1) === jsts.geomgraph.Quadrant
+            .quadrant(ep0, ep1)) {
+      return true;
+    }
+    return false;
+  };
+
+  /**
+   * Returns the EdgeEnd which has edge e as its base edge (MD 18 Feb 2002 -
+   * this should return a pair of edges)
+   *
+   * @return the edge, if found <code>null</code> if the edge was not found.
+   */
+  jsts.geomgraph.PlanarGraph.prototype.findEdgeEnd = function(e) {
+    for (var i = this.getEdgeEnds().iterator(); i.hasNext();) {
+      var ee = i.next();
+      if (ee.getEdge() === e) {
+        return ee;
+      }
+    }
+    return null;
+  };
+})();
+
+// TODO: port rest of class