jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/geom/util/LinearComponentExtracter.js

@@ -0,0 +1,207 @@
+/* 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/geom/GeometryComponentFilter.js
+ */
+
+
+
+/**
+ * Extracts all the 1-dimensional ({@link LineString}) components from a
+ * {@link Geometry}.
+ *
+ * @extends {jsts.geom.GeometryComponentFilter}
+ * @constructor
+ */
+jsts.geom.util.LinearComponentExtracter = function(lines, isForcedToLineString) {
+  this.lines = lines;
+  this.isForcedToLineString = isForcedToLineString;
+};
+
+jsts.geom.util.LinearComponentExtracter.prototype = new jsts.geom.GeometryComponentFilter();
+
+
+/**
+ * @private
+ */
+jsts.geom.util.LinearComponentExtracter.prototype.lines = null;
+
+
+/**
+ * @private
+ */
+jsts.geom.util.LinearComponentExtracter.prototype.isForcedToLineString = false;
+
+
+/**
+ * Extracts the linear components from a single {@link Geometry} and adds them
+ * to the provided {@link Collection}.
+ *
+ * NOTE: will call "overloaded" function depending on args.
+ *
+ * @param {[]}
+ *          geoms the collection of geometries from which to extract linear
+ *          components.
+ * @param {[]}
+ *          lines the collection to add the extracted linear components to.
+ * @return {[]} the collection of linear components (LineStrings or
+ *         LinearRings).
+ */
+jsts.geom.util.LinearComponentExtracter.getLines = function(geoms, lines) {
+  if (arguments.length == 1) {
+    return jsts.geom.util.LinearComponentExtracter.getLines5.apply(this, arguments);
+  }
+  else if (arguments.length == 2 && typeof lines === 'boolean') {
+    return jsts.geom.util.LinearComponentExtracter.getLines6.apply(this, arguments);
+  }
+  else if (arguments.length == 2 && geoms instanceof jsts.geom.Geometry) {
+    return jsts.geom.util.LinearComponentExtracter.getLines3.apply(this, arguments);
+  }
+  else if (arguments.length == 3 && geoms instanceof jsts.geom.Geometry) {
+    return jsts.geom.util.LinearComponentExtracter.getLines4.apply(this, arguments);
+  }
+  else if (arguments.length == 3) {
+    return jsts.geom.util.LinearComponentExtracter.getLines2.apply(this, arguments);
+  }
+
+  for (var i = 0; i < geoms.length; i++) {
+    var g = geoms[i];
+    jsts.geom.util.LinearComponentExtracter.getLines3(g, lines);
+  }
+  return lines;
+};
+
+
+/**
+ * Extracts the linear components from a single {@link Geometry} and adds them
+ * to the provided {@link Collection}.
+ *
+ * @param {[]}
+ *          geoms the Collection of geometries from which to extract linear
+ *          components.
+ * @param {[]}
+ *          lines the collection to add the extracted linear components to.
+ * @param {boolean}
+ *          forceToLineString true if LinearRings should be converted to
+ *          LineStrings.
+ * @return {[]} the collection of linear components (LineStrings or
+ *         LinearRings).
+ */
+jsts.geom.util.LinearComponentExtracter.getLines2 = function(geoms, lines,
+    forceToLineString) {
+  for (var i = 0; i < geoms.length; i++) {
+    var g = geoms[i];
+    jsts.geom.util.LinearComponentExtracter.getLines4(g, lines,
+        forceToLineString);
+  }
+  return lines;
+};
+
+
+/**
+ * Extracts the linear components from a single {@link Geometry} and adds them
+ * to the provided {@link Collection}.
+ *
+ * @param {Geometry}
+ *          geom the geometry from which to extract linear components.
+ * @param {[]}
+ *          lines the Collection to add the extracted linear components to.
+ * @return {[]} the Collection of linear components (LineStrings or
+ *         LinearRings).
+ */
+jsts.geom.util.LinearComponentExtracter.getLines3 = function(geom, lines) {
+  if (geom instanceof LineString) {
+    lines.add(geom);
+  } else {
+    geom.apply(new jsts.geom.util.LinearComponentExtracter(lines));
+  }
+  return lines;
+};
+
+
+/**
+ * Extracts the linear components from a single {@link Geometry} and adds them
+ * to the provided {@link Collection}.
+ *
+ * @param {Geometry}
+ *          geom the geometry from which to extract linear components.
+ * @param {[]}
+ *          lines the Collection to add the extracted linear components to.
+ * @param {boolean}
+ *          forceToLineString true if LinearRings should be converted to
+ *          LineStrings.
+ * @return {[]} the Collection of linear components (LineStrings or
+ *         LinearRings).
+ */
+jsts.geom.util.LinearComponentExtracter.getLines4 = function(geom, lines,
+    forceToLineString) {
+  geom.apply(new jsts.geom.util.LinearComponentExtracter(lines,
+      forceToLineString));
+  return lines;
+};
+
+
+/**
+ * Extracts the linear components from a single geometry. If more than one
+ * geometry is to be processed, it is more efficient to create a single
+ * {@link LinearComponentExtracter} instance and pass it to multiple geometries.
+ *
+ * @param {Geometry}
+ *          geom the geometry from which to extract linear components.
+ * @return {[]} the list of linear components.
+ */
+jsts.geom.util.LinearComponentExtracter.getLines5 = function(geom) {
+  return jsts.geom.util.LinearComponentExtracter.getLines6(geom, false);
+};
+
+
+/**
+ * Extracts the linear components from a single geometry. If more than one
+ * geometry is to be processed, it is more efficient to create a single
+ * {@link LinearComponentExtracter} instance and pass it to multiple geometries.
+ *
+ * @param {Geometry}
+ *          geom the geometry from which to extract linear components.
+ * @param {boolean}
+ *          forceToLineString true if LinearRings should be converted to
+ *          LineStrings.
+ * @return {[] the list of linear components.}
+ */
+jsts.geom.util.LinearComponentExtracter.getLines6 = function(geom,
+    forceToLineString) {
+  var lines = [];
+  geom.apply(new jsts.geom.util.LinearComponentExtracter(lines,
+      forceToLineString));
+  return lines;
+};
+
+
+/**
+ * Indicates that LinearRing components should be converted to pure LineStrings.
+ *
+ * @param {boolean}
+ *          isForcedToLineString true if LinearRings should be converted to
+ *          LineStrings.
+ */
+jsts.geom.util.LinearComponentExtracter.prototype.setForceToLineString = function(
+    isForcedToLineString) {
+  this.isForcedToLineString = isForcedToLineString;
+};
+
+jsts.geom.util.LinearComponentExtracter.prototype.filter = function(geom) {
+  if (this.isForcedToLineString && geom instanceof jsts.geom.LinearRing) {
+    var line = geom.getFactory().createLineString(geom.getCoordinateSequence());
+    this.lines.push(line);
+    return;
+  }
+  // if not being forced, and this is a linear component
+  // NOTE: inheritance will not show LinearRing to be of LineString heritance...
+  if (geom instanceof jsts.geom.LineString || geom instanceof jsts.geom.LinearRing)
+    this.lines.push(geom);
+
+  // else this is not a linear component, so skip it
+};

data/vendor/assets/javascripts/jsts/geom/util/PointExtracter.js

@@ -0,0 +1,67 @@
+/* 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/geom/GeometryFilter.js
+ */
+
+
+
+/**
+ * Extracts all the 0-dimensional ({@link Point}) components from a
+ * {@link Geometry}.
+ *
+ * Constructs a PointExtracterFilter with a list in which to store Points found.
+ *
+ * @extends {jsts.geom.GeometryFilter}
+ * @see GeometryExtracter
+ * @constructor
+ */
+jsts.geom.util.PointExtracter = function(pts) {
+  this.pts = pts;
+};
+
+jsts.geom.util.PointExtracter.prototype = new jsts.geom.GeometryFilter();
+
+
+/**
+ * @private
+ */
+jsts.geom.util.PointExtracter.prototype.pts = null;
+
+
+/**
+ * Extracts the {@link Point} elements from a single {@link Geometry} and adds
+ * them to the provided {@link List}.
+ *
+ * @param {Geometry}
+ *          geom the geometry from which to extract.
+ * @param {[]}
+ *          list the list to add the extracted elements to.
+ * @return {[]}
+ */
+jsts.geom.util.PointExtracter.getPoints = function(geom, list) {
+  if (list === undefined) {
+    list = [];
+  }
+
+  if (geom instanceof jsts.geom.Point) {
+    list.push(geom);
+  } else if (geom instanceof jsts.geom.GeometryCollection ||
+      geom instanceof jsts.geom.MultiPoint ||
+      geom instanceof jsts.geom.MultiLineString ||
+      geom instanceof jsts.geom.MultiPolygon) {
+    geom.apply(new jsts.geom.util.PointExtracter(list));
+  }
+  // skip non-Polygonal elemental geometries
+
+  return list;
+};
+
+jsts.geom.util.PointExtracter.prototype.filter = function(geom) {
+  if (geom instanceof jsts.geom.Point)
+    this.pts.push(geom);
+};

data/vendor/assets/javascripts/jsts/geom/util/PolygonExtracter.js

@@ -0,0 +1,71 @@
+/* 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/geom/GeometryFilter.js
+ */
+
+
+
+/**
+ * Extracts all the {@link Polygon} elements from a {@link Geometry}.
+ *
+ * Constructs a PolygonExtracterFilter with a list in which to store Polygons
+ * found.
+ *
+ * @param {Array}
+ *          comps
+ * @extends {jsts.geom.GeometryFilter}
+ * @see GeometryExtracter
+ * @constructor
+ */
+jsts.geom.util.PolygonExtracter = function(comps) {
+  this.comps = comps;
+};
+
+jsts.geom.util.PolygonExtracter.prototype = new jsts.geom.GeometryFilter();
+
+
+/**
+ * @private
+ */
+jsts.geom.util.PolygonExtracter.prototype.comps = null;
+
+
+/**
+ * Extracts the {@link Polygon} elements from a single {@link Geometry} and adds
+ * them to the provided {@link List}.
+ *
+ * @param {jsts.geom.Geometry}
+ *          geom the geometry from which to extract.
+ * @param {Array}
+ *          list the list to add the extracted elements to.
+ * @return {Array}
+ */
+jsts.geom.util.PolygonExtracter.getPolygons = function(geom, list) {
+  if (list === undefined) {
+    list = [];
+  }
+
+  if (geom instanceof jsts.geom.Polygon) {
+    list.push(geom);
+  } else if (geom instanceof jsts.geom.GeometryCollection) {
+    geom.apply(new jsts.geom.util.PolygonExtracter(list));
+  }
+  // skip non-Polygonal elemental geometries
+
+  return list;
+};
+
+
+/**
+ * @param {jsts.geom.Geometry}
+ *          geom
+ */
+jsts.geom.util.PolygonExtracter.prototype.filter = function(geom) {
+  if (geom instanceof jsts.geom.Polygon)
+    this.comps.push(geom);
+};

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

@@ -0,0 +1,145 @@
+/* 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
+   */
+
+  var Location = jsts.geom.Location;
+  var Position = jsts.geomgraph.Position;
+
+  /**
+   * A Depth object records the topological depth of the sides of an Edge for up
+   * to two Geometries.
+   *
+   * @constructor
+   */
+  jsts.geomgraph.Depth = function() {
+    // initialize depth array to a sentinel value
+    this.depth = [[], []];
+    for (var i = 0; i < 2; i++) {
+      for (var j = 0; j < 3; j++) {
+        this.depth[i][j] = jsts.geomgraph.Depth.NULL_VALUE;
+      }
+    }
+  };
+
+  jsts.geomgraph.Depth.NULL_VALUE = -1;
+
+  jsts.geomgraph.Depth.depthAtLocation = function(location) {
+    if (location === Location.EXTERIOR)
+      return 0;
+    if (location === Location.INTERIOR)
+      return 1;
+    return jsts.geomgraph.Depth.NULL_VALUE;
+  };
+
+  jsts.geomgraph.Depth.prototype.depth = null;
+
+
+  jsts.geomgraph.Depth.prototype.getDepth = function(geomIndex, posIndex) {
+    return this.depth[geomIndex][posIndex];
+  };
+
+  jsts.geomgraph.Depth.prototype.setDepth = function(geomIndex, posIndex,
+      depthValue) {
+    this.depth[geomIndex][posIndex] = depthValue;
+  };
+
+  jsts.geomgraph.Depth.prototype.getLocation = function(geomIndex, posIndex) {
+    if (this.depth[geomIndex][posIndex] <= 0)
+      return Location.EXTERIOR;
+    return Location.INTERIOR;
+  };
+
+  jsts.geomgraph.Depth.prototype.add = function(geomIndex, posIndex, location) {
+    if (location === Location.INTERIOR)
+      this.depth[geomIndex][posIndex]++;
+  };
+
+  /**
+   * A Depth object is null (has never been initialized) if all depths are null.
+   */
+  jsts.geomgraph.Depth.prototype.isNull = function() {
+    if (arguments.length > 0) {
+      return this.isNull2.apply(this, arguments);
+    }
+
+    for (var i = 0; i < 2; i++) {
+      for (var j = 0; j < 3; j++) {
+        if (this.depth[i][j] !== jsts.geomgraph.Depth.NULL_VALUE)
+          return false;
+      }
+    }
+    return true;
+  };
+
+  jsts.geomgraph.Depth.prototype.isNull2 = function(geomIndex) {
+    if (arguments.length > 1) {
+      return this.isNull3.apply(this, arguments);
+    }
+
+    return this.depth[geomIndex][1] == jsts.geomgraph.Depth.NULL_VALUE;
+  };
+
+  jsts.geomgraph.Depth.prototype.isNull3 = function(geomIndex, posIndex) {
+    return this.depth[geomIndex][posIndex] == jsts.geomgraph.Depth.NULL_VALUE;
+  };
+
+  jsts.geomgraph.Depth.prototype.add = function(lbl) {
+    for (var i = 0; i < 2; i++) {
+      for (var j = 1; j < 3; j++) {
+        var loc = lbl.getLocation(i, j);
+        if (loc === Location.EXTERIOR || loc === Location.INTERIOR) {
+          // initialize depth if it is null, otherwise add this location value
+          if (this.isNull(i, j)) {
+            this.depth[i][j] = jsts.geomgraph.Depth.depthAtLocation(loc);
+          } else
+            this.depth[i][j] += jsts.geomgraph.Depth.depthAtLocation(loc);
+        }
+      }
+    }
+  };
+
+  jsts.geomgraph.Depth.prototype.getDelta = function(geomIndex) {
+    return this.depth[geomIndex][Position.RIGHT] -
+        this.depth[geomIndex][Position.LEFT];
+  };
+
+  /**
+   * Normalize the depths for each geometry, if they are non-null. A normalized
+   * depth has depth values in the set { 0, 1 }. Normalizing the depths involves
+   * reducing the depths by the same amount so that at least one of them is 0.
+   * If the remaining value is > 0, it is set to 1.
+   */
+  jsts.geomgraph.Depth.prototype.normalize = function() {
+    for (var i = 0; i < 2; i++) {
+      if (!this.isNull(i)) {
+        var minDepth = this.depth[i][1];
+        if (this.depth[i][2] < minDepth)
+          minDepth = this.depth[i][2];
+
+        if (minDepth < 0)
+          minDepth = 0;
+        for (var j = 1; j < 3; j++) {
+          var newValue = 0;
+          if (this.depth[i][j] > minDepth)
+            newValue = 1;
+          this.depth[i][j] = newValue;
+        }
+      }
+    }
+  };
+
+  jsts.geomgraph.Depth.prototype.toString = function() {
+    return 'A: ' + this.depth[0][1] + ',' + this.depth[0][2] + ' B: ' +
+        this.depth[1][1] + ',' + this.depth[1][2];
+  };
+
+})();