d3js-plugins-rails 0.0.1

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

@@ -0,0 +1,21 @@
+function littrow(λ, φ) {
+  return [
+    Math.sin(λ) / Math.cos(φ),
+    Math.tan(φ) * Math.cos(λ)
+  ];
+}
+
+littrow.invert = function(x, y) {
+  var x2 = x * x,
+      y2 = y * y,
+      y2_1 = y2 + 1,
+      cosφ = x
+        ? Math.SQRT1_2 * Math.sqrt((y2_1 - Math.sqrt(x2 * x2 + 2 * x2 * (y2 - 1) + y2_1 * y2_1)) / x2 + 1)
+        : 1 / Math.sqrt(y2_1);
+  return [
+    asin(x * cosφ),
+    sgn(y) * acos(cosφ)
+  ];
+};
+
+(d3.geo.littrow = function() { return projection(littrow); }).raw = littrow;

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

@@ -0,0 +1,29 @@
+// @import parallel1
+
+function loximuthal(φ0) {
+  var cosφ0 = Math.cos(φ0),
+      tanφ0 = Math.tan(π / 4 + φ0 / 2);
+
+  function forward(λ, φ) {
+    var y = φ - φ0,
+        x = Math.abs(y) < ε ? λ * cosφ0
+        : Math.abs(x = π / 4 + φ / 2) < ε || Math.abs(Math.abs(x) - π / 2) < ε
+        ? 0 : λ * y / Math.log(Math.tan(x) / tanφ0);
+    return [x, y];
+  }
+
+  forward.invert = function(x, y) {
+    var λ,
+        φ = y + φ0;
+    return [
+      Math.abs(y) < ε ? x / cosφ0
+        : (Math.abs(λ = π / 4 + φ / 2) < ε || Math.abs(Math.abs(λ) - π / 2) < ε) ? 0
+        : x * Math.log(Math.tan(λ) / tanφ0) / y,
+      φ
+    ];
+  };
+
+  return forward;
+}
+
+(d3.geo.loximuthal = function() { return parallel1Projection(loximuthal).parallel(40); }).raw = loximuthal;

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

@@ -0,0 +1,15 @@
+function miller(λ, φ) {
+  return [
+    λ,
+    1.25 * Math.log(Math.tan(π / 4 + .4 * φ))
+  ];
+}
+
+miller.invert = function(x, y) {
+  return [
+    x,
+    2.5 * Math.atan(Math.exp(.8 * y)) - .625 * π
+  ];
+};
+
+(d3.geo.miller = function() { return projection(miller); }).raw = miller;

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

@@ -0,0 +1,35 @@
+function mollweideBromleyθ(Cp) {
+  return function(θ) {
+    var Cpsinθ = Cp * Math.sin(θ),
+        i = 30, δ;
+    do θ -= δ = (θ + Math.sin(θ) - Cpsinθ) / (1 + Math.cos(θ));
+    while (Math.abs(δ) > ε && --i > 0);
+    return θ / 2;
+  };
+}
+
+function mollweideBromley(Cx, Cy, Cp) {
+  var θ = mollweideBromleyθ(Cp);
+
+  function forward(λ, φ) {
+    return [
+      Cx * λ * Math.cos(φ = θ(φ)),
+      Cy * Math.sin(φ)
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var θ = asin(y / Cy);
+    return [
+      x / (Cx * Math.cos(θ)),
+      asin((2 * θ + Math.sin(2 * θ)) / Cp)
+    ];
+  };
+
+  return forward;
+}
+
+var mollweideθ = mollweideBromleyθ(π),
+    mollweide = mollweideBromley(2 * Math.SQRT2 / π, Math.SQRT2, π);
+
+(d3.geo.mollweide = function() { return projection(mollweide); }).raw = mollweide;

data/vendor/assets/javascripts/d3/plugins/geo/projection/mt-flat-polar-parabolic.js

@@ -0,0 +1,21 @@
+function mtFlatPolarParabolic(λ, φ) {
+  var sqrt6 = Math.sqrt(6),
+      sqrt7 = Math.sqrt(7),
+      θ = Math.asin(7 * Math.sin(φ) / (3 * sqrt6));
+  return [
+    sqrt6 * λ * (2 * Math.cos(2 * θ / 3) - 1) / sqrt7,
+    9 * Math.sin(θ / 3) / sqrt7
+  ];
+}
+
+mtFlatPolarParabolic.invert = function(x, y) {
+  var sqrt6 = Math.sqrt(6),
+      sqrt7 = Math.sqrt(7),
+      θ = 3 * asin(y * sqrt7 / 9);
+  return [
+    x * sqrt7 / (sqrt6 * (2 * Math.cos(2 * θ / 3) - 1)),
+    asin(Math.sin(θ) * 3 * sqrt6 / 7)
+  ];
+};
+
+(d3.geo.mtFlatPolarParabolic = function() { return projection(mtFlatPolarParabolic); }).raw = mtFlatPolarParabolic;

data/vendor/assets/javascripts/d3/plugins/geo/projection/mt-flat-polar-quartic.js

@@ -0,0 +1,23 @@
+function mtFlatPolarQuartic(λ, φ) {
+  var k = (1 + Math.SQRT1_2) * Math.sin(φ),
+      θ = φ;
+  for (var i = 0, δ; i < 25; i++) {
+    θ -= δ = (Math.sin(θ / 2) + Math.sin(θ) - k) / (.5 * Math.cos(θ / 2) + Math.cos(θ));
+    if (Math.abs(δ) < ε) break;
+  }
+  return [
+    λ * (1 + 2 * Math.cos(θ) / Math.cos(θ / 2)) / (3 * Math.SQRT2),
+    2 * Math.sqrt(3) * Math.sin(θ / 2) / Math.sqrt(2 + Math.SQRT2)
+  ];
+}
+
+mtFlatPolarQuartic.invert = function(x, y) {
+  var sinθ_2 = y * Math.sqrt(2 + Math.SQRT2) / (2 * Math.sqrt(3)),
+      θ = 2 * asin(sinθ_2);
+  return [
+    3 * Math.SQRT2 * x / (1 + 2 * Math.cos(θ) / Math.cos(θ / 2)),
+    asin((sinθ_2 + Math.sin(θ)) / (1 + Math.SQRT1_2))
+  ];
+};
+
+(d3.geo.mtFlatPolarQuartic = function() { return projection(mtFlatPolarQuartic); }).raw = mtFlatPolarQuartic;

data/vendor/assets/javascripts/d3/plugins/geo/projection/mt-flat-polar-sinusoidal.js

@@ -0,0 +1,25 @@
+function mtFlatPolarSinusoidal(λ, φ) {
+  var A = Math.sqrt(6 / (4 + π)),
+      k = (1 + π / 4) * Math.sin(φ),
+      θ = φ / 2;
+  for (var i = 0, δ; i < 25; i++) {
+    θ -= δ = (θ / 2 + Math.sin(θ) - k) / (.5 + Math.cos(θ));
+    if (Math.abs(δ) < ε) break;
+  }
+  return [
+    A * (.5 + Math.cos(θ)) * λ / 1.5,
+    A * θ
+  ];
+}
+
+mtFlatPolarSinusoidal.invert = function(x, y) {
+  var A = Math.sqrt(6 / (4 + π)),
+      θ = y / A;
+  if (Math.abs(Math.abs(θ) - π / 2) < ε) θ = θ < 0 ? -π / 2 : π / 2;
+  return [
+    1.5 * x / (A * (.5 + Math.cos(θ))),
+    asin((θ / 2 + Math.sin(θ)) / (1 + π / 4))
+  ];
+};
+
+(d3.geo.mtFlatPolarSinusoidal = function() { return projection(mtFlatPolarSinusoidal); }).raw = mtFlatPolarSinusoidal;

data/vendor/assets/javascripts/d3/plugins/geo/projection/natural-earth.js

@@ -0,0 +1,22 @@
+function naturalEarth(λ, φ) {
+  var φ2 = φ * φ, φ4 = φ2 * φ2;
+  return [
+    λ * (.8707 - .131979 * φ2 + φ4 * (-.013791 + φ4 * (.003971 * φ2 - .001529 * φ4))),
+    φ * (1.007226 + φ2 * (.015085 + φ4 * (-.044475 + .028874 * φ2 - .005916 * φ4)))
+  ];
+}
+
+naturalEarth.invert = function(x, y) {
+  var φ = y, i = 25, δ;
+  do {
+    var φ2 = φ * φ, φ4 = φ2 * φ2;
+    φ -= δ = (φ * (1.007226 + φ2 * (.015085 + φ4 * (-.044475 + .028874 * φ2 - .005916 * φ4))) - y) /
+        (1.007226 + φ2 * (.015085 * 3 + φ4 * (-.044475 * 7 + .028874 * 9 * φ2 - .005916 * 11 * φ4)));
+  } while (Math.abs(δ) > ε && --i > 0);
+  return [
+    x / (.8707 + (φ2 = φ * φ) * (-.131979 + φ2 * (-.013791 + φ2 * φ2 * φ2 * (.003971 - .001529 * φ2)))),
+    φ
+  ];
+};
+
+(d3.geo.naturalEarth = function() { return projection(naturalEarth); }).raw = naturalEarth;

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

@@ -0,0 +1,20 @@
+function nellHammer(λ, φ) {
+  return [
+    λ * (1 + Math.cos(φ)) / 2,
+    2 * (φ - Math.tan(φ / 2))
+  ];
+}
+
+nellHammer.invert = function(x, y) {
+  var p = y / 2;
+  for (var i = 0, δ = Infinity; i < 10 && Math.abs(δ) > ε; i++) {
+    var c = Math.cos(y / 2);
+    y -= δ = (y - Math.tan(y / 2) - p) / (1 - .5 / (c * c));
+  }
+  return [
+    2 * x / (1 + Math.cos(y)),
+    y
+  ];
+};
+
+(d3.geo.nellHammer = function() { return projection(nellHammer); }).raw = nellHammer;

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

@@ -0,0 +1,12 @@
+function parallel1Projection(projectAt) {
+  var φ0 = 0,
+      m = projectionMutator(projectAt),
+      p = m(φ0);
+
+  p.parallel = function(_) {
+    if (!arguments.length) return φ0 / π * 180;
+    return m(φ0 = _ * π / 180);
+  };
+
+  return p;
+}

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

@@ -0,0 +1,13 @@
+function parallel2Projection(projectAt) {
+  var φ0 = 0,
+      φ1 = π / 3,
+      m = projectionMutator(projectAt),
+      p = m(φ0, φ1);
+
+  p.parallels = function(_) {
+    if (!arguments.length) return [φ0 / π * 180, φ1 / π * 180];
+    return m(φ0 = _[0] * π / 180, φ1 = _[1] * π / 180);
+  };
+
+  return p;
+}

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

@@ -0,0 +1,14 @@
+// @import guyou
+
+function peirceQuincuncial(λ, φ) {
+  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;
+  if (t) return [x, y];
+  var d = 2 * 1.311028777082283, // TODO unobfuscate
+      s = (x > 0) ^ (y > 0) ? -1 : 1;
+  return [s * x - sgn(y) * d, s * y - sgn(x) * d];
+}
+
+(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

@@ -0,0 +1,25 @@
+function polyconic(λ, φ) {
+  if (Math.abs(φ) < ε) return [λ, 0];
+  var tanφ = Math.tan(φ),
+      k = λ * Math.sin(φ);
+  return [
+    Math.sin(k) / tanφ,
+    φ + (1 - Math.cos(k)) / tanφ
+  ];
+}
+
+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);
+  }
+  return [
+    asin(x * Math.tan(φ)) / Math.sin(φ),
+    φ
+  ];
+};
+
+(d3.geo.polyconic = function() { return projection(polyconic); }).raw = polyconic;

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

@@ -0,0 +1,29 @@
+var ε = 1e-6,
+    ε2 = ε * ε,
+    π = Math.PI,
+    sqrtπ = Math.sqrt(π),
+    radians = π / 180,
+    degrees = 180 / π;
+
+var projection = d3.geo.projection,
+    projectionMutator = d3.geo.projectionMutator;
+
+function sinci(x) {
+  return x ? x / Math.sin(x) : 1;
+}
+
+function sgn(x) {
+  return x > 0 ? 1 : x < 0 ? -1 : 0;
+}
+
+function asqrt(x) {
+  return x > 0 ? Math.sqrt(x) : 0;
+}
+
+function asin(x) {
+  return x > 1 ? π / 2 : x < -1 ? -π / 2 : Math.asin(x);
+}
+
+function acos(x) {
+  return x > 1 ? 0 : x < -1 ? π : Math.acos(x);
+}

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

@@ -0,0 +1,83 @@
+var robinsonConstants = [
+  [0.9986, -0.062],
+  [1.0000, 0.0000],
+  [0.9986, 0.0620],
+  [0.9954, 0.1240],
+  [0.9900, 0.1860],
+  [0.9822, 0.2480],
+  [0.9730, 0.3100],
+  [0.9600, 0.3720],
+  [0.9427, 0.4340],
+  [0.9216, 0.4958],
+  [0.8962, 0.5571],
+  [0.8679, 0.6176],
+  [0.8350, 0.6769],
+  [0.7986, 0.7346],
+  [0.7597, 0.7903],
+  [0.7186, 0.8435],
+  [0.6732, 0.8936],
+  [0.6213, 0.9394],
+  [0.5722, 0.9761],
+  [0.5322, 1.0000]
+];
+
+robinsonConstants.forEach(function(d) {
+  d[1] *= 1.0144;
+});
+
+function robinson(λ, φ) {
+  var i = Math.min(18, Math.abs(φ) * 36 / π),
+      i0 = Math.floor(i),
+      di = i - i0,
+      ax = (k = robinsonConstants[i0])[0],
+      ay = k[1],
+      bx = (k = robinsonConstants[++i0])[0],
+      by = k[1],
+      cx = (k = robinsonConstants[Math.min(19, ++i0)])[0],
+      cy = k[1],
+      k;
+  return [
+    λ * (bx + di * (cx - ax) / 2 + di * di * (cx - 2 * bx + ax) / 2),
+    (φ > 0 ? π : -π) / 2 * (by + di * (cy - ay) / 2 + di * di * (cy - 2 * by + ay) / 2)
+  ];
+}
+
+robinson.invert = function(x, y) {
+  var yy = 2 * y / π,
+      φ = yy * 90,
+      i = Math.min(18, Math.abs(φ / 5)),
+      i0 = Math.max(0, Math.floor(i));
+  do {
+    var ay = robinsonConstants[i0][1],
+        by = robinsonConstants[i0 + 1][1],
+        cy = robinsonConstants[Math.min(19, i0 + 2)][1],
+        u = cy - ay,
+        v = cy - 2 * by + ay,
+        t = 2 * (Math.abs(yy) - by) / u,
+        c = v / u,
+        di = t * (1 - c * t * (1 - 2 * c * t));
+    if (di >= 0 || i0 === 1) {
+      φ = (y >= 0 ? 5 : -5) * (di + i);
+      var j = 50, δ;
+      do {
+        i = Math.min(18, Math.abs(φ) / 5);
+        i0 = Math.floor(i);
+        di = i - i0;
+        ay = robinsonConstants[i0][1];
+        by = robinsonConstants[i0 + 1][1];
+        cy = robinsonConstants[Math.min(19, i0 + 2)][1];
+        φ -= (δ = (y >= 0 ? π : -π) / 2 * (by + di * (cy - ay) / 2 + di * di * (cy - 2 * by + ay) / 2) - y) * degrees;
+      } while (Math.abs(δ) > ε2 && --j > 0);
+      break;
+    }
+  } while (--i0 >= 0);
+  var ax = robinsonConstants[i0][0],
+      bx = robinsonConstants[i0 + 1][0],
+      cx = robinsonConstants[Math.min(19, i0 + 2)][0];
+  return [
+    x / (bx + di * (cx - ax) / 2 + di * di * (cx - 2 * bx + ax) / 2),
+    φ * radians
+  ];
+};
+
+(d3.geo.robinson = function() { return projection(robinson); }).raw = robinson;

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

@@ -0,0 +1,68 @@
+function satelliteVertical(P) {
+  function forward(λ, φ) {
+    var cosφ = Math.cos(φ),
+        k = (P - 1) / (P - cosφ * Math.cos(λ));
+    return [
+      k * cosφ * Math.sin(λ),
+      k * Math.sin(φ)
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var ρ2 = x * x + y * y,
+        ρ = Math.sqrt(ρ2),
+        sinc = (P - Math.sqrt(1 - ρ2 * (P + 1) / (P - 1))) / ((P - 1) / ρ + ρ / (P - 1));
+    return [
+      Math.atan2(x * sinc, ρ * Math.sqrt(1 - sinc * sinc)),
+      ρ ? asin(y * sinc / ρ) : 0
+    ];
+  };
+
+  return forward;
+}
+
+function satellite(P, ω) {
+  var vertical = satelliteVertical(P);
+  if (!ω) return vertical;
+  var cosω = Math.cos(ω),
+      sinω = Math.sin(ω);
+
+  function forward(λ, φ) {
+    var coordinates = vertical(λ, φ),
+        y = coordinates[1],
+        A = y * sinω / (P - 1) + cosω;
+    return [
+      coordinates[0] * cosω / A,
+      y / A
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var k = (P - 1) / (P - 1 - y * sinω);
+    return vertical.invert(k * x, k * y * cosω);
+  };
+
+  return forward;
+}
+
+function satelliteProjection() {
+  var P = 1.4,
+      ω = 0,
+      m = projectionMutator(satellite),
+      p = m(P, ω);
+
+  // As a multiple of radius.
+  p.distance = function(_) {
+    if (!arguments.length) return P;
+    return m(P = +_, ω);
+  };
+
+  p.tilt = function(_) {
+    if (!arguments.length) return ω * 180 / π;
+    return m(P, ω = _ * π / 180);
+  };
+
+  return p;
+}
+
+(d3.geo.satellite = satelliteProjection).raw = satellite;