@math.gl/geospatial 5.0.0-alpha.18 → 5.0.0-alpha.19

package/src/projection/experimental/datum.ts

@@ -0,0 +1,185 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Helmert equations directly adapted from proj4js 2.22.0 datumUtils.js. See ../../PROJ4-LICENSE.md. Geocentric equations now delegate to the attributed @math.gl/core/spheroid leaf.
+import {spheroidToCartesian, cartesianToSpheroid} from '@math.gl/core/spheroid';
+import type {Datum, Ellipsoid} from './crs/types';
+import type {ProjectionPoint} from './types';
+export type Coordinate3D = [number, number, number];
+const ARC_SECOND = Math.PI / (180 * 3600);
+const WGS84: Datum = {
+  ellipsoid: {
+    semiMajorAxis: 6378137,
+    semiMinorAxis: 6356752.314245179,
+    eccentricitySquared: 0.0066943799901413165
+  },
+  towgs84: [0, 0, 0]
+};
+
+export function geodeticToGeocentricInPlace(point: ProjectionPoint, ellipsoid: Ellipsoid): void {
+  if (Math.abs(point.y) > Math.PI / 2) throw new Error('Latitude outside geocentric domain');
+  if (!spheroidToCartesian(point, ellipsoid))
+    throw new Error('Geocentric coordinate must be finite');
+}
+
+/** Projection retains its center error and historical near-axis canonicalization. */
+export function geocentricToGeodeticInPlace(point: ProjectionPoint, ellipsoid: Ellipsoid): void {
+  const x = point.x,
+    y = point.y,
+    z = point.z;
+  const {semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es} = ellipsoid;
+  if (x === 0 && y === 0 && z === 0)
+    throw new Error('Geodetic coordinates are undefined at the Earth center');
+  if (
+    es !== 0 &&
+    Math.abs(x) < 1e-12 * a &&
+    Math.abs(y) < 1e-12 * a &&
+    Math.hypot(x, y) < 1e-12 * a
+  ) {
+    if (!Number.isFinite(Math.hypot(x, y, z))) throw new Error('Geocentric radius must be finite');
+    point.x = 0;
+    point.y = (Math.sign(z) * Math.PI) / 2;
+    point.z = Math.abs(z) - b;
+    return;
+  }
+  if (!cartesianToSpheroid(point, ellipsoid)) {
+    if (!Number.isFinite(Math.hypot(x, y, z))) throw new Error('Geocentric radius must be finite');
+    throw new Error('Geocentric inverse did not converge');
+  }
+}
+
+/** Convert rotation units and scale once for the lifetime of a compiled datum stage. */
+export function createHelmert(values: readonly number[], inverse: boolean): DatumOperation {
+  const dx = values[0],
+    dy = values[1],
+    dz = values[2];
+  const rx = (values[3] || 0) * ARC_SECOND,
+    ry = (values[4] || 0) * ARC_SECOND,
+    rz = (values[5] || 0) * ARC_SECOND;
+  const scale = 1 + (values[6] || 0) / 1e6;
+  return inverse
+    ? point => {
+        const x = (point.x - dx) / scale,
+          y = (point.y - dy) / scale,
+          z = (point.z - dz) / scale;
+        point.x = x + rz * y - ry * z;
+        point.y = -rz * x + y + rx * z;
+        point.z = ry * x - rx * y + z;
+      }
+    : point => {
+        const x = point.x,
+          y = point.y,
+          z = point.z;
+        point.x = scale * (x - rz * y + ry * z) + dx;
+        point.y = scale * (rz * x + y - rx * z) + dy;
+        point.z = scale * (-ry * x + rx * y + z) + dz;
+      };
+}
+function shifted(datum: Datum): boolean {
+  return Boolean(datum.towgs84?.some(value => value !== 0));
+}
+type DatumOperation = (point: ProjectionPoint) => void;
+/** Resolve identity, grid and Helmert stages once, outside coordinate loops. */
+export function createDatumTransform(
+  source: Datum,
+  destination: Datum
+): DatumOperation | undefined {
+  // datum=none disables the entire chain, including a shifted opposite endpoint.
+  if (!source.towgs84 || !destination.towgs84) return undefined;
+  if (source.grids || destination.grids) {
+    if (
+      source.grids &&
+      destination.grids &&
+      source.ellipsoid.semiMajorAxis === destination.ellipsoid.semiMajorAxis &&
+      source.ellipsoid.eccentricitySquared === destination.ellipsoid.eccentricitySquared &&
+      source.grids.length === destination.grids.length &&
+      source.grids.every(
+        (entry, i) =>
+          entry.name === destination.grids[i].name &&
+          entry.optional === destination.grids[i].optional &&
+          entry.grid === destination.grids[i].grid
+      )
+    )
+      return undefined;
+    const middle = createDatumTransform(
+      source.grids ? WGS84 : source,
+      destination.grids ? WGS84 : destination
+    );
+    return point => {
+      if (source.grids) applyDatumGrids(point, source, false);
+      middle?.(point);
+      if (destination.grids) applyDatumGrids(point, destination, true);
+    };
+  }
+  if (shifted(source) || shifted(destination)) {
+    const first = convertDatum(source, WGS84),
+      second = convertDatum(WGS84, destination);
+    return point => {
+      first?.(point);
+      second?.(point);
+    };
+  }
+  return convertDatum(source, destination);
+}
+function convertDatum(from: Datum, to: Datum): DatumOperation | undefined {
+  if (!from.towgs84 || !to.towgs84) return undefined;
+  const a = from.ellipsoid,
+    b = to.ellipsoid;
+  let sameParameters = true;
+  for (let i = 0; i < 7; i++)
+    if ((from.towgs84[i] || 0) !== (to.towgs84[i] || 0)) sameParameters = false;
+  if (
+    a.semiMajorAxis === b.semiMajorAxis &&
+    Math.abs(a.eccentricitySquared - b.eccentricitySquared) <= 5e-11 &&
+    sameParameters
+  )
+    return undefined;
+  const sourceShift = shifted(from) ? createHelmert(from.towgs84, false) : undefined,
+    targetShift = shifted(to) ? createHelmert(to.towgs84, true) : undefined;
+  return point => {
+    geodeticToGeocentricInPlace(point, a);
+    sourceShift?.(point);
+    targetShift?.(point);
+    geocentricToGeodeticInPlace(point, b);
+  };
+}
+/** Original per-instance dispatch informed by proj4js grid list semantics. */
+export function applyDatumGrids(point: ProjectionPoint, datum: Datum, inverse: boolean): void {
+  for (const reference of datum.grids) {
+    if (reference.name === 'null') return;
+    if (!reference.grid) {
+      if (reference.optional) continue;
+      throw new Error('Required datum grid is not registered: ' + reference.name);
+    }
+    let found = false;
+    if (reference.grid.shiftInPlace) found = reference.grid.shiftInPlace(point, inverse);
+    else {
+      const output = reference.grid.shift(point.x, point.y, inverse);
+      if (output) {
+        point.x = output[0];
+        point.y = output[1];
+        found = true;
+      }
+    }
+    if (found) {
+      if (!Number.isFinite(point.x) || !Number.isFinite(point.y) || Math.abs(point.y) > Math.PI / 2)
+        throw new Error('Datum grid produced a coordinate outside the geographic domain');
+      return;
+    }
+  }
+  throw new Error(
+    'No datum grid covers coordinate: ' + datum.grids.map(grid => grid.name).join(',')
+  );
+}
+// Scalar adapters retain the internal tuple API for existing callers.
+export function geodeticToGeocentric(coordinate: Coordinate3D, ellipsoid: Ellipsoid): Coordinate3D {
+  const point = {x: coordinate[0], y: coordinate[1], z: coordinate[2]};
+  geodeticToGeocentricInPlace(point, ellipsoid);
+  return [point.x, point.y, point.z];
+}
+export function geocentricToGeodetic(coordinate: Coordinate3D, ellipsoid: Ellipsoid): Coordinate3D {
+  const point = {x: coordinate[0], y: coordinate[1], z: coordinate[2]};
+  geocentricToGeodeticInPlace(point, ellipsoid);
+  return [point.x, point.y, point.z];
+}

package/src/projection/experimental/deformation-inverse.ts

@@ -0,0 +1,125 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original bounded damped Newton inverse with numerical displacement Jacobian; no upstream solver copied.
+import type {ProjectionPoint} from './types';
+export type FixedDisplacement = (point: ProjectionPoint, source: number, target: number) => void;
+/** Source-sampled map inverse. Successful iterations reuse the caller's working point. */
+export function inverseDisplacement(
+  point: ProjectionPoint,
+  x: number,
+  y: number,
+  z: number,
+  source: number,
+  target: number,
+  sample: FixedDisplacement
+): void {
+  let px = x,
+    py = y,
+    pz = z;
+  for (let iteration = 0; iteration < 16; iteration++) {
+    point.x = px;
+    point.y = py;
+    point.z = pz;
+    sample(point, source, target);
+    const rx = px - x + point.x,
+      ry = py - y + point.y,
+      rz = pz - z + point.z;
+    const norm = Math.hypot(rx, ry, rz);
+    if (!Number.isFinite(norm)) throw new Error('Non-finite temporal inverse residual');
+    if (norm <= 1e-8) {
+      point.x = px;
+      point.y = py;
+      point.z = pz;
+      return;
+    }
+    const epsilon =
+      Math.sqrt(Number.EPSILON) * Math.max(1, Math.abs(px), Math.abs(py), Math.abs(pz));
+    let j00 = 0,
+      j01 = 0,
+      j02 = 0,
+      j10 = 0,
+      j11 = 0,
+      j12 = 0,
+      j20 = 0,
+      j21 = 0,
+      j22 = 0;
+    for (let axis = 0; axis < 3; axis++) {
+      point.x = px + (axis === 0 ? epsilon : 0);
+      point.y = py + (axis === 1 ? epsilon : 0);
+      point.z = pz + (axis === 2 ? epsilon : 0);
+      sample(point, source, target);
+      const vx = point.x,
+        vy = point.y,
+        vz = point.z;
+      point.x = px - (axis === 0 ? epsilon : 0);
+      point.y = py - (axis === 1 ? epsilon : 0);
+      point.z = pz - (axis === 2 ? epsilon : 0);
+      sample(point, source, target);
+      const dx = (vx - point.x) / (2 * epsilon),
+        dy = (vy - point.y) / (2 * epsilon),
+        dz = (vz - point.z) / (2 * epsilon);
+      if (axis === 0) {
+        j00 = 1 + dx;
+        j10 = dy;
+        j20 = dz;
+      } else if (axis === 1) {
+        j01 = dx;
+        j11 = 1 + dy;
+        j21 = dz;
+      } else {
+        j02 = dx;
+        j12 = dy;
+        j22 = 1 + dz;
+      }
+    }
+    const c00 = j11 * j22 - j12 * j21,
+      c01 = j02 * j21 - j01 * j22,
+      c02 = j01 * j12 - j02 * j11;
+    const c10 = j12 * j20 - j10 * j22,
+      c11 = j00 * j22 - j02 * j20,
+      c12 = j02 * j10 - j00 * j12;
+    const c20 = j10 * j21 - j11 * j20,
+      c21 = j01 * j20 - j00 * j21,
+      c22 = j00 * j11 - j01 * j10;
+    const determinant = j00 * c00 + j01 * c10 + j02 * c20;
+    if (!Number.isFinite(determinant) || determinant === 0)
+      throw new Error('Singular temporal inverse Jacobian');
+    const sx = (c00 * rx + c01 * ry + c02 * rz) / determinant,
+      sy = (c10 * rx + c11 * ry + c12 * rz) / determinant,
+      sz = (c20 * rx + c21 * ry + c22 * rz) / determinant;
+    if (!Number.isFinite(sx) || !Number.isFinite(sy) || !Number.isFinite(sz))
+      throw new Error('Non-finite temporal inverse update');
+    let accepted = false;
+    for (let half = 0; half < 12; half++) {
+      const scale = 2 ** -half,
+        nx = px - scale * sx,
+        ny = py - scale * sy,
+        nz = pz - scale * sz;
+      point.x = nx;
+      point.y = ny;
+      point.z = nz;
+      try {
+        sample(point, source, target);
+        const error = Math.hypot(nx - x + point.x, ny - y + point.y, nz - z + point.z);
+        if (Number.isFinite(error) && error < norm) {
+          if (error <= 1e-8) {
+            point.x = nx;
+            point.y = ny;
+            point.z = nz;
+            return;
+          }
+          px = nx;
+          py = ny;
+          pz = nz;
+          accepted = true;
+          break;
+        }
+      } catch {
+        /* Domain/coverage failures reject this trial; no extrapolation. */
+      }
+    }
+    if (!accepted) throw new Error('Temporal inverse line search failed');
+  }
+  throw new Error('Temporal inverse did not converge');
+}

package/src/projection/experimental/deformation.ts

@@ -0,0 +1,30 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original ENU basis rotation and inverse, inspired by PROJ's documented deformation contract; no PROJ implementation is copied or forked. Geocentric conversion reuses the attributed proj4js adaptation in datum.ts.
+import {createSpatialDeformationModel} from './spatial-deformation';
+import type {ProjectionPoint} from './types';
+import type {VelocityGrid} from './grids/velocity';
+/** Both methods take the ORIGINAL source/target epoch pair. inverse solves forward,
+ * rather than sampling the endpoint with a negated duration. XYZ are ECEF metres.
+ * Successful calls mutate XYZ; a failure restores the input. No per-point allocations.
+ */
+export type DeformationModel = {
+  forward(point: ProjectionPoint, sourceEpoch: number, targetEpoch: number): void;
+  inverse(point: ProjectionPoint, sourceEpoch: number, targetEpoch: number): void;
+};
+export type DeformationModelOptions = {
+  readonly grid: VelocityGrid;
+  /** Inclusive, application-reviewed validity interval in decimal years. */
+  readonly epochRange: readonly [number, number];
+  /** Must match the velocity model's geographic reference frame. Default WGS84. */
+  readonly ellipsoid?: {readonly semiMajorAxis: number; readonly flattening: number};
+};
+
+/** Time-invariant ENU velocity, source-sampled in fixed XYZ space. */
+export function createDeformationModel(options: DeformationModelOptions): DeformationModel {
+  if (!options.grid || typeof options.grid.sample !== 'function')
+    throw new Error('Prepared velocity grid required');
+  const sample = options.grid.sample.bind(options.grid);
+  return createSpatialDeformationModel(options, sample, true);
+}

package/src/projection/experimental/entries/projections/aea.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {albersEqualArea} from '../../projections/aea';

package/src/projection/experimental/entries/projections/aeqd.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {azimuthalEquidistant} from '../../projections/aeqd';

package/src/projection/experimental/entries/projections/bonne.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {bonne} from '../../projections/bonne';

package/src/projection/experimental/entries/projections/cass.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {cassiniSoldner} from '../../projections/cass';

package/src/projection/experimental/entries/projections/cea.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {cylindricalEqualArea} from '../../projections/cea';

package/src/projection/experimental/entries/projections/eck6.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {eckertVI} from '../../projections/eck6';

package/src/projection/experimental/entries/projections/eqc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {equidistantCylindrical} from '../../projections/equidistant-cylindrical';

package/src/projection/experimental/entries/projections/eqdc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {equidistantConic} from '../../projections/eqdc';

package/src/projection/experimental/entries/projections/eqearth.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {equalEarth} from '../../projections/eqearth';

package/src/projection/experimental/entries/projections/equi.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {equirectangular} from '../../projections/equi';

package/src/projection/experimental/entries/projections/etmerc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {extendedTransverseMercator} from '../../projections/transverse-mercator';

package/src/projection/experimental/entries/projections/geocent.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {geocentric} from '../../projections/geocentric';

package/src/projection/experimental/entries/projections/geos.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {geostationary} from '../../projections/geos';

package/src/projection/experimental/entries/projections/gnom.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {gnomonic} from '../../projections/gnom';

package/src/projection/experimental/entries/projections/gstmerc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {gaussSchreiberTransverseMercator} from '../../projections/gstmerc';

package/src/projection/experimental/entries/projections/krovak.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {krovak} from '../../projections/krovak';

package/src/projection/experimental/entries/projections/laea.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {lambertAzimuthalEqualArea} from '../../projections/laea';

package/src/projection/experimental/entries/projections/lcc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {lambertConformalConic} from '../../projections/lcc';

package/src/projection/experimental/entries/projections/merc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {mercator} from '../../projections/mercator';

package/src/projection/experimental/entries/projections/mill.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {millerCylindrical} from '../../projections/mill';

package/src/projection/experimental/entries/projections/moll.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {mollweide} from '../../projections/moll';

package/src/projection/experimental/entries/projections/nzmg.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {newZealandMapGrid} from '../../projections/nzmg';

package/src/projection/experimental/entries/projections/ob_tran.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {obliqueTransformation} from '../../projections/ob-tran';

package/src/projection/experimental/entries/projections/omerc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {obliqueMercator} from '../../projections/omerc';

package/src/projection/experimental/entries/projections/ortho.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {orthographic} from '../../projections/ortho';

package/src/projection/experimental/entries/projections/poly.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {polyconic} from '../../projections/poly';

package/src/projection/experimental/entries/projections/qsc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {quadrilateralizedSphericalCube} from '../../projections/qsc';

package/src/projection/experimental/entries/projections/robin.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {robinson} from '../../projections/robin';

package/src/projection/experimental/entries/projections/sinu.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {sinusoidal} from '../../projections/sinu';

package/src/projection/experimental/entries/projections/somerc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {swissObliqueMercator} from '../../projections/somerc';

package/src/projection/experimental/entries/projections/stere.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {stereographic} from '../../projections/stere';

package/src/projection/experimental/entries/projections/sterea.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {obliqueStereographic} from '../../projections/sterea';

package/src/projection/experimental/entries/projections/tmerc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {transverseMercator} from '../../projections/transverse-mercator';

package/src/projection/experimental/entries/projections/tpers.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {tiltedPerspective} from '../../projections/tpers';

package/src/projection/experimental/entries/projections/utm.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {universalTransverseMercator} from '../../projections/utm';

package/src/projection/experimental/entries/projections/vandg.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {vanDerGrinten} from '../../projections/vandg';

package/src/projection/experimental/exact-helmert.ts

@@ -0,0 +1,58 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) 2016, Thomas Knudsen / SDFE (PROJ)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Exact rotation matrix adapted from PROJ 9.5.1 src/transformations/helmert.cpp. See ../../PROJ-LICENSE.txt. Modified into prepared, typed, allocation-free point operations. Existing small-angle Helmert equations remain the proj4js adaptation in datum.ts.
+import type {ProjectionPoint} from './types';
+
+type Operation = (point: ProjectionPoint) => void;
+export function createExactHelmert(
+  translation: readonly number[],
+  rotation: readonly number[],
+  scalePPM: number,
+  coordinateFrame: boolean
+): {forward: Operation; inverse: Operation; coefficients: readonly number[]} {
+  const radians = Math.PI / (180 * 3600);
+  const [rx, ry, rz] = rotation.map(angle => angle * radians);
+  const cx = Math.cos(rx),
+    sx = Math.sin(rx),
+    cy = Math.cos(ry),
+    sy = Math.sin(ry),
+    cz = Math.cos(rz),
+    sz = Math.sin(rz);
+  // Coordinate-frame convention. Position-vector convention transposes the
+  // whole matrix; simply negating Euler angles is not equivalent for finite rotations.
+  let r01 = cx * sz + sx * sy * cz,
+    r02 = sx * sz - cx * sy * cz,
+    r10 = -cy * sz,
+    r12 = sx * cz + cx * sy * sz,
+    r20 = sy,
+    r21 = -sx * cy;
+  const r00 = cy * cz,
+    r11 = cx * cz - sx * sy * sz,
+    r22 = cx * cy;
+  if (!coordinateFrame) {
+    [r01, r10] = [r10, r01];
+    [r02, r20] = [r20, r02];
+    [r12, r21] = [r21, r12];
+  }
+  const scale = 1 + scalePPM / 1e6;
+  const [dx, dy, dz] = translation;
+  return {
+    coefficients: [r00, r01, r02, r10, r11, r12, r20, r21, r22, dx, dy, dz, scale],
+    forward(point) {
+      const {x, y, z} = point;
+      point.x = scale * (r00 * x + r01 * y + r02 * z) + dx;
+      point.y = scale * (r10 * x + r11 * y + r12 * z) + dy;
+      point.z = scale * (r20 * x + r21 * y + r22 * z) + dz;
+    },
+    inverse(point) {
+      const x = (point.x - dx) / scale,
+        y = (point.y - dy) / scale,
+        z = (point.z - dz) / scale;
+      point.x = r00 * x + r10 * y + r20 * z;
+      point.y = r01 * x + r11 * y + r21 * z;
+      point.z = r02 * x + r12 * y + r22 * z;
+    }
+  };
+}