Last active
August 29, 2015 14:23
-
-
Save theOgrable/f18c06b2f6b233fa6794 to your computer and use it in GitHub Desktop.
MaskedImageryProvider
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/*global define*/ | |
define([ | |
'../Core/Credit', | |
'../Core/defaultValue', | |
'../Core/defined', | |
'../Core/defineProperties', | |
'../Core/DeveloperError', | |
'../Core/Event', | |
'../Core/GeographicTilingScheme', | |
'../Core/loadImage', | |
'../Core/Rectangle', | |
'../Core/TileProviderError', | |
'../ThirdParty/when' | |
], function( | |
Credit, | |
defaultValue, | |
defined, | |
defineProperties, | |
DeveloperError, | |
Event, | |
GeographicTilingScheme, | |
loadImage, | |
Rectangle, | |
TileProviderError, | |
when) { | |
"use strict"; | |
/** | |
* Provides a single, top-level imagery tile. The single image is assumed to use a | |
* {@link GeographicTilingScheme}. | |
* | |
* @alias MaskedImageryProvider | |
* @constructor | |
* | |
* @param {Object} options Object with the following properties: | |
* @param {ImageryProvider} options.sourceProvider The source Imagery Provider. | |
* @param {ImageryProvider} options.destinationProvider The destination Imagery Provider. | |
* @param {String} options.gco global composite operation used for melting the two imagery providers | |
* @param {Rectangle} [options.rectangle=Rectangle.MAX_VALUE] The rectangle, in radians, covered by the image. | |
* @param {Credit|String} [options.credit] A credit for the data source, which is displayed on the canvas. | |
* @param {Object} [options.proxy] A proxy to use for requests. This object is expected to have a getURL function which returns the proxied URL, if needed. | |
* | |
* @see ArcGisMapServerImageryProvider | |
* @see BingMapsImageryProvider | |
* @see GoogleEarthImageryProvider | |
* @see OpenStreetMapImageryProvider | |
* @see TileMapServiceImageryProvider | |
* @see WebMapServiceImageryProvider | |
*/ | |
var MaskedImageryProvider = function(options) { | |
options = defaultValue(options, {}); | |
var sourceProvider = options.sourceProvider; | |
var destinationProvider = options.destinationProvider; | |
//>>includeStart('debug', pragmas.debug); | |
if (!defined(sourceProvider)) { | |
throw new DeveloperError('sourceProvider is required.'); | |
} | |
if (!defined(destinationProvider)) { | |
throw new DeveloperError('destinationProvider is required.'); | |
} | |
//>>includeEnd('debug'); | |
this._sourceProvider = sourceProvider; | |
this._destinationProvider = destinationProvider; | |
var proxy = options.proxy; | |
this._proxy = proxy; | |
var rectangle = defaultValue(options.rectangle, Rectangle.MAX_VALUE); | |
var tilingScheme = new GeographicTilingScheme(); | |
this._tilingScheme = tilingScheme; | |
this._image = undefined; | |
this._texture = undefined; | |
this._tileWidth = defaultValue(options.tileWidth, 256); | |
this._tileHeight = defaultValue(options.tileHeight, 256); | |
this._maximumLevel = 0; | |
this._minimumLevel = 0; | |
this._errorEvent = new Event(); | |
this._gco = defaultValue(options.gco, "source-over"); | |
var credit = options.credit; | |
if (typeof credit === 'string') { | |
credit = new Credit(credit); | |
} | |
this._credit = credit; | |
var that = this; | |
var error; | |
this._ready = false; | |
var isReady = setInterval(function(){ | |
console.log(that._sourceProvider.ready + ' ' + that._destinationProvider.ready); | |
if (that._sourceProvider.ready && that._destinationProvider.ready){ | |
that._maximumLevel = Math.max(that._sourceProvider.maximumLevel, that._destinationProvider.maximumLevel); | |
that._minimumLevel = Math.max(that._sourceProvider.minimumLevel, that._destinationProvider.minimumLevel); | |
that._ready = true; | |
clearInterval(isReady); | |
} | |
}, 1000); | |
}; | |
defineProperties(MaskedImageryProvider.prototype, { | |
/** | |
* Get the source ImageryProvider | |
* @memberof MaskedImageryProvider.prototype | |
* @type {ImageryProvider} | |
* @readonly | |
*/ | |
sourceProvider : { | |
get : function() { | |
return this._sourceProvider; | |
} | |
}, | |
/** | |
* Get the destination ImageryProvider | |
* @memberof MaskedImageryProvider.prototype | |
* @type {ImageryProvider} | |
* @readonly | |
*/ | |
destinationProvider : { | |
get : function() { | |
return this._destinationProvider; | |
} | |
}, | |
/** | |
* Gets the proxy used by this provider. | |
* @memberof MaskedImageryProvider.prototype | |
* @type {Proxy} | |
* @readonly | |
*/ | |
proxy : { | |
get : function() { | |
return this._proxy; | |
} | |
}, | |
/** | |
* Gets the width of each tile, in pixels. This function should | |
* not be called before {@link MaskedImageryProvider#ready} returns true. | |
* @memberof MaskedImageryProvider.prototype | |
* @type {Number} | |
* @readonly | |
*/ | |
tileWidth : { | |
get : function() { | |
//>>includeStart('debug', pragmas.debug); | |
if (!this._ready) { | |
throw new DeveloperError('tileWidth must not be called before the imagery provider is ready.'); | |
} | |
//>>includeEnd('debug'); | |
return this._tileWidth; | |
} | |
}, | |
/** | |
* Gets the height of each tile, in pixels. This function should | |
* not be called before {@link MaskedImageryProvider#ready} returns true. | |
* @memberof MaskedImageryProvider.prototype | |
* @type {Number} | |
* @readonly | |
*/ | |
tileHeight: { | |
get : function() { | |
//>>includeStart('debug', pragmas.debug); | |
if (!this._ready) { | |
throw new DeveloperError('tileHeight must not be called before the imagery provider is ready.'); | |
} | |
//>>includeEnd('debug'); | |
return this._tileHeight; | |
} | |
}, | |
/** | |
* Gets the maximum level-of-detail that can be requested. This function should | |
* not be called before {@link MaskedImageryProvider#ready} returns true. | |
* @memberof MaskedImageryProvider.prototype | |
* @type {Number} | |
* @readonly | |
*/ | |
maximumLevel : { | |
get : function() { | |
//>>includeStart('debug', pragmas.debug); | |
if (!this._ready) { | |
throw new DeveloperError('maximumLevel must not be called before the imagery provider is ready.'); | |
} | |
//>>includeEnd('debug'); | |
return this._maximumLevel; | |
} | |
}, | |
/** | |
* Gets the minimum level-of-detail that can be requested. This function should | |
* not be called before {@link MaskedImageryProvider#ready} returns true. | |
* @memberof MaskedImageryProvider.prototype | |
* @type {Number} | |
* @readonly | |
*/ | |
minimumLevel : { | |
get : function() { | |
//>>includeStart('debug', pragmas.debug); | |
if (!this._ready) { | |
throw new DeveloperError('minimumLevel must not be called before the imagery provider is ready.'); | |
} | |
//>>includeEnd('debug'); | |
return this._minimumLevel; | |
} | |
}, | |
/** | |
* Gets the tiling scheme used by this provider. This function should | |
* not be called before {@link MaskedImageryProvider#ready} returns true. | |
* @memberof MaskedImageryProvider.prototype | |
* @type {TilingScheme} | |
* @readonly | |
*/ | |
tilingScheme : { | |
get : function() { | |
//>>includeStart('debug', pragmas.debug); | |
if (!this._ready) { | |
throw new DeveloperError('tilingScheme must not be called before the imagery provider is ready.'); | |
} | |
//>>includeEnd('debug'); | |
return this._tilingScheme; | |
} | |
}, | |
/** | |
* Gets the rectangle, in radians, of the imagery provided by this instance. This function should | |
* not be called before {@link MaskedImageryProvider#ready} returns true. | |
* @memberof MaskedImageryProvider.prototype | |
* @type {Rectangle} | |
* @readonly | |
*/ | |
rectangle : { | |
get : function() { | |
return this._tilingScheme.rectangle; | |
} | |
}, | |
/** | |
* Gets the tile discard policy. If not undefined, the discard policy is responsible | |
* for filtering out "missing" tiles via its shouldDiscardImage function. If this function | |
* returns undefined, no tiles are filtered. This function should | |
* not be called before {@link MaskedImageryProvider#ready} returns true. | |
* @memberof MaskedImageryProvider.prototype | |
* @type {TileDiscardPolicy} | |
* @readonly | |
*/ | |
tileDiscardPolicy : { | |
get : function() { | |
//>>includeStart('debug', pragmas.debug); | |
if (!this._ready) { | |
throw new DeveloperError('tileDiscardPolicy must not be called before the imagery provider is ready.'); | |
} | |
//>>includeEnd('debug'); | |
return undefined; | |
} | |
}, | |
/** | |
* Gets an event that is raised when the imagery provider encounters an asynchronous error. By subscribing | |
* to the event, you will be notified of the error and can potentially recover from it. Event listeners | |
* are passed an instance of {@link TileProviderError}. | |
* @memberof MaskedImageryProvider.prototype | |
* @type {Event} | |
* @readonly | |
*/ | |
errorEvent : { | |
get : function() { | |
return this._errorEvent; | |
} | |
}, | |
/** | |
* Gets a value indicating whether or not the provider is ready for use. | |
* @memberof MaskedImageryProvider.prototype | |
* @type {Boolean} | |
* @readonly | |
*/ | |
ready : { | |
get : function() { | |
return this._ready; | |
} | |
}, | |
/** | |
* Gets the credit to display when this imagery provider is active. Typically this is used to credit | |
* the source of the imagery. This function should not be called before {@link MaskedImageryProvider#ready} returns true. | |
* @memberof MaskedImageryProvider.prototype | |
* @type {Credit} | |
* @readonly | |
*/ | |
credit : { | |
get : function() { | |
return this._credit; | |
} | |
}, | |
/** | |
* Gets a value indicating whether or not the images provided by this imagery provider | |
* include an alpha channel. If this property is false, an alpha channel, if present, will | |
* be ignored. If this property is true, any images without an alpha channel will be treated | |
* as if their alpha is 1.0 everywhere. When this property is false, memory usage | |
* and texture upload time are reduced. | |
* @memberof MaskedImageryProvider.prototype | |
* @type {Boolean} | |
* @readonly | |
*/ | |
hasAlphaChannel : { | |
get : function() { | |
return true; | |
} | |
} | |
}); | |
/** | |
* Gets the credits to be displayed when a given tile is displayed. | |
* | |
* @param {Number} x The tile X coordinate. | |
* @param {Number} y The tile Y coordinate. | |
* @param {Number} level The tile level; | |
* @returns {Credit[]} The credits to be displayed when the tile is displayed. | |
* | |
* @exception {DeveloperError} <code>getTileCredits</code> must not be called before the imagery provider is ready. | |
*/ | |
MaskedImageryProvider.prototype.getTileCredits = function(x, y, level) { | |
return undefined; | |
}; | |
/** | |
* Requests the image for a given tile. This function should | |
* not be called before {@link MaskedImageryProvider#ready} returns true. | |
* | |
* @param {Number} x The tile X coordinate. | |
* @param {Number} y The tile Y coordinate. | |
* @param {Number} level The tile level. | |
* @returns {Promise} A promise for the image that will resolve when the image is available, or | |
* undefined if there are too many active requests to the server, and the request | |
* should be retried later. The resolved image may be either an | |
* Image or a Canvas DOM object. | |
* | |
* @exception {DeveloperError} <code>requestImage</code> must not be called before the imagery provider is ready. | |
*/ | |
MaskedImageryProvider.prototype.requestImage = function(x, y, level) { | |
//>>includeStart('debug', pragmas.debug); | |
if (!this._ready) { | |
throw new DeveloperError('requestImage must not be called before the imagery provider is ready.'); | |
} | |
//>>includeEnd('debug'); | |
var canvas = document.createElement("canvas"); | |
var img = new Image(); | |
canvas.setAttribute('width',this._tileWidth); | |
canvas.setAttribute('height',this._tileHeight); | |
// var sourcePromise = null; | |
// var destinationPromise = null; | |
// do the hardWork | |
var context = canvas.getContext('2d'); | |
var gco = this._gco; | |
return when.all([this._sourceProvider.requestImage(x,y,level), this._destinationProvider.requestImage(x,y,level)]).then(function(promises) | |
{ | |
if (!defined(promises[0])) | |
console.log('source promise is undefined'); | |
else{ | |
// console.log('drawSource'); | |
context.drawImage(promises[0],0,0); | |
} | |
if (!defined(promises[1])) | |
console.log('destination promise is undefined'); | |
else{ | |
context.globalCompositeOperation = gco; | |
// console.log('drawDestination'); | |
context.drawImage(promises[1],0,0); | |
} | |
return canvas; | |
}).then( | |
function(image){ | |
// console.log('success : ' + image); | |
return image;} | |
, function(error){ | |
console.log('error : ' + error); | |
return canvas;} | |
); // } | |
}; | |
/** | |
* Picking features is not currently supported by this imagery provider, so this function simply returns | |
* undefined. | |
* | |
* @param {Number} x The tile X coordinate. | |
* @param {Number} y The tile Y coordinate. | |
* @param {Number} level The tile level. | |
* @param {Number} longitude The longitude at which to pick features. | |
* @param {Number} latitude The latitude at which to pick features. | |
* @return {Promise} A promise for the picked features that will resolve when the asynchronous | |
* picking completes. The resolved value is an array of {@link ImageryLayerFeatureInfo} | |
* instances. The array may be empty if no features are found at the given location. | |
* It may also be undefined if picking is not supported. | |
*/ | |
MaskedImageryProvider.prototype.pickFeatures = function() { | |
return undefined; | |
}; | |
return MaskedImageryProvider; | |
}); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment