jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/operation/IsSimpleOp.js

@@ -0,0 +1,293 @@
+/* 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.
+ */
+
+/**
+ * Tests whether a <code>Geometry</code> is simple.
+ * In general, the SFS specification of simplicity
+ * follows the rule:
+ * <ul>
+ *  <li>A Geometry is simple if and only if the only self-intersections are at
+ *  boundary points.</li>
+ * </ul>
+ * This definition relies on the definition of boundary points.
+ * The SFS uses the Mod-2 rule to determine which points are on the boundary of
+ * lineal geometries, but this class supports
+ * using other {@link BoundaryNodeRule}s as well.
+ * <p>
+ * Simplicity is defined for each {@link Geometry} subclass as follows:
+ * <ul>
+ * <li>Valid polygonal geometries are simple by definition, so
+ * <code>isSimple</code> trivially returns true.
+ * (Hint: in order to check if a polygonal geometry has self-intersections,
+ * use {@link Geometry#isValid}).
+ * <li>Linear geometries are simple iff they do not self-intersect at points
+ * other than boundary points.
+ * (Using the Mod-2 rule, this means that closed linestrings
+ * cannot be touched at their endpoints, since these are
+ * interior points, not boundary points).
+ * <li>Zero-dimensional geometries (points) are simple iff they have no
+ * repeated points.
+ * <li>Empty <code>Geometry</code>s are always simple
+ * </ul>
+ *
+ * @see BoundaryNodeRule
+ */
+
+
+
+/**
+ * Creates a simplicity checker using the default SFS Mod-2 Boundary Node Rule
+ *
+ * @param {Geometry}
+ *          geom the geometry to test.
+ * @constructor
+ */
+jsts.operation.IsSimpleOp = function(geom) {
+  this.geom = geom;
+};
+
+
+/**
+ * @type {jsts.geom.Geometry}
+ */
+jsts.operation.IsSimpleOp.prototype.geom = null;
+
+
+/**
+ * @type {boolean}
+ */
+jsts.operation.IsSimpleOp.prototype.isClosedEndpointsInInterior = true;
+
+
+/**
+ * @type {jsts.geom.Coordinate}
+ */
+jsts.operation.IsSimpleOp.prototype.nonSimpleLocation = null;
+
+
+/**
+ * Creates a simplicity checker using the default SFS Mod-2 Boundary Node Rule
+ *
+ * @param {Geometry}
+ *          geom the geometry to test.
+ */
+jsts.operation.IsSimpleOp.prototype.IsSimpleOp = function(geom) {
+  this.geom = geom;
+};
+
+
+/**
+ * Tests whether the geometry is simple.
+ *
+ * @return {boolean} true if the geometry is simple.
+ */
+jsts.operation.IsSimpleOp.prototype.isSimple = function() {
+  this.nonSimpleLocation = null;
+  if (this.geom instanceof jsts.geom.LineString) {
+    return this.isSimpleLinearGeometry(this.geom);
+  }
+  if (this.geom instanceof jsts.geom.MultiLineString) {
+    return this.isSimpleLinearGeometry(this.geom);
+  }
+  if (this.geom instanceof jsts.geom.MultiPoint) {
+    return this.isSimpleMultiPoint(this.geom);
+  }
+  // all other geometry types are simple by definition
+  return true;
+};
+
+
+/**
+ * @param {MultiPoint}
+ *          mp
+ * @return {boolean} true if the geometry is simple.
+ * @private
+ */
+jsts.operation.IsSimpleOp.prototype.isSimpleMultiPoint = function(mp) {
+  if (mp.isEmpty())
+    return true;
+  var points = [];
+  for (var i = 0; i < mp.getNumGeometries(); i++) {
+    var pt = mp.getGeometryN(i);
+    var p = pt.getCoordinate();
+    for (var j = 0; j < points.length; j++) {
+      var point = points[j];
+      if (p.equals2D(point)) {
+        this.nonSimpleLocation = p;
+        return false;
+      }
+    }
+    points.push(p);
+  }
+  return true;
+};
+
+
+/**
+ * @param {Geometry}
+ *          geom input geometry.
+ * @return {boolean} true if the geometry is simple.
+ * @private
+ */
+jsts.operation.IsSimpleOp.prototype.isSimpleLinearGeometry = function(geom) {
+  if (geom.isEmpty())
+    return true;
+  var graph = new jsts.geomgraph.GeometryGraph(0, geom);
+  var li = new jsts.algorithm.RobustLineIntersector();
+  var si = graph.computeSelfNodes(li, true);
+  // if no self-intersection, must be simple
+  if (!si.hasIntersection())
+    return true;
+  if (si.hasProperIntersection()) {
+    this.nonSimpleLocation = si.getProperIntersectionPoint();
+    return false;
+  }
+  if (this.hasNonEndpointIntersection(graph))
+    return false;
+  if (this.isClosedEndpointsInInterior) {
+    if (this.hasClosedEndpointIntersection(graph))
+      return false;
+  }
+  return true;
+};
+
+
+/**
+ * For all edges, check if there are any intersections which are NOT at an
+ * endpoint. The Geometry is not simple if there are intersections not at
+ * endpoints.
+ *
+ * @param {GeometryGraph}
+ *          graph
+ * @return {boolean}
+ * @private
+ */
+jsts.operation.IsSimpleOp.prototype.hasNonEndpointIntersection = function(graph) {
+  for (var i = graph.getEdgeIterator(); i.hasNext(); ) {
+    var e = i.next();
+    var maxSegmentIndex = e.getMaximumSegmentIndex();
+    for (var eiIt = e.getEdgeIntersectionList().iterator(); eiIt.hasNext(); ) {
+      var ei = eiIt.next();
+      if (! ei.isEndPoint(maxSegmentIndex)) {
+        this.nonSimpleLocation = ei.getCoordinate();
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+
+/**
+ * Tests that no edge intersection is the endpoint of a closed line. This
+ * ensures that closed lines are not touched at their endpoint, which is an
+ * interior point according to the Mod-2 rule To check this we compute the
+ * degree of each endpoint. The degree of endpoints of closed lines must be
+ * exactly 2.
+ *
+ * @param {GeometryGraph}
+ *          graph
+ * @return {boolean}
+ * @private
+ */
+jsts.operation.IsSimpleOp.prototype.hasClosedEndpointIntersection = function(
+    graph) {
+  var endPoints = new javascript.util.TreeMap();
+  for (var i = graph.getEdgeIterator(); i.hasNext(); ) {
+    var e = i.next();
+    var maxSegmentIndex = e.getMaximumSegmentIndex();
+    var isClosed = e.isClosed();
+    var p0 = e.getCoordinate(0);
+    this.addEndpoint(endPoints, p0, isClosed);
+    var p1 = e.getCoordinate(e.getNumPoints() - 1);
+    this.addEndpoint(endPoints, p1, isClosed);
+  }
+
+  for (var i = endPoints.values().iterator(); i.hasNext(); ) {
+    var eiInfo = i.next();
+    if (eiInfo.isClosed && eiInfo.degree != 2) {
+      this.nonSimpleLocation = eiInfo.getCoordinate();
+      return true;
+    }
+  }
+  return false;
+};
+
+
+
+/**
+ * private
+ *
+ * @constructor
+ */
+jsts.operation.IsSimpleOp.EndpointInfo = function(pt) {
+
+  this.pt = pt;
+  this.isClosed = false;
+  this.degree = 0;
+};
+
+
+/**
+ * @type {Coordinate}
+ * @private
+ */
+jsts.operation.IsSimpleOp.EndpointInfo.prototype.pt = null;
+
+
+/**
+ * @type {boolean}
+ * @private
+ */
+jsts.operation.IsSimpleOp.EndpointInfo.prototype.isClosed = null;
+
+
+/**
+ * @type {int}
+ * @private
+ */
+jsts.operation.IsSimpleOp.EndpointInfo.prototype.degree = null;
+
+
+/**
+ * @return {Coordinate}
+ */
+jsts.operation.IsSimpleOp.EndpointInfo.prototype.getCoordinate = function() {
+  return this.pt;
+};
+
+
+/**
+ * @param {boolean}
+ *          isClosed
+ */
+jsts.operation.IsSimpleOp.EndpointInfo.prototype.addEndpoint = function(
+    isClosed) {
+  this.degree++;
+  this.isClosed = this.isClosed || isClosed;
+};
+
+
+/**
+ * Add an endpoint to the map, creating an entry for it if none exists
+ *
+ * @param {javascript.util.Map}
+ *          endPoints
+ * @param {jsts.geom.Coordinate}
+ *          p
+ * @param {boolean}
+ *          isClosed
+ * @private
+ */
+jsts.operation.IsSimpleOp.prototype.addEndpoint = function(endPoints, p,
+    isClosed) {
+  var eiInfo = endPoints.get(p);
+  if (eiInfo === null) {
+    eiInfo = new jsts.operation.IsSimpleOp.EndpointInfo(p);
+    endPoints.put(p, eiInfo);
+  }
+  eiInfo.addEndpoint(isClosed);
+};

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

@@ -0,0 +1,317 @@
+/* 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.
+ */
+
+
+
+/**
+ * Builds the buffer geometry for a given input geometry and precision model.
+ * Allows setting the level of approximation for circular arcs, and the
+ * precision model in which to carry out the computation.
+ * <p>
+ * When computing buffers in floating point double-precision it can happen that
+ * the process of iterated noding can fail to converge (terminate). In this case
+ * a TopologyException will be thrown. Retrying the computation in a fixed
+ * precision can produce more robust results.
+ *
+ * @param {jsts.operation.buffer.BufferBuilder.BufferParameters}
+ *          bufParams
+ * @constructor
+ */
+jsts.operation.buffer.BufferBuilder = function(bufParams) {
+  this.bufParams = bufParams;
+
+  this.edgeList = new jsts.geomgraph.EdgeList();
+};
+
+
+/**
+ * Compute the change in depth as an edge is crossed from R to L
+ *
+ * @param {Label}
+ *          label
+ * @return {Number}
+ */
+jsts.operation.buffer.BufferBuilder.depthDelta = function(label) {
+  var lLoc = label.getLocation(0, jsts.geomgraph.Position.LEFT);
+  var rLoc = label.getLocation(0, jsts.geomgraph.Position.RIGHT);
+  if (lLoc === jsts.geom.Location.INTERIOR &&
+      rLoc === jsts.geom.Location.EXTERIOR)
+    return 1;
+  else if (lLoc === jsts.geom.Location.EXTERIOR &&
+      rLoc === jsts.geom.Location.INTERIOR)
+    return -1;
+  return 0;
+};
+
+
+/**
+ * @type {BufferParameters}
+ * @private
+ */
+jsts.operation.buffer.BufferBuilder.prototype.bufParams = null;
+
+
+/**
+ * @type {PrecisionModel}
+ * @private
+ */
+jsts.operation.buffer.BufferBuilder.prototype.workingPrecisionModel = null;
+
+
+/**
+ * @type {Noder}
+ * @private
+ */
+jsts.operation.buffer.BufferBuilder.prototype.workingNoder = null;
+
+
+/**
+ * @type {GeometryFactory}
+ * @private
+ */
+jsts.operation.buffer.BufferBuilder.prototype.geomFact = null;
+
+
+/**
+ * @type {PlanarGraph}
+ * @private
+ */
+jsts.operation.buffer.BufferBuilder.prototype.graph = null;
+
+
+/**
+ * @type {EdgeList}
+ * @private
+ */
+jsts.operation.buffer.BufferBuilder.prototype.edgeList = null;
+
+
+/**
+ * Sets the precision model to use during the curve computation and noding, if
+ * it is different to the precision model of the Geometry. If the precision
+ * model is less than the precision of the Geometry precision model, the
+ * Geometry must have previously been rounded to that precision.
+ *
+ * @param pm
+ *          the precision model to use.
+ */
+jsts.operation.buffer.BufferBuilder.prototype.setWorkingPrecisionModel = function(
+    pm) {
+  this.workingPrecisionModel = pm;
+};
+
+
+/**
+ * Sets the {@link Noder} to use during noding. This allows choosing fast but
+ * non-robust noding, or slower but robust noding.
+ *
+ * @param noder
+ *          the noder to use.
+ */
+jsts.operation.buffer.BufferBuilder.prototype.setNoder = function(noder) {
+  this.workingNoder = noder;
+};
+
+jsts.operation.buffer.BufferBuilder.prototype.buffer = function(g, distance) {
+  var precisionModel = this.workingPrecisionModel;
+  if (precisionModel === null)
+    precisionModel = g.getPrecisionModel();
+
+  // factory must be the same as the one used by the input
+  this.geomFact = g.getFactory();
+
+  var curveBuilder = new jsts.operation.buffer.OffsetCurveBuilder(
+      precisionModel, this.bufParams);
+
+  var curveSetBuilder = new jsts.operation.buffer.OffsetCurveSetBuilder(g,
+      distance, curveBuilder);
+
+  var bufferSegStrList = curveSetBuilder.getCurves();
+
+  // short-circuit test
+  if (bufferSegStrList.size() <= 0) {
+    return this.createEmptyResultGeometry();
+  }
+
+  this.computeNodedEdges(bufferSegStrList, precisionModel);
+  this.graph = new jsts.geomgraph.PlanarGraph(
+      new jsts.operation.overlay.OverlayNodeFactory());
+  this.graph.addEdges(this.edgeList.getEdges());
+
+  var subgraphList = this.createSubgraphs(this.graph);
+  var polyBuilder = new jsts.operation.overlay.PolygonBuilder(this.geomFact);
+  this.buildSubgraphs(subgraphList, polyBuilder);
+  var resultPolyList = polyBuilder.getPolygons();
+
+  // just in case...
+  if (resultPolyList.size() <= 0) {
+    return this.createEmptyResultGeometry();
+  }
+
+  var resultGeom = this.geomFact.buildGeometry(resultPolyList);
+  return resultGeom;
+};
+
+
+/**
+ * @private
+ */
+jsts.operation.buffer.BufferBuilder.prototype.getNoder = function(
+    precisionModel) {
+  if (this.workingNoder !== null)
+    return this.workingNoder;
+
+  // otherwise use a fast (but non-robust) noder
+  var noder = new jsts.noding.MCIndexNoder();
+  var li = new jsts.algorithm.RobustLineIntersector();
+  li.setPrecisionModel(precisionModel);
+  noder.setSegmentIntersector(new jsts.noding.IntersectionAdder(li));
+  return noder;
+};
+
+
+/**
+ * @private
+ */
+jsts.operation.buffer.BufferBuilder.prototype.computeNodedEdges = function(
+    bufferSegStrList, precisionModel) {
+  var noder = this.getNoder(precisionModel);
+  noder.computeNodes(bufferSegStrList);
+  var nodedSegStrings = noder.getNodedSubstrings();
+
+  for (var i = nodedSegStrings.iterator(); i.hasNext();) {
+    var segStr = i.next();
+    var oldLabel = segStr.getData();
+    var edge = new jsts.geomgraph.Edge(segStr.getCoordinates(),
+        new jsts.geomgraph.Label(oldLabel));
+    this.insertUniqueEdge(edge);
+  }
+};
+
+
+/**
+ * Inserted edges are checked to see if an identical edge already exists. If so,
+ * the edge is not inserted, but its label is merged with the existing edge.
+ *
+ * @protected
+ */
+jsts.operation.buffer.BufferBuilder.prototype.insertUniqueEdge = function(e) {
+  var existingEdge = this.edgeList.findEqualEdge(e);
+
+  // If an identical edge already exists, simply update its label
+  if (existingEdge != null) {
+    var existingLabel = existingEdge.getLabel();
+
+    var labelToMerge = e.getLabel();
+    // check if new edge is in reverse direction to existing edge
+    // if so, must flip the label before merging it
+    if (!existingEdge.isPointwiseEqual(e)) {
+      labelToMerge = new jsts.geomgraph.Label(e.getLabel());
+      labelToMerge.flip();
+    }
+    existingLabel.merge(labelToMerge);
+
+    // compute new depth delta of sum of edges
+    var mergeDelta = jsts.operation.buffer.BufferBuilder
+        .depthDelta(labelToMerge);
+    var existingDelta = existingEdge.getDepthDelta();
+    var newDelta = existingDelta + mergeDelta;
+    existingEdge.setDepthDelta(newDelta);
+  } else {
+    // no matching existing edge was found
+    // add this new edge to the list of edges in this graph
+    this.edgeList.add(e);
+    e.setDepthDelta(jsts.operation.buffer.BufferBuilder
+        .depthDelta(e.getLabel()));
+  }
+};
+
+
+/**
+ * @param {PlanarGraph}
+ *          graph
+ * @private
+ */
+jsts.operation.buffer.BufferBuilder.prototype.createSubgraphs = function(graph) {
+  var subgraphList = [];
+  for (var i = graph.getNodes().iterator(); i.hasNext();) {
+    var node = i.next();
+    if (!node.isVisited()) {
+      var subgraph = new jsts.operation.buffer.BufferSubgraph();
+      subgraph.create(node);
+      subgraphList.push(subgraph);
+    }
+  }
+  /**
+   * Sort the subgraphs in descending order of their rightmost coordinate. This
+   * ensures that when the Polygons for the subgraphs are built, subgraphs for
+   * shells will have been built before the subgraphs for any holes they
+   * contain.
+   */
+
+  var compare = function(a, b) {
+    return a.compareTo(b);
+  };
+  subgraphList.sort(compare);
+  subgraphList.reverse();
+  return subgraphList;
+};
+
+
+/**
+ * Completes the building of the input subgraphs by depth-labelling them, and
+ * adds them to the PolygonBuilder. The subgraph list must be sorted in
+ * rightmost-coordinate order.
+ *
+ * @param {Array}
+ *          subgraphList the subgraphs to build.
+ * @param {PolygonBuilder}
+ *          polyBuilder the PolygonBuilder which will build the final polygons.
+ * @private
+ */
+jsts.operation.buffer.BufferBuilder.prototype.buildSubgraphs = function(
+    subgraphList, polyBuilder) {
+  var processedGraphs = [];
+  for (var i = 0; i < subgraphList.length; i++) {
+    var subgraph = subgraphList[i];
+    var p = subgraph.getRightmostCoordinate();
+    var locater = new jsts.operation.buffer.SubgraphDepthLocater(
+        processedGraphs);
+    var outsideDepth = locater.getDepth(p);
+    subgraph.computeDepth(outsideDepth);
+    subgraph.findResultEdges();
+    processedGraphs.push(subgraph);
+    polyBuilder.add(subgraph.getDirectedEdges(), subgraph.getNodes());
+  }
+};
+
+
+/**
+ * @private
+ */
+jsts.operation.buffer.BufferBuilder.convertSegStrings = function(it) {
+  var fact = new jsts.geom.GeometryFactory();
+  var lines = new javascript.util.ArrayList();
+  while (it.hasNext()) {
+    var ss = it.next();
+    var line = fact.createLineString(ss.getCoordinates());
+    lines.add(line);
+  }
+  return fact.buildGeometry(lines);
+};
+
+
+/**
+ * Gets the standard result for an empty buffer. Since buffer always returns a
+ * polygonal result, this is chosen to be an empty polygon.
+ *
+ * @return the empty result geometry.
+ * @private
+ */
+jsts.operation.buffer.BufferBuilder.prototype.createEmptyResultGeometry = function() {
+  var emptyGeom = this.geomFact.createPolygon(null, null);
+  return emptyGeom;
+};