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

package/src/projection/experimental/kernels/tmerc.ts

@@ -0,0 +1,227 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  en: number[];
+  ml0: number;
+};
+// Heavily based on this tmerc projection implementation
+// https://github.com/mbloch/mapshaper-proj/blob/master/src/projections/tmerc.js
+
+import pj_enfn from '../common/pj_enfn';
+import pj_mlfn from '../common/pj_mlfn';
+import pj_inv_mlfn from '../common/pj_inv_mlfn';
+import adjust_lon from '../common/adjust_lon';
+
+import {EPSLN, HALF_PI} from '../common/constants';
+import sign from '../common/sign';
+
+function initialize(state: State): void {
+  state.x0 = state.x0 !== undefined ? state.x0 : 0;
+  state.y0 = state.y0 !== undefined ? state.y0 : 0;
+  state.long0 = state.long0 !== undefined ? state.long0 : 0;
+  state.lat0 = state.lat0 !== undefined ? state.lat0 : 0;
+
+  if (state.es) {
+    state.en = pj_enfn(state.es);
+    state.ml0 = pj_mlfn(state.lat0, Math.sin(state.lat0), Math.cos(state.lat0), state.en);
+  }
+}
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var lon = p.x;
+  var lat = p.y;
+
+  var delta_lon = adjust_lon(lon - state.long0, state.over);
+  var con;
+  var x, y;
+  var sin_phi = Math.sin(lat);
+  var cos_phi = Math.cos(lat);
+
+  if (!state.es) {
+    var b = cos_phi * Math.sin(delta_lon);
+
+    if (Math.abs(Math.abs(b) - 1) < EPSLN) {
+      return 93;
+    } else {
+      x = 0.5 * state.a * state.k0 * Math.log((1 + b) / (1 - b)) + state.x0;
+      y = (cos_phi * Math.cos(delta_lon)) / Math.sqrt(1 - Math.pow(b, 2));
+      b = Math.abs(y);
+
+      if (b >= 1) {
+        if (b - 1 > EPSLN) {
+          return 93;
+        } else {
+          y = 0;
+        }
+      } else {
+        y = Math.acos(y);
+      }
+
+      if (lat < 0) {
+        y = -y;
+      }
+
+      y = state.a * state.k0 * (y - state.lat0) + state.y0;
+    }
+  } else {
+    var al = cos_phi * delta_lon;
+    var als = Math.pow(al, 2);
+    var c = state.ep2 * Math.pow(cos_phi, 2);
+    var cs = Math.pow(c, 2);
+    var tq = Math.abs(cos_phi) > EPSLN ? Math.tan(lat) : 0;
+    var t = Math.pow(tq, 2);
+    var ts = Math.pow(t, 2);
+    con = 1 - state.es * Math.pow(sin_phi, 2);
+    al = al / Math.sqrt(con);
+    var ml = pj_mlfn(lat, sin_phi, cos_phi, state.en);
+
+    x =
+      state.a *
+        (state.k0 *
+          al *
+          (1 +
+            (als / 6) *
+              (1 -
+                t +
+                c +
+                (als / 20) *
+                  (5 -
+                    18 * t +
+                    ts +
+                    14 * c -
+                    58 * t * c +
+                    (als / 42) * (61 + 179 * ts - ts * t - 479 * t))))) +
+      state.x0;
+
+    y =
+      state.a *
+        (state.k0 *
+          (ml -
+            state.ml0 +
+            ((sin_phi * delta_lon * al) / 2) *
+              (1 +
+                (als / 12) *
+                  (5 -
+                    t +
+                    9 * c +
+                    4 * cs +
+                    (als / 30) *
+                      (61 +
+                        ts -
+                        58 * t +
+                        270 * c -
+                        330 * t * c +
+                        (als / 56) * (1385 + 543 * ts - ts * t - 3111 * t)))))) +
+      state.y0;
+  }
+
+  p.x = x;
+  p.y = y;
+
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var con, phi;
+  var lat, lon;
+  var x = (p.x - state.x0) * (1 / state.a);
+  var y = (p.y - state.y0) * (1 / state.a);
+
+  if (!state.es) {
+    var f = Math.exp(x / state.k0);
+    var g = 0.5 * (f - 1 / f);
+    var temp = state.lat0 + y / state.k0;
+    var h = Math.cos(temp);
+    con = Math.sqrt((1 - Math.pow(h, 2)) / (1 + Math.pow(g, 2)));
+    lat = Math.asin(con);
+
+    // The sign comes from absolute latitude, not northing relative to lat_0.
+    if (Math.sin(temp) < 0) {
+      lat = -lat;
+    }
+
+    if (g === 0 && h === 0) {
+      lon = 0;
+    } else {
+      lon = adjust_lon(Math.atan2(g, h) + state.long0, state.over);
+    }
+  } else {
+    // ellipsoidal form
+    con = state.ml0 + y / state.k0;
+    phi = pj_inv_mlfn(con, state.es, state.en);
+
+    if (Math.abs(phi) < HALF_PI) {
+      var sin_phi = Math.sin(phi);
+      var cos_phi = Math.cos(phi);
+      var tan_phi = Math.abs(cos_phi) > EPSLN ? Math.tan(phi) : 0;
+      var c = state.ep2 * Math.pow(cos_phi, 2);
+      var cs = Math.pow(c, 2);
+      var t = Math.pow(tan_phi, 2);
+      var ts = Math.pow(t, 2);
+      con = 1 - state.es * Math.pow(sin_phi, 2);
+      var d = (x * Math.sqrt(con)) / state.k0;
+      var ds = Math.pow(d, 2);
+      con = con * tan_phi;
+
+      lat =
+        phi -
+        ((con * ds) / (1 - state.es)) *
+          0.5 *
+          (1 -
+            (ds / 12) *
+              (5 +
+                3 * t -
+                9 * c * t +
+                c -
+                4 * cs -
+                (ds / 30) *
+                  (61 +
+                    90 * t -
+                    252 * c * t +
+                    45 * ts +
+                    46 * c -
+                    (ds / 56) * (1385 + 3633 * t + 4095 * ts + 1574 * ts * t))));
+
+      lon = adjust_lon(
+        state.long0 +
+          (d *
+            (1 -
+              (ds / 6) *
+                (1 +
+                  2 * t +
+                  c -
+                  (ds / 20) *
+                    (5 +
+                      28 * t +
+                      24 * ts +
+                      8 * c * t +
+                      6 * c -
+                      (ds / 42) * (61 + 662 * t + 1320 * ts + 720 * ts * t))))) /
+            cos_phi,
+        state.over
+      );
+    } else {
+      lat = HALF_PI * sign(y);
+      lon = 0;
+    }
+  }
+
+  p.x = lon;
+  p.y = lat;
+
+  return p;
+}
+
+export function createState(base: KernelParameters): State {
+  const state: State = {
+    ...base,
+    en: [],
+    ml0: 0
+  };
+  initialize(state);
+  return state;
+}

package/src/projection/experimental/kernels/tpers.ts

@@ -0,0 +1,187 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0, modified to keep inverse temporary coordinates in local numbers. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  mode: number;
+  sinph0: number;
+  cosph0: number;
+  pn1: number;
+  h: number;
+  p: number;
+  rp: number;
+  h1: number;
+  pfact: number;
+  tilt: number;
+  azi: number;
+  cg: number;
+  sg: number;
+  cw: number;
+  sw: number;
+};
+import {HALF_PI, EPSLN} from '../common/constants';
+import hypot from '../common/hypot';
+
+var mode = {
+  N_POLE: 0,
+  S_POLE: 1,
+  EQUIT: 2,
+  OBLIQ: 3
+};
+
+function initialize(state: State): void {
+  if (Math.abs(Math.abs(state.lat0) - HALF_PI) < EPSLN) {
+    state.mode = state.lat0 < 0 ? mode.S_POLE : mode.N_POLE;
+  } else if (Math.abs(state.lat0) < EPSLN) {
+    state.mode = mode.EQUIT;
+  } else {
+    state.mode = mode.OBLIQ;
+    state.sinph0 = Math.sin(state.lat0);
+    state.cosph0 = Math.cos(state.lat0);
+  }
+
+  state.pn1 = state.h / state.a; // Normalize relative to the Earth's radius
+
+  if (state.pn1 <= 0 || state.pn1 > 1e10) {
+    throw new Error('Invalid height');
+  }
+
+  state.p = 1 + state.pn1;
+  state.rp = 1 / state.p;
+  state.h1 = 1 / state.pn1;
+  state.pfact = (state.p + 1) * state.h1;
+  state.es = 0;
+
+  var omega = state.tilt;
+  var gamma = state.azi;
+  state.cg = Math.cos(gamma);
+  state.sg = Math.sin(gamma);
+  state.cw = Math.cos(omega);
+  state.sw = Math.sin(omega);
+}
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  p.x -= state.long0;
+  var sinphi = Math.sin(p.y);
+  var cosphi = Math.cos(p.y);
+  var coslam = Math.cos(p.x);
+  var x, y;
+  switch (state.mode) {
+    case mode.OBLIQ:
+      y = state.sinph0 * sinphi + state.cosph0 * cosphi * coslam;
+      break;
+    case mode.EQUIT:
+      y = cosphi * coslam;
+      break;
+    case mode.S_POLE:
+      y = -sinphi;
+      break;
+    case mode.N_POLE:
+      y = sinphi;
+      break;
+  }
+  y = state.pn1 / (state.p - y);
+  x = y * cosphi * Math.sin(p.x);
+
+  switch (state.mode) {
+    case mode.OBLIQ:
+      y *= state.cosph0 * sinphi - state.sinph0 * cosphi * coslam;
+      break;
+    case mode.EQUIT:
+      y *= sinphi;
+      break;
+    case mode.N_POLE:
+      y *= -(cosphi * coslam);
+      break;
+    case mode.S_POLE:
+      y *= cosphi * coslam;
+      break;
+  }
+
+  // Tilt
+  var yt, ba;
+  yt = y * state.cg + x * state.sg;
+  ba = 1 / (yt * state.sw * state.h1 + state.cw);
+  x = (x * state.cg - y * state.sg) * state.cw * ba;
+  y = yt * ba;
+
+  p.x = x * state.a;
+  p.y = y * state.a;
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  p.x /= state.a;
+  p.y /= state.a;
+  var rx = p.x,
+    ry = p.y;
+
+  // Un-Tilt
+  var bm, bq, yt;
+  yt = 1 / (state.pn1 - p.y * state.sw);
+  bm = state.pn1 * p.x * yt;
+  bq = state.pn1 * p.y * state.cw * yt;
+  p.x = bm * state.cg + bq * state.sg;
+  p.y = bq * state.cg - bm * state.sg;
+
+  var rh = hypot(p.x, p.y);
+  if (Math.abs(rh) < EPSLN) {
+    rx = 0;
+    ry = state.lat0;
+  } else {
+    var cosz, sinz;
+    sinz = 1 - rh * rh * state.pfact;
+    sinz = (state.p - Math.sqrt(sinz)) / (state.pn1 / rh + rh / state.pn1);
+    cosz = Math.sqrt(1 - sinz * sinz);
+    switch (state.mode) {
+      case mode.OBLIQ:
+        ry = Math.asin(cosz * state.sinph0 + (p.y * sinz * state.cosph0) / rh);
+        p.y = (cosz - state.sinph0 * Math.sin(ry)) * rh;
+        p.x *= sinz * state.cosph0;
+        break;
+      case mode.EQUIT:
+        ry = Math.asin((p.y * sinz) / rh);
+        p.y = cosz * rh;
+        p.x *= sinz;
+        break;
+      case mode.N_POLE:
+        ry = Math.asin(cosz);
+        p.y = -p.y;
+        break;
+      case mode.S_POLE:
+        ry = -Math.asin(cosz);
+        break;
+    }
+    rx = Math.atan2(p.x, p.y);
+  }
+
+  p.x = rx + state.long0;
+  p.y = ry;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {
+    ...base,
+    mode: 0,
+    sinph0: 0,
+    cosph0: 0,
+    pn1: 0,
+    h: 0,
+    p: 0,
+    rp: 0,
+    h1: 0,
+    pfact: 0,
+    tilt: 0,
+    azi: 0,
+    cg: 0,
+    sg: 0,
+    cw: 0,
+    sw: 0,
+    ...options
+  };
+  initialize(state);
+  return state;
+}

package/src/projection/experimental/kernels/vandg.ts

@@ -0,0 +1,147 @@
+// 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: Cancellation-resistant rationalization of forward/inverse numerators is original math.gl code. Remaining equations ported from of proj4js 2.22.0. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  R: number;
+};
+import adjust_lon from '../common/adjust_lon';
+
+import {HALF_PI, EPSLN} from '../common/constants';
+
+import asinz from '../common/asinz';
+
+function initialize(state: State): void {
+  // state.R = 6370997; //Radius of earth
+  state.R = state.a;
+}
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var lon = p.x;
+  var lat = p.y;
+
+  /* Forward equations
+    ----------------- */
+  var dlon = adjust_lon(lon - state.long0, state.over);
+  var x, y;
+
+  if (Math.abs(lat) <= EPSLN) {
+    x = state.x0 + state.R * dlon;
+    y = state.y0;
+    p.x = x;
+    p.y = y;
+    return p;
+  }
+  var theta = asinz(2 * Math.abs(lat / Math.PI));
+  if (Math.abs(dlon) <= EPSLN || Math.abs(Math.abs(lat) - HALF_PI) <= EPSLN) {
+    x = state.x0;
+    if (lat >= 0) {
+      y = state.y0 + Math.PI * state.R * Math.tan(0.5 * theta);
+    } else {
+      y = state.y0 + Math.PI * state.R * -Math.tan(0.5 * theta);
+    }
+    p.x = x;
+    p.y = y;
+    return p;
+  }
+  var al = 0.5 * Math.abs(Math.PI / dlon - dlon / Math.PI);
+  var asq = al * al;
+  var sinth = Math.sin(theta);
+  var costh = Math.cos(theta);
+
+  var g = costh / (sinth - 2 * Math.sin(theta / 2) ** 2);
+  var gsq = g * g;
+  var m = g * (2 / sinth - 1);
+  var msq = m * m;
+  // Rationalize sqrt(B) + A to avoid cancellation near the equator/central meridian.
+  var root = Math.sqrt(asq * (g - msq) * (g - msq) - (msq + asq) * (gsq - msq));
+  var con = (Math.PI * state.R * (msq - gsq)) / (root - al * (g - msq));
+  if (dlon < 0) {
+    con = -con;
+  }
+  x = state.x0 + con;
+  // con = Math.abs(con / (Math.PI * state.R));
+  var q = asq + g;
+  con =
+    (Math.PI * state.R * (asq * (2 * g - 1) + gsq)) /
+    (m * q + al * Math.sqrt((msq + asq) * (asq + 1) - q * q));
+  if (lat >= 0) {
+    // y = state.y0 + Math.PI * state.R * Math.sqrt(1 - con * con - 2 * al * con);
+    y = state.y0 + con;
+  } else {
+    // y = state.y0 - Math.PI * state.R * Math.sqrt(1 - con * con - 2 * al * con);
+    y = state.y0 - con;
+  }
+  p.x = x;
+  p.y = y;
+  return p;
+}
+
+/* Van Der Grinten inverse equations--mapping x,y to lat/long
+  --------------------------------------------------------- */
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var lon, lat;
+  var xx, yy, xys, c1, c2, c3;
+  var a1;
+  var m1;
+  var con;
+  var th1;
+  var d;
+
+  /* inverse equations
+    ----------------- */
+  p.x -= state.x0;
+  p.y -= state.y0;
+  if (Math.abs(p.y) < EPSLN) {
+    p.x = adjust_lon(state.long0 + p.x / state.R, state.over);
+    p.y = 0;
+    return p;
+  }
+  con = Math.PI * state.R;
+  xx = p.x / con;
+  yy = p.y / con;
+  xys = xx * xx + yy * yy;
+  c1 = -Math.abs(yy) * (1 + xys);
+  c2 = c1 - 2 * yy * yy + xx * xx;
+  c3 = -2 * c1 + 1 + 2 * yy * yy + xys * xys;
+  d = (yy * yy) / c3 + ((2 * c2 * c2 * c2) / c3 / c3 / c3 - (9 * c1 * c2) / c3 / c3) / 27;
+  a1 = (c1 - (c2 * c2) / 3 / c3) / c3;
+  m1 = 2 * Math.sqrt(-a1 / 3);
+  con = (3 * d) / a1 / m1;
+  if (Math.abs(con) > 1) {
+    if (con >= 0) {
+      con = 1;
+    } else {
+      con = -1;
+    }
+  }
+  th1 = Math.acos(con) / 3;
+  if (p.y >= 0) {
+    lat = (-m1 * Math.cos(th1 + Math.PI / 3) - c2 / 3 / c3) * Math.PI;
+  } else {
+    lat = -(-m1 * Math.cos(th1 + Math.PI / 3) - c2 / 3 / c3) * Math.PI;
+  }
+
+  if (Math.abs(xx) < EPSLN) {
+    lon = state.long0;
+  } else {
+    lon = adjust_lon(
+      state.long0 +
+        (2 * Math.PI * xx) / (Math.sqrt(1 + 2 * (xx * xx - yy * yy) + xys * xys) + 1 - xys),
+      state.over
+    );
+  }
+
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, R: 0, ...options};
+  initialize(state);
+  return state;
+}

package/src/projection/experimental/kinematic-helmert-flat.ts

@@ -0,0 +1,85 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) 2016, Thomas Knudsen / SDFE (PROJ)
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Original numeric-buffer traversal around kinematic-helmert.ts's existing attributed equations and prepared coefficients. Exact matrix application follows the PROJ adaptation; small-angle matrix application follows the proj4js adaptation. See ../../PROJ-LICENSE.txt and ../../PROJ4-LICENSE.md. No model data is included.
+import type {NumericFlatOperation} from './numeric-flat';
+
+/** Borrow the stage's owned coefficients, with exactly the scalar epoch preparation. */
+export function createKinematicHelmertFlat(
+  coefficients: Float64Array,
+  prepare: (epoch: number | undefined) => void,
+  inverse: boolean
+): NumericFlatOperation {
+  return (coordinates, dimension, epochs) => {
+    const float32 = coordinates instanceof Float32Array;
+    const epochBuffer = typeof epochs === 'number' ? undefined : epochs;
+    const batchEpoch = typeof epochs === 'number' ? epochs : undefined;
+    // Call-local numeric bindings do not escape into a mutable closure or point.
+    let a = 0,
+      b = 0,
+      c = 0,
+      d = 0,
+      e = 0,
+      f = 0,
+      g = 0,
+      h = 0,
+      j = 0;
+    let dx = 0,
+      dy = 0,
+      dz = 0,
+      scale = 1;
+    for (let offset = 0, record = 0; offset < coordinates.length; offset += dimension, record++) {
+      let x = coordinates[offset],
+        y = coordinates[offset + 1],
+        z = coordinates[offset + 2];
+      const epoch = epochBuffer ? epochBuffer[record] : batchEpoch;
+      if (epochBuffer && !Number.isFinite(epoch))
+        throw new Error('Coordinate epoch must be a finite decimal year');
+      if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+        throw new Error('Pipeline coordinate must be finite');
+      if (epochBuffer || offset === 0) {
+        // Preserve precedence and empty-buffer behavior: first validate XYZ, then
+        // prepare the epoch-adjusted parameters. A constant batch prepares once.
+        prepare(epoch);
+        a = coefficients[0];
+        b = coefficients[1];
+        c = coefficients[2];
+        d = coefficients[3];
+        e = coefficients[4];
+        f = coefficients[5];
+        g = coefficients[6];
+        h = coefficients[7];
+        j = coefficients[8];
+        dx = coefficients[9];
+        dy = coefficients[10];
+        dz = coefficients[11];
+        scale = coefficients[12];
+      }
+      let outX: number, outY: number, outZ: number;
+      if (inverse) {
+        x = (x - dx) / scale;
+        y = (y - dy) / scale;
+        z = (z - dz) / scale;
+        outX = a * x + d * y + g * z;
+        outY = b * x + e * y + h * z;
+        outZ = c * x + f * y + j * z;
+      } else {
+        outX = scale * (a * x + b * y + c * z) + dx;
+        outY = scale * (d * x + e * y + f * z) + dy;
+        outZ = scale * (g * x + h * y + j * z) + dz;
+      }
+      if (!Number.isFinite(outX) || !Number.isFinite(outY) || !Number.isFinite(outZ))
+        throw new Error('Pipeline coordinate must be finite');
+      if (
+        float32 &&
+        Math.max(Math.abs(outX), Math.abs(outY), Math.abs(outZ)) > 3.4028234663852886e38
+      )
+        throw new Error('Pipeline output exceeds Float32 range');
+      coordinates[offset] = outX;
+      coordinates[offset + 1] = outY;
+      coordinates[offset + 2] = outZ;
+    }
+  };
+}