@cesium/engine 23.0.1 → 25.0.0

package/Source/Scene/WebMapTileServiceImageryProvider.js

@@ -1,19 +1,13 @@
 import combine from "../Core/combine.js";
-import Credit from "../Core/Credit.js";
 import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import Event from "../Core/Event.js";
 import Resource from "../Core/Resource.js";
 import WebMercatorTilingScheme from "../Core/WebMercatorTilingScheme.js";
-import ImageryProvider from "./ImageryProvider.js";
 import TimeDynamicImagery from "./TimeDynamicImagery.js";
-
-const defaultParameters = Object.freeze({
-  service: "WMTS",
-  version: "1.0.0",
-  request: "GetTile",
-});
+import UrlTemplateImageryProvider from "./UrlTemplateImageryProvider.js";
+import GetFeatureInfoFormat from "./GetFeatureInfoFormat.js";
 
 /**
  * @typedef {object} WebMapTileServiceImageryProvider.ConstructorOptions
@@ -25,21 +19,32 @@ const defaultParameters = Object.freeze({
  * @property {string} layer The layer name for WMTS requests.
  * @property {string} style The style name for WMTS requests.
  * @property {string} tileMatrixSetID The identifier of the TileMatrixSet to use for WMTS requests.
- * @property {Array} [tileMatrixLabels] A list of identifiers in the TileMatrix to use for WMTS requests, one per TileMatrix level.
- * @property {Clock} [clock] A Clock instance that is used when determining the value for the time dimension. Required when `times` is specified.
- * @property {TimeIntervalCollection} [times] TimeIntervalCollection with its <code>data</code> property being an object containing time dynamic dimension and their values.
- * @property {object} [dimensions] A object containing static dimensions and their values.
+ * @property {boolean} [enablePickFeatures] If true, {@link WebMapTileServiceImageryProvider#pickFeatures} will invoke
+ *                          the GetFeatureInfo operation on the WMTS server and return the features included in the response.  If false,
+ *                          {@link WebMapTileServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable features)
+ *                          without communicating with the server.  Set this property to false if you know your WMTS server does not support
+ *                          GetFeatureInfo or if you don't want this provider's features to be pickable.
+ *                          Defaults to true for KVP encoding. For RESTful encoding, defaults to true only when
+ *                          {@link WebMapTileServiceImageryProvider.ConstructorOptions#getFeatureInfoUrl} is specified, and false otherwise.
+ * @property {object} [getFeatureInfoParameters] Additional parameters to include in GetFeatureInfo requests. Keys are lowercased internally.
+ * @property {Resource|string} [getFeatureInfoUrl] The GetFeatureInfo URL of the WMTS service. If not specified, the value of <code>url</code> is used.
+ * @property {GetFeatureInfoFormat[]} [getFeatureInfoFormats=WebMapTileServiceImageryProvider.DefaultGetFeatureInfoFormats] The formats
+ *                          in which to try WMTS GetFeatureInfo requests.
+ * @property {Rectangle} [rectangle=Rectangle.MAX_VALUE] The rectangle covered by the layer.
+ * @property {TilingScheme} [tilingScheme] The tiling scheme corresponding to the organization of the tiles in the TileMatrixSet.
+ * @property {Ellipsoid} [ellipsoid] The ellipsoid.  If not specified, the WGS84 ellipsoid is used.
  * @property {number} [tileWidth=256] The tile width in pixels.
  * @property {number} [tileHeight=256] The tile height in pixels.
- * @property {TilingScheme} [tilingScheme] The tiling scheme corresponding to the organization of the tiles in the TileMatrixSet.
- * @property {Rectangle} [rectangle=Rectangle.MAX_VALUE] The rectangle covered by the layer.
  * @property {number} [minimumLevel=0] The minimum level-of-detail supported by the imagery provider.
  * @property {number} [maximumLevel] The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit.
- * @property {Ellipsoid} [ellipsoid] The ellipsoid.  If not specified, the WGS84 ellipsoid is used.
+ * @property {Array} [tileMatrixLabels] A list of identifiers in the TileMatrix to use for WMTS requests, one per TileMatrix level.
  * @property {Credit|string} [credit] A credit for the data source, which is displayed on the canvas.
  * @property {string|string[]} [subdomains='abc'] The subdomains to use for the <code>{s}</code> 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.
+ * @property {Clock} [clock] A Clock instance that is used when determining the value for the time dimension. Required when `times` is specified.
+ * @property {TimeIntervalCollection} [times] TimeIntervalCollection with its <code>data</code> property being an object containing time dynamic dimension and their values.
+ * @property {object} [dimensions] A object containing static dimensions and their values.
  */
 
 /**
@@ -81,28 +86,88 @@ const defaultParameters = Object.freeze({
  * viewer.imageryLayers.addImageryProvider(shadedRelief2);
  *
  * @example
- * // Example 3. NASA time dynamic weather data (RESTful)
+ * // Example 3: NASA time dynamic snowpack data (RESTful)
+ * // Define time intervals for the layer based on the capabilities XML
  * const times = Cesium.TimeIntervalCollection.fromIso8601({
- *     iso8601: '2015-07-30/2017-06-16/P1D',
- *     dataCallback: function dataCallback(interval, index) {
- *         return {
- *             Time: Cesium.JulianDate.toIso8601(interval.start)
- *         };
- *     }
+ *     iso8601: '2025-01-01/2025-09-01/P5D', // Use the valid interval(s) from the Dimension section
+ *     dataCallback: function(interval, index) {
+ *       // Return an object with the Time variable used in the URL template
+ *       return {
+ *           Time: Cesium.JulianDate.toIso8601(interval.start, 0)
+ *       };
+ *   }
  * });
+
+ * // Get the internal clock,  set desired start, stop, and multiplier
+ * const clock = viewer.clock;
+ * clock.startTime = Cesium.JulianDate.fromIso8601('2025-01-01');
+ * clock.currentTime = Cesium.JulianDate.fromIso8601('2025-01-01');
+ * clock.stopTime = Cesium.JulianDate.fromIso8601('2025-09-01');
+ * clock.clockRange = Cesium.ClockRange.LOOP_STOP;
+ * clock.multiplier = 1; // 1 day per second
+ * clock.clockStep = Cesium.ClockStep.SYSTEM_CLOCK_MULTIPLIER;
+ *
+ * viewer.timeline.zoomTo(clock.startTime, clock.stopTime);
+ *
  * const weather = new Cesium.WebMapTileServiceImageryProvider({
- *     url : 'https://gibs.earthdata.nasa.gov/wmts/epsg4326/best/AMSR2_Snow_Water_Equivalent/default/{Time}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.png',
- *     layer : 'AMSR2_Snow_Water_Equivalent',
- *     style : 'default',
- *     tileMatrixSetID : '2km',
- *     maximumLevel : 5,
- *     format : 'image/png',
+ *     url: 'https://gibs.earthdata.nasa.gov/wmts/epsg3857/best/AMSRU2_Snow_Water_Equivalent_5Day/default/{Time}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.png',
+ *     layer: 'AMSRU2_Snow_Water_Equivalent_5Day',
+ *     style: 'default',
+ *     tileMatrixSetID: 'GoogleMapsCompatible_Level6',
+ *     format: 'image/png',
  *     clock: clock,
  *     times: times,
- *     credit : new Cesium.Credit('NASA Global Imagery Browse Services for EOSDIS')
+ *     credit: new Cesium.Credit('NASA Global Imagery Browse Services for EOSDIS')
  * });
  * viewer.imageryLayers.addImageryProvider(weather);
  *
+ * @example
+ * // Example 4. Digital Earth AfricA waterbodies with GetFeatureInfo support (RESTful)
+ * const waterbodies = new Cesium.WebMapTileServiceImageryProvider({
+ *    url: "https://geoserver.digitalearth.africa/geoserver/gwc/service/wmts/rest/{layer}/{style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}?format={format}",
+ *    layer: "waterbodies:DEAfrica_Waterbodies",
+ *    style: "waterbodies:waterbodies_v0_0_4",
+ *    tileMatrixSetID: "EPSG:3857",
+ *    tileMatrixLabels: [
+ *      "EPSG:3857:0",
+ *      "EPSG:3857:1",
+ *      "EPSG:3857:2",
+ *      "EPSG:3857:3",
+ *      "EPSG:3857:4",
+ *      "EPSG:3857:5",
+ *      "EPSG:3857:6",
+ *      "EPSG:3857:7",
+ *      "EPSG:3857:8",
+ *      "EPSG:3857:9",
+ *      "EPSG:3857:10",
+ *      "EPSG:3857:11",
+ *      "EPSG:3857:12",
+ *      "EPSG:3857:13",
+ *      "EPSG:3857:14",
+ *      "EPSG:3857:15",
+ *      "EPSG:3857:16",
+ *      "EPSG:3857:17",
+ *      "EPSG:3857:18",
+ *      "EPSG:3857:19",
+ *      "EPSG:3857:20",
+ *      "EPSG:3857:21",
+ *      "EPSG:3857:22",
+ *      "EPSG:3857:23",
+ *      "EPSG:3857:24",
+ *      "EPSG:3857:25",
+ *      "EPSG:3857:26",
+ *      "EPSG:3857:27",
+ *      "EPSG:3857:28",
+ *      "EPSG:3857:29",
+ *      "EPSG:3857:30",
+ *    ],
+ *    format: "image/png",
+ *    enablePickFeatures: true,
+ *    getFeatureInfoUrl: "https://geoserver.digitalearth.africa/geoserver/gwc/service/wmts/rest/{layer}/{style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}/{j}/{i}?format={format}",
+ * });
+ *
+ * viewer.imageryLayers.addImageryProvider(waterbodies);
+ *
  * @see ArcGisMapServerImageryProvider
  * @see BingMapsImageryProvider
  * @see GoogleEarthEnterpriseMapsProvider
@@ -146,49 +211,90 @@ function WebMapTileServiceImageryProvider(options) {
   this._defaultMinificationFilter = undefined;
   this._defaultMagnificationFilter = undefined;
 
+  this._getFeatureInfoUrl = options.getFeatureInfoUrl ?? options.url;
+
   const resource = Resource.createIfNeeded(options.url);
+  const pickFeatureResource = Resource.createIfNeeded(this._getFeatureInfoUrl);
 
   const style = options.style;
   const tileMatrixSetID = options.tileMatrixSetID;
   const url = resource.url;
+  const format = options.format ?? "image/jpeg";
 
   const bracketMatch = url.match(/{/g);
   if (
     !defined(bracketMatch) ||
     (bracketMatch.length === 1 && /{s}/.test(url))
   ) {
-    resource.setQueryParameters(defaultParameters);
+    resource.setQueryParameters(
+      WebMapTileServiceImageryProvider.DefaultParameters,
+      true,
+    );
     this._useKvp = true;
   } else {
-    const templateValues = {
-      style: style,
-      Style: style,
-      TileMatrixSet: tileMatrixSetID,
-    };
-
-    resource.setTemplateValues(templateValues);
+    resource.setTemplateValues(
+      WebMapTileServiceImageryProvider.DefaultParameters,
+      true,
+    );
     this._useKvp = false;
   }
 
-  this._resource = resource;
-  this._layer = options.layer;
-  this._style = style;
-  this._tileMatrixSetID = tileMatrixSetID;
-  this._tileMatrixLabels = options.tileMatrixLabels;
-  this._format = options.format ?? "image/jpeg";
-  this._tileDiscardPolicy = options.tileDiscardPolicy;
+  if (this._useKvp) {
+    pickFeatureResource.setQueryParameters(
+      WebMapTileServiceImageryProvider.GetFeatureInfoDefaultParameters,
+      true,
+    );
 
-  this._tilingScheme = defined(options.tilingScheme)
-    ? options.tilingScheme
-    : new WebMercatorTilingScheme({ ellipsoid: options.ellipsoid });
-  this._tileWidth = options.tileWidth ?? 256;
-  this._tileHeight = options.tileHeight ?? 256;
+    if (defined(options.getFeatureInfoParameters)) {
+      pickFeatureResource.setQueryParameters(
+        objectToLowercase(options.getFeatureInfoParameters),
+      );
+    }
 
-  this._minimumLevel = options.minimumLevel ?? 0;
-  this._maximumLevel = options.maximumLevel;
+    const pickFeatureParams = {
+      infoformat: "{format}",
+      i: "{i}",
+      j: "{j}",
+    };
+    pickFeatureResource.setQueryParameters(pickFeatureParams, true);
+  } else {
+    pickFeatureResource.setTemplateValues(
+      WebMapTileServiceImageryProvider.GetFeatureInfoDefaultParameters,
+      true,
+    );
 
-  this._rectangle = options.rectangle ?? this._tilingScheme.rectangle;
+    if (defined(options.getFeatureInfoParameters)) {
+      pickFeatureResource.setTemplateValues(
+        objectToLowercase(options.getFeatureInfoParameters),
+      );
+    }
+  }
+
+  this._resource = resource;
+  this._tileMatrixLabels = options.tileMatrixLabels;
+  this._format = format;
   this._dimensions = options.dimensions;
+  this._tilematrixset = tileMatrixSetID;
+
+  const parameters = {};
+  parameters.tilematrix = "{TileMatrix}";
+  parameters.layer = options.layer;
+  parameters.style = style;
+  parameters.tilerow = "{TileRow}";
+  parameters.tilecol = "{TileCol}";
+  parameters.tilematrixset = tileMatrixSetID;
+
+  if (this._useKvp) {
+    resource.setQueryParameters(parameters, true);
+    resource.setQueryParameters({ format: format }, true);
+    pickFeatureResource.setQueryParameters({ format: format }, true);
+    pickFeatureResource.setQueryParameters(parameters, true);
+  } else {
+    parameters.Style = style;
+    resource.setTemplateValues(parameters);
+    resource.setTemplateValues({ format: format });
+    pickFeatureResource.setTemplateValues(parameters);
+  }
 
   const that = this;
   this._reload = undefined;
@@ -209,79 +315,57 @@ function WebMapTileServiceImageryProvider(options) {
 
   this._errorEvent = new Event();
 
-  const credit = options.credit;
-  this._credit = typeof credit === "string" ? new Credit(credit) : credit;
-
-  this._subdomains = options.subdomains;
-  if (Array.isArray(this._subdomains)) {
-    this._subdomains = this._subdomains.slice();
-  } else if (defined(this._subdomains) && this._subdomains.length > 0) {
-    this._subdomains = this._subdomains.split("");
-  } else {
-    this._subdomains = ["a", "b", "c"];
-  }
+  // Let UrlTemplateImageryProvider do the actual URL building.
+  this._tileProvider = new UrlTemplateImageryProvider({
+    url: resource,
+    pickFeaturesUrl: pickFeatureResource,
+    tilingScheme:
+      options.tilingScheme ??
+      new WebMercatorTilingScheme({ ellipsoid: options.ellipsoid }),
+    rectangle: options.rectangle,
+    tileWidth: options.tileWidth,
+    tileHeight: options.tileHeight,
+    minimumLevel: options.minimumLevel,
+    maximumLevel: options.maximumLevel,
+    subdomains: options.subdomains,
+    tileDiscardPolicy: options.tileDiscardPolicy,
+    credit: options.credit,
+    getFeatureInfoFormats:
+      options.getFeatureInfoFormats ??
+      WebMapTileServiceImageryProvider.DefaultGetFeatureInfoFormats,
+    enablePickFeatures:
+      options.enablePickFeatures ??
+      (this._useKvp || defined(options.getFeatureInfoUrl)),
+    customTags: createCustomTags(this),
+  });
 }
 
 function requestImage(imageryProvider, col, row, level, request, interval) {
-  const labels = imageryProvider._tileMatrixLabels;
-  const tileMatrix = defined(labels) ? labels[level] : level.toString();
-  const subdomains = imageryProvider._subdomains;
-  const staticDimensions = imageryProvider._dimensions;
-  const dynamicIntervalData = defined(interval) ? interval.data : undefined;
-
-  let resource;
-  let templateValues;
-  if (!imageryProvider._useKvp) {
-    templateValues = {
-      TileMatrix: tileMatrix,
-      TileRow: row.toString(),
-      TileCol: col.toString(),
-      s: subdomains[(col + row + level) % subdomains.length],
-    };
-
-    resource = imageryProvider._resource.getDerivedResource({
-      request: request,
-    });
-    resource.setTemplateValues(templateValues);
+  const tileProvider = imageryProvider._tileProvider;
 
-    if (defined(staticDimensions)) {
-      resource.setTemplateValues(staticDimensions);
-    }
+  applyDimensions(imageryProvider, tileProvider._resource, interval);
 
-    if (defined(dynamicIntervalData)) {
-      resource.setTemplateValues(dynamicIntervalData);
-    }
-  } else {
-    // build KVP request
-    let query = {};
-    query.tilematrix = tileMatrix;
-    query.layer = imageryProvider._layer;
-    query.style = imageryProvider._style;
-    query.tilerow = row;
-    query.tilecol = col;
-    query.tilematrixset = imageryProvider._tileMatrixSetID;
-    query.format = imageryProvider._format;
-
-    if (defined(staticDimensions)) {
-      query = combine(query, staticDimensions);
-    }
-
-    if (defined(dynamicIntervalData)) {
-      query = combine(query, dynamicIntervalData);
-    }
+  return tileProvider.requestImage(col, row, level, request);
+}
 
-    templateValues = {
-      s: subdomains[(col + row + level) % subdomains.length],
-    };
+function pickFeatures(
+  imageryProvider,
+  x,
+  y,
+  level,
+  longitude,
+  latitude,
+  interval,
+) {
+  const tileProvider = imageryProvider._tileProvider;
 
-    resource = imageryProvider._resource.getDerivedResource({
-      queryParameters: query,
-      request: request,
-    });
-    resource.setTemplateValues(templateValues);
-  }
+  applyDimensions(
+    imageryProvider,
+    tileProvider._pickFeaturesResource,
+    interval,
+  );
 
-  return ImageryProvider.loadImage(imageryProvider, resource);
+  return tileProvider.pickFeatures(x, y, level, longitude, latitude);
 }
 
 Object.defineProperties(WebMapTileServiceImageryProvider.prototype, {
@@ -317,7 +401,7 @@ Object.defineProperties(WebMapTileServiceImageryProvider.prototype, {
    */
   tileWidth: {
     get: function () {
-      return this._tileWidth;
+      return this._tileProvider.tileWidth;
     },
   },
 
@@ -329,7 +413,7 @@ Object.defineProperties(WebMapTileServiceImageryProvider.prototype, {
    */
   tileHeight: {
     get: function () {
-      return this._tileHeight;
+      return this._tileProvider.tileHeight;
     },
   },
 
@@ -341,7 +425,7 @@ Object.defineProperties(WebMapTileServiceImageryProvider.prototype, {
    */
   maximumLevel: {
     get: function () {
-      return this._maximumLevel;
+      return this._tileProvider.maximumLevel;
     },
   },
 
@@ -353,7 +437,7 @@ Object.defineProperties(WebMapTileServiceImageryProvider.prototype, {
    */
   minimumLevel: {
     get: function () {
-      return this._minimumLevel;
+      return this._tileProvider.minimumLevel;
     },
   },
 
@@ -365,7 +449,7 @@ Object.defineProperties(WebMapTileServiceImageryProvider.prototype, {
    */
   tilingScheme: {
     get: function () {
-      return this._tilingScheme;
+      return this._tileProvider.tilingScheme;
     },
   },
 
@@ -377,7 +461,7 @@ Object.defineProperties(WebMapTileServiceImageryProvider.prototype, {
    */
   rectangle: {
     get: function () {
-      return this._rectangle;
+      return this._tileProvider.rectangle;
     },
   },
 
@@ -391,7 +475,7 @@ Object.defineProperties(WebMapTileServiceImageryProvider.prototype, {
    */
   tileDiscardPolicy: {
     get: function () {
-      return this._tileDiscardPolicy;
+      return this._tileProvider.tileDiscardPolicy;
     },
   },
 
@@ -405,7 +489,7 @@ Object.defineProperties(WebMapTileServiceImageryProvider.prototype, {
    */
   errorEvent: {
     get: function () {
-      return this._errorEvent;
+      return this._tileProvider.errorEvent;
     },
   },
 
@@ -430,7 +514,7 @@ Object.defineProperties(WebMapTileServiceImageryProvider.prototype, {
    */
   credit: {
     get: function () {
-      return this._credit;
+      return this._tileProvider.credit;
     },
   },
 
@@ -449,6 +533,27 @@ Object.defineProperties(WebMapTileServiceImageryProvider.prototype, {
       return true;
     },
   },
+
+  /**
+   * Gets or sets a value indicating whether feature picking is enabled.  If true, {@link WebMapTileServiceImageryProvider#pickFeatures} will
+   * invoke the <code>GetFeatureInfo</code> service on the WMTS server and attempt to interpret the features included in the response.  If false,
+   * {@link WebMapTileServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable
+   * features) without communicating with the server.  Set this property to false if you know your data
+   * source does not support picking features or if you don't want this provider's features to be pickable.
+   * Defaults to true for KVP encoding. For RESTful encoding, defaults to true only when
+   * {@link WebMapTileServiceImageryProvider.ConstructorOptions#getFeatureInfoUrl} is specified, and false otherwise.
+   * @memberof WebMapTileServiceImageryProvider.prototype
+   * @type {boolean}
+   */
+  enablePickFeatures: {
+    get: function () {
+      return this._tileProvider.enablePickFeatures;
+    },
+    set: function (enablePickFeatures) {
+      this._tileProvider.enablePickFeatures = enablePickFeatures;
+    },
+  },
+
   /**
    * Gets or sets a clock that is used to get keep the time used for time dynamic parameters.
    * @memberof WebMapTileServiceImageryProvider.prototype
@@ -495,6 +600,18 @@ Object.defineProperties(WebMapTileServiceImageryProvider.prototype, {
       }
     },
   },
+
+  /**
+   * Gets the getFeatureInfo URL of the WMTS server.
+   * @memberof WebMapTileServiceImageryProvider.prototype
+   * @type {Resource|string}
+   * @readonly
+   */
+  getFeatureInfoUrl: {
+    get: function () {
+      return this._getFeatureInfoUrl;
+    },
+  },
 });
 
 /**
@@ -510,7 +627,7 @@ WebMapTileServiceImageryProvider.prototype.getTileCredits = function (
   y,
   level,
 ) {
-  return undefined;
+  return this._tileProvider.getTileCredits(x, y, level);
 };
 
 /**
@@ -553,15 +670,17 @@ WebMapTileServiceImageryProvider.prototype.requestImage = function (
 };
 
 /**
- * Picking features is not currently supported by this imagery provider, so this function simply returns
- * undefined.
+ * Asynchronously determines what features, if any, are located at a given longitude and latitude within
+ * a tile.
  *
  * @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 {undefined} Undefined since picking is not supported.
+ * @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.
  */
 WebMapTileServiceImageryProvider.prototype.pickFeatures = function (
   x,
@@ -570,6 +689,122 @@ WebMapTileServiceImageryProvider.prototype.pickFeatures = function (
   longitude,
   latitude,
 ) {
-  return undefined;
+  const timeDynamicImagery = this._timeDynamicImagery;
+  const currentInterval = defined(timeDynamicImagery)
+    ? timeDynamicImagery.currentInterval
+    : undefined;
+
+  return pickFeatures(this, x, y, level, longitude, latitude, currentInterval);
 };
+
+/**
+ * The default parameters to include in the WMTS URL to obtain images.  The values are as follows:
+ *    service=WMTS
+ *    version=1.0.0
+ *    request=GetTile
+ *
+ * @constant
+ * @type {object}
+ */
+WebMapTileServiceImageryProvider.DefaultParameters = Object.freeze({
+  service: "WMTS",
+  version: "1.0.0",
+  request: "GetTile",
+});
+
+/**
+ * The default parameters to include in the WMTS URL to get feature information.  The values are as follows:
+ *     service=WMTS
+ *     version=1.0.0
+ *     request=GetFeatureInfo
+ *
+ * @constant
+ * @type {object}
+ */
+WebMapTileServiceImageryProvider.GetFeatureInfoDefaultParameters =
+  Object.freeze({
+    service: "WMTS",
+    version: "1.0.0",
+    request: "GetFeatureInfo",
+  });
+
+WebMapTileServiceImageryProvider.DefaultGetFeatureInfoFormats = Object.freeze([
+  Object.freeze(new GetFeatureInfoFormat("json", "application/json")),
+  Object.freeze(new GetFeatureInfoFormat("xml", "text/xml")),
+  Object.freeze(new GetFeatureInfoFormat("text", "text/html")),
+]);
+
+function applyDimensions(imageryProvider, resource, interval) {
+  const staticDimensions = imageryProvider._dimensions;
+  const dynamicIntervalData = defined(interval) ? interval.data : undefined;
+
+  if (!imageryProvider._useKvp) {
+    if (defined(staticDimensions)) {
+      resource.setTemplateValues(staticDimensions);
+    }
+
+    if (defined(dynamicIntervalData)) {
+      resource.setTemplateValues(dynamicIntervalData);
+    }
+  } else {
+    // build KVP request
+    let query = {};
+
+    if (defined(staticDimensions)) {
+      query = combine(query, staticDimensions);
+    }
+
+    if (defined(dynamicIntervalData)) {
+      query = combine(query, dynamicIntervalData);
+    }
+
+    resource.setQueryParameters(query);
+  }
+}
+
+function createCustomTags(imageryProvider) {
+  function getTileMatrix(level) {
+    const labels = imageryProvider._tileMatrixLabels;
+    return defined(labels) ? labels[level] : level.toString();
+  }
+
+  // We provide both uppercase and lowercase to make it more convenient for users when creating URL templates.
+  return {
+    TileMatrix: function (provider, x, y, level) {
+      return getTileMatrix(level);
+    },
+    tilematrix: function (provider, x, y, level) {
+      return getTileMatrix(level);
+    },
+    TileRow: function (provider, x, y) {
+      return y.toString();
+    },
+    tilerow: function (provider, x, y) {
+      return y.toString();
+    },
+    TileCol: function (provider, x, y) {
+      return x.toString();
+    },
+    tilecol: function (provider, x, y) {
+      return x.toString();
+    },
+    TileMatrixSet: function (provider) {
+      return imageryProvider._tilematrixset;
+    },
+    tilematrixset: function (provider) {
+      return imageryProvider._tilematrixset;
+    },
+  };
+}
+
+function objectToLowercase(obj) {
+  const result = {};
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      result[key.toLowerCase()] = obj[key];
+    }
+  }
+  return result;
+}
+
 export default WebMapTileServiceImageryProvider;