diff options
Diffstat (limited to 'misc/openlayers/lib/OpenLayers/Format/WKT.js')
| -rw-r--r-- | misc/openlayers/lib/OpenLayers/Format/WKT.js | 392 |
1 files changed, 392 insertions, 0 deletions
diff --git a/misc/openlayers/lib/OpenLayers/Format/WKT.js b/misc/openlayers/lib/OpenLayers/Format/WKT.js new file mode 100644 index 0000000..a7a7b2e --- /dev/null +++ b/misc/openlayers/lib/OpenLayers/Format/WKT.js @@ -0,0 +1,392 @@ +/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for + * full list of contributors). Published under the 2-clause BSD license. + * See license.txt in the OpenLayers distribution or repository for the + * full text of the license. */ + +/** + * @requires OpenLayers/Format.js + * @requires OpenLayers/Feature/Vector.js + * @requires OpenLayers/Geometry/Point.js + * @requires OpenLayers/Geometry/MultiPoint.js + * @requires OpenLayers/Geometry/LineString.js + * @requires OpenLayers/Geometry/MultiLineString.js + * @requires OpenLayers/Geometry/Polygon.js + * @requires OpenLayers/Geometry/MultiPolygon.js + */ + +/** + * Class: OpenLayers.Format.WKT + * Class for reading and writing Well-Known Text. Create a new instance + * with the <OpenLayers.Format.WKT> constructor. + * + * Inherits from: + * - <OpenLayers.Format> + */ +OpenLayers.Format.WKT = OpenLayers.Class(OpenLayers.Format, { + + /** + * Constructor: OpenLayers.Format.WKT + * Create a new parser for WKT + * + * Parameters: + * options - {Object} An optional object whose properties will be set on + * this instance + * + * Returns: + * {<OpenLayers.Format.WKT>} A new WKT parser. + */ + initialize: function(options) { + this.regExes = { + 'typeStr': /^\s*(\w+)\s*\(\s*(.*)\s*\)\s*$/, + 'spaces': /\s+/, + 'parenComma': /\)\s*,\s*\(/, + 'doubleParenComma': /\)\s*\)\s*,\s*\(\s*\(/, // can't use {2} here + 'trimParens': /^\s*\(?(.*?)\)?\s*$/ + }; + OpenLayers.Format.prototype.initialize.apply(this, [options]); + }, + + /** + * APIMethod: read + * Deserialize a WKT string and return a vector feature or an + * array of vector features. Supports WKT for POINT, MULTIPOINT, + * LINESTRING, MULTILINESTRING, POLYGON, MULTIPOLYGON, and + * GEOMETRYCOLLECTION. + * + * Parameters: + * wkt - {String} A WKT string + * + * Returns: + * {<OpenLayers.Feature.Vector>|Array} A feature or array of features for + * GEOMETRYCOLLECTION WKT. + */ + read: function(wkt) { + var features, type, str; + wkt = wkt.replace(/[\n\r]/g, " "); + var matches = this.regExes.typeStr.exec(wkt); + if(matches) { + type = matches[1].toLowerCase(); + str = matches[2]; + if(this.parse[type]) { + features = this.parse[type].apply(this, [str]); + } + if (this.internalProjection && this.externalProjection) { + if (features && + features.CLASS_NAME == "OpenLayers.Feature.Vector") { + features.geometry.transform(this.externalProjection, + this.internalProjection); + } else if (features && + type != "geometrycollection" && + typeof features == "object") { + for (var i=0, len=features.length; i<len; i++) { + var component = features[i]; + component.geometry.transform(this.externalProjection, + this.internalProjection); + } + } + } + } + return features; + }, + + /** + * APIMethod: write + * Serialize a feature or array of features into a WKT string. + * + * Parameters: + * features - {<OpenLayers.Feature.Vector>|Array} A feature or array of + * features + * + * Returns: + * {String} The WKT string representation of the input geometries + */ + write: function(features) { + var collection, geometry, isCollection; + if (features.constructor == Array) { + collection = features; + isCollection = true; + } else { + collection = [features]; + isCollection = false; + } + var pieces = []; + if (isCollection) { + pieces.push('GEOMETRYCOLLECTION('); + } + for (var i=0, len=collection.length; i<len; ++i) { + if (isCollection && i>0) { + pieces.push(','); + } + geometry = collection[i].geometry; + pieces.push(this.extractGeometry(geometry)); + } + if (isCollection) { + pieces.push(')'); + } + return pieces.join(''); + }, + + /** + * Method: extractGeometry + * Entry point to construct the WKT for a single Geometry object. + * + * Parameters: + * geometry - {<OpenLayers.Geometry.Geometry>} + * + * Returns: + * {String} A WKT string of representing the geometry + */ + extractGeometry: function(geometry) { + var type = geometry.CLASS_NAME.split('.')[2].toLowerCase(); + if (!this.extract[type]) { + return null; + } + if (this.internalProjection && this.externalProjection) { + geometry = geometry.clone(); + geometry.transform(this.internalProjection, this.externalProjection); + } + var wktType = type == 'collection' ? 'GEOMETRYCOLLECTION' : type.toUpperCase(); + var 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. + */ + extract: { + /** + * Return a space delimited string of point coordinates. + * @param {OpenLayers.Geometry.Point} point + * @returns {String} A string of coordinates representing the point + */ + 'point': function(point) { + return point.x + ' ' + point.y; + }, + + /** + * Return a comma delimited string of point coordinates from a multipoint. + * @param {OpenLayers.Geometry.MultiPoint} multipoint + * @returns {String} A string of point coordinate strings representing + * the multipoint + */ + 'multipoint': function(multipoint) { + var array = []; + for(var i=0, len=multipoint.components.length; i<len; ++i) { + array.push('(' + + this.extract.point.apply(this, [multipoint.components[i]]) + + ')'); + } + return array.join(','); + }, + + /** + * Return a comma delimited string of point coordinates from a line. + * @param {OpenLayers.Geometry.LineString} linestring + * @returns {String} A string of point coordinate strings representing + * the linestring + */ + 'linestring': function(linestring) { + var array = []; + for(var i=0, len=linestring.components.length; i<len; ++i) { + array.push(this.extract.point.apply(this, [linestring.components[i]])); + } + return array.join(','); + }, + + /** + * Return a comma delimited string of linestring strings from a multilinestring. + * @param {OpenLayers.Geometry.MultiLineString} multilinestring + * @returns {String} A string of of linestring strings representing + * the multilinestring + */ + 'multilinestring': function(multilinestring) { + var array = []; + for(var i=0, len=multilinestring.components.length; i<len; ++i) { + array.push('(' + + this.extract.linestring.apply(this, [multilinestring.components[i]]) + + ')'); + } + return array.join(','); + }, + + /** + * Return a comma delimited string of linear ring arrays from a polygon. + * @param {OpenLayers.Geometry.Polygon} polygon + * @returns {String} An array of linear ring arrays representing the polygon + */ + 'polygon': function(polygon) { + var array = []; + for(var i=0, len=polygon.components.length; i<len; ++i) { + array.push('(' + + this.extract.linestring.apply(this, [polygon.components[i]]) + + ')'); + } + return array.join(','); + }, + + /** + * Return an array of polygon arrays from a multipolygon. + * @param {OpenLayers.Geometry.MultiPolygon} multipolygon + * @returns {String} An array of polygon arrays representing + * the multipolygon + */ + 'multipolygon': function(multipolygon) { + var array = []; + for(var i=0, len=multipolygon.components.length; i<len; ++i) { + array.push('(' + + this.extract.polygon.apply(this, [multipolygon.components[i]]) + + ')'); + } + return array.join(','); + }, + + /** + * Return the WKT portion between 'GEOMETRYCOLLECTION(' and ')' for an <OpenLayers.Geometry.Collection> + * @param {OpenLayers.Geometry.Collection} collection + * @returns {String} internal WKT representation of the collection + */ + 'collection': function(collection) { + var array = []; + for(var i=0, len=collection.components.length; i<len; ++i) { + array.push(this.extractGeometry.apply(this, [collection.components[i]])); + } + return array.join(','); + } + + }, + + /** + * Object with properties corresponding to the geometry types. + * Property values are functions that do the actual parsing. + */ + parse: { + /** + * Return point feature given a point WKT fragment. + * @param {String} str A WKT fragment representing the point + * @returns {OpenLayers.Feature.Vector} A point feature + * @private + */ + 'point': function(str) { + var coords = OpenLayers.String.trim(str).split(this.regExes.spaces); + return new OpenLayers.Feature.Vector( + new OpenLayers.Geometry.Point(coords[0], coords[1]) + ); + }, + + /** + * Return a multipoint feature given a multipoint WKT fragment. + * @param {String} str A WKT fragment representing the multipoint + * @returns {OpenLayers.Feature.Vector} A multipoint feature + * @private + */ + 'multipoint': function(str) { + var point; + var points = OpenLayers.String.trim(str).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]).geometry); + } + return new OpenLayers.Feature.Vector( + new OpenLayers.Geometry.MultiPoint(components) + ); + }, + + /** + * Return a linestring feature given a linestring WKT fragment. + * @param {String} str A WKT fragment representing the linestring + * @returns {OpenLayers.Feature.Vector} A linestring feature + * @private + */ + 'linestring': function(str) { + var points = OpenLayers.String.trim(str).split(','); + var components = []; + for(var i=0, len=points.length; i<len; ++i) { + components.push(this.parse.point.apply(this, [points[i]]).geometry); + } + return new OpenLayers.Feature.Vector( + new OpenLayers.Geometry.LineString(components) + ); + }, + + /** + * Return a multilinestring feature given a multilinestring WKT fragment. + * @param {String} str A WKT fragment representing the multilinestring + * @returns {OpenLayers.Feature.Vector} A multilinestring feature + * @private + */ + 'multilinestring': function(str) { + var line; + var lines = OpenLayers.String.trim(str).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]).geometry); + } + return new OpenLayers.Feature.Vector( + new OpenLayers.Geometry.MultiLineString(components) + ); + }, + + /** + * Return a polygon feature given a polygon WKT fragment. + * @param {String} str A WKT fragment representing the polygon + * @returns {OpenLayers.Feature.Vector} A polygon feature + * @private + */ + 'polygon': function(str) { + var ring, linestring, linearring; + var rings = OpenLayers.String.trim(str).split(this.regExes.parenComma); + var components = []; + 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]).geometry; + linearring = new OpenLayers.Geometry.LinearRing(linestring.components); + components.push(linearring); + } + return new OpenLayers.Feature.Vector( + new OpenLayers.Geometry.Polygon(components) + ); + }, + + /** + * Return a multipolygon feature given a multipolygon WKT fragment. + * @param {String} str A WKT fragment representing the multipolygon + * @returns {OpenLayers.Feature.Vector} A multipolygon feature + * @private + */ + 'multipolygon': function(str) { + var polygon; + var polygons = OpenLayers.String.trim(str).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]).geometry); + } + return new OpenLayers.Feature.Vector( + new OpenLayers.Geometry.MultiPolygon(components) + ); + }, + + /** + * Return an array of features given a geometrycollection WKT fragment. + * @param {String} str A WKT fragment representing the geometrycollection + * @returns {Array} An array of OpenLayers.Feature.Vector + * @private + */ + 'geometrycollection': function(str) { + // separate components of the collection with | + str = str.replace(/,\s*([A-Za-z])/g, '|$1'); + var wktArray = OpenLayers.String.trim(str).split('|'); + var components = []; + for(var i=0, len=wktArray.length; i<len; ++i) { + components.push(OpenLayers.Format.WKT.prototype.read.apply(this,[wktArray[i]])); + } + return components; + } + + }, + + CLASS_NAME: "OpenLayers.Format.WKT" +}); |