| Server IP : www.kowitt.ac.th / Your IP : 216.73.216.118 Web Server : Microsoft-IIS/7.5 System : Windows NT SERVER02 6.1 build 7601 (Windows Server 2008 R2 Standard Edition Service Pack 1) i586 User : IUSR ( 0) PHP Version : 5.6.31 Disable Function : NONE MySQL : ON | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : C:/BK/wwwroot/phpMyAdmin/js/openlayers/src/openlayers/lib/OpenLayers/Format/ |
Upload File : |
/* 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/XML.js
* @requires OpenLayers/Feature/Vector.js
* @requires OpenLayers/Geometry/Point.js
* @requires OpenLayers/Geometry/LineString.js
* @requires OpenLayers/Projection.js
*/
/**
* Class: OpenLayers.Format.GPX
* Read/write GPX parser. Create a new instance with the
* <OpenLayers.Format.GPX> constructor.
*
* Inherits from:
* - <OpenLayers.Format.XML>
*/
OpenLayers.Format.GPX = OpenLayers.Class(OpenLayers.Format.XML, {
/**
* APIProperty: defaultDesc
* {String} Default description for the waypoints/tracks in the case
* where the feature has no "description" attribute.
* Default is "No description available".
*/
defaultDesc: "No description available",
/**
* APIProperty: extractWaypoints
* {Boolean} Extract waypoints from GPX. (default: true)
*/
extractWaypoints: true,
/**
* APIProperty: extractTracks
* {Boolean} Extract tracks from GPX. (default: true)
*/
extractTracks: true,
/**
* APIProperty: extractRoutes
* {Boolean} Extract routes from GPX. (default: true)
*/
extractRoutes: true,
/**
* APIProperty: extractAttributes
* {Boolean} Extract feature attributes from GPX. (default: true)
* NOTE: Attributes as part of extensions to the GPX standard may not
* be extracted.
*/
extractAttributes: true,
/**
* Property: namespaces
* {Object} Mapping of namespace aliases to namespace URIs.
*/
namespaces: {
gpx: "http://www.topografix.com/GPX/1/1",
xsi: "http://www.w3.org/2001/XMLSchema-instance"
},
/**
* Property: schemaLocation
* {String} Schema location. Defaults to
* "http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd"
*/
schemaLocation: "http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd",
/**
* APIProperty: creator
* {String} The creator attribute to be added to the written GPX files.
* Defaults to "OpenLayers"
*/
creator: "OpenLayers",
/**
* Constructor: OpenLayers.Format.GPX
* Create a new parser for GPX.
*
* Parameters:
* options - {Object} An optional object whose properties will be set on
* this instance.
*/
initialize: function(options) {
// GPX coordinates are always in longlat WGS84
this.externalProjection = new OpenLayers.Projection("EPSG:4326");
OpenLayers.Format.XML.prototype.initialize.apply(this, [options]);
},
/**
* APIMethod: read
* Return a list of features from a GPX doc
*
* Parameters:
* doc - {Element}
*
* Returns:
* Array({<OpenLayers.Feature.Vector>})
*/
read: function(doc) {
if (typeof doc == "string") {
doc = OpenLayers.Format.XML.prototype.read.apply(this, [doc]);
}
var features = [];
if(this.extractTracks) {
var tracks = doc.getElementsByTagName("trk");
for (var i=0, len=tracks.length; i<len; i++) {
// Attributes are only in trk nodes, not trkseg nodes
var attrs = {};
if(this.extractAttributes) {
attrs = this.parseAttributes(tracks[i]);
}
var segs = this.getElementsByTagNameNS(tracks[i], tracks[i].namespaceURI, "trkseg");
for (var j = 0, seglen = segs.length; j < seglen; j++) {
// We don't yet support extraction of trkpt attributes
// All trksegs of a trk get that trk's attributes
var track = this.extractSegment(segs[j], "trkpt");
features.push(new OpenLayers.Feature.Vector(track, attrs));
}
}
}
if(this.extractRoutes) {
var routes = doc.getElementsByTagName("rte");
for (var k=0, klen=routes.length; k<klen; k++) {
var attrs = {};
if(this.extractAttributes) {
attrs = this.parseAttributes(routes[k]);
}
var route = this.extractSegment(routes[k], "rtept");
features.push(new OpenLayers.Feature.Vector(route, attrs));
}
}
if(this.extractWaypoints) {
var waypoints = doc.getElementsByTagName("wpt");
for (var l = 0, len = waypoints.length; l < len; l++) {
var attrs = {};
if(this.extractAttributes) {
attrs = this.parseAttributes(waypoints[l]);
}
var wpt = new OpenLayers.Geometry.Point(waypoints[l].getAttribute("lon"), waypoints[l].getAttribute("lat"));
features.push(new OpenLayers.Feature.Vector(wpt, attrs));
}
}
if (this.internalProjection && this.externalProjection) {
for (var g = 0, featLength = features.length; g < featLength; g++) {
features[g].geometry.transform(this.externalProjection,
this.internalProjection);
}
}
return features;
},
/**
* Method: extractSegment
*
* Parameters:
* segment - {DOMElement} a trkseg or rte node to parse
* segmentType - {String} nodeName of waypoints that form the line
*
* Returns:
* {<OpenLayers.Geometry.LineString>} A linestring geometry
*/
extractSegment: function(segment, segmentType) {
var points = this.getElementsByTagNameNS(segment, segment.namespaceURI, segmentType);
var point_features = [];
for (var i = 0, len = points.length; i < len; i++) {
point_features.push(new OpenLayers.Geometry.Point(points[i].getAttribute("lon"), points[i].getAttribute("lat")));
}
return new OpenLayers.Geometry.LineString(point_features);
},
/**
* Method: parseAttributes
*
* Parameters:
* node - {<DOMElement>}
*
* Returns:
* {Object} An attributes object.
*/
parseAttributes: function(node) {
// node is either a wpt, trk or rte
// attributes are children of the form <attr>value</attr>
var attributes = {};
var attrNode = node.firstChild, value, name;
while(attrNode) {
if(attrNode.nodeType == 1 && attrNode.firstChild) {
value = attrNode.firstChild;
if(value.nodeType == 3 || value.nodeType == 4) {
name = (attrNode.prefix) ?
attrNode.nodeName.split(":")[1] :
attrNode.nodeName;
if(name != "trkseg" && name != "rtept") {
attributes[name] = value.nodeValue;
}
}
}
attrNode = attrNode.nextSibling;
}
return attributes;
},
/**
* APIMethod: write
* Accepts Feature Collection, and returns a string.
*
* Parameters:
* features - {Array(<OpenLayers.Feature.Vector>)} List of features to serialize into a string.
* metadata - {Object} A key/value pairs object to build a metadata node to
* add to the gpx. Supported keys are 'name', 'desc', 'author'.
*/
write: function(features, metadata) {
features = OpenLayers.Util.isArray(features) ?
features : [features];
var gpx = this.createElementNS(this.namespaces.gpx, "gpx");
gpx.setAttribute("version", "1.1");
gpx.setAttribute("creator", this.creator);
this.setAttributes(gpx, {
"xsi:schemaLocation": this.schemaLocation
});
if (metadata && typeof metadata == 'object') {
gpx.appendChild(this.buildMetadataNode(metadata));
}
for(var i=0, len=features.length; i<len; i++) {
gpx.appendChild(this.buildFeatureNode(features[i]));
}
return OpenLayers.Format.XML.prototype.write.apply(this, [gpx]);
},
/**
* Method: buildMetadataNode
* Creates a "metadata" node.
*
* Returns:
* {DOMElement}
*/
buildMetadataNode: function(metadata) {
var types = ['name', 'desc', 'author'],
node = this.createElementNS(this.namespaces.gpx, 'metadata');
for (var i=0; i < types.length; i++) {
var type = types[i];
if (metadata[type]) {
var n = this.createElementNS(this.namespaces.gpx, type);
n.appendChild(this.createTextNode(metadata[type]));
node.appendChild(n);
}
}
return node;
},
/**
* Method: buildFeatureNode
* Accepts an <OpenLayers.Feature.Vector>, and builds a node for it.
*
* Parameters:
* feature - {<OpenLayers.Feature.Vector>}
*
* Returns:
* {DOMElement} - The created node, either a 'wpt' or a 'trk'.
*/
buildFeatureNode: function(feature) {
var geometry = feature.geometry;
geometry = geometry.clone();
if (this.internalProjection && this.externalProjection) {
geometry.transform(this.internalProjection,
this.externalProjection);
}
if (geometry.CLASS_NAME == "OpenLayers.Geometry.Point") {
var wpt = this.buildWptNode(geometry);
this.appendAttributesNode(wpt, feature);
return wpt;
} else {
var trkNode = this.createElementNS(this.namespaces.gpx, "trk");
this.appendAttributesNode(trkNode, feature);
var trkSegNodes = this.buildTrkSegNode(geometry);
trkSegNodes = OpenLayers.Util.isArray(trkSegNodes) ?
trkSegNodes : [trkSegNodes];
for (var i = 0, len = trkSegNodes.length; i < len; i++) {
trkNode.appendChild(trkSegNodes[i]);
}
return trkNode;
}
},
/**
* Method: buildTrkSegNode
* Builds trkseg node(s) given a geometry
*
* Parameters:
* trknode
* geometry - {<OpenLayers.Geometry>}
*/
buildTrkSegNode: function(geometry) {
var node,
i,
len,
point,
nodes;
if (geometry.CLASS_NAME == "OpenLayers.Geometry.LineString" ||
geometry.CLASS_NAME == "OpenLayers.Geometry.LinearRing") {
node = this.createElementNS(this.namespaces.gpx, "trkseg");
for (i = 0, len=geometry.components.length; i < len; i++) {
point = geometry.components[i];
node.appendChild(this.buildTrkPtNode(point));
}
return node;
} else {
nodes = [];
for (i = 0, len = geometry.components.length; i < len; i++) {
nodes.push(this.buildTrkSegNode(geometry.components[i]));
}
return nodes;
}
},
/**
* Method: buildTrkPtNode
* Builds a trkpt node given a point
*
* Parameters:
* point - {<OpenLayers.Geometry.Point>}
*
* Returns:
* {DOMElement} A trkpt node
*/
buildTrkPtNode: function(point) {
var node = this.createElementNS(this.namespaces.gpx, "trkpt");
node.setAttribute("lon", point.x);
node.setAttribute("lat", point.y);
return node;
},
/**
* Method: buildWptNode
* Builds a wpt node given a point
*
* Parameters:
* geometry - {<OpenLayers.Geometry.Point>}
*
* Returns:
* {DOMElement} A wpt node
*/
buildWptNode: function(geometry) {
var node = this.createElementNS(this.namespaces.gpx, "wpt");
node.setAttribute("lon", geometry.x);
node.setAttribute("lat", geometry.y);
return node;
},
/**
* Method: appendAttributesNode
* Adds some attributes node.
*
* Parameters:
* node - {DOMElement} the node to append the attribute nodes to.
* feature - {<OpenLayers.Feature.Vector>}
*/
appendAttributesNode: function(node, feature) {
var name = this.createElementNS(this.namespaces.gpx, 'name');
name.appendChild(this.createTextNode(
feature.attributes.name || feature.id));
node.appendChild(name);
var desc = this.createElementNS(this.namespaces.gpx, 'desc');
desc.appendChild(this.createTextNode(
feature.attributes.description || this.defaultDesc));
node.appendChild(desc);
// TBD - deal with remaining (non name/description) attributes.
},
CLASS_NAME: "OpenLayers.Format.GPX"
});