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

package/dist/constants.d.ts

@@ -9,4 +9,3 @@ export declare const WGS84_CONSTANTS: {
     maximumRadius: number;
     centerToleranceSquared: number;
 };
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -1,12 +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
+    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;
 };
-//# sourceMappingURL=constants.js.map

package/dist/ellipsoid/ellipsoid.d.ts

@@ -1,5 +1,5 @@
 import { Vector3, Matrix4, NumericArray } from '@math.gl/core';
-import type { AxisDirection } from './helpers/ellipsoid-transform';
+import type { AxisDirection } from "./helpers/ellipsoid-transform.js";
 /**
  * A quadratic surface defined in Cartesian coordinates by the equation
  * `(x / a)^2 + (y / b)^2 + (z / c)^2 = 1`.  Primarily used
@@ -66,4 +66,3 @@ export declare class Ellipsoid {
     /** 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.js

@@ -1,4 +1,6 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// 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, vec3 } from '@math.gl/core';
 import { WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z } from "../constants.js";
 import { fromCartographicToRadians, toCartographicFromRadians } from "../type-utils.js";
@@ -10,143 +12,129 @@ const scratchK = new Vector3();
 const scratchPosition = new Vector3();
 const scratchHeight = new Vector3();
 const scratchCartesian = new Vector3();
+/**
+ * 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 class Ellipsoid {
-  constructor(x = 0.0, y = 0.0, z = 0.0) {
-    _defineProperty(this, "radii", void 0);
-
-    _defineProperty(this, "radiiSquared", void 0);
-
-    _defineProperty(this, "radiiToTheFourth", void 0);
-
-    _defineProperty(this, "oneOverRadii", void 0);
-
-    _defineProperty(this, "oneOverRadiiSquared", void 0);
-
-    _defineProperty(this, "minimumRadius", void 0);
-
-    _defineProperty(this, "maximumRadius", void 0);
-
-    _defineProperty(this, "centerToleranceSquared", _MathUtils.EPSILON1);
-
-    _defineProperty(this, "squaredXOverSquaredZ", void 0);
-
-    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;
+    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);
     }
-
-    Object.freeze(this);
-  }
-
-  equals(right) {
-    return this === right || Boolean(right && this.radii.equals(right.radii));
-  }
-
-  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;
+    /** Compares this Ellipsoid against the provided Ellipsoid componentwise */
+    equals(right) {
+        return this === right || Boolean(right && this.radii.equals(right.radii));
     }
-
-    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);
-  }
-
-  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);
-  }
-
-  scaleToGeodeticSurface(cartesian, result) {
-    return scaleToGeodeticSurface(cartesian, this, result);
-  }
-
-  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);
-  }
-
-  transformPositionToScaledSpace(position, result = [0, 0, 0]) {
-    return scratchPosition.from(position).scale(this.oneOverRadii).to(result);
-  }
-
-  transformPositionFromScaledSpace(position, result = [0, 0, 0]) {
-    return scratchPosition.from(position).scale(this.radii).to(result);
-  }
-
-  getSurfaceNormalIntersectionWithZAxis(position, buffer = 0, result = [0, 0, 0]) {
-    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;
+    /** 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);
     }
-
-    return scratchPosition.set(0.0, 0.0, z).to(result);
-  }
-
 }
-
-_defineProperty(Ellipsoid, "WGS84", new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z));
-//# sourceMappingURL=ellipsoid.js.map
+/** 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

@@ -1,5 +1,4 @@
 import { NumericArray } from '@math.gl/core';
-import type { Ellipsoid } from '../ellipsoid';
-export declare type AxisDirection = 'up' | 'down' | 'north' | 'east' | 'south' | 'west';
+import type { Ellipsoid } from "../ellipsoid.js";
+export type AxisDirection = 'up' | 'down' | 'north' | 'east' | 'south' | 'west';
 export declare function localFrameToFixedFrame(ellipsoid: Ellipsoid, firstAxis: AxisDirection, secondAxis: AxisDirection, thirdAxis: AxisDirection, cartesianOrigin: Readonly<NumericArray>, result: number[]): number[];
-//# sourceMappingURL=ellipsoid-transform.d.ts.map

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

@@ -1,129 +1,124 @@
 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'
-  }
+    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]
+    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()
+    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 function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {
-  const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];
-  assert(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
-  let firstAxisVector;
-  let secondAxisVector;
-  let thirdAxisVector;
-  const origin = scratchOrigin.copy(cartesianOrigin);
-  const atPole = equalsEpsilon(origin.x, 0.0, EPSILON14) && equalsEpsilon(origin.y, 0.0, EPSILON14);
-
-  if (atPole) {
-    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);
+    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);
+        }
     }
-
-    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];
     }
-  } else {
-    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);
-    firstAxisVector = scratchAxisVectors[firstAxis];
-    secondAxisVector = scratchAxisVectors[secondAxis];
-    thirdAxisVector = scratchAxisVectors[thirdAxis];
-  }
-
-  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;
+    // 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;
 }
-//# sourceMappingURL=ellipsoid-transform.js.map

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

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