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

package/src/discontinuous/spherical-clip/polygonContains.js

@@ -0,0 +1,96 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2010-2024 Mike Bostock
+// Adapted from d3-geo 3.1.1; see ./D3-GEO-LICENSE.txt.
+
+import {Adder} from './helpers.js';
+import {cartesian, cartesianCross, cartesianNormalizeInPlace} from './cartesian.js';
+import {
+  abs,
+  asin,
+  atan2,
+  cos,
+  epsilon,
+  epsilon2,
+  halfPi,
+  pi,
+  quarterPi,
+  sign,
+  sin,
+  tau
+} from './math.js';
+
+function longitude(point) {
+  return abs(point[0]) <= pi ? point[0] : sign(point[0]) * (((abs(point[0]) + pi) % tau) - pi);
+}
+
+export default function (polygon, point) {
+  var lambda = longitude(point),
+    phi = point[1],
+    sinPhi = sin(phi),
+    normal = [sin(lambda), -cos(lambda), 0],
+    angle = 0,
+    winding = 0;
+
+  var sum = new Adder();
+
+  if (sinPhi === 1) phi = halfPi + epsilon;
+  else if (sinPhi === -1) phi = -halfPi - epsilon;
+
+  for (var i = 0, n = polygon.length; i < n; ++i) {
+    if (!(m = (ring = polygon[i]).length)) continue;
+    var ring,
+      m,
+      point0 = ring[m - 1],
+      lambda0 = longitude(point0),
+      phi0 = point0[1] / 2 + quarterPi,
+      sinPhi0 = sin(phi0),
+      cosPhi0 = cos(phi0);
+
+    for (
+      var j = 0;
+      j < m;
+      ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1
+    ) {
+      var point1 = ring[j],
+        lambda1 = longitude(point1),
+        phi1 = point1[1] / 2 + quarterPi,
+        sinPhi1 = sin(phi1),
+        cosPhi1 = cos(phi1),
+        delta = lambda1 - lambda0,
+        sign = delta >= 0 ? 1 : -1,
+        absDelta = sign * delta,
+        antimeridian = absDelta > pi,
+        k = sinPhi0 * sinPhi1;
+
+      sum.add(atan2(k * sign * sin(absDelta), cosPhi0 * cosPhi1 + k * cos(absDelta)));
+      angle += antimeridian ? delta + sign * tau : delta;
+
+      // Are the longitudes either side of the point’s meridian (lambda),
+      // and are the latitudes smaller than the parallel (phi)?
+      if (antimeridian ^ (lambda0 >= lambda) ^ (lambda1 >= lambda)) {
+        var arc = cartesianCross(cartesian(point0), cartesian(point1));
+        cartesianNormalizeInPlace(arc);
+        var intersection = cartesianCross(normal, arc);
+        cartesianNormalizeInPlace(intersection);
+        var phiArc = (antimeridian ^ (delta >= 0) ? -1 : 1) * asin(intersection[2]);
+        if (phi > phiArc || (phi === phiArc && (arc[0] || arc[1]))) {
+          winding += antimeridian ^ (delta >= 0) ? 1 : -1;
+        }
+      }
+    }
+  }
+
+  // First, determine whether the South pole is inside or outside:
+  //
+  // It is inside if:
+  // * the polygon winds around it in a clockwise direction.
+  // * the polygon does not (cumulatively) wind around it, but has a negative
+  //   (counter-clockwise) area.
+  //
+  // Second, count the (signed) number of times a segment crosses a lambda
+  // from the point to the South pole.  If it is zero, then the point is the
+  // same side as the South pole.
+
+  return (angle < -epsilon || (angle < epsilon && sum < -epsilon2)) ^ (winding & 1);
+}

package/src/discontinuous/world-composite-kernels.ts

@@ -0,0 +1,30 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {gringortenRaw} from './gringorten-kernel';
+
+/** Gilbert's two-world transform followed by an orthographic hemisphere. */
+export function gilbertRaw(lambda: number, phi: number): number[] {
+  const y = Math.tan(phi / 2);
+  return [Math.sqrt(Math.max(0, 1 - y * y)) * Math.sin(lambda / 2), y];
+}
+gilbertRaw.invert = (x: number, y: number): number[] => [
+  2 * Math.asin(Math.max(-1, Math.min(1, x / Math.sqrt(Math.max(0, 1 - y * y))))),
+  2 * Math.atan(y)
+];
+
+/** Place the two Gringorten hemisphere squares side by side. */
+export function rectangularGringortenRaw(lambda: number, phi: number): number[] {
+  const side = lambda > 0 ? 1 : -1;
+  const point = gringortenRaw(lambda - (side * Math.PI) / 2, phi);
+  return [point[0] + side, point[1]];
+}
+rectangularGringortenRaw.invert = (x: number, y: number): number[] => {
+  const side = x > 0 ? 1 : -1;
+  const point = gringortenRaw.invert(x - side, y);
+  let lambda = point[0] + (side * Math.PI) / 2;
+  if (lambda > Math.PI) lambda -= 2 * Math.PI;
+  if (lambda < -Math.PI) lambda += 2 * Math.PI;
+  return [lambda, point[1]];
+};

package/src/discontinuous/world-kernels/INTEGRATE-LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Ricky Reusser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/src/discontinuous/world-kernels/README.md

@@ -0,0 +1,24 @@
+# World and regional projection kernels
+
+Numeric kernels adapted from [d3-geo-projection 4.0.0](https://github.com/d3/d3-geo-projection/tree/v4.0.0/src),
+by Mike Bostock and the D3 contributors, under the adjacent [ISC license](../D3-LICENSE.txt).
+Each JavaScript file matches its upstream source filename except `d3-geo-raw.js`,
+which is an independent spherical Lambert azimuthal equal-area formula used by Hammer.
+
+Changes: display factories, D3 imports, and unused imports removed; shared numeric
+epsilon tightened to 1e-12 for chart boundary sampling; Newton finite-difference
+steps retained at 1e-6 independently of convergence tolerance. MapEngine supplies
+chart-local clipping, bounded inverse fallback, source coordinates and layout. Regional factories also retain named coefficient tables.
+Armadillo uses explicit domain clipping in place of the displaced hidden-y sentinel;
+Hammer retroazimuthal adds a center inverse limit and chart-side branch handling.
+No D3 runtime dependency is added. The projection formulas retain their historical
+names; attribution to D3 concerns this implementation, not invention of the maps.
+
+`integrate.js` retains the upstream adaptive Simpson integration attribution to
+[scijs/integrate-adaptive-simpson](https://github.com/scijs/integrate-adaptive-simpson),
+Copyright 2015 Ricky Reusser, under the retained [MIT license](./INTEGRATE-LICENSE.txt).
+
+Independent numeric fixtures are generated by
+`modules/geospatial/test/discontinuous/generate-world-reference.mjs` from a separate
+installation of the pinned upstream package. Tests compare forward coordinates,
+check chart-local inverse round trips, and exercise seam/pole geometry separately.

package/src/discontinuous/world-kernels/airy.js

@@ -0,0 +1,43 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+
+import {abs, asin, atan2, cos, epsilon, log, sin, sqrt, tan} from './math.js';
+
+export function airyRaw(beta) {
+  var tanBeta_2 = tan(beta / 2),
+    b = (2 * log(cos(beta / 2))) / (tanBeta_2 * tanBeta_2);
+
+  function forward(x, y) {
+    var cosx = cos(x),
+      cosy = cos(y),
+      siny = sin(y),
+      cosz = cosy * cosx,
+      k = -((1 - cosz ? log((1 + cosz) / 2) / (1 - cosz) : -0.5) + b / (1 + cosz));
+    return [k * cosy * sin(x), k * siny];
+  }
+
+  forward.invert = function (x, y) {
+    var r = sqrt(x * x + y * y),
+      z = -beta / 2,
+      i = 50,
+      delta;
+    if (!r) return [0, 0];
+    do {
+      var z_2 = z / 2,
+        cosz_2 = cos(z_2),
+        sinz_2 = sin(z_2),
+        tanz_2 = sinz_2 / cosz_2,
+        lnsecz_2 = -log(abs(cosz_2));
+      z -= delta =
+        (((2 / tanz_2) * lnsecz_2 - b * tanz_2 - r) /
+          (-lnsecz_2 / (sinz_2 * sinz_2) + 1 - b / (2 * cosz_2 * cosz_2))) *
+        (cosz_2 < 0 ? 0.7 : 1);
+    } while (abs(delta) > epsilon && --i > 0);
+    var sinz = sin(z);
+    return [atan2(x * sinz, r * cos(z)), asin((y * sinz) / r)];
+  };
+
+  return forward;
+}

package/src/discontinuous/world-kernels/aitoff.js

@@ -0,0 +1,48 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {abs, acos, cos, epsilon, pi, sin, sinci, sqrt} from './math.js';
+
+export function aitoffRaw(x, y) {
+  var cosy = cos(y),
+    sincia = sinci(acos(cosy * cos((x /= 2))));
+  return [2 * cosy * sin(x) * sincia, sin(y) * sincia];
+}
+
+// Abort if [x, y] is not within an ellipse centered at [0, 0] with
+// semi-major axis pi and semi-minor axis pi/2.
+aitoffRaw.invert = function (x, y) {
+  if (x * x + 4 * y * y > pi * pi + epsilon) return;
+  var x1 = x,
+    y1 = y,
+    i = 25;
+  do {
+    var sinx = sin(x1),
+      sinx_2 = sin(x1 / 2),
+      cosx_2 = cos(x1 / 2),
+      siny = sin(y1),
+      cosy = cos(y1),
+      sin_2y = sin(2 * y1),
+      sin2y = siny * siny,
+      cos2y = cosy * cosy,
+      sin2x_2 = sinx_2 * sinx_2,
+      c = 1 - cos2y * cosx_2 * cosx_2,
+      e = c ? acos(cosy * cosx_2) * sqrt((f = 1 / c)) : (f = 0),
+      f,
+      fx = 2 * e * cosy * sinx_2 - x,
+      fy = e * siny - y,
+      dxdx = f * (cos2y * sin2x_2 + e * cosy * cosx_2 * sin2y),
+      dxdy = f * (0.5 * sinx * sin_2y - e * 2 * siny * sinx_2),
+      dydx = f * 0.25 * (sin_2y * sinx_2 - e * siny * cos2y * sinx),
+      dydy = f * (sin2y * cosx_2 + e * sin2x_2 * cosy),
+      z = dxdy * dydx - dydy * dxdx;
+    if (!z) break;
+    var dx = (fy * dxdy - fx * dydy) / z,
+      dy = (fx * dydx - fy * dxdx) / z;
+    (x1 -= dx), (y1 -= dy);
+  } while ((abs(dx) > epsilon || abs(dy) > epsilon) && --i > 0);
+  return [x1, y1];
+};

package/src/discontinuous/world-kernels/armadillo.js

@@ -0,0 +1,51 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Domain clipping replaces the upstream out-of-domain y displacement.
+
+import {abs, atan2, cos, epsilon, sin, tan} from './math.js';
+
+export function armadilloRaw(phi0) {
+  var sinPhi0 = sin(phi0),
+    cosPhi0 = cos(phi0),
+    sPhi0 = phi0 >= 0 ? 1 : -1,
+    tanPhi0 = tan(sPhi0 * phi0),
+    k = (1 + sinPhi0 - cosPhi0) / 2;
+
+  function forward(lambda, phi) {
+    var cosPhi = cos(phi),
+      cosLambda = cos((lambda /= 2));
+    return [
+      (1 + cosPhi) * sin(lambda),
+      k + sin(phi) * cosPhi0 - (1 + cosPhi) * sinPhi0 * cosLambda // TODO D3 core should allow null or [NaN, NaN] to be returned.
+    ];
+  }
+
+  forward.invert = function (x, y) {
+    var lambda = 0,
+      phi = 0,
+      i = 50;
+    do {
+      var cosLambda = cos(lambda),
+        sinLambda = sin(lambda),
+        cosPhi = cos(phi),
+        sinPhi = sin(phi),
+        A = 1 + cosPhi,
+        fx = A * sinLambda - x,
+        fy = k + sinPhi * cosPhi0 - A * sinPhi0 * cosLambda - y,
+        dxdLambda = (A * cosLambda) / 2,
+        dxdPhi = -sinLambda * sinPhi,
+        dydLambda = (sinPhi0 * A * sinLambda) / 2,
+        dydPhi = cosPhi0 * cosPhi + sinPhi0 * cosLambda * sinPhi,
+        denominator = dxdPhi * dydLambda - dydPhi * dxdLambda,
+        dLambda = (fy * dxdPhi - fx * dydPhi) / denominator / 2,
+        dPhi = (fx * dydLambda - fy * dxdLambda) / denominator;
+      if (abs(dPhi) > 2) dPhi /= 2;
+      (lambda -= dLambda), (phi -= dPhi);
+    } while ((abs(dLambda) > epsilon || abs(dPhi) > epsilon) && --i > 0);
+    return sPhi0 * phi > -atan2(cos(lambda), tanPhi0) - 1e-3 ? [lambda * 2, phi] : null;
+  };
+
+  return forward;
+}

package/src/discontinuous/world-kernels/august.js

@@ -0,0 +1,36 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {abs, arcosh, arsinh, asin, atan2, cos, cosh, sign, sin, sinh, sqrt, tan} from './math.js';
+
+export function augustRaw(lambda, phi) {
+  var tanPhi = tan(phi / 2),
+    k = sqrt(1 - tanPhi * tanPhi),
+    c = 1 + k * cos((lambda /= 2)),
+    x = (sin(lambda) * k) / c,
+    y = tanPhi / c,
+    x2 = x * x,
+    y2 = y * y;
+  return [(4 / 3) * x * (3 + x2 - 3 * y2), (4 / 3) * y * (3 + 3 * x2 - y2)];
+}
+
+augustRaw.invert = function (x, y) {
+  (x *= 3 / 8), (y *= 3 / 8);
+  if (!x && abs(y) > 1) return null;
+  var x2 = x * x,
+    y2 = y * y,
+    s = 1 + x2 + y2,
+    sin3Eta = sqrt((s - sqrt(s * s - 4 * y * y)) / 2),
+    eta = asin(sin3Eta) / 3,
+    xi = sin3Eta ? arcosh(abs(y / sin3Eta)) / 3 : arsinh(abs(x)) / 3,
+    cosEta = cos(eta),
+    coshXi = cosh(xi),
+    d = coshXi * coshXi - cosEta * cosEta;
+  return [
+    sign(x) * 2 * atan2(sinh(xi) * cosEta, 0.25 - d),
+    sign(y) * 2 * atan2(coshXi * sin(eta), 0.25 + d)
+  ];
+};

package/src/discontinuous/world-kernels/baker.js

@@ -0,0 +1,50 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {
+  abs,
+  atan,
+  cos,
+  epsilon2,
+  exp,
+  halfPi,
+  log,
+  quarterPi,
+  sign,
+  sin,
+  sqrt,
+  sqrt2,
+  tan
+} from './math.js';
+
+var sqrt8 = sqrt(8),
+  phi0 = log(1 + sqrt2);
+
+export function bakerRaw(lambda, phi) {
+  var phi0 = abs(phi);
+  return phi0 < quarterPi
+    ? [lambda, log(tan(quarterPi + phi / 2))]
+    : [
+        lambda * cos(phi0) * (2 * sqrt2 - 1 / sin(phi0)),
+        sign(phi) * (2 * sqrt2 * (phi0 - quarterPi) - log(tan(phi0 / 2)))
+      ];
+}
+
+bakerRaw.invert = function (x, y) {
+  if ((y0 = abs(y)) < phi0) return [x, 2 * atan(exp(y)) - halfPi];
+  var phi = quarterPi,
+    i = 25,
+    delta,
+    y0;
+  do {
+    var cosPhi_2 = cos(phi / 2),
+      tanPhi_2 = tan(phi / 2);
+    phi -= delta =
+      (sqrt8 * (phi - quarterPi) - log(tanPhi_2) - y0) /
+      (sqrt8 - (cosPhi_2 * cosPhi_2) / (2 * tanPhi_2));
+  } while (abs(delta) > epsilon2 && --i > 0);
+  return [x / (cos(phi) * (sqrt8 - 1 / sin(phi))), sign(y) * phi];
+};

package/src/discontinuous/world-kernels/bertin.js

@@ -0,0 +1,41 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {hammerRaw} from './hammer.js';
+import {cos, pi, sin} from './math.js';
+import {solve2d} from './newton.js';
+
+// Bertin 1953 as a modified Briesemeister
+// https://bl.ocks.org/Fil/5b9ee9636dfb6ffa53443c9006beb642
+export function bertin1953Raw() {
+  var hammer = hammerRaw(1.68, 2),
+    fu = 1.4,
+    k = 12;
+
+  function forward(lambda, phi) {
+    if (lambda + phi < -fu) {
+      var u = ((lambda - phi + 1.6) * (lambda + phi + fu)) / 8;
+      lambda += u;
+      phi -= 0.8 * u * sin(phi + pi / 2);
+    }
+
+    var r = hammer(lambda, phi);
+
+    var d = (1 - cos(lambda * phi)) / k;
+
+    if (r[1] < 0) {
+      r[0] *= 1 + d;
+    }
+    if (r[1] > 0) {
+      r[1] *= 1 + (d / 1.5) * r[0] * r[0];
+    }
+
+    return r;
+  }
+
+  forward.invert = solve2d(forward);
+  return forward;
+}

package/src/discontinuous/world-kernels/boggs.js

@@ -0,0 +1,32 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {mollweideBromleyTheta} from './mollweide.js';
+import {abs, cos, epsilon, pi, quarterPi, sin, sqrt2} from './math.js';
+
+var k = 2.00276,
+  w = 1.11072;
+
+export function boggsRaw(lambda, phi) {
+  var theta = mollweideBromleyTheta(pi, phi);
+  return [(k * lambda) / (1 / cos(phi) + w / cos(theta)), (phi + sqrt2 * sin(theta)) / k];
+}
+
+boggsRaw.invert = function (x, y) {
+  var ky = k * y,
+    theta = y < 0 ? -quarterPi : quarterPi,
+    i = 25,
+    delta,
+    phi;
+  do {
+    phi = ky - sqrt2 * sin(theta);
+    theta -= delta =
+      (sin(2 * theta) + 2 * theta - pi * sin(phi)) /
+      (2 * cos(2 * theta) + 2 + pi * cos(phi) * sqrt2 * cos(theta));
+  } while (abs(delta) > epsilon && --i > 0);
+  phi = ky - sqrt2 * sin(theta);
+  return [(x * (1 / cos(phi) + w / cos(theta))) / k, phi];
+};

package/src/discontinuous/world-kernels/bonne.js

@@ -0,0 +1,27 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {atan2, cos, sin, sqrt, tan} from './math.js';
+import {sinusoidalRaw} from './sinusoidal.js';
+
+export function bonneRaw(phi0) {
+  if (!phi0) return sinusoidalRaw;
+  var cotPhi0 = 1 / tan(phi0);
+
+  function forward(lambda, phi) {
+    var rho = cotPhi0 + phi0 - phi,
+      e = rho ? (lambda * cos(phi)) / rho : rho;
+    return [rho * sin(e), cotPhi0 - rho * cos(e)];
+  }
+
+  forward.invert = function (x, y) {
+    var rho = sqrt(x * x + (y = cotPhi0 - y) * y),
+      phi = cotPhi0 + phi0 - rho;
+    return [(rho / cos(phi)) * atan2(x, y), phi];
+  };
+
+  return forward;
+}

package/src/discontinuous/world-kernels/bottomley.js

@@ -0,0 +1,25 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {atan2, cos, halfPi, sin, sqrt} from './math.js';
+
+export function bottomleyRaw(sinPsi) {
+  function forward(lambda, phi) {
+    var rho = halfPi - phi,
+      eta = rho ? (lambda * sinPsi * sin(rho)) / rho : rho;
+    return [(rho * sin(eta)) / sinPsi, halfPi - rho * cos(eta)];
+  }
+
+  forward.invert = function (x, y) {
+    var x1 = x * sinPsi,
+      y1 = halfPi - y,
+      rho = sqrt(x1 * x1 + y1 * y1),
+      eta = atan2(x1, y1);
+    return [((rho ? rho / sin(rho) : 1) * eta) / sinPsi, halfPi - rho];
+  };
+
+  return forward;
+}

package/src/discontinuous/world-kernels/bromley.js

@@ -0,0 +1,10 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {pi} from './math.js';
+import {mollweideBromleyRaw} from './mollweide.js';
+
+export var bromleyRaw = mollweideBromleyRaw(1, 4 / pi, pi);

package/src/discontinuous/world-kernels/chamberlin.js

@@ -0,0 +1,97 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+
+import {abs, acos, asin, atan2, cos, epsilon, floor, pi, sin, sqrt} from './math.js';
+
+// Azimuthal distance.
+function distance(dPhi, c1, s1, c2, s2, dLambda) {
+  var cosdLambda = cos(dLambda),
+    r;
+  if (abs(dPhi) > 1 || abs(dLambda) > 1) {
+    r = acos(s1 * s2 + c1 * c2 * cosdLambda);
+  } else {
+    var sindPhi = sin(dPhi / 2),
+      sindLambda = sin(dLambda / 2);
+    r = 2 * asin(sqrt(sindPhi * sindPhi + c1 * c2 * sindLambda * sindLambda));
+  }
+  return abs(r) > epsilon ? [r, atan2(c2 * sin(dLambda), c1 * s2 - s1 * c2 * cosdLambda)] : [0, 0];
+}
+
+// Angle opposite a, and contained between sides of lengths b and c.
+function angle(b, c, a) {
+  return acos((b * b + c * c - a * a) / (2 * b * c));
+}
+
+// Normalize longitude.
+function longitude(lambda) {
+  return lambda - 2 * pi * floor((lambda + pi) / (2 * pi));
+}
+
+export function chamberlinRaw(p0, p1, p2) {
+  var points = [
+    [p0[0], p0[1], sin(p0[1]), cos(p0[1])],
+    [p1[0], p1[1], sin(p1[1]), cos(p1[1])],
+    [p2[0], p2[1], sin(p2[1]), cos(p2[1])]
+  ];
+
+  for (var a = points[2], b, i = 0; i < 3; ++i, a = b) {
+    b = points[i];
+    a.v = distance(b[1] - a[1], a[3], a[2], b[3], b[2], b[0] - a[0]);
+    a.point = [0, 0];
+  }
+
+  var beta0 = angle(points[0].v[0], points[2].v[0], points[1].v[0]),
+    beta1 = angle(points[0].v[0], points[1].v[0], points[2].v[0]),
+    beta2 = pi - beta0;
+
+  points[2].point[1] = 0;
+  points[0].point[0] = -(points[1].point[0] = points[0].v[0] / 2);
+
+  var mean = [
+    (points[2].point[0] = points[0].point[0] + points[2].v[0] * cos(beta0)),
+    2 * (points[0].point[1] = points[1].point[1] = points[2].v[0] * sin(beta0))
+  ];
+
+  function forward(lambda, phi) {
+    var sinPhi = sin(phi),
+      cosPhi = cos(phi),
+      v = new Array(3),
+      i;
+
+    // Compute distance and azimuth from control points.
+    for (i = 0; i < 3; ++i) {
+      var p = points[i];
+      v[i] = distance(phi - p[1], p[3], p[2], cosPhi, sinPhi, lambda - p[0]);
+      if (!v[i][0]) return p.point;
+      v[i][1] = longitude(v[i][1] - p.v[1]);
+    }
+
+    // Arithmetic mean of interception points.
+    var point = mean.slice();
+    for (i = 0; i < 3; ++i) {
+      var j = i === 2 ? 0 : i + 1;
+      var a = angle(points[i].v[0], v[i][0], v[j][0]);
+      if (v[i][1] < 0) a = -a;
+
+      if (!i) {
+        point[0] += v[i][0] * cos(a);
+        point[1] -= v[i][0] * sin(a);
+      } else if (i === 1) {
+        a = beta1 - a;
+        point[0] -= v[i][0] * cos(a);
+        point[1] -= v[i][0] * sin(a);
+      } else {
+        a = beta2 - a;
+        point[0] += v[i][0] * cos(a);
+        point[1] += v[i][0] * sin(a);
+      }
+    }
+
+    (point[0] /= 3), (point[1] /= 3);
+    return point;
+  }
+
+  return forward;
+}

package/src/discontinuous/world-kernels/collignon.js

@@ -0,0 +1,17 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {asin, pi, sin, sqrt, sqrtPi} from './math.js';
+
+export function collignonRaw(lambda, phi) {
+  var alpha = sqrt(1 - sin(phi));
+  return [(2 / sqrtPi) * lambda * alpha, sqrtPi * (1 - alpha)];
+}
+
+collignonRaw.invert = function (x, y) {
+  var lambda = (lambda = y / sqrtPi - 1) * lambda;
+  return [lambda > 0 ? (x * sqrt(pi / lambda)) / 2 : 0, asin(1 - lambda)];
+};