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

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

@@ -0,0 +1,183 @@
+// 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 & {
+  flip_axis: number;
+  sweep: string;
+  h: number;
+  radius_g_1: number;
+  radius_g: number;
+  C: number;
+  radius_p: number;
+  radius_p2: number;
+  radius_p_inv2: number;
+  shape: string;
+};
+import hypot from '../common/hypot';
+
+function initialize(state: State): void {
+  state.flip_axis = state.sweep === 'x' ? 1 : 0;
+  state.h = Number(state.h);
+  state.radius_g_1 = state.h / state.a;
+
+  if (state.radius_g_1 <= 0 || state.radius_g_1 > 1e10) {
+    throw new Error();
+  }
+
+  state.radius_g = 1.0 + state.radius_g_1;
+  state.C = state.radius_g * state.radius_g - 1.0;
+
+  if (state.es !== 0.0) {
+    var one_es = 1.0 - state.es;
+    var rone_es = 1 / one_es;
+
+    state.radius_p = Math.sqrt(one_es);
+    state.radius_p2 = one_es;
+    state.radius_p_inv2 = rone_es;
+
+    state.shape = 'ellipse'; // Use as a condition in the forward and inverse functions.
+  } else {
+    state.radius_p = 1.0;
+    state.radius_p2 = 1.0;
+    state.radius_p_inv2 = 1.0;
+
+    state.shape = 'sphere'; // Use as a condition in the forward and inverse functions.
+  }
+}
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var lon = p.x;
+  var lat = p.y;
+  var tmp, v_x, v_y, v_z;
+  lon = lon - state.long0;
+
+  if (state.shape === 'ellipse') {
+    lat = Math.atan(state.radius_p2 * Math.tan(lat));
+    var r = state.radius_p / hypot(state.radius_p * Math.cos(lat), Math.sin(lat));
+
+    v_x = r * Math.cos(lon) * Math.cos(lat);
+    v_y = r * Math.sin(lon) * Math.cos(lat);
+    v_z = r * Math.sin(lat);
+
+    if ((state.radius_g - v_x) * v_x - v_y * v_y - v_z * v_z * state.radius_p_inv2 < 0.0) {
+      p.x = Number.NaN;
+      p.y = Number.NaN;
+      return p;
+    }
+
+    tmp = state.radius_g - v_x;
+    if (state.flip_axis) {
+      p.x = state.radius_g_1 * Math.atan(v_y / hypot(v_z, tmp));
+      p.y = state.radius_g_1 * Math.atan(v_z / tmp);
+    } else {
+      p.x = state.radius_g_1 * Math.atan(v_y / tmp);
+      p.y = state.radius_g_1 * Math.atan(v_z / hypot(v_y, tmp));
+    }
+  } else if (state.shape === 'sphere') {
+    tmp = Math.cos(lat);
+    v_x = Math.cos(lon) * tmp;
+    v_y = Math.sin(lon) * tmp;
+    v_z = Math.sin(lat);
+    tmp = state.radius_g - v_x;
+
+    if (state.flip_axis) {
+      p.x = state.radius_g_1 * Math.atan(v_y / hypot(v_z, tmp));
+      p.y = state.radius_g_1 * Math.atan(v_z / tmp);
+    } else {
+      p.x = state.radius_g_1 * Math.atan(v_y / tmp);
+      p.y = state.radius_g_1 * Math.atan(v_z / hypot(v_y, tmp));
+    }
+  }
+  p.x = p.x * state.a;
+  p.y = p.y * state.a;
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var v_x = -1.0;
+  var v_y = 0.0;
+  var v_z = 0.0;
+  var a, b, det, k;
+
+  p.x = p.x / state.a;
+  p.y = p.y / state.a;
+
+  if (state.shape === 'ellipse') {
+    if (state.flip_axis) {
+      v_z = Math.tan(p.y / state.radius_g_1);
+      v_y = Math.tan(p.x / state.radius_g_1) * hypot(1.0, v_z);
+    } else {
+      v_y = Math.tan(p.x / state.radius_g_1);
+      v_z = Math.tan(p.y / state.radius_g_1) * hypot(1.0, v_y);
+    }
+
+    var v_zp = v_z / state.radius_p;
+    a = v_y * v_y + v_zp * v_zp + v_x * v_x;
+    b = 2 * state.radius_g * v_x;
+    det = b * b - 4 * a * state.C;
+
+    if (det < 0.0) {
+      p.x = Number.NaN;
+      p.y = Number.NaN;
+      return p;
+    }
+
+    k = (-b - Math.sqrt(det)) / (2.0 * a);
+    v_x = state.radius_g + k * v_x;
+    v_y *= k;
+    v_z *= k;
+
+    p.x = Math.atan2(v_y, v_x);
+    p.y = Math.atan((v_z * Math.cos(p.x)) / v_x);
+    p.y = Math.atan(state.radius_p_inv2 * Math.tan(p.y));
+  } else if (state.shape === 'sphere') {
+    if (state.flip_axis) {
+      v_z = Math.tan(p.y / state.radius_g_1);
+      v_y = Math.tan(p.x / state.radius_g_1) * Math.sqrt(1.0 + v_z * v_z);
+    } else {
+      v_y = Math.tan(p.x / state.radius_g_1);
+      v_z = Math.tan(p.y / state.radius_g_1) * Math.sqrt(1.0 + v_y * v_y);
+    }
+
+    a = v_y * v_y + v_z * v_z + v_x * v_x;
+    b = 2 * state.radius_g * v_x;
+    det = b * b - 4 * a * state.C;
+    if (det < 0.0) {
+      p.x = Number.NaN;
+      p.y = Number.NaN;
+      return p;
+    }
+
+    k = (-b - Math.sqrt(det)) / (2.0 * a);
+    v_x = state.radius_g + k * v_x;
+    v_y *= k;
+    v_z *= k;
+
+    p.x = Math.atan2(v_y, v_x);
+    p.y = Math.atan((v_z * Math.cos(p.x)) / v_x);
+  }
+  p.x = p.x + state.long0;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {
+    ...base,
+    flip_axis: 0,
+    sweep: '',
+    h: 0,
+    radius_g_1: 0,
+    radius_g: 0,
+    C: 0,
+    radius_p: 0,
+    radius_p2: 0,
+    radius_p_inv2: 0,
+    shape: '',
+    ...options
+  };
+  initialize(state);
+  return state;
+}

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

@@ -0,0 +1,113 @@
+// 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 & {
+  sin_p14: number;
+  cos_p14: number;
+  infinity_dist: number;
+  rc: number;
+  phic0: number;
+};
+import adjust_lon from '../common/adjust_lon';
+import asinz from '../common/asinz';
+import {EPSLN} from '../common/constants';
+
+function initialize(state: State): void {
+  /* Place parameters in static storage for common use
+      ------------------------------------------------- */
+  state.sin_p14 = Math.sin(state.lat0);
+  state.cos_p14 = Math.cos(state.lat0);
+  // Approximation for projecting points to the horizon (infinity)
+  state.infinity_dist = 1000 * state.a;
+  state.rc = 1;
+}
+
+/* Gnomonic forward equations--mapping lat,long to x,y
+    --------------------------------------------------- */
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var sinphi, cosphi; /* sin and cos value        */
+  var dlon; /* delta longitude value      */
+  var coslon; /* cos of longitude        */
+  var ksp; /* scale factor          */
+  var g;
+  var x, y;
+  var lon = p.x;
+  var lat = p.y;
+  /* Forward equations
+      ----------------- */
+  dlon = adjust_lon(lon - state.long0, state.over);
+
+  sinphi = Math.sin(lat);
+  cosphi = Math.cos(lat);
+
+  coslon = Math.cos(dlon);
+  g = state.sin_p14 * sinphi + state.cos_p14 * cosphi * coslon;
+  ksp = 1;
+  if (g > 0 || Math.abs(g) <= EPSLN) {
+    x = state.x0 + (state.a * ksp * cosphi * Math.sin(dlon)) / g;
+    y = state.y0 + (state.a * ksp * (state.cos_p14 * sinphi - state.sin_p14 * cosphi * coslon)) / g;
+  } else {
+    // Point is in the opposing hemisphere and is unprojectable
+    // We still need to return a reasonable point, so we project
+    // to infinity, on a bearing
+    // equivalent to the northern hemisphere equivalent
+    // This is a reasonable approximation for short shapes and lines that
+    // straddle the horizon.
+
+    x = state.x0 + state.infinity_dist * cosphi * Math.sin(dlon);
+    y = state.y0 + state.infinity_dist * (state.cos_p14 * sinphi - state.sin_p14 * cosphi * coslon);
+  }
+  p.x = x;
+  p.y = y;
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var rh; /* Rho */
+  var sinc, cosc;
+  var c;
+  var lon, lat;
+
+  /* Inverse equations
+      ----------------- */
+  p.x = (p.x - state.x0) / state.a;
+  p.y = (p.y - state.y0) / state.a;
+
+  p.x /= state.k0;
+  p.y /= state.k0;
+
+  rh = Math.sqrt(p.x * p.x + p.y * p.y);
+  if (rh) {
+    c = Math.atan2(rh, state.rc);
+    sinc = Math.sin(c);
+    cosc = Math.cos(c);
+
+    lat = asinz(cosc * state.sin_p14 + (p.y * sinc * state.cos_p14) / rh);
+    lon = Math.atan2(p.x * sinc, rh * state.cos_p14 * cosc - p.y * state.sin_p14 * sinc);
+    lon = adjust_lon(state.long0 + lon, state.over);
+  } else {
+    lat = state.lat0;
+    lon = state.long0;
+  }
+
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {
+    ...base,
+    sin_p14: 0,
+    cos_p14: 0,
+    infinity_dist: 0,
+    rc: 0,
+    phic0: 0,
+    ...options
+  };
+  initialize(state);
+  return state;
+}

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

@@ -0,0 +1,74 @@
+// 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 & {
+  lc: number;
+  rs: number;
+  cp: number;
+  n2: number;
+  xs: number;
+  ys: number;
+};
+import latiso from '../common/latiso';
+import sinh from '../common/sinh';
+import cosh from '../common/cosh';
+import invlatiso from '../common/invlatiso';
+
+function initialize(state: State): void {
+  // array of:  a, b, lon0, lat0, k0, x0, y0
+  if (!state.k0) {
+    state.k0 = 1;
+  }
+  var temp = state.b / state.a;
+  state.e = Math.sqrt(1 - temp * temp);
+  state.lc = state.long0;
+  state.rs = Math.sqrt(
+    1 + (state.e * state.e * Math.pow(Math.cos(state.lat0), 4)) / (1 - state.e * state.e)
+  );
+  var sinz = Math.sin(state.lat0);
+  var pc = Math.asin(sinz / state.rs);
+  var sinzpc = Math.sin(pc);
+  state.cp = latiso(0, pc, sinzpc) - state.rs * latiso(state.e, state.lat0, sinz);
+  state.n2 =
+    (state.k0 * state.a * Math.sqrt(1 - state.e * state.e)) / (1 - state.e * state.e * sinz * sinz);
+  state.xs = state.x0;
+  state.ys = state.y0 - state.n2 * pc;
+}
+
+// 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 L = state.rs * (lon - state.lc);
+  var Ls = state.cp + state.rs * latiso(state.e, lat, Math.sin(lat));
+  var lat1 = Math.asin(Math.sin(L) / cosh(Ls));
+  var Ls1 = latiso(0, lat1, Math.sin(lat1));
+  p.x = state.xs + state.n2 * Ls1;
+  p.y = state.ys + state.n2 * Math.atan(sinh(Ls) / Math.cos(L));
+  return p;
+}
+
+// inverse equations--mapping x,y to lat/long
+// -----------------------------------------------------------------
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var x = p.x;
+  var y = p.y;
+
+  var L = Math.atan(sinh((x - state.xs) / state.n2) / Math.cos((y - state.ys) / state.n2));
+  var lat1 = Math.asin(Math.sin((y - state.ys) / state.n2) / cosh((x - state.xs) / state.n2));
+  var LC = latiso(0, lat1, Math.sin(lat1));
+  p.x = state.lc + L / state.rs;
+  p.y = invlatiso(state.e, (LC - state.cp) / state.rs);
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, lc: 0, rs: 0, cp: 0, n2: 0, xs: 0, ys: 0, ...options};
+  initialize(state);
+  return state;
+}

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

@@ -0,0 +1,166 @@
+// 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 & {
+  s45: number;
+  s90: number;
+  fi0: number;
+  e2: number;
+  alfa: number;
+  uq: number;
+  u0: number;
+  g: number;
+  k: number;
+  k1: number;
+  n0: number;
+  s0: number;
+  n: number;
+  ro0: number;
+  ad: number;
+  czech: boolean;
+};
+import adjust_lon from '../common/adjust_lon';
+
+function initialize(state: State): void {
+  state.a = 6377397.155;
+  state.es = 0.006674372230614;
+  state.e = Math.sqrt(state.es);
+
+  /* if scale not set default to 0.9999 */
+
+  state.s45 = 0.785398163397448; /* 45 */
+  state.s90 = 2 * state.s45;
+  state.fi0 = state.lat0;
+  state.e2 = state.es;
+  state.e = Math.sqrt(state.e2);
+  state.alfa = Math.sqrt(1 + (state.e2 * Math.pow(Math.cos(state.fi0), 4)) / (1 - state.e2));
+  state.uq = 1.04216856380474;
+  state.u0 = Math.asin(Math.sin(state.fi0) / state.alfa);
+  state.g = Math.pow(
+    (1 + state.e * Math.sin(state.fi0)) / (1 - state.e * Math.sin(state.fi0)),
+    (state.alfa * state.e) / 2
+  );
+  state.k =
+    (Math.tan(state.u0 / 2 + state.s45) /
+      Math.pow(Math.tan(state.fi0 / 2 + state.s45), state.alfa)) *
+    state.g;
+  state.k1 = state.k0;
+  state.n0 =
+    (state.a * Math.sqrt(1 - state.e2)) / (1 - state.e2 * Math.pow(Math.sin(state.fi0), 2));
+  state.s0 = 1.37008346281555;
+  state.n = Math.sin(state.s0);
+  state.ro0 = (state.k1 * state.n0) / Math.tan(state.s0);
+  state.ad = state.s90 - state.uq;
+}
+
+/* ellipsoid */
+/* calculate xy from lat/lon */
+/* Constants, identical to inverse transform function */
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var gfi, u, deltav, s, d, eps, ro;
+  var lon = p.x;
+  var lat = p.y;
+  var delta_lon = adjust_lon(lon - state.long0, state.over);
+  /* Transformation */
+  gfi = Math.pow(
+    (1 + state.e * Math.sin(lat)) / (1 - state.e * Math.sin(lat)),
+    (state.alfa * state.e) / 2
+  );
+  u =
+    2 *
+    (Math.atan((state.k * Math.pow(Math.tan(lat / 2 + state.s45), state.alfa)) / gfi) - state.s45);
+  deltav = -delta_lon * state.alfa;
+  s = Math.asin(
+    Math.cos(state.ad) * Math.sin(u) + Math.sin(state.ad) * Math.cos(u) * Math.cos(deltav)
+  );
+  d = Math.asin((Math.cos(u) * Math.sin(deltav)) / Math.cos(s));
+  eps = state.n * d;
+  ro =
+    (state.ro0 * Math.pow(Math.tan(state.s0 / 2 + state.s45), state.n)) /
+    Math.pow(Math.tan(s / 2 + state.s45), state.n);
+  p.y = (ro * Math.cos(eps)) / 1;
+  p.x = (ro * Math.sin(eps)) / 1;
+
+  if (!state.czech) {
+    p.y *= -1;
+    p.x *= -1;
+  }
+  return p;
+}
+
+/* calculate lat/lon from xy */
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var u, deltav, s, d, eps, ro, fi1;
+  var ok;
+
+  /* Transformation */
+  /* revert y, x */
+  var tmp = p.x;
+  p.x = p.y;
+  p.y = tmp;
+  if (!state.czech) {
+    p.y *= -1;
+    p.x *= -1;
+  }
+  ro = Math.sqrt(p.x * p.x + p.y * p.y);
+  eps = Math.atan2(p.y, p.x);
+  d = eps / Math.sin(state.s0);
+  s =
+    2 *
+    (Math.atan(Math.pow(state.ro0 / ro, 1 / state.n) * Math.tan(state.s0 / 2 + state.s45)) -
+      state.s45);
+  u = Math.asin(Math.cos(state.ad) * Math.sin(s) - Math.sin(state.ad) * Math.cos(s) * Math.cos(d));
+  deltav = Math.asin((Math.cos(s) * Math.sin(d)) / Math.cos(u));
+  p.x = state.long0 - deltav / state.alfa;
+  fi1 = u;
+  ok = 0;
+  var iter = 0;
+  do {
+    p.y =
+      2 *
+      (Math.atan(
+        Math.pow(state.k, -1 / state.alfa) *
+          Math.pow(Math.tan(u / 2 + state.s45), 1 / state.alfa) *
+          Math.pow((1 + state.e * Math.sin(fi1)) / (1 - state.e * Math.sin(fi1)), state.e / 2)
+      ) -
+        state.s45);
+    if (Math.abs(fi1 - p.y) < 0.0000000001) {
+      ok = 1;
+    }
+    fi1 = p.y;
+    iter += 1;
+  } while (ok === 0 && iter < 15);
+  if (iter >= 15) {
+    return null;
+  }
+
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {
+    ...base,
+    s45: 0,
+    s90: 0,
+    fi0: 0,
+    e2: 0,
+    alfa: 0,
+    uq: 0,
+    u0: 0,
+    g: 0,
+    k: 0,
+    k1: 0,
+    n0: 0,
+    s0: 0,
+    n: 0,
+    ro0: 0,
+    ad: 0,
+    czech: false,
+    ...options
+  };
+  initialize(state);
+  return state;
+}