jsts-rails 0.1.0 → 0.2.0

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

@@ -0,0 +1,111 @@
+/* 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/util/Assert.js
+   */
+
+  var ArrayList = javascript.util.ArrayList;
+  var TreeMap = javascript.util.TreeMap;
+
+  /**
+   * A EdgeList is a list of Edges. It supports locating edges that are
+   * pointwise equals to a target edge.
+   *
+   * @constructor
+   */
+  jsts.geomgraph.EdgeList = function() {
+    this.edges = new ArrayList();
+    this.ocaMap = new TreeMap();
+  };
+
+
+  /**
+   * @type {javascript.util.ArrayList}
+   * @private
+   */
+  jsts.geomgraph.EdgeList.prototype.edges = null;
+
+
+  /**
+   * An index of the edges, for fast lookup.
+   *
+   * @type {javascript.util.HashMap}
+   * @private
+   */
+  jsts.geomgraph.EdgeList.prototype.ocaMap = null;
+
+
+  /**
+   * Insert an edge unless it is already in the list
+   */
+  jsts.geomgraph.EdgeList.prototype.add = function(e) {
+    this.edges.add(e);
+    var oca = new jsts.noding.OrientedCoordinateArray(e.getCoordinates());
+    this.ocaMap.put(oca, e);
+  };
+
+  jsts.geomgraph.EdgeList.prototype.addAll = function(edgeColl) {
+    for (var i = edgeColl.iterator(); i.hasNext();) {
+      this.add(i.next());
+    }
+  };
+
+
+  /**
+   * @return {javascript.util.List}
+   */
+  jsts.geomgraph.EdgeList.prototype.getEdges = function() {
+    return this.edges;
+  };
+
+
+  /**
+   * If there is an edge equal to e already in the list, return it. Otherwise
+   * return null.
+   *
+   * @param {Edge}
+   *          e
+   * @return {Edge} equal edge, if there is one already in the list null
+   *         otherwise.
+   */
+  jsts.geomgraph.EdgeList.prototype.findEqualEdge = function(e) {
+    var oca = new jsts.noding.OrientedCoordinateArray(e.getCoordinates());
+    // will return null if no edge matches
+    var matchEdge = this.ocaMap.get(oca);
+    return matchEdge;
+  };
+
+  jsts.geomgraph.EdgeList.prototype.getEdges = function() {
+    return this.edges;
+  };
+
+  jsts.geomgraph.EdgeList.prototype.iterator = function() {
+    return this.edges.iterator();
+  };
+
+  jsts.geomgraph.EdgeList.prototype.get = function(i) {
+    return this.edges.get(i);
+  };
+
+
+  /**
+   * If the edge e is already in the list, return its index.
+   *
+   * @return {Number} index, if e is already in the list -1 otherwise.
+   */
+  jsts.geomgraph.EdgeList.prototype.findEdgeIndex = function(e) {
+    for (var i = 0; i < this.edges.size(); i++) {
+      if (this.edges.get(i).equals(e))
+        return i;
+    }
+    return -1;
+  };
+
+})();

data/vendor/assets/javascripts/jsts/geomgraph/EdgeNodingValidator.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.
+ */
+
+(function() {
+
+  /**
+   * @requires jsts/noding/FastNodingValidator.js
+   * @requires jsts/noding/BasicSegmentString.js
+   */
+
+  var FastNodingValidator = jsts.noding.FastNodingValidator;
+  var BasicSegmentString = jsts.noding.BasicSegmentString;
+  var ArrayList = javascript.util.ArrayList;
+
+  /**
+   * Validates that a collection of {@link Edge}s is correctly noded. Throws an
+   * appropriate exception if an noding error is found.
+   *
+   * Creates a new validator for the given collection of {@link Edge}s.
+   *
+   * @param edges
+   *          a collection of Edges.
+   */
+  jsts.geomgraph.EdgeNodingValidator = function(edges) {
+    this.nv = new FastNodingValidator(jsts.geomgraph.EdgeNodingValidator
+        .toSegmentStrings(edges));
+  };
+
+  /**
+   * Checks whether the supplied {@link Edge}s are correctly noded. Throws a
+   * {@link TopologyException} if they are not.
+   *
+   * @param edges
+   *          a collection of Edges.
+   * @throws TopologyException
+   *           if the SegmentStrings are not correctly noded
+   *
+   */
+  jsts.geomgraph.EdgeNodingValidator.checkValid = function(edges) {
+    var validator = new jsts.geomgraph.EdgeNodingValidator(edges);
+    validator.checkValid();
+  };
+
+  jsts.geomgraph.EdgeNodingValidator.toSegmentStrings = function(edges) {
+    // convert Edges to SegmentStrings
+    var segStrings = new ArrayList();
+    for (var i = edges.iterator(); i.hasNext();) {
+      var e = i.next();
+      segStrings.add(new BasicSegmentString(e.getCoordinates(), e));
+    }
+    return segStrings;
+  };
+
+  /**
+   * @type {jsts.noding.FastNodingValidator}
+   * @private
+   */
+  jsts.geomgraph.EdgeNodingValidator.prototype.nv = null;
+
+
+  /**
+   * Checks whether the supplied edges are correctly noded. Throws an exception
+   * if they are not.
+   *
+   * @throws TopologyException
+   *           if the SegmentStrings are not correctly noded
+   *
+   */
+  jsts.geomgraph.EdgeNodingValidator.prototype.checkValid = function() {
+    this.nv.checkValid();
+  };
+
+})();

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

@@ -0,0 +1,230 @@
+/* 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/Label.js
+ */
+
+/**
+ * Port source: com.vividsolutions.jts.geomgraph.EdgeRing r6
+ *
+ * @constructor
+ */
+jsts.geomgraph.EdgeRing = function(start, geometryFactory) {
+  this.edges = [];
+  this.pts = [];
+  this.holes = [];
+  this.label = new jsts.geomgraph.Label(jsts.geom.Location.NONE);
+
+  this.geometryFactory = geometryFactory;
+
+  if (start) {
+    this.computePoints(start);
+    this.computeRing();
+  }
+};
+
+jsts.geomgraph.EdgeRing.prototype.startDe = null; // the directed edge which
+                                                  // starts the list of edges
+                                                  // for this EdgeRing
+jsts.geomgraph.EdgeRing.prototype.maxNodeDegree = -1;
+jsts.geomgraph.EdgeRing.prototype.edges = null; // the DirectedEdges making up
+                                                // this EdgeRing
+jsts.geomgraph.EdgeRing.prototype.pts = null;
+jsts.geomgraph.EdgeRing.prototype.label = null; // label stores the locations of
+                                                // each geometry on the face
+                                                // surrounded by this ring
+jsts.geomgraph.EdgeRing.prototype.ring = null; // the ring created for this
+                                                // EdgeRing
+jsts.geomgraph.EdgeRing.prototype._isHole = null;
+jsts.geomgraph.EdgeRing.prototype.shell = null; // if non-null, the ring is a
+                                                // hole and this EdgeRing is its
+                                                // containing shell
+jsts.geomgraph.EdgeRing.prototype.holes = null; // a list of EdgeRings which are
+                                                // holes in this EdgeRing
+
+jsts.geomgraph.EdgeRing.prototype.geometryFactory = null;
+
+jsts.geomgraph.EdgeRing.prototype.isIsolated = function() {
+  return (this.label.getGeometryCount() == 1);
+};
+jsts.geomgraph.EdgeRing.prototype.isHole = function() {
+  return this._isHole;
+};
+
+jsts.geomgraph.EdgeRing.prototype.getCoordinate = function(i) {
+  return this.pts[i];
+};
+jsts.geomgraph.EdgeRing.prototype.getLinearRing = function() { return this.ring; };
+jsts.geomgraph.EdgeRing.prototype.getLabel = function() {
+  return this.label;
+};
+jsts.geomgraph.EdgeRing.prototype.isShell = function() {
+  return this.shell === null;
+};
+jsts.geomgraph.EdgeRing.prototype.getShell = function() {
+  return this.shell;
+};
+jsts.geomgraph.EdgeRing.prototype.setShell = function(shell) {
+  this.shell = shell;
+  if (shell !== null)
+    shell.addHole(this);
+};
+jsts.geomgraph.EdgeRing.prototype.addHole = function(ring) {
+  this.holes.push(ring);
+};
+
+jsts.geomgraph.EdgeRing.prototype.toPolygon = function(geometryFactory) {
+  var holeLR = [];
+  for (var i = 0; i < this.holes.length; i++) {
+    holeLR[i] = this.holes[i].getLinearRing();
+  }
+  var poly = this.geometryFactory.createPolygon(this.getLinearRing(), holeLR);
+  return poly;
+};
+/**
+ * Compute a LinearRing from the point list previously collected. Test if the
+ * ring is a hole (i.e. if it is CCW) and set the hole flag accordingly.
+ */
+jsts.geomgraph.EdgeRing.prototype.computeRing = function() {
+  if (this.ring !== null)
+    return; // don't compute more than once
+  var coord = [];
+  for (var i = 0; i < this.pts.length; i++) {
+    coord[i] = this.pts[i];
+  }
+  this.ring = this.geometryFactory.createLinearRing(coord);
+  this._isHole = jsts.algorithm.CGAlgorithms.isCCW(this.ring.getCoordinates());
+};
+jsts.geomgraph.EdgeRing.prototype.getNext = function(de) {
+  throw new jsts.error.AbstractInvocationError();
+};
+jsts.geomgraph.EdgeRing.prototype.setEdgeRing = function(de, er) {
+  throw new jsts.error.AbstractInvocationError();
+};
+/**
+ * Returns the list of DirectedEdges that make up this EdgeRing
+ */
+jsts.geomgraph.EdgeRing.prototype.getEdges = function() {
+  return this.edges;
+};
+
+/**
+ * Collect all the points from the DirectedEdges of this ring into a contiguous
+ * list
+ */
+jsts.geomgraph.EdgeRing.prototype.computePoints = function(start) {
+  this.startDe = start;
+  var de = start;
+  var isFirstEdge = true;
+  do {
+    if (de === null)
+      throw new jsts.error.TopologyError('Found null DirectedEdge');
+    if (de.getEdgeRing() === this)
+      throw new jsts.error.TopologyError(
+          'Directed Edge visited twice during ring-building at ' +
+              de.getCoordinate());
+
+    this.edges.push(de);
+    var label = de.getLabel();
+    jsts.util.Assert.isTrue(label.isArea());
+    this.mergeLabel(label);
+    this.addPoints(de.getEdge(), de.isForward(), isFirstEdge);
+    isFirstEdge = false;
+    this.setEdgeRing(de, this);
+    de = this.getNext(de);
+  } while (de !== this.startDe);
+};
+
+jsts.geomgraph.EdgeRing.prototype.getMaxNodeDegree = function() {
+  if (this.maxNodeDegree < 0)
+    this.computeMaxNodeDegree();
+  return this.maxNodeDegree;
+};
+
+jsts.geomgraph.EdgeRing.prototype.computeMaxNodeDegree = function() {
+  this.maxNodeDegree = 0;
+  var de = this.startDe;
+  do {
+    var node = de.getNode();
+    var degree = node.getEdges().getOutgoingDegree(this);
+    if (degree > this.maxNodeDegree)
+      this.maxNodeDegree = degree;
+    de = this.getNext(de);
+  } while (de !== this.startDe);
+  this.maxNodeDegree *= 2;
+};
+
+
+jsts.geomgraph.EdgeRing.prototype.setInResult = function() {
+  var de = this.startDe;
+  do {
+    de.getEdge().setInResult(true);
+    de = de.getNext();
+  } while (de != this.startDe);
+};
+
+jsts.geomgraph.EdgeRing.prototype.mergeLabel = function(deLabel) {
+  this.mergeLabel2(deLabel, 0);
+  this.mergeLabel2(deLabel, 1);
+};
+/**
+ * Merge the RHS label from a DirectedEdge into the label for this EdgeRing. The
+ * DirectedEdge label may be null. This is acceptable - it results from a node
+ * which is NOT an intersection node between the Geometries (e.g. the end node
+ * of a LinearRing). In this case the DirectedEdge label does not contribute any
+ * information to the overall labelling, and is simply skipped.
+ */
+jsts.geomgraph.EdgeRing.prototype.mergeLabel2 = function(deLabel, geomIndex) {
+  var loc = deLabel.getLocation(geomIndex, jsts.geomgraph.Position.RIGHT);
+  // no information to be had from this label
+  if (loc == jsts.geom.Location.NONE)
+    return;
+  // if there is no current RHS value, set it
+  if (this.label.getLocation(geomIndex) === jsts.geom.Location.NONE) {
+    this.label.setLocation(geomIndex, loc);
+    return;
+  }
+};
+jsts.geomgraph.EdgeRing.prototype.addPoints = function(edge, isForward,
+    isFirstEdge) {
+  var edgePts = edge.getCoordinates();
+  if (isForward) {
+    var startIndex = 1;
+    if (isFirstEdge)
+      startIndex = 0;
+    for (var i = startIndex; i < edgePts.length; i++) {
+      this.pts.push(edgePts[i]);
+    }
+  } else { // is backward
+    var startIndex = edgePts.length - 2;
+    if (isFirstEdge)
+      startIndex = edgePts.length - 1;
+    for (var i = startIndex; i >= 0; i--) {
+      this.pts.push(edgePts[i]);
+    }
+  }
+};
+
+/**
+ * This method will cause the ring to be computed. It will also check any holes,
+ * if they have been assigned.
+ */
+jsts.geomgraph.EdgeRing.prototype.containsPoint = function(p) {
+  var shell = this.getLinearRing();
+  var env = shell.getEnvelopeInternal();
+  if (!env.contains(p))
+    return false;
+  if (!jsts.algorithm.CGAlgorithms.isPointInRing(p, shell.getCoordinates()))
+    return false;
+
+  for (var i = 0; i < this.holes.length; i++) {
+    var hole = this.holes[i];
+    if (hole.containsPoint(p))
+      return false;
+  }
+  return true;
+};

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

@@ -0,0 +1,469 @@
+/* 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
+   * @requires jsts/geomgraph/Position.js
+   * @requires jsts/geomgraph/PlanarGraph.js
+   * @requires jsts/util/Assert.js
+   */
+
+  var Location = jsts.geom.Location;
+  var Position = jsts.geomgraph.Position;
+  var Assert = jsts.util.Assert;
+
+
+
+  /**
+   * A GeometryGraph is a graph that models a given Geometry
+   *
+   * @param {int}
+   *          argIndex
+   * @param {Geometry}
+   *          parentGeom
+   * @param {BoundaryNodeRule}
+   *          boundaryNodeRule
+   * @augments jsts.planargraph.PlanarGraph
+   */
+  jsts.geomgraph.GeometryGraph = function(argIndex, parentGeom,
+      boundaryNodeRule) {
+    jsts.geomgraph.PlanarGraph.call(this);
+
+    this.lineEdgeMap = new javascript.util.HashMap();
+
+    this.ptLocator = new jsts.algorithm.PointLocator();
+
+    this.argIndex = argIndex;
+    this.parentGeom = parentGeom;
+    this.boundaryNodeRule = boundaryNodeRule ||
+        jsts.algorithm.BoundaryNodeRule.OGC_SFS_BOUNDARY_RULE;
+    if (parentGeom !== null) {
+      this.add(parentGeom);
+    }
+  };
+
+  jsts.geomgraph.GeometryGraph.prototype = new jsts.geomgraph.PlanarGraph();
+  jsts.geomgraph.GeometryGraph.constructor = jsts.geomgraph.GeometryGraph;
+
+  /**
+   * @return {EdgeSetIntersector}
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.createEdgeSetIntersector = function() {
+    return new jsts.geomgraph.index.SimpleEdgeSetIntersector();
+    // TODO: use optimized version when ported
+    // return new jsts.geomgraph.index.SimpleMCSweepLineIntersector();
+  };
+
+  /**
+   * @param {BoundaryNodeRule}
+   *          boundaryNodeRule
+   * @param {int}
+   *          boundaryCount
+   * @return {int}
+   */
+  jsts.geomgraph.GeometryGraph.determineBoundary = function(boundaryNodeRule,
+      boundaryCount) {
+    return boundaryNodeRule.isInBoundary(boundaryCount) ? Location.BOUNDARY
+        : Location.INTERIOR;
+  };
+
+
+  /**
+   * @type {Geometry}
+   */
+  jsts.geomgraph.GeometryGraph.prototype.parentGeom = null;
+
+
+  /**
+   * The lineEdgeMap is a map of the linestring components of the parentGeometry
+   * to the edges which are derived from them. This is used to efficiently
+   * perform findEdge queries
+   *
+   * @type {Object}
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.lineEdgeMap = null;
+
+
+  /**
+   * @type {BoundaryNodeRule}
+   */
+  jsts.geomgraph.GeometryGraph.prototype.boundaryNodeRule = null;
+
+
+  /**
+   * If this flag is true, the Boundary Determination Rule will used when
+   * deciding whether nodes are in the boundary or not
+   */
+  /**
+   * @type {boolean}
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.useBoundaryDeterminationRule = true;
+
+
+  /**
+   * the index of this geometry as an argument to a spatial function (used for
+   * labelling)
+   *
+   * @type {number}
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.argIndex = null;
+
+
+  /**
+   * @type {javascript.util.Collection}
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.boundaryNodes = null;
+
+
+  /**
+   * @type {Coordinate}
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.hasTooFewPoints = false;
+
+
+  /**
+   * @type {Coordinate}
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.invalidPoint = null;
+
+
+  /**
+   * @type {PointOnGeometryLocator}
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.areaPtLocator = null;
+
+
+  /**
+   * for use if geometry is not Polygonal
+   *
+   * @type {PointLocator}
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.ptLocator = null;
+
+
+  jsts.geomgraph.GeometryGraph.prototype.getGeometry = function() {
+    return this.parentGeom;
+  };
+
+  jsts.geomgraph.GeometryGraph.prototype.getBoundaryNodes = function() {
+    if (this.boundaryNodes === null)
+      this.boundaryNodes = this.nodes.getBoundaryNodes(this.argIndex);
+    return this.boundaryNodes;
+  };
+
+  jsts.geomgraph.GeometryGraph.prototype.getBoundaryNodeRule = function() {
+    return this.boundaryNodeRule;
+  };
+
+
+
+  jsts.geomgraph.GeometryGraph.prototype.findEdge = function(line) {
+    return this.lineEdgeMap.get(line);
+  };
+
+  jsts.geomgraph.GeometryGraph.prototype.computeSplitEdges = function(edgelist) {
+    for (var i = this.edges.iterator(); i.hasNext();) {
+      var e = i.next();
+      e.eiList.addSplitEdges(edgelist);
+    }
+  }
+
+  /**
+   * @param {Geometry}
+   *          g
+   */
+  jsts.geomgraph.GeometryGraph.prototype.add = function(g) {
+    if (g.isEmpty()) {
+      return;
+    }
+
+    // check if this Geometry should obey the Boundary Determination Rule
+    // all collections except MultiPolygons obey the rule
+    if (g instanceof jsts.geom.MultiPolygon)
+      this.useBoundaryDeterminationRule = false;
+
+    if (g instanceof jsts.geom.Polygon)
+      this.addPolygon(g);
+    // LineString also handles LinearRings
+    else if (g instanceof jsts.geom.LineString)
+      this.addLineString(g);
+    else if (g instanceof jsts.geom.Point)
+      this.addPoint(g);
+    else if (g instanceof jsts.geom.MultiPoint)
+      this.addCollection(g);
+    else if (g instanceof jsts.geom.MultiLineString)
+      this.addCollection(g);
+    else if (g instanceof jsts.geom.MultiPolygon)
+      this.addCollection(g);
+    else if (g instanceof jsts.geom.GeometryCollection)
+      this.addCollection(g);
+    else
+      throw new jsts.error.IllegalArgumentError('Geometry type not supported.');
+  };
+
+
+  /**
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.addCollection = function(gc) {
+    for (var i = 0; i < gc.getNumGeometries(); i++) {
+      var g = gc.getGeometryN(i);
+      this.add(g);
+    }
+  };
+
+
+  /**
+   * Add an Edge computed externally. The label on the Edge is assumed to be
+   * correct.
+   */
+  jsts.geomgraph.GeometryGraph.prototype.addEdge = function(e) {
+    this.insertEdge(e);
+    var coord = e.getCoordinates();
+    // insert the endpoint as a node, to mark that it is on the boundary
+    this.insertPoint(this.argIndex, coord[0], Location.BOUNDARY);
+    this.insertPoint(this.argIndex, coord[coord.length - 1], Location.BOUNDARY);
+  };
+
+
+  /**
+   * Add a Point to the graph.
+   */
+  jsts.geomgraph.GeometryGraph.prototype.addPoint = function(p) {
+    var coord = p.getCoordinate();
+    this.insertPoint(this.argIndex, coord, Location.INTERIOR);
+  };
+
+
+  /**
+   * @param {LineString}
+   *          line
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.addLineString = function(line) {
+    var coord = jsts.geom.CoordinateArrays.removeRepeatedPoints(line
+        .getCoordinates());
+
+    if (coord.length < 2) {
+      this.hasTooFewPoints = true;
+      this.invalidPoint = coords[0];
+      return;
+    }
+
+    // add the edge for the LineString
+    // line edges do not have locations for their left and right sides
+    var e = new jsts.geomgraph.Edge(coord, new jsts.geomgraph.Label(
+        this.argIndex, Location.INTERIOR));
+    this.lineEdgeMap.put(line, e);
+    this.insertEdge(e);
+    /**
+     * Add the boundary points of the LineString, if any. Even if the LineString
+     * is closed, add both points as if they were endpoints. This allows for the
+     * case that the node already exists and is a boundary point.
+     */
+    Assert.isTrue(coord.length >= 2, 'found LineString with single point');
+    this.insertBoundaryPoint(this.argIndex, coord[0]);
+    this.insertBoundaryPoint(this.argIndex, coord[coord.length - 1]);
+  };
+
+
+  /**
+   * Adds a polygon ring to the graph. Empty rings are ignored.
+   *
+   * The left and right topological location arguments assume that the ring is
+   * oriented CW. If the ring is in the opposite orientation, the left and right
+   * locations must be interchanged.
+   *
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.addPolygonRing = function(lr, cwLeft,
+      cwRight) {
+    // don't bother adding empty holes
+    if (lr.isEmpty())
+      return;
+
+    var coord = jsts.geom.CoordinateArrays.removeRepeatedPoints(lr
+        .getCoordinates());
+
+    if (coord.length < 4) {
+      this.hasTooFewPoints = true;
+      this.invalidPoint = coord[0];
+      return;
+    }
+
+    var left = cwLeft;
+    var right = cwRight;
+    if (jsts.algorithm.CGAlgorithms.isCCW(coord)) {
+      left = cwRight;
+      right = cwLeft;
+    }
+    var e = new jsts.geomgraph.Edge(coord, new jsts.geomgraph.Label(
+        this.argIndex, Location.BOUNDARY, left, right));
+    this.lineEdgeMap.put(lr, e);
+
+    this.insertEdge(e);
+    // insert the endpoint as a node, to mark that it is on the boundary
+    this.insertPoint(this.argIndex, coord[0], Location.BOUNDARY);
+  };
+
+
+  /**
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.addPolygon = function(p) {
+    this.addPolygonRing(p.getExteriorRing(), Location.EXTERIOR,
+        Location.INTERIOR);
+
+    for (var i = 0; i < p.getNumInteriorRing(); i++) {
+      var hole = p.getInteriorRingN(i);
+
+      // Holes are topologically labelled opposite to the shell, since
+      // the interior of the polygon lies on their opposite side
+      // (on the left, if the hole is oriented CW)
+      this.addPolygonRing(hole, Location.INTERIOR, Location.EXTERIOR);
+    }
+  };
+
+
+  jsts.geomgraph.GeometryGraph.prototype.computeEdgeIntersections = function(g,
+      li, includeProper) {
+    var si = new jsts.geomgraph.index.SegmentIntersector(li, includeProper,
+        true);
+    si.setBoundaryNodes(this.getBoundaryNodes(), g.getBoundaryNodes());
+
+    var esi = this.createEdgeSetIntersector();
+    esi.computeIntersections(this.edges, g.edges, si);
+
+    return si;
+  };
+
+
+  /**
+   * Compute self-nodes, taking advantage of the Geometry type to minimize the
+   * number of intersection tests. (E.g. rings are not tested for
+   * self-intersection, since they are assumed to be valid).
+   *
+   * @param {LineIntersector}
+   *          li the LineIntersector to use.
+   * @param {boolean}
+   *          computeRingSelfNodes if <false>, intersection checks are optimized
+   *          to not test rings for self-intersection.
+   * @return {SegmentIntersector} the SegmentIntersector used, containing
+   *         information about the intersections found.
+   */
+  jsts.geomgraph.GeometryGraph.prototype.computeSelfNodes = function(li,
+      computeRingSelfNodes) {
+    var si = new jsts.geomgraph.index.SegmentIntersector(li, true, false);
+    var esi = this.createEdgeSetIntersector();
+    // optimized test for Polygons and Rings
+    if (!computeRingSelfNodes &&
+        (this.parentGeom instanceof jsts.geom.LinearRing ||
+            this.parentGeom instanceof jsts.geom.Polygon || this.parentGeom instanceof jsts.geom.MultiPolygon)) {
+      esi.computeIntersections(this.edges, si, false);
+    } else {
+      esi.computeIntersections(this.edges, si, true);
+    }
+    this.addSelfIntersectionNodes(this.argIndex);
+    return si;
+  };
+
+
+  /**
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.insertPoint = function(argIndex,
+      coord, onLocation) {
+    var n = this.nodes.addNode(coord);
+    var lbl = n.getLabel();
+    if (lbl == null) {
+      n.label = new jsts.geomgraph.Label(argIndex, onLocation);
+    } else
+      lbl.setLocation(argIndex, onLocation);
+  };
+
+
+  /**
+   * Adds candidate boundary points using the current {@link BoundaryNodeRule}.
+   * This is used to add the boundary points of dim-1 geometries
+   * (Curves/MultiCurves).
+   */
+  jsts.geomgraph.GeometryGraph.prototype.insertBoundaryPoint = function(
+      argIndex, coord) {
+    var n = this.nodes.addNode(coord);
+    var lbl = n.getLabel();
+    // the new point to insert is on a boundary
+    var boundaryCount = 1;
+    // determine the current location for the point (if any)
+    var loc = Location.NONE;
+    if (lbl !== null)
+      loc = lbl.getLocation(argIndex, Position.ON);
+    if (loc === Location.BOUNDARY)
+      boundaryCount++;
+
+    // determine the boundary status of the point according to the Boundary
+    // Determination Rule
+    var newLoc = jsts.geomgraph.GeometryGraph.determineBoundary(
+        this.boundaryNodeRule, boundaryCount);
+    lbl.setLocation(argIndex, newLoc);
+  };
+
+
+  /**
+   * add edge intersections as self intersections from each edge intersection
+   * list
+   *
+   * @param argIndex
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.addSelfIntersectionNodes = function(
+      argIndex) {
+    for (var i = this.edges.iterator(); i.hasNext();) {
+      var e = i.next();
+      var eLoc = e.getLabel().getLocation(argIndex);
+      for (var eiIt = e.eiList.iterator(); eiIt.hasNext();) {
+        var ei = eiIt.next();
+        this.addSelfIntersectionNode(argIndex, ei.coord, eLoc);
+      }
+    }
+  };
+
+
+  /**
+   * Add a node for a self-intersection. If the node is a potential boundary
+   * node (e.g. came from an edge which is a boundary) then insert it as a
+   * potential boundary node. Otherwise, just add it as a regular node.
+   *
+   * @private
+   */
+  jsts.geomgraph.GeometryGraph.prototype.addSelfIntersectionNode = function(
+      argIndex, coord, loc) {
+    // if this node is already a boundary node, don't change it
+    if (this.isBoundaryNode(argIndex, coord))
+      return;
+    if (loc === Location.BOUNDARY && this.useBoundaryDeterminationRule)
+      this.insertBoundaryPoint(argIndex, coord);
+    else
+      this.insertPoint(argIndex, coord, loc);
+  };
+
+  jsts.geomgraph.GeometryGraph.prototype.getInvalidPoint = function() {
+    return this.invalidPoint;
+  };
+
+})();
+
+// TODO: port rest of class