@math.gl/geospatial 3.5.6 → 3.6.0-alpha.1

package/dist/esm/type-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/type-utils.js"],"names":["Vector3","isArray","toRadians","toDegrees","config","WGS84_CONSTANTS","noop","x","scratchVector","fromCartographic","cartographic","result","map","longitude","latitude","height","y","z","fromCartographicToRadians","vector","_cartographicRadians","fromCartographicToDegrees","toCartographic","toCartographicFromRadians","toCartographicFromDegrees","isWGS84","from","oneOverRadiiSquared","centerToleranceSquared","x2","y2","z2","Math","abs"],"mappings":"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","sourcesContent":["// This file is derived from the Cesium math library under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {Vector3, isArray, toRadians, toDegrees, config} from '@math.gl/core';\nimport {WGS84_CONSTANTS} from './constants';\n\nconst noop = (x) => x;\n\nconst scratchVector = new Vector3();\n\nexport function fromCartographic(cartographic, result, map = noop) {\n  if (isArray(cartographic)) {\n    result[0] = map(cartographic[0]);\n    result[1] = map(cartographic[1]);\n    result[2] = cartographic[2];\n  } else if ('longitude' in cartographic) {\n    result[0] = map(cartographic.longitude);\n    result[1] = map(cartographic.latitude);\n    result[2] = cartographic.height;\n  } else {\n    result[0] = map(cartographic.x);\n    result[1] = map(cartographic.y);\n    result[2] = cartographic.z;\n  }\n  return result;\n}\n\nexport function fromCartographicToRadians(cartographic, vector = scratchVector) {\n  return fromCartographic(cartographic, vector, config._cartographicRadians ? noop : toRadians);\n}\n\nexport function fromCartographicToDegrees(cartographic, vector = scratchVector) {\n  return fromCartographic(cartographic, vector, config._cartographicRadians ? toDegrees : noop);\n}\n\nexport function toCartographic(vector, cartographic, map = noop) {\n  if (isArray(cartographic)) {\n    cartographic[0] = map(vector[0]);\n    cartographic[1] = map(vector[1]);\n    cartographic[2] = vector[2];\n  } else if ('longitude' in cartographic) {\n    cartographic.longitude = map(vector[0]);\n    cartographic.latitude = map(vector[1]);\n    cartographic.height = vector[2];\n  } else {\n    cartographic.x = map(vector[0]);\n    cartographic.y = map(vector[1]);\n    cartographic.z = vector[2];\n  }\n  return cartographic;\n}\n\nexport function toCartographicFromRadians(vector, cartographic) {\n  return toCartographic(vector, cartographic, config._cartographicRadians ? noop : toDegrees);\n}\n\nexport function toCartographicFromDegrees(vector, cartographic) {\n  return toCartographic(vector, cartographic, config._cartographicRadians ? toRadians : noop);\n}\n\nexport function isWGS84(vector) {\n  if (!vector) {\n    return false;\n  }\n  scratchVector.from(vector);\n  const {oneOverRadiiSquared, centerToleranceSquared} = WGS84_CONSTANTS;\n  const x2 = vector[0] * vector[0] * oneOverRadiiSquared[0];\n  const y2 = vector[1] * vector[1] * oneOverRadiiSquared[1];\n  const z2 = vector[2] * vector[2] * oneOverRadiiSquared[2];\n  return Math.abs(x2 + y2 + z2 - 1) < centerToleranceSquared;\n}\n"],"file":"type-utils.js"}
+{"version":3,"sources":["../../src/type-utils.ts"],"names":["Vector3","isArray","toRadians","toDegrees","config","WGS84_CONSTANTS","noop","x","scratchVector","fromCartographic","cartographic","result","map","longitude","latitude","height","y","z","fromCartographicToRadians","vector","_cartographicRadians","fromCartographicToDegrees","toCartographic","toCartographicFromRadians","toCartographicFromDegrees","isWGS84","from","oneOverRadiiSquared","centerToleranceSquared","x2","y2","z2","Math","abs"],"mappings":"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","sourcesContent":["// This file is derived from the Cesium math library under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {NumericArray} from '@math.gl/types';\nimport {Vector3, isArray, toRadians, toDegrees, config} from '@math.gl/core';\nimport {WGS84_CONSTANTS} from './constants';\n\ntype LngLatHeightObject = {\n  longitude: number;\n  latitude: number;\n  height: number;\n};\n\ntype XYZObject = {\n  x: number;\n  y: number;\n  z: number;\n};\n\ntype Cartographic = LngLatHeightObject | XYZObject | NumericArray;\n\nconst noop = (x) => x;\n\nconst scratchVector = new Vector3();\n\nexport function fromCartographic(cartographic: Cartographic): number[];\nexport function fromCartographic<NumArrayT>(\n  cartographic: Cartographic,\n  result: NumArrayT,\n  map: any\n): NumArrayT;\nexport function fromCartographic(cartographic, result = [-0, -0, -0], map = noop) {\n  if (isArray(cartographic)) {\n    result[0] = map(cartographic[0]);\n    result[1] = map(cartographic[1]);\n    result[2] = cartographic[2];\n  } else if ('longitude' in cartographic) {\n    result[0] = map(cartographic.longitude);\n    result[1] = map(cartographic.latitude);\n    result[2] = cartographic.height;\n  } else {\n    result[0] = map(cartographic.x);\n    result[1] = map(cartographic.y);\n    result[2] = cartographic.z;\n  }\n  return result;\n}\n\nexport function fromCartographicToRadians(cartographic: Cartographic, result?: number[]): number[];\nexport function fromCartographicToRadians<TArray>(\n  cartographic: Cartographic,\n  result: TArray\n): TArray;\nexport function fromCartographicToRadians(cartographic, vector = []) {\n  return fromCartographic(cartographic, vector, config._cartographicRadians ? noop : toRadians);\n}\n\nexport function fromCartographicToDegrees(cartographic: Cartographic, result?: number[]): number[];\nexport function fromCartographicToDegrees<TArray>(\n  cartographic: Cartographic,\n  result: TArray\n): TArray;\nexport function fromCartographicToDegrees(cartographic, vector = []) {\n  return fromCartographic(cartographic, vector, config._cartographicRadians ? toDegrees : noop);\n}\n\nexport function toCartographic(\n  vector: Readonly<NumericArray>,\n  result: Cartographic,\n  map: any\n): number[];\nexport function toCartographic(vector, cartographic, map = noop) {\n  if (isArray(cartographic)) {\n    cartographic[0] = map(vector[0]);\n    cartographic[1] = map(vector[1]);\n    cartographic[2] = vector[2];\n  } else if ('longitude' in cartographic) {\n    cartographic.longitude = map(vector[0]);\n    cartographic.latitude = map(vector[1]);\n    cartographic.height = vector[2];\n  } else {\n    cartographic.x = map(vector[0]);\n    cartographic.y = map(vector[1]);\n    cartographic.z = vector[2];\n  }\n  return cartographic;\n}\n\nexport function toCartographicFromRadians(\n  vector: Readonly<NumericArray>,\n  cartographic: Cartographic\n): number[] {\n  return toCartographic(vector, cartographic, config._cartographicRadians ? noop : toDegrees);\n}\n\nexport function toCartographicFromDegrees(\n  vector: Readonly<NumericArray>,\n  cartographic: Cartographic\n): number[] {\n  return toCartographic(vector, cartographic, config._cartographicRadians ? toRadians : noop);\n}\n\n// Estimates if a vector is close to the surface of the WGS84 Ellipsoid\nexport function isWGS84(vector: Readonly<NumericArray>): boolean {\n  if (!vector) {\n    return false;\n  }\n  scratchVector.from(vector);\n  const {oneOverRadiiSquared, centerToleranceSquared} = WGS84_CONSTANTS;\n  const x2 = vector[0] * vector[0] * oneOverRadiiSquared[0];\n  const y2 = vector[1] * vector[1] * oneOverRadiiSquared[1];\n  const z2 = vector[2] * vector[2] * oneOverRadiiSquared[2];\n  return Math.abs(x2 + y2 + z2 - 1) < centerToleranceSquared;\n}\n\n/*\n\nexport function fromCartographic(cartographic: Cartographic, result?: number[]): number[];\nexport function fromCartographic(cartographic: Cartographic, result: TypedArray): TypedArray;\nexport function fromCartographicToRadians(cartographic: Cartographic, result?: number[]): number[];\nexport function fromCartographicToRadians(\n  cartographic: Cartographic,\n  result: TypedArray\n): TypedArray;\nexport function fromCartographicToDegrees(cartographic: Cartographic, result?: number[]): number[];\nexport function fromCartographicToDegrees(\n  cartographic: Cartographic,\n  result: TypedArray\n): TypedArray;\n\nexport function toCartographic(vector: number[] | TypedArray, result: Cartographic): number[];\nexport function toCartographicFromRadians(\n  vector: number[] | TypedArray,\n  result: Cartographic\n): number[];\nexport function toCartographicFromDegrees(\n  vector: number[] | TypedArray,\n  result: Cartographic\n): number[];\n\n// Estimates if a vector is close to the surface of the WGS84 Ellipsoid\nexport function isWGS84(vector: number[] | TypedArray): boolean;\n*/\n"],"file":"type-utils.js"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Ellipsoid } from './ellipsoid/ellipsoid';
+export { isWGS84 } from './type-utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAC,OAAO,EAAC,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { default as Ellipsoid } from './ellipsoid/ellipsoid';
+export { isWGS84 } from './type-utils';

package/dist/type-utils.d.ts

@@ -0,0 +1,24 @@
+import { NumericArray } from '@math.gl/types';
+declare type LngLatHeightObject = {
+    longitude: number;
+    latitude: number;
+    height: number;
+};
+declare type XYZObject = {
+    x: number;
+    y: number;
+    z: number;
+};
+declare type Cartographic = LngLatHeightObject | XYZObject | NumericArray;
+export declare function fromCartographic(cartographic: Cartographic): number[];
+export declare function fromCartographic<NumArrayT>(cartographic: Cartographic, result: NumArrayT, map: any): NumArrayT;
+export declare function fromCartographicToRadians(cartographic: Cartographic, result?: number[]): number[];
+export declare function fromCartographicToRadians<TArray>(cartographic: Cartographic, result: TArray): TArray;
+export declare function fromCartographicToDegrees(cartographic: Cartographic, result?: number[]): number[];
+export declare function fromCartographicToDegrees<TArray>(cartographic: Cartographic, result: TArray): TArray;
+export declare function toCartographic(vector: Readonly<NumericArray>, result: Cartographic, map: any): number[];
+export declare function toCartographicFromRadians(vector: Readonly<NumericArray>, cartographic: Cartographic): number[];
+export declare function toCartographicFromDegrees(vector: Readonly<NumericArray>, cartographic: Cartographic): number[];
+export declare function isWGS84(vector: Readonly<NumericArray>): boolean;
+export {};
+//# sourceMappingURL=type-utils.d.ts.map

package/dist/type-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-utils.d.ts","sourceRoot":"","sources":["../src/type-utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAI5C,aAAK,kBAAkB,GAAG;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,aAAK,SAAS,GAAG;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,aAAK,YAAY,GAAG,kBAAkB,GAAG,SAAS,GAAG,YAAY,CAAC;AAMlE,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAC;AACvE,wBAAgB,gBAAgB,CAAC,SAAS,EACxC,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,SAAS,EACjB,GAAG,EAAE,GAAG,GACP,SAAS,CAAC;AAkBb,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;AACnG,wBAAgB,yBAAyB,CAAC,MAAM,EAC9C,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,MAAM,GACb,MAAM,CAAC;AAKV,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;AACnG,wBAAgB,yBAAyB,CAAC,MAAM,EAC9C,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,MAAM,GACb,MAAM,CAAC;AAKV,wBAAgB,cAAc,CAC5B,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC9B,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,GAAG,GACP,MAAM,EAAE,CAAC;AAkBZ,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC9B,YAAY,EAAE,YAAY,GACzB,MAAM,EAAE,CAEV;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC9B,YAAY,EAAE,YAAY,GACzB,MAAM,EAAE,CAEV;AAGD,wBAAgB,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,OAAO,CAU/D"}

package/dist/type-utils.js

@@ -0,0 +1,94 @@
+// 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
+import { Vector3, isArray, toRadians, toDegrees, config } from '@math.gl/core';
+import { WGS84_CONSTANTS } from './constants';
+const noop = (x) => x;
+const scratchVector = new Vector3();
+export function fromCartographic(cartographic, result = [-0, -0, -0], map = noop) {
+    if (isArray(cartographic)) {
+        result[0] = map(cartographic[0]);
+        result[1] = map(cartographic[1]);
+        result[2] = cartographic[2];
+    }
+    else if ('longitude' in cartographic) {
+        result[0] = map(cartographic.longitude);
+        result[1] = map(cartographic.latitude);
+        result[2] = cartographic.height;
+    }
+    else {
+        result[0] = map(cartographic.x);
+        result[1] = map(cartographic.y);
+        result[2] = cartographic.z;
+    }
+    return result;
+}
+export function fromCartographicToRadians(cartographic, vector = []) {
+    return fromCartographic(cartographic, vector, config._cartographicRadians ? noop : toRadians);
+}
+export function fromCartographicToDegrees(cartographic, vector = []) {
+    return fromCartographic(cartographic, vector, config._cartographicRadians ? toDegrees : noop);
+}
+export function toCartographic(vector, cartographic, map = noop) {
+    if (isArray(cartographic)) {
+        cartographic[0] = map(vector[0]);
+        cartographic[1] = map(vector[1]);
+        cartographic[2] = vector[2];
+    }
+    else if ('longitude' in cartographic) {
+        cartographic.longitude = map(vector[0]);
+        cartographic.latitude = map(vector[1]);
+        cartographic.height = vector[2];
+    }
+    else {
+        cartographic.x = map(vector[0]);
+        cartographic.y = map(vector[1]);
+        cartographic.z = vector[2];
+    }
+    return cartographic;
+}
+export function toCartographicFromRadians(vector, cartographic) {
+    return toCartographic(vector, cartographic, config._cartographicRadians ? noop : toDegrees);
+}
+export function toCartographicFromDegrees(vector, cartographic) {
+    return toCartographic(vector, cartographic, config._cartographicRadians ? toRadians : noop);
+}
+// Estimates if a vector is close to the surface of the WGS84 Ellipsoid
+export function isWGS84(vector) {
+    if (!vector) {
+        return false;
+    }
+    scratchVector.from(vector);
+    const { oneOverRadiiSquared, centerToleranceSquared } = WGS84_CONSTANTS;
+    const x2 = vector[0] * vector[0] * oneOverRadiiSquared[0];
+    const y2 = vector[1] * vector[1] * oneOverRadiiSquared[1];
+    const z2 = vector[2] * vector[2] * oneOverRadiiSquared[2];
+    return Math.abs(x2 + y2 + z2 - 1) < centerToleranceSquared;
+}
+/*
+
+export function fromCartographic(cartographic: Cartographic, result?: number[]): number[];
+export function fromCartographic(cartographic: Cartographic, result: TypedArray): TypedArray;
+export function fromCartographicToRadians(cartographic: Cartographic, result?: number[]): number[];
+export function fromCartographicToRadians(
+  cartographic: Cartographic,
+  result: TypedArray
+): TypedArray;
+export function fromCartographicToDegrees(cartographic: Cartographic, result?: number[]): number[];
+export function fromCartographicToDegrees(
+  cartographic: Cartographic,
+  result: TypedArray
+): TypedArray;
+
+export function toCartographic(vector: number[] | TypedArray, result: Cartographic): number[];
+export function toCartographicFromRadians(
+  vector: number[] | TypedArray,
+  result: Cartographic
+): number[];
+export function toCartographicFromDegrees(
+  vector: number[] | TypedArray,
+  result: Cartographic
+): number[];
+
+// Estimates if a vector is close to the surface of the WGS84 Ellipsoid
+export function isWGS84(vector: number[] | TypedArray): boolean;
+*/

package/package.json

@@ -5,7 +5,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.5.6",
+  "version": "3.6.0-alpha.1",
   "keywords": [
     "webgl",
     "javascript",
@@ -23,7 +23,7 @@
     "type": "git",
     "url": "https://github.com/uber-web/math.gl.git"
   },
-  "types": "src/index.js",
+  "types": "dist/index.d.ts",
   "main": "dist/es5/index.js",
   "module": "dist/esm/index.js",
   "files": [
@@ -32,8 +32,8 @@
   ],
   "dependencies": {
     "@babel/runtime": "^7.12.0",
-    "@math.gl/core": "3.5.6",
+    "@math.gl/core": "3.6.0-alpha.1",
     "gl-matrix": "~3.3.0"
   },
-  "gitHead": "0e69c70ff2e6373fed84d303cbf8198a6972944f"
+  "gitHead": "45386981340895bf201c2ebb76257c9bbffd8ff6"
 }

package/src/ellipsoid/{ellipsoid.js → ellipsoid.ts}

@@ -2,7 +2,16 @@
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 
 /* eslint-disable */
-import {Vector3, Matrix4, toRadians, toDegrees, assert, equals, _MathUtils} from '@math.gl/core';
+import {
+  Vector3,
+  Matrix4,
+  toRadians,
+  toDegrees,
+  assert,
+  equals,
+  _MathUtils,
+  NumericArray
+} from '@math.gl/core';
 import * as vec3 from 'gl-matrix/vec3';
 
 import {WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z} from '../constants';
@@ -20,17 +29,29 @@ const scratchCartesian = new Vector3();
 
 let wgs84;
 
-// A quadratic surface defined in Cartesian coordinates by the equation
-// <code>(x / a)^2 + (y / b)^2 + (z / c)^2 = 1</code>.  Primarily used
-// to represent the shape of planetary bodies.
+/**
+ * A quadratic surface defined in Cartesian coordinates by the equation
+ * `(x / a)^2 + (y / b)^2 + (z / c)^2 = 1`.  Primarily used
+ * to represent the shape of planetary bodies.
+ */
 export default class Ellipsoid {
-  // An Ellipsoid instance initialized to the WGS84 standard.
-  static get WGS84() {
-    wgs84 = wgs84 || new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
-    return wgs84;
-  }
+  /** An Ellipsoid instance initialized to the WGS84 standard. */
+  static readonly WGS84 = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
+
+  readonly radii: Vector3;
+  readonly radiiSquared: Vector3;
+  readonly radiiToTheFourth: Vector3;
+  readonly oneOverRadii: Vector3;
+  readonly oneOverRadiiSquared: Vector3;
+  readonly minimumRadius: number;
+  readonly maximumRadius: number;
+  readonly centerToleranceSquared: number = _MathUtils.EPSILON1;
+  readonly squaredXOverSquaredZ: number;
+
+  /** Creates an Ellipsoid from a Cartesian specifying the radii in x, y, and z directions. */
+  constructor(x: number, y: number, z: number);
+  constructor();
 
-  // Creates an Ellipsoid from a Cartesian specifying the radii in x, y, and z directions.
   constructor(x = 0.0, y = 0.0, z = 0.0) {
     assert(x >= 0.0);
     assert(y >= 0.0);
@@ -58,8 +79,6 @@ export default class Ellipsoid {
 
     this.maximumRadius = Math.max(x, y, z);
 
-    this.centerToleranceSquared = _MathUtils.EPSILON1;
-
     if (this.radiiSquared.z !== 0) {
       this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;
     }
@@ -67,17 +86,20 @@ export default class Ellipsoid {
     Object.freeze(this);
   }
 
-  // Compares this Ellipsoid against the provided Ellipsoid componentwise and returns
-  equals(right) {
+  /** Compares this Ellipsoid against the provided Ellipsoid componentwise */
+  equals(right: Ellipsoid): boolean {
     return this === right || Boolean(right && this.radii.equals(right.radii));
   }
 
-  // Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'.
-  toString() {
+  /** Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'. */
+  toString(): string {
     return this.radii.toString();
   }
 
-  // Converts the provided cartographic to Cartesian representation.
+  /** Converts the provided cartographic to Cartesian representation. */
+  cartographicToCartesian(cartographic: number[], result: Vector3): Vector3;
+  cartographicToCartesian(cartographic: number[], result?: number[]): number[];
+
   cartographicToCartesian(cartographic, result = [0, 0, 0]) {
     const normal = scratchNormal;
     const k = scratchK;
@@ -96,8 +118,11 @@ export default class Ellipsoid {
     return k.to(result);
   }
 
-  // Converts the provided cartesian to cartographic (lng/lat/z) representation.
-  // The cartesian is undefined at the center of the ellipsoid.
+  /** Converts the provided cartesian to cartographic (lng/lat/z) representation.
+   * The cartesian is undefined at the center of the ellipsoid. */
+  cartesianToCartographic(cartesian: number[], result: Vector3): Vector3;
+  cartesianToCartographic(cartesian: number[], result?: number[]): number[];
+
   cartesianToCartographic(cartesian, result = [0, 0, 0]) {
     scratchCartesian.from(cartesian);
     const point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);
@@ -118,25 +143,50 @@ export default class Ellipsoid {
     return toCartographicFromRadians([longitude, latitude, height], result);
   }
 
-  // Computes a 4x4 transformation matrix from a reference frame with an east-north-up axes
-  // centered at the provided origin to the provided ellipsoid's fixed reference frame.
+  /** Computes a 4x4 transformation matrix from a reference frame with an east-north-up axes
+   * centered at the provided origin to the provided ellipsoid's fixed reference frame. */
+  eastNorthUpToFixedFrame(origin: number[], result?: Matrix4): Matrix4;
+  eastNorthUpToFixedFrame(origin: number[], result: number[]): number[];
+
   eastNorthUpToFixedFrame(origin, result = new Matrix4()) {
     return localFrameToFixedFrame(this, 'east', 'north', 'up', origin, result);
   }
 
+  /** Computes a 4x4 transformation matrix from a reference frame centered at
+   * the provided origin to the ellipsoid's fixed reference frame.
+   */
+  localFrameToFixedFrame(
+    firstAxis: string,
+    secondAxis: string,
+    thirdAxis: string,
+    origin: Readonly<NumericArray>,
+    result?: Matrix4
+  ): Matrix4;
+  localFrameToFixedFrame<Matrix4T>(
+    firstAxis: string,
+    secondAxis: string,
+    thirdAxis: string,
+    origin: Readonly<NumericArray>,
+    result: number[]
+  ): number[];
+
   // Computes a 4x4 transformation matrix from a reference frame centered at
   // the provided origin to the ellipsoid's fixed reference frame.
   localFrameToFixedFrame(firstAxis, secondAxis, thirdAxis, origin, result = new Matrix4()) {
     return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);
   }
 
-  // Computes the unit vector directed from the center of this ellipsoid toward
-  // the provided Cartesian position.
+  /** Computes the unit vector directed from the center of this ellipsoid toward
+   * the provided Cartesian position. */
+  geocentricSurfaceNormal(cartesian: number[], result?: number[]): number[];
+  geocentricSurfaceNormal<NumArray>(cartesian: number[], result: NumArray): NumArray;
   geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {
     return scratchVector.from(cartesian).normalize().to(result);
   }
 
-  // Computes the normal of the plane tangent to the surface of the ellipsoid at provided position.
+  /** Computes the normal of the plane tangent to the surface of the ellipsoid at provided position. */
+  geodeticSurfaceNormalCartographic<NumArray>(cartographic: number[], result: NumArray): NumArray;
+  geodeticSurfaceNormalCartographic(cartographic: number[]): number[];
   geodeticSurfaceNormalCartographic(cartographic, result = [0, 0, 0]) {
     const cartographicVectorRadians = fromCartographicToRadians(cartographic);
 
@@ -152,20 +202,24 @@ export default class Ellipsoid {
     return scratchVector.to(result);
   }
 
-  // Computes the normal of the plane tangent to the surface of the ellipsoid at the provided position.
+  /** Computes the normal of the plane tangent to the surface of the ellipsoid at the provided position. */
+  geodeticSurfaceNormal<NumArrayT>(cartesian: number[], result: NumArrayT): NumArrayT;
+  geodeticSurfaceNormal(cartesian: number[]): number[];
   geodeticSurfaceNormal(cartesian, result = [0, 0, 0]) {
     return scratchVector.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);
   }
 
-  // Scales the provided Cartesian position along the geodetic surface normal
-  // so that it is on the surface of this ellipsoid.  If the position is
-  // at the center of the ellipsoid, this function returns undefined.
+  /** Scales the provided Cartesian position along the geodetic surface normal
+   * so that it is on the surface of this ellipsoid.  If the position is
+   * at the center of the ellipsoid, this function returns undefined. */
+  scaleToGeodeticSurface(cartesian: number[], result?: number[]): number[];
   scaleToGeodeticSurface(cartesian, result) {
     return scaleToGeodeticSurface(cartesian, this, result);
   }
 
-  // Scales the provided Cartesian position along the geocentric surface normal
-  // so that it is on the surface of this ellipsoid.
+  /** Scales the provided Cartesian position along the geocentric surface normal
+   * so that it is on the surface of this ellipsoid. */
+  scaleToGeocentricSurface(cartesian: number[], result?: number[]): number[];
   scaleToGeocentricSurface(cartesian, result = [0, 0, 0]) {
     scratchPosition.from(cartesian);
 
@@ -185,19 +239,26 @@ export default class Ellipsoid {
     return scratchPosition.multiplyScalar(beta).to(result);
   }
 
-  // Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
-  // its components by the result of `Ellipsoid#oneOverRadii`
+  /** Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
+   * its components by the result of `Ellipsoid#oneOverRadii` */
+  transformPositionToScaledSpace(position: number[], result?: number[]): number[];
   transformPositionToScaledSpace(position, result = [0, 0, 0]) {
     return scratchPosition.from(position).scale(this.oneOverRadii).to(result);
   }
 
-  // Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
-  // its components by the result of `Ellipsoid#radii`.
+  /** Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
+   * its components by the result of `Ellipsoid#radii`. */
+  transformPositionFromScaledSpace(position: number[], result?: number[]): number[];
   transformPositionFromScaledSpace(position, result = [0, 0, 0]) {
     return scratchPosition.from(position).scale(this.radii).to(result);
   }
 
-  // Computes a point which is the intersection of the surface normal with the z-axis.
+  /** Computes a point which is the intersection of the surface normal with the z-axis. */
+  getSurfaceNormalIntersectionWithZAxis(
+    position: number[],
+    buffer?: number,
+    result?: number[]
+  ): number[];
   getSurfaceNormalIntersectionWithZAxis(position, buffer = 0.0, result = [0, 0, 0]) {
     // Ellipsoid must be an ellipsoid of revolution (radii.x == radii.y)
     assert(equals(this.radii.x, this.radii.y, _MathUtils.EPSILON15));

package/src/type-utils.ts

@@ -0,0 +1,143 @@
+// 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
+
+import {NumericArray} from '@math.gl/types';
+import {Vector3, isArray, toRadians, toDegrees, config} from '@math.gl/core';
+import {WGS84_CONSTANTS} from './constants';
+
+type LngLatHeightObject = {
+  longitude: number;
+  latitude: number;
+  height: number;
+};
+
+type XYZObject = {
+  x: number;
+  y: number;
+  z: number;
+};
+
+type Cartographic = LngLatHeightObject | XYZObject | NumericArray;
+
+const noop = (x) => x;
+
+const scratchVector = new Vector3();
+
+export function fromCartographic(cartographic: Cartographic): number[];
+export function fromCartographic<NumArrayT>(
+  cartographic: Cartographic,
+  result: NumArrayT,
+  map: any
+): NumArrayT;
+export function fromCartographic(cartographic, result = [-0, -0, -0], map = noop) {
+  if (isArray(cartographic)) {
+    result[0] = map(cartographic[0]);
+    result[1] = map(cartographic[1]);
+    result[2] = cartographic[2];
+  } else if ('longitude' in cartographic) {
+    result[0] = map(cartographic.longitude);
+    result[1] = map(cartographic.latitude);
+    result[2] = cartographic.height;
+  } else {
+    result[0] = map(cartographic.x);
+    result[1] = map(cartographic.y);
+    result[2] = cartographic.z;
+  }
+  return result;
+}
+
+export function fromCartographicToRadians(cartographic: Cartographic, result?: number[]): number[];
+export function fromCartographicToRadians<TArray>(
+  cartographic: Cartographic,
+  result: TArray
+): TArray;
+export function fromCartographicToRadians(cartographic, vector = []) {
+  return fromCartographic(cartographic, vector, config._cartographicRadians ? noop : toRadians);
+}
+
+export function fromCartographicToDegrees(cartographic: Cartographic, result?: number[]): number[];
+export function fromCartographicToDegrees<TArray>(
+  cartographic: Cartographic,
+  result: TArray
+): TArray;
+export function fromCartographicToDegrees(cartographic, vector = []) {
+  return fromCartographic(cartographic, vector, config._cartographicRadians ? toDegrees : noop);
+}
+
+export function toCartographic(
+  vector: Readonly<NumericArray>,
+  result: Cartographic,
+  map: any
+): number[];
+export function toCartographic(vector, cartographic, map = noop) {
+  if (isArray(cartographic)) {
+    cartographic[0] = map(vector[0]);
+    cartographic[1] = map(vector[1]);
+    cartographic[2] = vector[2];
+  } else if ('longitude' in cartographic) {
+    cartographic.longitude = map(vector[0]);
+    cartographic.latitude = map(vector[1]);
+    cartographic.height = vector[2];
+  } else {
+    cartographic.x = map(vector[0]);
+    cartographic.y = map(vector[1]);
+    cartographic.z = vector[2];
+  }
+  return cartographic;
+}
+
+export function toCartographicFromRadians(
+  vector: Readonly<NumericArray>,
+  cartographic: Cartographic
+): number[] {
+  return toCartographic(vector, cartographic, config._cartographicRadians ? noop : toDegrees);
+}
+
+export function toCartographicFromDegrees(
+  vector: Readonly<NumericArray>,
+  cartographic: Cartographic
+): number[] {
+  return toCartographic(vector, cartographic, config._cartographicRadians ? toRadians : noop);
+}
+
+// Estimates if a vector is close to the surface of the WGS84 Ellipsoid
+export function isWGS84(vector: Readonly<NumericArray>): boolean {
+  if (!vector) {
+    return false;
+  }
+  scratchVector.from(vector);
+  const {oneOverRadiiSquared, centerToleranceSquared} = WGS84_CONSTANTS;
+  const x2 = vector[0] * vector[0] * oneOverRadiiSquared[0];
+  const y2 = vector[1] * vector[1] * oneOverRadiiSquared[1];
+  const z2 = vector[2] * vector[2] * oneOverRadiiSquared[2];
+  return Math.abs(x2 + y2 + z2 - 1) < centerToleranceSquared;
+}
+
+/*
+
+export function fromCartographic(cartographic: Cartographic, result?: number[]): number[];
+export function fromCartographic(cartographic: Cartographic, result: TypedArray): TypedArray;
+export function fromCartographicToRadians(cartographic: Cartographic, result?: number[]): number[];
+export function fromCartographicToRadians(
+  cartographic: Cartographic,
+  result: TypedArray
+): TypedArray;
+export function fromCartographicToDegrees(cartographic: Cartographic, result?: number[]): number[];
+export function fromCartographicToDegrees(
+  cartographic: Cartographic,
+  result: TypedArray
+): TypedArray;
+
+export function toCartographic(vector: number[] | TypedArray, result: Cartographic): number[];
+export function toCartographicFromRadians(
+  vector: number[] | TypedArray,
+  result: Cartographic
+): number[];
+export function toCartographicFromDegrees(
+  vector: number[] | TypedArray,
+  result: Cartographic
+): number[];
+
+// Estimates if a vector is close to the surface of the WGS84 Ellipsoid
+export function isWGS84(vector: number[] | TypedArray): boolean;
+*/