import buildModuleUrl from '../Core/buildModuleUrl.js';
|
import Check from '../Core/Check.js';
|
import Credit from '../Core/Credit.js';
|
import defaultValue from '../Core/defaultValue.js';
|
import defined from '../Core/defined.js';
|
import DeveloperError from '../Core/DeveloperError.js';
|
import Event from '../Core/Event.js';
|
import GeographicTilingScheme from '../Core/GeographicTilingScheme.js';
|
import Rectangle from '../Core/Rectangle.js';
|
import Resource from '../Core/Resource.js';
|
import RuntimeError from '../Core/RuntimeError.js';
|
import TileProviderError from '../Core/TileProviderError.js';
|
import WebMercatorTilingScheme from '../Core/WebMercatorTilingScheme.js';
|
import when from '../ThirdParty/when.js';
|
import ImageryProvider from './ImageryProvider.js';
|
|
/**
|
* Provides tiled imagery using the Google Earth Imagery API.
|
*
|
* Notes: This imagery provider does not work with the public Google Earth servers. It works with the
|
* Google Earth Enterprise Server.
|
*
|
* By default the Google Earth Enterprise server does not set the
|
* {@link http://www.w3.org/TR/cors/|Cross-Origin Resource Sharing} headers. You can either
|
* use a proxy server which adds these headers, or in the /opt/google/gehttpd/conf/gehttpd.conf
|
* and add the 'Header set Access-Control-Allow-Origin "*"' option to the '<Directory />' and
|
* '<Directory "/opt/google/gehttpd/htdocs">' directives.
|
*
|
* This provider is for use with 2D Maps API as part of Google Earth Enterprise. For 3D Earth API uses, it
|
* is necessary to use {@link GoogleEarthEnterpriseImageryProvider}
|
*
|
* @alias GoogleEarthEnterpriseMapsProvider
|
* @constructor
|
*
|
* @param {Object} options Object with the following properties:
|
* @param {Resource|String} options.url The url of the Google Earth server hosting the imagery.
|
* @param {Number} options.channel The channel (id) to be used when requesting data from the server.
|
* The channel number can be found by looking at the json file located at:
|
* earth.localdomain/default_map/query?request=Json&vars=geeServerDefs The /default_map path may
|
* differ depending on your Google Earth Enterprise server configuration. Look for the "id" that
|
* is associated with a "ImageryMaps" requestType. There may be more than one id available.
|
* Example:
|
* {
|
* layers: [
|
* {
|
* id: 1002,
|
* requestType: "ImageryMaps"
|
* },
|
* {
|
* id: 1007,
|
* requestType: "VectorMapsRaster"
|
* }
|
* ]
|
* }
|
* @param {String} [options.path="/default_map"] The path of the Google Earth server hosting the imagery.
|
* @param {Number} [options.maximumLevel] The maximum level-of-detail supported by the Google Earth
|
* Enterprise server, or undefined if there is no limit.
|
* @param {TileDiscardPolicy} [options.tileDiscardPolicy] The policy that determines if a tile
|
* is invalid and should be discarded. To ensure that no tiles are discarded, construct and pass
|
* a {@link NeverTileDiscardPolicy} for this parameter.
|
* @param {Ellipsoid} [options.ellipsoid] The ellipsoid. If not specified, the WGS84 ellipsoid is used.
|
*
|
* @exception {RuntimeError} Could not find layer with channel (id) of <code>options.channel</code>.
|
* @exception {RuntimeError} Could not find a version in channel (id) <code>options.channel</code>.
|
* @exception {RuntimeError} Unsupported projection <code>data.projection</code>.
|
*
|
* @see ArcGisMapServerImageryProvider
|
* @see BingMapsImageryProvider
|
* @see OpenStreetMapImageryProvider
|
* @see SingleTileImageryProvider
|
* @see TileMapServiceImageryProvider
|
* @see WebMapServiceImageryProvider
|
* @see WebMapTileServiceImageryProvider
|
* @see UrlTemplateImageryProvider
|
*
|
*
|
* @example
|
* var google = new Cesium.GoogleEarthEnterpriseMapsProvider({
|
* url : 'https://earth.localdomain',
|
* channel : 1008
|
* });
|
*
|
* @see {@link http://www.w3.org/TR/cors/|Cross-Origin Resource Sharing}
|
*/
|
function GoogleEarthEnterpriseMapsProvider(options) {
|
options = defaultValue(options, {});
|
|
//>>includeStart('debug', pragmas.debug);
|
if (!defined(options.url)) {
|
throw new DeveloperError('options.url is required.');
|
}
|
if (!defined(options.channel)) {
|
throw new DeveloperError('options.channel is required.');
|
}
|
//>>includeEnd('debug');
|
|
var url = options.url;
|
var path = defaultValue(options.path, '/default_map');
|
|
var resource = Resource.createIfNeeded(url).getDerivedResource({
|
// We used to just append path to url, so now that we do proper URI resolution, removed the /
|
url : (path[0] === '/') ? path.substring(1) : path
|
});
|
|
resource.appendForwardSlash();
|
|
this._resource = resource;
|
this._url = url;
|
this._path = path;
|
this._tileDiscardPolicy = options.tileDiscardPolicy;
|
this._channel = options.channel;
|
this._requestType = 'ImageryMaps';
|
this._credit = new Credit('<a href="http://www.google.com/enterprise/mapsearth/products/earthenterprise.html"><img src="' + GoogleEarthEnterpriseMapsProvider.logoUrl + '" title="Google Imagery"/></a>');
|
|
/**
|
* The default {@link ImageryLayer#gamma} to use for imagery layers created for this provider.
|
* By default, this is set to 1.9. Changing this value after creating an {@link ImageryLayer} for this provider will have
|
* no effect. Instead, set the layer's {@link ImageryLayer#gamma} property.
|
*
|
* @type {Number}
|
* @default 1.9
|
*/
|
this.defaultGamma = 1.9;
|
|
this._tilingScheme = undefined;
|
|
this._version = undefined;
|
|
this._tileWidth = 256;
|
this._tileHeight = 256;
|
this._maximumLevel = options.maximumLevel;
|
|
this._errorEvent = new Event();
|
|
this._ready = false;
|
this._readyPromise = when.defer();
|
|
var metadataResource = resource.getDerivedResource({
|
url: 'query',
|
queryParameters: {
|
request: 'Json',
|
vars: 'geeServerDefs',
|
is2d: 't'
|
}
|
});
|
var that = this;
|
var metadataError;
|
|
function metadataSuccess(text) {
|
var data;
|
|
// The Google Earth server sends malformed JSON data currently...
|
try {
|
// First, try parsing it like normal in case a future version sends correctly formatted JSON
|
data = JSON.parse(text);
|
} catch (e) {
|
// Quote object strings manually, then try parsing again
|
data = JSON.parse(text.replace(/([\[\{,])[\n\r ]*([A-Za-z0-9]+)[\n\r ]*:/g, '$1"$2":'));
|
}
|
|
var layer;
|
for (var i = 0; i < data.layers.length; i++) {
|
if (data.layers[i].id === that._channel) {
|
layer = data.layers[i];
|
break;
|
}
|
}
|
|
var message;
|
|
if (!defined(layer)) {
|
message = 'Could not find layer with channel (id) of ' + that._channel + '.';
|
metadataError = TileProviderError.handleError(metadataError, that, that._errorEvent, message, undefined, undefined, undefined, requestMetadata);
|
throw new RuntimeError(message);
|
}
|
|
if (!defined(layer.version)) {
|
message = 'Could not find a version in channel (id) ' + that._channel + '.';
|
metadataError = TileProviderError.handleError(metadataError, that, that._errorEvent, message, undefined, undefined, undefined, requestMetadata);
|
throw new RuntimeError(message);
|
}
|
that._version = layer.version;
|
|
if (defined(data.projection) && data.projection === 'flat') {
|
that._tilingScheme = new GeographicTilingScheme({
|
numberOfLevelZeroTilesX : 2,
|
numberOfLevelZeroTilesY : 2,
|
rectangle : new Rectangle(-Math.PI, -Math.PI, Math.PI, Math.PI),
|
ellipsoid : options.ellipsoid
|
});
|
// Default to mercator projection when projection is undefined
|
} else if (!defined(data.projection) || data.projection === 'mercator') {
|
that._tilingScheme = new WebMercatorTilingScheme({
|
numberOfLevelZeroTilesX : 2,
|
numberOfLevelZeroTilesY : 2,
|
ellipsoid : options.ellipsoid
|
});
|
} else {
|
message = 'Unsupported projection ' + data.projection + '.';
|
metadataError = TileProviderError.handleError(metadataError, that, that._errorEvent, message, undefined, undefined, undefined, requestMetadata);
|
throw new RuntimeError(message);
|
}
|
|
that._ready = true;
|
that._readyPromise.resolve(true);
|
TileProviderError.handleSuccess(metadataError);
|
}
|
|
function metadataFailure(e) {
|
var message = 'An error occurred while accessing ' + metadataResource.url + '.';
|
metadataError = TileProviderError.handleError(metadataError, that, that._errorEvent, message, undefined, undefined, undefined, requestMetadata);
|
that._readyPromise.reject(new RuntimeError(message));
|
}
|
|
function requestMetadata() {
|
var metadata = metadataResource.fetchText();
|
when(metadata, metadataSuccess, metadataFailure);
|
}
|
|
requestMetadata();
|
}
|
|
Object.defineProperties(GoogleEarthEnterpriseMapsProvider.prototype, {
|
/**
|
* Gets the URL of the Google Earth MapServer.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {String}
|
* @readonly
|
*/
|
url : {
|
get : function() {
|
return this._url;
|
}
|
},
|
|
/**
|
* Gets the url path of the data on the Google Earth server.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {String}
|
* @readonly
|
*/
|
path : {
|
get : function() {
|
return this._path;
|
}
|
},
|
|
/**
|
* Gets the proxy used by this provider.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Proxy}
|
* @readonly
|
*/
|
proxy : {
|
get : function() {
|
return this._resource.proxy;
|
}
|
},
|
|
/**
|
* Gets the imagery channel (id) currently being used.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Number}
|
* @readonly
|
*/
|
channel : {
|
get : function() {
|
return this._channel;
|
}
|
},
|
|
/**
|
* Gets the width of each tile, in pixels. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.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 GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.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 GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.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 GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.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 0;
|
}
|
},
|
|
/**
|
* Gets the tiling scheme used by this provider. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.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 version of the data used by this provider. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Number}
|
* @readonly
|
*/
|
version : {
|
get : function() {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError('version must not be called before the imagery provider is ready.');
|
}
|
//>>includeEnd('debug');
|
|
return this._version;
|
}
|
},
|
|
/**
|
* Gets the type of data that is being requested from the provider. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {String}
|
* @readonly
|
*/
|
requestType : {
|
get : function() {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError('requestType must not be called before the imagery provider is ready.');
|
}
|
//>>includeEnd('debug');
|
|
return this._requestType;
|
}
|
},
|
/**
|
* Gets the rectangle, in radians, of the imagery provided by this instance. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Rectangle}
|
* @readonly
|
*/
|
rectangle : {
|
get : function() {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError('rectangle must not be called before the imagery provider is ready.');
|
}
|
//>>includeEnd('debug');
|
|
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 GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.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 this._tileDiscardPolicy;
|
}
|
},
|
|
/**
|
* 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 GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Event}
|
* @readonly
|
*/
|
errorEvent : {
|
get : function() {
|
return this._errorEvent;
|
}
|
},
|
|
/**
|
* Gets a value indicating whether or not the provider is ready for use.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Boolean}
|
* @readonly
|
*/
|
ready : {
|
get : function() {
|
return this._ready;
|
}
|
},
|
|
/**
|
* Gets a promise that resolves to true when the provider is ready for use.
|
* @memberof GoogleEarthEnterpriseMapsProvider.prototype
|
* @type {Promise.<Boolean>}
|
* @readonly
|
*/
|
readyPromise : {
|
get : function() {
|
return this._readyPromise.promise;
|
}
|
},
|
|
/**
|
* 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 GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
* @memberof GoogleEarthEnterpriseMapsProvider.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 GoogleEarthEnterpriseMapsProvider.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.
|
*/
|
GoogleEarthEnterpriseMapsProvider.prototype.getTileCredits = function(x, y, level) {
|
return undefined;
|
};
|
|
/**
|
* Requests the image for a given tile. This function should
|
* not be called before {@link GoogleEarthEnterpriseMapsProvider#ready} returns true.
|
*
|
* @param {Number} x The tile X coordinate.
|
* @param {Number} y The tile Y coordinate.
|
* @param {Number} level The tile level.
|
* @param {Request} [request] The request object. Intended for internal use only.
|
* @returns {Promise.<Image|Canvas>|undefined} 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.
|
*/
|
GoogleEarthEnterpriseMapsProvider.prototype.requestImage = function(x, y, level, request) {
|
//>>includeStart('debug', pragmas.debug);
|
if (!this._ready) {
|
throw new DeveloperError('requestImage must not be called before the imagery provider is ready.');
|
}
|
//>>includeEnd('debug');
|
|
var resource = this._resource.getDerivedResource({
|
url: 'query',
|
request: request,
|
queryParameters: {
|
request: this._requestType,
|
channel: this._channel,
|
version: this._version,
|
x: x,
|
y: y,
|
z: level + 1 // Google Earth starts with a zoom level of 1, not 0
|
}
|
});
|
|
return ImageryProvider.loadImage(this, resource);
|
};
|
|
/**
|
* 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.<ImageryLayerFeatureInfo[]>|undefined} 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.
|
*/
|
GoogleEarthEnterpriseMapsProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
|
return undefined;
|
};
|
|
GoogleEarthEnterpriseMapsProvider._logoUrl = undefined;
|
|
Object.defineProperties(GoogleEarthEnterpriseMapsProvider, {
|
/**
|
* Gets or sets the URL to the Google Earth logo for display in the credit.
|
* @memberof GoogleEarthEnterpriseMapsProvider
|
* @type {String}
|
*/
|
logoUrl: {
|
get: function() {
|
if (!defined(GoogleEarthEnterpriseMapsProvider._logoUrl)) {
|
GoogleEarthEnterpriseMapsProvider._logoUrl = buildModuleUrl('Assets/Images/google_earth_credit.png');
|
}
|
return GoogleEarthEnterpriseMapsProvider._logoUrl;
|
},
|
set: function(value) {
|
//>>includeStart('debug', pragmas.debug);
|
Check.defined('value', value);
|
//>>includeEnd('debug');
|
|
GoogleEarthEnterpriseMapsProvider._logoUrl = value;
|
}
|
}
|
});
|
export default GoogleEarthEnterpriseMapsProvider;
|
