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

package/src/experimental/kernels/ortho.ts

@@ -0,0 +1,106 @@
+// 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;
+};
+import adjust_lon from '../common/adjust_lon';
+import asinz from '../common/asinz';
+import {EPSLN, HALF_PI} from '../common/constants';
+
+function initialize(state: State): void {
+  // double temp;      /* temporary variable    */
+
+  /* Place parameters in static storage for common use
+      ------------------------------------------------- */
+  state.sin_p14 = Math.sin(state.lat0 || 0);
+  state.cos_p14 = Math.cos(state.lat0 || 0);
+}
+
+/* Orthographic 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, x, y;
+  var lon = p.x;
+  var lat = p.y;
+  /* Forward equations
+      ----------------- */
+  dlon = adjust_lon(lon - (state.long0 || 0), 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 || 0) + state.a * ksp * cosphi * Math.sin(dlon);
+    y =
+      (state.y0 || 0) + state.a * ksp * (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; /* height above ellipsoid      */
+  var z; /* angle          */
+  var sinz, cosz; /* sin of z and cos of z      */
+  var con;
+  var lon, lat;
+  var long0, lat0;
+  /* Inverse equations
+      ----------------- */
+  p.x -= state.x0 || 0;
+  p.y -= state.y0 || 0;
+  rh = Math.sqrt(p.x * p.x + p.y * p.y);
+  if (rh > state.a * (1 + 1e-14)) throw new Error('Coordinate is outside the orthographic disk');
+  z = asinz(rh / state.a);
+
+  sinz = Math.sin(z);
+  cosz = Math.cos(z);
+
+  long0 = state.long0 || 0;
+  lat0 = state.lat0 || 0;
+  lon = long0;
+  if (Math.abs(rh) <= EPSLN) {
+    lat = lat0;
+    p.x = lon;
+    p.y = lat;
+    return p;
+  }
+  lat = asinz(cosz * state.sin_p14 + (p.y * sinz * state.cos_p14) / rh);
+  con = Math.abs(lat0) - HALF_PI;
+  if (Math.abs(con) <= EPSLN) {
+    if (lat0 >= 0) {
+      lon = adjust_lon(long0 + Math.atan2(p.x, -p.y), state.over);
+    } else {
+      lon = adjust_lon(long0 - Math.atan2(-p.x, p.y), state.over);
+    }
+    p.x = lon;
+    p.y = lat;
+    return p;
+  }
+  lon = adjust_lon(
+    long0 + Math.atan2(p.x * sinz, rh * state.cos_p14 * cosz - p.y * state.sin_p14 * sinz),
+    state.over
+  );
+  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, ...options};
+  initialize(state);
+  return state;
+}

package/src/experimental/kernels/poly.ts

@@ -0,0 +1,156 @@
+// 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 & {
+  temp: number;
+  e0: number;
+  e1: number;
+  e2: number;
+  e3: number;
+  ml0: number;
+};
+import e0fn from '../common/e0fn';
+import e1fn from '../common/e1fn';
+import e2fn from '../common/e2fn';
+import e3fn from '../common/e3fn';
+import adjust_lon from '../common/adjust_lon';
+import adjust_lat from '../common/adjust_lat';
+import mlfn from '../common/mlfn';
+import {EPSLN} from '../common/constants';
+
+import gN from '../common/gN';
+
+var MAX_ITER = 20;
+
+function initialize(state: State): void {
+  /* Place parameters in static storage for common use
+      ------------------------------------------------- */
+  state.temp = state.b / state.a;
+  state.es = 1 - Math.pow(state.temp, 2); // devait etre dans tmerc.js mais n y est pas donc je commente sinon retour de valeurs nulles
+  state.e = Math.sqrt(state.es);
+  state.e0 = e0fn(state.es);
+  state.e1 = e1fn(state.es);
+  state.e2 = e2fn(state.es);
+  state.e3 = e3fn(state.es);
+  state.ml0 = state.a * mlfn(state.e0, state.e1, state.e2, state.e3, state.lat0); // si que des zeros le calcul ne se fait pas
+}
+
+/* Polyconic 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 x, y, el;
+  var dlon = adjust_lon(lon - state.long0, state.over);
+  el = dlon * Math.sin(lat);
+  if (state.sphere) {
+    if (Math.abs(lat) <= EPSLN) {
+      x = state.a * dlon;
+      y = -1 * state.a * state.lat0;
+    } else {
+      x = (state.a * Math.sin(el)) / Math.tan(lat);
+      y = state.a * (adjust_lat(lat - state.lat0) + (1 - Math.cos(el)) / Math.tan(lat));
+    }
+  } else {
+    if (Math.abs(lat) <= EPSLN) {
+      x = state.a * dlon;
+      y = -1 * state.ml0;
+    } else {
+      var nl = gN(state.a, state.e, Math.sin(lat)) / Math.tan(lat);
+      x = nl * Math.sin(el);
+      y =
+        state.a * mlfn(state.e0, state.e1, state.e2, state.e3, lat) -
+        state.ml0 +
+        nl * (1 - Math.cos(el));
+    }
+  }
+  p.x = x + state.x0;
+  p.y = y + state.y0;
+  return p;
+}
+
+/* Inverse equations
+  ----------------- */
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var lon, lat, x, y, i;
+  var al, bl;
+  var phi, dphi;
+  x = p.x - state.x0;
+  y = p.y - state.y0;
+
+  if (state.sphere) {
+    if (Math.abs(y + state.a * state.lat0) <= EPSLN) {
+      lon = adjust_lon(x / state.a + state.long0, state.over);
+      lat = 0;
+    } else {
+      al = state.lat0 + y / state.a;
+      bl = (x * x) / state.a / state.a + al * al;
+      phi = al;
+      var tanphi;
+      for (i = MAX_ITER; i; --i) {
+        tanphi = Math.tan(phi);
+        dphi =
+          (-1 * (al * (phi * tanphi + 1) - phi - 0.5 * (phi * phi + bl) * tanphi)) /
+          ((phi - al) / tanphi - 1);
+        phi += dphi;
+        if (Math.abs(dphi) <= EPSLN) {
+          lat = phi;
+          break;
+        }
+      }
+      lon = adjust_lon(
+        state.long0 + Math.asin((x * Math.tan(phi)) / state.a) / Math.sin(lat),
+        state.over
+      );
+    }
+  } else {
+    if (Math.abs(y + state.ml0) <= EPSLN) {
+      lat = 0;
+      lon = adjust_lon(state.long0 + x / state.a, state.over);
+    } else {
+      al = (state.ml0 + y) / state.a;
+      bl = (x * x) / state.a / state.a + al * al;
+      phi = al;
+      var cl, mln, mlnp, ma;
+      var con;
+      for (i = MAX_ITER; i; --i) {
+        con = state.e * Math.sin(phi);
+        cl = Math.sqrt(1 - con * con) * Math.tan(phi);
+        mln = state.a * mlfn(state.e0, state.e1, state.e2, state.e3, phi);
+        mlnp =
+          state.e0 -
+          2 * state.e1 * Math.cos(2 * phi) +
+          4 * state.e2 * Math.cos(4 * phi) -
+          6 * state.e3 * Math.cos(6 * phi);
+        ma = mln / state.a;
+        dphi =
+          (al * (cl * ma + 1) - ma - 0.5 * cl * (ma * ma + bl)) /
+          ((state.es * Math.sin(2 * phi) * (ma * ma + bl - 2 * al * ma)) / (4 * cl) +
+            (al - ma) * (cl * mlnp - 2 / Math.sin(2 * phi)) -
+            mlnp);
+        phi -= dphi;
+        if (Math.abs(dphi) <= EPSLN) {
+          lat = phi;
+          break;
+        }
+      }
+
+      // lat=phi4z(state.e,state.e0,state.e1,state.e2,state.e3,al,bl,0,0);
+      cl = Math.sqrt(1 - state.es * Math.pow(Math.sin(lat), 2)) * Math.tan(lat);
+      lon = adjust_lon(state.long0 + Math.asin((x * cl) / state.a) / Math.sin(lat), state.over);
+    }
+  }
+
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, temp: 0, e0: 0, e1: 0, e2: 0, e3: 0, ml0: 0, ...options};
+  initialize(state);
+  return state;
+}

package/src/experimental/kernels/qsc.ts

@@ -0,0 +1,369 @@
+// 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 reuse the caller-owned point and represent area/temporary coordinates as local numbers. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  face: number;
+  one_minus_f: number;
+  one_minus_f_squared: number;
+};
+// QSC projection rewritten from the original PROJ4
+// https://github.com/OSGeo/proj.4/blob/master/src/PJ_qsc.c
+
+import {EPSLN, TWO_PI, SPI, HALF_PI, FORTPI} from '../common/constants';
+
+/* constants */
+var FACE_ENUM = {
+  FRONT: 1,
+  RIGHT: 2,
+  BACK: 3,
+  LEFT: 4,
+  TOP: 5,
+  BOTTOM: 6
+};
+
+var AREA_ENUM = {
+  AREA_0: 1,
+  AREA_1: 2,
+  AREA_2: 3,
+  AREA_3: 4
+};
+
+function initialize(state: State): void {
+  state.x0 = state.x0 || 0;
+  state.y0 = state.y0 || 0;
+  state.lat0 = state.lat0 || 0;
+  state.long0 = state.long0 || 0;
+  state.lat_ts = state.lat_ts || 0;
+
+  /* Determine the cube face from the center of projection. */
+  if (state.lat0 >= HALF_PI - FORTPI / 2.0) {
+    state.face = FACE_ENUM.TOP;
+  } else if (state.lat0 <= -(HALF_PI - FORTPI / 2.0)) {
+    state.face = FACE_ENUM.BOTTOM;
+  } else if (Math.abs(state.long0) <= FORTPI) {
+    state.face = FACE_ENUM.FRONT;
+  } else if (Math.abs(state.long0) <= HALF_PI + FORTPI) {
+    state.face = state.long0 > 0.0 ? FACE_ENUM.RIGHT : FACE_ENUM.LEFT;
+  } else {
+    state.face = FACE_ENUM.BACK;
+  }
+
+  /* Fill in useful values for the ellipsoid <-> sphere shift
+   * described in [LK12]. */
+  if (state.es !== 0) {
+    state.one_minus_f = 1 - (state.a - state.b) / state.a;
+    state.one_minus_f_squared = state.one_minus_f * state.one_minus_f;
+  }
+}
+
+// QSC forward equations--mapping lat,long to x,y
+// -----------------------------------------------------------------
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var xy = p;
+  var lat, lon;
+  var theta, phi;
+  var t, mu;
+  /* nu; */
+  var area = 0;
+
+  // move lon according to projection's lon
+  p.x -= state.long0;
+
+  /* Convert the geodetic latitude to a geocentric latitude.
+   * This corresponds to the shift from the ellipsoid to the sphere
+   * described in [LK12]. */
+  if (state.es !== 0) {
+    // if (P->es != 0) {
+    lat = Math.atan(state.one_minus_f_squared * Math.tan(p.y));
+  } else {
+    lat = p.y;
+  }
+
+  /* Convert the input lat, lon into theta, phi as used by QSC.
+   * This depends on the cube face and the area on it.
+   * For the top and bottom face, we can compute theta and phi
+   * directly from phi, lam. For the other faces, we must use
+   * unit sphere cartesian coordinates as an intermediate step. */
+  lon = p.x; // lon = lam;
+  if (state.face === FACE_ENUM.TOP) {
+    phi = HALF_PI - lat;
+    if (lon >= FORTPI && lon <= HALF_PI + FORTPI) {
+      area = AREA_ENUM.AREA_0;
+      theta = lon - HALF_PI;
+    } else if (lon > HALF_PI + FORTPI || lon <= -(HALF_PI + FORTPI)) {
+      area = AREA_ENUM.AREA_1;
+      theta = lon > 0.0 ? lon - SPI : lon + SPI;
+    } else if (lon > -(HALF_PI + FORTPI) && lon <= -FORTPI) {
+      area = AREA_ENUM.AREA_2;
+      theta = lon + HALF_PI;
+    } else {
+      area = AREA_ENUM.AREA_3;
+      theta = lon;
+    }
+  } else if (state.face === FACE_ENUM.BOTTOM) {
+    phi = HALF_PI + lat;
+    if (lon >= FORTPI && lon <= HALF_PI + FORTPI) {
+      area = AREA_ENUM.AREA_0;
+      theta = -lon + HALF_PI;
+    } else if (lon < FORTPI && lon >= -FORTPI) {
+      area = AREA_ENUM.AREA_1;
+      theta = -lon;
+    } else if (lon < -FORTPI && lon >= -(HALF_PI + FORTPI)) {
+      area = AREA_ENUM.AREA_2;
+      theta = -lon - HALF_PI;
+    } else {
+      area = AREA_ENUM.AREA_3;
+      theta = lon > 0.0 ? -lon + SPI : -lon - SPI;
+    }
+  } else {
+    var q, r, s;
+    var sinlat, coslat;
+    var sinlon, coslon;
+
+    if (state.face === FACE_ENUM.RIGHT) {
+      lon = qsc_shift_lon_origin(lon, +HALF_PI);
+    } else if (state.face === FACE_ENUM.BACK) {
+      lon = qsc_shift_lon_origin(lon, +SPI);
+    } else if (state.face === FACE_ENUM.LEFT) {
+      lon = qsc_shift_lon_origin(lon, -HALF_PI);
+    }
+    sinlat = Math.sin(lat);
+    coslat = Math.cos(lat);
+    sinlon = Math.sin(lon);
+    coslon = Math.cos(lon);
+    q = coslat * coslon;
+    r = coslat * sinlon;
+    s = sinlat;
+
+    if (state.face === FACE_ENUM.FRONT) {
+      phi = Math.acos(q);
+      theta = qsc_fwd_equat_face_theta(phi, s, r);
+    } else if (state.face === FACE_ENUM.RIGHT) {
+      phi = Math.acos(r);
+      theta = qsc_fwd_equat_face_theta(phi, s, -q);
+    } else if (state.face === FACE_ENUM.BACK) {
+      phi = Math.acos(-q);
+      theta = qsc_fwd_equat_face_theta(phi, s, -r);
+    } else if (state.face === FACE_ENUM.LEFT) {
+      phi = Math.acos(-r);
+      theta = qsc_fwd_equat_face_theta(phi, s, q);
+    } else {
+      /* Impossible */
+      phi = theta = 0;
+    }
+    if (Math.abs(theta) <= FORTPI) {
+      area = AREA_ENUM.AREA_0;
+    } else if (theta > FORTPI && theta <= HALF_PI + FORTPI) {
+      area = AREA_ENUM.AREA_1;
+      theta -= HALF_PI;
+    } else if (theta > HALF_PI + FORTPI || theta <= -(HALF_PI + FORTPI)) {
+      area = AREA_ENUM.AREA_2;
+      theta = theta >= 0.0 ? theta - SPI : theta + SPI;
+    } else {
+      area = AREA_ENUM.AREA_3;
+      theta += HALF_PI;
+    }
+  }
+
+  /* Compute mu and nu for the area of definition.
+   * For mu, see Eq. (3-21) in [OL76], but note the typos:
+   * compare with Eq. (3-14). For nu, see Eq. (3-38). */
+  mu = Math.atan((12 / SPI) * (theta + Math.acos(Math.sin(theta) * Math.cos(FORTPI)) - HALF_PI));
+  t = Math.sqrt(
+    (1 - Math.cos(phi)) /
+      (Math.cos(mu) * Math.cos(mu)) /
+      (1 - Math.cos(Math.atan(1 / Math.cos(theta))))
+  );
+
+  /* Apply the result to the real area. */
+  if (area === AREA_ENUM.AREA_1) {
+    mu += HALF_PI;
+  } else if (area === AREA_ENUM.AREA_2) {
+    mu += SPI;
+  } else if (area === AREA_ENUM.AREA_3) {
+    mu += 1.5 * SPI;
+  }
+
+  /* Now compute x, y from mu and nu */
+  xy.x = t * Math.cos(mu);
+  xy.y = t * Math.sin(mu);
+  xy.x = xy.x * state.a + state.x0;
+  xy.y = xy.y * state.a + state.y0;
+
+  return p;
+}
+
+// QSC inverse equations--mapping x,y to lat/long
+// -----------------------------------------------------------------
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var lam = 0,
+    latitude = 0;
+  var mu, nu, cosmu, tannu;
+  var tantheta, theta, cosphi, phi;
+  var t;
+  var area = 0;
+
+  /* de-offset */
+  p.x = (p.x - state.x0) / state.a;
+  p.y = (p.y - state.y0) / state.a;
+
+  /* Convert the input x, y to the mu and nu angles as used by QSC.
+   * This depends on the area of the cube face. */
+  nu = Math.atan(Math.sqrt(p.x * p.x + p.y * p.y));
+  mu = Math.atan2(p.y, p.x);
+  if (p.x >= 0.0 && p.x >= Math.abs(p.y)) {
+    area = AREA_ENUM.AREA_0;
+  } else if (p.y >= 0.0 && p.y >= Math.abs(p.x)) {
+    area = AREA_ENUM.AREA_1;
+    mu -= HALF_PI;
+  } else if (p.x < 0.0 && -p.x >= Math.abs(p.y)) {
+    area = AREA_ENUM.AREA_2;
+    mu = mu < 0.0 ? mu + SPI : mu - SPI;
+  } else {
+    area = AREA_ENUM.AREA_3;
+    mu += HALF_PI;
+  }
+
+  /* Compute phi and theta for the area of definition.
+   * The inverse projection is not described in the original paper, but some
+   * good hints can be found here (as of 2011-12-14):
+   * http://fits.gsfc.nasa.gov/fitsbits/saf.93/saf.9302
+   * (search for "Message-Id: <9302181759.AA25477 at fits.cv.nrao.edu>") */
+  t = (SPI / 12) * Math.tan(mu);
+  tantheta = Math.sin(t) / (Math.cos(t) - 1 / Math.sqrt(2));
+  theta = Math.atan(tantheta);
+  cosmu = Math.cos(mu);
+  tannu = Math.tan(nu);
+  cosphi = 1 - cosmu * cosmu * tannu * tannu * (1 - Math.cos(Math.atan(1 / Math.cos(theta))));
+  if (cosphi < -1) {
+    cosphi = -1;
+  } else if (cosphi > +1) {
+    cosphi = +1;
+  }
+
+  /* Apply the result to the real area on the cube face.
+   * For the top and bottom face, we can compute phi and lam directly.
+   * For the other faces, we must use unit sphere cartesian coordinates
+   * as an intermediate step. */
+  if (state.face === FACE_ENUM.TOP) {
+    phi = Math.acos(cosphi);
+    latitude = HALF_PI - phi;
+    if (area === AREA_ENUM.AREA_0) {
+      lam = theta + HALF_PI;
+    } else if (area === AREA_ENUM.AREA_1) {
+      lam = theta < 0.0 ? theta + SPI : theta - SPI;
+    } else if (area === AREA_ENUM.AREA_2) {
+      lam = theta - HALF_PI;
+    } /* area == AREA_ENUM.AREA_3 */ else {
+      lam = theta;
+    }
+  } else if (state.face === FACE_ENUM.BOTTOM) {
+    phi = Math.acos(cosphi);
+    latitude = phi - HALF_PI;
+    if (area === AREA_ENUM.AREA_0) {
+      lam = -theta + HALF_PI;
+    } else if (area === AREA_ENUM.AREA_1) {
+      lam = -theta;
+    } else if (area === AREA_ENUM.AREA_2) {
+      lam = -theta - HALF_PI;
+    } /* area == AREA_ENUM.AREA_3 */ else {
+      lam = theta < 0.0 ? -theta - SPI : -theta + SPI;
+    }
+  } else {
+    /* Compute phi and lam via cartesian unit sphere coordinates. */
+    var q, r, s;
+    q = cosphi;
+    t = q * q;
+    if (t >= 1) {
+      s = 0;
+    } else {
+      s = Math.sqrt(1 - t) * Math.sin(theta);
+    }
+    t += s * s;
+    if (t >= 1) {
+      r = 0;
+    } else {
+      r = Math.sqrt(1 - t);
+    }
+    /* Rotate q,r,s into the correct area. */
+    if (area === AREA_ENUM.AREA_1) {
+      t = r;
+      r = -s;
+      s = t;
+    } else if (area === AREA_ENUM.AREA_2) {
+      r = -r;
+      s = -s;
+    } else if (area === AREA_ENUM.AREA_3) {
+      t = r;
+      r = s;
+      s = -t;
+    }
+    /* Rotate q,r,s into the correct cube face. */
+    if (state.face === FACE_ENUM.RIGHT) {
+      t = q;
+      q = -r;
+      r = t;
+    } else if (state.face === FACE_ENUM.BACK) {
+      q = -q;
+      r = -r;
+    } else if (state.face === FACE_ENUM.LEFT) {
+      t = q;
+      q = r;
+      r = -t;
+    }
+    /* Now compute phi and lam from the unit sphere coordinates. */
+    latitude = Math.acos(-s) - HALF_PI;
+    lam = Math.atan2(r, q);
+    if (state.face === FACE_ENUM.RIGHT) {
+      lam = qsc_shift_lon_origin(lam, -HALF_PI);
+    } else if (state.face === FACE_ENUM.BACK) {
+      lam = qsc_shift_lon_origin(lam, -SPI);
+    } else if (state.face === FACE_ENUM.LEFT) {
+      lam = qsc_shift_lon_origin(lam, +HALF_PI);
+    }
+  }
+
+  /* Apply the shift from the sphere to the ellipsoid as described
+   * in [LK12]. */
+  if (state.es !== 0) {
+    var invert_sign;
+    var tanphi, xa;
+    invert_sign = latitude < 0 ? 1 : 0;
+    tanphi = Math.tan(latitude);
+    xa = state.b / Math.sqrt(tanphi * tanphi + state.one_minus_f_squared);
+    latitude = Math.atan(Math.sqrt(state.a * state.a - xa * xa) / (state.one_minus_f * xa));
+    if (invert_sign) {
+      latitude = -latitude;
+    }
+  }
+
+  lam += state.long0;
+  p.x = lam;
+  p.y = latitude;
+  return p;
+}
+
+/* Equatorial-face theta before scalar area selection in forward. */
+function qsc_fwd_equat_face_theta(phi: number, y: number, x: number): number {
+  return phi < EPSLN ? 0.0 : Math.atan2(y, x);
+}
+
+/* Helper function: shift the longitude. */
+function qsc_shift_lon_origin(lon: number, offset: number) {
+  var slon = lon + offset;
+  if (slon < -SPI) {
+    slon += TWO_PI;
+  } else if (slon > +SPI) {
+    slon -= TWO_PI;
+  }
+  return slon;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, face: 0, one_minus_f: 0, one_minus_f_squared: 0, ...options};
+  initialize(state);
+  return state;
+}