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

package/src/discontinuous/world-kernels/sinuMollweide.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 {mollweideRaw} from './mollweide.js';
+import {sinusoidalRaw} from './sinusoidal.js';
+
+export var sinuMollweidePhi = 0.7109889596207567;
+
+export var sinuMollweideY = 0.0528035274542;
+
+export function sinuMollweideRaw(lambda, phi) {
+  return phi > -sinuMollweidePhi
+    ? ((lambda = mollweideRaw(lambda, phi)), (lambda[1] += sinuMollweideY), lambda)
+    : sinusoidalRaw(lambda, phi);
+}
+
+sinuMollweideRaw.invert = function (x, y) {
+  return y > -sinuMollweidePhi
+    ? mollweideRaw.invert(x, y - sinuMollweideY)
+    : sinusoidalRaw.invert(x, y);
+};

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

@@ -0,0 +1,15 @@
+// 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} from './math.js';
+
+export function sinusoidalRaw(lambda, phi) {
+  return [lambda * cos(phi), phi];
+}
+
+sinusoidalRaw.invert = function (x, y) {
+  return [x / cos(y), y];
+};

package/src/discontinuous/world-kernels/times.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, quarterPi, sin, tan} from './math.js';
+
+export function timesRaw(lambda, phi) {
+  var t = tan(phi / 2),
+    s = sin(quarterPi * t);
+  return [lambda * (0.74482 - 0.34588 * s * s), 1.70711 * t];
+}
+
+timesRaw.invert = function (x, y) {
+  var t = y / 1.70711,
+    s = sin(quarterPi * t);
+  return [x / (0.74482 - 0.34588 * s * s), 2 * atan(t)];
+};

package/src/discontinuous/world-kernels/twoPointEquidistant.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.
+
+import {geoAzimuthalEquidistantRaw as azimuthalEquidistantRaw} from './d3-geo-raw.js';
+import {acos, atan2, cos, sin, sqrt, tan} from './math.js';
+
+export function twoPointEquidistantRaw(z0) {
+  if (!(z0 *= 2)) return azimuthalEquidistantRaw;
+  var lambdaa = -z0 / 2,
+    lambdab = -lambdaa,
+    z02 = z0 * z0,
+    tanLambda0 = tan(lambdab),
+    S = 0.5 / sin(lambdab);
+
+  function forward(lambda, phi) {
+    var za = acos(cos(phi) * cos(lambda - lambdaa)),
+      zb = acos(cos(phi) * cos(lambda - lambdab)),
+      ys = phi < 0 ? -1 : 1;
+    (za *= za), (zb *= zb);
+    return [
+      (za - zb) / (2 * z0),
+      (ys * sqrt(4 * z02 * zb - (z02 - za + zb) * (z02 - za + zb))) / (2 * z0)
+    ];
+  }
+
+  forward.invert = function (x, y) {
+    var y2 = y * y,
+      cosza = cos(sqrt(y2 + (t = x + lambdaa) * t)),
+      coszb = cos(sqrt(y2 + (t = x + lambdab) * t)),
+      t,
+      d;
+    return [
+      atan2((d = cosza - coszb), (t = (cosza + coszb) * tanLambda0)),
+      (y < 0 ? -1 : 1) * acos(sqrt(t * t + d * d) * S)
+    ];
+  };
+
+  return forward;
+}

package/src/discontinuous/world-kernels/vanDerGrinten.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, asin, atan, cos, epsilon, halfPi, pi, sign, sin, sqrt, tan} from './math.js';
+
+export function vanDerGrintenRaw(lambda, phi) {
+  if (abs(phi) < epsilon) return [lambda, 0];
+  var sinTheta = abs(phi / halfPi),
+    theta = asin(sinTheta);
+  if (abs(lambda) < epsilon || abs(abs(phi) - halfPi) < epsilon)
+    return [0, sign(phi) * pi * tan(theta / 2)];
+  var cosTheta = cos(theta),
+    A = abs(pi / lambda - lambda / pi) / 2,
+    A2 = A * A,
+    G = cosTheta / (sinTheta + cosTheta - 1),
+    P = G * (2 / sinTheta - 1),
+    P2 = P * P,
+    P2_A2 = P2 + A2,
+    G_P2 = G - P2,
+    Q = A2 + G;
+  return [
+    (sign(lambda) * pi * (A * G_P2 + sqrt(A2 * G_P2 * G_P2 - P2_A2 * (G * G - P2)))) / P2_A2,
+    (sign(phi) * pi * (P * Q - A * sqrt((A2 + 1) * P2_A2 - Q * Q))) / P2_A2
+  ];
+}
+
+vanDerGrintenRaw.invert = function (x, y) {
+  if (abs(y) < epsilon) return [x, 0];
+  if (abs(x) < epsilon) return [0, halfPi * sin(2 * atan(y / pi))];
+  var x2 = (x /= pi) * x,
+    y2 = (y /= pi) * y,
+    x2_y2 = x2 + y2,
+    z = x2_y2 * x2_y2,
+    c1 = -abs(y) * (1 + x2_y2),
+    c2 = c1 - 2 * y2 + x2,
+    c3 = -2 * c1 + 1 + 2 * y2 + z,
+    d = y2 / c3 + ((2 * c2 * c2 * c2) / (c3 * c3 * c3) - (9 * c1 * c2) / (c3 * c3)) / 27,
+    a1 = (c1 - (c2 * c2) / (3 * c3)) / c3,
+    m1 = 2 * sqrt(-a1 / 3),
+    theta1 = acos((3 * d) / (a1 * m1)) / 3;
+  return [
+    (pi * (x2_y2 - 1 + sqrt(1 + 2 * (x2 - y2) + z))) / (2 * x),
+    sign(y) * pi * (-m1 * cos(theta1 + pi / 3) - c2 / (3 * c3))
+  ];
+};

package/src/discontinuous/world-kernels/vanDerGrinten2.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 {abs, asin, atan, atan2, cos, halfPi, epsilon, pi, sign, sin, sqrt, tan} from './math.js';
+
+export function vanDerGrinten2Raw(lambda, phi) {
+  if (abs(phi) < epsilon) return [lambda, 0];
+  var sinTheta = abs(phi / halfPi),
+    theta = asin(sinTheta);
+  if (abs(lambda) < epsilon || abs(abs(phi) - halfPi) < epsilon)
+    return [0, sign(phi) * pi * tan(theta / 2)];
+  var cosTheta = cos(theta),
+    A = abs(pi / lambda - lambda / pi) / 2,
+    A2 = A * A,
+    x1 = (cosTheta * (sqrt(1 + A2) - A * cosTheta)) / (1 + A2 * sinTheta * sinTheta);
+  return [sign(lambda) * pi * x1, sign(phi) * pi * sqrt(1 - x1 * (2 * A + x1))];
+}
+
+vanDerGrinten2Raw.invert = function (x, y) {
+  if (!x) return [0, halfPi * sin(2 * atan(y / pi))];
+  var x1 = abs(x / pi),
+    A = (1 - x1 * x1 - (y /= pi) * y) / (2 * x1),
+    A2 = A * A,
+    B = sqrt(A2 + 1);
+  return [
+    sign(x) * pi * (B - A),
+    sign(y) * halfPi * sin(2 * atan2(sqrt((1 - 2 * A * x1) * (A + B) - x1), sqrt(B + A + x1)))
+  ];
+};

package/src/discontinuous/world-kernels/vanDerGrinten3.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, atan, cos, epsilon, halfPi, pi, sign, sin, sqrt, tan} from './math.js';
+
+export function vanDerGrinten3Raw(lambda, phi) {
+  if (abs(phi) < epsilon) return [lambda, 0];
+  var sinTheta = phi / halfPi,
+    theta = asin(sinTheta);
+  if (abs(lambda) < epsilon || abs(abs(phi) - halfPi) < epsilon) return [0, pi * tan(theta / 2)];
+  var A = (pi / lambda - lambda / pi) / 2,
+    y1 = sinTheta / (1 + cos(theta));
+  return [pi * (sign(lambda) * sqrt(A * A + 1 - y1 * y1) - A), pi * y1];
+}
+
+vanDerGrinten3Raw.invert = function (x, y) {
+  if (!y) return [x, 0];
+  var y1 = y / pi,
+    A = (pi * pi * (1 - y1 * y1) - x * x) / (2 * pi * x);
+  return [x ? pi * (sign(x) * sqrt(A * A + 1) - A) : 0, halfPi * sin(2 * atan(y1))];
+};

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

@@ -0,0 +1,70 @@
+// 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, halfPi, min, pi, sign, sqrt} from './math.js';
+
+export function vanDerGrinten4Raw(lambda, phi) {
+  if (!phi) return [lambda, 0];
+  var phi0 = abs(phi);
+  if (!lambda || phi0 === halfPi) return [0, phi];
+  var B = phi0 / halfPi,
+    B2 = B * B,
+    C = (8 * B - B2 * (B2 + 2) - 5) / (2 * B2 * (B - 1)),
+    C2 = C * C,
+    BC = B * C,
+    B_C2 = B2 + C2 + 2 * BC,
+    B_3C = B + 3 * C,
+    lambda0 = lambda / halfPi,
+    lambda1 = lambda0 + 1 / lambda0,
+    D = sign(abs(lambda) - halfPi) * sqrt(lambda1 * lambda1 - 4),
+    D2 = D * D,
+    F =
+      B_C2 * (B2 + C2 * D2 - 1) +
+      (1 - B2) * (B2 * (B_3C * B_3C + 4 * C2) + 12 * BC * C2 + 4 * C2 * C2),
+    x1 = (D * (B_C2 + C2 - 1) + 2 * sqrt(F)) / (4 * B_C2 + D2);
+  return [sign(lambda) * halfPi * x1, sign(phi) * halfPi * sqrt(1 + D * abs(x1) - x1 * x1)];
+}
+
+vanDerGrinten4Raw.invert = function (x, y) {
+  var delta;
+  if (!x || !y) return [x, y];
+  var sy = sign(y);
+  y = abs(y) / pi;
+  var x1 = (sign(x) * x) / halfPi,
+    D = (x1 * x1 - 1 + 4 * y * y) / abs(x1),
+    D2 = D * D,
+    B = y * (2 - (y > 0.5 ? min(y, abs(x)) : 0)),
+    r = x * x + y * y,
+    i = 50;
+  do {
+    var B2 = B * B,
+      C = (8 * B - B2 * (B2 + 2) - 5) / (2 * B2 * (B - 1)),
+      C_ = (3 * B - B2 * B - 10) / (2 * B2 * B),
+      C2 = C * C,
+      BC = B * C,
+      B_C = B + C,
+      B_C2 = B_C * B_C,
+      B_3C = B + 3 * C,
+      F =
+        B_C2 * (B2 + C2 * D2 - 1) +
+        (1 - B2) * (B2 * (B_3C * B_3C + 4 * C2) + C2 * (12 * BC + 4 * C2)),
+      F_ =
+        -2 *
+        B_C *
+        (4 * BC * C2 +
+          (1 - 4 * B2 + 3 * B2 * B2) * (1 + C_) +
+          C2 * (-6 + 14 * B2 - D2 + (-8 + 8 * B2 - 2 * D2) * C_) +
+          BC * (-8 + 12 * B2 + (-10 + 10 * B2 - D2) * C_)),
+      sqrtF = sqrt(F),
+      f = D * (B_C2 + C2 - 1) + 2 * sqrtF - x1 * (4 * B_C2 + D2),
+      f_ =
+        D * (2 * C * C_ + 2 * B_C * (1 + C_)) +
+        F_ / sqrtF -
+        (8 * B_C * (D * (-1 + C2 + B_C2) + 2 * sqrtF) * (1 + C_)) / (D2 + 4 * B_C2);
+    B -= delta = f / f_;
+  } while (delta * r * r > epsilon && --i > 0);
+  return [(sign(x) * (sqrt(D * D + 4) + D) * pi) / 4, sy * halfPi * B];
+};

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

@@ -0,0 +1,61 @@
+// 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 {acos, asin, atan2, cos, epsilon, halfPi, max, min, pi, sin, sqrt, tan} from './math.js';
+
+function wagnerFormula(cx, cy, m1, m2, n) {
+  function forward(lambda, phi) {
+    var s = m1 * sin(m2 * phi),
+      c0 = sqrt(1 - s * s),
+      c1 = sqrt(2 / (1 + c0 * cos((lambda *= n))));
+    return [cx * c0 * c1 * sin(lambda), cy * s * c1];
+  }
+
+  forward.invert = function (x, y) {
+    var t1 = x / cx,
+      t2 = y / cy,
+      p = sqrt(t1 * t1 + t2 * t2),
+      c = 2 * asin(p / 2);
+    return [atan2(x * tan(c), cx * p) / n, p && asin((y * sin(c)) / (cy * m1 * p)) / m2];
+  };
+
+  return forward;
+}
+
+export function wagnerRaw(poleline, parallels, inflation, ratio) {
+  // 60 is always used as reference parallel
+  var phi1 = pi / 3;
+
+  // sanitizing the input values
+  // poleline and parallels may approximate but never equal 0
+  poleline = max(poleline, epsilon);
+  parallels = max(parallels, epsilon);
+  // poleline must be <= 90; parallels may approximate but never equal 180
+  poleline = min(poleline, halfPi);
+  parallels = min(parallels, pi - epsilon);
+  // 0 <= inflation <= 99.999
+  inflation = max(inflation, 0);
+  inflation = min(inflation, 100 - epsilon);
+  // ratio > 0.
+  // sensible values, i.e. something that renders a map which still can be
+  // recognized as world map, are e.g. 20 <= ratio <= 1000.
+  ratio = max(ratio, epsilon);
+
+  // convert values from boehm notation
+  // areal inflation e.g. from 0 to 1 or 20 to 1.2:
+  var vinflation = inflation / 100 + 1;
+  // axial ratio e.g. from 200 to 2:
+  var vratio = ratio / 100;
+  // the other ones are a bit more complicated...
+  var m2 = acos(vinflation * cos(phi1)) / phi1,
+    m1 = sin(poleline) / sin(m2 * halfPi),
+    n = parallels / pi,
+    k = sqrt((vratio * sin(poleline / 2)) / sin(parallels / 2)),
+    cx = k / sqrt(n * m1 * m2),
+    cy = 1 / (k * sqrt(n * m1 * m2));
+
+  return wagnerFormula(cx, cy, m1, m2, n);
+}

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

@@ -0,0 +1,13 @@
+// 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 {sqrt, pi} from './math.js';
+import {mollweideBromleyRaw} from './mollweide.js';
+
+var A = 4 * pi + 3 * sqrt(3),
+  B = 2 * sqrt((2 * pi * sqrt(3)) / A);
+
+export var wagner4Raw = mollweideBromleyRaw((B * sqrt(3)) / pi, B, A / 6);

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

@@ -0,0 +1,15 @@
+// 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 wagner6Raw(lambda, phi) {
+  return [lambda * sqrt(1 - (3 * phi * phi) / (pi * pi)), phi];
+}
+
+wagner6Raw.invert = function (x, y) {
+  return [x / sqrt(1 - (3 * y * y) / (pi * pi)), y];
+};

package/src/discontinuous/world-kernels/wiechel.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.
+
+import {asin, atan2, cos, sin, sqrt} from './math.js';
+
+export function wiechelRaw(lambda, phi) {
+  var cosPhi = cos(phi),
+    sinPhi = cos(lambda) * cosPhi,
+    sin1_Phi = 1 - sinPhi,
+    cosLambda = cos((lambda = atan2(sin(lambda) * cosPhi, -sin(phi)))),
+    sinLambda = sin(lambda);
+  cosPhi = sqrt(1 - sinPhi * sinPhi);
+  return [sinLambda * cosPhi - cosLambda * sin1_Phi, -cosLambda * cosPhi - sinLambda * sin1_Phi];
+}
+
+wiechelRaw.invert = function (x, y) {
+  var w = (x * x + y * y) / -2,
+    k = sqrt(-w * (2 + w)),
+    b = y * w + x * k,
+    a = x * w - y * k,
+    D = sqrt(a * a + b * b);
+  return [atan2(k * b, D * (1 + w)), D ? -asin((k * a) / D) : 0];
+};

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

@@ -0,0 +1,45 @@
+// 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 {aitoffRaw} from './aitoff.js';
+import {halfPi, epsilon, sin, cos, sqrt, abs, acos} from './math.js';
+
+export function winkel3Raw(lambda, phi) {
+  var coordinates = aitoffRaw(lambda, phi);
+  return [(coordinates[0] + lambda / halfPi) / 2, (coordinates[1] + phi) / 2];
+}
+
+winkel3Raw.invert = function (x, y) {
+  var lambda = x,
+    phi = y,
+    i = 25;
+  do {
+    var cosphi = cos(phi),
+      sinphi = sin(phi),
+      sin_2phi = sin(2 * phi),
+      sin2phi = sinphi * sinphi,
+      cos2phi = cosphi * cosphi,
+      sinlambda = sin(lambda),
+      coslambda_2 = cos(lambda / 2),
+      sinlambda_2 = sin(lambda / 2),
+      sin2lambda_2 = sinlambda_2 * sinlambda_2,
+      C = 1 - cos2phi * coslambda_2 * coslambda_2,
+      E = C ? acos(cosphi * coslambda_2) * sqrt((F = 1 / C)) : (F = 0),
+      F,
+      fx = 0.5 * (2 * E * cosphi * sinlambda_2 + lambda / halfPi) - x,
+      fy = 0.5 * (E * sinphi + phi) - y,
+      dxdlambda =
+        0.5 * F * (cos2phi * sin2lambda_2 + E * cosphi * coslambda_2 * sin2phi) + 0.5 / halfPi,
+      dxdphi = F * ((sinlambda * sin_2phi) / 4 - E * sinphi * sinlambda_2),
+      dydlambda = 0.125 * F * (sin_2phi * sinlambda_2 - E * sinphi * cos2phi * sinlambda),
+      dydphi = 0.5 * F * (sin2phi * coslambda_2 + E * sin2lambda_2 * cosphi) + 0.5,
+      denominator = dxdphi * dydlambda - dydphi * dxdlambda,
+      dlambda = (fy * dxdphi - fx * dydphi) / denominator,
+      dphi = (fx * dydlambda - fy * dxdlambda) / denominator;
+    (lambda -= dlambda), (phi -= dphi);
+  } while ((abs(dlambda) > epsilon || abs(dphi) > epsilon) && --i > 0);
+  return [lambda, phi];
+};