dd0b86b6d9
git-svn-id: http://svn.openlayers.org/tags/openlayers/release-2.5-rc1@4347 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
331 lines
12 KiB
JavaScript
331 lines
12 KiB
JavaScript
/* Copyright (c) 2006-2007 MetaCarta, Inc., published under the BSD license.
|
|
* See http://svn.openlayers.org/trunk/openlayers/release-license.txt
|
|
* for the full text of the license. */
|
|
|
|
/**
|
|
* @requires OpenLayers/Format.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]);
|
|
},
|
|
|
|
/**
|
|
* Method: read
|
|
* Deserialize a WKT string and return an OpenLayers.Feature.Vector or an
|
|
* array of OpenLayers.Feature.Vector. 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;
|
|
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]);
|
|
}
|
|
}
|
|
return features;
|
|
},
|
|
|
|
/**
|
|
* Method: 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, type, data, 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; i<collection.length; ++i) {
|
|
if(isCollection && i>0) {
|
|
pieces.push(',');
|
|
}
|
|
geometry = collection[i].geometry;
|
|
type = geometry.CLASS_NAME.split('.')[2].toLowerCase();
|
|
if(!this.extract[type]) {
|
|
return null;
|
|
}
|
|
data = this.extract[type].apply(this, [geometry]);
|
|
pieces.push(type.toUpperCase() + '(' + data + ')');
|
|
}
|
|
if(isCollection) {
|
|
pieces.push(')');
|
|
}
|
|
return pieces.join('');
|
|
},
|
|
|
|
/**
|
|
* 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; i<multipoint.components.length; ++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; i<linestring.components.length; ++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; i<multilinestring.components.length; ++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; i<polygon.components.length; ++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 {Array} An array of polygon arrays representing
|
|
* the multipolygon
|
|
*/
|
|
'multipolygon': function(multipolygon) {
|
|
var array = [];
|
|
for(var i=0; i<multipolygon.components.length; ++i) {
|
|
array.push('(' +
|
|
this.extract.polygon.apply(this, [multipolygon.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} A WKT fragment representing the multipoint
|
|
* @returns {<OpenLayers.Feature.Vector>} A multipoint feature
|
|
* @private
|
|
*/
|
|
'multipoint': function(str) {
|
|
var points = OpenLayers.String.trim(str).split(',');
|
|
var components = [];
|
|
for(var i=0; i<points.length; ++i) {
|
|
components.push(this.parse.point.apply(this, [points[i]]).geometry);
|
|
}
|
|
return new OpenLayers.Feature.Vector(
|
|
new OpenLayers.Geometry.MultiPoint(components)
|
|
);
|
|
},
|
|
|
|
/**
|
|
* Return a linestring feature given a linestring WKT fragment.
|
|
* @param {String} 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; i<points.length; ++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} 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; i<lines.length; ++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} 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; i<rings.length; ++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} 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; i<polygons.length; ++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} 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; i<wktArray.length; ++i) {
|
|
components.push(OpenLayers.Format.WKT.prototype.read.apply(this,[wktArray[i]]));
|
|
}
|
|
return components;
|
|
}
|
|
|
|
},
|
|
|
|
CLASS_NAME: "OpenLayers.Format.WKT"
|
|
});
|