366 lines
8.9 KiB
JavaScript
366 lines
8.9 KiB
JavaScript
goog.provide('ol.source.TileUTFGrid');
|
|
|
|
goog.require('goog.asserts');
|
|
goog.require('goog.events');
|
|
goog.require('goog.events.EventType');
|
|
goog.require('goog.net.Jsonp');
|
|
goog.require('ol.Attribution');
|
|
goog.require('ol.Tile');
|
|
goog.require('ol.TileCache');
|
|
goog.require('ol.TileState');
|
|
goog.require('ol.TileUrlFunction');
|
|
goog.require('ol.extent');
|
|
goog.require('ol.proj');
|
|
goog.require('ol.source.State');
|
|
goog.require('ol.source.Tile');
|
|
goog.require('ol.tilegrid.XYZ');
|
|
|
|
|
|
|
|
/**
|
|
* @classdesc
|
|
* Layer source for UTFGrid interaction data loaded from TileJSON format.
|
|
*
|
|
* @constructor
|
|
* @extends {ol.source.Tile}
|
|
* @param {olx.source.TileUTFGridOptions} options Source options.
|
|
* @api
|
|
*/
|
|
ol.source.TileUTFGrid = function(options) {
|
|
goog.base(this, {
|
|
projection: ol.proj.get('EPSG:3857'),
|
|
state: ol.source.State.LOADING
|
|
});
|
|
|
|
/**
|
|
* @private
|
|
* @type {boolean}
|
|
*/
|
|
this.preemptive_ = goog.isDef(options.preemptive) ?
|
|
options.preemptive : false;
|
|
|
|
/**
|
|
* @protected
|
|
* @type {ol.TileUrlFunctionType}
|
|
*/
|
|
this.tileUrlFunction = ol.TileUrlFunction.nullTileUrlFunction;
|
|
|
|
/**
|
|
* @protected
|
|
* @type {ol.TileCache}
|
|
*/
|
|
this.tileCache = new ol.TileCache();
|
|
|
|
var request = new goog.net.Jsonp(options.url);
|
|
request.send(undefined, goog.bind(this.handleTileJSONResponse, this));
|
|
};
|
|
goog.inherits(ol.source.TileUTFGrid, ol.source.Tile);
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
ol.source.TileUTFGrid.prototype.canExpireCache = function() {
|
|
return this.tileCache.canExpireCache();
|
|
};
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
ol.source.TileUTFGrid.prototype.expireCache = function(usedTiles) {
|
|
this.tileCache.expireCache(usedTiles);
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {ol.Coordinate} coordinate Coordinate.
|
|
* @param {number} resolution Resolution.
|
|
* @param {function(this: T, (Object|undefined))} f Callback.
|
|
* @param {T=} opt_this The object to use as `this` in `f`.
|
|
* @param {boolean=} opt_noRequest Only process already loaded data.
|
|
* @template T
|
|
* @api
|
|
*/
|
|
ol.source.TileUTFGrid.prototype.forDataAtCoordinateAndResolution = function(
|
|
coordinate, resolution, f, opt_this, opt_noRequest) {
|
|
if (!goog.isNull(this.tileGrid)) {
|
|
var tileCoord = this.tileGrid.getTileCoordForCoordAndResolution(
|
|
coordinate, resolution);
|
|
var tile = /** @type {!ol.source.TileUTFGridTile_} */(this.getTile(
|
|
tileCoord[0], tileCoord[1], tileCoord[2], 1, this.getProjection()));
|
|
tile.forDataAtCoordinate(coordinate, f, opt_this, opt_noRequest);
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* TODO: very similar to ol.source.TileJSON#handleTileJSONResponse
|
|
* @protected
|
|
* @param {TileJSON} tileJSON Tile JSON.
|
|
*/
|
|
ol.source.TileUTFGrid.prototype.handleTileJSONResponse = function(tileJSON) {
|
|
|
|
var epsg4326Projection = ol.proj.get('EPSG:4326');
|
|
|
|
var sourceProjection = this.getProjection();
|
|
var extent;
|
|
if (goog.isDef(tileJSON.bounds)) {
|
|
var transform = ol.proj.getTransformFromProjections(
|
|
epsg4326Projection, sourceProjection);
|
|
extent = ol.extent.applyTransform(tileJSON.bounds, transform);
|
|
}
|
|
|
|
if (goog.isDef(tileJSON.scheme)) {
|
|
goog.asserts.assert(tileJSON.scheme == 'xyz');
|
|
}
|
|
var minZoom = tileJSON.minzoom || 0;
|
|
var maxZoom = tileJSON.maxzoom || 22;
|
|
var tileGrid = new ol.tilegrid.XYZ({
|
|
extent: ol.tilegrid.extentFromProjection(sourceProjection),
|
|
maxZoom: maxZoom,
|
|
minZoom: minZoom
|
|
});
|
|
this.tileGrid = tileGrid;
|
|
|
|
var grids = tileJSON.grids;
|
|
if (!goog.isDefAndNotNull(grids)) {
|
|
this.setState(ol.source.State.ERROR);
|
|
return;
|
|
}
|
|
|
|
this.tileUrlFunction = ol.TileUrlFunction.withTileCoordTransform(
|
|
tileGrid.createTileCoordTransform({
|
|
extent: extent
|
|
}),
|
|
ol.TileUrlFunction.createFromTemplates(grids));
|
|
|
|
if (goog.isDef(tileJSON.attribution)) {
|
|
var attributionExtent = goog.isDef(extent) ?
|
|
extent : epsg4326Projection.getExtent();
|
|
/** @type {Object.<string, Array.<ol.TileRange>>} */
|
|
var tileRanges = {};
|
|
var z, zKey;
|
|
for (z = minZoom; z <= maxZoom; ++z) {
|
|
zKey = z.toString();
|
|
tileRanges[zKey] =
|
|
[tileGrid.getTileRangeForExtentAndZ(attributionExtent, z)];
|
|
}
|
|
this.setAttributions([
|
|
new ol.Attribution({
|
|
html: tileJSON.attribution,
|
|
tileRanges: tileRanges
|
|
})
|
|
]);
|
|
}
|
|
|
|
this.setState(ol.source.State.READY);
|
|
|
|
};
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
ol.source.TileUTFGrid.prototype.getTile =
|
|
function(z, x, y, pixelRatio, projection) {
|
|
var tileCoordKey = this.getKeyZXY(z, x, y);
|
|
if (this.tileCache.containsKey(tileCoordKey)) {
|
|
return /** @type {!ol.Tile} */ (this.tileCache.get(tileCoordKey));
|
|
} else {
|
|
goog.asserts.assert(projection);
|
|
var tileCoord = [z, x, y];
|
|
var tileUrl = this.tileUrlFunction(tileCoord, pixelRatio, projection);
|
|
var tile = new ol.source.TileUTFGridTile_(
|
|
tileCoord,
|
|
goog.isDef(tileUrl) ? ol.TileState.IDLE : ol.TileState.EMPTY,
|
|
goog.isDef(tileUrl) ? tileUrl : '',
|
|
this.tileGrid.getTileCoordExtent(tileCoord),
|
|
this.preemptive_);
|
|
this.tileCache.set(tileCoordKey, tile);
|
|
return tile;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
ol.source.TileUTFGrid.prototype.useTile = function(z, x, y) {
|
|
var tileCoordKey = this.getKeyZXY(z, x, y);
|
|
if (this.tileCache.containsKey(tileCoordKey)) {
|
|
this.tileCache.get(tileCoordKey);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
* @constructor
|
|
* @extends {ol.Tile}
|
|
* @param {ol.TileCoord} tileCoord Tile coordinate.
|
|
* @param {ol.TileState} state State.
|
|
* @param {string} src Image source URI.
|
|
* @param {ol.Extent} extent Extent of the tile.
|
|
* @param {boolean} preemptive Load the tile when visible (before it's needed).
|
|
* @private
|
|
*/
|
|
ol.source.TileUTFGridTile_ =
|
|
function(tileCoord, state, src, extent, preemptive) {
|
|
|
|
goog.base(this, tileCoord, state);
|
|
|
|
/**
|
|
* @private
|
|
* @type {string}
|
|
*/
|
|
this.src_ = src;
|
|
|
|
/**
|
|
* @private
|
|
* @type {ol.Extent}
|
|
*/
|
|
this.extent_ = extent;
|
|
|
|
/**
|
|
* @private
|
|
* @type {boolean}
|
|
*/
|
|
this.preemptive_ = preemptive;
|
|
|
|
/**
|
|
* @private
|
|
* @type {?Array.<string>}
|
|
*/
|
|
this.grid_ = null;
|
|
|
|
/**
|
|
* @private
|
|
* @type {?Array.<string>}
|
|
*/
|
|
this.keys_ = null;
|
|
|
|
/**
|
|
* @private
|
|
* @type {?Object.<string, Object>|undefined}
|
|
*/
|
|
this.data_ = null;
|
|
};
|
|
goog.inherits(ol.source.TileUTFGridTile_, ol.Tile);
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
ol.source.TileUTFGridTile_.prototype.getImage = function(opt_context) {
|
|
return null;
|
|
};
|
|
|
|
|
|
/**
|
|
* Synchronously returns data at given coordinate (if available).
|
|
* @param {ol.Coordinate} coordinate Coordinate.
|
|
* @return {Object|undefined}
|
|
*/
|
|
ol.source.TileUTFGridTile_.prototype.getData = function(coordinate) {
|
|
if (goog.isNull(this.grid_) || goog.isNull(this.keys_) ||
|
|
goog.isNull(this.data_)) {
|
|
return undefined;
|
|
}
|
|
var xRelative = (coordinate[0] - this.extent_[0]) /
|
|
(this.extent_[2] - this.extent_[0]);
|
|
var yRelative = (coordinate[1] - this.extent_[1]) /
|
|
(this.extent_[3] - this.extent_[1]);
|
|
|
|
var row = this.grid_[Math.floor((1 - yRelative) * this.grid_.length)];
|
|
|
|
if (!goog.isString(row)) {
|
|
return undefined;
|
|
}
|
|
|
|
var code = row.charCodeAt(Math.floor(xRelative * row.length));
|
|
if (code >= 93) code--;
|
|
if (code >= 35) code--;
|
|
code -= 32;
|
|
|
|
var key = this.keys_[code];
|
|
|
|
return goog.isDefAndNotNull(key) ? this.data_[key] : undefined;
|
|
};
|
|
|
|
|
|
/**
|
|
* Calls `f` when the data for given coordinate is available.
|
|
* @param {ol.Coordinate} coordinate Coordinate.
|
|
* @param {function(this: T, (Object|undefined))} f Callback.
|
|
* @param {T=} opt_this The object to use as `this` in `f`.
|
|
* @param {boolean=} opt_noRequest If not loaded, callback with `undefined`
|
|
* without loading the tile.
|
|
* @template T
|
|
*/
|
|
ol.source.TileUTFGridTile_.prototype.forDataAtCoordinate =
|
|
function(coordinate, f, opt_this, opt_noRequest) {
|
|
if (this.state == ol.TileState.IDLE && opt_noRequest !== true) {
|
|
this.listenOnce(goog.events.EventType.CHANGE, function(e) {
|
|
f.call(opt_this, this.getData(coordinate));
|
|
}, false, this);
|
|
this.loadInternal_();
|
|
} else {
|
|
f.call(opt_this, this.getData(coordinate));
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* @inheritDoc
|
|
*/
|
|
ol.source.TileUTFGridTile_.prototype.getKey = function() {
|
|
return this.src_;
|
|
};
|
|
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
ol.source.TileUTFGridTile_.prototype.handleError_ = function() {
|
|
this.state = ol.TileState.ERROR;
|
|
this.changed();
|
|
};
|
|
|
|
|
|
/**
|
|
* @param {!UTFGridJSON} json
|
|
* @private
|
|
*/
|
|
ol.source.TileUTFGridTile_.prototype.handleLoad_ = function(json) {
|
|
this.grid_ = json.grid;
|
|
this.keys_ = json.keys;
|
|
this.data_ = json.data;
|
|
|
|
this.state = ol.TileState.EMPTY;
|
|
this.changed();
|
|
};
|
|
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
ol.source.TileUTFGridTile_.prototype.loadInternal_ = function() {
|
|
if (this.state == ol.TileState.IDLE) {
|
|
this.state = ol.TileState.LOADING;
|
|
var request = new goog.net.Jsonp(this.src_);
|
|
request.send(undefined, goog.bind(this.handleLoad_, this),
|
|
goog.bind(this.handleError_, this));
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* Load not yet loaded URI.
|
|
*/
|
|
ol.source.TileUTFGridTile_.prototype.load = function() {
|
|
if (this.preemptive_) {
|
|
this.loadInternal_();
|
|
}
|
|
};
|