d3js-plugins-rails 0.0.1

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

@@ -0,0 +1,51 @@
+var hammerAzimuthalEqualArea = d3.geo.azimuthalEqualArea.raw;
+
+function hammer(A, B) {
+  if (arguments.length < 2) B = A;
+  if (B === 1) return hammerAzimuthalEqualArea;
+  if (B === Infinity) return hammerQuarticAuthalic;
+
+  function forward(λ, φ) {
+    var coordinates = hammerAzimuthalEqualArea(λ / B, φ);
+    coordinates[0] *= A;
+    return coordinates;
+  }
+
+  forward.invert = function(x, y) {
+    var coordinates = hammerAzimuthalEqualArea.invert(x / A, y);
+    coordinates[0] *= B;
+    return coordinates;
+  };
+
+  return forward;
+}
+
+function hammerProjection() {
+  var B = 2,
+      m = projectionMutator(hammer),
+      p = m(B);
+
+  p.coefficient = function(_) {
+    if (!arguments.length) return B;
+    return m(B = +_);
+  };
+
+  return p;
+}
+
+function hammerQuarticAuthalic(λ, φ) {
+  return [
+    λ * Math.cos(φ) / Math.cos(φ /= 2),
+    2 * Math.sin(φ)
+  ];
+}
+
+hammerQuarticAuthalic.invert = function(x, y) {
+  var φ = 2 * asin(y / 2);
+  return [
+    x * Math.cos(φ / 2) / Math.cos(φ),
+    φ
+  ];
+};
+
+(d3.geo.hammer = hammerProjection).raw = hammer;

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

@@ -0,0 +1,25 @@
+function hatano(λ, φ) {
+  var c = Math.sin(φ) * (φ < 0 ? 2.43763 : 2.67595);
+  for (var i = 0, δ; i < 20; i++) {
+    φ -= δ = (φ + Math.sin(φ) - c) / (1 + Math.cos(φ));
+    if (Math.abs(δ) < ε) break;
+  }
+  return [
+    .85 * λ * Math.cos(φ *= .5),
+    Math.sin(φ) * (φ < 0 ? 1.93052 : 1.75859)
+  ];
+}
+
+hatano.invert = function(x, y) {
+  var θ = Math.abs(θ = y * (y < 0 ? .51799515156538134803 : .56863737426006061674)) > 1 - ε
+      ? θ > 0 ? π / 2 : -π / 2
+      : asin(θ);
+  return [
+    1.17647058823529411764 * x / Math.cos(θ),
+    Math.abs(θ = ((θ += θ) + Math.sin(θ)) * (y < 0 ? .41023453108141924738 : .37369906014686373063)) > 1 - ε
+      ? θ > 0 ? π / 2 : -π / 2
+      : asin(θ)
+  ];
+};
+
+(d3.geo.hatano = function() { return projection(hatano); }).raw = hatano;

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

@@ -0,0 +1,64 @@
+var healpixParallel = 41 + 48 / 36 + 37 / 3600; // TODO automate
+
+function healpix(h) {
+  var lambert = d3.geo.cylindricalEqualArea.raw(0),
+      φ0 = healpixParallel * π / 180,
+      dx0 = lambert(π, 0)[0] - lambert(-π, 0)[0],
+      dx1 = d3.geo.collignon.raw(π, φ0)[0] - d3.geo.collignon.raw(-π, φ0)[0],
+      y0 = lambert(0, φ0)[1],
+      y1 = d3.geo.collignon.raw(0, φ0)[1],
+      dy1 = d3.geo.collignon.raw(0, π / 2)[1] - y1,
+      k = 2 * π / h;
+
+  return function(λ, φ) {
+    var point;
+    if (Math.abs(φ) > φ0) {
+      var i = Math.min(h - 1, Math.max(0, Math.floor((λ + π) / k)));
+      λ = λ + π * (h - 1) / h - i * k;
+      point = d3.geo.collignon.raw(λ, Math.abs(φ));
+      point[0] = point[0] * dx0 / dx1 - dx0 * (h - 1) / (2 * h) + i * dx0 / h;
+      point[1] = y0 + (point[1] - y1) * 4 * dy1 / dx0;
+      if (φ < 0) point[1] = -point[1];
+    } else {
+      point = lambert(λ, φ);
+    }
+    point[0] /= 2;
+    return point;
+  };
+}
+
+function healpixProjection() {
+  var n = 2,
+      m = projectionMutator(healpix),
+      p = m(n),
+      stream_ = p.stream;
+
+  p.lobes = function(_) {
+    if (!arguments.length) return n;
+    return m(n = +_);
+  };
+
+  p.stream = function(stream) {
+    var rotate = p.rotate(),
+        rotateStream = stream_(stream),
+        sphereStream = (p.rotate([0, 0]), stream_(stream));
+    p.rotate(rotate);
+    rotateStream.sphere = function() { d3.geo.stream(sphere(), sphereStream); };
+    return rotateStream;
+  };
+
+  function sphere() {
+    var step = 180 / n;
+    return {
+      type: "Polygon",
+      coordinates: [
+        d3.range(-180, 180 + step / 2, step).map(function(x, i) { return [x, i & 1 ? 90 - 1e-6 : healpixParallel]; })
+        .concat(d3.range(180, -180 - step / 2, -step).map(function(x, i) { return [x, i & 1 ? -90 + 1e-6 : -healpixParallel]; }))
+      ]
+    };
+  }
+
+  return p;
+}
+
+(d3.geo.healpix = healpixProjection).raw = healpix;

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

@@ -0,0 +1,64 @@
+function hill(K) {
+  var L = 1 + K,
+      sinβ = Math.sin(1 / L),
+      β = asin(sinβ),
+      A = 2 * Math.sqrt(π / (B = π + 4 * β * L)),
+      B,
+      ρ0 = .5 * A * (L + Math.sqrt(K * (2 + K))),
+      K2 = K * K,
+      L2 = L * L;
+
+  function forward(λ, φ) {
+    var t = 1 - Math.sin(φ),
+        ρ,
+        ω;
+    if (t && t < 2) {
+      var θ = π / 2 - φ, i = 25, δ;
+      do {
+        var sinθ = Math.sin(θ),
+            cosθ = Math.cos(θ),
+            β_β1 = β + Math.atan2(sinθ, L - cosθ),
+            C = 1 + L2 - 2 * L * cosθ;
+        θ -= δ = (θ - K2 * β - L * sinθ + C * β_β1 - .5 * t * B) / (2 * L * sinθ * β_β1);
+      } while (Math.abs(δ) > ε2 && --i > 0);
+      ρ = A * Math.sqrt(C);
+      ω = λ * β_β1 / π;
+    } else {
+      ρ = A * (K + t);
+      ω = λ * β / π;
+    }
+    return [
+      ρ * Math.sin(ω),
+      ρ0 - ρ * Math.cos(ω)
+    ];
+  };
+
+  forward.invert = function(x, y) {
+    var ρ2 = x * x + (y -= ρ0) * y,
+        cosθ = (1 + L2 - ρ2 / (A * A)) / (2 * L),
+        θ = acos(cosθ),
+        sinθ = Math.sin(θ),
+        β_β1 = β + Math.atan2(sinθ, L - cosθ);
+    return [
+      asin(x / Math.sqrt(ρ2)) * π / β_β1,
+      asin(1 - 2 * (θ - K2 * β - L * sinθ + (1 + L2 - 2 * L * cosθ) * β_β1) / B)
+    ];
+  };
+
+  return forward;
+}
+
+function hillProjection() {
+  var K = 1,
+      m = projectionMutator(hill),
+      p = m(K);
+
+  p.ratio = function(_) {
+    if (!arguments.length) return K;
+    return m(K = +_);
+  };
+
+  return p;
+}
+
+(d3.geo.hill = hillProjection).raw = hill;

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

@@ -0,0 +1,17 @@
+// @import mollweide
+// @import sinusoidal
+// @import sinu-mollweide
+
+function homolosine(λ, φ) {
+  return Math.abs(φ) > sinuMollweideφ
+      ? (λ = mollweide(λ, φ), λ[1] -= φ > 0 ? sinuMollweideY : -sinuMollweideY, λ)
+      : sinusoidal(λ, φ);
+}
+
+homolosine.invert = function(x, y) {
+  return Math.abs(y) > sinuMollweideφ
+      ? mollweide.invert(x, y + (y > 0 ? sinuMollweideY : -sinuMollweideY))
+      : sinusoidal.invert(x, y);
+};
+
+(d3.geo.homolosine = function() { return projection(homolosine); }).raw = homolosine;

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

@@ -0,0 +1,111 @@
+d3.geo.interrupt = function(project) {
+  var lobes = [
+    [[[-π, 0], [0,  π / 2], [π, 0]]],
+    [[[-π, 0], [0, -π / 2], [π, 0]]]
+  ];
+
+  var projection = d3.geo.projection(function(λ, φ) {
+    var sign = φ < 0 ? -1 : +1,
+        hemilobes = lobes[+(φ < 0)];
+    for (var i = 0, n = hemilobes.length - 1; i < n && λ > hemilobes[i][2][0]; ++i);
+    var coordinates = project(λ - hemilobes[i][1][0], φ);
+    coordinates[0] += project(hemilobes[i][1][0], sign * φ > sign * hemilobes[i][0][1] ? hemilobes[i][0][1] : φ)[0];
+    return coordinates;
+  });
+
+  var stream_ = projection.stream;
+
+  projection.stream = function(stream) {
+    var rotate = projection.rotate(),
+        rotateStream = stream_(stream),
+        sphereStream = (projection.rotate([0, 0]), stream_(stream));
+    projection.rotate(rotate);
+    rotateStream.sphere = function() { d3.geo.stream(sphere(), sphereStream); };
+    return rotateStream;
+  };
+
+  projection.lobes = function(_) {
+    if (!arguments.length) return lobes.map(function(lobes) {
+      return lobes.map(function(lobe) {
+        return [
+          [lobe[0][0] * 180 / π, lobe[0][1] * 180 / π],
+          [lobe[1][0] * 180 / π, lobe[1][1] * 180 / π],
+          [lobe[2][0] * 180 / π, lobe[2][1] * 180 / π],
+        ];
+      });
+    });
+    lobes = _.map(function(lobes) {
+      return lobes.map(function(lobe) {
+        return [
+          [lobe[0][0] * π / 180, lobe[0][1] * π / 180],
+          [lobe[1][0] * π / 180, lobe[1][1] * π / 180],
+          [lobe[2][0] * π / 180, lobe[2][1] * π / 180]
+        ];
+      });
+    });
+    return projection;
+  };
+
+  function sphere() {
+    var ε = 1e-6,
+        coordinates = [];
+
+    // Northern Hemisphere
+    for (var i = 0, n = lobes[0].length; i < n; ++i) {
+      var lobe = lobes[0][i],
+          λ0 = lobe[0][0] * 180 / π,
+          φ0 = lobe[0][1] * 180 / π,
+          φ1 = lobe[1][1] * 180 / π,
+          λ2 = lobe[2][0] * 180 / π,
+          φ2 = lobe[2][1] * 180 / π;
+      coordinates.push(resample([
+        [λ0 + ε, φ0 + ε],
+        [λ0 + ε, φ1 - ε],
+        [λ2 - ε, φ1 - ε],
+        [λ2 - ε, φ2 + ε]
+      ], 30));
+    }
+
+    // Southern Hemisphere
+    for (var i = lobes[1].length - 1; i >= 0; --i) {
+      var lobe = lobes[1][i],
+          λ0 = lobe[0][0] * 180 / π,
+          φ0 = lobe[0][1] * 180 / π,
+          φ1 = lobe[1][1] * 180 / π,
+          λ2 = lobe[2][0] * 180 / π,
+          φ2 = lobe[2][1] * 180 / π;
+      coordinates.push(resample([
+        [λ2 - ε, φ2 - ε],
+        [λ2 - ε, φ1 + ε],
+        [λ0 + ε, φ1 + ε],
+        [λ0 + ε, φ0 - ε]
+      ], 30));
+    }
+
+    return {
+      type: "Polygon",
+      coordinates: [d3.merge(coordinates)]
+    };
+  }
+
+  function resample(coordinates, m) {
+    var i = -1,
+        n = coordinates.length,
+        p0 = coordinates[0],
+        p1,
+        dx,
+        dy,
+        resampled = [];
+    while (++i < n) {
+      p1 = coordinates[i];
+      dx = (p1[0] - p0[0]) / m;
+      dy = (p1[1] - p0[1]) / m;
+      for (var j = 0; j < m; ++j) resampled.push([p0[0] + j * dx, p0[1] + j * dy]);
+      p0 = p1;
+    }
+    resampled.push(p1);
+    return resampled;
+  }
+
+  return projection;
+};

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

@@ -0,0 +1,15 @@
+function kavrayskiy7(λ, φ) {
+  return [
+    3 * λ / (2 * π) * Math.sqrt(π * π / 3 - φ * φ),
+    φ
+  ];
+}
+
+kavrayskiy7.invert = function(x, y) {
+  return [
+    2 / 3 * π * x / Math.sqrt(π * π / 3 - y * y),
+    y
+  ];
+};
+
+(d3.geo.kavrayskiy7 = function() { return projection(kavrayskiy7); }).raw = kavrayskiy7;

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

@@ -0,0 +1,27 @@
+function lagrange(n) {
+  return function(λ, φ) {
+    if (Math.abs(Math.abs(φ) - π / 2) < ε) return [0, φ < 0 ? -2 : 2];
+    var sinφ = Math.sin(φ),
+        v = Math.pow((1 + sinφ) / (1 - sinφ), n / 2),
+        c = .5 * (v + 1 / v) + Math.cos(λ *= n);
+    return [
+      2 * Math.sin(λ) / c,
+      (v - 1 / v) / c
+    ];
+  };
+}
+
+function lagrangeProjection() {
+  var n = .5,
+      m = projectionMutator(lagrange),
+      p = m(n);
+
+  p.spacing = function(_) {
+    if (!arguments.length) return n;
+    return m(n = +_);
+  };
+
+  return p;
+}
+
+(d3.geo.lagrange = lagrangeProjection).raw = lagrange;

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

@@ -0,0 +1,39 @@
+function larrivee(λ, φ) {
+  return [
+    λ * (1 + Math.sqrt(Math.cos(φ))) / 2,
+    φ / (Math.cos(φ / 2) * Math.cos(λ / 6))
+  ];
+}
+
+larrivee.invert = function(x, y) {
+  var x0 = Math.abs(x),
+      y0 = Math.abs(y),
+      π_sqrt2 = π / Math.SQRT2,
+      λ = ε,
+      φ = π / 2;
+  if (y0 < π_sqrt2) φ *= y0 / π_sqrt2;
+  else λ += 6 * acos(π_sqrt2 / y0);
+  for (var i = 0; i < 25; i++) {
+    var sinφ = Math.sin(φ),
+        sqrtcosφ = asqrt(Math.cos(φ)),
+        sinφ_2 = Math.sin(φ / 2),
+        cosφ_2 = Math.cos(φ / 2),
+        sinλ_6 = Math.sin(λ / 6),
+        cosλ_6 = Math.cos(λ / 6),
+        f0 = .5 * λ * (1 + sqrtcosφ) - x0,
+        f1 = φ / (cosφ_2 * cosλ_6) - y0,
+        df0dφ = sqrtcosφ ? -.25 * λ * sinφ / sqrtcosφ : 0,
+        df0dλ = .5 * (1 + sqrtcosφ),
+        df1dφ = (1 + .5 * φ * sinφ_2 / cosφ_2) / (cosφ_2 * cosλ_6),
+        df1dλ = (φ / cosφ_2) * (sinλ_6 / 6) / (cosλ_6 * cosλ_6),
+        denom = df0dφ * df1dλ - df1dφ * df0dλ,
+        dφ = (f0 * df1dλ - f1 * df0dλ) / denom,
+        dλ = (f1 * df0dφ - f0 * df1dφ) / denom;
+    φ -= dφ;
+    λ -= dλ;
+    if (Math.abs(dφ) < ε && Math.abs(dλ) < ε) break;
+  }
+  return [x < 0 ? -λ : λ, y < 0 ? -φ : φ];
+};
+
+(d3.geo.larrivee = function() { return projection(larrivee); }).raw = larrivee;

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

@@ -0,0 +1,31 @@
+function laskowski(λ, φ) {
+  var λ2 = λ * λ, φ2 = φ * φ;
+  return [
+    λ * (.975534 + φ2 * (-.119161 + λ2 * -.0143059 + φ2 * -.0547009)),
+    φ * (1.00384 + λ2 * (.0802894 + φ2 * -.02855 + λ2 * .000199025) + φ2 * (.0998909 + φ2 * -.0491032))
+  ];
+}
+
+laskowski.invert = function(x, y) {
+  var λ = x,
+      φ = y,
+      i = 50;
+  do {
+    var λ2 = λ * λ,
+        φ2 = φ * φ,
+        λφ = λ * φ,
+        fx = λ * (.975534 + φ2 * (-.119161 + λ2 * -.0143059 + φ2 * -.0547009)) - x,
+        fy = φ * (1.00384 + λ2 * (.0802894 + φ2 * -.02855 + λ2 * .000199025) + φ2 * (.0998909 + φ2 * -.0491032)) - y,
+        δxδλ = .975534 - φ2 * (.119161 + 3 * λ2 * .0143059 + φ2 * .0547009),
+        δxδφ = -λφ * (2 * .119161 + 4 * .0547009 * φ2 + 2 * .0143059 * λ2),
+        δyδλ = λφ * (2 * .0802894 + 4 * .000199025 * λ2 + 2 * -.02855 * φ2),
+        δyδφ = 1.00384 + λ2 * (.0802894 + .000199025 * λ2) + φ2 * (3 * (.0998909 - .02855 * λ2) - 5 * .0491032 * φ2),
+        denominator = δxδφ * δyδλ - δyδφ * δxδλ,
+        δλ = (fy * δxδφ - fx * δyδφ) / denominator,
+        δφ = (fx * δyδλ - fy * δxδλ) / denominator;
+    λ -= δλ, φ -= δφ;
+  } while ((Math.abs(δλ) > ε || Math.abs(δφ) > ε) && --i > 0);
+  return [λ, φ];
+};
+
+(d3.geo.laskowski = function() { return projection(laskowski); }).raw = laskowski;