jsts-rails 0.1.0 → 0.2.0

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

@@ -0,0 +1,246 @@
+/* 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/PlanarGraph.java
+ * Revision: 107
+ */
+
+/**
+ * @requires jsts/planargraph/NodeMap.js
+ */
+
+(function() {
+
+  var ArrayList = javascript.util.ArrayList;
+
+
+  /**
+   * Represents a directed graph which is embeddable in a planar surface.
+   * <p>
+   * This class and the other classes in this package serve as a framework for
+   * building planar graphs for specific algorithms. This class must be
+   * subclassed to expose appropriate methods to construct the graph. This
+   * allows controlling the types of graph components ({@link DirectedEdge}s,
+   * {@link Edge}s and {@link Node}s) which can be added to the graph. An
+   * application which uses the graph framework will almost always provide
+   * subclasses for one or more graph components, which hold
+   * application-specific data and graph algorithms.
+   *
+   * Constructs a empty graph.
+   */
+  var PlanarGraph = function() {
+    this.edges = new javascript.util.HashSet();
+    this.dirEdges = new javascript.util.HashSet();
+    this.nodeMap = new jsts.planargraph.NodeMap();
+  };
+
+
+  PlanarGraph.prototype.edges = null;
+  PlanarGraph.prototype.dirEdges = null;
+  PlanarGraph.prototype.nodeMap = null;
+
+
+  /**
+   * Returns the {@link Node} at the given location, or null if no {@link Node}
+   * was there.
+   *
+   * @param pt
+   *          the location to query.
+   * @return the node found.
+   * @return <code>null</code> if this graph contains no node at the location.
+   */
+  PlanarGraph.prototype.findNode = function(pt) {
+    return this.nodeMap.find(pt);
+  };
+
+  /**
+   * Adds a node to the map, replacing any that is already at that location.
+   * Only subclasses can add Nodes, to ensure Nodes are of the right type.
+   *
+   * @param node
+   *          the node to add.
+   */
+  PlanarGraph.prototype.add = function(node) {
+    if (node instanceof jsts.planargraph.Edge) {
+      return this.add2(node);
+    } else if (node instanceof jsts.planargraph.DirectedEdge) {
+      return this.add3(node);
+    }
+
+    this.nodeMap.add(node);
+  };
+
+  /**
+   * Adds the Edge and its DirectedEdges with this PlanarGraph. Assumes that the
+   * Edge has already been created with its associated DirectEdges. Only
+   * subclasses can add Edges, to ensure the edges added are of the right class.
+   */
+  PlanarGraph.prototype.add2 = function(edge) {
+    this.edges.add(edge);
+    this.add(edge.getDirEdge(0));
+    this.add(edge.getDirEdge(1));
+  };
+
+  /**
+   * Adds the Edge to this PlanarGraph; only subclasses can add DirectedEdges,
+   * to ensure the edges added are of the right class.
+   */
+  PlanarGraph.prototype.add3 = function(dirEdge) {
+    this.dirEdges.add(dirEdge);
+  };
+
+  /**
+   * Returns an Iterator over the Nodes in this PlanarGraph.
+   */
+  PlanarGraph.prototype.nodeIterator = function() {
+    return this.nodeMap.iterator();
+  };
+
+  /**
+   * Returns the Nodes in this PlanarGraph.
+   */
+
+  /**
+   * Tests whether this graph contains the given {@link Edge}
+   *
+   * @param e
+   *          the edge to query.
+   * @return <code>true</code> if the graph contains the edge.
+   */
+  PlanarGraph.prototype.contains = function(e) {
+    if (e instanceof jsts.planargraph.DirectedEdge) {
+      return this.contains2(e);
+    }
+
+    return this.edges.contains(e);
+  };
+
+  /**
+   * Tests whether this graph contains the given {@link DirectedEdge}
+   *
+   * @param de
+   *          the directed edge to query.
+   * @return <code>true</code> if the graph contains the directed edge.
+   */
+  PlanarGraph.prototype.contains2 = function(de) {
+    return this.dirEdges.contains(de);
+  };
+
+  PlanarGraph.prototype.getNodes = function() {
+    return this.nodeMap.values();
+  };
+
+  /**
+   * Returns an Iterator over the DirectedEdges in this PlanarGraph, in the
+   * order in which they were added.
+   *
+   * @see #add(Edge)
+   * @see #add(DirectedEdge)
+   */
+  PlanarGraph.prototype.dirEdgeIterator = function() {
+    return this.dirEdges.iterator();
+  };
+  /**
+   * Returns an Iterator over the Edges in this PlanarGraph, in the order in
+   * which they were added.
+   *
+   * @see #add(Edge)
+   */
+  PlanarGraph.prototype.edgeIterator = function() {
+    return this.edges.iterator();
+  };
+
+  /**
+   * Returns the Edges that have been added to this PlanarGraph
+   *
+   * @see #add(Edge)
+   */
+  PlanarGraph.prototype.getEdges = function() {
+    return this.edges;
+  };
+
+  /**
+   * Removes an {@link Edge} and its associated {@link DirectedEdge}s from
+   * their from-Nodes and from the graph. Note: This method does not remove the
+   * {@link Node}s associated with the {@link Edge}, even if the removal of
+   * the {@link Edge} reduces the degree of a {@link Node} to zero.
+   */
+  PlanarGraph.prototype.remove = function(edge) {
+    if (edge instanceof jsts.planargraph.DirectedEdge) {
+      return this.remove2(edge);
+    }
+
+    this.remove(edge.getDirEdge(0));
+    this.remove(edge.getDirEdge(1));
+    this.edges.remove(edge);
+    this.edge.remove();
+  };
+
+  /**
+   * Removes a {@link DirectedEdge} from its from-{@link Node} and from this
+   * graph. This method does not remove the {@link Node}s associated with the
+   * DirectedEdge, even if the removal of the DirectedEdge reduces the degree of
+   * a Node to zero.
+   */
+  PlanarGraph.prototype.remove2 = function(de) {
+    if (de instanceof jsts.planargraph.Node) {
+      return this.remove3(de);
+    }
+
+    var sym = de.getSym();
+    if (sym != null)
+      sym.setSym(null);
+
+    de.getFromNode().remove(de);
+    de.remove();
+    this.dirEdges.remove(de);
+  };
+
+  /**
+   * Removes a node from the graph, along with any associated DirectedEdges and
+   * Edges.
+   */
+  PlanarGraph.prototype.remove3 = function(node) {
+    // unhook all directed edges
+    var outEdges = node.getOutEdges().getEdges();
+    for (var i = outEdges.iterator(); i.hasNext();) {
+      var de = i.next();
+      var sym = de.getSym();
+      // remove the diredge that points to this node
+      if (sym != null)
+        this.remove(sym);
+      // remove this diredge from the graph collection
+      this.dirEdges.remove(de);
+
+      var edge = de.getEdge();
+      if (edge != null) {
+        this.edges.remove(edge);
+      }
+
+    }
+    // remove the node from the graph
+    this.nodeMap.remove(node.getCoordinate());
+    node.remove();
+  };
+
+  /**
+   * Returns all Nodes with the given number of Edges around it.
+   */
+  PlanarGraph.prototype.findNodesOfDegree = function(degree) {
+    var nodesFound = new ArrayList();
+    for (var i = this.nodeIterator(); i.hasNext();) {
+      var node = i.next();
+      if (node.getDegree() == degree)
+        nodesFound.add(node);
+    }
+    return nodesFound;
+  };
+
+  jsts.planargraph.PlanarGraph = PlanarGraph;
+
+})();

data/vendor/assets/javascripts/jsts/simplify/LineSegmentIndex.js

@@ -0,0 +1,101 @@
+/* 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.
+ */
+
+
+/**
+ * An spatial index on a set of {@link LineSegment}s. Supports adding and
+ * removing items.
+ *
+ * @author Martin Davis
+ */
+jsts.simplify.LineSegmentIndex = function() {
+  this.index = new jsts.index.quadtree.Quadtree();
+};
+
+/**
+ * @private
+ */
+jsts.simplify.LineSegmentIndex.prototype.index = null;
+
+/**
+ * @param {TaggedLineString}
+ *          line
+ */
+jsts.simplify.LineSegmentIndex.prototype.add = function(line) {
+  if (line instanceof jsts.geom.LineSegment) {
+    this.add2(line);
+    return;
+  }
+
+  var segs = line.getSegments();
+  for (var i = 0; i < segs.length; i++) {
+    var seg = segs[i];
+    this.add2(seg);
+  }
+};
+
+/**
+ * @param {LineSegment}
+ *          seg
+ */
+jsts.simplify.LineSegmentIndex.prototype.add2 = function(seg) {
+  this.index.insert(new jsts.geom.Envelope(seg.p0, seg.p1), seg);
+};
+/**
+ * @param {LineSegment}
+ *          seg
+ */
+jsts.simplify.LineSegmentIndex.prototype.remove = function(seg) {
+  this.index.remove(new jsts.geom.Envelope(seg.p0, seg.p1), seg);
+};
+
+/**
+ * @param {LineSegment}
+ *          querySeg
+ * @return {Array}
+ */
+jsts.simplify.LineSegmentIndex.prototype.query = function(querySeg) {
+  var env = new jsts.geom.Envelope(querySeg.p0, querySeg.p1);
+
+  var visitor = new jsts.simplify.LineSegmentIndex.LineSegmentVisitor(querySeg);
+  this.index.query(env, visitor);
+  var itemsFound = visitor.getItems();
+
+  return itemsFound;
+};
+
+
+/**
+ * @requires jsts/index/ItemVisitor.js
+ */
+/**
+ * ItemVisitor subclass to reduce volume of query results.
+ *
+ * @implements {jsts.index.ItemVisitor}
+ */
+jsts.simplify.LineSegmentIndex.LineSegmentVisitor = function(querySeg) {
+  this.items = [];
+
+  this.querySeg = querySeg;
+};
+
+
+jsts.simplify.LineSegmentIndex.LineSegmentVisitor.prototype = new jsts.index.ItemVisitor();
+
+// MD - only seems to make about a 10% difference in overall time.
+jsts.simplify.LineSegmentIndex.LineSegmentVisitor.prototype.querySeg = null;
+jsts.simplify.LineSegmentIndex.LineSegmentVisitor.prototype.items = null;
+
+jsts.simplify.LineSegmentIndex.LineSegmentVisitor.prototype.visitItem = function(
+    item) {
+  var seg = item;
+  if (jsts.geom.Envelope.intersects(seg.p0, seg.p1, this.querySeg.p0, this.querySeg.p1))
+    this.items.push(item);
+};
+
+jsts.simplify.LineSegmentIndex.LineSegmentVisitor.prototype.getItems = function() {
+  return this.items;
+};

data/vendor/assets/javascripts/jsts/triangulate/DelaunayTriangulationBuilder.js

@@ -0,0 +1,224 @@
+/* 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 utility class which creates Delaunay Trianglulations from collections of
+ * points and extract the resulting triangulation edges or triangles as
+ * geometries.
+ *
+ * Initializes a new DelaunayTriangulationBuilder
+ *
+ * @constructor
+ */
+jsts.triangulate.DelaunayTriangulationBuilder = function() {
+
+  this.siteCoords = null;
+  this.tolerance = 0.0;
+  this.subdiv = null;
+};
+
+
+/**
+ * Extracts the unique {@link Coordinate}s from the given {@link Geometry}.
+ *
+ * @param {jsts.geom.Geometry}
+ *          geom the geometry to extract from.
+ * @return {Array{jsts.geom.Coordinate}} An array of the unique Coordinates
+ */
+jsts.triangulate.DelaunayTriangulationBuilder.extractUniqueCoordinates = function(
+    geom) {
+  if (geom === undefined || geom === null) {
+    return new jsts.geom.CoordinateList([], false).toArray();
+  }
+
+  var coords = geom.getCoordinates();
+  return jsts.triangulate.DelaunayTriangulationBuilder.unique(coords);
+};
+
+
+/**
+ * Removes any duplicates in the passed array.
+ *
+ * @param {Array{jsts.geom.Coordinate}}
+ *          coords The input coordinates
+ * @return {Array{jsts.geom.Coordinate}} An array stripped out of any duplicates
+ */
+jsts.triangulate.DelaunayTriangulationBuilder.unique = function(coords) {
+  // Sort the coordinates by their compareTo-function
+  coords.sort(function(a, b) {
+    return a.compareTo(b);
+  });
+
+  var coordList = new jsts.geom.CoordinateList(coords, false);
+  return coordList.toArray();
+};
+
+
+/**
+ * Converts an array of coordinates to an array of vertexes
+ *
+ * @param {Array{jsts.geom.Coordinate}}
+ *          coords the input coordinates
+ * @return {Array{jsts.triangulate.quadedge.Vertex}} The created vertexes
+ */
+jsts.triangulate.DelaunayTriangulationBuilder.toVertices = function(coords) {
+  var verts = new Array(coords.length), i = 0, il = coords.length, coord;
+
+  for (i; i < il; i++) {
+    coord = coords[i];
+    verts[i] = new jsts.triangulate.quadedge.Vertex(coord);
+  }
+
+  return verts;
+};
+
+
+/**
+ * Computes the {jsts.geom.Envelope} of an array of {jsts.geom.Coordinate}s
+ *
+ * @param {Array{jsts.geom.Coordinate}}
+ *          coords the input coordinates
+ * @return {jsts.geom.Envelope} The created envelope.
+ *
+ */
+jsts.triangulate.DelaunayTriangulationBuilder.envelope = function(coords) {
+  var env = new jsts.geom.Envelope(), i = 0, il = coords.length;
+
+  for (i; i < il; i++) {
+    env.expandToInclude(coords[i]);
+  }
+
+  return env;
+};
+
+
+/**
+ * Sets the sites which will be triangulated. Calls the correct setSites*
+ * function after argument-checking
+ */
+jsts.triangulate.DelaunayTriangulationBuilder.prototype.setSites = function() {
+  var arg = arguments[0];
+
+  if (arg instanceof jsts.geom.Geometry ||
+      arg instanceof jsts.geom.Coordinate || arg instanceof jsts.geom.Point ||
+      arg instanceof jsts.geom.MultiPoint ||
+      arg instanceof jsts.geom.LineString ||
+      arg instanceof jsts.geom.MultiLineString ||
+      arg instanceof jsts.geom.LinearRing || arg instanceof jsts.geom.Polygon ||
+      arg instanceof jsts.geom.MultiPolygon) {
+    this.setSitesFromGeometry(arg);
+  } else {
+    this.setSitesFromCollection(arg);
+  }
+};
+
+
+/**
+ * Sets the sites (point or vertices) which will be triangulated. All vertices
+ * of the given geometry will be used as sites.
+ *
+ * @param {jsts.geom.Geometry}
+ *          geom the geometry from which the sites will be extracted.
+ */
+jsts.triangulate.DelaunayTriangulationBuilder.prototype.setSitesFromGeometry = function(
+    geom) {
+  // remove any duplicate points (they will cause the triangulation to fail)
+  this.siteCoords = jsts.triangulate.DelaunayTriangulationBuilder
+      .extractUniqueCoordinates(geom);
+};
+
+
+/**
+ * Sets the sites (point or vertices) which will be triangulated from a
+ * collection of {@link Coordinate}s.
+ *
+ * @param {Array{Coordinates}}
+ *          coords a collection of Coordinates.
+ */
+jsts.triangulate.DelaunayTriangulationBuilder.prototype.setSitesFromCollection = function(
+    coords) {
+  // remove any duplicate points (they will cause the triangulation to fail)
+  this.siteCoords = jsts.triangulate.DelaunayTriangulationBuilder.unique(coords);
+};
+
+
+/**
+ * Sets the snapping tolerance which will be used to improved the robustness of
+ * the triangulation computation. A tolerance of 0.0 specifies that no snapping
+ * will take place.
+ *
+ * @param {Number}
+ *          tolerance the tolerance distance to use.
+ */
+jsts.triangulate.DelaunayTriangulationBuilder.prototype.setTolerance = function(
+    tolerance) {
+  this.tolerance = tolerance;
+};
+
+
+/**
+ * Creates the Delaunay-triangulation.
+ *
+ */
+jsts.triangulate.DelaunayTriangulationBuilder.prototype.create = function() {
+  if (this.subdiv === null) {
+    var siteEnv, vertices, triangulator;
+
+    siteEnv = jsts.triangulate.DelaunayTriangulationBuilder
+        .envelope(this.siteCoords);
+    vertices = jsts.triangulate.DelaunayTriangulationBuilder
+        .toVertices(this.siteCoords);
+    this.subdiv = new jsts.triangulate.quadedge.QuadEdgeSubdivision(siteEnv,
+        this.tolerance);
+    triangulator = new jsts.triangulate.IncrementalDelaunayTriangulator(
+        this.subdiv);
+    triangulator.insertSites(vertices);
+  }
+};
+
+
+/**
+ * Gets the {jsts.triangulate.quadedge.QuadEdgeSubdivision} which models the
+ * computed triangulation.
+ *
+ * @return {jsts.triangulate.quadedge.QuadEdgeSubdivision} containing the
+ *         triangulation.
+ */
+jsts.triangulate.DelaunayTriangulationBuilder.prototype.getSubdivision = function() {
+  this.create();
+  return this.subdiv;
+};
+
+
+/**
+ * Gets the edges of the computed triangulation as a {@link MultiLineString}.
+ *
+ * @param {jsts.geom.GeometryFactory}
+ *          geomFact the geometry factory to use to create the output.
+ * @return {jsts.geom.Geometry} the edges of the triangulation.
+ */
+jsts.triangulate.DelaunayTriangulationBuilder.prototype.getEdges = function(
+    geomFact) {
+  this.create();
+  return this.subdiv.getEdges(geomFact);
+};
+
+
+/**
+ * Gets the faces of the computed triangulation as a {@link GeometryCollection}
+ * of {@link Polygon}.
+ *
+ * @param {jsts.geom.GeometryFactory}
+ *          geomFact the geometry factory to use to create the output.
+ * @return {jsts.geom.Geometry} the faces of the triangulation.
+ */
+jsts.triangulate.DelaunayTriangulationBuilder.prototype.getTriangles = function(
+    geomFact) {
+  this.create();
+  return this.subdiv.getTriangles(geomFact);
+};