@cesium/engine 26.1.0 → 26.2.0

package/Source/Core/CoplanarPolygonGeometry.js

@@ -368,7 +368,7 @@ CoplanarPolygonGeometry.pack = function (value, array, startingIndex) {
   } else {
     array[startingIndex++] = -1.0;
   }
-  array[startingIndex++] = value.packedLength;
+  array[startingIndex] = value.packedLength;
 
   return array;
 };
@@ -426,7 +426,7 @@ CoplanarPolygonGeometry.unpack = function (array, startingIndex, result) {
   } else {
     startingIndex++;
   }
-  const packedLength = array[startingIndex++];
+  const packedLength = array[startingIndex];
 
   if (!defined(result)) {
     result = new CoplanarPolygonGeometry(scratchOptions);

package/Source/Core/CorridorGeometry.js

@@ -63,7 +63,6 @@ function combine(computedPositions, vertexFormat, ellipsoid) {
   const computedLefts = computedPositions.lefts;
   const computedNormals = computedPositions.normals;
   const attributes = new GeometryAttributes();
-  let corner;
   let leftCount = 0;
   let rightCount = 0;
   let i;
@@ -78,7 +77,6 @@ function combine(computedPositions, vertexFormat, ellipsoid) {
   leftCount += 3; //add back count for end positions
   rightCount += 3;
   for (i = 0; i < corners.length; i++) {
-    corner = corners[i];
     const leftSide = corners[i].leftPositions;
     if (defined(leftSide)) {
       length = leftSide.length;
@@ -221,7 +219,7 @@ function combine(computedPositions, vertexFormat, ellipsoid) {
   compIndex += 3;
   for (i = 0; i < corners.length; i++) {
     let j;
-    corner = corners[i];
+    const corner = corners[i];
     const l = corner.leftPositions;
     const r = corner.rightPositions;
     let pivot;
@@ -727,7 +725,7 @@ function addWallPositions(positions, index, wallPositions) {
   }
   wallPositions[index++] = positions[0];
   wallPositions[index++] = positions[1];
-  wallPositions[index++] = positions[2];
+  wallPositions[index] = positions[2];
 
   return wallPositions;
 }

package/Source/Core/CorridorOutlineGeometry.js

@@ -49,7 +49,6 @@ function combine(computedPositions, cornerType) {
   leftCount += 3; //add back count for end positions
   rightCount += 3;
   for (i = 0; i < corners.length; i++) {
-    corner = corners[i];
     const leftSide = corners[i].leftPositions;
     if (defined(leftSide)) {
       length = leftSide.length;
@@ -200,7 +199,6 @@ function combine(computedPositions, cornerType) {
     leftEdge.splice(leftEdge.length - 3, 3);
     finalPositions.set(rightEdge, front);
     finalPositions.set(leftEdge, back - leftEdge.length + 1);
-    length = leftEdge.length - 3;
 
     for (j = 0; j < leftEdge.length; j += 3) {
       LR = front / 3;
@@ -259,7 +257,7 @@ function combine(computedPositions, cornerType) {
     wallIndices.push(front / 3, (back - 2) / 3);
   }
   indices[index++] = front / 3;
-  indices[index++] = (back - 2) / 3;
+  indices[index] = (back - 2) / 3;
 
   attributes.position = new GeometryAttribute({
     componentDatatype: ComponentDatatype.DOUBLE,

package/Source/Core/EarthOrientationParameters.js

@@ -182,8 +182,8 @@ EarthOrientationParameters.prototype.compute = function (date, result) {
   const dates = this._dates;
   const lastIndex = this._lastIndex;
 
-  let before = 0;
-  let after = 0;
+  let before;
+  let after;
   if (defined(lastIndex)) {
     const previousIndexDate = dates[lastIndex];
     const nextIndexDate = dates[lastIndex + 1];

package/Source/Core/EllipseGeometryLibrary.js

@@ -349,14 +349,14 @@ EllipseGeometryLibrary.computeEllipsePositions = function (
   if (addFillPositions) {
     positions[positionIndex++] = position.x;
     positions[positionIndex++] = position.y;
-    positions[positionIndex++] = position.z;
+    positions[positionIndex] = position.z;
     r.positions = positions;
     r.numPts = numPts;
   }
   if (addEdgePositions) {
     outerPositions[outerRightIndex--] = position.z;
     outerPositions[outerRightIndex--] = position.y;
-    outerPositions[outerRightIndex--] = position.x;
+    outerPositions[outerRightIndex] = position.x;
     r.outerPositions = outerPositions;
   }
 

package/Source/Core/EllipsoidGeodesic.js

@@ -133,10 +133,10 @@ function vincentyInverseFormula(
   const sc = sineU1 * cosineU2;
 
   let lambda = l;
-  let lambdaDot = CesiumMath.TWO_PI;
+  let lambdaDot;
 
-  let cosineLambda = Math.cos(lambda);
-  let sineLambda = Math.sin(lambda);
+  let cosineLambda;
+  let sineLambda;
 
   let sigma;
   let cosineSigma;

package/Source/Core/EllipsoidRhumbLine.js

@@ -200,7 +200,7 @@ function calculateArcLength(
   const heading = ellipsoidRhumbLine._heading;
   const deltaLongitude = secondLongitude - firstLongitude;
 
-  let distance = 0.0;
+  let distance;
 
   //Check to see if the rhumb line has constant latitude
   //This equation will diverge if heading gets close to 90 degrees

package/Source/Core/GroundPolylineGeometry.js

@@ -318,7 +318,7 @@ GroundPolylineGeometry.pack = function (value, array, startingIndex) {
   index += Ellipsoid.packedLength;
 
   array[index++] = value._projectionIndex;
-  array[index++] = value._scene3DOnly ? 1.0 : 0.0;
+  array[index] = value._scene3DOnly ? 1.0 : 0.0;
 
   return array;
 };
@@ -352,7 +352,7 @@ GroundPolylineGeometry.unpack = function (array, startingIndex, result) {
   index += Ellipsoid.packedLength;
 
   const projectionIndex = array[index++];
-  const scene3DOnly = array[index++] === 1.0;
+  const scene3DOnly = array[index] === 1.0;
 
   if (!defined(result)) {
     result = new GroundPolylineGeometry({

package/Source/Core/Heap.js

@@ -121,7 +121,7 @@ Heap.prototype.heapify = function (index) {
   const length = this._length;
   const comparator = this._comparator;
   const array = this._array;
-  let candidate = -1;
+  let candidate;
   let inserting = true;
 
   while (inserting) {

package/Source/Core/HermitePolynomialApproximation.js

@@ -1,9 +1,22 @@
+// @ts-check
+
 import defined from "./defined.js";
 import DeveloperError from "./DeveloperError.js";
 import CesiumMath from "./Math.js";
 
 const factorial = CesiumMath.factorial;
 
+/**
+ * @param {number} x
+ * @param {number[]} zIndices
+ * @param {number[]} xTable
+ * @param {number} derivOrder
+ * @param {number} termOrder
+ * @param {number[]} reservedIndices
+ * @returns {number}
+ *
+ * @private
+ */
 function calculateCoefficientTerm(
   x,
   zIndices,
@@ -61,223 +74,245 @@ function calculateCoefficientTerm(
 }
 
 /**
- * An {@link InterpolationAlgorithm} for performing Hermite interpolation.
+ * @type {number[]}
  *
- * @namespace HermitePolynomialApproximation
+ * @private
  */
-const HermitePolynomialApproximation = {
-  type: "Hermite",
-};
+const arrayScratch = [];
 
 /**
- * Given the desired degree, returns the number of data points required for interpolation.
+ * An {@link InterpolationAlgorithm} for performing Hermite interpolation.
  *
- * @param {number} degree The desired degree of interpolation.
- * @param {number} [inputOrder=0]  The order of the inputs (0 means just the data, 1 means the data and its derivative, etc).
- * @returns {number} The number of required data points needed for the desired degree of interpolation.
- * @exception {DeveloperError} degree must be 0 or greater.
- * @exception {DeveloperError} inputOrder must be 0 or greater.
+ * @namespace HermitePolynomialApproximation
  */
-HermitePolynomialApproximation.getRequiredDataPoints = function (
-  degree,
-  inputOrder,
-) {
-  inputOrder = inputOrder ?? 0;
-
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(degree)) {
-    throw new DeveloperError("degree is required.");
+class HermitePolynomialApproximation {
+  /**
+   * Gets the name of this interpolation algorithm.
+   * @type {string}
+   */
+  static get type() {
+    return "Hermite";
   }
-  if (degree < 0) {
-    throw new DeveloperError("degree must be 0 or greater.");
-  }
-  if (inputOrder < 0) {
-    throw new DeveloperError("inputOrder must be 0 or greater.");
-  }
-  //>>includeEnd('debug');
 
-  return Math.max(Math.floor((degree + 1) / (inputOrder + 1)), 2);
-};
+  /**
+   * Given the desired degree, returns the number of data points required for interpolation.
+   *
+   * @param {number} degree The desired degree of interpolation.
+   * @param {number} [inputOrder=0]  The order of the inputs (0 means just the data, 1 means the data and its derivative, etc).
+   * @returns {number} The number of required data points needed for the desired degree of interpolation.
+   * @exception {DeveloperError} degree must be 0 or greater.
+   * @exception {DeveloperError} inputOrder must be 0 or greater.
+   */
+  static getRequiredDataPoints(degree, inputOrder) {
+    inputOrder = inputOrder ?? 0;
+
+    //>>includeStart('debug', pragmas.debug);
+    if (!defined(degree)) {
+      throw new DeveloperError("degree is required.");
+    }
+    if (degree < 0) {
+      throw new DeveloperError("degree must be 0 or greater.");
+    }
+    if (inputOrder < 0) {
+      throw new DeveloperError("inputOrder must be 0 or greater.");
+    }
+    //>>includeEnd('debug');
 
-/**
- * Interpolates values using Hermite Polynomial Approximation.
- *
- * @param {number} x The independent variable for which the dependent variables will be interpolated.
- * @param {number[]} xTable The array of independent variables to use to interpolate.  The values
- * in this array must be in increasing order and the same value must not occur twice in the array.
- * @param {number[]} yTable The array of dependent variables to use to interpolate.  For a set of three
- * dependent values (p,q,w) at time 1 and time 2 this should be as follows: {p1, q1, w1, p2, q2, w2}.
- * @param {number} yStride The number of dependent variable values in yTable corresponding to
- * each independent variable value in xTable.
- * @param {number[]} [result] An existing array into which to store the result.
- * @returns {number[]} The array of interpolated values, or the result parameter if one was provided.
- */
-HermitePolynomialApproximation.interpolateOrderZero = function (
-  x,
-  xTable,
-  yTable,
-  yStride,
-  result,
-) {
-  if (!defined(result)) {
-    result = new Array(yStride);
+    return Math.max(Math.floor((degree + 1) / (inputOrder + 1)), 2);
   }
 
-  let i;
-  let j;
-  let d;
-  let s;
-  let len;
-  let index;
-  const length = xTable.length;
-  const coefficients = new Array(yStride);
-
-  for (i = 0; i < yStride; i++) {
-    result[i] = 0;
-
-    const l = new Array(length);
-    coefficients[i] = l;
-    for (j = 0; j < length; j++) {
-      l[j] = [];
+  /**
+   * Interpolates values using Hermite Polynomial Approximation.
+   *
+   * @param {number} x The independent variable for which the dependent variables will be interpolated.
+   * @param {number[]} xTable The array of independent variables to use to interpolate.  The values
+   * in this array must be in increasing order and the same value must not occur twice in the array.
+   * @param {number[]} yTable The array of dependent variables to use to interpolate.  For a set of three
+   * dependent values (p,q,w) at time 1 and time 2 this should be as follows: {p1, q1, w1, p2, q2, w2}.
+   * @param {number} yStride The number of dependent variable values in yTable corresponding to
+   * each independent variable value in xTable.
+   * @param {number[]} [result] An existing array into which to store the result.
+   * @returns {number[]} The array of interpolated values, or the result parameter if one was provided.
+   */
+  static interpolateOrderZero(x, xTable, yTable, yStride, result) {
+    if (!defined(result)) {
+      result = new Array(yStride);
     }
-  }
 
-  const zIndicesLength = length,
-    zIndices = new Array(zIndicesLength);
+    let i;
+    let j;
+    let d;
+    let s;
+    let len;
+    let index;
+    const length = xTable.length;
+    const coefficients = new Array(yStride);
+
+    for (i = 0; i < yStride; i++) {
+      result[i] = 0;
+
+      const l = new Array(length);
+      coefficients[i] = l;
+      for (j = 0; j < length; j++) {
+        l[j] = [];
+      }
+    }
 
-  for (i = 0; i < zIndicesLength; i++) {
-    zIndices[i] = i;
-  }
+    const zIndicesLength = length,
+      zIndices = new Array(zIndicesLength);
 
-  let highestNonZeroCoef = length - 1;
-  for (s = 0; s < yStride; s++) {
-    for (j = 0; j < zIndicesLength; j++) {
-      index = zIndices[j] * yStride + s;
-      coefficients[s][0].push(yTable[index]);
+    for (i = 0; i < zIndicesLength; i++) {
+      zIndices[i] = i;
     }
 
-    for (i = 1; i < zIndicesLength; i++) {
-      let nonZeroCoefficients = false;
-      for (j = 0; j < zIndicesLength - i; j++) {
-        const zj = xTable[zIndices[j]];
-        const zn = xTable[zIndices[j + i]];
+    let highestNonZeroCoef = length - 1;
+    for (s = 0; s < yStride; s++) {
+      for (j = 0; j < zIndicesLength; j++) {
+        index = zIndices[j] * yStride + s;
+        coefficients[s][0].push(yTable[index]);
+      }
 
-        let numerator;
-        if (zn - zj <= 0) {
-          index = zIndices[j] * yStride + yStride * i + s;
-          numerator = yTable[index];
-          coefficients[s][i].push(numerator / factorial(i));
-        } else {
-          numerator = coefficients[s][i - 1][j + 1] - coefficients[s][i - 1][j];
-          coefficients[s][i].push(numerator / (zn - zj));
+      for (i = 1; i < zIndicesLength; i++) {
+        let nonZeroCoefficients = false;
+        for (j = 0; j < zIndicesLength - i; j++) {
+          const zj = xTable[zIndices[j]];
+          const zn = xTable[zIndices[j + i]];
+
+          let numerator;
+          if (zn - zj <= 0) {
+            index = zIndices[j] * yStride + yStride * i + s;
+            numerator = yTable[index];
+            coefficients[s][i].push(numerator / factorial(i));
+          } else {
+            numerator =
+              coefficients[s][i - 1][j + 1] - coefficients[s][i - 1][j];
+            coefficients[s][i].push(numerator / (zn - zj));
+          }
+          nonZeroCoefficients = nonZeroCoefficients || numerator !== 0;
         }
-        nonZeroCoefficients = nonZeroCoefficients || numerator !== 0;
-      }
 
-      if (!nonZeroCoefficients) {
-        highestNonZeroCoef = i - 1;
+        if (!nonZeroCoefficients) {
+          highestNonZeroCoef = i - 1;
+        }
       }
     }
-  }
 
-  for (d = 0, len = 0; d <= len; d++) {
-    for (i = d; i <= highestNonZeroCoef; i++) {
-      const tempTerm = calculateCoefficientTerm(x, zIndices, xTable, d, i, []);
-      for (s = 0; s < yStride; s++) {
-        const coeff = coefficients[s][i][0];
-        result[s + d * yStride] += coeff * tempTerm;
+    for (d = 0, len = 0; d <= len; d++) {
+      for (i = d; i <= highestNonZeroCoef; i++) {
+        const tempTerm = calculateCoefficientTerm(
+          x,
+          zIndices,
+          xTable,
+          d,
+          i,
+          [],
+        );
+        for (s = 0; s < yStride; s++) {
+          const coeff = coefficients[s][i][0];
+          result[s + d * yStride] += coeff * tempTerm;
+        }
       }
     }
-  }
-
-  return result;
-};
-
-const arrayScratch = [];
-
-/**
- * Interpolates values using Hermite Polynomial Approximation.
- *
- * @param {number} x The independent variable for which the dependent variables will be interpolated.
- * @param {number[]} xTable The array of independent variables to use to interpolate.  The values
- * in this array must be in increasing order and the same value must not occur twice in the array.
- * @param {number[]} yTable The array of dependent variables to use to interpolate.  For a set of three
- * dependent values (p,q,w) at time 1 and time 2 this should be as follows: {p1, q1, w1, p2, q2, w2}.
- * @param {number} yStride The number of dependent variable values in yTable corresponding to
- * each independent variable value in xTable.
- * @param {number} inputOrder The number of derivatives supplied for input.
- * @param {number} outputOrder The number of derivatives desired for output.
- * @param {number[]} [result] An existing array into which to store the result.
- *
- * @returns {number[]} The array of interpolated values, or the result parameter if one was provided.
- */
-HermitePolynomialApproximation.interpolate = function (
-  x,
-  xTable,
-  yTable,
-  yStride,
-  inputOrder,
-  outputOrder,
-  result,
-) {
-  const resultLength = yStride * (outputOrder + 1);
-  if (!defined(result)) {
-    result = new Array(resultLength);
-  }
-  for (let r = 0; r < resultLength; r++) {
-    result[r] = 0;
-  }
 
-  const length = xTable.length;
-  // The zIndices array holds copies of the addresses of the xTable values
-  // in the range we're looking at. Even though this just holds information already
-  // available in xTable this is a much more convenient format.
-  const zIndices = new Array(length * (inputOrder + 1));
-  let i;
-  for (i = 0; i < length; i++) {
-    for (let j = 0; j < inputOrder + 1; j++) {
-      zIndices[i * (inputOrder + 1) + j] = i;
-    }
+    return result;
   }
 
-  const zIndiceslength = zIndices.length;
-  const coefficients = arrayScratch;
-  const highestNonZeroCoef = fillCoefficientList(
-    coefficients,
-    zIndices,
+  /**
+   * Interpolates values using Hermite Polynomial Approximation.
+   *
+   * @param {number} x The independent variable for which the dependent variables will be interpolated.
+   * @param {number[]} xTable The array of independent variables to use to interpolate.  The values
+   * in this array must be in increasing order and the same value must not occur twice in the array.
+   * @param {number[]} yTable The array of dependent variables to use to interpolate.  For a set of three
+   * dependent values (p,q,w) at time 1 and time 2 this should be as follows: {p1, q1, w1, p2, q2, w2}.
+   * @param {number} yStride The number of dependent variable values in yTable corresponding to
+   * each independent variable value in xTable.
+   * @param {number} inputOrder The number of derivatives supplied for input.
+   * @param {number} outputOrder The number of derivatives desired for output.
+   * @param {number[]} [result] An existing array into which to store the result.
+   *
+   * @returns {number[]} The array of interpolated values, or the result parameter if one was provided.
+   */
+  static interpolate(
+    x,
     xTable,
     yTable,
     yStride,
     inputOrder,
-  );
-  const reservedIndices = [];
+    outputOrder,
+    result,
+  ) {
+    const resultLength = yStride * (outputOrder + 1);
+    if (!defined(result)) {
+      result = new Array(resultLength);
+    }
+    for (let r = 0; r < resultLength; r++) {
+      result[r] = 0;
+    }
 
-  const tmp = (zIndiceslength * (zIndiceslength + 1)) / 2;
-  const loopStop = Math.min(highestNonZeroCoef, outputOrder);
-  for (let d = 0; d <= loopStop; d++) {
-    for (i = d; i <= highestNonZeroCoef; i++) {
-      reservedIndices.length = 0;
-      const tempTerm = calculateCoefficientTerm(
-        x,
-        zIndices,
-        xTable,
-        d,
-        i,
-        reservedIndices,
-      );
-      const dimTwo = Math.floor((i * (1 - i)) / 2) + zIndiceslength * i;
+    const length = xTable.length;
+    // The zIndices array holds copies of the addresses of the xTable values
+    // in the range we're looking at. Even though this just holds information already
+    // available in xTable this is a much more convenient format.
+    const zIndices = new Array(length * (inputOrder + 1));
+    let i;
+    for (i = 0; i < length; i++) {
+      for (let j = 0; j < inputOrder + 1; j++) {
+        zIndices[i * (inputOrder + 1) + j] = i;
+      }
+    }
 
-      for (let s = 0; s < yStride; s++) {
-        const dimOne = Math.floor(s * tmp);
-        const coef = coefficients[dimOne + dimTwo];
-        result[s + d * yStride] += coef * tempTerm;
+    const zIndiceslength = zIndices.length;
+    const coefficients = arrayScratch;
+    const highestNonZeroCoef = fillCoefficientList(
+      coefficients,
+      zIndices,
+      xTable,
+      yTable,
+      yStride,
+      inputOrder,
+    );
+    /** @type {number[]} */
+    const reservedIndices = [];
+
+    const tmp = (zIndiceslength * (zIndiceslength + 1)) / 2;
+    const loopStop = Math.min(highestNonZeroCoef, outputOrder);
+    for (let d = 0; d <= loopStop; d++) {
+      for (i = d; i <= highestNonZeroCoef; i++) {
+        reservedIndices.length = 0;
+        const tempTerm = calculateCoefficientTerm(
+          x,
+          zIndices,
+          xTable,
+          d,
+          i,
+          reservedIndices,
+        );
+        const dimTwo = Math.floor((i * (1 - i)) / 2) + zIndiceslength * i;
+
+        for (let s = 0; s < yStride; s++) {
+          const dimOne = Math.floor(s * tmp);
+          const coef = coefficients[dimOne + dimTwo];
+          result[s + d * yStride] += coef * tempTerm;
+        }
       }
     }
-  }
 
-  return result;
-};
+    return result;
+  }
+}
 
+/**
+ * @param {number[]} coefficients
+ * @param {number[]} zIndices
+ * @param {number[]} xTable
+ * @param {number[]} yTable
+ * @param {number} yStride
+ * @param {number} inputOrder
+ * @returns {number}
+ *
+ * @private
+ */
 function fillCoefficientList(
   coefficients,
   zIndices,
@@ -338,4 +373,5 @@ function fillCoefficientList(
 
   return highestNonZero;
 }
+
 export default HermitePolynomialApproximation;

package/Source/Core/InterpolationAlgorithm.js

@@ -52,6 +52,7 @@ class InterpolationAlgorithm {
    * if this function remains undefined on implementing objects, interpolateOrderZero will be used instead.
    *
    * @function
+   * @optional
    * @param {number} x The independent variable for which the dependent variables will be interpolated.
    * @param {number[]} xTable The array of independent variables to use to interpolate.  The values
    * in this array must be in increasing order and the same value must not occur twice in the array.

package/Source/Core/Ion.js

@@ -4,7 +4,7 @@ import Resource from "./Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiIzNzRjZTkzNC05M2UwLTRlNDItOWU0My1hYjk5YjFiNTNhYTMiLCJpZCI6MjU5LCJzdWIiOiJDZXNpdW1KUyIsImlzcyI6Imh0dHBzOi8vYXBpLmNlc2l1bS5jb20iLCJhdWQiOiIxLjE0MyBSZWxlYXNlIC0gRGVsZXRlIG9uIFNlcHRlbWJlciAxLCAyMDI2IiwiaWF0IjoxNzgyMzY4NzY4fQ.kDcFqK7jTTloOcBbwb-epSQGd1Lu12_hRuqk1XRE_H8";
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJkYjZkM2MyOS1mODRiLTRlMGQtYTYzMy0xNWYyYmNiZjE1NGUiLCJpZCI6MjU5LCJzdWIiOiJDZXNpdW1KUyIsImlzcyI6Imh0dHBzOi8vYXBpLmNlc2l1bS5jb20iLCJhdWQiOiIxLjE0NCBSZWxlYXNlIC0gRGVsZXRlIG9uIE9jdG9iZXIgMSwgMjAyNiIsImlhdCI6MTc4NDk1ODg5MH0.x3Ra1-m0GEx7jwv8wnz-bAt4SSG3_ZCC9zU_MwzfjA4";
 /**
  * Default settings for accessing the Cesium ion API.
  *

package/Source/Core/JulianDate.js

@@ -106,7 +106,7 @@ function convertTaiToUtc(julianDate, result) {
   //we're converting, so we subtract one to get the correct LeapSecond instance.
   return JulianDate.addSeconds(
     julianDate,
-    -leapSeconds[--index].offset,
+    -leapSeconds[index - 1].offset,
     result,
   );
 }