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

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

@@ -1,7 +1,7 @@
 // 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.
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution.
 
 import type {KernelParameters, Point} from '../kernel';
 export type State = KernelParameters & {

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

@@ -1,7 +1,7 @@
 // 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.
+// SPDX-FileComment: Adapted from proj4js 2.22.0, using the exact pi/4 constant as in PROJ 9.5.1 src/projections/krovak.cpp to preserve the south pole. See ../../../../projection/PROJ-LICENSE.txt. See ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution.
 
 import type {KernelParameters, Point} from '../kernel';
 export type State = KernelParameters & {
@@ -31,7 +31,7 @@ function initialize(state: State): void {
 
   /* if scale not set default to 0.9999 */
 
-  state.s45 = 0.785398163397448; /* 45 */
+  state.s45 = Math.PI / 4; /* 45 */
   state.s90 = 2 * state.s45;
   state.fi0 = state.lat0;
   state.e2 = state.es;

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

@@ -1,14 +1,14 @@
 // 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.
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original math.gl pole-complement and Cartesian inverse stability corrections. Adapted from proj4js 2.22.0 with bounded inverse disk/pole roundoff. See ../../../../projection/PROJ4-LICENSE.md for upstream attribution. Independent corrections acknowledge PROJ 9.5.1 src/projections/laea.cpp; see ../../../../projection/PROJ-LICENSE.txt.
 
 import type {KernelParameters, Point} from '../kernel';
 export type State = KernelParameters & {
   mode: number;
   qp: number;
   mmf: number;
-  apa: number[];
   dd: number;
   rq: number;
   xmf: number;
@@ -22,8 +22,8 @@ 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';
+import {authalicPoleDifference, inverseAuthalicLatitude} from '../authalic-latitude';
+import {inverseSphericalLatitude} from '../inverse-spherical-latitude';
 
 /*
   reference
@@ -50,7 +50,6 @@ function initialize(state: State): void {
 
     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;
@@ -132,7 +131,8 @@ export function forward(state: State, p: Point): Point | null | undefined | numb
     q = qsfnz(state.e, sinphi);
     if (state.mode === OBLIQ || state.mode === EQUIT) {
       sinb = q / state.qp;
-      cosb = Math.sqrt(1 - sinb * sinb);
+      const poleFraction = authalicPoleDifference(state.e, phi) / state.qp;
+      cosb = Math.sqrt(poleFraction * (2 - poleFraction));
     }
     switch (state.mode) {
       case OBLIQ:
@@ -143,11 +143,17 @@ export function forward(state: State, p: Point): Point | null | undefined | numb
         break;
       case N_POLE:
         b = HALF_PI + phi;
-        q = state.qp - q;
+        q =
+          phi >= 0
+            ? authalicPoleDifference(state.e, phi)
+            : 2 * state.qp - authalicPoleDifference(state.e, phi);
         break;
       case S_POLE:
         b = phi - HALF_PI;
-        q = state.qp + q;
+        q =
+          phi <= 0
+            ? authalicPoleDifference(state.e, phi)
+            : 2 * state.qp - authalicPoleDifference(state.e, phi);
         break;
     }
     if (Math.abs(b) < EPSLN) {
@@ -198,17 +204,17 @@ export function inverse(state: State, p: Point): Point | null | undefined | numb
 
     rh = Math.sqrt(x * x + y * y);
     phi = rh * 0.5;
-    if (phi > 1) {
+    if (phi > 1 + 8 * Number.EPSILON) {
       return null;
     }
-    phi = 2 * Math.asin(phi);
+    phi = 2 * Math.asin(Math.min(1, 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);
+        phi = Math.abs(rh) <= EPSLN ? 0 : inverseSphericalLatitude(0, 1, sinz, cosz, x, y, rh);
         x *= sinz;
         y = cosz * rh;
         break;
@@ -216,7 +222,7 @@ export function inverse(state: State, p: Point): Point | null | undefined | numb
         phi =
           Math.abs(rh) <= EPSLN
             ? state.lat0
-            : Math.asin(cosz * state.sinph0 + (y * sinz * state.cosph0) / rh);
+            : inverseSphericalLatitude(state.sinph0, state.cosph0, sinz, cosz, x, y, rh);
         x *= sinz * state.cosph0;
         y = (cosz - Math.sin(phi) * state.sinph0) * rh;
         break;
@@ -240,9 +246,22 @@ export function inverse(state: State, p: Point): Point | null | undefined | numb
         p.y = state.lat0;
         return p;
       }
-      sCe = 2 * Math.asin((0.5 * rho) / state.rq);
+      const sinHalfCe = (0.5 * rho) / state.rq;
+      if (sinHalfCe > 1 + 8 * Number.EPSILON) return null;
+      sCe = 2 * Math.asin(Math.min(1, sinHalfCe));
       cCe = Math.cos(sCe);
-      x *= sCe = Math.sin(sCe);
+      sCe = Math.sin(sCe);
+      const beta = inverseSphericalLatitude(
+        state.mode === OBLIQ ? state.sinb1 : 0,
+        state.mode === OBLIQ ? state.cosb1 : 1,
+        sCe,
+        cCe,
+        x,
+        y,
+        rho
+      );
+      phi = inverseAuthalicLatitude(state.e, state.qp, beta);
+      x *= sCe;
       if (state.mode === OBLIQ) {
         ab = cCe * state.sinb1 + (y * sCe * state.cosb1) / rho;
         q = state.qp * ab;
@@ -268,7 +287,12 @@ export function inverse(state: State, p: Point): Point | null | undefined | numb
       }
     }
     lam = Math.atan2(x, y);
-    phi = authlat(Math.asin(ab), state.apa);
+    if (Math.abs(ab) > 1 + 8 * Number.EPSILON) return null;
+    if (state.mode === N_POLE || state.mode === S_POLE) {
+      const fraction = Math.max(0, Math.min(2, q / state.qp));
+      const beta = Math.atan2(ab, Math.sqrt(fraction * (2 - fraction)));
+      phi = inverseAuthalicLatitude(state.e, state.qp, beta);
+    }
   }
 
   p.x = adjust_lon(state.long0 + lam, state.over);
@@ -282,7 +306,6 @@ export function createState(base: KernelParameters): State {
     mode: 0,
     qp: 0,
     mmf: 0,
-    apa: [],
     dd: 0,
     rq: 0,
     xmf: 0,

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

@@ -1,7 +1,7 @@
 // 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.
+// SPDX-FileComment: Adapted from proj4js 2.22.0 with exact pole handling instead of latitude perturbation. See ../../../../projection/PROJ4-LICENSE.md for upstream attribution. Independent corrections acknowledge PROJ 9.5.1 src/projections/lcc.cpp; see ../../../../projection/PROJ-LICENSE.txt.
 
 import type {KernelParameters, Point} from '../kernel';
 export type State = KernelParameters & {
@@ -11,7 +11,6 @@ export type State = KernelParameters & {
 };
 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';
@@ -76,15 +75,10 @@ export function forward(state: State, p: Point): Point | null | undefined | numb
   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));
+    ts = state.sphere ? 1 / Math.tan(Math.PI / 4 + lat / 2) : tsfnz(state.e, lat, Math.sin(lat));
     rh1 = state.a * state.f0 * Math.pow(ts, state.ns);
   } else {
     con = lat * state.ns;

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

@@ -1,7 +1,7 @@
 // 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.
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution.
 
 import type {KernelParameters, Point} from '../kernel';
 export type State = KernelParameters & {};

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

@@ -1,12 +1,12 @@
 // 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.
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original math.gl pole-complement solve, exact constants and bounded inverse replace cancellation-prone iteration.  Direct TypeScript port of proj4js 2.22.0. See ../../../../projection/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';
-import {EPSLN} from '../common/constants';
 
 function initialize(state: State): void {
   state.x0 = state.x0 !== undefined ? state.x0 : 0;
@@ -23,33 +23,28 @@ export function forward(state: State, p: Point): Point | null | undefined | numb
   var lat = p.y;
 
   var delta_lon = adjust_lon(lon - state.long0, state.over);
-  var theta = lat;
-  var con = Math.PI * Math.sin(lat);
-
-  /* Iterate using the Newton-Raphson method to find theta
-      ----------------------------------------------------- */
-  for (let iteration = 0; iteration < 50; iteration++) {
-    if (Math.abs(Math.abs(lat) - Math.PI / 2) < EPSLN) {
-      theta = Math.sign(lat) * Math.PI;
-      break;
-    }
-    var delta_theta = -(theta + Math.sin(theta) - con) / (1 + Math.cos(theta));
-    theta += delta_theta;
-    if (iteration === 49) throw new Error('Mollweide forward did not converge');
-    if (Math.abs(delta_theta) < EPSLN) {
-      break;
-    }
-  }
-  theta /= 2;
-
-  /* If the latitude is 90 deg, force the x coordinate to be "0 + false easting"
-       this is done here because of precision problems with "cos(theta)"
-       -------------------------------------------------------------------------- */
-  if (Math.PI / 2 - Math.abs(lat) < EPSLN) {
-    delta_lon = 0;
+  // Solve v - sin(v) = pi*(1 - sin(|latitude|)), v=pi-2*theta.
+  // Retain the pole complement even when sin(latitude) rounds to one.
+  const sin = Math.sin(Math.abs(lat));
+  const cos = Math.cos(lat);
+  const target = Math.abs(lat) === Math.PI / 2 ? 0 : (Math.PI * cos * cos) / (1 + sin);
+  let v = Math.cbrt(6 * target);
+  let lower = 0;
+  let upper = Math.PI;
+  v = Math.min(v, upper);
+  for (let i = 0; i < 32 && v > 0; i++) {
+    const residual = sineComplement(v) - target;
+    const step = residual / (2 * Math.sin(v / 2) ** 2);
+    if (Math.abs(step) <= 16 * Number.EPSILON * v) break;
+    if (residual > 0) upper = v;
+    else lower = v;
+    const next = v - step;
+    if (next === v || upper - lower <= 8 * Number.EPSILON * Math.max(1, v)) break;
+    v = next >= lower && next <= upper ? next : (lower + upper) / 2;
+    if (i === 31) throw new Error('Mollweide forward did not converge');
   }
-  var x = 0.900316316158 * state.a * delta_lon * Math.cos(theta) + state.x0;
-  var y = 1.4142135623731 * state.a * Math.sin(theta) + state.y0;
+  var x = ((2 * Math.SQRT2) / Math.PI) * state.a * delta_lon * Math.sin(v / 2) + state.x0;
+  var y = Math.sign(lat) * Math.SQRT2 * state.a * Math.cos(v / 2) + state.y0;
 
   p.x = x;
   p.y = y;
@@ -57,37 +52,27 @@ export function forward(state: State, p: Point): Point | null | undefined | numb
 }
 
 export function inverse(state: State, p: Point): Point | null | undefined | number {
-  var theta;
-  var arg;
-
-  /* Inverse equations
-      ----------------- */
-  p.x -= state.x0;
-  p.y -= state.y0;
-  arg = p.y / (1.4142135623731 * state.a);
-
-  /* Because of division by zero problems, 'arg' can not be 1.  Therefore
-       a number very close to one is used instead.
-       ------------------------------------------------------------------- */
-  if (Math.abs(arg) > 0.999999999999) {
-    arg = Math.sign(arg) * 0.999999999999;
+  const x = p.x - state.x0;
+  const y = (p.y - state.y0) / (Math.SQRT2 * state.a);
+  if (Math.abs(y) > 1 + 8 * Number.EPSILON) return null;
+  const normalizedX = x / (2 * Math.SQRT2 * state.a);
+  // Test the ellipse in projected space: a rounded polar northing cannot
+  // support a fixed longitude tolerance after division by its tiny cosine.
+  const ellipse = normalizedX * normalizedX + y * y;
+  if (!state.over && ellipse > 1 + 8 * Number.EPSILON) return null;
+  let v = 2 * Math.acos(Math.min(1, Math.abs(y)));
+  let sinHalf = Math.sin(v / 2);
+  if (!state.over && Math.abs(ellipse - 1) <= 8 * Number.EPSILON) {
+    // Within the roundoff envelope, recover the seam from easting. This also
+    // handles a near-pole northing that rounds to the exact polar ordinate.
+    sinHalf = Math.min(1, Math.abs(normalizedX));
+    v = 2 * Math.asin(sinHalf);
   }
-  theta = Math.asin(arg);
-  var lon = adjust_lon(
-    state.long0 + p.x / (0.900316316158 * state.a * Math.cos(theta)),
-    state.over
-  );
-  if (!state.over && lon < -Math.PI) {
-    lon = -Math.PI;
-  }
-  if (!state.over && lon > Math.PI) {
-    lon = Math.PI;
-  }
-  arg = (2 * theta + Math.sin(2 * theta)) / Math.PI;
-  if (Math.abs(arg) > 1) {
-    arg = Math.sign(arg);
-  }
-  var lat = Math.asin(arg);
+  if (sinHalf === 0 && Math.abs(x) > 8 * Number.EPSILON * state.a) return null;
+  const longitude = sinHalf === 0 ? 0 : (Math.PI * normalizedX) / sinHalf;
+  var lon = adjust_lon(state.long0 + longitude, state.over);
+  var lat =
+    Math.sign(y) * (Math.PI / 2 - 2 * Math.asin(Math.sqrt(sineComplement(v) / (2 * Math.PI))));
 
   p.x = lon;
   p.y = lat;
@@ -103,3 +88,22 @@ export function createState(base: KernelParameters, options: Partial<State> = {}
   initialize(state);
   return state;
 }
+
+/** v-sin(v), retaining the cubic leading term at a pole. */
+function sineComplement(v: number): number {
+  if (v > 0.5) return v - Math.sin(v);
+  const squared = v * v;
+  return (
+    v *
+    squared *
+    (1 / 6 +
+      squared *
+        (-1 / 120 +
+          squared *
+            (1 / 5040 +
+              squared *
+                (-1 / 362880 +
+                  squared *
+                    (1 / 39916800 + squared * (-1 / 6227020800 + squared / 1307674368000))))))
+  );
+}

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

@@ -1,7 +1,7 @@
 // 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.
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution.
 
 import type {KernelParameters, Point} from '../kernel';
 export type State = KernelParameters & {

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

@@ -1,7 +1,7 @@
 // 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 instead of allocating coordinate results. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0, modified to reuse the caller-owned point instead of allocating coordinate results. See ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution.
 
 import type {KernelParameters, Point} from '../kernel';
 export type State = KernelParameters & {

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

@@ -1,106 +1,52 @@
 // 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.
-
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original orthographic equations using an ellipsoid surface and parallel ray intersection. Independently qualified against native PROJ. Independent corrections acknowledge PROJ 9.5.1 src/projections/ortho.cpp and OSGeo/PROJ #2361, #2844 and #2855; see ../../../../projection/PROJ-LICENSE.txt.
 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    */
+export type State = KernelParameters & {sin0: number; cos0: number; originY: number};
 
-  /* Place parameters in static storage for common use
-      ------------------------------------------------- */
-  state.sin_p14 = Math.sin(state.lat0 || 0);
-  state.cos_p14 = Math.cos(state.lat0 || 0);
+export function createState(base: KernelParameters): State {
+  const sin0 = Math.sin(base.lat0);
+  const cos0 = Math.cos(base.lat0);
+  const nu0 = 1 / Math.sqrt(1 - base.es * sin0 * sin0);
+  return {...base, sin0, cos0, originY: -base.es * nu0 * sin0 * cos0};
 }
 
-/* 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;
+export function forward(s: State, p: Point): Point {
+  const longitude = adjust_lon(p.x - s.long0, s.over);
+  const sin = Math.sin(p.y);
+  const cos = Math.cos(p.y);
+  const nu = 1 / Math.sqrt(1 - s.es * sin * sin);
+  p.x = s.x0 + s.a * s.k0 * nu * cos * Math.sin(longitude);
+  p.y =
+    s.y0 +
+    s.a *
+      s.k0 *
+      (nu * ((1 - s.es) * sin * s.cos0 - cos * Math.cos(longitude) * s.sin0) - s.originY);
   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;
+export function inverse(s: State, p: Point): Point {
+  // In the meridian frame, E=(0,1,0), N=(-sin0,0,cos0),
+  // V=(cos0,0,sin0). Intersect x E + y N + t V with the ellipsoid.
+  const x = (p.x - s.x0) / (s.a * s.k0);
+  const y = (p.y - s.y0) / (s.a * s.k0) + s.originY;
+  const q = 1 - s.es;
+  const a = s.cos0 * s.cos0 + (s.sin0 * s.sin0) / q;
+  const b = (y * s.sin0 * s.cos0 * s.es) / q;
+  const c = x * x + y * y * (s.sin0 * s.sin0 + (s.cos0 * s.cos0) / q) - 1;
+  const discriminant = b * b - a * c;
+  // The positive root selects the visible intersection. A few ulps of
+  // discriminant roundoff are possible exactly on the projected limb.
+  if (discriminant < -32 * Number.EPSILON * a) {
+    throw new Error('Coordinate is outside the orthographic ellipse');
   }
-  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;
+  const t = (-b + Math.sqrt(Math.max(0, discriminant))) / a;
+  const radial = t * s.cos0 - y * s.sin0;
+  const z = t * s.sin0 + y * s.cos0;
+  p.x = adjust_lon(s.long0 + Math.atan2(x, radial), s.over);
+  p.y = Math.atan2(z, q * Math.hypot(radial, x));
   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;
-}