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

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

@@ -0,0 +1,33 @@
+// 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 {asin, atan2, cos, sin, sqrt, tan} from './math.js';
+
+export function craigRaw(phi0) {
+  var tanPhi0 = tan(phi0);
+
+  function forward(lambda, phi) {
+    return [
+      lambda,
+      (lambda ? lambda / sin(lambda) : 1) * (sin(phi) * cos(lambda) - tanPhi0 * cos(phi))
+    ];
+  }
+
+  forward.invert = tanPhi0
+    ? function (x, y) {
+        if (x) y *= sin(x) / x;
+        var cosLambda = cos(x);
+        return [
+          x,
+          2 *
+            atan2(sqrt(cosLambda * cosLambda + tanPhi0 * tanPhi0 - y * y) - cosLambda, tanPhi0 - y)
+        ];
+      }
+    : function (x, y) {
+        return [x, asin(x ? (y * tan(x)) / x : y)];
+      };
+
+  return forward;
+}

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

@@ -0,0 +1,18 @@
+// 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, cos, sin, sqrt, sqrtPi} from './math.js';
+
+var sqrt3 = sqrt(3);
+
+export function crasterRaw(lambda, phi) {
+  return [(sqrt3 * lambda * (2 * cos((2 * phi) / 3) - 1)) / sqrtPi, sqrt3 * sqrtPi * sin(phi / 3)];
+}
+
+crasterRaw.invert = function (x, y) {
+  var phi = 3 * asin(y / (sqrt3 * sqrtPi));
+  return [(sqrtPi * x) / (sqrt3 * (2 * cos((2 * phi) / 3) - 1)), phi];
+};

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

@@ -0,0 +1,21 @@
+// 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, cos, sin} from './math.js';
+
+export function cylindricalEqualAreaRaw(phi0) {
+  var cosPhi0 = cos(phi0);
+
+  function forward(lambda, phi) {
+    return [lambda * cosPhi0, sin(phi) / cosPhi0];
+  }
+
+  forward.invert = function (x, y) {
+    return [x / cosPhi0, asin(y * cosPhi0)];
+  };
+
+  return forward;
+}

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

@@ -0,0 +1,21 @@
+// 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 {atan, cos, tan} from './math.js';
+
+export function cylindricalStereographicRaw(phi0) {
+  var cosPhi0 = cos(phi0);
+
+  function forward(lambda, phi) {
+    return [lambda * cosPhi0, (1 + cosPhi0) * tan(phi / 2)];
+  }
+
+  forward.invert = function (x, y) {
+    return [x / cosPhi0, atan(y / (1 + cosPhi0)) * 2];
+  };
+
+  return forward;
+}

package/src/discontinuous/world-kernels/d3-geo-raw.js

@@ -0,0 +1,26 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// Spherical Lambert azimuthal equal-area formula (unit radius).
+
+export function geoAzimuthalEqualAreaRaw(x, y) {
+  const cy = Math.cos(y),
+    k = Math.sqrt(2 / (1 + Math.cos(x) * cy));
+  return [k * cy * Math.sin(x), k * Math.sin(y)];
+}
+geoAzimuthalEqualAreaRaw.invert = (x, y) => {
+  const r = Math.hypot(x, y),
+    c = 2 * Math.asin(Math.min(1, r / 2));
+  return [Math.atan2(x * Math.sin(c), r * Math.cos(c)), Math.asin(r ? (y * Math.sin(c)) / r : 0)];
+};
+
+export function geoAzimuthalEquidistantRaw(lambda, phi) {
+  const c = Math.acos(Math.max(-1, Math.min(1, Math.cos(lambda) * Math.cos(phi)))),
+    k = c ? c / Math.sin(c) : 1;
+  return [k * Math.cos(phi) * Math.sin(lambda), k * Math.sin(phi)];
+}
+geoAzimuthalEquidistantRaw.invert = (x, y) => {
+  const c = Math.hypot(x, y),
+    s = Math.sin(c);
+  return [Math.atan2(x * s, c * Math.cos(c)), Math.asin(c ? (y * s) / c : 0)];
+};

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

@@ -0,0 +1,18 @@
+// 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, pi, sqrt} from './math.js';
+
+export function eckert1Raw(lambda, phi) {
+  var alpha = sqrt(8 / (3 * pi));
+  return [alpha * lambda * (1 - abs(phi) / pi), alpha * phi];
+}
+
+eckert1Raw.invert = function (x, y) {
+  var alpha = sqrt(8 / (3 * pi)),
+    phi = y / alpha;
+  return [x / (alpha * (1 - abs(phi) / pi)), phi];
+};

package/src/discontinuous/world-kernels/eckert2.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 {abs, asin, pi, sign, sin, sqrt} from './math.js';
+
+export function eckert2Raw(lambda, phi) {
+  var alpha = sqrt(4 - 3 * sin(abs(phi)));
+  return [(2 / sqrt(6 * pi)) * lambda * alpha, sign(phi) * sqrt((2 * pi) / 3) * (2 - alpha)];
+}
+
+eckert2Raw.invert = function (x, y) {
+  var alpha = 2 - abs(y) / sqrt((2 * pi) / 3);
+  return [(x * sqrt(6 * pi)) / (2 * alpha), sign(y) * asin((4 - alpha * alpha) / 3)];
+};

package/src/discontinuous/world-kernels/eckert3.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 {pi, sqrt} from './math.js';
+
+export function eckert3Raw(lambda, phi) {
+  var k = sqrt(pi * (4 + pi));
+  return [(2 / k) * lambda * (1 + sqrt(1 - (4 * phi * phi) / (pi * pi))), (4 / k) * phi];
+}
+
+eckert3Raw.invert = function (x, y) {
+  var k = sqrt(pi * (4 + pi)) / 2;
+  return [(x * k) / (1 + sqrt(1 - (y * y * (4 + pi)) / (4 * pi))), (y * k) / 2];
+};

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

@@ -0,0 +1,24 @@
+// 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, asin, cos, epsilon, halfPi, pi, sin, sqrt} from './math.js';
+
+export function eckert4Raw(lambda, phi) {
+  var k = (2 + halfPi) * sin(phi);
+  phi /= 2;
+  for (var i = 0, delta = Infinity; i < 10 && abs(delta) > epsilon; i++) {
+    var cosPhi = cos(phi);
+    phi -= delta = (phi + sin(phi) * (cosPhi + 2) - k) / (2 * cosPhi * (1 + cosPhi));
+  }
+  return [(2 / sqrt(pi * (4 + pi))) * lambda * (1 + cos(phi)), 2 * sqrt(pi / (4 + pi)) * sin(phi)];
+}
+
+eckert4Raw.invert = function (x, y) {
+  var A = (y * sqrt((4 + pi) / pi)) / 2,
+    k = asin(A),
+    c = cos(k);
+  return [x / ((2 / sqrt(pi * (4 + pi))) * (1 + c)), asin((k + A * (c + 2)) / (2 + halfPi))];
+};

package/src/discontinuous/world-kernels/eckert5.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 {cos, pi, sqrt} from './math.js';
+
+export function eckert5Raw(lambda, phi) {
+  return [(lambda * (1 + cos(phi))) / sqrt(2 + pi), (2 * phi) / sqrt(2 + pi)];
+}
+
+eckert5Raw.invert = function (x, y) {
+  var k = sqrt(2 + pi),
+    phi = (y * k) / 2;
+  return [(k * x) / (1 + cos(phi)), phi];
+};

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

@@ -0,0 +1,22 @@
+// 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, asin, cos, epsilon, halfPi, pi, sin, sqrt} from './math.js';
+
+export function eckert6Raw(lambda, phi) {
+  var k = (1 + halfPi) * sin(phi);
+  for (var i = 0, delta = Infinity; i < 10 && abs(delta) > epsilon; i++) {
+    phi -= delta = (phi + sin(phi) - k) / (1 + cos(phi));
+  }
+  k = sqrt(2 + pi);
+  return [(lambda * (1 + cos(phi))) / k, (2 * phi) / k];
+}
+
+eckert6Raw.invert = function (x, y) {
+  var j = 1 + halfPi,
+    k = sqrt(j / 2);
+  return [(x * 2 * k) / (1 + cos((y *= k))), asin((y + sin(y)) / j)];
+};

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

@@ -0,0 +1,88 @@
+// 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 {augustRaw} from './august.js';
+import {abs, atan, cos, epsilon, halfPi, log, max, min, sin, sqrt, sqrt1_2, sqrt2} from './math.js';
+
+var eisenlohrK = 3 + 2 * sqrt2;
+
+export function eisenlohrRaw(lambda, phi) {
+  var s0 = sin((lambda /= 2)),
+    c0 = cos(lambda),
+    k = sqrt(cos(phi)),
+    c1 = cos((phi /= 2)),
+    t = sin(phi) / (c1 + sqrt2 * c0 * k),
+    c = sqrt(2 / (1 + t * t)),
+    v = sqrt((sqrt2 * c1 + (c0 + s0) * k) / (sqrt2 * c1 + (c0 - s0) * k));
+  return [
+    eisenlohrK * (c * (v - 1 / v) - 2 * log(v)),
+    eisenlohrK * (c * t * (v + 1 / v) - 2 * atan(t))
+  ];
+}
+
+eisenlohrRaw.invert = function (x, y) {
+  if (!(p = augustRaw.invert(x / 1.2, y * 1.065))) return null;
+  var lambda = p[0],
+    phi = p[1],
+    i = 20,
+    p;
+  (x /= eisenlohrK), (y /= eisenlohrK);
+  do {
+    var _0 = lambda / 2,
+      _1 = phi / 2,
+      s0 = sin(_0),
+      c0 = cos(_0),
+      s1 = sin(_1),
+      c1 = cos(_1),
+      cos1 = cos(phi),
+      k = sqrt(cos1),
+      t = s1 / (c1 + sqrt2 * c0 * k),
+      t2 = t * t,
+      c = sqrt(2 / (1 + t2)),
+      v0 = sqrt2 * c1 + (c0 + s0) * k,
+      v1 = sqrt2 * c1 + (c0 - s0) * k,
+      v2 = v0 / v1,
+      v = sqrt(v2),
+      vm1v = v - 1 / v,
+      vp1v = v + 1 / v,
+      fx = c * vm1v - 2 * log(v) - x,
+      fy = c * t * vp1v - 2 * atan(t) - y,
+      deltatDeltaLambda = s1 && (sqrt1_2 * k * s0 * t2) / s1,
+      deltatDeltaPhi =
+        (sqrt2 * c0 * c1 + k) / (2 * (c1 + sqrt2 * c0 * k) * (c1 + sqrt2 * c0 * k) * k),
+      deltacDeltat = -0.5 * t * c * c * c,
+      deltacDeltaLambda = deltacDeltat * deltatDeltaLambda,
+      deltacDeltaPhi = deltacDeltat * deltatDeltaPhi,
+      A = (A = 2 * c1 + sqrt2 * k * (c0 - s0)) * A * v,
+      deltavDeltaLambda = (sqrt2 * c0 * c1 * k + cos1) / A,
+      deltavDeltaPhi = -(sqrt2 * s0 * s1) / (k * A),
+      deltaxDeltaLambda =
+        vm1v * deltacDeltaLambda -
+        (2 * deltavDeltaLambda) / v +
+        c * (deltavDeltaLambda + deltavDeltaLambda / v2),
+      deltaxDeltaPhi =
+        vm1v * deltacDeltaPhi -
+        (2 * deltavDeltaPhi) / v +
+        c * (deltavDeltaPhi + deltavDeltaPhi / v2),
+      deltayDeltaLambda =
+        t * vp1v * deltacDeltaLambda -
+        (2 * deltatDeltaLambda) / (1 + t2) +
+        c * vp1v * deltatDeltaLambda +
+        c * t * (deltavDeltaLambda - deltavDeltaLambda / v2),
+      deltayDeltaPhi =
+        t * vp1v * deltacDeltaPhi -
+        (2 * deltatDeltaPhi) / (1 + t2) +
+        c * vp1v * deltatDeltaPhi +
+        c * t * (deltavDeltaPhi - deltavDeltaPhi / v2),
+      denominator = deltaxDeltaPhi * deltayDeltaLambda - deltayDeltaPhi * deltaxDeltaLambda;
+    if (!denominator) break;
+    var deltaLambda = (fy * deltaxDeltaPhi - fx * deltayDeltaPhi) / denominator,
+      deltaPhi = (fx * deltayDeltaLambda - fy * deltaxDeltaLambda) / denominator;
+    lambda -= deltaLambda;
+    phi = max(-halfPi, min(halfPi, phi - deltaPhi));
+  } while ((abs(deltaLambda) > epsilon || abs(deltaPhi) > epsilon) && --i > 0);
+  return abs(abs(phi) - halfPi) < epsilon ? [0, phi] : i && [lambda, phi];
+};

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

@@ -0,0 +1,19 @@
+// 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 {atan, cos, radians, sqrt, tan} from './math.js';
+
+var faheyK = cos(35 * radians);
+
+export function faheyRaw(lambda, phi) {
+  var t = tan(phi / 2);
+  return [lambda * faheyK * sqrt(1 - t * t), (1 + faheyK) * t];
+}
+
+faheyRaw.invert = function (x, y) {
+  var t = y / (1 + faheyK);
+  return [x && x / (faheyK * sqrt(1 - t * t)), 2 * atan(t)];
+};

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

@@ -0,0 +1,20 @@
+// 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 {atan, cos, sqrtPi, tan} from './math.js';
+
+export function foucautRaw(lambda, phi) {
+  var k = phi / 2,
+    cosk = cos(k);
+  return [((2 * lambda) / sqrtPi) * cos(phi) * cosk * cosk, sqrtPi * tan(k)];
+}
+
+foucautRaw.invert = function (x, y) {
+  var k = atan(y / sqrtPi),
+    cosk = cos(k),
+    phi = 2 * k;
+  return [(x * sqrtPi) / 2 / (cos(phi) * cosk * cosk), phi];
+};

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

@@ -0,0 +1,38 @@
+// 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 {cos, halfPi, pi, sin, sqrt} from './math.js';
+import {solve} from './newton.js';
+
+export function foucautSinusoidalRaw(alpha) {
+  var beta = 1 - alpha,
+    equatorial = raw(pi, 0)[0] - raw(-pi, 0)[0],
+    polar = raw(0, halfPi)[1] - raw(0, -halfPi)[1],
+    ratio = sqrt((2 * polar) / equatorial);
+
+  function raw(lambda, phi) {
+    var cosphi = cos(phi),
+      sinphi = sin(phi);
+    return [(cosphi / (beta + alpha * cosphi)) * lambda, beta * phi + alpha * sinphi];
+  }
+
+  function forward(lambda, phi) {
+    var p = raw(lambda, phi);
+    return [p[0] * ratio, p[1] / ratio];
+  }
+
+  function forwardMeridian(phi) {
+    return forward(0, phi)[1];
+  }
+
+  forward.invert = function (x, y) {
+    var phi = solve(forwardMeridian, y),
+      lambda = (x / ratio) * (alpha + beta / cos(phi));
+    return [lambda, phi];
+  };
+
+  return forward;
+}

package/src/discontinuous/world-kernels/ginzburg4.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 ginzburgPolyconicRaw from './ginzburgPolyconic.js';
+
+export var ginzburg4Raw = ginzburgPolyconicRaw(
+  2.8284,
+  -1.6988,
+  0.75432,
+  -0.18071,
+  1.76003,
+  -0.38914,
+  0.042555
+);

package/src/discontinuous/world-kernels/ginzburg5.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 ginzburgPolyconicRaw from './ginzburgPolyconic.js';
+
+export var ginzburg5Raw = ginzburgPolyconicRaw(
+  2.583819,
+  -0.835827,
+  0.170354,
+  -0.038094,
+  1.543313,
+  -0.411435,
+  0.082742
+);

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

@@ -0,0 +1,19 @@
+// 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 ginzburgPolyconicRaw from './ginzburgPolyconic.js';
+import {pi} from './math.js';
+
+export var ginzburg6Raw = ginzburgPolyconicRaw(
+  (5 / 6) * pi,
+  -0.62636,
+  -0.0344,
+  0,
+  1.3493,
+  -0.05524,
+  0,
+  0.045
+);

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

@@ -0,0 +1,34 @@
+// 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, epsilon} from './math.js';
+
+export function ginzburg8Raw(lambda, phi) {
+  var lambda2 = lambda * lambda,
+    phi2 = phi * phi;
+  return [
+    lambda * (1 - 0.162388 * phi2) * (0.87 - 0.000952426 * lambda2 * lambda2),
+    phi * (1 + phi2 / 12)
+  ];
+}
+
+ginzburg8Raw.invert = function (x, y) {
+  var lambda = x,
+    phi = y,
+    i = 50,
+    delta;
+  do {
+    var phi2 = phi * phi;
+    phi -= delta = (phi * (1 + phi2 / 12) - y) / (1 + phi2 / 4);
+  } while (abs(delta) > epsilon && --i > 0);
+  i = 50;
+  x /= 1 - 0.162388 * phi2;
+  do {
+    var lambda4 = (lambda4 = lambda * lambda) * lambda4;
+    lambda -= delta = (lambda * (0.87 - 0.000952426 * lambda4) - x) / (0.87 - 0.00476213 * lambda4);
+  } while (abs(delta) > epsilon && --i > 0);
+  return [lambda, phi];
+};

package/src/discontinuous/world-kernels/ginzburg9.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 ginzburgPolyconicRaw from './ginzburgPolyconic.js';
+
+export var ginzburg9Raw = ginzburgPolyconicRaw(
+  2.6516,
+  -0.76534,
+  0.19123,
+  -0.047094,
+  1.36289,
+  -0.13965,
+  0.031762
+);

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

@@ -0,0 +1,64 @@
+// 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, asin, cos, epsilon, pi, sin, sqrt} from './math.js';
+
+export default function (a, b, c, d, e, f, g, h) {
+  if (arguments.length < 8) h = 0;
+
+  function forward(lambda, phi) {
+    if (!phi) return [(a * lambda) / pi, 0];
+    var phi2 = phi * phi,
+      xB = a + phi2 * (b + phi2 * (c + phi2 * d)),
+      yB = phi * (e - 1 + phi2 * (f - h + phi2 * g)),
+      m = (xB * xB + yB * yB) / (2 * yB),
+      alpha = (lambda * asin(xB / m)) / pi;
+    return [m * sin(alpha), phi * (1 + phi2 * h) + m * (1 - cos(alpha))];
+  }
+
+  forward.invert = function (x, y) {
+    var lambda = (pi * x) / a,
+      phi = y,
+      deltaLambda,
+      deltaPhi,
+      i = 50;
+    do {
+      var phi2 = phi * phi,
+        xB = a + phi2 * (b + phi2 * (c + phi2 * d)),
+        yB = phi * (e - 1 + phi2 * (f - h + phi2 * g)),
+        p = xB * xB + yB * yB,
+        q = 2 * yB,
+        m = p / q,
+        m2 = m * m,
+        dAlphadLambda = asin(xB / m) / pi,
+        alpha = lambda * dAlphadLambda,
+        xB2 = xB * xB,
+        dxBdPhi = (2 * b + phi2 * (4 * c + phi2 * 6 * d)) * phi,
+        dyBdPhi = e + phi2 * (3 * f + phi2 * 5 * g),
+        dpdPhi = 2 * (xB * dxBdPhi + yB * (dyBdPhi - 1)),
+        dqdPhi = 2 * (dyBdPhi - 1),
+        dmdPhi = (dpdPhi * q - p * dqdPhi) / (q * q),
+        cosAlpha = cos(alpha),
+        sinAlpha = sin(alpha),
+        mcosAlpha = m * cosAlpha,
+        msinAlpha = m * sinAlpha,
+        dAlphadPhi = ((lambda / pi) * (1 / sqrt(1 - xB2 / m2)) * (dxBdPhi * m - xB * dmdPhi)) / m2,
+        fx = msinAlpha - x,
+        fy = phi * (1 + phi2 * h) + m - mcosAlpha - y,
+        deltaxDeltaPhi = dmdPhi * sinAlpha + mcosAlpha * dAlphadPhi,
+        deltaxDeltaLambda = mcosAlpha * dAlphadLambda,
+        deltayDeltaPhi = 1 + dmdPhi - (dmdPhi * cosAlpha - msinAlpha * dAlphadPhi),
+        deltayDeltaLambda = msinAlpha * dAlphadLambda,
+        denominator = deltaxDeltaPhi * deltayDeltaLambda - deltayDeltaPhi * deltaxDeltaLambda;
+      if (!denominator) break;
+      lambda -= deltaLambda = (fy * deltaxDeltaPhi - fx * deltayDeltaPhi) / denominator;
+      phi -= deltaPhi = (fx * deltayDeltaLambda - fy * deltaxDeltaLambda) / denominator;
+    } while ((abs(deltaLambda) > epsilon || abs(deltaPhi) > epsilon) && --i > 0);
+    return [lambda, phi];
+  };
+
+  return forward;
+}

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

@@ -0,0 +1,37 @@
+// 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 {geoAzimuthalEqualAreaRaw as azimuthalEqualAreaRaw} from './d3-geo-raw.js';
+import {asin, cos, sin} from './math.js';
+
+export function hammerRaw(A, B) {
+  if (arguments.length < 2) B = A;
+  if (B === 1) return azimuthalEqualAreaRaw;
+  if (B === Infinity) return hammerQuarticAuthalicRaw;
+
+  function forward(lambda, phi) {
+    var coordinates = azimuthalEqualAreaRaw(lambda / B, phi);
+    coordinates[0] *= A;
+    return coordinates;
+  }
+
+  forward.invert = function (x, y) {
+    var coordinates = azimuthalEqualAreaRaw.invert(x / A, y);
+    coordinates[0] *= B;
+    return coordinates;
+  };
+
+  return forward;
+}
+
+function hammerQuarticAuthalicRaw(lambda, phi) {
+  return [(lambda * cos(phi)) / cos((phi /= 2)), 2 * sin(phi)];
+}
+
+hammerQuarticAuthalicRaw.invert = function (x, y) {
+  var phi = 2 * asin(y / 2);
+  return [(x * cos(phi / 2)) / cos(phi), phi];
+};