goog.provide('ol.source.TileUTFGrid');
goog.require('goog.asserts');
goog.require('goog.async.nextTick');
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 : true;
/**
* @private
* @type {!ol.TileUrlFunctionType}
*/
this.tileUrlFunction_ = ol.TileUrlFunction.nullTileUrlFunction;
/**
* @private
* @type {!ol.TileCache}
*/
this.tileCache_ = new ol.TileCache();
/**
* @private
* @type {string|undefined}
*/
this.template_ = undefined;
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);
};
/**
* @return {string|undefined} The template from TileJSON.
* @api
*/
ol.source.TileUTFGrid.prototype.getTemplate = function() {
return this.template_;
};
/**
* Calls the callback (synchronously by default) with the available data
* for given coordinate and resolution (or `null` if not yet loaded or
* in case of an error).
* @param {ol.Coordinate} coordinate Coordinate.
* @param {number} resolution Resolution.
* @param {function(this: T, Object)} callback Callback.
* @param {T=} opt_this The object to use as `this` in the callback.
* @param {boolean=} opt_request If `true` the callback is always async.
* The tile data is requested if not yet loaded.
* @template T
* @api
*/
ol.source.TileUTFGrid.prototype.forDataAtCoordinateAndResolution = function(
coordinate, resolution, callback, opt_this, opt_request) {
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, callback, opt_this, opt_request);
} else {
if (opt_request === true) {
goog.async.nextTick(function() {
callback.call(opt_this, null);
});
} else {
callback.call(opt_this, null);
}
}
};
/**
* 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;
this.template_ = tileJSON.template;
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}
*/
ol.source.TileUTFGridTile_.prototype.getData = function(coordinate) {
if (goog.isNull(this.grid_) || goog.isNull(this.keys_) ||
goog.isNull(this.data_)) {
return null;
}
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 null;
}
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] : null;
};
/**
* Calls the callback (synchronously by default) with the available data
* for given coordinate (or `null` if not yet loaded).
* @param {ol.Coordinate} coordinate Coordinate.
* @param {function(this: T, Object)} callback Callback.
* @param {T=} opt_this The object to use as `this` in the callback.
* @param {boolean=} opt_request If `true` the callback is always async.
* The tile data is requested if not yet loaded.
* @template T
*/
ol.source.TileUTFGridTile_.prototype.forDataAtCoordinate =
function(coordinate, callback, opt_this, opt_request) {
if (this.state == ol.TileState.IDLE && opt_request === true) {
goog.events.listenOnce(this, goog.events.EventType.CHANGE, function(e) {
callback.call(opt_this, this.getData(coordinate));
}, false, this);
this.loadInternal_();
} else {
if (opt_request === true) {
goog.async.nextTick(function() {
callback.call(opt_this, this.getData(coordinate));
}, this);
} else {
callback.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_();
}
};