@cesium/engine 6.1.1 → 7.0.0

package/Source/Core/Ellipsoid.js

@@ -1,3 +1,4 @@
+import Cartesian2 from "./Cartesian2.js";
 import Cartesian3 from "./Cartesian3.js";
 import Cartographic from "./Cartographic.js";
 import Check from "./Check.js";
@@ -694,6 +695,50 @@ Ellipsoid.prototype.getSurfaceNormalIntersectionWithZAxis = function (
   return result;
 };
 
+const scratchEndpoint = new Cartesian3();
+
+/**
+ * Computes the ellipsoid curvatures at a given position on the surface.
+ *
+ * @param {Cartesian3} surfacePosition The position on the ellipsoid surface where curvatures will be calculated.
+ * @param {Cartesian2} [result] The cartesian to which to copy the result, or undefined to create and return a new instance.
+ * @returns {Cartesian2} The local curvature of the ellipsoid surface at the provided position, in east and north directions.
+ *
+ * @exception {DeveloperError} position is required.
+ */
+Ellipsoid.prototype.getLocalCurvature = function (surfacePosition, result) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("surfacePosition", surfacePosition);
+  //>>includeEnd('debug');
+
+  if (!defined(result)) {
+    result = new Cartesian2();
+  }
+
+  const primeVerticalEndpoint = this.getSurfaceNormalIntersectionWithZAxis(
+    surfacePosition,
+    0.0,
+    scratchEndpoint
+  );
+  const primeVerticalRadius = Cartesian3.distance(
+    surfacePosition,
+    primeVerticalEndpoint
+  );
+  // meridional radius = (1 - e^2) * primeVerticalRadius^3 / a^2
+  // where 1 - e^2 = b^2 / a^2,
+  // so meridional = b^2 * primeVerticalRadius^3 / a^4
+  //   = (b * primeVerticalRadius / a^2)^2 * primeVertical
+  const radiusRatio =
+    (this.minimumRadius * primeVerticalRadius) / this.maximumRadius ** 2;
+  const meridionalRadius = primeVerticalRadius * radiusRatio ** 2;
+
+  return Cartesian2.fromElements(
+    1.0 / primeVerticalRadius,
+    1.0 / meridionalRadius,
+    result
+  );
+};
+
 const abscissas = [
   0.14887433898163,
   0.43339539412925,

package/Source/Core/GregorianDate.js

@@ -1,3 +1,10 @@
+import Check from "./Check.js";
+import defaultValue from "./defaultValue.js";
+import DeveloperError from "./DeveloperError.js";
+import isLeapYear from "./isLeapYear.js";
+
+const daysInYear = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
 /**
  * Represents a Gregorian date in a more precise format than the JavaScript Date object.
  * In addition to submillisecond precision, this object can also represent leap seconds.
@@ -25,6 +32,27 @@ function GregorianDate(
   millisecond,
   isLeapSecond
 ) {
+  const minimumYear = 1;
+  const minimumMonth = 1;
+  const minimumDay = 1;
+  const minimumHour = 0;
+  const minimumMinute = 0;
+  const minimumSecond = 0;
+  const minimumMillisecond = 0;
+
+  year = defaultValue(year, minimumYear);
+  month = defaultValue(month, minimumMonth);
+  day = defaultValue(day, minimumDay);
+  hour = defaultValue(hour, minimumHour);
+  minute = defaultValue(minute, minimumMinute);
+  second = defaultValue(second, minimumSecond);
+  millisecond = defaultValue(millisecond, minimumMillisecond);
+  isLeapSecond = defaultValue(isLeapSecond, false);
+  //>>includeStart('debug', pragmas.debug);
+  validateRange();
+  validateDate();
+  //>>includeEnd('debug');
+
   /**
    * Gets or sets the year as a whole number.
    * @type {number}
@@ -65,5 +93,62 @@ function GregorianDate(
    * @type {boolean}
    */
   this.isLeapSecond = isLeapSecond;
+
+  function validateRange() {
+    const maximumYear = 9999;
+    const maximumMonth = 12;
+    const maximumDay = 31;
+    const maximumHour = 23;
+    const maximumMinute = 59;
+    const maximumSecond = 59;
+    const excludedMaximumMilisecond = 1000;
+
+    Check.typeOf.number.greaterThanOrEquals("Year", year, minimumYear);
+    Check.typeOf.number.lessThanOrEquals("Year", year, maximumYear);
+
+    Check.typeOf.number.greaterThanOrEquals("Month", month, minimumMonth);
+    Check.typeOf.number.lessThanOrEquals("Month", month, maximumMonth);
+
+    Check.typeOf.number.greaterThanOrEquals("Day", day, minimumDay);
+    Check.typeOf.number.lessThanOrEquals("Day", day, maximumDay);
+
+    Check.typeOf.number.greaterThanOrEquals("Hour", hour, minimumHour);
+    Check.typeOf.number.lessThanOrEquals("Hour", hour, maximumHour);
+
+    Check.typeOf.number.greaterThanOrEquals("Minute", minute, minimumMinute);
+    Check.typeOf.number.lessThanOrEquals("Minute", minute, maximumMinute);
+
+    Check.typeOf.bool("IsLeapSecond", isLeapSecond);
+
+    Check.typeOf.number.greaterThanOrEquals("Second", second, minimumSecond);
+    Check.typeOf.number.lessThanOrEquals(
+      "Second",
+      second,
+      isLeapSecond ? maximumSecond + 1 : maximumSecond
+    );
+
+    Check.typeOf.number.greaterThanOrEquals(
+      "Millisecond",
+      millisecond,
+      minimumMillisecond
+    );
+    Check.typeOf.number.lessThan(
+      "Millisecond",
+      millisecond,
+      excludedMaximumMilisecond
+    );
+  }
+
+  // Javascript date object supports only dates greater than 1901. Thus validating with custom logic
+  function validateDate() {
+    const daysInMonth =
+      month === 2 && isLeapYear(year)
+        ? daysInYear[month - 1] + 1
+        : daysInYear[month - 1];
+
+    if (day > daysInMonth) {
+      throw new DeveloperError("Month and Day represents invalid date");
+    }
+  }
 }
 export default GregorianDate;

package/Source/Core/HeadingPitchRange.js

@@ -3,7 +3,7 @@ import defined from "./defined.js";
 
 /**
  * Defines a heading angle, pitch angle, and range in a local frame.
- * Heading is the rotation from the local north direction where a positive angle is increasing eastward.
+ * Heading is the rotation from the local east direction where a positive angle is increasing southward.
  * Pitch is the rotation from the local xy-plane. Positive pitch angles are above the plane. Negative pitch
  * angles are below the plane. Range is the distance from the center of the frame.
  * @alias HeadingPitchRange
@@ -15,7 +15,7 @@ import defined from "./defined.js";
  */
 function HeadingPitchRange(heading, pitch, range) {
   /**
-   * Heading is the rotation from the local north direction where a positive angle is increasing eastward.
+   * Heading is the rotation from the local east direction where a positive angle is increasing southward.
    * @type {number}
    * @default 0.0
    */

package/Source/Core/Ion.js

@@ -4,7 +4,7 @@ import Resource from "./Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiIzN2UwMjViMC0xOTJhLTQxMmItOWEzMS1kMjJiNmZiY2E5N2YiLCJpZCI6MjU5LCJpYXQiOjE3MDE0NTc1NjB9.bMNhc7S4cuG1qUnRUiLxr5lunSH1k6-UfkRXSqVFYyM";
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJiOGQ5NjRhYy1lYzBmLTRjYjktODA5MC01M2FhYmE4YjliZTIiLCJpZCI6MjU5LCJpYXQiOjE3MDY4MDU1MTR9.3b1XUfaoUwtY0Mi87tOQUGTnU4oMyyzSwAYqkDENcHo";
 /**
  * Default settings for accessing the Cesium ion API.
  *

package/Source/Core/PolygonGeometry.js

@@ -8,10 +8,8 @@ import Check from "./Check.js";
 import ComponentDatatype from "./ComponentDatatype.js";
 import defaultValue from "./defaultValue.js";
 import defined from "./defined.js";
-import deprecationWarning from "./deprecationWarning.js";
 import DeveloperError from "./DeveloperError.js";
 import Ellipsoid from "./Ellipsoid.js";
-import EllipsoidGeodesic from "./EllipsoidGeodesic.js";
 import EllipsoidTangentPlane from "./EllipsoidTangentPlane.js";
 import Geometry from "./Geometry.js";
 import GeometryAttribute from "./GeometryAttribute.js";
@@ -425,123 +423,6 @@ function computeAttributes(options) {
   return geometry;
 }
 
-const startCartographicScratch = new Cartographic();
-const endCartographicScratch = new Cartographic();
-const idlCross = {
-  westOverIDL: 0.0,
-  eastOverIDL: 0.0,
-};
-let ellipsoidGeodesic = new EllipsoidGeodesic();
-function computeRectangle(positions, ellipsoid, arcType, granularity, result) {
-  result = defaultValue(result, new Rectangle());
-  if (!defined(positions) || positions.length < 3) {
-    result.west = 0.0;
-    result.north = 0.0;
-    result.south = 0.0;
-    result.east = 0.0;
-    return result;
-  }
-
-  if (arcType === ArcType.RHUMB) {
-    return Rectangle.fromCartesianArray(positions, ellipsoid, result);
-  }
-
-  if (!ellipsoidGeodesic.ellipsoid.equals(ellipsoid)) {
-    ellipsoidGeodesic = new EllipsoidGeodesic(undefined, undefined, ellipsoid);
-  }
-
-  result.west = Number.POSITIVE_INFINITY;
-  result.east = Number.NEGATIVE_INFINITY;
-  result.south = Number.POSITIVE_INFINITY;
-  result.north = Number.NEGATIVE_INFINITY;
-
-  idlCross.westOverIDL = Number.POSITIVE_INFINITY;
-  idlCross.eastOverIDL = Number.NEGATIVE_INFINITY;
-
-  const inverseChordLength =
-    1.0 / CesiumMath.chordLength(granularity, ellipsoid.maximumRadius);
-  const positionsLength = positions.length;
-  let endCartographic = ellipsoid.cartesianToCartographic(
-    positions[0],
-    endCartographicScratch
-  );
-  let startCartographic = startCartographicScratch;
-  let swap;
-
-  for (let i = 1; i < positionsLength; i++) {
-    swap = startCartographic;
-    startCartographic = endCartographic;
-    endCartographic = ellipsoid.cartesianToCartographic(positions[i], swap);
-    ellipsoidGeodesic.setEndPoints(startCartographic, endCartographic);
-    interpolateAndGrowRectangle(
-      ellipsoidGeodesic,
-      inverseChordLength,
-      result,
-      idlCross
-    );
-  }
-
-  swap = startCartographic;
-  startCartographic = endCartographic;
-  endCartographic = ellipsoid.cartesianToCartographic(positions[0], swap);
-  ellipsoidGeodesic.setEndPoints(startCartographic, endCartographic);
-  interpolateAndGrowRectangle(
-    ellipsoidGeodesic,
-    inverseChordLength,
-    result,
-    idlCross
-  );
-
-  if (result.east - result.west > idlCross.eastOverIDL - idlCross.westOverIDL) {
-    result.west = idlCross.westOverIDL;
-    result.east = idlCross.eastOverIDL;
-
-    if (result.east > CesiumMath.PI) {
-      result.east = result.east - CesiumMath.TWO_PI;
-    }
-    if (result.west > CesiumMath.PI) {
-      result.west = result.west - CesiumMath.TWO_PI;
-    }
-  }
-
-  return result;
-}
-
-const interpolatedCartographicScratch = new Cartographic();
-function interpolateAndGrowRectangle(
-  ellipsoidGeodesic,
-  inverseChordLength,
-  result,
-  idlCross
-) {
-  const segmentLength = ellipsoidGeodesic.surfaceDistance;
-
-  const numPoints = Math.ceil(segmentLength * inverseChordLength);
-  const subsegmentDistance =
-    numPoints > 0 ? segmentLength / (numPoints - 1) : Number.POSITIVE_INFINITY;
-  let interpolationDistance = 0.0;
-
-  for (let i = 0; i < numPoints; i++) {
-    const interpolatedCartographic = ellipsoidGeodesic.interpolateUsingSurfaceDistance(
-      interpolationDistance,
-      interpolatedCartographicScratch
-    );
-    interpolationDistance += subsegmentDistance;
-    const longitude = interpolatedCartographic.longitude;
-    const latitude = interpolatedCartographic.latitude;
-
-    result.west = Math.min(result.west, longitude);
-    result.east = Math.max(result.east, longitude);
-    result.south = Math.min(result.south, latitude);
-    result.north = Math.max(result.north, latitude);
-
-    const lonAdjusted =
-      longitude >= 0 ? longitude : longitude + CesiumMath.TWO_PI;
-    idlCross.westOverIDL = Math.min(idlCross.westOverIDL, lonAdjusted);
-    idlCross.eastOverIDL = Math.max(idlCross.eastOverIDL, lonAdjusted);
-  }
-}
-
 const createGeometryFromPositionsExtrudedPositions = [];
 
 function createGeometryFromPositionsExtruded(
@@ -1264,56 +1145,6 @@ PolygonGeometry.computeRectangleFromPositions = function (
   return result;
 };
 
-/**
- * Returns the bounding rectangle given the provided options
- *
- * @param {object} options Object with the following properties:
- * @param {PolygonHierarchy} options.polygonHierarchy A polygon hierarchy that can include holes.
- * @param {number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions sampled.
- * @param {ArcType} [options.arcType=ArcType.GEODESIC] The type of line the polygon edges must follow. Valid options are {@link ArcType.GEODESIC} and {@link ArcType.RHUMB}.
- * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid to be used as a reference.
- * @param {Rectangle} [result] An object in which to store the result.
- *
- * @returns {Rectangle} The result rectangle
- *
- * @deprecated
- */
-PolygonGeometry.computeRectangle = function (options, result) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("options", options);
-  Check.typeOf.object("options.polygonHierarchy", options.polygonHierarchy);
-  //>>includeEnd('debug');
-
-  deprecationWarning(
-    "PolygonGeometry.computeRectangle",
-    "PolygonGeometry.computeRectangle was deprecated in CesiumJS 1.110.  It will be removed in CesiumJS 1.112. Use PolygonGeometry.computeRectangleFromPositions instead."
-  );
-
-  const granularity = defaultValue(
-    options.granularity,
-    CesiumMath.RADIANS_PER_DEGREE
-  );
-  const arcType = defaultValue(options.arcType, ArcType.GEODESIC);
-  //>>includeStart('debug', pragmas.debug);
-  if (arcType !== ArcType.GEODESIC && arcType !== ArcType.RHUMB) {
-    throw new DeveloperError(
-      "Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB."
-    );
-  }
-  //>>includeEnd('debug');
-
-  const polygonHierarchy = options.polygonHierarchy;
-  const ellipsoid = defaultValue(options.ellipsoid, Ellipsoid.WGS84);
-
-  return computeRectangle(
-    polygonHierarchy.positions,
-    ellipsoid,
-    arcType,
-    granularity,
-    result
-  );
-};
-
 const scratchPolarForPlane = new Stereographic();
 function getTangentPlane(rectangle, positions, ellipsoid) {
   if (rectangle.height >= CesiumMath.PI || rectangle.width >= CesiumMath.PI) {

package/Source/Core/Quaternion.js

@@ -677,8 +677,12 @@ Quaternion.computeAxis = function (quaternion, result) {
   //>>includeEnd('debug');
 
   const w = quaternion.w;
-  if (Math.abs(w - 1.0) < CesiumMath.EPSILON6) {
-    result.x = result.y = result.z = 0;
+  if (
+    Math.abs(w - 1.0) < CesiumMath.EPSILON6 ||
+    Math.abs(w + 1.0) < CesiumMath.EPSILON6
+  ) {
+    result.x = 1;
+    result.y = result.z = 0;
     return result;
   }
 

package/Source/Core/RectangleOutlineGeometry.js

@@ -159,11 +159,9 @@ function constructRectangle(geometry, computedOptions) {
 }
 
 function constructExtrudedRectangle(rectangleGeometry, computedOptions) {
-  const surfaceHeight = rectangleGeometry._surfaceHeight;
-  const extrudedHeight = rectangleGeometry._extrudedHeight;
+  const maxHeight = rectangleGeometry._surfaceHeight;
+  const minHeight = rectangleGeometry._extrudedHeight;
   const ellipsoid = rectangleGeometry._ellipsoid;
-  const minHeight = extrudedHeight;
-  const maxHeight = surfaceHeight;
   const geo = constructRectangle(rectangleGeometry, computedOptions);
 
   const height = computedOptions.height;

package/Source/Core/RequestScheduler.js

@@ -60,9 +60,9 @@ RequestScheduler.maximumRequests = 50;
  * The maximum number of simultaneous active requests per server. Un-throttled requests or servers specifically
  * listed in {@link requestsByServer} do not observe this limit.
  * @type {number}
- * @default 6
+ * @default 18
  */
-RequestScheduler.maximumRequestsPerServer = 6;
+RequestScheduler.maximumRequestsPerServer = 18;
 
 /**
  * A per server key list of overrides to use for throttling instead of <code>maximumRequestsPerServer</code>.
@@ -78,13 +78,7 @@ RequestScheduler.maximumRequestsPerServer = 6;
  *   "assets.cesium.com:443": 18,
  * };
  */
-RequestScheduler.requestsByServer = {
-  "api.cesium.com:443": 18,
-  "assets.ion.cesium.com:443": 18,
-  "ibasemaps-api.arcgis.com:443": 18,
-  "tile.googleapis.com:443": 18,
-  "tile.openstreetmap.org:443": 18,
-};
+RequestScheduler.requestsByServer = {};
 
 /**
  * Specifies if the request scheduler should throttle incoming requests, or let the browser queue requests under its control.

package/Source/Core/Resource.js

@@ -2045,17 +2045,6 @@ Resource.createImageBitmapFromBlob = function (blob, options) {
   });
 };
 
-function decodeResponse(loadWithHttpResponse, responseType) {
-  switch (responseType) {
-    case "text":
-      return loadWithHttpResponse.toString("utf8");
-    case "json":
-      return JSON.parse(loadWithHttpResponse.toString("utf8"));
-    default:
-      return new Uint8Array(loadWithHttpResponse).buffer;
-  }
-}
-
 function loadWithHttpRequest(
   url,
   responseType,
@@ -2066,64 +2055,36 @@ function loadWithHttpRequest(
   overrideMimeType
 ) {
   // Note: only the 'json' and 'text' responseTypes transforms the loaded buffer
-  let URL;
-  let zlib;
-  Promise.all([import("url"), import("zlib")])
-    .then(([urlImport, zlibImport]) => {
-      URL = urlImport.parse(url);
-      zlib = zlibImport;
-
-      return URL.protocol === "https:" ? import("https") : import("http");
-    })
-    .then((http) => {
-      const options = {
-        protocol: URL.protocol,
-        hostname: URL.hostname,
-        port: URL.port,
-        path: URL.path,
-        query: URL.query,
-        method: method,
-        headers: headers,
-      };
-      http
-        .request(options)
-        .on("response", function (res) {
-          if (res.statusCode < 200 || res.statusCode >= 300) {
-            deferred.reject(
-              new RequestErrorEvent(res.statusCode, res, res.headers)
-            );
-            return;
-          }
-
-          const chunkArray = [];
-          res.on("data", function (chunk) {
-            chunkArray.push(chunk);
-          });
+  fetch(url, {
+    method,
+    headers,
+  })
+    .then(async (response) => {
+      if (!response.ok) {
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        deferred.reject(
+          new RequestErrorEvent(response.status, response, responseHeaders)
+        );
+        return;
+      }
 
-          res.on("end", function () {
-            // eslint-disable-next-line no-undef
-            const result = Buffer.concat(chunkArray);
-            if (res.headers["content-encoding"] === "gzip") {
-              zlib.gunzip(result, function (error, resultUnzipped) {
-                if (error) {
-                  deferred.reject(
-                    new RuntimeError("Error decompressing response.")
-                  );
-                } else {
-                  deferred.resolve(
-                    decodeResponse(resultUnzipped, responseType)
-                  );
-                }
-              });
-            } else {
-              deferred.resolve(decodeResponse(result, responseType));
-            }
-          });
-        })
-        .on("error", function (e) {
-          deferred.reject(new RequestErrorEvent());
-        })
-        .end();
+      switch (responseType) {
+        case "text":
+          deferred.resolve(response.text());
+          break;
+        case "json":
+          deferred.resolve(response.json());
+          break;
+        default:
+          deferred.resolve(new Uint8Array(await response.arrayBuffer()).buffer);
+          break;
+      }
+    })
+    .catch(() => {
+      deferred.reject(new RequestErrorEvent());
     });
 }
 
@@ -2226,7 +2187,7 @@ Resource._Implementations.loadWithXhr = function (
     //or do not support the xhr.response property.
     if (xhr.status === 204) {
       // accept no content
-      deferred.resolve();
+      deferred.resolve(undefined);
     } else if (
       defined(response) &&
       (!defined(responseType) || browserResponseType === responseType)

package/Source/Core/TerrainEncoding.js

@@ -6,7 +6,7 @@ import defaultValue from "./defaultValue.js";
 import defined from "./defined.js";
 import CesiumMath from "./Math.js";
 import Matrix4 from "./Matrix4.js";
-import TerrainExaggeration from "./TerrainExaggeration.js";
+import VerticalExaggeration from "./VerticalExaggeration.js";
 import TerrainQuantization from "./TerrainQuantization.js";
 
 const cartesian3Scratch = new Cartesian3();
@@ -386,7 +386,7 @@ TerrainEncoding.prototype.getExaggeratedPosition = function (
     );
     const rawHeight = this.decodeHeight(buffer, index);
     const heightDifference =
-      TerrainExaggeration.getHeight(
+      VerticalExaggeration.getHeight(
         rawHeight,
         exaggeration,
         exaggerationRelativeHeight

package/Source/Core/Transforms.js

@@ -360,7 +360,7 @@ const scratchHPRMatrix4 = new Matrix4();
 
 /**
  * Computes a 4x4 transformation matrix from a reference frame with axes computed from the heading-pitch-roll angles
- * centered at the provided origin to the provided ellipsoid's fixed reference frame. Heading is the rotation from the local north
+ * centered at the provided origin to the provided ellipsoid's fixed reference frame. Heading is the rotation from the local east
  * direction where a positive angle is increasing eastward. Pitch is the rotation from the local east-north plane. Positive pitch angles
  * are above the plane. Negative pitch angles are below the plane. Roll is the first rotation applied about the local east axis.
  *
@@ -415,7 +415,7 @@ const scratchHPRMatrix3 = new Matrix3();
 
 /**
  * Computes a quaternion from a reference frame with axes computed from the heading-pitch-roll angles
- * centered at the provided origin. Heading is the rotation from the local north
+ * centered at the provided origin. Heading is the rotation from the local east
  * direction where a positive angle is increasing eastward. Pitch is the rotation from the local east-north plane. Positive pitch angles
  * are above the plane. Negative pitch angles are below the plane. Roll is the first rotation applied about the local east axis.
  *
@@ -465,7 +465,7 @@ const hprTransformScratch = new Matrix4();
 const hprRotationScratch = new Matrix3();
 const hprQuaternionScratch = new Quaternion();
 /**
- * Computes heading-pitch-roll angles from a transform in a particular reference frame. Heading is the rotation from the local north
+ * Computes heading-pitch-roll angles from a transform in a particular reference frame. Heading is the rotation from the local east
  * direction where a positive angle is increasing eastward. Pitch is the rotation from the local east-north plane. Positive pitch angles
  * are above the plane. Negative pitch angles are below the plane. Roll is the first rotation applied about the local east axis.
  *
@@ -1045,21 +1045,30 @@ Transforms.basisTo2D = function (projection, matrix, result) {
   const rtcCenter = Matrix4.getTranslation(matrix, scratchCenter);
   const ellipsoid = projection.ellipsoid;
 
-  // Get the 2D Center
-  const cartographic = ellipsoid.cartesianToCartographic(
-    rtcCenter,
-    scratchCartographic
-  );
-  const projectedPosition = projection.project(
-    cartographic,
-    scratchCartesian3Projection
-  );
-  Cartesian3.fromElements(
-    projectedPosition.z,
-    projectedPosition.x,
-    projectedPosition.y,
-    projectedPosition
-  );
+  let projectedPosition;
+  if (Cartesian3.equals(rtcCenter, Cartesian3.ZERO)) {
+    projectedPosition = Cartesian3.clone(
+      Cartesian3.ZERO,
+      scratchCartesian3Projection
+    );
+  } else {
+    // Get the 2D Center
+    const cartographic = ellipsoid.cartesianToCartographic(
+      rtcCenter,
+      scratchCartographic
+    );
+
+    projectedPosition = projection.project(
+      cartographic,
+      scratchCartesian3Projection
+    );
+    Cartesian3.fromElements(
+      projectedPosition.z,
+      projectedPosition.x,
+      projectedPosition.y,
+      projectedPosition
+    );
+  }
 
   // Assuming the instance are positioned in WGS84, invert the WGS84 transform to get the local transform and then convert to 2D
   const fromENU = Transforms.eastNorthUpToFixedFrame(