@math.gl/projection 0.0.0-stage → 5.0.0-alpha.12

package/src/experimental/kernels/sterea.ts

@@ -0,0 +1,80 @@
+// 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 = GaussState & {
+  sinc0: number;
+  cosc0: number;
+  R2: number;
+};
+import {
+  createState as createGaussState,
+  forward as gaussForward,
+  inverse as gaussInverse
+} from './gauss';
+import type {State as GaussState} from './gauss';
+import adjust_lon from '../common/adjust_lon';
+import hypot from '../common/hypot';
+
+function initialize(state: State): void {
+  if (!state.rc) {
+    return;
+  }
+  state.sinc0 = Math.sin(state.phic0);
+  state.cosc0 = Math.cos(state.phic0);
+  state.R2 = 2 * state.rc;
+}
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var sinc, cosc, cosl, k;
+  p.x = adjust_lon(p.x - state.long0, state.over);
+  gaussForward(state, p);
+  sinc = Math.sin(p.y);
+  cosc = Math.cos(p.y);
+  cosl = Math.cos(p.x);
+  k = (state.k0 * state.R2) / (1 + state.sinc0 * sinc + state.cosc0 * cosc * cosl);
+  p.x = k * cosc * Math.sin(p.x);
+  p.y = k * (state.cosc0 * sinc - state.sinc0 * cosc * cosl);
+  p.x = state.a * p.x + state.x0;
+  p.y = state.a * p.y + state.y0;
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var sinc, cosc, lon, lat, rho;
+  p.x = (p.x - state.x0) / state.a;
+  p.y = (p.y - state.y0) / state.a;
+
+  p.x /= state.k0;
+  p.y /= state.k0;
+  rho = hypot(p.x, p.y);
+  if (rho) {
+    var c = 2 * Math.atan2(rho, state.R2);
+    sinc = Math.sin(c);
+    cosc = Math.cos(c);
+    lat = Math.asin(cosc * state.sinc0 + (p.y * sinc * state.cosc0) / rho);
+    lon = Math.atan2(p.x * sinc, rho * state.cosc0 * cosc - p.y * state.sinc0 * sinc);
+  } else {
+    lat = state.phic0;
+    lon = 0;
+  }
+
+  p.x = lon;
+  p.y = lat;
+  if (!gaussInverse(state, p)) throw new Error('Oblique stereographic inverse did not converge');
+  p.x = adjust_lon(p.x + state.long0, state.over);
+  return p;
+}
+
+export function createState(base: KernelParameters): State {
+  const state: State = {
+    ...createGaussState(base),
+    sinc0: 0,
+    cosc0: 0,
+    R2: 0
+  };
+  initialize(state);
+  return state;
+}

package/src/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/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/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-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 & {
+  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 + costh - 1);
+  var gsq = g * g;
+  var m = g * (2 / sinth - 1);
+  var msq = m * m;
+  var con =
+    (Math.PI *
+      state.R *
+      (al * (g - msq) + Math.sqrt(asq * (g - msq) * (g - msq) - (msq + asq) * (gsq - msq)))) /
+    (msq + asq);
+  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 * (m * q - al * Math.sqrt((msq + asq) * (asq + 1) - q * q))) / (msq + asq);
+  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 +
+        (Math.PI * (xys - 1 + Math.sqrt(1 + 2 * (xx * xx - yy * yy) + xys * xys))) / 2 / xx,
+      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;
+}