@math.gl/geospatial 5.0.0-alpha.11 → 5.0.0-alpha.13

package/dist/index.cjs

@@ -20,16 +20,161 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   Ellipsoid: () => Ellipsoid,
+  EllipsoidOccluder: () => EllipsoidOccluder,
   EllipsoidTangentPlane: () => EllipsoidTangentPlane,
   LngLatRectangle: () => LngLatRectangle,
+  getGeographicTile: () => getGeographicTile,
+  getGeographicTileBounds: () => getGeographicTileBounds,
+  getGeographicTileRanges: () => getGeographicTileRanges,
+  getGlobeHorizonBounds: () => getGlobeHorizonBounds,
   isWGS84: () => isWGS84,
-  makeOBBFromRegion: () => makeOBBFromRegion
+  makeOBBFromRegion: () => makeOBBFromRegion,
+  splitGlobeBounds: () => splitGlobeBounds
 });
 module.exports = __toCommonJS(index_exports);
 
 // dist/ellipsoid.js
 var import_core4 = require("@math.gl/core");
 
+// ../core/src/spheroid.ts
+function spheroidToCartesian(point, geometry, result = point) {
+  const longitude = point.x, latitude = point.y, height = point.z;
+  const { semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es } = geometry;
+  const sin = Math.sin(latitude), cos = Math.cos(latitude);
+  const ratio = b / a;
+  const radius = es < 0.9 ? a / Math.sqrt(1 - es * sin * sin) : a / Math.hypot(cos, ratio * sin);
+  const x = (radius + height) * cos * Math.cos(longitude);
+  const y = (radius + height) * cos * Math.sin(longitude);
+  const z = (radius * (es < 0.9 ? 1 - es : ratio * ratio) + height) * sin;
+  return commit(result, x, y, z);
+}
+function cartesianToSpheroid(point, geometry, result = point) {
+  const x = point.x, y = point.y, z = point.z;
+  const { semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es } = geometry;
+  const p = Math.hypot(x, y), rr = Math.hypot(x, y, z);
+  if (!(rr > 0) || !Number.isFinite(rr)) return false;
+  if (es === 0) return commit(result, p === 0 ? 0 : Math.atan2(y, x), Math.atan2(z, p), rr - a);
+  if (p === 0) return commit(result, 0, Math.sign(z) * Math.PI / 2, Math.abs(z) - b);
+  const horizontal = p / a, vertical = z / b;
+  if (horizontal * horizontal + vertical * vertical < 1 - 16 * Number.EPSILON)
+    return interiorInverse(x, y, z, p, a, b, result);
+  if (es >= 0.9) return exteriorInverse(x, y, z, p, a, b, result);
+  const ct = z / rr, st = p / rr;
+  let rx = 1 / Math.sqrt(1 - es * (2 - es) * st * st);
+  let cos = st * (1 - es) * rx, sin = ct * rx;
+  for (let i = 0; i < 30; i++) {
+    const rn = a / Math.sqrt(1 - es * sin * sin);
+    const height = p * cos + z * sin - rn * (1 - es * sin * sin);
+    const rk = es * rn / (rn + height);
+    rx = 1 / Math.sqrt(1 - rk * (2 - rk) * st * st);
+    const nextCos = st * (1 - rk) * rx, nextSin = ct * rx;
+    if (Math.abs(nextSin * cos - nextCos * sin) <= 1e-12) {
+      if (!Number.isFinite(height) || !Number.isFinite(nextSin) || !Number.isFinite(nextCos)) break;
+      return commit(result, Math.atan2(y, x), Math.atan2(nextSin, Math.abs(nextCos)), height);
+    }
+    cos = nextCos;
+    sin = nextSin;
+  }
+  return exteriorInverse(x, y, z, p, a, b, result);
+}
+function interiorInverse(x, y, z, p, a, b, result) {
+  const ratio = b / a, ratio2 = ratio * ratio;
+  const horizontal = p / a, vertical = z / a, delta = 1 - ratio2;
+  if (!(ratio2 > 0) || ratio > 1) return false;
+  if (z === 0) {
+    if (horizontal < delta) return false;
+    return commit(result, Math.atan2(y, x), 0, p - a);
+  }
+  const aa = a * a, bb = b * b;
+  const ratioError = Number.isFinite(aa) && aa > 0 ? (bb - ratio2 * aa + productError(b, b, bb) - ratio2 * productError(a, a, aa) - productError(ratio2, aa, ratio2 * aa)) / aa : 0;
+  const pp = p * p, xx = x * x, yy = y * y, sum = xx + yy;
+  const radiusError = Number.isFinite(pp) && pp > 0 ? (sum - pp + sumError(xx, yy, sum) + productError(x, x, xx) + productError(y, y, yy) - productError(p, p, pp)) / (2 * p) : 0;
+  const shift = a * ratio2, base = p - a + shift;
+  const correction = radiusError + sumError(p - a, shift, base) + productError(a, ratio2, shift) + a * ratioError;
+  const weighted = Math.abs(vertical) * ratio;
+  if (!(weighted > 0)) return false;
+  let lower = 0, upper = ratio2;
+  let t = Math.max(weighted, horizontal - delta);
+  if (!(t > lower && t < upper)) t = upper / 2;
+  for (let i = 0; i < 128; i++) {
+    const equatorial = delta + t;
+    const u = horizontal / equatorial, v = weighted / t;
+    const at = a * t, difference = base - at;
+    const offset = (difference + (sumError(base, -at, difference) + correction - productError(a, t, at))) / (a * equatorial);
+    const term = offset * (u + 1);
+    const residual = term + v * v;
+    if (Math.abs(residual) <= 4 * Number.EPSILON * (Math.abs(term) + v * v) || upper - lower <= 4 * Number.EPSILON * t) {
+      const latitude = Math.atan2(vertical / t, horizontal / equatorial);
+      const sin = Math.sin(latitude), cos = Math.cos(latitude);
+      return commit(
+        result,
+        Math.atan2(y, x),
+        latitude,
+        p * cos + z * sin - a * Math.hypot(cos, ratio * sin)
+      );
+    }
+    if (residual > 0) lower = t;
+    else upper = t;
+    const derivative = -2 * (u * u / equatorial + v * v / t);
+    const next = t - residual / derivative;
+    const candidate = Number.isFinite(next) && next > lower && next < upper ? next : lower + (upper - lower) / 2;
+    if (candidate === t) {
+      const latitude = Math.atan2(vertical / t, horizontal / equatorial);
+      return commit(
+        result,
+        Math.atan2(y, x),
+        latitude,
+        p * Math.cos(latitude) + z * Math.sin(latitude) - a * Math.hypot(Math.cos(latitude), ratio * Math.sin(latitude))
+      );
+    }
+    t = candidate;
+  }
+  return false;
+}
+function sumError(x, y, sum) {
+  const part = sum - x;
+  return x - (sum - part) + (y - part);
+}
+function productError(x, y, product) {
+  const sx = 134217729 * x, sy = 134217729 * y;
+  if (!Number.isFinite(sx) || !Number.isFinite(sy)) return 0;
+  const hx = sx - (sx - x), hy = sy - (sy - y), lx = x - hx, ly = y - hy;
+  return hx * hy - product + hx * ly + lx * hy + lx * ly;
+}
+function exteriorInverse(x, y, z, p, a, b, result) {
+  const ratio = b / a, ratio2 = ratio * ratio, horizontal = p / a, vertical = z / a;
+  const norm = Math.hypot(horizontal, z / b);
+  if (!Number.isFinite(norm) || norm < 1 - 8 * Number.EPSILON || !(ratio2 > 0)) return false;
+  let lower = 0, upper = Math.hypot(horizontal, vertical * ratio);
+  if (!Number.isFinite(upper)) return false;
+  let multiplier = norm <= 1 + 8 * Number.EPSILON ? 0 : upper / 2;
+  for (let i = 0; i < 96; i++) {
+    const equatorial = 1 + multiplier, polar = ratio2 + multiplier;
+    const u = horizontal / equatorial, v = vertical * ratio / polar;
+    const length2 = Math.hypot(u, v);
+    const residual = length2 - 1;
+    if (Math.abs(residual) <= 4 * Number.EPSILON) {
+      const latitude = Math.atan2(vertical / polar, horizontal / equatorial);
+      const sin = Math.sin(latitude), cos = Math.cos(latitude);
+      const height = p * cos + z * sin - a * Math.hypot(cos, ratio * sin);
+      return commit(result, Math.atan2(y, x), latitude, height);
+    }
+    if (residual > 0) lower = multiplier;
+    else upper = multiplier;
+    const derivative = -(u * u / equatorial + v * v / polar) / length2;
+    const next = multiplier - residual / derivative;
+    multiplier = Number.isFinite(next) && next > lower && next < upper ? next : (lower + upper) / 2;
+  }
+  return false;
+}
+function commit(result, x, y, z) {
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z)) return false;
+  result.x = x;
+  result.y = y;
+  result.z = z;
+  return true;
+}
+
 // ../core/src/gl-matrix/vec3.ts
 function length(a) {
   const x = a[0];
@@ -88,25 +233,24 @@ function fromCartographic(cartographic, result = [], map = identity) {
 function fromCartographicToRadians(cartographic, vector = []) {
   return fromCartographic(cartographic, vector, import_core.config._cartographicRadians ? identity : import_core.toRadians);
 }
-function toCartographic(vector, cartographic, map = identity) {
+function toCartographicFromRadiansComponents(longitude, latitude, height, cartographic) {
+  const map = import_core.config._cartographicRadians ? identity : import_core.toDegrees;
+  const mappedLongitude = map(longitude), mappedLatitude = map(latitude);
   if ("longitude" in cartographic) {
-    cartographic.longitude = map(vector[0]);
-    cartographic.latitude = map(vector[1]);
-    cartographic.height = vector[2];
+    cartographic.longitude = mappedLongitude;
+    cartographic.latitude = mappedLatitude;
+    cartographic.height = height;
   } else if ("x" in cartographic) {
-    cartographic.x = map(vector[0]);
-    cartographic.y = map(vector[1]);
-    cartographic.z = vector[2];
+    cartographic.x = mappedLongitude;
+    cartographic.y = mappedLatitude;
+    cartographic.z = height;
   } else {
-    cartographic[0] = map(vector[0]);
-    cartographic[1] = map(vector[1]);
-    cartographic[2] = vector[2];
+    cartographic[0] = mappedLongitude;
+    cartographic[1] = mappedLatitude;
+    cartographic[2] = height;
   }
   return cartographic;
 }
-function toCartographicFromRadians(vector, cartographic) {
-  return toCartographic(vector, cartographic, import_core.config._cartographicRadians ? identity : import_core.toDegrees);
-}
 function isWGS84(vector) {
   if (!vector) {
     return false;
@@ -121,8 +265,93 @@ function isWGS84(vector) {
 
 // dist/ellipsoid-helpers/ellipsoid-transform.js
 var import_core2 = require("@math.gl/core");
+
+// ../core/src/local-frame.ts
+function createLocalFrameBasis() {
+  return { eastX: 0, eastY: 1, northZ: 1, upX: 1, upY: 0, upZ: 0 };
+}
+function eastNorthUpBasisFromDirections(east, up, result) {
+  const ex = east.x, ey = east.y, ez = east.z;
+  const ux = up.x, uy = up.y, uz = up.z;
+  if (ez !== 0) return false;
+  return commitBasis(result, ex, ey, ux * ey - uy * ex, ux, uy, uz);
+}
+function localFrameToMatrix(basis, origin, firstAxis, secondAxis, thirdAxis, result) {
+  const first = axisCode(firstAxis), second = axisCode(secondAxis), third = axisCode(thirdAxis);
+  const a = Math.abs(first), b = Math.abs(second), c = Math.abs(third);
+  if (!a || !b || !c || a === b || a === c || b === c) return false;
+  const parity = a % 3 + 1 === b ? 1 : -1;
+  if (parity * Math.sign(first * second * third) !== 1 || !Array.isArray(result) && result.length < 16)
+    return false;
+  const ex = basis.eastX, ey = basis.eastY, nz = basis.northZ;
+  const ux = basis.upX, uy = basis.upY, uz = basis.upZ;
+  const nx = -uz * ey, ny = uz * ex;
+  const x = origin.x, y = origin.y, z = origin.z;
+  const ax = (a === 1 ? ex : a === 2 ? nx : ux) * Math.sign(first);
+  const ay = (a === 1 ? ey : a === 2 ? ny : uy) * Math.sign(first);
+  const az = (a === 1 ? 0 : a === 2 ? nz : uz) * Math.sign(first);
+  const bx = (b === 1 ? ex : b === 2 ? nx : ux) * Math.sign(second);
+  const by = (b === 1 ? ey : b === 2 ? ny : uy) * Math.sign(second);
+  const bz = (b === 1 ? 0 : b === 2 ? nz : uz) * Math.sign(second);
+  const cx = (c === 1 ? ex : c === 2 ? nx : ux) * Math.sign(third);
+  const cy = (c === 1 ? ey : c === 2 ? ny : uy) * Math.sign(third);
+  const cz = (c === 1 ? 0 : c === 2 ? nz : uz) * Math.sign(third);
+  if (!Number.isFinite(ax) || !Number.isFinite(ay) || !Number.isFinite(az) || !Number.isFinite(bx) || !Number.isFinite(by) || !Number.isFinite(bz) || !Number.isFinite(cx) || !Number.isFinite(cy) || !Number.isFinite(cz) || !Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+    return false;
+  if (result instanceof Float32Array && (!Number.isFinite(Math.fround(ax)) || !Number.isFinite(Math.fround(ay)) || !Number.isFinite(Math.fround(az)) || !Number.isFinite(Math.fround(bx)) || !Number.isFinite(Math.fround(by)) || !Number.isFinite(Math.fround(bz)) || !Number.isFinite(Math.fround(cx)) || !Number.isFinite(Math.fround(cy)) || !Number.isFinite(Math.fround(cz)) || !Number.isFinite(Math.fround(x)) || !Number.isFinite(Math.fround(y)) || !Number.isFinite(Math.fround(z))))
+    return false;
+  result[0] = ax;
+  result[1] = ay;
+  result[2] = az;
+  result[3] = 0;
+  result[4] = bx;
+  result[5] = by;
+  result[6] = bz;
+  result[7] = 0;
+  result[8] = cx;
+  result[9] = cy;
+  result[10] = cz;
+  result[11] = 0;
+  result[12] = x;
+  result[13] = y;
+  result[14] = z;
+  result[15] = 1;
+  return true;
+}
+function axisCode(axis) {
+  switch (axis) {
+    case "east":
+      return 1;
+    case "west":
+      return -1;
+    case "north":
+      return 2;
+    case "south":
+      return -2;
+    case "up":
+      return 3;
+    case "down":
+      return -3;
+    default:
+      return 0;
+  }
+}
+function commitBasis(result, ex, ey, nz, ux, uy, uz) {
+  if (!Number.isFinite(ex) || !Number.isFinite(ey) || !Number.isFinite(nz) || !Number.isFinite(ux) || !Number.isFinite(uy) || !Number.isFinite(uz))
+    return false;
+  result.eastX = ex;
+  result.eastY = ey;
+  result.northZ = nz;
+  result.upX = ux;
+  result.upY = uy;
+  result.upZ = uz;
+  return true;
+}
+
+// dist/ellipsoid-helpers/ellipsoid-transform.js
 var EPSILON14 = 1e-14;
 var scratchOrigin = new import_core2.Vector3();
+var scratchBasis = createLocalFrameBasis();
 var VECTOR_PRODUCT_LOCAL_FRAME = {
   up: {
     south: "east",
@@ -188,6 +417,20 @@ function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, car
   let thirdAxisVector;
   const origin = scratchOrigin.copy(cartesianOrigin);
   const atPole = (0, import_core2.equals)(origin.x, 0, EPSILON14) && (0, import_core2.equals)(origin.y, 0, EPSILON14);
+  const radii = ellipsoid.radii;
+  if (radii.x === radii.y && radii.x > 0 && radii.z > 0 && radii.z <= radii.x && (!atPole || origin.z !== 0)) {
+    const { east, up } = scratchAxisVectors;
+    if (atPole) {
+      east.set(0, 1, 0);
+      up.set(0, 0, Math.sign(origin.z));
+    } else {
+      east.set(-origin.y, origin.x, 0).normalize();
+      ellipsoid.geodeticSurfaceNormal(origin, up);
+    }
+    if (!eastNorthUpBasisFromDirections(east, up, scratchBasis) || !localFrameToMatrix(scratchBasis, origin, firstAxis, secondAxis, thirdAxis, result))
+      throw new Error("Unsupported local frame");
+    return result;
+  }
   if (atPole) {
     const sign = Math.sign(origin.z);
     firstAxisVector = scratchVector1.fromArray(degeneratePositionLocalFrame[firstAxis]);
@@ -215,21 +458,25 @@ function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, car
     secondAxisVector = scratchAxisVectors[secondAxis];
     thirdAxisVector = scratchAxisVectors[thirdAxis];
   }
-  result[0] = firstAxisVector.x;
-  result[1] = firstAxisVector.y;
-  result[2] = firstAxisVector.z;
+  const ax = firstAxisVector.x, ay = firstAxisVector.y, az = firstAxisVector.z;
+  const bx = secondAxisVector.x, by = secondAxisVector.y, bz = secondAxisVector.z;
+  const cx = thirdAxisVector.x, cy = thirdAxisVector.y, cz = thirdAxisVector.z;
+  const x = origin.x, y = origin.y, z = origin.z;
+  result[0] = ax;
+  result[1] = ay;
+  result[2] = az;
   result[3] = 0;
-  result[4] = secondAxisVector.x;
-  result[5] = secondAxisVector.y;
-  result[6] = secondAxisVector.z;
+  result[4] = bx;
+  result[5] = by;
+  result[6] = bz;
   result[7] = 0;
-  result[8] = thirdAxisVector.x;
-  result[9] = thirdAxisVector.y;
-  result[10] = thirdAxisVector.z;
+  result[8] = cx;
+  result[9] = cy;
+  result[10] = cz;
   result[11] = 0;
-  result[12] = origin.x;
-  result[13] = origin.y;
-  result[14] = origin.z;
+  result[12] = x;
+  result[13] = y;
+  result[14] = z;
   result[15] = 1;
   return result;
 }
@@ -241,10 +488,14 @@ var scaleToGeodeticSurfaceIntersection = new import_core3.Vector3();
 var scaleToGeodeticSurfaceGradient = new import_core3.Vector3();
 function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
   const { oneOverRadii, oneOverRadiiSquared, centerToleranceSquared } = ellipsoid;
-  scratchVector4.from(cartesian);
-  const positionX = scratchVector4.x;
-  const positionY = scratchVector4.y;
-  const positionZ = scratchVector4.z;
+  const object = cartesian;
+  const positionX = "x" in cartesian ? object.x : cartesian[0];
+  const positionY = "x" in cartesian ? object.y : cartesian[1];
+  const positionZ = "x" in cartesian ? object.z : cartesian[2];
+  if (!Number.isFinite(positionX) || !Number.isFinite(positionY) || !Number.isFinite(positionZ)) {
+    return void 0;
+  }
+  scratchVector4.set(positionX, positionY, positionZ);
   const oneOverRadiiX = oneOverRadii.x;
   const oneOverRadiiY = oneOverRadii.y;
   const oneOverRadiiZ = oneOverRadii.z;
@@ -253,13 +504,13 @@ function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
   const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;
   const squaredNorm = x2 + y2 + z2;
   const ratio = Math.sqrt(1 / squaredNorm);
-  if (!Number.isFinite(ratio)) {
+  if (!Number.isFinite(ratio) || !Number.isFinite(squaredNorm)) {
     return void 0;
   }
   const intersection = scaleToGeodeticSurfaceIntersection;
-  intersection.copy(cartesian).scale(ratio);
+  intersection.set(positionX, positionY, positionZ).scale(ratio);
   if (squaredNorm < centerToleranceSquared) {
-    return intersection.to(result);
+    return writeResult(result, intersection.x, intersection.y, intersection.z);
   }
   const oneOverRadiiSquaredX = oneOverRadiiSquared.x;
   const oneOverRadiiSquaredY = oneOverRadiiSquared.y;
@@ -272,7 +523,7 @@ function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
   let yMultiplier;
   let zMultiplier;
   let func;
-  do {
+  for (let iteration = 0; iteration < 64; iteration++) {
     lambda -= correction;
     xMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredX);
     yMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredY);
@@ -284,21 +535,52 @@ function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
     const yMultiplier3 = yMultiplier2 * yMultiplier;
     const zMultiplier3 = zMultiplier2 * zMultiplier;
     func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1;
+    if (!Number.isFinite(func))
+      return void 0;
+    if (Math.abs(func) <= import_core3._MathUtils.EPSILON12) {
+      return writeResult(result, positionX * xMultiplier, positionY * yMultiplier, positionZ * zMultiplier);
+    }
     const denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX + y2 * yMultiplier3 * oneOverRadiiSquaredY + z2 * zMultiplier3 * oneOverRadiiSquaredZ;
     const derivative = -2 * denominator;
+    if (!Number.isFinite(derivative) || derivative === 0)
+      return void 0;
     correction = func / derivative;
-  } while (Math.abs(func) > import_core3._MathUtils.EPSILON12);
-  return scratchVector4.scale([xMultiplier, yMultiplier, zMultiplier]).to(result);
+    if (!Number.isFinite(correction))
+      return void 0;
+  }
+  return void 0;
+}
+function writeResult(result, x, y, z) {
+  if ((0, import_core3.isArray)(result)) {
+    result[0] = x;
+    result[1] = y;
+    result[2] = z;
+  } else {
+    const point = result;
+    point.x = x;
+    point.y = y;
+    point.z = z;
+  }
+  return result;
 }
 
 // dist/ellipsoid.js
+var spheroidScratch = { x: 0, y: 0, z: 0 };
 var scratchVector5 = new import_core4.Vector3();
 var scratchNormal = new import_core4.Vector3();
 var scratchK = new import_core4.Vector3();
 var scratchPosition = new import_core4.Vector3();
 var scratchHeight = new import_core4.Vector3();
 var scratchCartesian = new import_core4.Vector3();
-var Ellipsoid = class {
+var Ellipsoid = class _Ellipsoid {
+  /** Construct from two-axis geometry, including normalized projection ellipsoids.
+   * The equatorial X/Y radii are equal; no CRS or datum information is inferred.
+   */
+  static fromSpheroid(parameters) {
+    const { semiMajorAxis, semiMinorAxis } = parameters;
+    validateSpheroid(semiMajorAxis, semiMinorAxis);
+    return new _Ellipsoid(semiMajorAxis, semiMajorAxis, semiMinorAxis);
+  }
   constructor(x = 0, y = 0, z = 0) {
     this.centerToleranceSquared = import_core4._MathUtils.EPSILON1;
     (0, import_core4.assert)(x >= 0);
@@ -314,8 +596,25 @@ var Ellipsoid = class {
     if (this.radiiSquared.z !== 0) {
       this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;
     }
+    if (x === y && z > 0 && z <= x && Number.isFinite(this.radiiSquared.x) && this.radiiSquared.z > 0)
+      this.spheroidGeometry = Object.freeze({
+        semiMajorAxis: x,
+        semiMinorAxis: z,
+        eccentricitySquared: 1 - this.radiiSquared.z / this.radiiSquared.x
+      });
     Object.freeze(this);
   }
+  /** Return an owned geometry snapshot for a sphere or oblate spheroid.
+   * Triaxial, prolate and degenerate ellipsoids cannot be represented by this contract.
+   * Call during setup, outside coordinate loops.
+   */
+  toSpheroid() {
+    const { x, y, z } = this.radii;
+    if (x !== y)
+      throw new Error("Spheroid requires equal X/Y radii");
+    validateSpheroid(x, z);
+    return Object.freeze({ semiMajorAxis: x, semiMinorAxis: z });
+  }
   /** Compares this Ellipsoid against the provided Ellipsoid componentwise */
   equals(right) {
     return this === right || Boolean(right && this.radii.equals(right.radii));
@@ -325,6 +624,15 @@ var Ellipsoid = class {
     return this.radii.toString();
   }
   cartographicToCartesian(cartographic, result = [0, 0, 0]) {
+    if (this.spheroidGeometry) {
+      const llh = fromCartographicToRadians(cartographic, scratchCartesian);
+      spheroidScratch.x = llh[0];
+      spheroidScratch.y = llh[1];
+      spheroidScratch.z = llh[2];
+      if (!spheroidToCartesian(spheroidScratch, this.spheroidGeometry))
+        return void 0;
+      return writeResult(result, spheroidScratch.x, spheroidScratch.y, spheroidScratch.z);
+    }
     const normal = scratchNormal;
     const k = scratchK;
     const [, , height] = cartographic;
@@ -337,7 +645,22 @@ var Ellipsoid = class {
     return k.to(result);
   }
   cartesianToCartographic(cartesian, result = [0, 0, 0]) {
-    scratchCartesian.from(cartesian);
+    const object = cartesian;
+    const x = "x" in cartesian ? object.x : cartesian[0];
+    const y = "x" in cartesian ? object.y : cartesian[1];
+    const z = "x" in cartesian ? object.z : cartesian[2];
+    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+      return void 0;
+    if (this.spheroidGeometry && Number.isFinite(x * x + y * y + z * z) && Number.isFinite(this.oneOverRadiiSquared.x) && Number.isFinite(this.oneOverRadiiSquared.z)) {
+      spheroidScratch.x = x;
+      spheroidScratch.y = y;
+      spheroidScratch.z = z;
+      if (!cartesianToSpheroid(spheroidScratch, this.spheroidGeometry))
+        return void 0;
+      const longitude2 = x === 0 && y === 0 ? Math.atan2(y, x) : spheroidScratch.x;
+      return toCartographicFromRadiansComponents(longitude2, spheroidScratch.y, spheroidScratch.z, result);
+    }
+    scratchCartesian.set(x, y, z);
     const point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);
     if (!point) {
       return void 0;
@@ -346,9 +669,9 @@ var Ellipsoid = class {
     const h = scratchHeight;
     h.copy(scratchCartesian).subtract(point);
     const longitude = Math.atan2(normal.y, normal.x);
-    const latitude = Math.asin(normal.z);
+    const latitude = Math.atan2(normal.z, Math.hypot(normal.x, normal.y));
     const height = Math.sign(dot(h, scratchCartesian)) * length(h);
-    return toCartographicFromRadians([longitude, latitude, height], result);
+    return toCartographicFromRadiansComponents(longitude, latitude, height, result);
   }
   eastNorthUpToFixedFrame(origin, result = new import_core4.Matrix4()) {
     return localFrameToFixedFrame(this, "east", "north", "up", origin, result);
@@ -412,6 +735,10 @@ var Ellipsoid = class {
   }
 };
 Ellipsoid.WGS84 = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
+function validateSpheroid(a, b) {
+  if (!Number.isFinite(a) || !Number.isFinite(b) || a <= 0 || b <= 0 || b > a)
+    throw new Error("Spheroid requires finite positive axes with semiMinorAxis <= semiMajorAxis");
+}
 
 // dist/ellipsoid-tangent-plane.js
 var import_core5 = require("@math.gl/core");
@@ -730,4 +1057,194 @@ function fromPlaneExtents(planeOrigin, planeXAxis, planeYAxis, planeZAxis, minim
   center.copy(planeOrigin).add(centerOffset);
   return result;
 }
+
+// dist/ellipsoid-occluder.js
+var EllipsoidOccluder = class {
+  constructor(radii, center = [0, 0, 0]) {
+    validateVector(radii);
+    validateVector(center);
+    if (Array.from(radii).some((value) => value <= 0))
+      throw new RangeError("Radii must be positive");
+    this.radii = Object.freeze(Array.from(radii));
+    this.center = Object.freeze(Array.from(center));
+  }
+  /** Nonnegative ray parameter interval, including tangency and inside-origin rays.
+   * Direction need not be normalized. Undefined is a true miss; never clamps a miss
+   * to the limb. Result is untouched on miss. Distances equal parameters only for
+   * unit directions. Zero direction is a miss.
+   */
+  intersectRay(origin, direction, result = [0, 0]) {
+    validateVector(origin);
+    validateVector(direction);
+    const [x, y, z] = this.scalePoint(origin);
+    const dx = direction[0] / this.radii[0];
+    const dy = direction[1] / this.radii[1];
+    const dz = direction[2] / this.radii[2];
+    const length2 = Math.hypot(dx, dy, dz);
+    if (length2 === 0 || !Number.isFinite(length2))
+      return void 0;
+    const ux = dx / length2, uy = dy / length2, uz = dz / length2;
+    const along = -(x * ux + y * uy + z * uz);
+    const perpendicular = Math.hypot(y * uz - z * uy, z * ux - x * uz, x * uy - y * ux);
+    if (perpendicular > 1)
+      return void 0;
+    const half = Math.sqrt((1 - perpendicular) * (1 + perpendicular));
+    let near = along - half;
+    let far = along + half;
+    const radius = Math.hypot(x, y, z);
+    if (!Number.isFinite(radius))
+      throw new RangeError("Scaled origin magnitude must be finite");
+    if (half > 0 && along > 0 && far !== 0)
+      near = (radius - 1) / far * (radius + 1);
+    if (half > 0 && along < 0 && near !== 0)
+      far = (radius - 1) / near * (radius + 1);
+    if (far < 0)
+      return void 0;
+    result[0] = Math.max(0, Math.min(near, far)) / length2;
+    result[1] = Math.max(0, far) / length2;
+    return result;
+  }
+  /** True if the finite camera-to-point segment enters the solid interior.
+   * Surface contact/tangency alone is not occlusion. Works for elevated points;
+   * unlike a facing-normal test it does not discard visible points beyond the
+   * surface horizon. tolerance is a nonnegative scaled-space squared-radius margin.
+   */
+  isPointOccluded(camera, point, tolerance = 1e-12) {
+    validateVector(camera);
+    validateVector(point);
+    if (!Number.isFinite(tolerance) || tolerance < 0 || tolerance >= 1)
+      throw new RangeError("Tolerance must be in [0, 1)");
+    const a = this.scalePoint(camera);
+    const b = this.scalePoint(point);
+    const dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
+    const length2 = Math.hypot(dx, dy, dz);
+    if (!Number.isFinite(length2))
+      throw new RangeError("Segment magnitude must be finite");
+    if (length2 === 0)
+      return Math.hypot(...a) ** 2 < 1 - tolerance;
+    const ux = dx / length2, uy = dy / length2, uz = dz / length2;
+    const distance = Math.max(0, Math.min(length2, -(a[0] * ux + a[1] * uy + a[2] * uz)));
+    return Math.hypot(a[0] + distance * ux, a[1] + distance * uy, a[2] + distance * uz) ** 2 < 1 - tolerance;
+  }
+  /** Exact apparent limb ellipse for an exterior camera; undefined on/inside surface. */
+  getHorizon(camera) {
+    validateVector(camera);
+    const scaled = this.scalePoint(camera);
+    const distance = Math.hypot(...scaled);
+    if (!Number.isFinite(distance))
+      throw new RangeError("Camera magnitude must be finite");
+    if (distance <= 1)
+      return void 0;
+    const normal = scaled.map((value) => value / distance);
+    const reference = Math.abs(normal[2]) < 0.9 ? [0, 0, 1] : [0, 1, 0];
+    const u = cross(normal, reference);
+    const uLength = Math.hypot(...u);
+    const v = cross(normal, u.map((value) => value / uLength));
+    const radius = Math.sqrt((1 - 1 / distance) * (1 + 1 / distance));
+    return {
+      center: normal.map((value, i) => this.center[i] + this.radii[i] * value / distance),
+      axis1: u.map((value, i) => this.radii[i] * radius * value / uLength),
+      axis2: v.map((value, i) => this.radii[i] * radius * value)
+    };
+  }
+  scalePoint(point) {
+    const result = this.radii.map((radius, i) => (point[i] - this.center[i]) / radius);
+    if (!result.every(Number.isFinite))
+      throw new RangeError("Scaled coordinates must be finite");
+    return result;
+  }
+};
+function validateVector(vector) {
+  if (vector.length !== 3 || !Array.from(vector).every(Number.isFinite))
+    throw new RangeError("Expected three finite Cartesian components");
+}
+function cross(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+
+// dist/globe-horizon-bounds.js
+function getGlobeHorizonBounds(camera, radius) {
+  if (camera.length !== 3 || !Array.from(camera).every(Number.isFinite) || !Number.isFinite(radius) || radius <= 0)
+    throw new RangeError("Expected a finite camera and positive sphere radius");
+  const distance = Math.hypot(camera[0], camera[1], camera[2]);
+  if (!Number.isFinite(distance))
+    throw new RangeError("Camera magnitude must be finite");
+  if (distance <= radius)
+    return void 0;
+  const latitude = Math.atan2(camera[2], Math.hypot(camera[0], camera[1]));
+  const longitude = Math.atan2(camera[1], camera[0]);
+  const angle = Math.acos(radius / distance);
+  const degrees2 = 180 / Math.PI;
+  const padding = 1e-10;
+  const south = Math.max(-90, (latitude - angle) * degrees2 - padding);
+  const north = Math.min(90, (latitude + angle) * degrees2 + padding);
+  if (Math.abs(latitude) + angle >= Math.PI / 2 - 1e-12)
+    return [-180, south, 180, north];
+  const extent = Math.asin(Math.min(1, Math.sin(angle) / Math.cos(latitude))) * degrees2 + padding;
+  return [wrap(longitude * degrees2 - extent), south, wrap(longitude * degrees2 + extent), north];
+}
+function splitGlobeBounds(bounds) {
+  const [west, south, east, north] = bounds;
+  if (bounds.length !== 4 || !bounds.every(Number.isFinite) || west < -180 || west > 180 || east < -180 || east > 180 || south < -90 || north > 90 || south > north)
+    throw new RangeError("Invalid degree bounds");
+  return west <= east ? [[west, south, east, north]] : [
+    [west, south, 180, north],
+    [-180, south, east, north]
+  ];
+}
+function wrap(longitude) {
+  return ((longitude + 180) % 360 + 360) % 360 - 180;
+}
+
+// dist/geographic-tiles.js
+function getGeographicTileBounds(tile) {
+  const size = gridSize(tile.level);
+  if (![tile.x, tile.y].every((v) => Number.isInteger(v) && v >= 0 && v < size))
+    throw new RangeError("Tile coordinates must be integers inside the level grid");
+  return [
+    -180 + 360 * tile.x / size,
+    90 - 180 * (tile.y + 1) / size,
+    -180 + 360 * (tile.x + 1) / size,
+    90 - 180 * tile.y / size
+  ];
+}
+function getGeographicTile(longitude, latitude, level) {
+  const size = gridSize(level);
+  if (!Number.isFinite(longitude) || longitude < -180 || longitude > 180 || !Number.isFinite(latitude) || latitude < -90 || latitude > 90)
+    throw new RangeError("Expected longitude in [-180, 180] and latitude in [-90, 90]");
+  return {
+    x: Math.min(size - 1, Math.floor((longitude + 180) / 360 * size)),
+    y: Math.min(size - 1, Math.floor((90 - latitude) / 180 * size)),
+    level
+  };
+}
+function getGeographicTileRanges(bounds, level) {
+  const size = gridSize(level);
+  const split = splitGlobeBounds(bounds);
+  const positiveWidth = split.filter(([west, , east]) => east > west);
+  const rectangles = positiveWidth.length ? positiveWidth : split;
+  const intervals = rectangles.map(([west, south, east, north]) => {
+    const start = getGeographicTile(west, north, level);
+    return {
+      minX: start.x,
+      maxX: west === east ? start.x : Math.max(start.x, Math.min(size - 1, Math.ceil((east + 180) / 360 * size) - 1)),
+      minY: start.y,
+      maxY: south === north ? start.y : Math.max(start.y, Math.min(size - 1, Math.ceil((90 - south) / 180 * size) - 1))
+    };
+  }).sort((a, b) => a.minX - b.minX);
+  const result = [];
+  for (const range of intervals) {
+    const previous = result[result.length - 1];
+    if (previous && range.minX <= previous.maxX + 1)
+      previous.maxX = Math.max(previous.maxX, range.maxX);
+    else
+      result.push(range);
+  }
+  return result;
+}
+function gridSize(level) {
+  if (!Number.isInteger(level) || level < 0 || level > 30)
+    throw new RangeError("Level must be an integer from 0 through 30");
+  return 2 ** level;
+}
 //# sourceMappingURL=index.cjs.map