jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/planargraph/Edge.js

@@ -0,0 +1,124 @@
+/* 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/planargraph/Edge.java
+ * Revision: 6
+ */
+
+/**
+ * @requires jsts/planargraph/GraphComponent.js
+ */
+
+(function() {
+
+  var GraphComponent = jsts.planargraph.GraphComponent;
+
+  /**
+   * Represents an undirected edge of a {@link PlanarGraph}. An undirected edge
+   * in fact simply acts as a central point of reference for two opposite
+   * {@link DirectedEdge}s.
+   * <p>
+   * Usually a client using a <code>PlanarGraph</code> will subclass
+   * <code>Edge</code> to add its own application-specific data and methods.
+   *
+   * Constructs an Edge initialized with the given DirectedEdges, and for each
+   * DirectedEdge: sets the Edge, sets the symmetric DirectedEdge, and adds this
+   * Edge to its from-Node.
+   */
+  var Edge = function(de0, de1) {
+    if (de0 === undefined) {
+      return;
+    }
+    this.setDirectedEdges(de0, de1);
+  };
+
+  Edge.prototype = new GraphComponent();
+
+
+  /**
+   * The two DirectedEdges associated with this Edge. Index 0 is forward, 1 is
+   * reverse.
+   */
+  Edge.prototype.dirEdge = null;
+
+  /**
+   * Initializes this Edge's two DirectedEdges, and for each DirectedEdge: sets
+   * the Edge, sets the symmetric DirectedEdge, and adds this Edge to its
+   * from-Node.
+   */
+  Edge.prototype.setDirectedEdges = function(de0, de1) {
+    this.dirEdge = [de0, de1];
+    de0.setEdge(this);
+    de1.setEdge(this);
+    de0.setSym(de1);
+    de1.setSym(de0);
+    de0.getFromNode().addOutEdge(de0);
+    de1.getFromNode().addOutEdge(de1);
+  };
+
+  /**
+   * Returns one of the DirectedEdges associated with this Edge.
+   *
+   * @param i
+   *          0 or 1. 0 returns the forward directed edge, 1 returns the reverse.
+   */
+  Edge.prototype.getDirEdge = function(i) {
+    if (i instanceof jsts.planargraph.Node) {
+      this.getDirEdge2(i);
+    }
+
+    return this.dirEdge[i];
+  };
+
+  /**
+   * Returns the {@link DirectedEdge} that starts from the given node, or null
+   * if the node is not one of the two nodes associated with this Edge.
+   */
+  Edge.prototype.getDirEdge2 = function(fromNode) {
+    if (this.dirEdge[0].getFromNode() == fromNode)
+      return this.dirEdge[0];
+    if (this.dirEdge[1].getFromNode() == fromNode)
+      return this.dirEdge[1];
+    // node not found
+    // possibly should throw an exception here?
+    return null;
+  };
+
+  /**
+   * If <code>node</code> is one of the two nodes associated with this Edge,
+   * returns the other node; otherwise returns null.
+   */
+  Edge.prototype.getOppositeNode = function(node) {
+    if (this.dirEdge[0].getFromNode() == node)
+      return this.dirEdge[0].getToNode();
+    if (this.dirEdge[1].getFromNode() == node)
+      return this.dirEdge[1].getToNode();
+    // node not found
+    // possibly should throw an exception here?
+    return null;
+  };
+
+  /**
+   * Removes this edge from its containing graph.
+   */
+  Edge.prototype.remove = function() {
+    this.dirEdge = null;
+  };
+
+  /**
+   * Tests whether this edge has been removed from its containing graph
+   *
+   * @return <code>true</code> if this edge is removed.
+   */
+  Edge.prototype.isRemoved = function() {
+    return dirEdge == null;
+  };
+
+  jsts.planargraph.Edge = Edge;
+
+})();

data/vendor/assets/javascripts/jsts/planargraph/GraphComponent.js

@@ -0,0 +1,182 @@
+/* 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/planargraph/GraphComponent.java
+ * Revision: 6
+ */
+
+(function() {
+
+  /**
+   * The base class for all graph component classes. Maintains flags of use in
+   * generic graph algorithms. Provides two flags:
+   * <ul>
+   * <li><b>marked</b> - typically this is used to indicate a state that
+   * persists for the course of the graph's lifetime. For instance, it can be
+   * used to indicate that a component has been logically deleted from the
+   * graph.
+   * <li><b>visited</b> - this is used to indicate that a component has been
+   * processed or visited by an single graph algorithm. For instance, a
+   * breadth-first traversal of the graph might use this to indicate that a node
+   * has already been traversed. The visited flag may be set and cleared many
+   * times during the lifetime of a graph.
+   *
+   * <p>
+   * Graph components support storing user context data. This will typically be
+   * used by client algorithms which use planar graphs.
+   */
+  var GraphComponent = function() {
+
+  };
+
+  /**
+   * Sets the Visited state for all {@link GraphComponent}s in an
+   * {@link Iterator}
+   *
+   * @param i
+   *          the Iterator to scan.
+   * @param visited
+   *          the state to set the visited flag to.
+   */
+  GraphComponent.setVisited = function(i, visited) {
+    while (i.hasNext()) {
+      var comp = i.next();
+      comp.setVisited(visited);
+    }
+  };
+
+  /**
+   * Sets the Marked state for all {@link GraphComponent}s in an
+   * {@link Iterator}
+   *
+   * @param i
+   *          the Iterator to scan.
+   * @param marked
+   *          the state to set the Marked flag to.
+   */
+  GraphComponent.setMarked = function(i, marked) {
+    while (i.hasNext()) {
+      var comp = i.next();
+      comp.setMarked(marked);
+    }
+  };
+
+  /**
+   * Finds the first {@link GraphComponent} in a {@link Iterator} set which has
+   * the specified visited state.
+   *
+   * @param i
+   *          an Iterator of GraphComponents.
+   * @param visitedState
+   *          the visited state to test.
+   * @return the first component found, or <code>null</code> if none found.
+   */
+  GraphComponent.getComponentWithVisitedState = function(i, visitedState) {
+    while (i.hasNext()) {
+      var comp = i.next();
+      if (comp.isVisited() == visitedState)
+        return comp;
+    }
+    return null;
+  };
+
+  GraphComponent.prototype._isMarked = false;
+  GraphComponent.prototype._isVisited = false;
+  GraphComponent.prototype.data;
+
+
+  /**
+   * Tests if a component has been visited during the course of a graph
+   * algorithm
+   *
+   * @return <code>true</code> if the component has been visited.
+   */
+  GraphComponent.prototype.isVisited = function() {
+    return this._isVisited;
+  };
+
+  /**
+   * Sets the visited flag for this component.
+   *
+   * @param isVisited
+   *          the desired value of the visited flag.
+   */
+  GraphComponent.prototype.setVisited = function(isVisited) {
+    this._isVisited = isVisited;
+  };
+
+  /**
+   * Tests if a component has been marked at some point during the processing
+   * involving this graph.
+   *
+   * @return <code>true</code> if the component has been marked.
+   */
+  GraphComponent.prototype.isMarked = function() {
+    return this._isMarked;
+  };
+
+  /**
+   * Sets the marked flag for this component.
+   *
+   * @param isMarked
+   *          the desired value of the marked flag.
+   */
+  GraphComponent.prototype.setMarked = function(isMarked) {
+    this._isMarked = isMarked;
+  };
+
+  /**
+   * Sets the user-defined data for this component.
+   *
+   * @param data
+   *          an Object containing user-defined data.
+   */
+  GraphComponent.prototype.setContext = function(data) {
+    this.data = data;
+  };
+
+  /**
+   * Gets the user-defined data for this component.
+   *
+   * @return the user-defined data.
+   */
+  GraphComponent.prototype.getContext = function() {
+    return data;
+  };
+
+  /**
+   * Sets the user-defined data for this component.
+   *
+   * @param data
+   *          an Object containing user-defined data.
+   */
+  GraphComponent.prototype.setData = function(data) {
+    this.data = data;
+  };
+
+  /**
+   * Gets the user-defined data for this component.
+   *
+   * @return the user-defined data.
+   */
+  GraphComponent.prototype.getData = function() {
+    return data;
+  };
+
+  /**
+   * Tests whether this component has been removed from its containing graph
+   *
+   * @return <code>true</code> if this component is removed.
+   */
+  GraphComponent.prototype.isRemoved = function() {
+    throw new jsts.error.AbstractMethodInvocationError();
+  };
+
+  jsts.planargraph.GraphComponent = GraphComponent;
+
+})();

data/vendor/assets/javascripts/jsts/planargraph/Node.js

@@ -0,0 +1,127 @@
+/* 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/planargraph/Node.java
+ * Revision: 6
+ */
+
+/**
+ * @requires jsts/planargraph/GraphComponent.js
+ * @requires jsts/planargraph/DirectedEdgeStar.js
+ */
+
+(function() {
+
+  var GraphComponent = jsts.planargraph.GraphComponent;
+  var DirectedEdgeStar = jsts.planargraph.DirectedEdgeStar;
+
+  /**
+   * A node in a {@link PlanarGraph}is a location where 0 or more {@link Edge}s
+   * meet. A node is connected to each of its incident Edges via an outgoing
+   * DirectedEdge. Some clients using a <code>PlanarGraph</code> may want to
+   * subclass <code>Node</code> to add their own application-specific data and
+   * methods.
+   *
+   * Constructs a Node with the given location and collection of outgoing
+   * DirectedEdges.
+   */
+  var Node = function(pt, deStar) {
+    this.pt = pt;
+    this.deStar = deStar || new DirectedEdgeStar();
+  };
+
+
+  Node.prototype = new GraphComponent();
+
+
+  /**
+   * Returns all Edges that connect the two nodes (which are assumed to be
+   * different).
+   */
+  Node.getEdgesBetween = function(node0, node1) {
+    var edges0 = DirectedEdge.toEdges(node0.getOutEdges().getEdges());
+    var commonEdges = new javascript.util.HashSet(edges0);
+    var edges1 = DirectedEdge.toEdges(node1.getOutEdges().getEdges());
+    commonEdges.retainAll(edges1);
+    return commonEdges;
+  };
+
+  /** The location of this Node */
+  Node.prototype.pt = null;
+
+  /** The collection of DirectedEdges that leave this Node */
+  Node.prototype.deStar = null;
+
+  /**
+   * Returns the location of this Node.
+   */
+  Node.prototype.getCoordinate = function() {
+    return this.pt;
+  };
+
+  /**
+   * Adds an outgoing DirectedEdge to this Node.
+   */
+  Node.prototype.addOutEdge = function(de) {
+    this.deStar.add(de);
+  };
+
+  /**
+   * Returns the collection of DirectedEdges that leave this Node.
+   */
+  Node.prototype.getOutEdges = function() {
+    return this.deStar;
+  };
+
+  /**
+   * Returns the number of edges around this Node.
+   */
+  Node.prototype.getDegree = function() {
+    return this.deStar.getDegree();
+  };
+
+  /**
+   * Returns the zero-based index of the given Edge, after sorting in ascending
+   * order by angle with the positive x-axis.
+   */
+  Node.prototype.getIndex = function(edge) {
+    return this.deStar.getIndex(edge);
+  };
+
+  /**
+   * Removes a {@link DirectedEdge} incident on this node. Does not change the
+   * state of the directed edge.
+   */
+  Node.prototype.remove = function(de) {
+    if (de === undefined) {
+      return this.remove2();
+    }
+
+    this.deStar.remove(de);
+  };
+
+  /**
+   * Removes this node from its containing graph.
+   */
+  Node.prototype.remove2 = function() {
+    this.pt = null;
+  };
+
+
+  /**
+   * Tests whether this node has been removed from its containing graph
+   *
+   * @return <code>true</code> if this node is removed.
+   */
+  Node.prototype.isRemoved = function() {
+    return this.pt == null;
+  };
+
+  jsts.planargraph.Node = Node;
+
+})();

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

@@ -0,0 +1,76 @@
+/* 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/planargraph/NodeMap.java
+ * Revision: 6
+ */
+
+/**
+ * @requires jsts/geom/Coordinate.js
+ * @requires jsts/planargraph/Node.js
+ */
+
+(function() {
+
+  /**
+   * A map of {@link Node}s, indexed by the coordinate of the node.
+   *
+   * Constructs a NodeMap without any Nodes.
+   */
+  var NodeMap = function() {
+    this.nodeMap = new javascript.util.TreeMap();
+  };
+
+
+  NodeMap.prototype.nodeMap = null;
+
+
+  /**
+   * Adds a node to the map, replacing any that is already at that location.
+   *
+   * @return the added node.
+   */
+  NodeMap.prototype.add = function(n) {
+    this.nodeMap.put(n.getCoordinate(), n);
+    return n;
+  };
+
+  /**
+   * Removes the Node at the given location, and returns it (or null if no Node
+   * was there).
+   */
+  NodeMap.prototype.remove = function(pt) {
+    return this.nodeMap.remove(pt);
+  };
+
+  /**
+   * Returns the Node at the given location, or null if no Node was there.
+   */
+  NodeMap.prototype.find = function(coord) {
+    return this.nodeMap.get(coord);
+  };
+
+  /**
+   * Returns an Iterator over the Nodes in this NodeMap, sorted in ascending
+   * order by angle with the positive x-axis.
+   */
+  NodeMap.prototype.iterator = function() {
+    return this.nodeMap.values().iterator();
+  };
+
+  /**
+   * Returns the Nodes in this NodeMap, sorted in ascending order by angle with
+   * the positive x-axis.
+   */
+  NodeMap.prototype.values = function() {
+    return this.nodeMap.values();
+  };
+
+  jsts.planargraph.NodeMap = NodeMap;
+
+})();