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

package/dist/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const WGS84_RADIUS_X = 6378137;
+export declare const WGS84_RADIUS_Y = 6378137;
+export declare const WGS84_RADIUS_Z = 6356752.314245179;
+export declare const WGS84_CONSTANTS: {
+    radii: number[];
+    radiiSquared: number[];
+    oneOverRadii: number[];
+    oneOverRadiiSquared: number[];
+    maximumRadius: number;
+    centerToleranceSquared: number;
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,22 @@
+// 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
+export const WGS84_RADIUS_X = 6378137.0;
+export const WGS84_RADIUS_Y = 6378137.0;
+export const WGS84_RADIUS_Z = 6356752.3142451793;
+// Pre-calculated ellipsoid defaults to avoid utils depending on `ellipsoid.js`
+export const WGS84_CONSTANTS = {
+    radii: [WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z],
+    radiiSquared: [
+        WGS84_RADIUS_X * WGS84_RADIUS_X,
+        WGS84_RADIUS_Y * WGS84_RADIUS_Y,
+        WGS84_RADIUS_Z * WGS84_RADIUS_Z
+    ],
+    oneOverRadii: [1.0 / WGS84_RADIUS_X, 1.0 / WGS84_RADIUS_Y, 1.0 / WGS84_RADIUS_Z],
+    oneOverRadiiSquared: [
+        1.0 / (WGS84_RADIUS_X * WGS84_RADIUS_X),
+        1.0 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y),
+        1.0 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)
+    ],
+    maximumRadius: Math.max(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z),
+    centerToleranceSquared: 1e-1 // EPSILON1;
+};

package/dist/ellipsoid/ellipsoid.d.ts

@@ -0,0 +1,68 @@
+import { Vector3, Matrix4, NumericArray } from '@math.gl/core';
+/**
+ * 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 readonly WGS84: Ellipsoid;
+    readonly radii: Vector3;
+    readonly radiiSquared: Vector3;
+    readonly radiiToTheFourth: Vector3;
+    readonly oneOverRadii: Vector3;
+    readonly oneOverRadiiSquared: Vector3;
+    readonly minimumRadius: number;
+    readonly maximumRadius: number;
+    readonly centerToleranceSquared: number;
+    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();
+    /** Compares this Ellipsoid against the provided Ellipsoid componentwise */
+    equals(right: Ellipsoid): boolean;
+    /** Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'. */
+    toString(): string;
+    /** Converts the provided cartographic to Cartesian representation. */
+    cartographicToCartesian(cartographic: number[], result: Vector3): Vector3;
+    cartographicToCartesian(cartographic: number[], result?: number[]): number[];
+    /** 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[];
+    /** 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[];
+    /** 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 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;
+    /** 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[];
+    /** 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[];
+    /** 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[];
+    /** 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[];
+    /** 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[];
+    /** 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[];
+    /** Computes a point which is the intersection of the surface normal with the z-axis. */
+    getSurfaceNormalIntersectionWithZAxis(position: number[], buffer?: number, result?: number[]): number[];
+}
+//# sourceMappingURL=ellipsoid.d.ts.map

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

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

package/dist/ellipsoid/ellipsoid.js

@@ -0,0 +1,142 @@
+// 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 } from '@math.gl/core';
+import * as vec3 from 'gl-matrix/vec3';
+import { WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z } from '../constants';
+import { fromCartographicToRadians, toCartographicFromRadians } from '../type-utils';
+import scaleToGeodeticSurface from './helpers/scale-to-geodetic-surface';
+import localFrameToFixedFrame from './helpers/ellipsoid-transform';
+const scratchVector = new Vector3();
+const scratchNormal = new Vector3();
+const scratchK = new Vector3();
+const scratchPosition = new Vector3();
+const scratchHeight = new Vector3();
+const scratchCartesian = new Vector3();
+let wgs84;
+/**
+ * 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 {
+    constructor(x = 0.0, y = 0.0, z = 0.0) {
+        this.centerToleranceSquared = _MathUtils.EPSILON1;
+        assert(x >= 0.0);
+        assert(y >= 0.0);
+        assert(z >= 0.0);
+        this.radii = new Vector3(x, y, z);
+        this.radiiSquared = new Vector3(x * x, y * y, z * z);
+        this.radiiToTheFourth = new Vector3(x * x * x * x, y * y * y * y, z * z * z * z);
+        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);
+        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));
+        this.minimumRadius = Math.min(x, y, z);
+        this.maximumRadius = Math.max(x, y, z);
+        if (this.radiiSquared.z !== 0) {
+            this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;
+        }
+        Object.freeze(this);
+    }
+    /** Compares this Ellipsoid against the provided Ellipsoid componentwise */
+    equals(right) {
+        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() {
+        return this.radii.toString();
+    }
+    cartographicToCartesian(cartographic, result = [0, 0, 0]) {
+        const normal = scratchNormal;
+        const k = scratchK;
+        const [, , height] = cartographic;
+        this.geodeticSurfaceNormalCartographic(cartographic, normal);
+        k.copy(this.radiiSquared).scale(normal);
+        const gamma = Math.sqrt(normal.dot(k));
+        k.scale(1 / gamma);
+        normal.scale(height);
+        k.add(normal);
+        return k.to(result);
+    }
+    cartesianToCartographic(cartesian, result = [0, 0, 0]) {
+        scratchCartesian.from(cartesian);
+        const point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);
+        if (!point) {
+            return undefined;
+        }
+        const normal = this.geodeticSurfaceNormal(point, scratchNormal);
+        const h = scratchHeight;
+        h.copy(scratchCartesian).subtract(point);
+        const longitude = Math.atan2(normal.y, normal.x);
+        const latitude = Math.asin(normal.z);
+        const height = Math.sign(vec3.dot(h, scratchCartesian)) * vec3.length(h);
+        return toCartographicFromRadians([longitude, latitude, height], result);
+    }
+    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, secondAxis, thirdAxis, origin, result = new Matrix4()) {
+        return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);
+    }
+    geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {
+        return scratchVector.from(cartesian).normalize().to(result);
+    }
+    geodeticSurfaceNormalCartographic(cartographic, result = [0, 0, 0]) {
+        const cartographicVectorRadians = fromCartographicToRadians(cartographic);
+        const longitude = cartographicVectorRadians[0];
+        const latitude = cartographicVectorRadians[1];
+        const cosLatitude = Math.cos(latitude);
+        scratchVector
+            .set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude))
+            .normalize();
+        return scratchVector.to(result);
+    }
+    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. */
+    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. */
+    scaleToGeocentricSurface(cartesian, result = [0, 0, 0]) {
+        scratchPosition.from(cartesian);
+        const positionX = scratchPosition.x;
+        const positionY = scratchPosition.y;
+        const positionZ = scratchPosition.z;
+        const oneOverRadiiSquared = this.oneOverRadiiSquared;
+        const beta = 1.0 /
+            Math.sqrt(positionX * positionX * oneOverRadiiSquared.x +
+                positionY * positionY * oneOverRadiiSquared.y +
+                positionZ * positionZ * oneOverRadiiSquared.z);
+        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` */
+    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`. */
+    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. */
+    getSurfaceNormalIntersectionWithZAxis(position, buffer = 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));
+        assert(this.radii.z > 0);
+        scratchPosition.from(position);
+        const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);
+        if (Math.abs(z) >= this.radii.z - buffer) {
+            return undefined;
+        }
+        return scratchPosition.set(0.0, 0.0, z).to(result);
+    }
+}
+/** An Ellipsoid instance initialized to the WGS84 standard. */
+Ellipsoid.WGS84 = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);

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

@@ -0,0 +1,5 @@
+import type Ellipsoid from '../ellipsoid';
+declare type Axis = 'up' | 'down' | 'north' | 'east' | 'south' | 'west';
+export default function localFrameToFixedFrame(ellipsoid: Ellipsoid, firstAxis: Axis, secondAxis: Axis, thirdAxis: Axis, cartesianOrigin: number[], result: number[]): number[];
+export {};
+//# sourceMappingURL=ellipsoid-transform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ellipsoid-transform.d.ts","sourceRoot":"","sources":["../../../src/ellipsoid/helpers/ellipsoid-transform.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC;AAoE1C,aAAK,IAAI,GAAG,IAAI,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAKhE,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAC5C,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,IAAI,EACf,UAAU,EAAE,IAAI,EAChB,SAAS,EAAE,IAAI,EACf,eAAe,EAAE,MAAM,EAAE,EACzB,MAAM,EAAE,MAAM,EAAE,GACf,MAAM,EAAE,CAwEV"}

package/dist/ellipsoid/helpers/ellipsoid-transform.js

@@ -0,0 +1,125 @@
+import { Vector3, assert, equals as equalsEpsilon } from '@math.gl/core';
+const EPSILON14 = 1e-14;
+const scratchOrigin = new Vector3();
+// Caclulate third axis from given two axii
+const VECTOR_PRODUCT_LOCAL_FRAME = {
+    up: {
+        south: 'east',
+        north: 'west',
+        west: 'south',
+        east: 'north'
+    },
+    down: {
+        south: 'west',
+        north: 'east',
+        west: 'north',
+        east: 'south'
+    },
+    south: {
+        up: 'west',
+        down: 'east',
+        west: 'down',
+        east: 'up'
+    },
+    north: {
+        up: 'east',
+        down: 'west',
+        west: 'up',
+        east: 'down'
+    },
+    west: {
+        up: 'north',
+        down: 'south',
+        north: 'down',
+        south: 'up'
+    },
+    east: {
+        up: 'south',
+        down: 'north',
+        north: 'up',
+        south: 'down'
+    }
+};
+const degeneratePositionLocalFrame = {
+    north: [-1, 0, 0],
+    east: [0, 1, 0],
+    up: [0, 0, 1],
+    south: [1, 0, 0],
+    west: [0, -1, 0],
+    down: [0, 0, -1]
+};
+const scratchAxisVectors = {
+    east: new Vector3(),
+    north: new Vector3(),
+    up: new Vector3(),
+    west: new Vector3(),
+    south: new Vector3(),
+    down: new Vector3()
+};
+const scratchVector1 = new Vector3();
+const scratchVector2 = new Vector3();
+const scratchVector3 = new Vector3();
+// Computes a 4x4 transformation matrix from a reference frame
+// centered at the provided origin to the provided ellipsoid's fixed reference frame.
+// eslint-disable-next-line max-statements, max-params, complexity
+export default function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {
+    const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] &&
+        VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];
+    // firstAxis and secondAxis must be east, north, up, west, south or down.');
+    assert(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
+    let firstAxisVector;
+    let secondAxisVector;
+    let thirdAxisVector;
+    const origin = scratchOrigin.copy(cartesianOrigin);
+    // If x and y are zero, assume origin is at a pole, which is a special case.
+    const atPole = equalsEpsilon(origin.x, 0.0, EPSILON14) && equalsEpsilon(origin.y, 0.0, EPSILON14);
+    if (atPole) {
+        // Look up axis value and adjust
+        const sign = Math.sign(origin.z);
+        firstAxisVector = scratchVector1.fromArray(degeneratePositionLocalFrame[firstAxis]);
+        if (firstAxis !== 'east' && firstAxis !== 'west') {
+            firstAxisVector.scale(sign);
+        }
+        secondAxisVector = scratchVector2.fromArray(degeneratePositionLocalFrame[secondAxis]);
+        if (secondAxis !== 'east' && secondAxis !== 'west') {
+            secondAxisVector.scale(sign);
+        }
+        thirdAxisVector = scratchVector3.fromArray(degeneratePositionLocalFrame[thirdAxis]);
+        if (thirdAxis !== 'east' && thirdAxis !== 'west') {
+            thirdAxisVector.scale(sign);
+        }
+    }
+    else {
+        // Calculate all axis
+        const { up, east, north } = scratchAxisVectors;
+        east.set(-origin.y, origin.x, 0.0).normalize();
+        ellipsoid.geodeticSurfaceNormal(origin, up);
+        north.copy(up).cross(east);
+        const { down, west, south } = scratchAxisVectors;
+        down.copy(up).scale(-1);
+        west.copy(east).scale(-1);
+        south.copy(north).scale(-1);
+        // Pick three axis based on desired orientation
+        firstAxisVector = scratchAxisVectors[firstAxis];
+        secondAxisVector = scratchAxisVectors[secondAxis];
+        thirdAxisVector = scratchAxisVectors[thirdAxis];
+    }
+    // TODO - assuming the result is column-major
+    result[0] = firstAxisVector.x;
+    result[1] = firstAxisVector.y;
+    result[2] = firstAxisVector.z;
+    result[3] = 0.0;
+    result[4] = secondAxisVector.x;
+    result[5] = secondAxisVector.y;
+    result[6] = secondAxisVector.z;
+    result[7] = 0.0;
+    result[8] = thirdAxisVector.x;
+    result[9] = thirdAxisVector.y;
+    result[10] = thirdAxisVector.z;
+    result[11] = 0.0;
+    result[12] = origin.x;
+    result[13] = origin.y;
+    result[14] = origin.z;
+    result[15] = 1.0;
+    return result;
+}

package/dist/ellipsoid/helpers/scale-to-geodetic-surface.d.ts

@@ -0,0 +1,3 @@
+import type Ellipsoid from '../ellipsoid';
+export default function scaleToGeodeticSurface(cartesian: number[], ellipsoid: Ellipsoid, result?: number[]): number[];
+//# sourceMappingURL=scale-to-geodetic-surface.d.ts.map

package/dist/ellipsoid/helpers/scale-to-geodetic-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scale-to-geodetic-surface.d.ts","sourceRoot":"","sources":["../../../src/ellipsoid/helpers/scale-to-geodetic-surface.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC;AAS1C,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAC5C,SAAS,EAAE,MAAM,EAAE,EACnB,SAAS,EAAE,SAAS,EACpB,MAAM,GAAE,MAAM,EAAO,GACpB,MAAM,EAAE,CAuFV"}

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

@@ -0,0 +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 default 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;
+    // 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);
+}

package/dist/es5/constants.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/constants.js"],"names":["WGS84_RADIUS_X","WGS84_RADIUS_Y","WGS84_RADIUS_Z","WGS84_CONSTANTS","radii","radiiSquared","oneOverRadii","oneOverRadiiSquared","maximumRadius","Math","max","centerToleranceSquared"],"mappings":";;;;;;AAGO,IAAMA,cAAc,GAAG,SAAvB;;AACA,IAAMC,cAAc,GAAG,SAAvB;;AACA,IAAMC,cAAc,GAAG,kBAAvB;;AAIA,IAAMC,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"}
+{"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":";;;;;;AAGO,IAAMA,cAAc,GAAG,SAAvB;;AACA,IAAMC,cAAc,GAAG,SAAvB;;AACA,IAAMC,cAAc,GAAG,kBAAvB;;AAIA,IAAMC,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/es5/ellipsoid/ellipsoid.js

@@ -15,6 +15,8 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _core = require("@math.gl/core");
 
 var vec3 = _interopRequireWildcard(require("gl-matrix/vec3"));
@@ -45,6 +47,15 @@ var Ellipsoid = function () {
     var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.0;
     var z = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0.0;
     (0, _classCallCheck2.default)(this, Ellipsoid);
+    (0, _defineProperty2.default)(this, "radii", void 0);
+    (0, _defineProperty2.default)(this, "radiiSquared", void 0);
+    (0, _defineProperty2.default)(this, "radiiToTheFourth", void 0);
+    (0, _defineProperty2.default)(this, "oneOverRadii", void 0);
+    (0, _defineProperty2.default)(this, "oneOverRadiiSquared", void 0);
+    (0, _defineProperty2.default)(this, "minimumRadius", void 0);
+    (0, _defineProperty2.default)(this, "maximumRadius", void 0);
+    (0, _defineProperty2.default)(this, "centerToleranceSquared", _core._MathUtils.EPSILON1);
+    (0, _defineProperty2.default)(this, "squaredXOverSquaredZ", void 0);
     (0, _core.assert)(x >= 0.0);
     (0, _core.assert)(y >= 0.0);
     (0, _core.assert)(z >= 0.0);
@@ -55,7 +66,6 @@ var Ellipsoid = function () {
     this.oneOverRadiiSquared = new _core.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));
     this.minimumRadius = Math.min(x, y, z);
     this.maximumRadius = Math.max(x, y, z);
-    this.centerToleranceSquared = _core._MathUtils.EPSILON1;
 
     if (this.radiiSquared.z !== 0) {
       this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;
@@ -178,7 +188,7 @@ var Ellipsoid = function () {
   }, {
     key: "getSurfaceNormalIntersectionWithZAxis",
     value: function getSurfaceNormalIntersectionWithZAxis(position) {
-      var buffer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.0;
+      var buffer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
       var result = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [0, 0, 0];
       (0, _core.assert)((0, _core.equals)(this.radii.x, this.radii.y, _core._MathUtils.EPSILON15));
       (0, _core.assert)(this.radii.z > 0);
@@ -191,15 +201,10 @@ var Ellipsoid = function () {
 
       return scratchPosition.set(0.0, 0.0, z).to(result);
     }
-  }], [{
-    key: "WGS84",
-    get: function get() {
-      wgs84 = wgs84 || new Ellipsoid(_constants.WGS84_RADIUS_X, _constants.WGS84_RADIUS_Y, _constants.WGS84_RADIUS_Z);
-      return wgs84;
-    }
   }]);
   return Ellipsoid;
 }();
 
 exports.default = Ellipsoid;
+(0, _defineProperty2.default)(Ellipsoid, "WGS84", new Ellipsoid(_constants.WGS84_RADIUS_X, _constants.WGS84_RADIUS_Y, _constants.WGS84_RADIUS_Z));
 //# sourceMappingURL=ellipsoid.js.map

package/dist/es5/ellipsoid/ellipsoid.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/ellipsoid/ellipsoid.js"],"names":["scratchVector","Vector3","scratchNormal","scratchK","scratchPosition","scratchHeight","scratchCartesian","wgs84","Ellipsoid","x","y","z","radii","radiiSquared","radiiToTheFourth","oneOverRadii","oneOverRadiiSquared","minimumRadius","Math","min","maximumRadius","max","centerToleranceSquared","_MathUtils","EPSILON1","squaredXOverSquaredZ","Object","freeze","right","Boolean","equals","toString","cartographic","result","normal","k","height","geodeticSurfaceNormalCartographic","copy","scale","gamma","sqrt","dot","add","to","cartesian","from","point","scaleToGeodeticSurface","undefined","geodeticSurfaceNormal","h","subtract","longitude","atan2","latitude","asin","sign","vec3","length","origin","Matrix4","firstAxis","secondAxis","thirdAxis","normalize","cartographicVectorRadians","cosLatitude","cos","set","sin","positionX","positionY","positionZ","beta","multiplyScalar","position","buffer","EPSILON15","abs","WGS84_RADIUS_X","WGS84_RADIUS_Y","WGS84_RADIUS_Z"],"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, toRadians, toDegrees, assert, equals, _MathUtils} from '@math.gl/core';\nimport * as vec3 from 'gl-matrix/vec3';\n\nimport {WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z} from '../constants';\nimport {fromCartographicToRadians, toCartographicFromRadians} from '../type-utils';\n\nimport scaleToGeodeticSurface from './helpers/scale-to-geodetic-surface';\nimport localFrameToFixedFrame from './helpers/ellipsoid-transform';\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\nlet wgs84;\n\n// A quadratic surface defined in Cartesian coordinates by the equation\n// <code>(x / a)^2 + (y / b)^2 + (z / c)^2 = 1</code>.  Primarily used\n// to represent the shape of planetary bodies.\nexport default class Ellipsoid {\n  // An Ellipsoid instance initialized to the WGS84 standard.\n  static get WGS84() {\n    wgs84 = wgs84 || new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);\n    return wgs84;\n  }\n\n  // Creates an Ellipsoid from a Cartesian specifying the radii in x, y, and z directions.\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    this.centerToleranceSquared = _MathUtils.EPSILON1;\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 and returns\n  equals(right) {\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() {\n    return this.radii.toString();\n  }\n\n  // Converts the provided cartographic to Cartesian representation.\n  cartographicToCartesian(cartographic, 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, 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, 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  localFrameToFixedFrame(firstAxis, secondAxis, thirdAxis, origin, result = new Matrix4()) {\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, 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(cartographic, 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(cartesian, 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, result) {\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, result = [0, 0, 0]) {\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, result = [0, 0, 0]) {\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, result = [0, 0, 0]) {\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(position, buffer = 0.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\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"}
+{"version":3,"sources":["../../../src/ellipsoid/ellipsoid.ts"],"names":["scratchVector","Vector3","scratchNormal","scratchK","scratchPosition","scratchHeight","scratchCartesian","wgs84","Ellipsoid","x","y","z","_MathUtils","EPSILON1","radii","radiiSquared","radiiToTheFourth","oneOverRadii","oneOverRadiiSquared","minimumRadius","Math","min","maximumRadius","max","squaredXOverSquaredZ","Object","freeze","right","Boolean","equals","toString","cartographic","result","normal","k","height","geodeticSurfaceNormalCartographic","copy","scale","gamma","sqrt","dot","add","to","cartesian","from","point","scaleToGeodeticSurface","undefined","geodeticSurfaceNormal","h","subtract","longitude","atan2","latitude","asin","sign","vec3","length","origin","Matrix4","firstAxis","secondAxis","thirdAxis","normalize","cartographicVectorRadians","cosLatitude","cos","set","sin","positionX","positionY","positionZ","beta","multiplyScalar","position","buffer","EPSILON15","abs","WGS84_RADIUS_X","WGS84_RADIUS_Y","WGS84_RADIUS_Z"],"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 {\n  Vector3,\n  Matrix4,\n  toRadians,\n  toDegrees,\n  assert,\n  equals,\n  _MathUtils,\n  NumericArray\n} from '@math.gl/core';\nimport * as vec3 from 'gl-matrix/vec3';\n\nimport {WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z} from '../constants';\nimport {fromCartographicToRadians, toCartographicFromRadians} from '../type-utils';\n\nimport scaleToGeodeticSurface from './helpers/scale-to-geodetic-surface';\nimport localFrameToFixedFrame from './helpers/ellipsoid-transform';\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\nlet wgs84;\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 default 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, 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: number[], result: Vector3): Vector3;\n  cartesianToCartographic(cartesian: number[], result?: number[]): number[];\n\n  cartesianToCartographic(cartesian, 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: number[], result?: Matrix4): Matrix4;\n  eastNorthUpToFixedFrame(origin: number[], result: number[]): number[];\n\n  eastNorthUpToFixedFrame(origin, 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: string,\n    secondAxis: string,\n    thirdAxis: string,\n    origin: Readonly<NumericArray>,\n    result?: Matrix4\n  ): Matrix4;\n  localFrameToFixedFrame<Matrix4T>(\n    firstAxis: string,\n    secondAxis: string,\n    thirdAxis: string,\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(firstAxis, secondAxis, thirdAxis, origin, result = new Matrix4()) {\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, 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>(cartographic: number[], result: NumArray): NumArray;\n  geodeticSurfaceNormalCartographic(cartographic: number[]): number[];\n  geodeticSurfaceNormalCartographic(cartographic, 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, 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"}