@cesium/engine 26.0.0 → 26.2.0

package/Source/DataSources/PathGraphics.js

@@ -14,10 +14,11 @@ import createPropertyDescriptor from "./createPropertyDescriptor.js";
  * @property {Property | number} [leadTime] A Property specifying the number of seconds in front the object to show.
  * @property {Property | number} [trailTime] A Property specifying the number of seconds behind of the object to show.
  * @property {Property | number} [width=1.0] A numeric Property specifying the width in pixels.
- * @property {Property | number} [resolution=60] A numeric Property specifying the maximum number of seconds to step when sampling the position.
+ * @property {Property | number} [resolution=60] A numeric Property specifying the maximum number of seconds to step when sampling the position. Fractional positive values are allowed; in PORTIONS materialMode, non-positive values fall back to the default resolution of 60 seconds.
  * @property {MaterialProperty | Color} [material=Color.WHITE] A Property specifying the material used to draw the path.
  * @property {Property | DistanceDisplayCondition} [distanceDisplayCondition] A Property specifying at what distance from the camera that this path will be displayed.
  * @property {Property | string} [relativeTo] A Property specifying the frame in which to visualize the path. Use another entity's id to visualize the path relative to that entity, or use the string values "FIXED" or "INERTIAL" to visualize the path in those reference frames.
+ * @property {Property | PathMode} [materialMode] A Property specifying how material properties are applied along the path.
  */
 
 /**
@@ -46,6 +47,8 @@ function PathGraphics(options) {
   this._distanceDisplayConditionSubscription = undefined;
   this._relativeTo = undefined;
   this._relativeToSubscription = undefined;
+  this._materialMode = undefined;
+  this._materialModeSubscription = undefined;
 
   this.merge(options ?? Frozen.EMPTY_OBJECT);
 }
@@ -95,6 +98,7 @@ Object.defineProperties(PathGraphics.prototype, {
 
   /**
    * Gets or sets the Property specifying the maximum number of seconds to step when sampling the position.
+   * Fractional positive values are allowed; in PORTIONS materialMode, non-positive values fall back to the default resolution of 60 seconds.
    * @memberof PathGraphics.prototype
    * @type {Property|undefined}
    * @default 60
@@ -125,6 +129,7 @@ Object.defineProperties(PathGraphics.prototype, {
    * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
    */
   relativeTo: createPropertyDescriptor("relativeTo"),
+  materialMode: createPropertyDescriptor("materialMode"),
 });
 
 /**
@@ -145,6 +150,7 @@ PathGraphics.prototype.clone = function (result) {
   result.material = this.material;
   result.distanceDisplayCondition = this.distanceDisplayCondition;
   result.relativeTo = this.relativeTo;
+  result.materialMode = this.materialMode;
   return result;
 };
 
@@ -170,5 +176,6 @@ PathGraphics.prototype.merge = function (source) {
   this.distanceDisplayCondition =
     this.distanceDisplayCondition ?? source.distanceDisplayCondition;
   this.relativeTo = this.relativeTo ?? source.relativeTo;
+  this.materialMode = this.materialMode ?? source.materialMode;
 };
 export default PathGraphics;

package/Source/DataSources/PathMode.js

@@ -0,0 +1,27 @@
+// @ts-check
+
+/**
+ * Defines how material properties are applied along a path.
+ *
+ * @enum {number}
+ */
+const PathMode = {
+  /**
+   * The material is applied to the entire path as a whole.
+   * @type {number}
+   * @constant
+   */
+  WHOLE: 0,
+
+  /**
+   * The material is applied in portions based on temporal position information,
+   * using interval-based material properties.
+   * @type {number}
+   * @constant
+   */
+  PORTIONS: 1,
+};
+
+Object.freeze(PathMode);
+
+export default PathMode;

package/Source/DataSources/PathVisualizer.js

@@ -17,12 +17,14 @@ import CallbackPositionProperty from "./CallbackPositionProperty.js";
 import CompositePositionProperty from "./CompositePositionProperty.js";
 import ConstantPositionProperty from "./ConstantPositionProperty.js";
 import MaterialProperty from "./MaterialProperty.js";
+import PathMode from "./PathMode.js";
 import Property from "./Property.js";
 import ReferenceProperty from "./ReferenceProperty.js";
 import SampledPositionProperty from "./SampledPositionProperty.js";
 import ScaledPositionProperty from "./ScaledPositionProperty.js";
 import TimeIntervalCollectionPositionProperty from "./TimeIntervalCollectionPositionProperty.js";
 import Quaternion from "../Core/Quaternion.js";
+import arrayRemoveDuplicates from "../Core/arrayRemoveDuplicates.js";
 
 const update3DMatrix3Scratch1 = new Matrix3();
 const update3DMatrix3Scratch2 = new Matrix3();
@@ -210,6 +212,7 @@ const subSampleIntervalPropertyScratch = new TimeInterval();
 function EntityData(entity) {
   this.entity = entity;
   this.polyline = undefined;
+  this.segmentPolylines = [];
   this.index = undefined;
   this.updater = undefined;
 }
@@ -734,6 +737,111 @@ function subSample(
 const toFixedScratch = new Matrix3();
 const updateOrientationScratch = new Quaternion();
 const updateRotationScratch = new Matrix3();
+const portionsVisibleIntervalScratch = new TimeInterval();
+const portionsSegmentIntervalScratch = new TimeInterval();
+const portionsDynamicIntervalScratch = new TimeInterval();
+
+function getDynamicMaterialProperties(materialData) {
+  const dynamic = [];
+  if (!defined(materialData)) {
+    return dynamic;
+  }
+
+  for (const key in materialData) {
+    // Material properties store uniforms as underscored backing fields.
+    // Ignore event and subscription bookkeeping fields.
+    if (
+      key[0] !== "_" ||
+      key === "_definitionChanged" ||
+      key.endsWith("Subscription")
+    ) {
+      continue;
+    }
+
+    const prop = materialData[key];
+    if (
+      defined(prop) &&
+      typeof prop.getValue === "function" &&
+      !Property.isConstant(prop)
+    ) {
+      dynamic.push(prop);
+    }
+  }
+
+  return dynamic;
+}
+
+function emitSegmentsForSplitTimes(
+  splitTimes,
+  positionProperty,
+  time,
+  pathGraphics,
+  entity,
+  item,
+  polylineCollection,
+  resolution,
+  referenceFrame,
+  materialProp,
+  startingSegIndex,
+) {
+  // Sort and dedupe
+  splitTimes.sort(JulianDate.compare);
+  splitTimes = arrayRemoveDuplicates(splitTimes, JulianDate.equalsEpsilon);
+
+  let segIndex = startingSegIndex;
+  for (let j = 0; j < splitTimes.length - 1; j++) {
+    const splitStart = splitTimes[j];
+    const splitStop = splitTimes[j + 1];
+    if (!JulianDate.lessThan(splitStart, splitStop)) {
+      continue;
+    }
+
+    // Get segment midpoint
+    const splitMidTime = JulianDate.addSeconds(
+      splitStart,
+      JulianDate.secondsDifference(splitStop, splitStart) / 2,
+      new JulianDate(),
+    );
+
+    // Subsample positions
+    const subPositions = subSample(
+      positionProperty,
+      splitStart,
+      splitStop,
+      time,
+      referenceFrame,
+      resolution,
+      [],
+    );
+    if (subPositions.length < 2) {
+      continue;
+    }
+
+    // Get or create a polyline for this segment
+    let segPolyline = item.segmentPolylines[segIndex];
+    if (!defined(segPolyline)) {
+      segPolyline = polylineCollection.add();
+      segPolyline.id = entity;
+      item.segmentPolylines[segIndex] = segPolyline;
+    }
+    segPolyline.show = true;
+    segPolyline.positions = subPositions;
+    segPolyline.material = MaterialProperty.getValue(
+      splitMidTime,
+      materialProp,
+      segPolyline.material,
+    );
+    segPolyline.width = Property.getValueOrDefault(
+      pathGraphics._width,
+      time,
+      defaultWidth,
+    );
+
+    segIndex++;
+  }
+  return segIndex;
+}
+
 function PolylineUpdater(scene, referenceFrame) {
   this._unusedIndexes = [];
   this._polylineCollection = new PolylineCollection();
@@ -845,6 +953,9 @@ PolylineUpdater.prototype.updateObject = function (time, item) {
       polyline.show = false;
       item.index = undefined;
     }
+    for (let j = 0; j < item.segmentPolylines.length; j++) {
+      item.segmentPolylines[j].show = false;
+    }
     return;
   }
 
@@ -883,16 +994,198 @@ PolylineUpdater.prototype.updateObject = function (time, item) {
   // This can happen if the position is sampled at a time when it is only defined at a single point
   if (positions.length < 2) {
     polyline.show = false;
+    for (let j = 0; j < item.segmentPolylines.length; j++) {
+      item.segmentPolylines[j].show = false;
+    }
     return;
   }
 
   polyline.show = true;
   polyline.positions = positions;
+
   polyline.material = MaterialProperty.getValue(
     time,
-    pathGraphics._material,
+    pathGraphics.material,
     polyline.material,
   );
+
+  const materialMode = Property.getValueOrUndefined(
+    pathGraphics.materialMode,
+    time,
+  );
+  const materialProp = pathGraphics.material;
+  if (materialMode === PathMode.PORTIONS && !materialProp.isConstant) {
+    // Hide the single polyline if it exists
+    if (defined(polyline)) {
+      polyline.show = false;
+    }
+
+    // Prevent non-positive split steps from creating non-terminating loops.
+    // Positive fractional resolutions are valid; only values <= 0 fall back to the default.
+    const splitResolution = resolution > 0 ? resolution : defaultResolution;
+
+    const intervals = materialProp.intervals;
+    let nextSegIndex = 0;
+
+    if (!defined(intervals)) {
+      // Sampled/interpolated root material - generate synthetic times at resolution intervals
+      const splitTimes = [
+        JulianDate.clone(sampleStart),
+        JulianDate.clone(sampleStop),
+      ];
+      let splitTime = JulianDate.addSeconds(
+        sampleStart,
+        splitResolution,
+        new JulianDate(),
+      );
+      while (JulianDate.lessThan(splitTime, sampleStop)) {
+        splitTimes.push(JulianDate.clone(splitTime));
+        splitTime = JulianDate.addSeconds(
+          splitTime,
+          splitResolution,
+          new JulianDate(),
+        );
+      }
+      nextSegIndex = emitSegmentsForSplitTimes(
+        splitTimes,
+        positionProperty,
+        time,
+        pathGraphics,
+        entity,
+        item,
+        this._polylineCollection,
+        splitResolution,
+        this._referenceFrame,
+        pathGraphics.material,
+        nextSegIndex,
+      );
+    } else {
+      portionsVisibleIntervalScratch.start = sampleStart;
+      portionsVisibleIntervalScratch.stop = sampleStop;
+      portionsVisibleIntervalScratch.isStartIncluded = true;
+      portionsVisibleIntervalScratch.isStopIncluded = true;
+
+      // Interval-based material - process each interval separately
+      for (let i = 0; i < intervals.length; i++) {
+        const interval = intervals.get(i);
+
+        if (
+          !TimeInterval.intersect(
+            interval,
+            portionsVisibleIntervalScratch,
+            portionsSegmentIntervalScratch,
+          )
+        ) {
+          continue;
+        }
+
+        const segStart = portionsSegmentIntervalScratch.start;
+        const segStop = portionsSegmentIntervalScratch.stop;
+
+        if (JulianDate.greaterThanOrEquals(segStart, segStop)) {
+          continue;
+        }
+
+        // Detect dynamic properties and collect their split times
+        const dynamic = getDynamicMaterialProperties(interval.data);
+        const splitTimes = [
+          JulianDate.clone(segStart),
+          JulianDate.clone(segStop),
+        ];
+
+        for (let j = 0; j < dynamic.length; j++) {
+          const prop = dynamic[j];
+          const timeDynamicIntervals = prop.intervals;
+
+          if (defined(timeDynamicIntervals)) {
+            // Interval-based property: collect interval boundaries
+            for (let k = 0; k < timeDynamicIntervals.length; k++) {
+              const timeDynamicInterval = timeDynamicIntervals.get(k);
+
+              if (
+                !TimeInterval.intersect(
+                  timeDynamicInterval,
+                  portionsSegmentIntervalScratch,
+                  portionsDynamicIntervalScratch,
+                )
+              ) {
+                continue;
+              }
+
+              if (
+                JulianDate.greaterThan(
+                  portionsDynamicIntervalScratch.start,
+                  segStart,
+                ) &&
+                JulianDate.lessThan(
+                  portionsDynamicIntervalScratch.start,
+                  segStop,
+                )
+              ) {
+                splitTimes.push(
+                  JulianDate.clone(portionsDynamicIntervalScratch.start),
+                );
+              }
+
+              if (
+                JulianDate.greaterThan(
+                  portionsDynamicIntervalScratch.stop,
+                  segStart,
+                ) &&
+                JulianDate.lessThan(
+                  portionsDynamicIntervalScratch.stop,
+                  segStop,
+                )
+              ) {
+                splitTimes.push(
+                  JulianDate.clone(portionsDynamicIntervalScratch.stop),
+                );
+              }
+            }
+          } else if (!Property.isConstant(prop)) {
+            // Sampled/interpolated property: add resolution-based split times
+            let sampledTime = JulianDate.clone(segStart);
+            while (JulianDate.lessThan(sampledTime, segStop)) {
+              splitTimes.push(JulianDate.clone(sampledTime));
+              sampledTime = JulianDate.addSeconds(
+                sampledTime,
+                splitResolution,
+                new JulianDate(),
+              );
+            }
+          }
+        }
+
+        // Emit segments for this interval's split times
+        nextSegIndex = emitSegmentsForSplitTimes(
+          splitTimes,
+          positionProperty,
+          time,
+          pathGraphics,
+          entity,
+          item,
+          this._polylineCollection,
+          splitResolution,
+          this._referenceFrame,
+          interval.data,
+          nextSegIndex,
+        );
+      }
+    }
+
+    // Hide any excess segment polylines from previous frames.
+    for (let j = nextSegIndex; j < item.segmentPolylines.length; j++) {
+      if (defined(item.segmentPolylines[j])) {
+        item.segmentPolylines[j].show = false;
+      }
+    }
+  } else {
+    // Not in PORTIONS mode, hide all segment polylines from previous frames
+    for (let j = 0; j < item.segmentPolylines.length; j++) {
+      item.segmentPolylines[j].show = false;
+    }
+  }
+
   polyline.width = Property.getValueOrDefault(
     pathGraphics._width,
     time,
@@ -914,6 +1207,10 @@ PolylineUpdater.prototype.removeObject = function (item) {
     polyline.id = undefined;
     item.index = undefined;
   }
+  for (let i = 0; i < item.segmentPolylines.length; i++) {
+    item.segmentPolylines[i].show = false;
+  }
+  item.segmentPolylines.length = 0;
 };
 
 PolylineUpdater.prototype.destroy = function () {

package/Source/DataSources/PolylineVisualizer.js

@@ -295,7 +295,7 @@ PolylineVisualizer.prototype.getBoundingSphere = function (entity, result) {
   const tmp = getBoundingSphereBoundingSphereScratch;
 
   let count = 0;
-  let state = BoundingSphereState.DONE;
+  let state;
   const batches = this._batches;
   const batchesLength = batches.length;
   const updater = this._updaters.get(entity.id);

package/Source/DataSources/StaticOutlineGeometryBatch.js

@@ -375,7 +375,7 @@ StaticOutlineGeometryBatch.prototype.update = function (time) {
   const translucentBatchesLength = translucentBatches.length;
   let itemsToRemove;
   let isUpdated = true;
-  let needUpdate = false;
+  let needUpdate;
 
   do {
     needUpdate = false;

package/Source/Renderer/AutomaticUniforms.js

@@ -222,6 +222,29 @@ const AutomaticUniforms = {
     },
   }),
 
+  /**
+   * An automatic GLSL uniform containing the feature-ID texture produced by
+   * the planar fill pre-pass (BENTLEY_materials_planar_fill). Non-behind
+   * planar fill geometry writes its per-fragment feature ID here so that
+   * behind fills can test whether the existing pixel belongs to the same
+   * logical object.
+   *
+   * @example
+   * // GLSL declaration
+   * uniform sampler2D czm_planarFillIdTexture;
+   *
+   * // Sample
+   * vec2 coords = gl_FragCoord.xy / czm_viewport.zw;
+   * float existingFeatureId = texture(czm_planarFillIdTexture, coords).r;
+   */
+  czm_planarFillIdTexture: new AutomaticUniform({
+    size: 1,
+    datatype: WebGLConstants.SAMPLER_2D,
+    getValue: function (uniformState) {
+      return uniformState.planarFillIdTexture;
+    },
+  }),
+
   /**
    * An automatic GLSL uniform representing a 4x4 model transformation matrix that
    * transforms model coordinates to world coordinates.

package/Source/Renderer/Context.js

@@ -1010,20 +1010,26 @@ Object.defineProperties(Context.prototype, {
   },
 
   /**
-   * A 1x1 RGBA texture initialized to [255, 255, 255, 255].  This can
-   * be used as a placeholder texture while other textures are downloaded.
+   * A 1x1 RGBA texture initialized to the color defined by {@link Texture.defaultColor}.
+   * This can be used as a placeholder texture while other textures are downloaded.
    * @memberof Context.prototype
    * @type {Texture}
    */
   defaultTexture: {
     get: function () {
       if (this._defaultTexture === undefined) {
+        const color = Texture.defaultColor;
         this._defaultTexture = new Texture({
           context: this,
           source: {
             width: 1,
             height: 1,
-            arrayBufferView: new Uint8Array([255, 255, 255, 255]),
+            arrayBufferView: new Uint8Array([
+              color.red * 255,
+              color.green * 255,
+              color.blue * 255,
+              color.alpha * 255,
+            ]),
           },
           flipY: false,
         });

package/Source/Renderer/DrawCommand.js

@@ -47,6 +47,7 @@ const Flags = {
  * @property {Pass} [pass]
  * @property {object} [owner]
  * @property {string} [pickId]
+ * @property {string} [snapId]
  * @property {boolean} [pickMetadataAllowed=false]
  * @property {boolean} [cull=true]
  * @property {boolean} [occlude=true]
@@ -102,6 +103,7 @@ class DrawCommand {
     this._debugOverlappingFrustums = 0;
     /** @private */
     this._pickId = options.pickId;
+    this._snapId = options.snapId;
     /** @private */
     this._pickMetadataAllowed = options.pickMetadataAllowed === true;
     /**
@@ -532,6 +534,25 @@ class DrawCommand {
     }
   }
 
+  /**
+   * A GLSL string that will evaluate to the float snap payload written during
+   * a snapping pass (see {@link Scene#snap}). When <code>undefined</code>, the
+   * command does not render during a snapping pass.
+   *
+   * @type {string|undefined}
+   * @default undefined
+   */
+  get snapId() {
+    return this._snapId;
+  }
+
+  set snapId(value) {
+    if (this._snapId !== value) {
+      this._snapId = value;
+      this.dirty = true;
+    }
+  }
+
   /**
    * Whether metadata picking is allowed.
    *
@@ -628,6 +649,7 @@ class DrawCommand {
     result._owner = command._owner;
     result._debugOverlappingFrustums = command._debugOverlappingFrustums;
     result._pickId = command._pickId;
+    result._snapId = command._snapId;
     result._pickMetadataAllowed = command._pickMetadataAllowed;
     result._pickedMetadataInfo = command._pickedMetadataInfo;
     result._flags = command._flags;

package/Source/Renderer/Framebuffer.js

@@ -287,6 +287,10 @@ function Framebuffer(options) {
   }
 
   this._unBind();
+
+  // _bind and _unBind bypass the context's framebuffer binding cache. The GL
+  // binding is now the default framebuffer; update the cache to match.
+  context._currentFramebuffer = undefined;
 }
 
 Object.defineProperties(Framebuffer.prototype, {

package/Source/Renderer/Pass.js

@@ -19,16 +19,17 @@ const Pass = {
   GLOBE: 2,
   TERRAIN_CLASSIFICATION: 3,
   CESIUM_3D_TILE_EDGES: 4,
-  CESIUM_3D_TILE: 5,
-  CESIUM_3D_TILE_CLASSIFICATION: 6,
-  CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW: 7,
-  OPAQUE: 8,
-  TRANSLUCENT: 9,
-  VOXELS: 10,
-  GAUSSIAN_SPLATS: 11,
-  CESIUM_3D_TILE_EDGES_DIRECT: 12,
-  OVERLAY: 13,
-  NUMBER_OF_PASSES: 14,
+  CESIUM_3D_TILE_PLANAR_FILL_ID: 5,
+  CESIUM_3D_TILE: 6,
+  CESIUM_3D_TILE_CLASSIFICATION: 7,
+  CESIUM_3D_TILE_CLASSIFICATION_IGNORE_SHOW: 8,
+  OPAQUE: 9,
+  TRANSLUCENT: 10,
+  VOXELS: 11,
+  GAUSSIAN_SPLATS: 12,
+  CESIUM_3D_TILE_EDGES_DIRECT: 13,
+  OVERLAY: 14,
+  NUMBER_OF_PASSES: 15,
 };
 
 Object.freeze(Pass);

package/Source/Renderer/Texture.js

@@ -1,5 +1,6 @@
 import Cartesian2 from "../Core/Cartesian2.js";
 import Check from "../Core/Check.js";
+import Color from "../Core/Color.js";
 import createGuid from "../Core/createGuid.js";
 import Frozen from "../Core/Frozen.js";
 import defined from "../Core/defined.js";
@@ -576,7 +577,7 @@ function loadNull(texture) {
 /**
  * This function is identical to using the Texture constructor except that it can be
  * replaced with a mock/spy in tests.
- * @private
+ * @ignore
  */
 Texture.create = function (options) {
   return new Texture(options);
@@ -1123,4 +1124,14 @@ Texture.prototype.destroy = function () {
   this._context._gl.deleteTexture(this._texture);
   return destroyObject(this);
 };
+
+/**
+ * The default color used as a placeholder texture while other textures are downloaded.
+ * This can be changed globally to customize the placeholder appearance.
+ *
+ * @type {Color}
+ * @default Color.WHITE
+ */
+Texture.defaultColor = Color.WHITE;
+
 export default Texture;

package/Source/Renderer/UniformState.js

@@ -37,6 +37,13 @@ function UniformState() {
    * @type {Texture}
    */
   this.edgeDepthTexture = undefined; // packed depth color attachment from edge pass
+  /**
+   * Texture written by the planar fill feature-ID pre-pass.
+   * Contains per-pixel feature IDs for non-behind planar fill geometry.
+   * Sampled by behind fills to test same-object coplanarity.
+   * @type {Texture}
+   */
+  this.planarFillIdTexture = undefined;
   /**
    * @type {number}
    */

package/Source/Renderer/VertexArray.js

@@ -16,6 +16,7 @@ import assert from "../Core/assert.js";
 
 /** @import {TypedArray, TypedArrayConstructor} from "../Core/globalTypes.js"; */
 
+/** @ignore */
 function addAttribute(attributes, attribute, index, context) {
   const hasVertexBuffer = defined(attribute.vertexBuffer);
   const hasValue = defined(attribute.value);
@@ -644,7 +645,6 @@ VertexArray.fromGeometry = function (options) {
         }
 
         let attrProps = {};
-        vertexBuffer = undefined;
         if (defined(attribute.values)) {
           vertexBuffer = Buffer.createVertexBuffer({
             context: context,

package/Source/Scene/ArcGisMapServerImageryProvider.js

@@ -325,11 +325,6 @@ function ArcGisMapServerImageryProvider(options) {
   this._credit = options.credit;
   this._tileCredits = undefined;
 
-  let credit = options.credit;
-  if (typeof credit === "string") {
-    credit = new Credit(credit);
-  }
-
   /**
    * Gets or sets a value indicating whether feature picking is enabled.  If true, {@link ArcGisMapServerImageryProvider#pickFeatures} will
    * invoke the "identify" operation on the ArcGIS server and return the features included in the response.  If false,

package/Source/Scene/ArcGisMapService.js

@@ -4,7 +4,7 @@ import Resource from "../Core/Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "AAPTauP-rqeCeHTtrSMga9XbPxQ..ZMIZzf1tcwicoJi5E5T2mG0EO3qlIRkQNe5S-uA95RJKU0YkrwOT0AF-lSIyXXBFakDJIPaxsZ5vpnzlaW3kCYG2Tk53bY6OntMqn1EBYtDPyqz38iM4NU_bbDN3DuxUdkxYDWnxJXxxWe3bEeUANbvhKK76PU7N0wjZgtEYHYocspYXSHxbCEYo_eXrHDkrWpgkzcmQ3WpQqf2XprJ39pbqVSZbxskDh3zBm92XxUaiSmdf7rC1w3VoAT1_UarLJfAQ";
+  "AAPTa7BPWL4PoZRFPJ2CM2YRclg..ub1vMOBXctC7ozMMKNnmx3ZwVTsDJAXo2GLomQ2CZjuOc2HLr1-CryeuRo9ZsV65cuZ9xN1yFKeLTu7Cxld7B97aI28os_NnuC9nvWde_l4G1DTApSHmhrVoZfKgO0bqOrsDfvvSgO-cdkUEvBASNX_4Lb9tB5fEY7lbYaWdOOWBXyZylR9il0-biB248V6HdDT1kgkSwz9esfKialRTLgxJx8AFM9is--UXK0CLvZn6JUU44PZSFuMyAT1_rgxsirsZ";
 /**
  * Default options for accessing the ArcGIS image tile service.
  *