From ca9a0124a3b29e617d2c68f41e13785f9f419784 Mon Sep 17 00:00:00 2001 From: Adam Cole Date: Tue, 1 Dec 2015 06:46:15 -0500 Subject: [PATCH 1/3] createWebMapTileServiceImageryProvider using UrlTemplateImageProvider --- .idea/misc.xml | 13 - .../gallery/Imagery Layers Manipulation.html | 2 +- .../createWebMapTileServiceImageryProvider.js | 172 ++++++++ ...ateWebMapTileServiceImageryProviderSpec.js | 396 ++++++++++++++++++ 4 files changed, 569 insertions(+), 14 deletions(-) delete mode 100644 .idea/misc.xml create mode 100644 Source/Scene/createWebMapTileServiceImageryProvider.js create mode 100644 Specs/Scene/createWebMapTileServiceImageryProviderSpec.js diff --git a/.idea/misc.xml b/.idea/misc.xml deleted file mode 100644 index 72abef0a7321..000000000000 --- a/.idea/misc.xml +++ /dev/null @@ -1,13 +0,0 @@ - - - - - - - - - - - - - \ No newline at end of file diff --git a/Apps/Sandcastle/gallery/Imagery Layers Manipulation.html b/Apps/Sandcastle/gallery/Imagery Layers Manipulation.html index 9dd9f56ab96b..81a26683b2f3 100644 --- a/Apps/Sandcastle/gallery/Imagery Layers Manipulation.html +++ b/Apps/Sandcastle/gallery/Imagery Layers Manipulation.html @@ -144,7 +144,7 @@ })); addBaseLayerOption( 'USGS Shaded Relief (via WMTS)', - new Cesium.WebMapTileServiceImageryProvider({ + Cesium.createWebMapTileServiceImageryProvider({ url : 'http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS', layer : 'USGSShadedReliefOnly', style : 'default', diff --git a/Source/Scene/createWebMapTileServiceImageryProvider.js b/Source/Scene/createWebMapTileServiceImageryProvider.js new file mode 100644 index 000000000000..b5661079c4a6 --- /dev/null +++ b/Source/Scene/createWebMapTileServiceImageryProvider.js @@ -0,0 +1,172 @@ +/*global define*/ +define([ + '../Core/combine', + '../Core/Credit', + '../Core/defaultValue', + '../Core/defined', + '../Core/defineProperties', + '../Core/DeveloperError', + '../Core/Event', + '../Core/freezeObject', + '../Core/objectToQuery', + '../Core/queryToObject', + '../Core/Rectangle', + '../Core/WebMercatorTilingScheme', + '../ThirdParty/Uri', + '../ThirdParty/when', + './ImageryProvider', + './UrlTemplateImageryProvider' +], function( + combine, + Credit, + defaultValue, + defined, + defineProperties, + DeveloperError, + Event, + freezeObject, + objectToQuery, + queryToObject, + Rectangle, + WebMercatorTilingScheme, + Uri, + when, + ImageryProvider, + UrlTemplateImageryProvider) { + "use strict"; + + /** + * Provides tiled imagery served by {@link http://www.opengeospatial.org/standards/wmts|WMTS 1.0.0} compliant servers. + * This provider supports HTTP KVP-encoded and RESTful GetTile requests, but does not yet support the SOAP encoding. + * + * @alias WebMapTileServiceImageryProvider + * @constructor + * + * @param {Object} options Object with the following properties: + * @param {String} options.url The base URL for the WMTS GetTile operation (for KVP-encoded requests) or the tile-URL template (for RESTful requests). The tile-URL template should contain the following variables: {style}, {TileMatrixSet}, {TileMatrix}, {TileRow}, {TileCol}. The first two are optional if actual values are hardcoded or not required by the server. The {s} keyword may be used to specify subdomains. + * @param {String} [options.format='image/jpeg'] The MIME type for images to retrieve from the server. + * @param {String} options.layer The layer name for WMTS requests. + * @param {String} options.style The style name for WMTS requests. + * @param {String} options.tileMatrixSetID The identifier of the TileMatrixSet to use for WMTS requests. + * @param {Array} [options.tileMatrixLabels] A list of identifiers in the TileMatrix to use for WMTS requests, one per TileMatrix level. + * @param {Number} [options.tileWidth=256] The tile width in pixels. + * @param {Number} [options.tileHeight=256] The tile height in pixels. + * @param {TilingScheme} [options.tilingScheme] The tiling scheme corresponding to the organization of the tiles in the TileMatrixSet. + * @param {Object} [options.proxy] A proxy to use for requests. This object is expected to have a getURL function which returns the proxied URL. + * @param {Rectangle} [options.rectangle=Rectangle.MAX_VALUE] The rectangle covered by the layer. + * @param {Number} [options.minimumLevel=0] The minimum level-of-detail supported by the imagery provider. + * @param {Number} [options.maximumLevel] The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit. + * @param {Ellipsoid} [options.ellipsoid] The ellipsoid. If not specified, the WGS84 ellipsoid is used. + * @param {Credit|String} [options.credit] A credit for the data source, which is displayed on the canvas. + * @param {String|String[]} [options.subdomains='abc'] The subdomains to use for the {s} placeholder in the URL template. + * If this parameter is a single string, each character in the string is a subdomain. If it is + * an array, each element in the array is a subdomain. + * + * @see ArcGisMapServerImageryProvider + * @see BingMapsImageryProvider + * @see GoogleEarthImageryProvider + * @see OpenStreetMapImageryProvider + * @see SingleTileImageryProvider + * @see TileMapServiceImageryProvider + * @see WebMapServiceImageryProvider + * @see UrlTemplateImageryProvider + * + * @example + * // Example 1. USGS shaded relief tiles (KVP) + * var shadedRelief1 = new Cesium.WebMapTileServiceImageryProvider({ + * url : 'http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS', + * layer : 'USGSShadedReliefOnly', + * style : 'default', + * format : 'image/jpeg', + * tileMatrixSetID : 'default028mm', + * // tileMatrixLabels : ['default028mm:0', 'default028mm:1', 'default028mm:2' ...], + * maximumLevel: 19, + * credit : new Cesium.Credit('U. S. Geological Survey') + * }); + * viewer.imageryLayers.addImageryProvider(shadedRelief1); + * + * @example + * // Example 2. USGS shaded relief tiles (RESTful) + * var shadedRelief2 = new Cesium.WebMapTileServiceImageryProvider({ + * url : 'http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS/tile/1.0.0/USGSShadedReliefOnly/{Style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.jpg', + * layer : 'USGSShadedReliefOnly', + * style : 'default', + * format : 'image/jpeg', + * tileMatrixSetID : 'default028mm', + * maximumLevel: 19, + * credit : new Cesium.Credit('U. S. Geological Survey') + * }); + * viewer.imageryLayers.addImageryProvider(shadedRelief2); + */ + var createWebMapTileServiceImageryProvider = function WebMapTileServiceImageryProvider(options) { + options = defaultValue(options, defaultValue.EMPTY_OBJECT); + + if (!defined(options.url)) { + throw new DeveloperError('options.url is required.'); + } + if (!defined(options.layer)) { + throw new DeveloperError('options.layer is required.'); + } + if (!defined(options.style)) { + throw new DeveloperError('options.style is required.'); + } + if (!defined(options.tileMatrixSetID)) { + throw new DeveloperError('options.tileMatrixSetID is required.'); + } + + var style = options.style; + var tileMatrixSetID = options.tileMatrixSetID; + var proxy = options.proxy; + var tileDiscardPolicy = options.tileDiscardPolicy; + + var tilingScheme = defined(options.tilingScheme) ? options.tilingScheme : new WebMercatorTilingScheme({ ellipsoid : options.ellipsoid }); + var tileWidth = defaultValue(options.tileWidth, 256); + var tileHeight = defaultValue(options.tileHeight, 256); + + var minimumLevel = defaultValue(options.minimumLevel, 0); + var maximumLevel = options.maximumLevel; + + var rectangle = defaultValue(options.rectangle, tilingScheme.rectangle); + + // Check the number of tiles at the minimum level. If it's more than four, + // throw an exception, because starting at the higher minimum + // level will cause too many tiles to be downloaded and rendered. + var swTile = tilingScheme.positionToTileXY(Rectangle.southwest(rectangle), minimumLevel); + var neTile = tilingScheme.positionToTileXY(Rectangle.northeast(rectangle), minimumLevel); + var tileCount = (Math.abs(neTile.x - swTile.x) + 1) * (Math.abs(neTile.y - swTile.y) + 1); + if (tileCount > 4) { + throw new DeveloperError('The imagery provider\'s rectangle and minimumLevel indicate that there are ' + tileCount + ' tiles at the minimum level. Imagery providers with more than four tiles at the minimum level are not supported.'); + } + + var credit = options.credit; + credit = typeof credit === 'string' ? new Credit(credit) : credit; + + var subdomains = options.subdomains; + if (Array.isArray(subdomains)) { + subdomains = subdomains.slice(); + } else if (defined(subdomains) && subdomains.length > 0) { + subdomains = subdomains.split(''); + } else { + subdomains = ['a', 'b', 'c']; + } + + var templateUrl = "http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS/" + + "tile/1.0.0/USGSShadedReliefOnly/" + style + "/" + tileMatrixSetID + "/{z}/{y}/{x}.jpg"; + + return new UrlTemplateImageryProvider({ + url : templateUrl, + tilingScheme : tilingScheme, + rectangle : rectangle, + tileWidth : tileWidth, + tileHeight : tileHeight, + minimumLevel : minimumLevel, + maximumLevel : maximumLevel, + proxy : proxy, + subdomains: subdomains, + tileDiscardPolicy : tileDiscardPolicy, + credit : credit + }); + }; + + return createWebMapTileServiceImageryProvider; +}); diff --git a/Specs/Scene/createWebMapTileServiceImageryProviderSpec.js b/Specs/Scene/createWebMapTileServiceImageryProviderSpec.js new file mode 100644 index 000000000000..57cb16b2547b --- /dev/null +++ b/Specs/Scene/createWebMapTileServiceImageryProviderSpec.js @@ -0,0 +1,396 @@ +/*global defineSuite*/ +defineSuite([ + 'Scene/createWebMapTileServiceImageryProvider', + 'Core/Credit', + 'Core/DefaultProxy', + 'Core/defined', + 'Core/GeographicTilingScheme', + 'Core/loadImage', + 'Core/queryToObject', + 'Core/WebMercatorTilingScheme', + 'Scene/Imagery', + 'Scene/ImageryLayer', + 'Scene/ImageryProvider', + 'Scene/ImageryState', + 'Specs/pollToPromise', + 'ThirdParty/Uri' +], function( + createWebMapTileServiceImageryProvider, + Credit, + DefaultProxy, + defined, + GeographicTilingScheme, + loadImage, + queryToObject, + WebMercatorTilingScheme, + Imagery, + ImageryLayer, + ImageryProvider, + ImageryState, + pollToPromise, + Uri) { + "use strict"; + + afterEach(function() { + loadImage.createImage = loadImage.defaultCreateImage; + }); + + it('conforms to ImageryProvider interface', function() { + expect(createWebMapTileServiceImageryProvider).toConformToInterface(ImageryProvider); + }); + + it('generates expected tile urls', function() { + var options = { + url : 'http://wmts.invalid', + format : 'image/png', + layer : 'someLayer', + style : 'someStyle', + tileMatrixSetID : 'someTMS', + tileMatrixLabels : ['first', 'second', 'third'] + }; + + var provider = createWebMapTileServiceImageryProvider(options); + + spyOn(ImageryProvider, 'loadImage'); + + var tilecol = 12; + var tilerow = 5; + var level = 1; + provider.requestImage(tilecol, tilerow, level); + var uri = new Uri(ImageryProvider.loadImage.calls.mostRecent().args[1]); + var queryObject = queryToObject(uri.query); + + expect(queryObject.request).toEqual('GetTile'); + expect(queryObject.service).toEqual('WMTS'); + expect(queryObject.version).toEqual('1.0.0'); + expect(queryObject.format).toEqual(options.format); + expect(queryObject.layer).toEqual(options.layer); + expect(queryObject.style).toEqual(options.style); + expect(parseInt(queryObject.tilecol, 10)).toEqual(tilecol); + expect(queryObject.tilematrixset).toEqual(options.tileMatrixSetID); + expect(queryObject.tilematrix).toEqual(options.tileMatrixLabels[level]); + expect(parseInt(queryObject.tilerow, 10)).toEqual(tilerow); + + tilecol = 1; + tilerow = 3; + level = 2; + provider.requestImage(tilecol, tilerow, level); + uri = new Uri(ImageryProvider.loadImage.calls.mostRecent().args[1]); + queryObject = queryToObject(uri.query); + + expect(queryObject.request).toEqual('GetTile'); + expect(queryObject.service).toEqual('WMTS'); + expect(queryObject.version).toEqual('1.0.0'); + expect(queryObject.format).toEqual(options.format); + expect(queryObject.layer).toEqual(options.layer); + expect(queryObject.style).toEqual(options.style); + expect(parseInt(queryObject.tilecol, 10)).toEqual(tilecol); + expect(queryObject.tilematrixset).toEqual(options.tileMatrixSetID); + expect(queryObject.tilematrix).toEqual(options.tileMatrixLabels[level]); + expect(parseInt(queryObject.tilerow, 10)).toEqual(tilerow); + }); + + it('supports subdomains string urls', function() { + var options = { + url : '{s}', + layer : '', + style : '', + subdomains : '123', + tileMatrixSetID : '' + }; + + var provider = createWebMapTileServiceImageryProvider(options); + + spyOn(ImageryProvider, 'loadImage'); + + var tilecol = 1; + var tilerow = 1; + var level = 1; + provider.requestImage(tilecol, tilerow, level); + var url = ImageryProvider.loadImage.calls.mostRecent().args[1]; + expect('123'.indexOf(url)).toBeGreaterThanOrEqualTo(0); + }); + + it('supports subdomains array urls', function() { + var options = { + url : '{s}', + layer : '', + style : '', + subdomains : ['foo', 'bar'], + tileMatrixSetID : '' + }; + + var provider = createWebMapTileServiceImageryProvider(options); + + spyOn(ImageryProvider, 'loadImage'); + + var tilecol = 1; + var tilerow = 1; + var level = 1; + provider.requestImage(tilecol, tilerow, level); + var url = ImageryProvider.loadImage.calls.mostRecent().args[1]; + expect(['foo', 'bar'].indexOf(url)).toBeGreaterThanOrEqualTo(0); + }); + + it('generates expected tile urls from template', function() { + var options = { + url : 'http://wmts.invalid/{style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.png', + format : 'image/png', + layer : 'someLayer', + style : 'someStyle', + tileMatrixSetID : 'someTMS', + tileMatrixLabels : ['first', 'second', 'third'] + }; + + var provider = createWebMapTileServiceImageryProvider(options); + + spyOn(ImageryProvider, 'loadImage'); + + var tilecol = 12; + var tilerow = 5; + var level = 1; + provider.requestImage(tilecol, tilerow, level); + var uri = new Uri(ImageryProvider.loadImage.calls.mostRecent().args[1]); + expect(uri.toString()).toEqual('http://wmts.invalid/someStyle/someTMS/second/5/12.png'); + }); + + it('requires the url to be specified', function() { + function createWithoutUrl() { + return createWebMapTileServiceImageryProvider({ + layer : 'someLayer', + style : 'someStyle', + tileMatrixSetID : 'someTMS' + }); + } + expect(createWithoutUrl).toThrowDeveloperError(); + }); + + it('requires the layer to be specified', function() { + function createWithoutLayer() { + return createWebMapTileServiceImageryProvider({ + url : 'http://wmts.invalid', + style : 'someStyle', + tileMatrixSetID : 'someTMS' + }); + } + expect(createWithoutLayer).toThrowDeveloperError(); + }); + + it('requires the style to be specified', function() { + function createWithoutStyle() { + return createWebMapTileServiceImageryProvider({ + layer : 'someLayer', + url : 'http://wmts.invalid', + tileMatrixSetID : 'someTMS' + }); + } + expect(createWithoutStyle).toThrowDeveloperError(); + }); + + it('requires the tileMatrixSetID to be specified', function() { + function createWithoutTMS() { + return createWebMapTileServiceImageryProvider({ + layer : 'someLayer', + style : 'someStyle', + url : 'http://wmts.invalid' + }); + } + expect(createWithoutTMS).toThrowDeveloperError(); + }); + + it('resolves readyPromise', function() { + var provider = createWebMapTileServiceImageryProvider({ + layer : 'someLayer', + style : 'someStyle', + url : 'http://wmts.invalid', + tileMatrixSetID : 'someTMS' + }); + + return provider.readyPromise.then(function(result) { + expect(result).toBe(true); + expect(provider.ready).toBe(true); + }); + }); + + // default parameters values + it('uses default values for undefined parameters', function() { + var provider = createWebMapTileServiceImageryProvider({ + layer : 'someLayer', + style : 'someStyle', + url : 'http://wmts.invalid', + tileMatrixSetID : 'someTMS' + }); + expect(provider.format).toEqual('image/jpeg'); + expect(provider.tileWidth).toEqual(256); + expect(provider.tileHeight).toEqual(256); + expect(provider.minimumLevel).toEqual(0); + expect(provider.maximumLevel).toBeUndefined(); + expect(provider.tilingScheme).toBeInstanceOf(WebMercatorTilingScheme); + expect(provider.rectangle).toEqual(provider.tilingScheme.rectangle); + expect(provider.credit).toBeUndefined(); + expect(provider.proxy).toBeUndefined(); + }); + + // non default parameters values + it('uses parameters passed to constructor', function() { + var proxy = new DefaultProxy('/proxy/'); + var tilingScheme = new GeographicTilingScheme(); + var rectangle = new WebMercatorTilingScheme().rectangle; + var provider = createWebMapTileServiceImageryProvider({ + layer : 'someLayer', + style : 'someStyle', + url : 'http://wmts.invalid', + tileMatrixSetID : 'someTMS', + format : 'someFormat', + tileWidth : 512, + tileHeight : 512, + tilingScheme : tilingScheme, + minimumLevel : 0, + maximumLevel : 12, + rectangle : rectangle, + proxy : proxy, + credit : "Thanks for using our WMTS server." + }); + expect(provider.format).toEqual('someFormat'); + expect(provider.tileWidth).toEqual(512); + expect(provider.tileHeight).toEqual(512); + expect(provider.minimumLevel).toEqual(0); + expect(provider.maximumLevel).toEqual(12); + expect(provider.tilingScheme).toEqual(tilingScheme); + expect(provider.credit).toBeDefined(); + expect(provider.credit).toBeInstanceOf(Credit); + expect(provider.rectangle).toEqual(rectangle); + expect(provider.proxy).toEqual(proxy); + }); + + it("doesn't care about trailing question mark at the end of URL", function() { + var provider1 = createWebMapTileServiceImageryProvider({ + layer : 'someLayer', + style : 'someStyle', + url : 'http://wmts.invalid', + tileMatrixSetID : 'someTMS' + }); + var provider2 = createWebMapTileServiceImageryProvider({ + layer : 'someLayer', + style : 'someStyle', + url : 'http://wmts.invalid?', + tileMatrixSetID : 'someTMS' + }); + + return pollToPromise(function() { + return provider1.ready && provider2.ready; + }).then(function() { + spyOn(loadImage, 'createImage').and.callFake(function(url, crossOrigin, deferred) { + // Just return any old image. + loadImage.defaultCreateImage('Data/Images/Red16x16.png', crossOrigin, deferred); + }); + + return provider1.requestImage(0, 0, 0).then(function(image) { + return provider2.requestImage(0, 0, 0).then(function(image) { + expect(loadImage.createImage.calls.count()).toEqual(2); + //expect the two image URLs to be the same between the two providers + var allCalls = loadImage.createImage.calls.all(); + expect(allCalls[1].args[0]).toEqual(allCalls[0].args[0]); + }); + }); + }); + }); + + it('requestImage returns a promise for an image and loads it for cross-origin use', function() { + var provider = createWebMapTileServiceImageryProvider({ + layer : 'someLayer', + style : 'someStyle', + url : 'http://wmts.invalid', + tileMatrixSetID : 'someTMS' + }); + + return pollToPromise(function() { + return provider.ready; + }).then(function() { + spyOn(loadImage, 'createImage').and.callFake(function(url, crossOrigin, deferred) { + // Just return any old image. + loadImage.defaultCreateImage('Data/Images/Red16x16.png', crossOrigin, deferred); + }); + + return provider.requestImage(0, 0, 0).then(function(image) { + expect(loadImage.createImage).toHaveBeenCalled(); + expect(image).toBeInstanceOf(Image); + }); + }); + }); + + it('routes requests through a proxy if one is specified', function() { + var proxy = new DefaultProxy('/proxy/'); + var provider = createWebMapTileServiceImageryProvider({ + layer : 'someLayer', + style : 'someStyle', + url : 'http://wmts.invalid', + tileMatrixSetID : 'someTMS', + proxy : proxy + }); + + return pollToPromise(function() { + return provider.ready; + }).then(function() { + spyOn(loadImage, 'createImage').and.callFake(function(url, crossOrigin, deferred) { + expect(url.indexOf(proxy.getURL('http://wmts.invalid'))).toEqual(0); + + // Just return any old image. + loadImage.defaultCreateImage('Data/Images/Red16x16.png', crossOrigin, deferred); + }); + + return provider.requestImage(0, 0, 0).then(function(image) { + expect(loadImage.createImage).toHaveBeenCalled(); + expect(image).toBeInstanceOf(Image); + }); + }); + }); + + it('raises error event when image cannot be loaded', function() { + var provider = createWebMapTileServiceImageryProvider({ + layer : 'someLayer', + style : 'someStyle', + url : 'http://wmts.invalid', + tileMatrixSetID : 'someTMS' + }); + + var layer = new ImageryLayer(provider); + + var tries = 0; + provider.errorEvent.addEventListener(function(error) { + expect(error.timesRetried).toEqual(tries); + ++tries; + if (tries < 3) { + error.retry = true; + } + }); + + loadImage.createImage = function(url, crossOrigin, deferred) { + if (tries === 2) { + // Succeed after 2 tries + loadImage.defaultCreateImage('Data/Images/Red16x16.png', crossOrigin, deferred); + } else { + // fail + setTimeout(function() { + deferred.reject(); + }, 1); + } + }; + + return pollToPromise(function() { + return provider.ready; + }).then(function() { + var imagery = new Imagery(layer, 0, 0, 0); + imagery.addReference(); + layer._requestImagery(imagery); + + return pollToPromise(function() { + return imagery.state === ImageryState.RECEIVED; + }).then(function() { + expect(imagery.image).toBeInstanceOf(Image); + expect(tries).toEqual(2); + imagery.releaseReference(); + }); + }); + }); +}); From d73a6603d3354c67874b7846d3d17b88901433c1 Mon Sep 17 00:00:00 2001 From: Adam Cole Date: Sun, 13 Dec 2015 20:31:00 -0500 Subject: [PATCH 2/3] added deprecation tag and warning to WebMapServiceImageryProvider --- Source/Scene/WebMapServiceImageryProvider.js | 3 +++ Source/Scene/createWebMapTileServiceImageryProvider.js | 4 ++-- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/Source/Scene/WebMapServiceImageryProvider.js b/Source/Scene/WebMapServiceImageryProvider.js index 7b410ac77150..74f26a566899 100644 --- a/Source/Scene/WebMapServiceImageryProvider.js +++ b/Source/Scene/WebMapServiceImageryProvider.js @@ -4,6 +4,7 @@ define([ '../Core/defaultValue', '../Core/defined', '../Core/defineProperties', + '../Core/deprecationWarning', '../Core/DeveloperError', '../Core/freezeObject', '../Core/GeographicTilingScheme', @@ -18,6 +19,7 @@ define([ defaultValue, defined, defineProperties, + deprecationWarning, DeveloperError, freezeObject, GeographicTilingScheme, @@ -90,6 +92,7 @@ define([ * viewer.imageryLayers.addImageryProvider(provider); */ var WebMapServiceImageryProvider = function WebMapServiceImageryProvider(options) { + deprecationWarning('WebMapServiceImageryProvider', 'WebMapServiceImageryProvider is deprecated. It will be removed in Cesium 1.19. Use createWebMapServiceImageryProvider instead.') options = defaultValue(options, defaultValue.EMPTY_OBJECT); //>>includeStart('debug', pragmas.debug); diff --git a/Source/Scene/createWebMapTileServiceImageryProvider.js b/Source/Scene/createWebMapTileServiceImageryProvider.js index b5661079c4a6..633d5bf0fc05 100644 --- a/Source/Scene/createWebMapTileServiceImageryProvider.js +++ b/Source/Scene/createWebMapTileServiceImageryProvider.js @@ -73,7 +73,7 @@ define([ * * @example * // Example 1. USGS shaded relief tiles (KVP) - * var shadedRelief1 = new Cesium.WebMapTileServiceImageryProvider({ + * var shadedRelief1 = Cesium.createWebMapTileServiceImageryProvider({ * url : 'http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS', * layer : 'USGSShadedReliefOnly', * style : 'default', @@ -87,7 +87,7 @@ define([ * * @example * // Example 2. USGS shaded relief tiles (RESTful) - * var shadedRelief2 = new Cesium.WebMapTileServiceImageryProvider({ + * var shadedRelief2 = Cesium.createWebMapTileServiceImageryProvider({ * url : 'http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS/tile/1.0.0/USGSShadedReliefOnly/{Style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.jpg', * layer : 'USGSShadedReliefOnly', * style : 'default', From e3385544fcdc823c0fb4ff3d5a94571d2355e4ef Mon Sep 17 00:00:00 2001 From: Adam Cole Date: Sun, 13 Dec 2015 21:48:09 -0500 Subject: [PATCH 3/3] create the template url correctly according to the passed options --- .../createWebMapTileServiceImageryProvider.js | 35 +++++++++++++++++-- 1 file changed, 33 insertions(+), 2 deletions(-) diff --git a/Source/Scene/createWebMapTileServiceImageryProvider.js b/Source/Scene/createWebMapTileServiceImageryProvider.js index 48efff5476e5..09499200166a 100644 --- a/Source/Scene/createWebMapTileServiceImageryProvider.js +++ b/Source/Scene/createWebMapTileServiceImageryProvider.js @@ -97,6 +97,7 @@ define([ * }); * viewer.imageryLayers.addImageryProvider(shadedRelief2); */ + var createWebMapTileServiceImageryProvider = function WebMapTileServiceImageryProvider(options) { options = defaultValue(options, defaultValue.EMPTY_OBJECT); @@ -117,6 +118,8 @@ define([ var tileMatrixSetID = options.tileMatrixSetID; var proxy = options.proxy; var tileDiscardPolicy = options.tileDiscardPolicy; + var format = defaultValue(options.format, 'image/jpeg'); + var tilingScheme = defined(options.tilingScheme) ? options.tilingScheme : new WebMercatorTilingScheme({ ellipsoid : options.ellipsoid }); var tileWidth = defaultValue(options.tileWidth, 256); @@ -149,8 +152,36 @@ define([ subdomains = ['a', 'b', 'c']; } - var templateUrl = "http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS/" + - "tile/1.0.0/USGSShadedReliefOnly/" + style + "/" + tileMatrixSetID + "/{z}/{y}/{x}.jpg"; + // construct templateUrl + var templateUrl; + if (options.url.indexOf('{') >= 0) { + templateUrl = options.url + .replace('{style}', style) + .replace('{Style}', style) + .replace('{TileMatrixSet}', tileMatrixSetID) + .replace('{TileMatrix}', "{z}") + .replace('{TileRow}', "{y}") + .replace('{TileCol}', "{x}"); + } else { + var defaultParameters = freezeObject({ + service : 'WMTS', + version : '1.0.0', + request : 'GetTile' + }); + // build KVP request + var uri = new Uri(options.url); + var queryOptions = queryToObject(defaultValue(uri.query, '')); + + queryOptions = combine(defaultParameters, queryOptions); + queryOptions.layer = options.layer; + queryOptions.style = style; + queryOptions.tilematrixset = tileMatrixSetID; + queryOptions.format = format; + + uri.query = objectToQuery(queryOptions); + uri += "&tilematrix={z}&tilerow={y}&tilecol={x}"; + templateUrl = uri.toString(); + } return new UrlTemplateImageryProvider({ url : templateUrl,