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

package/src/ellipsoid-occluder.ts

@@ -0,0 +1,135 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original scaled-space analytic geometry. Consumer requirements: https://github.com/keplergl/kepler.gl/pull/3557 and https://github.com/keplergl/kepler.gl/pull/3593. No implementation code copied.
+
+/** The limb is center + axis1*cos(t) + axis2*sin(t), in input Cartesian units. */
+export type EllipsoidHorizon = {
+  center: number[];
+  axis1: number[];
+  axis2: number[];
+};
+
+/** Axis-aligned ellipsoid queries, independent of viewport and vector classes. */
+export class EllipsoidOccluder {
+  readonly radii: readonly number[];
+  readonly center: readonly number[];
+
+  constructor(radii: Readonly<ArrayLike<number>>, center: Readonly<ArrayLike<number>> = [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: Readonly<ArrayLike<number>>,
+    direction: Readonly<ArrayLike<number>>,
+    result: number[] = [0, 0]
+  ): number[] | undefined {
+    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];
+    // Normalize in scaled space: avoid a tiny quadratic coefficient for ECEF rays.
+    const length = Math.hypot(dx, dy, dz);
+    if (length === 0 || !Number.isFinite(length)) return undefined;
+    const ux = dx / length,
+      uy = dy / length,
+      uz = dz / length;
+    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 undefined;
+    const half = Math.sqrt((1 - perpendicular) * (1 + perpendicular));
+    let near = along - half;
+    let far = along + half;
+    // Recover the small root by the root product rather than subtracting large terms.
+    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 undefined;
+    result[0] = Math.max(0, Math.min(near, far)) / length;
+    result[1] = Math.max(0, far) / length;
+    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: Readonly<ArrayLike<number>>,
+    point: Readonly<ArrayLike<number>>,
+    tolerance = 1e-12
+  ): boolean {
+    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 length = Math.hypot(dx, dy, dz);
+    if (!Number.isFinite(length)) throw new RangeError('Segment magnitude must be finite');
+    if (length === 0) return Math.hypot(...a) ** 2 < 1 - tolerance;
+    const ux = dx / length,
+      uy = dy / length,
+      uz = dz / length;
+    const distance = Math.max(0, Math.min(length, -(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: Readonly<ArrayLike<number>>): EllipsoidHorizon | undefined {
+    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 undefined;
+    const normal = scaled.map(value => value / distance);
+    // Choose a basis away from parallel to the normal, including polar views.
+    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)
+    };
+  }
+
+  private scalePoint(point: Readonly<ArrayLike<number>>): number[] {
+    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: Readonly<ArrayLike<number>>): void {
+  if (vector.length !== 3 || !Array.from(vector).every(Number.isFinite))
+    throw new RangeError('Expected three finite Cartesian components');
+}
+
+function cross(a: number[], b: number[]): number[] {
+  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]];
+}

package/src/ellipsoid-tangent-plane.ts

@@ -1,6 +1,8 @@
 // math.gl
-// SPDX-License-Identifier: MIT and Apache-2.0
-// Copyright (c) vis.gl contributors
+// SPDX-License-Identifier: MIT AND Apache-2.0
+// SPDX-FileCopyrightText: Copyright 2011-2018 CesiumJS Contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Derived from Cesium. See the repository LICENSE for upstream attribution and Apache-2.0 terms.
 
 // This file is derived from the Cesium library under Apache 2 license
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md

package/src/ellipsoid.ts

@@ -1,21 +1,30 @@
 // math.gl
-// SPDX-License-Identifier: MIT and Apache-2.0
-// Copyright (c) vis.gl contributors
+// SPDX-License-Identifier: MIT AND Apache-2.0
+// SPDX-FileCopyrightText: Copyright 2011-2018 CesiumJS Contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Derived from Cesium. See the repository LICENSE for upstream attribution and Apache-2.0 terms. Original math.gl follow-up uses stable atan2 latitude and numeric cartographic output.
 
 // This file is derived from the Cesium math library under Apache 2 license
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 
 /* eslint-disable */
 import {Vector3, Matrix4, assert, equals, _MathUtils, NumericArray} from '@math.gl/core';
+import type {SpheroidParameters} from '@math.gl/types';
+import {
+  spheroidToCartesian,
+  cartesianToSpheroid,
+  type SpheroidGeometry
+} from '@math.gl/core/spheroid';
 import * as vec3 from '@math.gl/core/vec3';
 
 import {WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z} from './constants';
-import {fromCartographicToRadians, toCartographicFromRadians} from './type-utils';
+import {fromCartographicToRadians, toCartographicFromRadiansComponents} from './type-utils';
 
 import type {AxisDirection} from './ellipsoid-helpers/ellipsoid-transform';
 import {localFrameToFixedFrame} from './ellipsoid-helpers/ellipsoid-transform';
-import {scaleToGeodeticSurface} from './ellipsoid-helpers/scale-to-geodetic-surface';
+import {scaleToGeodeticSurface, writeResult} from './ellipsoid-helpers/scale-to-geodetic-surface';
 
+const spheroidScratch = {x: 0, y: 0, z: 0};
 const scratchVector = new Vector3();
 const scratchNormal = new Vector3();
 const scratchK = new Vector3();
@@ -32,6 +41,15 @@ export class Ellipsoid {
   /** An Ellipsoid instance initialized to the WGS84 standard. */
   static readonly WGS84: Ellipsoid = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
 
+  /** 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: SpheroidParameters): Ellipsoid {
+    const {semiMajorAxis, semiMinorAxis} = parameters;
+    validateSpheroid(semiMajorAxis, semiMinorAxis);
+    return new Ellipsoid(semiMajorAxis, semiMajorAxis, semiMinorAxis);
+  }
+
   readonly radii: Vector3;
   readonly radiiSquared: Vector3;
   readonly radiiToTheFourth: Vector3;
@@ -41,6 +59,7 @@ export class Ellipsoid {
   readonly maximumRadius: number;
   readonly centerToleranceSquared: number = _MathUtils.EPSILON1;
   readonly squaredXOverSquaredZ: number;
+  private readonly spheroidGeometry?: SpheroidGeometry;
 
   /** Creates an Ellipsoid from a Cartesian specifying the radii in x, y, and z directions. */
   constructor(x: number, y: number, z: number);
@@ -77,9 +96,33 @@ export class Ellipsoid {
       this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;
     }
 
+    // Setup only: retain the three-radius path for unsupported/lossy shapes.
+    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(): SpheroidParameters {
+    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: Ellipsoid): boolean {
     return this === right || Boolean(right && this.radii.equals(right.radii));
@@ -98,6 +141,14 @@ export class Ellipsoid {
   cartographicToCartesian(cartographic: number[], result?: number[]): number[];
 
   cartographicToCartesian(cartographic: Readonly<NumericArray>, 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 undefined;
+      return writeResult(result, spheroidScratch.x, spheroidScratch.y, spheroidScratch.z);
+    }
     const normal = scratchNormal;
     const k = scratchK;
 
@@ -123,7 +174,33 @@ export class Ellipsoid {
   cartesianToCartographic(cartesian: Readonly<NumericArray>, result?: number[]): number[];
 
   cartesianToCartographic(cartesian: Readonly<NumericArray>, result = [0, 0, 0]) {
-    scratchCartesian.from(cartesian);
+    const object = cartesian as unknown as {x: number; y: number; z: number};
+    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 undefined;
+    // Sphere/oblate conversion chooses the unique nearest normal, including interiors.
+    // Preserve legacy geometry magnitude limits; prolate/triaxial keep their own kernel.
+    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 undefined;
+      // Preserve signed-zero atan2 at exact poles rather than projection's canonical zero.
+      const longitude = x === 0 && y === 0 ? Math.atan2(y, x) : spheroidScratch.x;
+      return toCartographicFromRadiansComponents(
+        longitude,
+        spheroidScratch.y,
+        spheroidScratch.z,
+        result
+      );
+    }
+    scratchCartesian.set(x, y, z);
     const point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);
 
     if (!point) {
@@ -136,10 +213,11 @@ export class Ellipsoid {
     h.copy(scratchCartesian).subtract(point);
 
     const longitude = Math.atan2(normal.y, normal.x);
-    const latitude = Math.asin(normal.z);
+    // atan2 retains latitude precision when the normal is almost vertical.
+    const latitude = Math.atan2(normal.z, Math.hypot(normal.x, normal.y));
     const height = Math.sign(vec3.dot(h, scratchCartesian)) * vec3.length(h);
 
-    return toCartographicFromRadians([longitude, latitude, height], result);
+    return toCartographicFromRadiansComponents(longitude, latitude, height, result);
   }
 
   /** Computes a 4x4 transformation matrix from a reference frame with an east-north-up axes
@@ -279,3 +357,9 @@ export class Ellipsoid {
     return scratchPosition.set(0.0, 0.0, z).to(result);
   }
 }
+
+// Original parameter adapter; conversion and surface kernels above retain Cesium attribution.
+function validateSpheroid(a: number, b: number): void {
+  if (!Number.isFinite(a) || !Number.isFinite(b) || a <= 0 || b <= 0 || b > a)
+    throw new Error('Spheroid requires finite positive axes with semiMinorAxis <= semiMajorAxis');
+}

package/src/geographic-tiles.ts

@@ -0,0 +1,87 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import {splitGlobeBounds, type GlobeBounds} from './globe-horizon-bounds';
+
+/** Equal-angle longitude/latitude grid: one world tile at level zero, north-origin Y. */
+export type GeographicTile = {x: number; y: number; level: number};
+/** Inclusive integer tile ranges. Ranges are disjoint and ordered by minX. */
+export type GeographicTileRange = {minX: number; maxX: number; minY: number; maxY: number};
+
+/** Geographic degree bounds of an equal-angle tile, not Web Mercator XYZ. */
+export function getGeographicTileBounds(tile: GeographicTile): GlobeBounds {
+  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
+  ];
+}
+
+/** Address a point in degrees. Interior edges belong to the east/south tile. */
+export function getGeographicTile(
+  longitude: number,
+  latitude: number,
+  level: number
+): GeographicTile {
+  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
+  };
+}
+
+/** Cover a degree rectangle without enumerating tiles, including wrapped longitude.
+ * Positive-area queries exclude edge-only neighbors; zero-width/height queries use
+ * point-address edge ownership. Both +/-180 spellings of the seam stay explicit.
+ */
+export function getGeographicTileRanges(bounds: GlobeBounds, level: number): GeographicTileRange[] {
+  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: GeographicTileRange[] = [];
+  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: number): number {
+  if (!Number.isInteger(level) || level < 0 || level > 30)
+    throw new RangeError('Level must be an integer from 0 through 30');
+  return 2 ** level;
+}

package/src/globe-horizon-bounds.ts

@@ -0,0 +1,68 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original spherical-cap extrema; requirements from https://github.com/keplergl/kepler.gl/pull/3557. No sampled viewport or upstream implementation copied.
+
+/** Degrees [west, south, east, north]; west > east means a dateline crossing. */
+export type GlobeBounds = readonly [number, number, number, number];
+
+/** Conservative geographic extent of every visible surface point on a sphere.
+ * Cartesian X points to longitude 0, Y to longitude 90, Z north. Covers the
+ * entire horizon cap, not just the screen: safe overfetch, not viewport-tight.
+ * Returns undefined on/inside the sphere. Radius and camera use matching units.
+ */
+export function getGlobeHorizonBounds(
+  camera: Readonly<ArrayLike<number>>,
+  radius: number
+): GlobeBounds | undefined {
+  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 undefined;
+  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 degrees = 180 / Math.PI;
+  // Outward padding protects tangent and near-pole limits from floating rounding.
+  const padding = 1e-10;
+  const south = Math.max(-90, (latitude - angle) * degrees - padding);
+  const north = Math.min(90, (latitude + angle) * degrees + 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))) * degrees + padding;
+  return [wrap(longitude * degrees - extent), south, wrap(longitude * degrees + extent), north];
+}
+
+/** Split wrapped bounds into protocol-safe rectangles (e.g. EPSG:4326 WMS).
+ * No screen sampling, image caching or request policy is implied.
+ */
+export function splitGlobeBounds(bounds: GlobeBounds): GlobeBounds[] {
+  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: number): number {
+  return ((((longitude + 180) % 360) + 360) % 360) - 180;
+}

package/src/index.ts

@@ -1,6 +1,6 @@
 // math.gl
 // SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 export {Ellipsoid} from './ellipsoid';
 export {EllipsoidTangentPlane} from './ellipsoid-tangent-plane';
@@ -8,3 +8,17 @@ export {LngLatRectangle} from './lng-lat-rectangle';
 export {makeOBBFromRegion} from './make-obb-from-region';
 export type {GeodeticRegion, MakeOBBFromRegionOptions} from './make-obb-from-region';
 export {isWGS84} from './type-utils';
+
+export type {SpheroidParameters} from '@math.gl/types';
+
+export {EllipsoidOccluder} from './ellipsoid-occluder';
+export type {EllipsoidHorizon} from './ellipsoid-occluder';
+export {getGlobeHorizonBounds, splitGlobeBounds} from './globe-horizon-bounds';
+export type {GlobeBounds} from './globe-horizon-bounds';
+
+export {
+  getGeographicTile,
+  getGeographicTileBounds,
+  getGeographicTileRanges
+} from './geographic-tiles';
+export type {GeographicTile, GeographicTileRange} from './geographic-tiles';

package/src/lng-lat-rectangle.ts

@@ -1,6 +1,8 @@
 // math.gl
-// SPDX-License-Identifier: MIT and Apache-2.0
-// Copyright (c) vis.gl contributors
+// SPDX-License-Identifier: MIT AND Apache-2.0
+// SPDX-FileCopyrightText: Copyright 2011-2018 CesiumJS Contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Derived from Cesium. See the repository LICENSE for upstream attribution and Apache-2.0 terms.
 
 // This file is derived from the Cesium library under Apache 2 license
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md

package/src/make-obb-from-region.ts

@@ -1,6 +1,8 @@
 // math.gl
-// SPDX-License-Identifier: MIT and Apache-2.0
-// Copyright (c) vis.gl contributors
+// SPDX-License-Identifier: MIT AND Apache-2.0
+// SPDX-FileCopyrightText: Copyright 2011-2018 CesiumJS Contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Derived from Cesium. See the repository LICENSE for upstream attribution and Apache-2.0 terms.
 
 // This file is derived from the Cesium math library under Apache 2 license
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md

package/src/type-utils.ts

@@ -1,6 +1,8 @@
 // math.gl
-// SPDX-License-Identifier: MIT and Apache-2.0
-// Copyright (c) vis.gl contributors
+// SPDX-License-Identifier: MIT AND Apache-2.0
+// SPDX-FileCopyrightText: Copyright 2011-2018 CesiumJS Contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Derived from Cesium. See the repository LICENSE for upstream attribution and Apache-2.0 terms. The numeric-component cartographic adapter is original math.gl code.
 
 // This file is derived from the Cesium math library under Apache 2 license
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
@@ -114,6 +116,32 @@ export function toCartographicFromRadians<T extends Cartographic>(
   return toCartographic(vector, cartographic, config._cartographicRadians ? identity : toDegrees);
 }
 
+/** Original numeric adapter: snapshot values before writing application-owned outputs. */
+export function toCartographicFromRadiansComponents<T extends Cartographic>(
+  longitude: number,
+  latitude: number,
+  height: number,
+  cartographic: T
+): T {
+  const map = config._cartographicRadians ? identity : toDegrees;
+  const mappedLongitude = map(longitude),
+    mappedLatitude = map(latitude);
+  if ('longitude' in cartographic) {
+    cartographic.longitude = mappedLongitude;
+    cartographic.latitude = mappedLatitude;
+    cartographic.height = height;
+  } else if ('x' in cartographic) {
+    cartographic.x = mappedLongitude;
+    cartographic.y = mappedLatitude;
+    cartographic.z = height;
+  } else {
+    cartographic[0] = mappedLongitude;
+    cartographic[1] = mappedLatitude;
+    cartographic[2] = height;
+  }
+  return cartographic;
+}
+
 export function toCartographicFromDegrees<T extends Cartographic>(
   vector: Readonly<NumericArray>,
   cartographic: T