d3js-plugins-rails 0.0.2 → 0.0.3

data/vendor/assets/javascripts/d3/plugins/geo/projection/hammer-retroazimuthal.js

@@ -1,18 +1,15 @@
 function hammerRetroazimuthal(φ0) {
   var sinφ0 = Math.sin(φ0),
-      cosφ0 = Math.cos(φ0);
+      cosφ0 = Math.cos(φ0),
+      rotate = hammerRetroazimuthalRotation(φ0);
+  rotate.invert = hammerRetroazimuthalRotation(-φ0);
 
   function forward(λ, φ) {
-    var cosφ = Math.cos(φ),
-        // Cartesian coordinates.
-        x = Math.cos(λ) * cosφ,
-        y = Math.sin(λ) * cosφ,
-        z = Math.sin(φ),
-        // Latitudinal rotation of φ by φ0.
-        sinφ = z * cosφ0 + x * sinφ0,
-        // Latitudinal rotation of λ by φ0 (inline).
-        cosλ = Math.cos(λ = Math.atan2(y, x * cosφ0 - z * sinφ0)),
-        cosφ = Math.cos(φ = asin(sinφ)),
+    var p = rotate(λ, φ);
+    λ = p[0], φ = p[1];
+    var sinφ = Math.sin(φ),
+        cosφ = Math.cos(φ),
+        cosλ = Math.cos(λ),
         z = acos(sinφ0 * sinφ + cosφ0 * cosφ * cosλ),
         sinz = Math.sin(z),
         K = Math.abs(sinz) > ε ? z / sinz : 1;
@@ -23,9 +20,40 @@ function hammerRetroazimuthal(φ0) {
     ];
   }
 
+  forward.invert = function(x, y) {
+    var ρ = Math.sqrt(x * x + y * y),
+        sinz = -Math.sin(ρ),
+        cosz = Math.cos(ρ),
+        a = ρ * cosz,
+        b = -y * sinz,
+        c = ρ * sinφ0,
+        d = asqrt(a * a + b * b - c * c),
+        φ = Math.atan2(a * c + b * d, b * c - a * d),
+        λ = (ρ > π / 2 ? -1 : 1) * Math.atan2(x * sinz, ρ * Math.cos(φ) * cosz + y * Math.sin(φ) * sinz);
+    return rotate.invert(λ, φ);
+  };
+
   return forward;
 }
 
+// Latitudinal rotation by φ0.
+// Temporary hack until D3 supports arbitrary small-circle clipping origins.
+function hammerRetroazimuthalRotation(φ0) {
+  var sinφ0 = Math.sin(φ0),
+      cosφ0 = Math.cos(φ0);
+
+  return function(λ, φ) {
+    var cosφ = Math.cos(φ),
+        x = Math.cos(λ) * cosφ,
+        y = Math.sin(λ) * cosφ,
+        z = Math.sin(φ);
+    return [
+      Math.atan2(y, x * cosφ0 - z * sinφ0),
+      asin(z * cosφ0 + x * sinφ0)
+    ];
+  };
+}
+
 function hammerRetroazimuthalProjection() {
   var φ0 = 0,
       m = projectionMutator(hammerRetroazimuthal),
@@ -40,6 +68,7 @@ function hammerRetroazimuthalProjection() {
     return m(φ0 = _ * π / 180).rotate(r);
   };
 
+  // Temporary hack; see hammerRetroazimuthalRotation.
   p.rotate = function(_) {
     if (!arguments.length) return (_ = rotate_.call(p), _[1] += φ0 / π * 180, _);
     rotate_.call(p, [_[0], _[1] - φ0 / π * 180]);

data/vendor/assets/javascripts/d3/plugins/geo/projection/lagrange.js

@@ -1,5 +1,5 @@
 function lagrange(n) {
-  return function(λ, φ) {
+  function forward(λ, φ) {
     if (Math.abs(Math.abs(φ) - π / 2) < ε) return [0, φ < 0 ? -2 : 2];
     var sinφ = Math.sin(φ),
         v = Math.pow((1 + sinφ) / (1 - sinφ), n / 2),
@@ -8,7 +8,25 @@ function lagrange(n) {
       2 * Math.sin(λ) / c,
       (v - 1 / v) / c
     ];
+  }
+
+  forward.invert = function(x, y) {
+    var y0 = Math.abs(y);
+    if (Math.abs(y0 - 2) < ε) return x ? null : [0, sgn(y) * π / 2];
+    if (y0 > 2) return null;
+
+    x /= 2, y /= 2;
+    var x2 = x * x,
+        y2 = y * y,
+        t = 2 * y / (1 + x2 + y2); // tanh(nφ)
+    t = Math.pow((1 + t) / (1 - t), 1 / n);
+    return [
+      Math.atan2(2 * x, 1 - x2 - y2) / n,
+      asin((t - 1) / (t + 1))
+    ];
   };
+
+  return forward;
 }
 
 function lagrangeProjection() {

data/vendor/assets/javascripts/d3/plugins/geo/projection/laskowski.js

@@ -7,8 +7,8 @@ function laskowski(λ, φ) {
 }
 
 laskowski.invert = function(x, y) {
-  var λ = x,
-      φ = y,
+  var λ = sgn(x) * π,
+      φ = y / 2,
       i = 50;
   do {
     var λ2 = λ * λ,
@@ -25,7 +25,7 @@ laskowski.invert = function(x, y) {
         δφ = (fx * δyδλ - fy * δxδλ) / denominator;
     λ -= δλ, φ -= δφ;
   } while ((Math.abs(δλ) > ε || Math.abs(δφ) > ε) && --i > 0);
-  return [λ, φ];
+  return i && [λ, φ];
 };
 
 (d3.geo.laskowski = function() { return projection(laskowski); }).raw = laskowski;

data/vendor/assets/javascripts/d3/plugins/geo/projection/modified-stereographic.js

@@ -0,0 +1,104 @@
+function modifiedStereographic(C) {
+  var m = C.length - 1;
+
+  function forward(λ, φ) {
+    var cosφ = Math.cos(φ),
+        k = 2 / (1 + cosφ * Math.cos(λ)),
+        zr = k * cosφ * Math.sin(λ),
+        zi = k * Math.sin(φ),
+        i = m,
+        w = C[i],
+        ar = w[0],
+        ai = w[1],
+        t;
+    while (--i >= 0) {
+      w = C[i];
+      ar = w[0] + zr * (t = ar) - zi * ai;
+      ai = w[1] + zr * ai + zi * t;
+    }
+    ar = zr * (t = ar) - zi * ai;
+    ai = zr * ai + zi * t;
+    return [ar, ai];
+  }
+
+  forward.invert = function(x, y) {
+    var i = 20,
+        zr = x,
+        zi = y;
+    do {
+      var j = m,
+          w = C[j],
+          ar = w[0],
+          ai = w[1],
+          br = 0,
+          bi = 0,
+          t;
+
+      while (--j >= 0) {
+        w = C[j];
+        br = ar + zr * (t = br) - zi * bi;
+        bi = ai + zr * bi + zi * t;
+        ar = w[0] + zr * (t = ar) - zi * ai;
+        ai = w[1] + zr * ai + zi * t;
+      }
+      br = ar + zr * (t = br) - zi * bi;
+      bi = ai + zr * bi + zi * t;
+      ar = zr * (t = ar) - zi * ai - x;
+      ai = zr * ai + zi * t - y;
+
+      var denominator = br * br + bi * bi, δr, δi;
+      zr -= δr = (ar * br + ai * bi) / denominator;
+      zi -= δi = (ai * br - ar * bi) / denominator;
+    } while (Math.abs(δr) + Math.abs(δi) > ε * ε && --i > 0);
+
+    if (i) {
+      var ρ = Math.sqrt(zr * zr + zi * zi),
+          c = 2 * Math.atan(ρ * .5),
+          sinc = Math.sin(c);
+      return [Math.atan2(zr * sinc, ρ * Math.cos(c)), ρ ? asin(zi * sinc / ρ) : 0];
+    }
+  };
+
+  return forward;
+}
+
+var modifiedStereographicCoefficients = {
+  alaska: [
+    [ .9972523, 0],
+    [ .0052513, -.0041175],
+    [ .0074606,  .0048125],
+    [-.0153783, -.1968253],
+    [ .0636871, -.1408027],
+    [ .3660976, -.2937382]
+  ],
+  gs48: [[.98879, 0], [0, 0], [-.050909, 0], [0, 0], [.075528, 0]],
+  gs50: [
+    [ .9842990, 0],
+    [ .0211642,  .0037608],
+    [-.1036018, -.0575102],
+    [-.0329095, -.0320119],
+    [ .0499471,  .1223335],
+    [ .0260460,  .0899805],
+    [ .0007388, -.1435792],
+    [ .0075848, -.1334108],
+    [-.0216473,  .0776645],
+    [-.0225161,  .0853673]
+  ],
+  miller: [[.9245, 0], [0, 0], [.01943, 0]],
+  lee: [[.721316, 0], [0, 0], [-.00881625, -.00617325]]
+};
+
+function modifiedStereographicProjection() {
+  var coefficients = modifiedStereographicCoefficients.miller,
+      m = projectionMutator(modifiedStereographic),
+      p = m(coefficients);
+
+  p.coefficients = function(_) {
+    if (!arguments.length) return coefficients;
+    return m(coefficients = typeof _ === "string" ? modifiedStereographicCoefficients[_] : _);
+  };
+
+  return p;
+}
+
+(d3.geo.modifiedStereographic = modifiedStereographicProjection).raw = modifiedStereographic;

data/vendor/assets/javascripts/d3/plugins/geo/projection/peirce-quincuncial.js

@@ -1,14 +1,50 @@
 // @import guyou
 
 function peirceQuincuncial(λ, φ) {
+  var k_ = (Math.SQRT2 - 1) / (Math.SQRT2 + 1),
+      k = Math.sqrt(1 - k_ * k_),
+      K = ellipticF(π / 2, k * k);
+
   var t = Math.abs(λ) < π / 2,
-      p = guyou(t ? λ : -sgn(λ) * (π - Math.abs(λ)), φ),
-      x = p[0] / Math.SQRT2 - p[1] / Math.SQRT2,
-      y = p[1] / Math.SQRT2 + p[0] / Math.SQRT2;
+      p = guyou(λ + (λ < -π / 2 ? 1.5 : -.5) * π, φ);
+
+  p[0] += (t ? .5 : -.5) * K;
+
+  var x = (p[0] - p[1]) * Math.SQRT1_2,
+      y = (p[0] + p[1]) * Math.SQRT1_2;
+
   if (t) return [x, y];
-  var d = 2 * 1.311028777082283, // TODO unobfuscate
-      s = (x > 0) ^ (y > 0) ? -1 : 1;
+
+  var d = K * Math.SQRT1_2,
+      s = x > 0 ^ y > 0 ? -1 : 1;
+
   return [s * x - sgn(y) * d, s * y - sgn(x) * d];
 }
 
+peirceQuincuncial.invert = function(x0, y0) {
+  var k_ = (Math.SQRT2 - 1) / (Math.SQRT2 + 1),
+      k = Math.sqrt(1 - k_ * k_),
+      K = ellipticF(π / 2, k * k);
+
+  var x = (x0 + y0) * Math.SQRT1_2,
+      y = (y0 - x0) * Math.SQRT1_2;
+
+  var t = Math.abs(x) < .5 * K && Math.abs(y) < .5 * K;
+
+  if (!t) {
+    var d = K * Math.SQRT1_2,
+        s = x > 0 ^ y > 0 ? -1 : 1,
+        x1 = -s * (x0 + (y > 0 ? 1 : -1) * d),
+        y1 = -s * (y0 + (x > 0 ? 1 : -1) * d);
+    x = (-x1 - y1) * Math.SQRT1_2;
+    y = (x1 - y1) * Math.SQRT1_2;
+  }
+
+  x -= (t ? .5 : -.5) * K;
+
+  var p = guyou.invert(x, y);
+  p[0] += .5 * π;
+  return p;
+};
+
 (d3.geo.peirceQuincuncial = function() { return projection(peirceQuincuncial).rotate([-90, -90, 45]).clipAngle(180 - 1e-6); }).raw = peirceQuincuncial;

data/vendor/assets/javascripts/d3/plugins/geo/projection/polyconic.js

@@ -11,13 +11,17 @@ function polyconic(λ, φ) {
 polyconic.invert = function(x, y) {
   if (Math.abs(y) < ε) return [x, 0];
   var k = x * x + y * y,
-      φ = y;
-  for (var i = 0, δ = Infinity; i < 10 && Math.abs(δ) > ε; i++) {
-    var tanφ = Math.tan(φ);
-    φ -= δ = (y * (φ * tanφ + 1) - φ - .5 * (φ * φ + k) * tanφ) / ((φ - y) / tanφ - 1);
-  }
+      φ = y * .5,
+      i = 10, δ;
+  do {
+    var tanφ = Math.tan(φ),
+        secφ = 1 / Math.cos(φ),
+        j = k - 2 * y * φ + φ * φ;
+    φ -= δ = (tanφ * j + 2 * (φ - y)) / (2 + j * secφ * secφ + 2 * (φ - y) * tanφ);
+  } while (Math.abs(δ) > ε && --i > 0);
+  tanφ = Math.tan(φ);
   return [
-    asin(x * Math.tan(φ)) / Math.sin(φ),
+    (Math.abs(y) < Math.abs(φ + 1 / tanφ) ? asin(x * tanφ) : sgn(x) * (acos(Math.abs(x * tanφ)) + π / 2)) / Math.sin(φ),
     φ
   ];
 };

data/vendor/assets/javascripts/d3/plugins/geo/projection/projection.js

@@ -27,3 +27,24 @@ function asin(x) {
 function acos(x) {
   return x > 1 ? 0 : x < -1 ? π : Math.acos(x);
 }
+
+function tanh(x) {
+  x = Math.exp(2 * x);
+  return (x - 1) / (x + 1);
+}
+
+function sinh(x) {
+  return .5 * (Math.exp(x) - Math.exp(-x));
+}
+
+function cosh(x) {
+  return .5 * (Math.exp(x) + Math.exp(-x));
+}
+
+function arsinh(x) {
+  return Math.log(x + asqrt(x * x + 1));
+}
+
+function arcosh(x) {
+  return Math.log(x + asqrt(x * x - 1));
+}

data/vendor/assets/javascripts/d3/plugins/geo/projection/rectangular-polyconic.js

@@ -0,0 +1,40 @@
+// @import parallel1
+
+function rectangularPolyconic(φ0) {
+  var sinφ0 = Math.sin(φ0);
+
+  function forward(λ, φ) {
+    var A = sinφ0 ? Math.tan(λ * sinφ0 / 2) / sinφ0 : λ / 2;
+    if (!φ) return [2 * A, -φ0];
+    var E = 2 * Math.atan(A * Math.sin(φ)),
+        cotφ = 1 / Math.tan(φ);
+    return [
+      Math.sin(E) * cotφ,
+      φ + (1 - Math.cos(E)) * cotφ - φ0
+    ];
+  }
+
+  // TODO return null for points outside outline.
+  forward.invert = function(x, y) {
+    if (Math.abs(y += φ0) < ε) return [sinφ0 ? 2 * Math.atan(sinφ0 * x / 2) / sinφ0 : x, 0];
+    var k = x * x + y * y,
+        φ = 0,
+        i = 10, δ;
+    do {
+      var tanφ = Math.tan(φ),
+          secφ = 1 / Math.cos(φ),
+          j = k - 2 * y * φ + φ * φ;
+      φ -= δ = (tanφ * j + 2 * (φ - y)) / (2 + j * secφ * secφ + 2 * (φ - y) * tanφ);
+    } while (Math.abs(δ) > ε && --i > 0);
+    var E = x * (tanφ = Math.tan(φ)),
+        A = Math.tan(Math.abs(y) < Math.abs(φ + 1 / tanφ) ? asin(E) * .5 : acos(E) * .5 + π / 4) / Math.sin(φ);
+    return [
+      sinφ0 ? 2 * Math.atan(sinφ0 * A) / sinφ0 : 2 * A,
+      φ
+    ];
+  };
+
+  return forward;
+}
+
+(d3.geo.rectangularPolyconic = function() { return parallel1Projection(rectangularPolyconic); }).raw = rectangularPolyconic;

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/august-test.js

@@ -0,0 +1,27 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.august");
+
+suite.addBatch({
+  "august": {
+    topic: d3.geo.august,
+    "projections and inverse projections": function(august) {
+      assert.equalInverse(august, [  0,   0], [480,        250]);
+      assert.equalInverse(august, [  0, -45], [480,        378.067905]);
+      assert.equalInverse(august, [  0,  45], [480,        121.932094]);
+      assert.equalInverse(august, [  0,  90], [480,       -150]);
+      assert.equalInverse(august, [  0,  80], [480,        -43.976545]);
+      assert.equalInverse(august, [-90,   0], [217.258300, 250]);
+      assert.equalInverse(august, [ 90,   0], [742.741699, 250]);
+      assert.equalInverse(august, [-80,  15], [254.414080, 199.297313]);
+      assert.equalInverse(august, [  1,   1], [482.617927, 247.381806]);
+      assert.equalInverse(august, [ 15,  80], [499.471722, -45.366200]);
+      assert.equalInverse(august, [100,  50], [732.424769,  43.602745]);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/berghaus-test.js

@@ -0,0 +1,26 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.berghaus");
+
+suite.addBatch({
+  "berghaus": {
+    topic: d3.geo.berghaus,
+    "projections and inverse projections": function(berghaus) {
+      assert.equalInverse(berghaus, [  0,   0], [480,        250]);
+      assert.equalInverse(berghaus, [  0, -45], [480,        367.809724]);
+      assert.equalInverse(berghaus, [  0,  45], [480,        132.190275]);
+      assert.equalInverse(berghaus, [-90,   0], [244.380550, 250]);
+      assert.equalInverse(berghaus, [ 90,   0], [715.619449, 250]);
+      assert.equalInverse(berghaus, [-80,  15], [277.038148, 194.777583]);
+      assert.equalInverse(berghaus, [  1,   1], [482.617728, 247.381873]);
+      assert.equalInverse(berghaus, [ 15,  45], [510.778518, 131.080938]);
+      assert.equalInverse(berghaus, [120,  30], [750.967904, 114.867516]);
+      assert.equalInverse(berghaus, [110,  10], [759.454234, 183.963114]);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/test/craig-test.js

@@ -7,17 +7,32 @@ var suite = vows.describe("d3.geo.craig");
 
 suite.addBatch({
   "craig": {
-    topic: d3.geo.craig,
-    "projections and inverse projections": function(craig) {
-      assert.inDelta(craig([   0,   0]), [480,          250], 1e-6);
-      assert.inDelta(craig([   0, -90]), [480,          400], 1e-6);
-      assert.inDelta(craig([   0,  90]), [480,          100], 1e-6);
-      assert.inDelta(craig([   0, -45]), [480,          356.066017], 1e-6);
-      assert.inDelta(craig([   0,  45]), [480,          143.933982], 1e-6);
-      assert.inDelta(craig([-180,   0]), [  8.761101,   250], 1e-6);
-      assert.inDelta(craig([ 180,   0]), [951.238898,   250], 1e-6);
-      assert.inDelta(craig([-179,  15]), [ 11.3790958, 7198.585721], 1e-6);
-      assert.inDelta(craig([   1,   1]), [482.617993,   247.382404], 1e-6);
+    "0° parallel": {
+      topic: d3.geo.craig,
+      "projections and inverse projections": function(craig) {
+        assert.equalInverse(craig, [   0,   0], [480,          250]);
+        assert.equalInverse(craig, [   0, -90], [480,          400]);
+        assert.equalInverse(craig, [   0,  90], [480,          100]);
+        assert.equalInverse(craig, [   0, -45], [480,          356.066017]);
+        assert.equalInverse(craig, [   0,  45], [480,          143.933982]);
+        assert.equalInverse(craig, [-180,   0], [  8.761101,   250]);
+        assert.equalInverse(craig, [ 180,   0], [951.238898,   250]);
+        assert.equalInverse(craig, [-179,  15], [ 11.3790958, 7198.585721]);
+        assert.equalInverse(craig, [   1,   1], [482.617993,   247.382404]);
+      }
+    },
+    "30° parallel": {
+      topic: function() {
+        return d3.geo.craig().parallel(30);
+      },
+      "projections and inverse projections": function(craig) {
+        assert.equalInverse(craig, [   0,   0], [480,        250]);
+        assert.equalInverse(craig, [   0, -30], [480,        313.397459]);
+        assert.equalInverse(craig, [   0,  30], [480,        163.397459]);
+        assert.equalInverse(craig, [   0, -45], [480,        330.700720]);
+        assert.equalInverse(craig, [   0,  45], [480,        118.568686]);
+        assert.equalInverse(craig, [   1,   1], [482.617993, 247.373611]);
+      }
     }
   }
 });