jsts-rails 0.1.0 → 0.2.0

data/vendor/assets/javascripts/jsts/io/GeoJSONReader.js

@@ -0,0 +1,58 @@
+/* Copyright (c) 2011, 2012 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() {
+
+    /**
+     * Converts a geometry in GeoJSON to a {@link Geometry}.
+     * <p>
+     * A <code>GeoJSONReader</code> is parameterized by a <code>GeometryFactory</code>,
+     * to allow it to create <code>Geometry</code> objects of the appropriate
+     * implementation. In particular, the <code>GeometryFactory</code> determines
+     * the <code>PrecisionModel</code> and <code>SRID</code> that is used.
+     * <P>
+     *
+     * @constructor
+     */
+    jsts.io.GeoJSONReader = function(geometryFactory) {
+      this.geometryFactory = geometryFactory || new jsts.geom.GeometryFactory();
+      this.precisionModel = this.geometryFactory.getPrecisionModel();
+      this.parser = new jsts.io.GeoJSONParser(this.geometryFactory);
+    };
+
+    /**
+     * Reads a GeoJSON representation of a {@link Geometry}
+     *
+     * @param {object}
+     *          geoJson a GeoJSON Object or String.
+     * @return {jsts.geom.Geometry} a <code>Geometry.</code>
+     */
+    jsts.io.GeoJSONReader.prototype.read = function(geoJson) {
+      var geometry = this.parser.read(geoJson);
+
+      if (this.precisionModel.getType() === jsts.geom.PrecisionModel.FIXED) {
+        this.reducePrecision(geometry);
+      }
+
+      return geometry;
+    };
+
+    // NOTE: this is a hack
+    jsts.io.GeoJSONReader.prototype.reducePrecision = function(geometry) {
+      var i, len;
+
+      if (geometry.coordinate) {
+        this.precisionModel.makePrecise(geometry.coordinate);
+      } else if (geometry.points) {
+        for (i = 0, len = geometry.points.length; i < len; i++) {
+          this.precisionModel.makePrecise(geometry.points[i]);
+        }
+      } else if (geometry.geometries) {
+        for (i = 0, len = geometry.geometries.length; i < len; i++) {
+          this.reducePrecision(geometry.geometries[i]);
+        }
+      }
+    };
+})();

data/vendor/assets/javascripts/jsts/io/GeoJSONWriter.js

@@ -0,0 +1,38 @@
+/* Copyright (c) 2011, 2012 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() {
+    /**
+     * Writes the GeoJSON representation of a {@link Geometry}. The
+     * The GeoJSON format is defined <A
+     * HREF="http://geojson.org/geojson-spec.html">here</A>.
+     * <p>
+     * The <code>GeoJSONWriter</code> outputs coordinates rounded to the precision
+     * model. Only the maximum number of decimal places necessary to represent the
+     * ordinates to the required precision will be output.
+     * <p>
+     *
+     * @see WKTReader
+     * @constructor
+     */
+    jsts.io.GeoJSONWriter = function() {
+      this.parser = new jsts.io.GeoJSONParser(this.geometryFactory);
+    };
+
+    /**
+     * Converts a <code>Geometry</code> to its GeoJSON representation.
+     *
+     * @param {jsts.geom.Geometry}
+     *          geometry a <code>Geometry</code> to process.
+     * @return {Object} The GeoJSON representation of the Geometry.
+     */
+
+    jsts.io.GeoJSONWriter.prototype.write = function(geometry) {
+      var geoJson = this.parser.write(geometry);
+
+      return geoJson;
+    };
+})();

data/vendor/assets/javascripts/jsts/io/OpenLayersParser.js

@@ -0,0 +1,245 @@
+/* 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.
+ */
+
+jsts.io.OpenLayersParser = function(geometryFactory) {
+  this.geometryFactory = geometryFactory || new jsts.geom.GeometryFactory();
+};
+
+/**
+ * @param geometry
+ *          {OpenLayers.Geometry}
+ * @return {jsts.geom.Geometry}
+ */
+jsts.io.OpenLayersParser.prototype.read = function(geometry) {
+  if (geometry.CLASS_NAME === 'OpenLayers.Geometry.Point') {
+    return this.convertFromPoint(geometry);
+  } else if (geometry.CLASS_NAME === 'OpenLayers.Geometry.LineString') {
+    return this.convertFromLineString(geometry);
+  } else if (geometry.CLASS_NAME === 'OpenLayers.Geometry.LinearRing') {
+    return this.convertFromLinearRing(geometry);
+  } else if (geometry.CLASS_NAME === 'OpenLayers.Geometry.Polygon') {
+    return this.convertFromPolygon(geometry);
+  } else if (geometry.CLASS_NAME === 'OpenLayers.Geometry.MultiPoint') {
+    return this.convertFromMultiPoint(geometry);
+  } else if (geometry.CLASS_NAME === 'OpenLayers.Geometry.MultiLineString') {
+    return this.convertFromMultiLineString(geometry);
+  } else if (geometry.CLASS_NAME === 'OpenLayers.Geometry.MultiPolygon') {
+    return this.convertFromMultiPolygon(geometry);
+  } else if (geometry.CLASS_NAME === 'OpenLayers.Geometry.Collection') {
+    return this.convertFromCollection(geometry);
+  }
+};
+
+jsts.io.OpenLayersParser.prototype.convertFromPoint = function(point) {
+  return this.geometryFactory.createPoint(new jsts.geom.Coordinate(point.x,
+      point.y));
+};
+
+jsts.io.OpenLayersParser.prototype.convertFromLineString = function(lineString) {
+  var i;
+  var coordinates = [];
+
+  for (i = 0; i < lineString.components.length; i++) {
+    coordinates.push(new jsts.geom.Coordinate(lineString.components[i].x,
+        lineString.components[i].y));
+  }
+
+  return this.geometryFactory.createLineString(coordinates);
+};
+
+jsts.io.OpenLayersParser.prototype.convertFromLinearRing = function(linearRing) {
+  var i;
+  var coordinates = [];
+
+  for (i = 0; i < linearRing.components.length; i++) {
+    coordinates.push(new jsts.geom.Coordinate(linearRing.components[i].x,
+        linearRing.components[i].y));
+  }
+
+  return this.geometryFactory.createLinearRing(coordinates);
+};
+
+jsts.io.OpenLayersParser.prototype.convertFromPolygon = function(polygon) {
+  var i;
+  var shell = null;
+  var holes = [];
+
+  for (i = 0; i < polygon.components.length; i++) {
+    var linearRing = this.convertFromLinearRing(polygon.components[i]);
+
+    if (i === 0) {
+      shell = linearRing;
+    } else {
+      holes.push(linearRing);
+    }
+  }
+
+  return this.geometryFactory.createPolygon(shell, holes);
+};
+
+jsts.io.OpenLayersParser.prototype.convertFromMultiPoint = function(multiPoint) {
+  var i;
+  var points = [];
+
+  for (i = 0; i < multiPoint.components.length; i++) {
+    points.push(this.convertFromPoint(multiPoint.components[i]));
+  }
+
+  return this.geometryFactory.createMultiPoint(points);
+};
+
+jsts.io.OpenLayersParser.prototype.convertFromMultiLineString = function(
+    multiLineString) {
+  var i;
+  var lineStrings = [];
+
+  for (i = 0; i < multiLineString.components.length; i++) {
+    lineStrings.push(this.convertFromLineString(multiLineString.components[i]));
+  }
+
+  return this.geometryFactory.createMultiLineString(lineStrings);
+};
+
+jsts.io.OpenLayersParser.prototype.convertFromMultiPolygon = function(
+    multiPolygon) {
+  var i;
+  var polygons = [];
+
+  for (i = 0; i < multiPolygon.components.length; i++) {
+    polygons.push(this.convertFromPolygon(multiPolygon.components[i]));
+  }
+
+  return this.geometryFactory.createMultiPolygon(polygons);
+};
+
+jsts.io.OpenLayersParser.prototype.convertFromCollection = function(collection) {
+  var i;
+  var geometries = [];
+
+  for (i = 0; i < collection.components.length; i++) {
+    geometries.push(this.convertFrom(collection.components[i]));
+  }
+
+  return this.geometryFactory.createGeometryCollection(geometries);
+};
+
+/**
+ * @param geometry
+ *          {jsts.geom.Geometry}
+ * @return {OpenLayers.Geometry}
+ */
+jsts.io.OpenLayersParser.prototype.write = function(geometry) {
+  if (geometry.CLASS_NAME === 'jsts.geom.Point') {
+    return this.convertToPoint(geometry.coordinate);
+  } else if (geometry.CLASS_NAME === 'jsts.geom.LineString') {
+    return this.convertToLineString(geometry);
+  } else if (geometry.CLASS_NAME === 'jsts.geom.LinearRing') {
+    return this.convertToLinearRing(geometry);
+  } else if (geometry.CLASS_NAME === 'jsts.geom.Polygon') {
+    return this.convertToPolygon(geometry);
+  } else if (geometry.CLASS_NAME === 'jsts.geom.MultiPoint') {
+    return this.convertToMultiPoint(geometry);
+  } else if (geometry.CLASS_NAME === 'jsts.geom.MultiLineString') {
+    return this.convertToMultiLineString(geometry);
+  } else if (geometry.CLASS_NAME === 'jsts.geom.MultiPolygon') {
+    return this.convertToMultiPolygon(geometry);
+  } else if (geometry.CLASS_NAME === 'jsts.geom.GeometryCollection') {
+    return this.convertToCollection(geometry);
+  }
+};
+
+jsts.io.OpenLayersParser.prototype.convertToPoint = function(coordinate) {
+  return new OpenLayers.Geometry.Point(coordinate.x, coordinate.y);
+};
+
+jsts.io.OpenLayersParser.prototype.convertToLineString = function(lineString) {
+  var i;
+  var points = [];
+
+  for (i = 0; i < lineString.points.length; i++) {
+    var coordinate = lineString.points[i];
+    points.push(this.convertToPoint(coordinate));
+  }
+
+  return new OpenLayers.Geometry.LineString(points);
+};
+
+jsts.io.OpenLayersParser.prototype.convertToLinearRing = function(linearRing) {
+  var i;
+  var points = [];
+
+  for (i = 0; i < linearRing.points.length; i++) {
+    var coordinate = linearRing.points[i];
+    points.push(this.convertToPoint(coordinate));
+  }
+
+  return new OpenLayers.Geometry.LinearRing(points);
+};
+
+jsts.io.OpenLayersParser.prototype.convertToPolygon = function(polygon) {
+  var i;
+  var rings = [];
+
+  rings.push(this.convertToLinearRing(polygon.shell));
+
+  for (i = 0; i < polygon.holes.length; i++) {
+    var ring = polygon.holes[i];
+    rings.push(this.convertToLinearRing(ring));
+  }
+
+  return new OpenLayers.Geometry.Polygon(rings);
+};
+
+jsts.io.OpenLayersParser.prototype.convertToMultiPoint = function(multiPoint) {
+  var i;
+  var points = [];
+
+  for (i = 0; i < multiPoint.geometries.length; i++) {
+    var coordinate = multiPoint.geometries[i].coordinate;
+    points.push(new OpenLayers.Geometry.Point(coordinate.x, coordinate.y));
+  }
+
+  return new OpenLayers.Geometry.MultiPoint(points);
+};
+
+jsts.io.OpenLayersParser.prototype.convertToMultiLineString = function(
+    multiLineString) {
+  var i;
+  var lineStrings = [];
+
+  for (i = 0; i < multiLineString.geometries.length; i++) {
+    lineStrings.push(this.convertToLineString(multiLineString.geometries[i]));
+  }
+
+  return new OpenLayers.Geometry.MultiLineString(lineStrings);
+};
+
+jsts.io.OpenLayersParser.prototype.convertToMultiPolygon = function(
+    multiPolygon) {
+  var i;
+  var polygons = [];
+
+  for (i = 0; i < multiPolygon.geometries.length; i++) {
+    polygons.push(this.convertToPolygon(multiPolygon.geometries[i]));
+  }
+
+  return new OpenLayers.Geometry.MultiPolygon(polygons);
+};
+
+jsts.io.OpenLayersParser.prototype.convertToCollection = function(
+    geometryCollection) {
+  var i;
+  var geometries = [];
+
+  for (i = 0; i < geometryCollection.geometries.length; i++) {
+    var geometry = geometryCollection.geometries[i];
+    var geometryOpenLayers = this.write(geometry);
+
+    geometries.push(geometryOpenLayers);
+  }
+
+  return new OpenLayers.Geometry.Collection(geometries);
+};

data/vendor/assets/javascripts/jsts/io/WKTParser.js

@@ -0,0 +1,421 @@
+/* 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.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ * Copyright (c) 2006-2011 by OpenLayers Contributors (see authors.txt for
+ * full list of contributors). Published under the Clear BSD license.
+ * See http://svn.openlayers.org/trunk/openlayers/license.txt for the
+ * full text of the license.
+ */
+
+/**
+ * Class for reading and writing Well-Known Text.
+ *
+ * NOTE: Adapted from OpenLayers 2.11 implementation.
+ */
+
+/**
+ * Create a new parser for WKT
+ * 
+ * @param {}
+ *          geometryFactory
+ * @return An instance of WKTParser.
+ */
+jsts.io.WKTParser = function(geometryFactory) {
+  this.geometryFactory = geometryFactory || new jsts.geom.GeometryFactory();
+
+  this.regExes = {
+    'typeStr': /^\s*(\w+)\s*\(\s*(.*)\s*\)\s*$/,
+    'emptyTypeStr': /^\s*(\w+)\s*EMPTY\s*$/,
+    'spaces': /\s+/,
+    'parenComma': /\)\s*,\s*\(/,
+    'doubleParenComma': /\)\s*\)\s*,\s*\(\s*\(/, // can't use {2} here
+    'trimParens': /^\s*\(?(.*?)\)?\s*$/
+  };
+};
+
+
+/**
+ * Deserialize a WKT string and return a geometry. Supports WKT for POINT,
+ * MULTIPOINT, LINESTRING, LINEARRING, MULTILINESTRING, POLYGON, MULTIPOLYGON,
+ * and GEOMETRYCOLLECTION.
+ * 
+ * @param {String}
+ *          wkt A WKT string.
+ * @return {jsts.geom.Geometry} A geometry instance.
+ */
+jsts.io.WKTParser.prototype.read = function(wkt) {
+  var geometry, type, str;
+  wkt = wkt.replace(/[\n\r]/g, ' ');
+  var matches = this.regExes.typeStr.exec(wkt);
+  if (wkt.search('EMPTY') !== -1) {
+    matches = this.regExes.emptyTypeStr.exec(wkt);
+    matches[2] = undefined;
+  }
+  if (matches) {
+    type = matches[1].toLowerCase();
+    str = matches[2];
+    if (this.parse[type]) {
+      geometry = this.parse[type].apply(this, [str]);
+    }
+  }
+
+  if (geometry === undefined)
+    throw new Error('Could not parse WKT ' + wkt);
+
+  return geometry;
+};
+
+/**
+ * Serialize a geometry into a WKT string.
+ * 
+ * @param {jsts.geom.Geometry}
+ *          geometry A feature or array of features.
+ * @return {String} The WKT string representation of the input geometries.
+ */
+jsts.io.WKTParser.prototype.write = function(geometry) {
+  return this.extractGeometry(geometry);
+};
+
+/**
+ * Entry point to construct the WKT for a single Geometry object.
+ * 
+ * @param {jsts.geom.Geometry}
+ *          geometry
+ * 
+ * @return {String} A WKT string of representing the geometry.
+ */
+jsts.io.WKTParser.prototype.extractGeometry = function(geometry) {
+  var type = geometry.CLASS_NAME.split('.')[2].toLowerCase();
+  if (!this.extract[type]) {
+    return null;
+  }
+  var wktType = type.toUpperCase();
+  var data;
+  if (geometry.isEmpty()) {
+    data = wktType + ' EMPTY';
+  } else {
+    data = wktType + '(' + this.extract[type].apply(this, [geometry]) + ')';
+  }
+  return data;
+};
+
+/**
+ * Object with properties corresponding to the geometry types. Property values
+ * are functions that do the actual data extraction.
+ */
+jsts.io.WKTParser.prototype.extract = {
+  'coordinate': function(coordinate) {
+    return coordinate.x + ' ' + coordinate.y;
+  },
+
+  /**
+   * Return a space delimited string of point coordinates.
+   * 
+   * @param {jsts.geom.Point}
+   *          point
+   * @return {String} A string of coordinates representing the point.
+   */
+  'point': function(point) {
+    return point.coordinate.x + ' ' + point.coordinate.y;
+  },
+
+  /**
+   * Return a comma delimited string of point coordinates from a multipoint.
+   * 
+   * @param {jsts.geom.MultiPoint>}
+   *          multipoint
+   * @return {String} A string of point coordinate strings representing the
+   *         multipoint.
+   */
+  'multipoint': function(multipoint) {
+    var array = [];
+    for ( var i = 0, len = multipoint.geometries.length; i < len; ++i) {
+      array.push('(' +
+          this.extract.point.apply(this, [multipoint.geometries[i]]) + ')');
+    }
+    return array.join(',');
+  },
+
+  /**
+   * Return a comma delimited string of point coordinates from a line.
+   * 
+   * @param {jsts.geom.LineString>}
+   *          linestring
+   * @return {String} A string of point coordinate strings representing the
+   *         linestring.
+   */
+  'linestring': function(linestring) {
+    var array = [];
+    for ( var i = 0, len = linestring.points.length; i < len; ++i) {
+      array.push(this.extract.coordinate.apply(this, [linestring.points[i]]));
+    }
+    return array.join(',');
+  },
+
+  /**
+   * Return a comma delimited string of linestring strings from a
+   * multilinestring.
+   * 
+   * @param {jsts.geom.MultiLineString>}
+   *          multilinestring
+   * @return {String} A string of of linestring strings representing the
+   *         multilinestring.
+   */
+  'multilinestring': function(multilinestring) {
+    var array = [];
+    for ( var i = 0, len = multilinestring.geometries.length; i < len; ++i) {
+      array.push('(' +
+          this.extract.linestring.apply(this, [multilinestring.geometries[i]]) +
+          ')');
+    }
+    return array.join(',');
+  },
+
+  /**
+   * Return a comma delimited string of linear ring arrays from a polygon.
+   * 
+   * @param {jsts.geom.Polygon>}
+   *          polygon
+   * @return {String} An array of linear ring arrays representing the polygon.
+   */
+  'polygon': function(polygon) {
+    var array = [];
+    array.push('(' + this.extract.linestring.apply(this, [polygon.shell]) + ')');
+    for ( var i = 0, len = polygon.holes.length; i < len; ++i) {
+      array.push('(' + this.extract.linestring.apply(this, [polygon.holes[i]]) + ')');
+    }
+    return array.join(',');
+  },
+
+  /**
+   * Return an array of polygon arrays from a multipolygon.
+   * 
+   * @param {jsts.geom.MultiPolygon>}
+   *          multipolygon
+   * @return {String} An array of polygon arrays representing the multipolygon.
+   */
+  'multipolygon': function(multipolygon) {
+    var array = [];
+    for ( var i = 0, len = multipolygon.geometries.length; i < len; ++i) {
+      array.push('(' + this.extract.polygon.apply(this, [multipolygon.geometries[i]]) + ')');
+    }
+    return array.join(',');
+  },
+
+  /**
+   * Return the WKT portion between 'GEOMETRYCOLLECTION(' and ')' for an
+   * geometrycollection.
+   * 
+   * @param {jsts.geom.GeometryCollection>}
+   *          collection
+   * @return {String} internal WKT representation of the collection.
+   */
+  'geometrycollection': function(collection) {
+    var array = [];
+    for ( var i = 0, len = collection.geometries.length; i < len; ++i) {
+      array.push(this.extractGeometry.apply(this, [collection.geometries[i]]));
+    }
+    return array.join(',');
+  }
+
+};
+
+/**
+ * Object with properties corresponding to the geometry types. Property values
+ * are functions that do the actual parsing.
+ */
+jsts.io.WKTParser.prototype.parse = {
+  /**
+   * Return point geometry given a point WKT fragment.
+   * 
+   * @param {String}
+   *          str A WKT fragment representing the point.
+   * @return {jsts.geom.Point} A point geometry.
+   * @private
+   */
+  'point': function(str) {
+    if (str === undefined) {
+      return this.geometryFactory.createPoint(null);
+    }
+
+    var coords = str.trim().split(this.regExes.spaces);
+    return this.geometryFactory.createPoint(new jsts.geom.Coordinate(coords[0],
+        coords[1]));
+  },
+
+  /**
+   * Return a multipoint geometry given a multipoint WKT fragment.
+   * 
+   * @param {String}
+   *          A WKT fragment representing the multipoint.
+   * @return {jsts.geom.Point} A multipoint feature.
+   * @private
+   */
+  'multipoint': function(str) {
+    if (str === undefined) {
+      return this.geometryFactory.createMultiPoint(null);
+    }
+
+    var point;
+    var points = str.trim().split(',');
+    var components = [];
+    for ( var i = 0, len = points.length; i < len; ++i) {
+      point = points[i].replace(this.regExes.trimParens, '$1');
+      components.push(this.parse.point.apply(this, [point]));
+    }
+    return this.geometryFactory.createMultiPoint(components);
+  },
+
+  /**
+   * Return a linestring geometry given a linestring WKT fragment.
+   * 
+   * @param {String}
+   *          A WKT fragment representing the linestring.
+   * @return {jsts.geom.LineString} A linestring geometry.
+   * @private
+   */
+  'linestring': function(str) {
+    if (str === undefined) {
+      return this.geometryFactory.createLineString(null);
+    }
+
+    var points = str.trim().split(',');
+    var components = [];
+    var coords;
+    for ( var i = 0, len = points.length; i < len; ++i) {
+      coords = points[i].trim().split(this.regExes.spaces);
+      components.push(new jsts.geom.Coordinate(coords[0], coords[1]));
+    }
+    return this.geometryFactory.createLineString(components);
+  },
+
+  /**
+   * Return a linearring geometry given a linearring WKT fragment.
+   * 
+   * @param {String}
+   *          A WKT fragment representing the linearring.
+   * @return {jsts.geom.LinearRing} A linearring geometry.
+   * @private
+   */
+  'linearring': function(str) {
+    if (str === undefined) {
+      return this.geometryFactory.createLinearRing(null);
+    }
+
+    var points = str.trim().split(',');
+    var components = [];
+    var coords;
+    for ( var i = 0, len = points.length; i < len; ++i) {
+      coords = points[i].trim().split(this.regExes.spaces);
+      components.push(new jsts.geom.Coordinate(coords[0], coords[1]));
+    }
+    return this.geometryFactory.createLinearRing(components);
+  },
+
+  /**
+   * Return a multilinestring geometry given a multilinestring WKT fragment.
+   * 
+   * @param {String}
+   *          A WKT fragment representing the multilinestring.
+   * @return {jsts.geom.MultiLineString} A multilinestring geometry.
+   * @private
+   */
+  'multilinestring': function(str) {
+    if (str === undefined) {
+      return this.geometryFactory.createMultiLineString(null);
+    }
+
+    var line;
+    var lines = str.trim().split(this.regExes.parenComma);
+    var components = [];
+    for ( var i = 0, len = lines.length; i < len; ++i) {
+      line = lines[i].replace(this.regExes.trimParens, '$1');
+      components.push(this.parse.linestring.apply(this, [line]));
+    }
+    return this.geometryFactory.createMultiLineString(components);
+  },
+
+  /**
+   * Return a polygon geometry given a polygon WKT fragment.
+   * 
+   * @param {String}
+   *          A WKT fragment representing the polygon.
+   * @return {jsts.geom.Polygon} A polygon geometry.
+   * @private
+   */
+  'polygon': function(str) {
+    if (str === undefined) {
+      return this.geometryFactory.createPolygon(null);
+    }
+
+    var ring, linestring, linearring;
+    var rings = str.trim().split(this.regExes.parenComma);
+    var shell;
+    var holes = [];
+    for ( var i = 0, len = rings.length; i < len; ++i) {
+      ring = rings[i].replace(this.regExes.trimParens, '$1');
+      linestring = this.parse.linestring.apply(this, [ring]);
+      linearring = this.geometryFactory.createLinearRing(linestring.points);
+      if (i === 0) {
+        shell = linearring;
+      } else {
+        holes.push(linearring);
+      }
+
+    }
+    return this.geometryFactory.createPolygon(shell, holes);
+  },
+
+  /**
+   * Return a multipolygon geometry given a multipolygon WKT fragment.
+   * 
+   * @param {String}
+   *          A WKT fragment representing the multipolygon.
+   * @return {jsts.geom.MultiPolygon} A multipolygon geometry.
+   * @private
+   */
+  'multipolygon': function(str) {
+    if (str === undefined) {
+      return this.geometryFactory.createMultiPolygon(null);
+    }
+
+    var polygon;
+    var polygons = str.trim().split(this.regExes.doubleParenComma);
+    var components = [];
+    for ( var i = 0, len = polygons.length; i < len; ++i) {
+      polygon = polygons[i].replace(this.regExes.trimParens, '$1');
+      components.push(this.parse.polygon.apply(this, [polygon]));
+    }
+    return this.geometryFactory.createMultiPolygon(components);
+  },
+
+  /**
+   * Return a geometrycollection given a geometrycollection WKT fragment.
+   * 
+   * @param {String}
+   *          A WKT fragment representing the geometrycollection.
+   * @return {jsts.geom.GeometryCollection}
+   * @private
+   */
+  'geometrycollection': function(str) {
+    if (str === undefined) {
+      return this.geometryFactory.createGeometryCollection(null);
+    }
+
+    // separate components of the collection with |
+    str = str.replace(/,\s*([A-Za-z])/g, '|$1');
+    var wktArray = str.trim().split('|');
+    var components = [];
+    for ( var i = 0, len = wktArray.length; i < len; ++i) {
+      components.push(jsts.io.WKTParser.prototype.read.apply(this,
+          [wktArray[i]]));
+    }
+    return this.geometryFactory.createGeometryCollection(components);
+  }
+
+};