@math.gl/geospatial 4.0.0-beta.1 → 4.0.1

package/dist/ellipsoid/helpers/scale-to-geodetic-surface.js

@@ -1,66 +1,70 @@
+/* eslint-disable */
 import { Vector3, _MathUtils } from '@math.gl/core';
 const scratchVector = new Vector3();
 const scaleToGeodeticSurfaceIntersection = new Vector3();
 const scaleToGeodeticSurfaceGradient = new Vector3();
+// 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.
 export function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
-  const {
-    oneOverRadii,
-    oneOverRadiiSquared,
-    centerToleranceSquared
-  } = ellipsoid;
-  scratchVector.from(cartesian);
-  const positionX = scratchVector.x;
-  const positionY = scratchVector.y;
-  const positionZ = scratchVector.z;
-  const oneOverRadiiX = oneOverRadii.x;
-  const oneOverRadiiY = oneOverRadii.y;
-  const oneOverRadiiZ = oneOverRadii.z;
-  const x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;
-  const y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;
-  const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;
-  const squaredNorm = x2 + y2 + z2;
-  const ratio = Math.sqrt(1.0 / squaredNorm);
-
-  if (!Number.isFinite(ratio)) {
-    return undefined;
-  }
-
-  const intersection = scaleToGeodeticSurfaceIntersection;
-  intersection.copy(cartesian).scale(ratio);
-
-  if (squaredNorm < centerToleranceSquared) {
-    return intersection.to(result);
-  }
-
-  const oneOverRadiiSquaredX = oneOverRadiiSquared.x;
-  const oneOverRadiiSquaredY = oneOverRadiiSquared.y;
-  const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
-  const gradient = scaleToGeodeticSurfaceGradient;
-  gradient.set(intersection.x * oneOverRadiiSquaredX * 2.0, intersection.y * oneOverRadiiSquaredY * 2.0, intersection.z * oneOverRadiiSquaredZ * 2.0);
-  let lambda = (1.0 - ratio) * scratchVector.len() / (0.5 * gradient.len());
-  let correction = 0.0;
-  let xMultiplier;
-  let yMultiplier;
-  let zMultiplier;
-  let func;
-
-  do {
-    lambda -= correction;
-    xMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredX);
-    yMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredY);
-    zMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredZ);
-    const xMultiplier2 = xMultiplier * xMultiplier;
-    const yMultiplier2 = yMultiplier * yMultiplier;
-    const zMultiplier2 = zMultiplier * zMultiplier;
-    const xMultiplier3 = xMultiplier2 * xMultiplier;
-    const yMultiplier3 = yMultiplier2 * yMultiplier;
-    const zMultiplier3 = zMultiplier2 * zMultiplier;
-    func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1.0;
-    const denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX + y2 * yMultiplier3 * oneOverRadiiSquaredY + z2 * zMultiplier3 * oneOverRadiiSquaredZ;
-    const derivative = -2.0 * denominator;
-    correction = func / derivative;
-  } while (Math.abs(func) > _MathUtils.EPSILON12);
-
-  return scratchVector.scale([xMultiplier, yMultiplier, zMultiplier]).to(result);
+    const { oneOverRadii, oneOverRadiiSquared, centerToleranceSquared } = ellipsoid;
+    scratchVector.from(cartesian);
+    const positionX = scratchVector.x;
+    const positionY = scratchVector.y;
+    const positionZ = scratchVector.z;
+    const oneOverRadiiX = oneOverRadii.x;
+    const oneOverRadiiY = oneOverRadii.y;
+    const oneOverRadiiZ = oneOverRadii.z;
+    const x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;
+    const y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;
+    const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;
+    // Compute the squared ellipsoid norm.
+    const squaredNorm = x2 + y2 + z2;
+    const ratio = Math.sqrt(1.0 / squaredNorm);
+    // When very close to center or at center
+    if (!Number.isFinite(ratio)) {
+        return undefined;
+    }
+    // As an initial approximation, assume that the radial intersection is the projection point.
+    const intersection = scaleToGeodeticSurfaceIntersection;
+    intersection.copy(cartesian).scale(ratio);
+    // If the position is near the center, the iteration will not converge.
+    if (squaredNorm < centerToleranceSquared) {
+        return intersection.to(result);
+    }
+    const oneOverRadiiSquaredX = oneOverRadiiSquared.x;
+    const oneOverRadiiSquaredY = oneOverRadiiSquared.y;
+    const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
+    // Use the gradient at the intersection point in place of the true unit normal.
+    // The difference in magnitude will be absorbed in the multiplier.
+    const gradient = scaleToGeodeticSurfaceGradient;
+    gradient.set(intersection.x * oneOverRadiiSquaredX * 2.0, intersection.y * oneOverRadiiSquaredY * 2.0, intersection.z * oneOverRadiiSquaredZ * 2.0);
+    // Compute the initial guess at the normal vector multiplier, lambda.
+    let lambda = ((1.0 - ratio) * scratchVector.len()) / (0.5 * gradient.len());
+    let correction = 0.0;
+    let xMultiplier;
+    let yMultiplier;
+    let zMultiplier;
+    let func;
+    do {
+        lambda -= correction;
+        xMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredX);
+        yMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredY);
+        zMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredZ);
+        const xMultiplier2 = xMultiplier * xMultiplier;
+        const yMultiplier2 = yMultiplier * yMultiplier;
+        const zMultiplier2 = zMultiplier * zMultiplier;
+        const xMultiplier3 = xMultiplier2 * xMultiplier;
+        const yMultiplier3 = yMultiplier2 * yMultiplier;
+        const zMultiplier3 = zMultiplier2 * zMultiplier;
+        func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1.0;
+        // "denominator" here refers to the use of this expression in the velocity and acceleration
+        // computations in the sections to follow.
+        const denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX +
+            y2 * yMultiplier3 * oneOverRadiiSquaredY +
+            z2 * zMultiplier3 * oneOverRadiiSquaredZ;
+        const derivative = -2.0 * denominator;
+        correction = func / derivative;
+    } while (Math.abs(func) > _MathUtils.EPSILON12);
+    return scratchVector.scale([xMultiplier, yMultiplier, zMultiplier]).to(result);
 }
-//# sourceMappingURL=scale-to-geodetic-surface.js.map

package/dist/index.cjs

@@ -16,18 +16,18 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
   Ellipsoid: () => Ellipsoid,
   isWGS84: () => isWGS84
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(dist_exports);
 
-// src/ellipsoid/ellipsoid.ts
+// dist/ellipsoid/ellipsoid.js
 var import_core4 = require("@math.gl/core");
 
-// src/constants.ts
+// dist/constants.js
 var WGS84_RADIUS_X = 6378137;
 var WGS84_RADIUS_Y = 6378137;
 var WGS84_RADIUS_Z = 6356752314245179e-9;
@@ -48,7 +48,7 @@ var WGS84_CONSTANTS = {
   centerToleranceSquared: 0.1
 };
 
-// src/type-utils.ts
+// dist/type-utils.js
 var import_core = require("@math.gl/core");
 function identity(x) {
   return x;
@@ -104,7 +104,7 @@ function isWGS84(vector) {
   return Math.abs(x2 + y2 + z2 - 1) < centerToleranceSquared;
 }
 
-// src/ellipsoid/helpers/ellipsoid-transform.ts
+// dist/ellipsoid/helpers/ellipsoid-transform.js
 var import_core2 = require("@math.gl/core");
 var EPSILON14 = 1e-14;
 var scratchOrigin = new import_core2.Vector3();
@@ -219,7 +219,7 @@ function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, car
   return result;
 }
 
-// src/ellipsoid/helpers/scale-to-geodetic-surface.ts
+// dist/ellipsoid/helpers/scale-to-geodetic-surface.js
 var import_core3 = require("@math.gl/core");
 var scratchVector4 = new import_core3.Vector3();
 var scaleToGeodeticSurfaceIntersection = new import_core3.Vector3();
@@ -250,11 +250,7 @@ function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
   const oneOverRadiiSquaredY = oneOverRadiiSquared.y;
   const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
   const gradient = scaleToGeodeticSurfaceGradient;
-  gradient.set(
-    intersection.x * oneOverRadiiSquaredX * 2,
-    intersection.y * oneOverRadiiSquaredY * 2,
-    intersection.z * oneOverRadiiSquaredZ * 2
-  );
+  gradient.set(intersection.x * oneOverRadiiSquaredX * 2, intersection.y * oneOverRadiiSquaredY * 2, intersection.z * oneOverRadiiSquaredZ * 2);
   let lambda = (1 - ratio) * scratchVector4.len() / (0.5 * gradient.len());
   let correction = 0;
   let xMultiplier;
@@ -280,14 +276,14 @@ function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
   return scratchVector4.scale([xMultiplier, yMultiplier, zMultiplier]).to(result);
 }
 
-// src/ellipsoid/ellipsoid.ts
+// dist/ellipsoid/ellipsoid.js
 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 {
   constructor(x = 0, y = 0, z = 0) {
     this.centerToleranceSquared = import_core4._MathUtils.EPSILON1;
     (0, import_core4.assert)(x >= 0);
@@ -296,16 +292,8 @@ var _Ellipsoid = class {
     this.radii = new import_core4.Vector3(x, y, z);
     this.radiiSquared = new import_core4.Vector3(x * x, y * y, z * z);
     this.radiiToTheFourth = new import_core4.Vector3(x * x * x * x, y * y * y * y, z * z * z * z);
-    this.oneOverRadii = new import_core4.Vector3(
-      x === 0 ? 0 : 1 / x,
-      y === 0 ? 0 : 1 / y,
-      z === 0 ? 0 : 1 / z
-    );
-    this.oneOverRadiiSquared = new import_core4.Vector3(
-      x === 0 ? 0 : 1 / (x * x),
-      y === 0 ? 0 : 1 / (y * y),
-      z === 0 ? 0 : 1 / (z * z)
-    );
+    this.oneOverRadii = new import_core4.Vector3(x === 0 ? 0 : 1 / x, y === 0 ? 0 : 1 / y, z === 0 ? 0 : 1 / z);
+    this.oneOverRadiiSquared = new import_core4.Vector3(x === 0 ? 0 : 1 / (x * x), y === 0 ? 0 : 1 / (y * y), z === 0 ? 0 : 1 / (z * z));
     this.minimumRadius = Math.min(x, y, z);
     this.maximumRadius = Math.max(x, y, z);
     if (this.radiiSquared.z !== 0) {
@@ -374,9 +362,7 @@ var _Ellipsoid = class {
     const positionY = scratchPosition.y;
     const positionZ = scratchPosition.z;
     const oneOverRadiiSquared = this.oneOverRadiiSquared;
-    const beta = 1 / Math.sqrt(
-      positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z
-    );
+    const beta = 1 / Math.sqrt(positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z);
     return scratchPosition.multiplyScalar(beta).to(result);
   }
   transformPositionToScaledSpace(position, result = [0, 0, 0]) {
@@ -396,5 +382,5 @@ var _Ellipsoid = class {
     return scratchPosition.set(0, 0, z).to(result);
   }
 };
-var Ellipsoid = _Ellipsoid;
-Ellipsoid.WGS84 = new _Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
+Ellipsoid.WGS84 = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["index.js", "ellipsoid/ellipsoid.js", "constants.js", "type-utils.js", "ellipsoid/helpers/ellipsoid-transform.js", "ellipsoid/helpers/scale-to-geodetic-surface.js"],
+  "sourcesContent": ["export { Ellipsoid } from \"./ellipsoid/ellipsoid.js\";\nexport { isWGS84 } from \"./type-utils.js\";\n", "// 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/* eslint-disable */\nimport { Vector3, Matrix4, assert, equals, _MathUtils, vec3 } from '@math.gl/core';\nimport { WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z } from \"../constants.js\";\nimport { fromCartographicToRadians, toCartographicFromRadians } from \"../type-utils.js\";\nimport { localFrameToFixedFrame } from \"./helpers/ellipsoid-transform.js\";\nimport { scaleToGeodeticSurface } from \"./helpers/scale-to-geodetic-surface.js\";\nconst scratchVector = new Vector3();\nconst scratchNormal = new Vector3();\nconst scratchK = new Vector3();\nconst scratchPosition = new Vector3();\nconst scratchHeight = new Vector3();\nconst scratchCartesian = new Vector3();\n/**\n * A quadratic surface defined in Cartesian coordinates by the equation\n * `(x / a)^2 + (y / b)^2 + (z / c)^2 = 1`.  Primarily used\n * to represent the shape of planetary bodies.\n */\nexport class Ellipsoid {\n    constructor(x = 0.0, y = 0.0, z = 0.0) {\n        this.centerToleranceSquared = _MathUtils.EPSILON1;\n        assert(x >= 0.0);\n        assert(y >= 0.0);\n        assert(z >= 0.0);\n        this.radii = new Vector3(x, y, z);\n        this.radiiSquared = new Vector3(x * x, y * y, z * z);\n        this.radiiToTheFourth = new Vector3(x * x * x * x, y * y * y * y, z * z * z * z);\n        this.oneOverRadii = new Vector3(x === 0.0 ? 0.0 : 1.0 / x, y === 0.0 ? 0.0 : 1.0 / y, z === 0.0 ? 0.0 : 1.0 / z);\n        this.oneOverRadiiSquared = new Vector3(x === 0.0 ? 0.0 : 1.0 / (x * x), y === 0.0 ? 0.0 : 1.0 / (y * y), z === 0.0 ? 0.0 : 1.0 / (z * z));\n        this.minimumRadius = Math.min(x, y, z);\n        this.maximumRadius = Math.max(x, y, z);\n        if (this.radiiSquared.z !== 0) {\n            this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;\n        }\n        Object.freeze(this);\n    }\n    /** Compares this Ellipsoid against the provided Ellipsoid componentwise */\n    equals(right) {\n        return this === right || Boolean(right && this.radii.equals(right.radii));\n    }\n    /** Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'. */\n    toString() {\n        return this.radii.toString();\n    }\n    cartographicToCartesian(cartographic, result = [0, 0, 0]) {\n        const normal = scratchNormal;\n        const k = scratchK;\n        const [, , height] = cartographic;\n        this.geodeticSurfaceNormalCartographic(cartographic, normal);\n        k.copy(this.radiiSquared).scale(normal);\n        const gamma = Math.sqrt(normal.dot(k));\n        k.scale(1 / gamma);\n        normal.scale(height);\n        k.add(normal);\n        return k.to(result);\n    }\n    cartesianToCartographic(cartesian, result = [0, 0, 0]) {\n        scratchCartesian.from(cartesian);\n        const point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);\n        if (!point) {\n            return undefined;\n        }\n        const normal = this.geodeticSurfaceNormal(point, scratchNormal);\n        const h = scratchHeight;\n        h.copy(scratchCartesian).subtract(point);\n        const longitude = Math.atan2(normal.y, normal.x);\n        const latitude = Math.asin(normal.z);\n        const height = Math.sign(vec3.dot(h, scratchCartesian)) * vec3.length(h);\n        return toCartographicFromRadians([longitude, latitude, height], result);\n    }\n    eastNorthUpToFixedFrame(origin, result = new Matrix4()) {\n        return localFrameToFixedFrame(this, 'east', 'north', 'up', origin, result);\n    }\n    // Computes a 4x4 transformation matrix from a reference frame centered at\n    // the provided origin to the ellipsoid's fixed reference frame.\n    localFrameToFixedFrame(firstAxis, secondAxis, thirdAxis, origin, result = new Matrix4()) {\n        return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);\n    }\n    geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {\n        return scratchVector.from(cartesian).normalize().to(result);\n    }\n    geodeticSurfaceNormalCartographic(cartographic, result = [0, 0, 0]) {\n        const cartographicVectorRadians = fromCartographicToRadians(cartographic);\n        const longitude = cartographicVectorRadians[0];\n        const latitude = cartographicVectorRadians[1];\n        const cosLatitude = Math.cos(latitude);\n        scratchVector\n            .set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude))\n            .normalize();\n        return scratchVector.to(result);\n    }\n    geodeticSurfaceNormal(cartesian, result = [0, 0, 0]) {\n        return scratchVector.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);\n    }\n    /** Scales the provided Cartesian position along the geodetic surface normal\n     * so that it is on the surface of this ellipsoid.  If the position is\n     * at the center of the ellipsoid, this function returns undefined. */\n    scaleToGeodeticSurface(cartesian, result) {\n        return scaleToGeodeticSurface(cartesian, this, result);\n    }\n    /** Scales the provided Cartesian position along the geocentric surface normal\n     * so that it is on the surface of this ellipsoid. */\n    scaleToGeocentricSurface(cartesian, result = [0, 0, 0]) {\n        scratchPosition.from(cartesian);\n        const positionX = scratchPosition.x;\n        const positionY = scratchPosition.y;\n        const positionZ = scratchPosition.z;\n        const oneOverRadiiSquared = this.oneOverRadiiSquared;\n        const beta = 1.0 /\n            Math.sqrt(positionX * positionX * oneOverRadiiSquared.x +\n                positionY * positionY * oneOverRadiiSquared.y +\n                positionZ * positionZ * oneOverRadiiSquared.z);\n        return scratchPosition.multiplyScalar(beta).to(result);\n    }\n    /** Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying\n     * its components by the result of `Ellipsoid#oneOverRadii` */\n    transformPositionToScaledSpace(position, result = [0, 0, 0]) {\n        return scratchPosition.from(position).scale(this.oneOverRadii).to(result);\n    }\n    /** Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying\n     * its components by the result of `Ellipsoid#radii`. */\n    transformPositionFromScaledSpace(position, result = [0, 0, 0]) {\n        return scratchPosition.from(position).scale(this.radii).to(result);\n    }\n    /** Computes a point which is the intersection of the surface normal with the z-axis. */\n    getSurfaceNormalIntersectionWithZAxis(position, buffer = 0, result = [0, 0, 0]) {\n        // Ellipsoid must be an ellipsoid of revolution (radii.x == radii.y)\n        assert(equals(this.radii.x, this.radii.y, _MathUtils.EPSILON15));\n        assert(this.radii.z > 0);\n        scratchPosition.from(position);\n        const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);\n        if (Math.abs(z) >= this.radii.z - buffer) {\n            return undefined;\n        }\n        return scratchPosition.set(0.0, 0.0, z).to(result);\n    }\n}\n/** An Ellipsoid instance initialized to the WGS84 standard. */\nEllipsoid.WGS84 = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);\n", "// 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\nexport const WGS84_RADIUS_X = 6378137.0;\nexport const WGS84_RADIUS_Y = 6378137.0;\nexport const WGS84_RADIUS_Z = 6356752.3142451793;\n// Pre-calculated ellipsoid defaults to avoid utils depending on `ellipsoid.js`\nexport const WGS84_CONSTANTS = {\n    radii: [WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z],\n    radiiSquared: [\n        WGS84_RADIUS_X * WGS84_RADIUS_X,\n        WGS84_RADIUS_Y * WGS84_RADIUS_Y,\n        WGS84_RADIUS_Z * WGS84_RADIUS_Z\n    ],\n    oneOverRadii: [1.0 / WGS84_RADIUS_X, 1.0 / WGS84_RADIUS_Y, 1.0 / WGS84_RADIUS_Z],\n    oneOverRadiiSquared: [\n        1.0 / (WGS84_RADIUS_X * WGS84_RADIUS_X),\n        1.0 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y),\n        1.0 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)\n    ],\n    maximumRadius: Math.max(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z),\n    centerToleranceSquared: 1e-1 // EPSILON1;\n};\n", "// 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\nimport { Vector3, toRadians, toDegrees, config } from '@math.gl/core';\nimport { WGS84_CONSTANTS } from \"./constants.js\";\nfunction identity(x) {\n    return x;\n}\nconst scratchVector = new Vector3();\nexport function fromCartographic(cartographic, result = [], map = identity) {\n    if ('longitude' in cartographic) {\n        result[0] = map(cartographic.longitude);\n        result[1] = map(cartographic.latitude);\n        result[2] = cartographic.height;\n    }\n    else if ('x' in cartographic) {\n        result[0] = map(cartographic.x);\n        result[1] = map(cartographic.y);\n        result[2] = cartographic.z;\n    }\n    else {\n        result[0] = map(cartographic[0]);\n        result[1] = map(cartographic[1]);\n        result[2] = cartographic[2];\n    }\n    return result;\n}\nexport function fromCartographicToRadians(cartographic, vector = []) {\n    return fromCartographic(cartographic, vector, config._cartographicRadians ? identity : toRadians);\n}\nexport function fromCartographicToDegrees(cartographic, vector = []) {\n    return fromCartographic(cartographic, vector, config._cartographicRadians ? toDegrees : identity);\n}\nexport function toCartographic(vector, cartographic, map = identity) {\n    if ('longitude' in cartographic) {\n        cartographic.longitude = map(vector[0]);\n        cartographic.latitude = map(vector[1]);\n        cartographic.height = vector[2];\n    }\n    else if ('x' in cartographic) {\n        cartographic.x = map(vector[0]);\n        cartographic.y = map(vector[1]);\n        cartographic.z = vector[2];\n    }\n    else {\n        cartographic[0] = map(vector[0]);\n        cartographic[1] = map(vector[1]);\n        cartographic[2] = vector[2];\n    }\n    return cartographic;\n}\nexport function toCartographicFromRadians(vector, cartographic) {\n    return toCartographic(vector, cartographic, config._cartographicRadians ? identity : toDegrees);\n}\nexport function toCartographicFromDegrees(vector, cartographic) {\n    return toCartographic(vector, cartographic, config._cartographicRadians ? toRadians : identity);\n}\n// Estimates if a vector is close to the surface of the WGS84 Ellipsoid\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/*\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", "import { Vector3, assert, equals as equalsEpsilon } from '@math.gl/core';\nconst EPSILON14 = 1e-14;\nconst scratchOrigin = new Vector3();\n// Caclulate third axis from given two axii\nconst VECTOR_PRODUCT_LOCAL_FRAME = {\n    up: {\n        south: 'east',\n        north: 'west',\n        west: 'south',\n        east: 'north'\n    },\n    down: {\n        south: 'west',\n        north: 'east',\n        west: 'north',\n        east: 'south'\n    },\n    south: {\n        up: 'west',\n        down: 'east',\n        west: 'down',\n        east: 'up'\n    },\n    north: {\n        up: 'east',\n        down: 'west',\n        west: 'up',\n        east: 'down'\n    },\n    west: {\n        up: 'north',\n        down: 'south',\n        north: 'down',\n        south: 'up'\n    },\n    east: {\n        up: 'south',\n        down: 'north',\n        north: 'up',\n        south: 'down'\n    }\n};\nconst degeneratePositionLocalFrame = {\n    north: [-1, 0, 0],\n    east: [0, 1, 0],\n    up: [0, 0, 1],\n    south: [1, 0, 0],\n    west: [0, -1, 0],\n    down: [0, 0, -1]\n};\nconst scratchAxisVectors = {\n    east: new Vector3(),\n    north: new Vector3(),\n    up: new Vector3(),\n    west: new Vector3(),\n    south: new Vector3(),\n    down: new Vector3()\n};\nconst scratchVector1 = new Vector3();\nconst scratchVector2 = new Vector3();\nconst scratchVector3 = new Vector3();\n// Computes a 4x4 transformation matrix from a reference frame\n// centered at the provided origin to the provided ellipsoid's fixed reference frame.\n// eslint-disable-next-line max-statements, max-params, complexity\nexport function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {\n    const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];\n    // firstAxis and secondAxis must be east, north, up, west, south or down.');\n    assert(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));\n    let firstAxisVector;\n    let secondAxisVector;\n    let thirdAxisVector;\n    const origin = scratchOrigin.copy(cartesianOrigin);\n    // If x and y are zero, assume origin is at a pole, which is a special case.\n    const atPole = equalsEpsilon(origin.x, 0.0, EPSILON14) && equalsEpsilon(origin.y, 0.0, EPSILON14);\n    if (atPole) {\n        // Look up axis value and adjust\n        const sign = Math.sign(origin.z);\n        firstAxisVector = scratchVector1.fromArray(degeneratePositionLocalFrame[firstAxis]);\n        if (firstAxis !== 'east' && firstAxis !== 'west') {\n            firstAxisVector.scale(sign);\n        }\n        secondAxisVector = scratchVector2.fromArray(degeneratePositionLocalFrame[secondAxis]);\n        if (secondAxis !== 'east' && secondAxis !== 'west') {\n            secondAxisVector.scale(sign);\n        }\n        thirdAxisVector = scratchVector3.fromArray(degeneratePositionLocalFrame[thirdAxis]);\n        if (thirdAxis !== 'east' && thirdAxis !== 'west') {\n            thirdAxisVector.scale(sign);\n        }\n    }\n    else {\n        // Calculate all axis\n        const { up, east, north } = scratchAxisVectors;\n        east.set(-origin.y, origin.x, 0.0).normalize();\n        ellipsoid.geodeticSurfaceNormal(origin, up);\n        north.copy(up).cross(east);\n        const { down, west, south } = scratchAxisVectors;\n        down.copy(up).scale(-1);\n        west.copy(east).scale(-1);\n        south.copy(north).scale(-1);\n        // Pick three axis based on desired orientation\n        firstAxisVector = scratchAxisVectors[firstAxis];\n        secondAxisVector = scratchAxisVectors[secondAxis];\n        thirdAxisVector = scratchAxisVectors[thirdAxis];\n    }\n    // TODO - assuming the result is column-major\n    result[0] = firstAxisVector.x;\n    result[1] = firstAxisVector.y;\n    result[2] = firstAxisVector.z;\n    result[3] = 0.0;\n    result[4] = secondAxisVector.x;\n    result[5] = secondAxisVector.y;\n    result[6] = secondAxisVector.z;\n    result[7] = 0.0;\n    result[8] = thirdAxisVector.x;\n    result[9] = thirdAxisVector.y;\n    result[10] = thirdAxisVector.z;\n    result[11] = 0.0;\n    result[12] = origin.x;\n    result[13] = origin.y;\n    result[14] = origin.z;\n    result[15] = 1.0;\n    return result;\n}\n", "/* eslint-disable */\nimport { Vector3, _MathUtils } from '@math.gl/core';\nconst scratchVector = new Vector3();\nconst scaleToGeodeticSurfaceIntersection = new Vector3();\nconst scaleToGeodeticSurfaceGradient = new Vector3();\n// Scales the provided Cartesian position along the geodetic surface normal\n// so that it is on the surface of this ellipsoid.  If the position is\n// at the center of the ellipsoid, this function returns undefined.\nexport function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {\n    const { oneOverRadii, oneOverRadiiSquared, centerToleranceSquared } = ellipsoid;\n    scratchVector.from(cartesian);\n    const positionX = scratchVector.x;\n    const positionY = scratchVector.y;\n    const positionZ = scratchVector.z;\n    const oneOverRadiiX = oneOverRadii.x;\n    const oneOverRadiiY = oneOverRadii.y;\n    const oneOverRadiiZ = oneOverRadii.z;\n    const x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;\n    const y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;\n    const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;\n    // Compute the squared ellipsoid norm.\n    const squaredNorm = x2 + y2 + z2;\n    const ratio = Math.sqrt(1.0 / squaredNorm);\n    // When very close to center or at center\n    if (!Number.isFinite(ratio)) {\n        return undefined;\n    }\n    // As an initial approximation, assume that the radial intersection is the projection point.\n    const intersection = scaleToGeodeticSurfaceIntersection;\n    intersection.copy(cartesian).scale(ratio);\n    // If the position is near the center, the iteration will not converge.\n    if (squaredNorm < centerToleranceSquared) {\n        return intersection.to(result);\n    }\n    const oneOverRadiiSquaredX = oneOverRadiiSquared.x;\n    const oneOverRadiiSquaredY = oneOverRadiiSquared.y;\n    const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;\n    // Use the gradient at the intersection point in place of the true unit normal.\n    // The difference in magnitude will be absorbed in the multiplier.\n    const gradient = scaleToGeodeticSurfaceGradient;\n    gradient.set(intersection.x * oneOverRadiiSquaredX * 2.0, intersection.y * oneOverRadiiSquaredY * 2.0, intersection.z * oneOverRadiiSquaredZ * 2.0);\n    // Compute the initial guess at the normal vector multiplier, lambda.\n    let lambda = ((1.0 - ratio) * scratchVector.len()) / (0.5 * gradient.len());\n    let correction = 0.0;\n    let xMultiplier;\n    let yMultiplier;\n    let zMultiplier;\n    let func;\n    do {\n        lambda -= correction;\n        xMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredX);\n        yMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredY);\n        zMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredZ);\n        const xMultiplier2 = xMultiplier * xMultiplier;\n        const yMultiplier2 = yMultiplier * yMultiplier;\n        const zMultiplier2 = zMultiplier * zMultiplier;\n        const xMultiplier3 = xMultiplier2 * xMultiplier;\n        const yMultiplier3 = yMultiplier2 * yMultiplier;\n        const zMultiplier3 = zMultiplier2 * zMultiplier;\n        func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1.0;\n        // \"denominator\" here refers to the use of this expression in the velocity and acceleration\n        // computations in the sections to follow.\n        const denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX +\n            y2 * yMultiplier3 * oneOverRadiiSquaredY +\n            z2 * zMultiplier3 * oneOverRadiiSquaredZ;\n        const derivative = -2.0 * denominator;\n        correction = func / derivative;\n    } while (Math.abs(func) > _MathUtils.EPSILON12);\n    return scratchVector.scale([xMultiplier, yMultiplier, zMultiplier]).to(result);\n}\n"],
+  "mappings": "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",
+  "names": ["import_core", "import_core", "equalsEpsilon", "import_core", "scratchVector", "scratchVector"]
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,3 +1,2 @@
 export { Ellipsoid } from "./ellipsoid/ellipsoid.js";
 export { isWGS84 } from "./type-utils.js";
-//# sourceMappingURL=index.js.map

package/dist/type-utils.d.ts

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

package/dist/type-utils.js

@@ -1,70 +1,96 @@
+// 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, toRadians, toDegrees, config } from '@math.gl/core';
 import { WGS84_CONSTANTS } from "./constants.js";
-
 function identity(x) {
-  return x;
+    return x;
 }
-
 const scratchVector = new Vector3();
 export function fromCartographic(cartographic, result = [], map = identity) {
-  if ('longitude' in cartographic) {
-    result[0] = map(cartographic.longitude);
-    result[1] = map(cartographic.latitude);
-    result[2] = cartographic.height;
-  } else if ('x' in cartographic) {
-    result[0] = map(cartographic.x);
-    result[1] = map(cartographic.y);
-    result[2] = cartographic.z;
-  } else {
-    result[0] = map(cartographic[0]);
-    result[1] = map(cartographic[1]);
-    result[2] = cartographic[2];
-  }
-
-  return result;
+    if ('longitude' in cartographic) {
+        result[0] = map(cartographic.longitude);
+        result[1] = map(cartographic.latitude);
+        result[2] = cartographic.height;
+    }
+    else if ('x' in cartographic) {
+        result[0] = map(cartographic.x);
+        result[1] = map(cartographic.y);
+        result[2] = cartographic.z;
+    }
+    else {
+        result[0] = map(cartographic[0]);
+        result[1] = map(cartographic[1]);
+        result[2] = cartographic[2];
+    }
+    return result;
 }
 export function fromCartographicToRadians(cartographic, vector = []) {
-  return fromCartographic(cartographic, vector, config._cartographicRadians ? identity : toRadians);
+    return fromCartographic(cartographic, vector, config._cartographicRadians ? identity : toRadians);
 }
 export function fromCartographicToDegrees(cartographic, vector = []) {
-  return fromCartographic(cartographic, vector, config._cartographicRadians ? toDegrees : identity);
+    return fromCartographic(cartographic, vector, config._cartographicRadians ? toDegrees : identity);
 }
 export function toCartographic(vector, cartographic, map = identity) {
-  if ('longitude' in cartographic) {
-    cartographic.longitude = map(vector[0]);
-    cartographic.latitude = map(vector[1]);
-    cartographic.height = vector[2];
-  } else if ('x' in cartographic) {
-    cartographic.x = map(vector[0]);
-    cartographic.y = map(vector[1]);
-    cartographic.z = vector[2];
-  } else {
-    cartographic[0] = map(vector[0]);
-    cartographic[1] = map(vector[1]);
-    cartographic[2] = vector[2];
-  }
-
-  return cartographic;
+    if ('longitude' in cartographic) {
+        cartographic.longitude = map(vector[0]);
+        cartographic.latitude = map(vector[1]);
+        cartographic.height = vector[2];
+    }
+    else if ('x' in cartographic) {
+        cartographic.x = map(vector[0]);
+        cartographic.y = map(vector[1]);
+        cartographic.z = vector[2];
+    }
+    else {
+        cartographic[0] = map(vector[0]);
+        cartographic[1] = map(vector[1]);
+        cartographic[2] = vector[2];
+    }
+    return cartographic;
 }
 export function toCartographicFromRadians(vector, cartographic) {
-  return toCartographic(vector, cartographic, config._cartographicRadians ? identity : toDegrees);
+    return toCartographic(vector, cartographic, config._cartographicRadians ? identity : toDegrees);
 }
 export function toCartographicFromDegrees(vector, cartographic) {
-  return toCartographic(vector, cartographic, config._cartographicRadians ? toRadians : identity);
+    return toCartographic(vector, cartographic, config._cartographicRadians ? toRadians : identity);
 }
+// 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;
+    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;
 }
-//# sourceMappingURL=type-utils.js.map
+/*
+
+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

@@ -6,7 +6,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "4.0.0-beta.1",
+  "version": "4.0.1",
   "keywords": [
     "webgl",
     "javascript",
@@ -29,9 +29,9 @@
   "module": "dist/index.js",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.cjs"
     }
   },
   "files": [
@@ -39,8 +39,7 @@
     "src"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.12.0",
-    "@math.gl/core": "4.0.0-beta.1"
+    "@math.gl/core": "4.0.1"
   },
-  "gitHead": "5a2364216b6aadbece690e05b9b5b71753aee472"
+  "gitHead": "33f369ba3a259f79acc3fa8181190c9da8841648"
 }

package/dist/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,UAAY,CAAC;AACxC,eAAO,MAAM,cAAc,UAAY,CAAC;AACxC,eAAO,MAAM,cAAc,oBAAqB,CAAC;AAIjD,eAAO,MAAM,eAAe;;;;;;;CAe3B,CAAC"}

package/dist/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/constants.ts"],"names":["WGS84_RADIUS_X","WGS84_RADIUS_Y","WGS84_RADIUS_Z","WGS84_CONSTANTS","radii","radiiSquared","oneOverRadii","oneOverRadiiSquared","maximumRadius","Math","max","centerToleranceSquared"],"mappings":"AAGA,OAAO,MAAMA,cAAc,GAAG,SAAvB;AACP,OAAO,MAAMC,cAAc,GAAG,SAAvB;AACP,OAAO,MAAMC,cAAc,GAAG,kBAAvB;AAIP,OAAO,MAAMC,eAAe,GAAG;AAC7BC,EAAAA,KAAK,EAAE,CAACJ,cAAD,EAAiBC,cAAjB,EAAiCC,cAAjC,CADsB;AAE7BG,EAAAA,YAAY,EAAE,CACZL,cAAc,GAAGA,cADL,EAEZC,cAAc,GAAGA,cAFL,EAGZC,cAAc,GAAGA,cAHL,CAFe;AAO7BI,EAAAA,YAAY,EAAE,CAAC,MAAMN,cAAP,EAAuB,MAAMC,cAA7B,EAA6C,MAAMC,cAAnD,CAPe;AAQ7BK,EAAAA,mBAAmB,EAAE,CACnB,OAAOP,cAAc,GAAGA,cAAxB,CADmB,EAEnB,OAAOC,cAAc,GAAGA,cAAxB,CAFmB,EAGnB,OAAOC,cAAc,GAAGA,cAAxB,CAHmB,CARQ;AAa7BM,EAAAA,aAAa,EAAEC,IAAI,CAACC,GAAL,CAASV,cAAT,EAAyBC,cAAzB,EAAyCC,cAAzC,CAbc;AAc7BS,EAAAA,sBAAsB,EAAE;AAdK,CAAxB","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\nexport const WGS84_RADIUS_X = 6378137.0;\nexport const WGS84_RADIUS_Y = 6378137.0;\nexport const WGS84_RADIUS_Z = 6356752.3142451793;\n\n// Pre-calculated ellipsoid defaults to avoid utils depending on `ellipsoid.js`\n\nexport const WGS84_CONSTANTS = {\n  radii: [WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z],\n  radiiSquared: [\n    WGS84_RADIUS_X * WGS84_RADIUS_X,\n    WGS84_RADIUS_Y * WGS84_RADIUS_Y,\n    WGS84_RADIUS_Z * WGS84_RADIUS_Z\n  ],\n  oneOverRadii: [1.0 / WGS84_RADIUS_X, 1.0 / WGS84_RADIUS_Y, 1.0 / WGS84_RADIUS_Z],\n  oneOverRadiiSquared: [\n    1.0 / (WGS84_RADIUS_X * WGS84_RADIUS_X),\n    1.0 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y),\n    1.0 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)\n  ],\n  maximumRadius: Math.max(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z),\n  centerToleranceSquared: 1e-1 // EPSILON1;\n};\n"],"file":"constants.js"}

package/dist/ellipsoid/ellipsoid.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ellipsoid.d.ts","sourceRoot":"","sources":["../../src/ellipsoid/ellipsoid.ts"],"names":[],"mappings":"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"}

package/dist/ellipsoid/ellipsoid.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/ellipsoid/ellipsoid.ts"],"names":["Vector3","Matrix4","assert","equals","_MathUtils","vec3","WGS84_RADIUS_X","WGS84_RADIUS_Y","WGS84_RADIUS_Z","fromCartographicToRadians","toCartographicFromRadians","localFrameToFixedFrame","scaleToGeodeticSurface","scratchVector","scratchNormal","scratchK","scratchPosition","scratchHeight","scratchCartesian","Ellipsoid","constructor","x","y","z","EPSILON1","radii","radiiSquared","radiiToTheFourth","oneOverRadii","oneOverRadiiSquared","minimumRadius","Math","min","maximumRadius","max","squaredXOverSquaredZ","Object","freeze","right","Boolean","toString","cartographicToCartesian","cartographic","result","normal","k","height","geodeticSurfaceNormalCartographic","copy","scale","gamma","sqrt","dot","add","to","cartesianToCartographic","cartesian","from","point","undefined","geodeticSurfaceNormal","h","subtract","longitude","atan2","latitude","asin","sign","length","eastNorthUpToFixedFrame","origin","firstAxis","secondAxis","thirdAxis","geocentricSurfaceNormal","normalize","cartographicVectorRadians","cosLatitude","cos","set","sin","scaleToGeocentricSurface","positionX","positionY","positionZ","beta","multiplyScalar","transformPositionToScaledSpace","position","transformPositionFromScaledSpace","getSurfaceNormalIntersectionWithZAxis","buffer","EPSILON15","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\n/* eslint-disable */\nimport {Vector3, Matrix4, assert, equals, _MathUtils, NumericArray, vec3} from '@math.gl/core';\n\nimport {WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z} from '../constants';\nimport {fromCartographicToRadians, toCartographicFromRadians} from '../type-utils';\n\nimport type {AxisDirection} from './helpers/ellipsoid-transform';\nimport {localFrameToFixedFrame} from './helpers/ellipsoid-transform';\nimport {scaleToGeodeticSurface} from './helpers/scale-to-geodetic-surface';\n\nconst scratchVector = new Vector3();\nconst scratchNormal = new Vector3();\nconst scratchK = new Vector3();\nconst scratchPosition = new Vector3();\nconst scratchHeight = new Vector3();\nconst scratchCartesian = new Vector3();\n\n/**\n * A quadratic surface defined in Cartesian coordinates by the equation\n * `(x / a)^2 + (y / b)^2 + (z / c)^2 = 1`.  Primarily used\n * to represent the shape of planetary bodies.\n */\nexport class Ellipsoid {\n  /** An Ellipsoid instance initialized to the WGS84 standard. */\n  static readonly WGS84: Ellipsoid = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);\n\n  readonly radii: Vector3;\n  readonly radiiSquared: Vector3;\n  readonly radiiToTheFourth: Vector3;\n  readonly oneOverRadii: Vector3;\n  readonly oneOverRadiiSquared: Vector3;\n  readonly minimumRadius: number;\n  readonly maximumRadius: number;\n  readonly centerToleranceSquared: number = _MathUtils.EPSILON1;\n  readonly squaredXOverSquaredZ: number;\n\n  /** Creates an Ellipsoid from a Cartesian specifying the radii in x, y, and z directions. */\n  constructor(x: number, y: number, z: number);\n  constructor();\n\n  constructor(x = 0.0, y = 0.0, z = 0.0) {\n    assert(x >= 0.0);\n    assert(y >= 0.0);\n    assert(z >= 0.0);\n\n    this.radii = new Vector3(x, y, z);\n\n    this.radiiSquared = new Vector3(x * x, y * y, z * z);\n\n    this.radiiToTheFourth = new Vector3(x * x * x * x, y * y * y * y, z * z * z * z);\n\n    this.oneOverRadii = new Vector3(\n      x === 0.0 ? 0.0 : 1.0 / x,\n      y === 0.0 ? 0.0 : 1.0 / y,\n      z === 0.0 ? 0.0 : 1.0 / z\n    );\n\n    this.oneOverRadiiSquared = new Vector3(\n      x === 0.0 ? 0.0 : 1.0 / (x * x),\n      y === 0.0 ? 0.0 : 1.0 / (y * y),\n      z === 0.0 ? 0.0 : 1.0 / (z * z)\n    );\n\n    this.minimumRadius = Math.min(x, y, z);\n\n    this.maximumRadius = Math.max(x, y, z);\n\n    if (this.radiiSquared.z !== 0) {\n      this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;\n    }\n\n    Object.freeze(this);\n  }\n\n  /** Compares this Ellipsoid against the provided Ellipsoid componentwise */\n  equals(right: Ellipsoid): boolean {\n    return this === right || Boolean(right && this.radii.equals(right.radii));\n  }\n\n  /** Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'. */\n  toString(): string {\n    return this.radii.toString();\n  }\n\n  /** Converts the provided cartographic to Cartesian representation. */\n  cartographicToCartesian(cartographic: number[], result: Vector3): Vector3;\n  cartographicToCartesian(cartographic: number[], result?: number[]): number[];\n\n  cartographicToCartesian(cartographic: Readonly<NumericArray>, result = [0, 0, 0]) {\n    const normal = scratchNormal;\n    const k = scratchK;\n\n    const [, , height] = cartographic;\n    this.geodeticSurfaceNormalCartographic(cartographic, normal);\n    k.copy(this.radiiSquared).scale(normal);\n\n    const gamma = Math.sqrt(normal.dot(k));\n    k.scale(1 / gamma);\n\n    normal.scale(height);\n\n    k.add(normal);\n\n    return k.to(result);\n  }\n\n  /** Converts the provided cartesian to cartographic (lng/lat/z) representation.\n   * The cartesian is undefined at the center of the ellipsoid. */\n  cartesianToCartographic(cartesian: Readonly<NumericArray>, result: Vector3): Vector3;\n  cartesianToCartographic(cartesian: Readonly<NumericArray>, result?: number[]): number[];\n\n  cartesianToCartographic(cartesian: Readonly<NumericArray>, result = [0, 0, 0]) {\n    scratchCartesian.from(cartesian);\n    const point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);\n\n    if (!point) {\n      return undefined;\n    }\n\n    const normal = this.geodeticSurfaceNormal(point, scratchNormal);\n\n    const h = scratchHeight;\n    h.copy(scratchCartesian).subtract(point);\n\n    const longitude = Math.atan2(normal.y, normal.x);\n    const latitude = Math.asin(normal.z);\n    const height = Math.sign(vec3.dot(h, scratchCartesian)) * vec3.length(h);\n\n    return toCartographicFromRadians([longitude, latitude, height], result);\n  }\n\n  /** Computes a 4x4 transformation matrix from a reference frame with an east-north-up axes\n   * centered at the provided origin to the provided ellipsoid's fixed reference frame. */\n  eastNorthUpToFixedFrame(origin: Readonly<NumericArray>, result?: Matrix4): Matrix4;\n  eastNorthUpToFixedFrame(origin: Readonly<NumericArray>, result: number[]): number[];\n\n  eastNorthUpToFixedFrame(origin: Readonly<NumericArray>, result = new Matrix4()) {\n    return localFrameToFixedFrame(this, 'east', 'north', 'up', origin, result);\n  }\n\n  /** Computes a 4x4 transformation matrix from a reference frame centered at\n   * the provided origin to the ellipsoid's fixed reference frame.\n   */\n  localFrameToFixedFrame(\n    firstAxis: AxisDirection,\n    secondAxis: AxisDirection,\n    thirdAxis: AxisDirection,\n    origin: Readonly<NumericArray>,\n    result?: Matrix4\n  ): Matrix4;\n  localFrameToFixedFrame<Matrix4T>(\n    firstAxis: AxisDirection,\n    secondAxis: AxisDirection,\n    thirdAxis: AxisDirection,\n    origin: Readonly<NumericArray>,\n    result: number[]\n  ): number[];\n\n  // Computes a 4x4 transformation matrix from a reference frame centered at\n  // the provided origin to the ellipsoid's fixed reference frame.\n  localFrameToFixedFrame(\n    firstAxis: AxisDirection,\n    secondAxis: AxisDirection,\n    thirdAxis: AxisDirection,\n    origin: Readonly<NumericArray>,\n    result = new Matrix4()\n  ) {\n    return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);\n  }\n\n  /** Computes the unit vector directed from the center of this ellipsoid toward\n   * the provided Cartesian position. */\n  geocentricSurfaceNormal(cartesian: number[], result?: number[]): number[];\n  geocentricSurfaceNormal<NumArray>(cartesian: number[], result: NumArray): NumArray;\n  geocentricSurfaceNormal(cartesian: Readonly<NumericArray>, result = [0, 0, 0]) {\n    return scratchVector.from(cartesian).normalize().to(result);\n  }\n\n  /** Computes the normal of the plane tangent to the surface of the ellipsoid at provided position. */\n  geodeticSurfaceNormalCartographic<NumArray>(\n    cartographic: Readonly<NumericArray>,\n    result: NumArray\n  ): NumArray;\n  geodeticSurfaceNormalCartographic(cartographic: number[]): number[];\n  geodeticSurfaceNormalCartographic(cartographic: Readonly<NumericArray>, result = [0, 0, 0]) {\n    const cartographicVectorRadians = fromCartographicToRadians(cartographic);\n\n    const longitude = cartographicVectorRadians[0];\n    const latitude = cartographicVectorRadians[1];\n\n    const cosLatitude = Math.cos(latitude);\n\n    scratchVector\n      .set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude))\n      .normalize();\n\n    return scratchVector.to(result);\n  }\n\n  /** Computes the normal of the plane tangent to the surface of the ellipsoid at the provided position. */\n  geodeticSurfaceNormal<NumArrayT>(cartesian: number[], result: NumArrayT): NumArrayT;\n  geodeticSurfaceNormal(cartesian: number[]): number[];\n  geodeticSurfaceNormal(cartesian: Readonly<NumericArray>, result = [0, 0, 0]) {\n    return scratchVector.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);\n  }\n\n  /** Scales the provided Cartesian position along the geodetic surface normal\n   * so that it is on the surface of this ellipsoid.  If the position is\n   * at the center of the ellipsoid, this function returns undefined. */\n  scaleToGeodeticSurface(cartesian: number[], result?: number[]): number[] {\n    return scaleToGeodeticSurface(cartesian, this, result);\n  }\n\n  /** Scales the provided Cartesian position along the geocentric surface normal\n   * so that it is on the surface of this ellipsoid. */\n  scaleToGeocentricSurface(cartesian: number[], result: number[] = [0, 0, 0]): number[] {\n    scratchPosition.from(cartesian);\n\n    const positionX = scratchPosition.x;\n    const positionY = scratchPosition.y;\n    const positionZ = scratchPosition.z;\n    const oneOverRadiiSquared = this.oneOverRadiiSquared;\n\n    const beta =\n      1.0 /\n      Math.sqrt(\n        positionX * positionX * oneOverRadiiSquared.x +\n          positionY * positionY * oneOverRadiiSquared.y +\n          positionZ * positionZ * oneOverRadiiSquared.z\n      );\n\n    return scratchPosition.multiplyScalar(beta).to(result);\n  }\n\n  /** Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying\n   * its components by the result of `Ellipsoid#oneOverRadii` */\n  transformPositionToScaledSpace(position: number[], result: number[] = [0, 0, 0]): number[] {\n    return scratchPosition.from(position).scale(this.oneOverRadii).to(result);\n  }\n\n  /** Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying\n   * its components by the result of `Ellipsoid#radii`. */\n  transformPositionFromScaledSpace(position: number[], result: number[] = [0, 0, 0]): number[] {\n    return scratchPosition.from(position).scale(this.radii).to(result);\n  }\n\n  /** Computes a point which is the intersection of the surface normal with the z-axis. */\n  getSurfaceNormalIntersectionWithZAxis(\n    position: number[],\n    buffer: number = 0,\n    result: number[] = [0, 0, 0]\n  ): number[] {\n    // Ellipsoid must be an ellipsoid of revolution (radii.x == radii.y)\n    assert(equals(this.radii.x, this.radii.y, _MathUtils.EPSILON15));\n    assert(this.radii.z > 0);\n\n    scratchPosition.from(position);\n    const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);\n\n    if (Math.abs(z) >= this.radii.z - buffer) {\n      return undefined;\n    }\n\n    return scratchPosition.set(0.0, 0.0, z).to(result);\n  }\n}\n"],"file":"ellipsoid.js"}

package/dist/ellipsoid/helpers/ellipsoid-transform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ellipsoid-transform.d.ts","sourceRoot":"","sources":["../../../src/ellipsoid/helpers/ellipsoid-transform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAA2C,MAAM,eAAe,CAAC;AAErF,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAM5C,oBAAY,aAAa,GAAG,IAAI,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAsEhF,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,SAAS,EAAE,aAAa,EACxB,eAAe,EAAE,QAAQ,CAAC,YAAY,CAAC,EACvC,MAAM,EAAE,MAAM,EAAE,GACf,MAAM,EAAE,CAuEV"}