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

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

@@ -0,0 +1,116 @@
+// 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[];
+  n: number;
+  m: number;
+  C_y: number;
+  C_x: number;
+};
+import adjust_lon from '../common/adjust_lon';
+import adjust_lat from '../common/adjust_lat';
+import pj_enfn from '../common/pj_enfn';
+var MAX_ITER = 20;
+import pj_mlfn from '../common/pj_mlfn';
+import pj_inv_mlfn from '../common/pj_inv_mlfn';
+import {EPSLN, HALF_PI} from '../common/constants';
+
+import asinz from '../common/asinz';
+
+function initialize(state: State): void {
+  /* Place parameters in static storage for common use
+    ------------------------------------------------- */
+  state.long0 = state.long0 || 0;
+
+  if (!state.sphere) {
+    state.en = pj_enfn(state.es);
+  } else {
+    state.n = 1;
+    state.m = 0;
+    state.es = 0;
+    state.C_y = Math.sqrt((state.m + 1) / state.n);
+    state.C_x = state.C_y / (state.m + 1);
+  }
+}
+
+/* Sinusoidal forward equations--mapping lat,long to x,y
+  ----------------------------------------------------- */
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var x, y;
+  var lon = p.x;
+  var lat = p.y;
+  /* Forward equations
+    ----------------- */
+  lon = adjust_lon(lon - state.long0, state.over);
+
+  if (state.sphere) {
+    if (!state.m) {
+      lat = state.n !== 1 ? Math.asin(state.n * Math.sin(lat)) : lat;
+    } else {
+      var k = state.n * Math.sin(lat);
+      for (var i = MAX_ITER; i; --i) {
+        var V = (state.m * lat + Math.sin(lat) - k) / (state.m + Math.cos(lat));
+        lat -= V;
+        if (Math.abs(V) < EPSLN) {
+          break;
+        }
+      }
+    }
+    x = state.a * state.C_x * lon * (state.m + Math.cos(lat));
+    y = state.a * state.C_y * lat;
+  } else {
+    var s = Math.sin(lat);
+    var c = Math.cos(lat);
+    y = state.a * pj_mlfn(lat, s, c, state.en);
+    x = (state.a * lon * c) / Math.sqrt(1 - state.es * s * s);
+  }
+
+  p.x = x;
+  p.y = y;
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var lat, temp, lon, s;
+
+  p.x -= state.x0;
+  lon = p.x / state.a;
+  p.y -= state.y0;
+  lat = p.y / state.a;
+
+  if (state.sphere) {
+    lat /= state.C_y;
+    lon = lon / (state.C_x * (state.m + Math.cos(lat)));
+    if (state.m) {
+      lat = asinz((state.m * lat + Math.sin(lat)) / state.n);
+    } else if (state.n !== 1) {
+      lat = asinz(Math.sin(lat) / state.n);
+    }
+    lon = adjust_lon(lon + state.long0, state.over);
+    lat = adjust_lat(lat);
+  } else {
+    lat = pj_inv_mlfn(p.y / state.a, state.es, state.en);
+    s = Math.abs(lat);
+    if (s < HALF_PI) {
+      s = Math.sin(lat);
+      temp = state.long0 + (p.x * Math.sqrt(1 - state.es * s * s)) / (state.a * Math.cos(lat));
+      // temp = state.long0 + p.x / (state.a * Math.cos(lat));
+      lon = adjust_lon(temp, state.over);
+    } else if (s - EPSLN < HALF_PI) {
+      lon = state.long0;
+    }
+  }
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, en: [], n: 0, m: 0, C_y: 0, C_x: 0, ...options};
+  initialize(state);
+  return state;
+}

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

@@ -0,0 +1,112 @@
+// 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 & {
+  lambda0: number;
+  rf: number;
+  R: number;
+  alpha: number;
+  b0: number;
+  K: number;
+};
+/*
+  references:
+    Formules et constantes pour le Calcul pour la
+    projection cylindrique conforme à axe oblique et pour la transformation entre
+    des systèmes de référence.
+    http://www.swisstopo.admin.ch/internet/swisstopo/fr/home/topics/survey/sys/refsys/switzerland.parsysrelated1.31216.downloadList.77004.DownloadFile.tmp/swissprojectionfr.pdf
+  */
+
+function initialize(state: State): void {
+  if (!state.k0) {
+    state.k0 = 1;
+  }
+  var phy0 = state.lat0;
+  state.lambda0 = state.long0;
+  var sinPhy0 = Math.sin(phy0);
+  var semiMajorAxis = state.a;
+  var invF = state.rf;
+  var flattening = 1 / invF;
+  var e2 = 2 * flattening - Math.pow(flattening, 2);
+  state.e = Math.sqrt(e2);
+  var e = state.e;
+  state.R = (state.k0 * semiMajorAxis * Math.sqrt(1 - e2)) / (1 - e2 * Math.pow(sinPhy0, 2));
+  state.alpha = Math.sqrt(1 + (e2 / (1 - e2)) * Math.pow(Math.cos(phy0), 4));
+  state.b0 = Math.asin(sinPhy0 / state.alpha);
+  var k1 = Math.log(Math.tan(Math.PI / 4 + state.b0 / 2));
+  var k2 = Math.log(Math.tan(Math.PI / 4 + phy0 / 2));
+  var k3 = Math.log((1 + e * sinPhy0) / (1 - e * sinPhy0));
+  state.K = k1 - state.alpha * k2 + ((state.alpha * e) / 2) * k3;
+}
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var Sa1 = Math.log(Math.tan(Math.PI / 4 - p.y / 2));
+  var Sa2 = (state.e / 2) * Math.log((1 + state.e * Math.sin(p.y)) / (1 - state.e * Math.sin(p.y)));
+  var S = -state.alpha * (Sa1 + Sa2) + state.K;
+
+  // spheric latitude
+  var b = 2 * (Math.atan(Math.exp(S)) - Math.PI / 4);
+
+  // spheric longitude
+  var I = state.alpha * (p.x - state.lambda0);
+
+  // psoeudo equatorial rotation
+  var rotI = Math.atan(
+    Math.sin(I) / (Math.sin(state.b0) * Math.tan(b) + Math.cos(state.b0) * Math.cos(I))
+  );
+
+  var rotB = Math.asin(
+    Math.cos(state.b0) * Math.sin(b) - Math.sin(state.b0) * Math.cos(b) * Math.cos(I)
+  );
+
+  p.y = (state.R / 2) * Math.log((1 + Math.sin(rotB)) / (1 - Math.sin(rotB))) + state.y0;
+  p.x = state.R * rotI + state.x0;
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var Y = p.x - state.x0;
+  var X = p.y - state.y0;
+
+  var rotI = Y / state.R;
+  var rotB = 2 * (Math.atan(Math.exp(X / state.R)) - Math.PI / 4);
+
+  var b = Math.asin(
+    Math.cos(state.b0) * Math.sin(rotB) + Math.sin(state.b0) * Math.cos(rotB) * Math.cos(rotI)
+  );
+  var I = Math.atan(
+    Math.sin(rotI) / (Math.cos(state.b0) * Math.cos(rotI) - Math.sin(state.b0) * Math.tan(rotB))
+  );
+
+  var lambda = state.lambda0 + I / state.alpha;
+
+  var S = 0;
+  var phy = b;
+  var prevPhy = -1000;
+  var iteration = 0;
+  while (Math.abs(phy - prevPhy) > 0.0000001) {
+    if (++iteration > 20) {
+      // ...reportError("omercFwdInfinity");
+      return undefined;
+    }
+    // S = Math.log(Math.tan(Math.PI / 4 + phy / 2));
+    S =
+      (1 / state.alpha) * (Math.log(Math.tan(Math.PI / 4 + b / 2)) - state.K) +
+      state.e * Math.log(Math.tan(Math.PI / 4 + Math.asin(state.e * Math.sin(phy)) / 2));
+    prevPhy = phy;
+    phy = 2 * Math.atan(Math.exp(S)) - Math.PI / 2;
+  }
+
+  p.x = lambda;
+  p.y = phy;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, lambda0: 0, rf: 0, R: 0, alpha: 0, b0: 0, K: 0, ...options};
+  initialize(state);
+  return state;
+}

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

@@ -0,0 +1,221 @@
+// 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 & {
+  coslat0: number;
+  sinlat0: number;
+  con: number;
+  cons: number;
+  ms1: number;
+  X0: number;
+  cosX0: number;
+  sinX0: number;
+};
+import {EPSLN, HALF_PI} from '../common/constants';
+
+import sign from '../common/sign';
+import msfnz from '../common/msfnz';
+import tsfnz from '../common/tsfnz';
+import phi2z from '../common/phi2z';
+import adjust_lon from '../common/adjust_lon';
+
+function ssfn_(phit: number, sinphi: number, eccen: number): number {
+  sinphi *= eccen;
+  return Math.tan(0.5 * (HALF_PI + phit)) * Math.pow((1 - sinphi) / (1 + sinphi), 0.5 * eccen);
+}
+
+function initialize(state: State): void {
+  // setting default parameters
+  state.x0 = state.x0 || 0;
+  state.y0 = state.y0 || 0;
+  state.lat0 = state.lat0 || 0;
+  state.long0 = state.long0 || 0;
+
+  state.coslat0 = Math.cos(state.lat0);
+  state.sinlat0 = Math.sin(state.lat0);
+  if (state.sphere) {
+    if (!Number.isNaN(state.lat_ts) && Math.abs(state.coslat0) <= EPSLN) {
+      state.k0 = 0.5 * (1 + sign(state.lat0) * Math.sin(state.lat_ts));
+    }
+  } else {
+    if (Math.abs(state.coslat0) <= EPSLN) {
+      if (state.lat0 > 0) {
+        // North pole
+        // trace('stere:north pole');
+        state.con = 1;
+      } else {
+        // South pole
+        // trace('stere:south pole');
+        state.con = -1;
+      }
+    }
+    state.cons = Math.sqrt(Math.pow(1 + state.e, 1 + state.e) * Math.pow(1 - state.e, 1 - state.e));
+    if (
+      !Number.isNaN(state.lat_ts) &&
+      Math.abs(state.coslat0) <= EPSLN &&
+      Math.abs(Math.cos(state.lat_ts)) > EPSLN
+    ) {
+      // Polar Stereographic variant B: k0 is derived from lat_ts (EPSG guidance note 7-2, method 9829)
+      // https://epsg.org/coord-operation-method_9829/Polar-Stereographic-variant-B.html
+      state.k0 =
+        (0.5 * state.cons * msfnz(state.e, Math.sin(state.lat_ts), Math.cos(state.lat_ts))) /
+        tsfnz(state.e, state.con * state.lat_ts, state.con * Math.sin(state.lat_ts));
+    }
+    state.ms1 = msfnz(state.e, state.sinlat0, state.coslat0);
+    state.X0 = 2 * Math.atan(ssfn_(state.lat0, state.sinlat0, state.e)) - HALF_PI;
+    state.cosX0 = Math.cos(state.X0);
+    state.sinX0 = Math.sin(state.X0);
+  }
+}
+
+// Stereographic forward equations--mapping lat,long to x,y
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var lon = p.x;
+  var lat = p.y;
+  var sinlat = Math.sin(lat);
+  var coslat = Math.cos(lat);
+  var A, X, sinX, cosX, ts, rh;
+  var dlon = adjust_lon(lon - state.long0, state.over);
+
+  if (
+    Math.abs(Math.abs(lon - state.long0) - Math.PI) <= EPSLN &&
+    Math.abs(lat + state.lat0) <= EPSLN
+  ) {
+    // case of the origine point
+    // trace('stere:this is the origin point');
+    p.x = NaN;
+    p.y = NaN;
+    return p;
+  }
+  if (state.sphere) {
+    // trace('stere:sphere case');
+    A = (2 * state.k0) / (1 + state.sinlat0 * sinlat + state.coslat0 * coslat * Math.cos(dlon));
+    p.x = state.a * A * coslat * Math.sin(dlon) + state.x0;
+    p.y =
+      state.a * A * (state.coslat0 * sinlat - state.sinlat0 * coslat * Math.cos(dlon)) + state.y0;
+    return p;
+  } else {
+    X = 2 * Math.atan(ssfn_(lat, sinlat, state.e)) - HALF_PI;
+    cosX = Math.cos(X);
+    sinX = Math.sin(X);
+    if (Math.abs(state.coslat0) <= EPSLN) {
+      ts = tsfnz(state.e, lat * state.con, state.con * sinlat);
+      rh = (2 * state.a * state.k0 * ts) / state.cons;
+      p.x = state.x0 + rh * Math.sin(lon - state.long0);
+      p.y = state.y0 - state.con * rh * Math.cos(lon - state.long0);
+      // trace(p.toString());
+      return p;
+    } else if (Math.abs(state.sinlat0) < EPSLN) {
+      // Eq
+      // trace('stere:equateur');
+      A = (2 * state.a * state.k0) / (1 + cosX * Math.cos(dlon));
+      // Correct the missing false northing in proj4js 2.22.0 equatorial stereographic.
+      p.y = A * sinX + state.y0;
+    } else {
+      // other case
+      // trace('stere:normal case');
+      A =
+        (2 * state.a * state.k0 * state.ms1) /
+        (state.cosX0 * (1 + state.sinX0 * sinX + state.cosX0 * cosX * Math.cos(dlon)));
+      p.y = A * (state.cosX0 * sinX - state.sinX0 * cosX * Math.cos(dlon)) + state.y0;
+    }
+    p.x = A * cosX * Math.sin(dlon) + state.x0;
+  }
+  // trace(p.toString());
+  return p;
+}
+
+//* Stereographic inverse equations--mapping x,y to lat/long
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  p.x -= state.x0;
+  p.y -= state.y0;
+  var lon, lat, ts, ce, Chi;
+  var rh = Math.sqrt(p.x * p.x + p.y * p.y);
+  if (state.sphere) {
+    var c = 2 * Math.atan(rh / (2 * state.a * state.k0));
+    lon = state.long0;
+    lat = state.lat0;
+    if (rh <= EPSLN) {
+      p.x = lon;
+      p.y = lat;
+      return p;
+    }
+    lat = Math.asin(Math.cos(c) * state.sinlat0 + (p.y * Math.sin(c) * state.coslat0) / rh);
+    if (Math.abs(state.coslat0) < EPSLN) {
+      if (state.lat0 > 0) {
+        lon = adjust_lon(state.long0 + Math.atan2(p.x, -1 * p.y), state.over);
+      } else {
+        lon = adjust_lon(state.long0 + Math.atan2(p.x, p.y), state.over);
+      }
+    } else {
+      lon = adjust_lon(
+        state.long0 +
+          Math.atan2(
+            p.x * Math.sin(c),
+            rh * state.coslat0 * Math.cos(c) - p.y * state.sinlat0 * Math.sin(c)
+          ),
+        state.over
+      );
+    }
+    p.x = lon;
+    p.y = lat;
+    return p;
+  } else {
+    if (Math.abs(state.coslat0) <= EPSLN) {
+      if (rh <= EPSLN) {
+        lat = state.lat0;
+        lon = state.long0;
+        p.x = lon;
+        p.y = lat;
+        // trace(p.toString());
+        return p;
+      }
+      p.x *= state.con;
+      p.y *= state.con;
+      ts = (rh * state.cons) / (2 * state.a * state.k0);
+      lat = state.con * phi2z(state.e, ts);
+      lon = state.con * adjust_lon(state.con * state.long0 + Math.atan2(p.x, -1 * p.y), state.over);
+    } else {
+      ce = 2 * Math.atan((rh * state.cosX0) / (2 * state.a * state.k0 * state.ms1));
+      lon = state.long0;
+      if (rh <= EPSLN) {
+        Chi = state.X0;
+      } else {
+        Chi = Math.asin(Math.cos(ce) * state.sinX0 + (p.y * Math.sin(ce) * state.cosX0) / rh);
+        lon = adjust_lon(
+          state.long0 +
+            Math.atan2(
+              p.x * Math.sin(ce),
+              rh * state.cosX0 * Math.cos(ce) - p.y * state.sinX0 * Math.sin(ce)
+            ),
+          state.over
+        );
+      }
+      lat = -1 * phi2z(state.e, Math.tan(0.5 * (HALF_PI + Chi)));
+    }
+  }
+  p.x = lon;
+  p.y = lat;
+
+  // trace(p.toString());
+  return p;
+}
+
+export function createState(base: KernelParameters): State {
+  const state: State = {
+    ...base,
+    coslat0: 0,
+    sinlat0: 0,
+    con: 0,
+    cons: 0,
+    ms1: 0,
+    X0: 0,
+    cosX0: 0,
+    sinX0: 0
+  };
+  initialize(state);
+  return state;
+}

package/src/projection/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;
+}