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

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

package/src/experimental/kernels/laea.ts

@@ -0,0 +1,297 @@
+// 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 & {
+  mode: number;
+  qp: number;
+  mmf: number;
+  apa: number[];
+  dd: number;
+  rq: number;
+  xmf: number;
+  ymf: number;
+  sinb1: number;
+  cosb1: number;
+  sinph0: number;
+  cosph0: number;
+};
+import {HALF_PI, EPSLN, FORTPI} from '../common/constants';
+
+import qsfnz from '../common/qsfnz';
+import adjust_lon from '../common/adjust_lon';
+import authset from '../common/authset';
+import authlat from '../common/authlat';
+
+/*
+  reference
+    "New Equal-Area Map Projections for Noncircular Regions", John P. Snyder,
+    The American Cartographer, Vol 15, No. 4, October 1988, pp. 341-355.
+  */
+
+export var S_POLE = 1;
+export var N_POLE = 2;
+export var EQUIT = 3;
+export var OBLIQ = 4;
+
+function initialize(state: State): void {
+  var t = Math.abs(state.lat0);
+  if (Math.abs(t - HALF_PI) < EPSLN) {
+    state.mode = state.lat0 < 0 ? S_POLE : N_POLE;
+  } else if (Math.abs(t) < EPSLN) {
+    state.mode = EQUIT;
+  } else {
+    state.mode = OBLIQ;
+  }
+  if (state.es > 0) {
+    var sinphi;
+
+    state.qp = qsfnz(state.e, 1);
+    state.mmf = 0.5 / (1 - state.es);
+    state.apa = authset(state.es);
+    switch (state.mode) {
+      case N_POLE:
+        state.dd = 1;
+        break;
+      case S_POLE:
+        state.dd = 1;
+        break;
+      case EQUIT:
+        state.rq = Math.sqrt(0.5 * state.qp);
+        state.dd = 1 / state.rq;
+        state.xmf = 1;
+        state.ymf = 0.5 * state.qp;
+        break;
+      case OBLIQ:
+        state.rq = Math.sqrt(0.5 * state.qp);
+        sinphi = Math.sin(state.lat0);
+        state.sinb1 = qsfnz(state.e, sinphi) / state.qp;
+        state.cosb1 = Math.sqrt(1 - state.sinb1 * state.sinb1);
+        state.dd =
+          Math.cos(state.lat0) /
+          (Math.sqrt(1 - state.es * sinphi * sinphi) * state.rq * state.cosb1);
+        state.xmf = state.rq;
+        state.ymf = state.xmf / state.dd;
+        state.xmf *= state.dd;
+        break;
+    }
+  } else {
+    if (state.mode === OBLIQ) {
+      state.sinph0 = Math.sin(state.lat0);
+      state.cosph0 = Math.cos(state.lat0);
+    }
+  }
+}
+
+/* Lambert Azimuthal Equal Area forward equations--mapping lat,long to x,y
+  ----------------------------------------------------------------------- */
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  /* Forward equations
+      ----------------- */
+  var x, y, coslam, sinlam, sinphi, q, sinb, cosb, b, cosphi;
+  var lam = p.x;
+  var phi = p.y;
+
+  lam = adjust_lon(lam - state.long0, state.over);
+  if (state.sphere) {
+    sinphi = Math.sin(phi);
+    cosphi = Math.cos(phi);
+    coslam = Math.cos(lam);
+    if (state.mode === OBLIQ || state.mode === EQUIT) {
+      y =
+        state.mode === EQUIT
+          ? 1 + cosphi * coslam
+          : 1 + state.sinph0 * sinphi + state.cosph0 * cosphi * coslam;
+      if (y <= EPSLN) {
+        return null;
+      }
+      y = Math.sqrt(2 / y);
+      x = y * cosphi * Math.sin(lam);
+      y *= state.mode === EQUIT ? sinphi : state.cosph0 * sinphi - state.sinph0 * cosphi * coslam;
+    } else if (state.mode === N_POLE || state.mode === S_POLE) {
+      if (state.mode === N_POLE) {
+        coslam = -coslam;
+      }
+      if (Math.abs(phi + state.lat0) < EPSLN) {
+        return null;
+      }
+      y = FORTPI - phi * 0.5;
+      y = 2 * (state.mode === S_POLE ? Math.cos(y) : Math.sin(y));
+      x = y * Math.sin(lam);
+      y *= coslam;
+    }
+  } else {
+    sinb = 0;
+    cosb = 0;
+    b = 0;
+    coslam = Math.cos(lam);
+    sinlam = Math.sin(lam);
+    sinphi = Math.sin(phi);
+    q = qsfnz(state.e, sinphi);
+    if (state.mode === OBLIQ || state.mode === EQUIT) {
+      sinb = q / state.qp;
+      cosb = Math.sqrt(1 - sinb * sinb);
+    }
+    switch (state.mode) {
+      case OBLIQ:
+        b = 1 + state.sinb1 * sinb + state.cosb1 * cosb * coslam;
+        break;
+      case EQUIT:
+        b = 1 + cosb * coslam;
+        break;
+      case N_POLE:
+        b = HALF_PI + phi;
+        q = state.qp - q;
+        break;
+      case S_POLE:
+        b = phi - HALF_PI;
+        q = state.qp + q;
+        break;
+    }
+    if (Math.abs(b) < EPSLN) {
+      return null;
+    }
+    switch (state.mode) {
+      case OBLIQ:
+      case EQUIT:
+        b = Math.sqrt(2 / b);
+        if (state.mode === OBLIQ) {
+          y = state.ymf * b * (state.cosb1 * sinb - state.sinb1 * cosb * coslam);
+        } else {
+          b = Math.sqrt(2 / (1 + cosb * coslam));
+          y = b * sinb * state.ymf;
+        }
+        x = state.xmf * b * cosb * sinlam;
+        break;
+      case N_POLE:
+      case S_POLE:
+        if (q >= 0) {
+          b = Math.sqrt(q);
+          x = b * sinlam;
+          y = coslam * (state.mode === S_POLE ? b : -b);
+        } else {
+          x = y = 0;
+        }
+        break;
+    }
+  }
+
+  p.x = state.a * x + state.x0;
+  p.y = state.a * y + state.y0;
+  return p;
+}
+
+/* Inverse equations
+  ----------------- */
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  p.x -= state.x0;
+  p.y -= state.y0;
+  var x = p.x / state.a;
+  var y = p.y / state.a;
+  var lam, phi, cCe, sCe, q, rho, ab;
+  if (state.sphere) {
+    var cosz = 0,
+      rh,
+      sinz = 0;
+
+    rh = Math.sqrt(x * x + y * y);
+    phi = rh * 0.5;
+    if (phi > 1) {
+      return null;
+    }
+    phi = 2 * Math.asin(phi);
+    if (state.mode === OBLIQ || state.mode === EQUIT) {
+      sinz = Math.sin(phi);
+      cosz = Math.cos(phi);
+    }
+    switch (state.mode) {
+      case EQUIT:
+        phi = Math.abs(rh) <= EPSLN ? 0 : Math.asin((y * sinz) / rh);
+        x *= sinz;
+        y = cosz * rh;
+        break;
+      case OBLIQ:
+        phi =
+          Math.abs(rh) <= EPSLN
+            ? state.lat0
+            : Math.asin(cosz * state.sinph0 + (y * sinz * state.cosph0) / rh);
+        x *= sinz * state.cosph0;
+        y = (cosz - Math.sin(phi) * state.sinph0) * rh;
+        break;
+      case N_POLE:
+        y = -y;
+        phi = HALF_PI - phi;
+        break;
+      case S_POLE:
+        phi -= HALF_PI;
+        break;
+    }
+    lam = y === 0 && (state.mode === EQUIT || state.mode === OBLIQ) ? 0 : Math.atan2(x, y);
+  } else {
+    ab = 0;
+    if (state.mode === OBLIQ || state.mode === EQUIT) {
+      x /= state.dd;
+      y *= state.dd;
+      rho = Math.sqrt(x * x + y * y);
+      if (rho < EPSLN) {
+        p.x = state.long0;
+        p.y = state.lat0;
+        return p;
+      }
+      sCe = 2 * Math.asin((0.5 * rho) / state.rq);
+      cCe = Math.cos(sCe);
+      x *= sCe = Math.sin(sCe);
+      if (state.mode === OBLIQ) {
+        ab = cCe * state.sinb1 + (y * sCe * state.cosb1) / rho;
+        q = state.qp * ab;
+        y = rho * state.cosb1 * cCe - y * state.sinb1 * sCe;
+      } else {
+        ab = (y * sCe) / rho;
+        q = state.qp * ab;
+        y = rho * cCe;
+      }
+    } else if (state.mode === N_POLE || state.mode === S_POLE) {
+      if (state.mode === N_POLE) {
+        y = -y;
+      }
+      q = x * x + y * y;
+      if (!q) {
+        p.x = state.long0;
+        p.y = state.lat0;
+        return p;
+      }
+      ab = 1 - q / state.qp;
+      if (state.mode === S_POLE) {
+        ab = -ab;
+      }
+    }
+    lam = Math.atan2(x, y);
+    phi = authlat(Math.asin(ab), state.apa);
+  }
+
+  p.x = adjust_lon(state.long0 + lam, state.over);
+  p.y = phi;
+  return p;
+}
+
+export function createState(base: KernelParameters): State {
+  const state: State = {
+    ...base,
+    mode: 0,
+    qp: 0,
+    mmf: 0,
+    apa: [],
+    dd: 0,
+    rq: 0,
+    xmf: 0,
+    ymf: 0,
+    sinb1: 0,
+    cosb1: 0,
+    sinph0: 0,
+    cosph0: 0
+  };
+  initialize(state);
+  return state;
+}

package/src/experimental/kernels/lcc.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 & {
+  ns: number;
+  f0: number;
+  rh: number;
+};
+import msfnz from '../common/msfnz';
+import tsfnz from '../common/tsfnz';
+import sign from '../common/sign';
+import adjust_lon from '../common/adjust_lon';
+import phi2z from '../common/phi2z';
+import {HALF_PI, EPSLN} from '../common/constants';
+
+function initialize(state: State): void {
+  // double lat0;                    /* the reference latitude               */
+  // double long0;                   /* the reference longitude              */
+  // double lat1;                    /* first standard parallel              */
+  // double lat2;                    /* second standard parallel             */
+  // double r_maj;                   /* major axis                           */
+  // double r_min;                   /* minor axis                           */
+  // double false_east;              /* x offset in meters                   */
+  // double false_north;             /* y offset in meters                   */
+
+  // the above value can be set with proj4.defs
+  // example: proj4.defs("EPSG:2154","+proj=lcc +lat_1=49 +lat_2=44 +lat_0=46.5 +lon_0=3 +x_0=700000 +y_0=6600000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs");
+
+  // kernelParameters defaults omitted parallels; an explicit zero is meaningful.
+  if (!state.k0) {
+    state.k0 = 1;
+  }
+  state.x0 = state.x0 || 0;
+  state.y0 = state.y0 || 0;
+  state.long0 = state.long0 || 0;
+  // Standard Parallels cannot be equal and on opposite sides of the equator
+  if (Math.abs(state.lat1 + state.lat2) < EPSLN) {
+    return;
+  }
+
+  var temp = state.b / state.a;
+  state.e = Math.sqrt(1 - temp * temp);
+
+  var sin1 = Math.sin(state.lat1);
+  var cos1 = Math.cos(state.lat1);
+  var ms1 = msfnz(state.e, sin1, cos1);
+  var ts1 = tsfnz(state.e, state.lat1, sin1);
+
+  var sin2 = Math.sin(state.lat2);
+  var cos2 = Math.cos(state.lat2);
+  var ms2 = msfnz(state.e, sin2, cos2);
+  var ts2 = tsfnz(state.e, state.lat2, sin2);
+  var ts0 = tsfnz(state.e, state.lat0, Math.sin(state.lat0));
+
+  if (Math.abs(state.lat1 - state.lat2) > EPSLN) {
+    state.ns = Math.log(ms1 / ms2) / Math.log(ts1 / ts2);
+  } else {
+    state.ns = sin1;
+  }
+  if (Number.isNaN(state.ns)) {
+    state.ns = sin1;
+  }
+  state.f0 = ms1 / (state.ns * Math.pow(ts1, state.ns));
+  state.rh =
+    Math.abs(Math.abs(state.lat0) - HALF_PI) < EPSLN
+      ? 0 // Handle poles by setting rh to 0
+      : state.a * state.f0 * Math.pow(ts0, state.ns);
+}
+
+// Lambert Conformal conic 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;
+
+  // singular cases :
+  if (Math.abs(2 * Math.abs(lat) - Math.PI) <= EPSLN) {
+    lat = sign(lat) * (HALF_PI - 2 * EPSLN);
+  }
+
+  var con = Math.abs(Math.abs(lat) - HALF_PI);
+  var ts, rh1;
+  if (con > EPSLN) {
+    ts = tsfnz(state.e, lat, Math.sin(lat));
+    rh1 = state.a * state.f0 * Math.pow(ts, state.ns);
+  } else {
+    con = lat * state.ns;
+    if (con <= 0) {
+      return null;
+    }
+    rh1 = 0;
+  }
+  var theta = state.ns * adjust_lon(lon - state.long0, state.over);
+  p.x = state.k0 * (rh1 * Math.sin(theta)) + state.x0;
+  p.y = state.k0 * (state.rh - rh1 * Math.cos(theta)) + state.y0;
+
+  return p;
+}
+
+// Lambert Conformal Conic inverse equations--mapping x,y to lat/long
+// -----------------------------------------------------------------
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var rh1, con, ts;
+  var lat, lon;
+  var x = (p.x - state.x0) / state.k0;
+  var y = state.rh - (p.y - state.y0) / state.k0;
+  if (state.ns > 0) {
+    rh1 = Math.sqrt(x * x + y * y);
+    con = 1;
+  } else {
+    rh1 = -Math.sqrt(x * x + y * y);
+    con = -1;
+  }
+  var theta = 0;
+  if (rh1 !== 0) {
+    theta = Math.atan2(con * x, con * y);
+  }
+  if (rh1 !== 0 || state.ns > 0) {
+    con = 1 / state.ns;
+    ts = Math.pow(rh1 / (state.a * state.f0), con);
+    lat = phi2z(state.e, ts);
+    if (lat === -9999) {
+      return null;
+    }
+  } else {
+    lat = -HALF_PI;
+  }
+  lon = adjust_lon(theta / state.ns + state.long0, state.over);
+
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+export function createState(base: KernelParameters): State {
+  const state: State = {
+    ...base,
+    ns: 0,
+    f0: 0,
+    rh: 0
+  };
+  initialize(state);
+  return state;
+}

package/src/experimental/kernels/mill.ts

@@ -0,0 +1,60 @@
+// 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 & {};
+import adjust_lon from '../common/adjust_lon';
+
+/*
+  reference
+    "New Equal-Area Map Projections for Noncircular Regions", John P. Snyder,
+    The American Cartographer, Vol 15, No. 4, October 1988, pp. 341-355.
+  */
+
+/* Initialize the Miller Cylindrical projection
+  ------------------------------------------- */
+function initialize(state: State): void {
+  // no-op
+}
+
+/* Miller Cylindrical 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;
+  /* Forward equations
+      ----------------- */
+  var dlon = adjust_lon(lon - state.long0, state.over);
+  var x = state.x0 + state.a * dlon;
+  var y = state.y0 + state.a * Math.log(Math.tan(Math.PI / 4 + lat / 2.5)) * 1.25;
+
+  p.x = x;
+  p.y = y;
+  return p;
+}
+
+/* Miller Cylindrical 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 = adjust_lon(state.long0 + p.x / state.a, state.over);
+  var lat = 2.5 * (Math.atan(Math.exp((0.8 * p.y) / state.a)) - Math.PI / 4);
+
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {
+    ...base,
+
+    ...options
+  };
+  initialize(state);
+  return state;
+}