d3js-plugins-rails 0.0.1

data/vendor/assets/javascripts/d3/plugins/geo/projection/conic-equidistant.js

@@ -0,0 +1,27 @@
+// @import parallel2
+
+function conicEquidistant(φ0, φ1) {
+  var cosφ0 = Math.cos(φ0),
+      n = (cosφ0 - Math.cos(φ1)) / (φ1 - φ0),
+      G = cosφ0 / n + φ0;
+
+  function forward(λ, φ) {
+    var ρ = G - φ;
+    return [
+      ρ * Math.sin(n * λ),
+      G - ρ * Math.cos(n * λ)
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var ρ0_y = G - y;
+    return [
+      Math.atan2(x, ρ0_y) / n,
+      G - sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y)
+    ];
+  };
+
+  return forward;
+}
+
+(d3.geo.conicEquidistant = function() { return parallel2Projection(conicEquidistant); }).raw = conicEquidistant;

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

@@ -0,0 +1,24 @@
+// @import parallel1
+
+function craig(φ0) {
+  var tanφ0 = Math.tan(φ0);
+
+  function forward(λ, φ) {
+    return [
+      λ,
+      (λ ? λ / Math.sin(λ) : 1) * (Math.sin(φ) * Math.cos(λ) - tanφ0 * Math.cos(φ))
+    ];
+  }
+
+  // TODO
+  // forward.invert = function(x, y) {
+  //   return [
+  //     x,
+  //     asin(y * (x ? Math.tan(x) / x : 1))
+  //   ];
+  // };
+
+  return forward;
+}
+
+(d3.geo.craig = function() { return parallel1Projection(craig); }).raw = craig;

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

@@ -0,0 +1,18 @@
+function craster(λ, φ) {
+  var sqrt3 = Math.sqrt(3);
+  return [
+    sqrt3 * λ * (2 * Math.cos(2 * φ / 3) - 1) / sqrtπ,
+    sqrt3 * sqrtπ * Math.sin(φ / 3)
+  ];
+}
+
+craster.invert = function(x, y) {
+  var sqrt3 = Math.sqrt(3),
+      φ = 3 * asin(y / (sqrt3 * sqrtπ));
+  return [
+    sqrtπ * x / (sqrt3 * (2 * Math.cos(2 * φ / 3) - 1)),
+    φ
+  ];
+};
+
+(d3.geo.craster = function() { return projection(craster); }).raw = craster;

data/vendor/assets/javascripts/d3/plugins/geo/projection/cylindrical-equal-area.js

@@ -0,0 +1,23 @@
+// @import parallel1
+
+function cylindricalEqualArea(φ0) {
+  var cosφ0 = Math.cos(φ0);
+
+  function forward(λ, φ) {
+    return [
+      λ * cosφ0,
+      Math.sin(φ) / cosφ0
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    return [
+      x / cosφ0,
+      asin(y * cosφ0)
+    ];
+  };
+
+  return forward;
+}
+
+(d3.geo.cylindricalEqualArea = function() { return parallel1Projection(cylindricalEqualArea); }).raw = cylindricalEqualArea;

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

@@ -0,0 +1,18 @@
+function eckert1(λ, φ) {
+  var α = Math.sqrt(8 / (3 * π));
+  return [
+    α * λ * (1 - Math.abs(φ) / π),
+    α * φ
+  ];
+}
+
+eckert1.invert = function(x, y) {
+  var α = Math.sqrt(8 / (3 * π)),
+      φ = y / α;
+  return [
+    x / (α * (1 - Math.abs(φ) / π)),
+    φ
+  ];
+};
+
+(d3.geo.eckert1 = function() { return projection(eckert1); }).raw = eckert1;

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

@@ -0,0 +1,17 @@
+function eckert2(λ, φ) {
+  var α = Math.sqrt(4 - 3 * Math.sin(Math.abs(φ)));
+  return [
+    2 / Math.sqrt(6 * π) * λ * α,
+    sgn(φ) * Math.sqrt(2 * π / 3) * (2 - α)
+  ];
+}
+
+eckert2.invert = function(x, y) {
+  var α = 2 - Math.abs(y) / Math.sqrt(2 * π / 3);
+  return [
+    x * Math.sqrt(6 * π) / (2 * α),
+    sgn(y) * asin((4 - α * α) / 3)
+  ];
+};
+
+(d3.geo.eckert2 = function() { return projection(eckert2); }).raw = eckert2;

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

@@ -0,0 +1,17 @@
+function eckert3(λ, φ) {
+  var k = Math.sqrt(π * (4 + π));
+  return [
+    2 / k * λ * (1 + Math.sqrt(1 - 4 * φ * φ / (π * π))),
+    4 / k * φ
+  ];
+}
+
+eckert3.invert = function(x, y) {
+  var k = Math.sqrt(π * (4 + π)) / 2;
+  return [
+    x * k / (1 + asqrt(1 - y * y * (4 + π) / (4 * π))),
+    y * k / 2
+  ];
+};
+
+(d3.geo.eckert3 = function() { return projection(eckert3); }).raw = eckert3;

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

@@ -0,0 +1,24 @@
+function eckert4(λ, φ) {
+  var k = (2 + π / 2) * Math.sin(φ);
+  φ /= 2;
+  for (var i = 0, δ = Infinity; i < 10 && Math.abs(δ) > ε; i++) {
+    var cosφ = Math.cos(φ);
+    φ -= δ = (φ + Math.sin(φ) * (cosφ + 2) - k) / (2 * cosφ * (1 + cosφ));
+  }
+  return [
+    2 / Math.sqrt(π * (4 + π)) * λ * (1 + Math.cos(φ)),
+    2 * Math.sqrt(π / (4 + π)) * Math.sin(φ)
+  ];
+}
+
+eckert4.invert = function(x, y) {
+  var j = 2 * Math.sqrt(π / (4 + π)),
+      k = asin(y / cy),
+      c = Math.cos(k);
+  return [
+    x / (2 / Math.sqrt(π * (4 + π)) * (1 + c)),
+    asin((k + y / j * (c + 2)) / (2 + π / 2))
+  ];
+};
+
+(d3.geo.eckert4 = function() { return projection(eckert4); }).raw = eckert4;

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

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

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

@@ -0,0 +1,22 @@
+function eckert6(λ, φ) {
+  var k = (1 + π / 2) * Math.sin(φ);
+  for (var i = 0, δ = Infinity; i < 10 && Math.abs(δ) > ε; i++) {
+    φ -= δ = (φ + Math.sin(φ) - k) / (1 + Math.cos(φ));
+  }
+  k = Math.sqrt(2 + π);
+  return [
+    λ * (1 + Math.cos(φ)) / k,
+    2 * φ / k
+  ];
+}
+
+eckert6.invert = function(x, y) {
+  var j = 1 + π / 2,
+      k = Math.sqrt(j / 2);
+  return [
+    x * 2 * k / (1 + Math.cos(y *= k)),
+    asin((y + Math.sin(y)) / j)
+  ];
+};
+
+(d3.geo.eckert6 = function() { return projection(eckert6); }).raw = eckert6;

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

@@ -0,0 +1,16 @@
+function eisenlohr(λ, φ) {
+  var f = 3 + Math.sqrt(8),
+      s1 = Math.sin(λ /= 2),
+      c1 = Math.cos(λ),
+      k = Math.sqrt(Math.cos(φ) / 2),
+      cosφ2 = Math.cos(φ /= 2),
+      t = Math.sin(φ) / (cosφ2 + 2 * c1 * k),
+      c = Math.sqrt(2 / (1 + t * t)),
+      v = Math.sqrt((cosφ2 + (c1 + s1) * k) / (cosφ2 + (c1 - s1) * k));
+  return [
+    f * (c * (v - 1 / v) - 2 * Math.log(v)),
+    f * (c * t * (v + 1 / v) - 2 * Math.atan(t))
+  ];
+}
+
+(d3.geo.eisenlohr = function() { return projection(eisenlohr); }).raw = eisenlohr;

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

@@ -0,0 +1 @@
+})();

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

@@ -0,0 +1,111 @@
+function gringortenProjection() {
+  var quincuncial = false,
+      m = projectionMutator(gringorten),
+      p = m(quincuncial);
+
+  p.quincuncial = function(_) {
+    if (!arguments.length) return quincuncial;
+    return m(quincuncial = !!_);
+  };
+
+  return p;
+}
+
+function gringorten(quincuncial) {
+  return function(λ, φ) {
+    var cosφ = Math.cos(φ),
+        x = Math.cos(λ) * cosφ,
+        y = Math.sin(λ) * cosφ,
+        z = Math.sin(φ);
+    if (quincuncial) {
+      λ = Math.atan2(y, -z) - π / 4;
+      φ = asin(x);
+    } else {
+      λ = Math.atan2(z, x) + π / 2;
+      φ = asin(-y);
+    }
+    while (λ < 0) λ += 2 * π;
+    var nφ = φ < 0,
+        df = ~~(λ / (π / 4));
+    λ %= π / 2;
+    var point = gringortenHexadecant(df & 1 ? π / 2 - λ : λ, Math.abs(φ)),
+        x = point[0],
+        y = point[1],
+        t;
+    if (quincuncial && nφ) y = -2 - y;
+    if (df > 3) x = -x, y = -y;
+    switch (df % 4) {
+      case 1: x = -x; // fall through
+      case 2: t = x; x = -y; y = t; break;
+      case 3: y = -y; break;
+    }
+    if (!quincuncial && nφ) x = 2 - x;
+    return quincuncial ? [(x - y) / Math.SQRT2, (x + y) / Math.SQRT2] : [x, y];
+  };
+}
+
+function gringortenHexadecant(λ, φ) {
+  if (φ === π / 2) return [0, 0];
+
+  var sinφ = Math.sin(φ),
+      r = sinφ * sinφ,
+      r2 = r * r,
+      j = 1 + r2,
+      k = 1 + 3 * r2,
+      q = 1 - r2,
+      z = asin(1 / Math.sqrt(j)),
+      v = q + r * j * z,
+      p2 = (1 - sinφ) / v,
+      p = Math.sqrt(p2),
+      a2 = p2 * j,
+      a = Math.sqrt(a2),
+      h = p * q;
+  if (λ === 0) return [0, -(h + r * a)];
+
+  var cosφ = Math.cos(φ),
+      secφ = 1 / cosφ,
+      drdφ = 2 * sinφ * cosφ,
+      dvdφ = (-3 * r + z * k) * drdφ,
+      dp2dφ = (-v * cosφ - (1 - sinφ) * dvdφ) / (v * v),
+      dpdφ = (.5 * dp2dφ) / p,
+      dhdφ = q * dpdφ - 2 * r * p * drdφ,
+      dra2dφ = r * j * dp2dφ + p2 * k * drdφ,
+      μ = -secφ * drdφ,
+      ν = -secφ * dra2dφ,
+      ζ = -2 * secφ * dhdφ,
+      Λ = 4 * λ / π;
+
+  if (λ > .222 * π || φ < π / 4 && λ > .175 * π) {
+    // Slower but accurate bisection method.
+    var x = (h + r * asqrt(a2 * (1 + r2) - h * h)) / (1 + r2);
+    if (λ > π / 4) return [x, x];
+
+    var x1 = x,
+        x0 = .5 * x,
+        i = -1;
+    x = .5 * (x0 + x1);
+    do {
+      var g = Math.sqrt(a2 - x * x),
+          f = (x * (ζ + μ * g) + ν * asin(x / a)) - Λ;
+      if (!f) break;
+      if (f < 0) x0 = x;
+      else x1 = x;
+      x = .5 * (x0 + x1);
+    } while (++i < 50 && Math.abs(x1 - x0) > ε);
+  } else {
+    // Newton-Raphson.
+    for (var x = ε, i = 0; i < 25; i++) {
+      var x2 = x * x,
+          g = asqrt(a2 - x2),
+          ζμg = ζ + μ * g,
+          f = x * ζμg + ν * asin(x / a) - Λ,
+          df = ζμg + (ν - μ * x2) / g,
+          dx = g ? -f / df : 0;
+      x += dx;
+      if (Math.abs(dx) < ε) break;
+    }
+  }
+  return [x, -h - r * asqrt(a2 - x * x)];
+}
+
+(d3.geo.gringorten = gringortenProjection).raw = gringorten;

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

@@ -0,0 +1,46 @@
+function guyou(λ, φ) {
+  return guyouEllipticFi(λ, sgn(φ) * Math.log(Math.tan(.5 * (Math.abs(φ) + π / 2))), .5);
+}
+
+// Calculate F(φ+iψ|m).
+// See Abramowitz and Stegun, 17.4.11.
+function guyouEllipticFi(φ, ψ, m) {
+  var r = Math.abs(φ),
+      i = Math.abs(ψ),
+      sinhψ = .5 * ((sinhψ = Math.exp(i)) - 1 / sinhψ);
+  if (r) {
+    var cscφ = 1 / Math.sin(r),
+        cotφ2 = (cotφ2 = Math.cos(r) * cscφ) * cotφ2,
+        b = -(cotφ2 + m * (sinhψ * sinhψ * cscφ * cscφ + 1) - 1),
+        cotλ2 = .5 * (-b + Math.sqrt(b * b - 4 * (m - 1) * cotφ2));
+    return [
+      guyouEllipticF(Math.atan(1 / Math.sqrt(cotλ2)), m) * sgn(φ),
+      guyouEllipticF(Math.atan(Math.sqrt(cotλ2 / cotφ2 - 1) / m), 1 - m) * sgn(ψ)
+    ];
+  }
+  return [
+    0,
+    guyouEllipticF(Math.atan(sinhψ), 1 - m) * sgn(ψ)
+  ];
+}
+
+// Calculate F(φ|m) where m = k² = sin²α.
+// See Abramowitz and Stegun, 17.6.7.
+function guyouEllipticF(φ, m) {
+  var a = 1,
+      b = Math.sqrt(1 - m),
+      c = Math.sqrt(m);
+  for (var i = 0; Math.abs(c) > ε; i++) {
+    if (φ % π) {
+      var dφ = Math.atan(b * Math.tan(φ) / a);
+      if (dφ < 0) dφ += π;
+      φ += dφ + ~~(φ / π) * π;
+    } else φ += φ;
+    c = (a + b) / 2;
+    b = Math.sqrt(a * b);
+    c = ((a = c) - b) / 2;
+  }
+  return φ / (Math.pow(2, i) * a);
+}
+
+(d3.geo.guyou = function() { return projection(guyou); }).raw = guyou;

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

@@ -0,0 +1,75 @@
+function hammerRetroazimuthal(φ0) {
+  var sinφ0 = Math.sin(φ0),
+      cosφ0 = Math.cos(φ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φ)),
+        z = acos(sinφ0 * sinφ + cosφ0 * cosφ * cosλ),
+        sinz = Math.sin(z),
+        K = Math.abs(sinz) > ε ? z / sinz : 1;
+    return [
+      K * cosφ0 * Math.sin(λ),
+      (Math.abs(λ) > π / 2 ? K : -K) // rotate for back hemisphere
+        * (sinφ0 * cosφ - cosφ0 * sinφ * cosλ)
+    ];
+  }
+
+  return forward;
+}
+
+function hammerRetroazimuthalProjection() {
+  var φ0 = 0,
+      m = projectionMutator(hammerRetroazimuthal),
+      p = m(φ0),
+      rotate_ = p.rotate,
+      stream_ = p.stream,
+      circle = d3.geo.circle();
+
+  p.parallel = function(_) {
+    if (!arguments.length) return φ0 / π * 180;
+    var r = p.rotate();
+    return m(φ0 = _ * π / 180).rotate(r);
+  };
+
+  p.rotate = function(_) {
+    if (!arguments.length) return (_ = rotate_.call(p), _[1] += φ0 / π * 180, _);
+    rotate_.call(p, [_[0], _[1] - φ0 / π * 180]);
+    circle.origin([-_[0], -_[1]]);
+    return p;
+  };
+
+  p.stream = function(stream) {
+    stream = stream_(stream);
+    stream.sphere = function() {
+      stream.polygonStart();
+      var ε = 1e-2,
+          ring = circle.angle(90 - ε)().coordinates[0],
+          n = ring.length - 1,
+          i = -1,
+          p;
+      stream.lineStart();
+      while (++i < n) stream.point((p = ring[i])[0], p[1]);
+      stream.lineEnd();
+      ring = circle.angle(90 + ε)().coordinates[0];
+      n = ring.length - 1;
+      stream.lineStart();
+      while (--i >= 0) stream.point((p = ring[i])[0], p[1]);
+      stream.lineEnd();
+      stream.polygonEnd();
+    };
+    return stream;
+  };
+
+  return p;
+}
+
+(d3.geo.hammerRetroazimuthal = hammerRetroazimuthalProjection).raw = hammerRetroazimuthal;