@math.gl/geospatial 3.6.0-alpha.8 → 3.6.2

package/package.json

@@ -5,7 +5,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.6.0-alpha.8",
+  "version": "3.6.2",
   "keywords": [
     "webgl",
     "javascript",
@@ -32,8 +32,8 @@
   ],
   "dependencies": {
     "@babel/runtime": "^7.12.0",
-    "@math.gl/core": "3.6.0-alpha.8",
+    "@math.gl/core": "3.6.2",
     "gl-matrix": "^3.4.0"
   },
-  "gitHead": "5354df2f3c4111d4e48f4a0508d8e8103dd5eaf4"
+  "gitHead": "517015873bbd7143bfc4bb761e70071c7a86771b"
 }

package/dist/constants.js

@@ -1,22 +0,0 @@
-// 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.js

@@ -1,142 +0,0 @@
-// 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.js

@@ -1,125 +0,0 @@
-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.js

@@ -1,70 +0,0 @@
-/* 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/index.js

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

package/dist/type-utils.js

@@ -1,96 +0,0 @@
-// 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';
-function identity(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;
-}
-export function fromCartographicToRadians(cartographic, vector = []) {
-    return fromCartographic(cartographic, vector, config._cartographicRadians ? identity : toRadians);
-}
-export function fromCartographicToDegrees(cartographic, vector = []) {
-    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;
-}
-export function toCartographicFromRadians(vector, cartographic) {
-    return toCartographic(vector, cartographic, config._cartographicRadians ? identity : toDegrees);
-}
-export function toCartographicFromDegrees(vector, cartographic) {
-    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;
-}
-/*
-
-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;
-*/