d3js-plugins-rails 0.0.1

data/vendor/assets/javascripts/d3/plugins/geo/projection/README.md

@@ -0,0 +1,107 @@
+# Extended Geographic Projections
+
+Projections:
+
+* d3.geo.aitoff - [Aitoff](http://bl.ocks.org/3682698)
+* d3.geo.albers - [Albers equal-area conic](http://bl.ocks.org/3734308)
+* d3.geo.armadillo - [Armadillo](http://bl.ocks.org/4463127)
+* d3.geo.august - [August conformal](http://bl.ocks.org/3797581)
+* d3.geo.azimuthalEqualArea - [Lambert azimuthal equal-area](http://bl.ocks.org/3757101)
+* d3.geo.azimuthalEquidistant - [azimuthal equidistant](http://bl.ocks.org/3757110)
+* d3.geo.baker - [Baker Dinomic](http://bl.ocks.org/4476279)
+* d3.geo.berghaus - [Berghaus Star](http://bl.ocks.org/4463049)
+* d3.geo.boggs - [Boggs eumorphic](http://bl.ocks.org/4481220)
+* d3.geo.bonne - [Bonne](http://bl.ocks.org/3734313)
+* d3.geo.bromley - [Bromley](http://bl.ocks.org/4487695)
+* d3.geo.collignon - [Collignon](http://bl.ocks.org/3734316)
+* d3.geo.conicConformal - [Lambert conformal conic](http://bl.ocks.org/3734321)
+* d3.geo.conicEquidistant - [conic equidistant](http://bl.ocks.org/3734317)
+* d3.geo.craig - [Craig retroazimuthal](http://bl.ocks.org/4459466)
+* d3.geo.craster - [Craster parabolic](http://bl.ocks.org/4465118)
+* d3.geo.cylindricalEqualArea - [cylindrical equal-area](http://bl.ocks.org/3712408), [Gall–Peters](http://bl.ocks.org/3946824), [Hobo–Dyer](http://bl.ocks.org/4476487), [Tobler world-in-a-square](http://bl.ocks.org/4476496)
+* d3.geo.eckert1 - [Eckert I](http://bl.ocks.org/3734322)
+* d3.geo.eckert2 - [Eckert II](http://bl.ocks.org/3734324)
+* d3.geo.eckert3 - [Eckert III](http://bl.ocks.org/3734325)
+* d3.geo.eckert4 - [Eckert IV](http://bl.ocks.org/3734327)
+* d3.geo.eckert5 - [Eckert V](http://bl.ocks.org/3734328)
+* d3.geo.eckert6 - [Eckert VI](http://bl.ocks.org/3734329)
+* d3.geo.eisenlohr - [Eisenlohr conformal](http://bl.ocks.org/3797585)
+* d3.geo.equirectangular - [Equirectangular (Plate Carrée)](http://bl.ocks.org/3757119)
+* d3.geo.gnomonic - [gnomonic](http://bl.ocks.org/3757349)
+* d3.geo.gringorten - [Gringorten](http://bl.ocks.org/3796882)
+* d3.geo.guyou - [Guyou hemisphere-in-a-square](http://bl.ocks.org/3763867)
+* d3.geo.hammer - [Hammer](http://bl.ocks.org/3712397), [Eckert–Greifendorff](http://bl.ocks.org/4496212), [quartic authalic](http://bl.ocks.org/4463175), [Briesemeister](http://bl.ocks.org/4519926)
+* d3.geo.hammerRetroazimuthal - [Hammer retroazimuthal](http://bl.ocks.org/4459130)
+* d3.geo.healpix - [HEALPix](http://bl.ocks.org/4463237)
+* d3.geo.hill - [Hill eucyclic](http://bl.ocks.org/4479513), [Maurer No. 73](http://bl.ocks.org/4479547)
+* d3.geo.homolosine - [Goode homolosine](http://bl.ocks.org/3734330)
+* d3.geo.kavrayskiy7 - [Kavrayskiy VII](http://bl.ocks.org/3710082)
+* d3.geo.lagrange - [Lagrange conformal](http://bl.ocks.org/3797591)
+* d3.geo.larrivee - [Larrivée](http://bl.ocks.org/3719042)
+* d3.geo.laskowski - [Laskowski tri-optimal](http://bl.ocks.org/4489342)
+* d3.geo.littrow - [Littrow](http://bl.ocks.org/4459071)
+* d3.geo.loximuthal - [loximuthal](http://bl.ocks.org/3867220)
+* d3.geo.mercator - [Mercator](http://bl.ocks.org/3757132)
+* d3.geo.miller - [Miller](http://bl.ocks.org/3734333)
+* d3.geo.mollweide - [Mollweide](http://bl.ocks.org/3734336), [Atlantis](http://bl.ocks.org/4519975)
+* d3.geo.mtFlatPolarParabolic - [McBryde–Thomas flat-polar parabolic](http://bl.ocks.org/4465130)
+* d3.geo.mtFlatPolarQuartic - [McBryde–Thomas flat-polar quartic](http://bl.ocks.org/4465137)
+* d3.geo.mtFlatPolarSinusoidal - [McBryde–Thomas flat-polar sinusoidal](http://bl.ocks.org/4465140)
+* d3.geo.naturalEarth - [Natural Earth](http://bl.ocks.org/4479477)
+* d3.geo.nellHammer - [Nell–Hammer](http://bl.ocks.org/3734342)
+* d3.geo.orthographic - [orthographic](http://bl.ocks.org/3757125)
+* d3.geo.peirceQuincuncial - [Pierce quincuncial](http://bl.ocks.org/4310087)
+* d3.geo.polyconic - [Polyconic](http://bl.ocks.org/3734343)
+* d3.geo.robinson - [Robinson](http://bl.ocks.org/3710566)
+* d3.geo.satellite - [satellite (tilted perpsective)](http://bl.ocks.org/3790444)
+* d3.geo.sinusoidal - [sinusoidal](http://bl.ocks.org/3712399)
+* d3.geo.sinuMollweide - [Sinu-Mollweide](http://bl.ocks.org/4319903)
+* d3.geo.stereographic - [stereographic](http://bl.ocks.org/3757137)
+* d3.geo.vanDerGrinten - [Van der Grinten](http://bl.ocks.org/3796831)
+* d3.geo.vanDerGrinten4 - [Van der Grinten IV](http://bl.ocks.org/4489365)
+* d3.geo.wagner4 - [Wagner IV, Putniṇš P2´](http://bl.ocks.org/4487674)
+* d3.geo.wagner6 - [Wagner VI](http://bl.ocks.org/3710148)
+* d3.geo.wagner7 - [Wagner VII](http://bl.ocks.org/4465109)
+* d3.geo.wiechel - [Wiechel](http://bl.ocks.org/4463155)
+* d3.geo.winkel3 - [Winkel Tripel](http://bl.ocks.org/3682676)
+
+This plugin also provides d3.geo.interrupt, which can be used to create arbitrary interrupted projections from a given raw projection. For example, see [Philbrick’s interrupted Sinu-Mollweide](http://bl.ocks.org/4481520).
+
+This plugin requires [D3 3.0](https://github.com/mbostock/d3/wiki/Upgrading-to-3.0) or greater. To use the official hosted version, include the projection plugin after including D3:
+
+```html
+<script src="http://d3js.org/d3.v3.min.js"></script>
+<script src="http://d3js.org/d3.geo.projection.v0.min.js"></script>
+```
+
+Alternatively, you can clone this repo, [download the zipball](http://github.com/d3/d3-plugins/zipball/master), or right-click [d3.geo.projection.v0.min.js](http://d3js.org/d3.geo.projection.v0.min.js) and save.
+
+## Defining a New Projection
+
+First define your raw projection function:
+
+```js
+function cosinusoidal(λ, φ) {
+  return [λ * Math.sin(φ), φ];
+}
+
+cosinusoidal.invert = function(x, y) {
+  return [x / Math.sin(y), y];
+};
+```
+
+Then create a constructor using d3.geo.projection:
+
+```js
+d3.geo.cosinusoidal = function() {
+  return d3.geo.projection(cosinusoidal);
+};
+```
+
+You can optionally expose the raw projection to facilitate composite projections:
+
+```js
+(d3.geo.cosinusoidal = function() {
+  return d3.geo.projection(cosinusoidal);
+}).raw = cosinusoidal;
+```

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

@@ -0,0 +1,40 @@
+function aitoff(λ, φ) {
+  var cosφ = Math.cos(φ),
+      sinciα = sinci(acos(cosφ * Math.cos(λ /= 2)));
+  return [
+    2 * cosφ * Math.sin(λ) * sinciα,
+    Math.sin(φ) * sinciα
+  ];
+}
+
+aitoff.invert = function(x, y) {
+  var λ = x, φ = y, i = 25;
+  do {
+    var sinλ = Math.sin(λ),
+        sinλ_2 = Math.sin(λ / 2),
+        cosλ_2 = Math.cos(λ / 2),
+        sinφ = Math.sin(φ),
+        cosφ = Math.cos(φ),
+        sin_2φ = Math.sin(2 * φ),
+        sin2φ = sinφ * sinφ,
+        cos2φ = cosφ * cosφ,
+        sin2λ_2 = sinλ_2 * sinλ_2,
+        C = 1 - cos2φ * cosλ_2 * cosλ_2,
+        E = C ? acos(cosφ * cosλ_2) * Math.sqrt(F = 1 / C) : F = 0,
+        F,
+        fx = 2 * E * cosφ * sinλ_2 - x,
+        fy = E * sinφ - y,
+        δxδλ = F * (cos2φ * sin2λ_2 + E * cosφ * cosλ_2 * sin2φ),
+        δxδφ = F * (.5 * sinλ * sin_2φ - E * 2 * sinφ * sinλ_2),
+        δyδλ = F * .25 * (sin_2φ * sinλ_2 - E * sinφ * cos2φ * sinλ),
+        δyδφ = F * (sin2φ * cosλ_2 + E * sin2λ_2 * cosφ),
+        denominator = δxδφ * δyδλ - δyδφ * δxδλ;
+    if (!denominator) break;
+    var δλ = (fy * δxδφ - fx * δyδφ) / denominator,
+        δφ = (fx * δyδλ - fy * δxδλ) / denominator;
+    λ -= δλ, φ -= δφ;
+  } while ((Math.abs(δλ) > ε || Math.abs(δφ) > ε) && --i > 0);
+  return [λ, φ];
+};
+
+(d3.geo.aitoff = function() { return projection(aitoff); }).raw = aitoff;

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

@@ -0,0 +1,79 @@
+function armadillo(φ0) {
+  var sinφ0 = Math.sin(φ0),
+      cosφ0 = Math.cos(φ0),
+      sφ0 = φ0 > 0 ? 1 : -1,
+      tanφ0 = Math.tan(sφ0 * φ0),
+      k = (1 + sinφ0 - cosφ0) / 2;
+
+  function forward(λ, φ) {
+    var cosφ = Math.cos(φ),
+        cosλ = Math.cos(λ /= 2);
+    return [
+      (1 + cosφ) * Math.sin(λ),
+      // TODO D3 core should allow null or [NaN, NaN] to be returned.
+      (sφ0 * φ > -Math.atan2(cosλ, tanφ0) - 1e-3 ? 0 : -sφ0 * 10) +
+        k + Math.sin(φ) * cosφ0 - (1 + cosφ) * sinφ0 * cosλ
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var λ = 0,
+        φ = 0,
+        i = 50;
+    do {
+      var cosλ = Math.cos(λ),
+          sinλ = Math.sin(λ),
+          cosφ = Math.cos(φ),
+          sinφ = Math.sin(φ),
+          A = 1 + cosφ,
+          fx = A * sinλ - x,
+          fy = k + sinφ * cosφ0 - A * sinφ0 * cosλ - y,
+          δxδλ = .5 * A * cosλ,
+          δxδφ = -sinλ * sinφ,
+          δyδλ = .5 * sinφ0 * A * sinλ,
+          δyδφ = cosφ0 * cosφ + sinφ0 * cosλ * sinφ,
+          denominator = δxδφ * δyδλ - δyδφ * δxδλ,
+          δλ = .5 * (fy * δxδφ - fx * δyδφ) / denominator,
+          δφ = (fx * δyδλ - fy * δxδλ) / denominator;
+      λ -= δλ, φ -= δφ;
+    } while ((Math.abs(δλ) > ε || Math.abs(δφ) > ε) && --i > 0);
+    return sφ0 * φ > -Math.atan2(Math.cos(λ), tanφ0) - 1e-3 ? [λ * 2, φ] : null;
+  };
+
+  return forward;
+}
+
+function armadilloProjection() {
+  var φ0 = π / 9, // 20°
+      sφ0 = φ0 > 0 ? 1 : -1,
+      tanφ0 = Math.tan(sφ0 * φ0),
+      m = projectionMutator(armadillo),
+      p = m(φ0),
+      stream_ = p.stream;
+
+  p.parallel = function(_) {
+    if (!arguments.length) return φ0 / π * 180;
+    tanφ0 = Math.tan((sφ0 = (φ0 = _ * π / 180) > 0 ? 1 : -1) * φ0);
+    return m(φ0);
+  };
+
+  p.stream = function(stream) {
+    var rotate = p.rotate(),
+        rotateStream = stream_(stream),
+        sphereStream = (p.rotate([0, 0]), stream_(stream));
+    p.rotate(rotate);
+    rotateStream.sphere = function() {
+      sphereStream.polygonStart(), sphereStream.lineStart();
+      for (var λ = sφ0 * -180; sφ0 * λ < 180; λ += sφ0 * 90) sphereStream.point(λ, sφ0 * 90);
+      while (sφ0 * (λ -= φ0) >= -180) { // TODO precision?
+        sphereStream.point(λ, sφ0 * -Math.atan2(Math.cos(λ * radians / 2), tanφ0) * degrees);
+      }
+      sphereStream.lineEnd(), sphereStream.polygonEnd();
+    };
+    return rotateStream;
+  };
+
+  return p;
+}
+
+(d3.geo.armadillo = armadilloProjection).raw = armadillo;

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

@@ -0,0 +1,15 @@
+function august(λ, φ) {
+  var tanφ = Math.tan(φ / 2),
+      k = 1 - tanφ * tanφ,
+      c = 1 + k * Math.cos(λ /= 2),
+      x = Math.sin(λ) * k / c,
+      y = tanφ / c,
+      x2 = x * x,
+      y2 = y * y;
+  return [
+    4 / 3 * x * (3 + x2 - 3 * y2),
+    4 / 3 * y * (3 + 3 * x2 - y2)
+  ];
+}
+
+(d3.geo.august = function() { return projection(august); }).raw = august;

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

@@ -0,0 +1,28 @@
+var bakerφ = Math.log(1 + Math.SQRT2);
+
+function baker(λ, φ) {
+  var φ0 = Math.abs(φ);
+  return φ0 < π / 4
+      ? [λ, Math.log(Math.tan(π / 4 + φ / 2))]
+      : [
+        λ * Math.cos(φ0) * (2 * Math.SQRT2 - 1 / Math.sin(φ0)),
+        sgn(φ) * (2 * Math.SQRT2 * (φ0 - π / 4) - Math.log(Math.tan(φ0 / 2)))
+      ];
+}
+
+baker.invert = function(x, y) {
+  if ((y0 = Math.abs(y)) < bakerφ) return [x, 2 * Math.atan(Math.exp(y)) - π / 2];
+  var sqrt8 = Math.sqrt(8),
+      φ = π / 4, i = 25, δ, y0;
+  do {
+    var cosφ_2 = Math.cos(φ / 2),
+        tanφ_2 = Math.tan(φ / 2);
+    φ -= δ = (sqrt8 * (φ - π / 4) - Math.log(tanφ_2) - y0) / (sqrt8 - .5 * cosφ_2 * cosφ_2 / tanφ_2);
+  } while (Math.abs(δ) > ε2 && --i > 0);
+  return [
+    x / (Math.cos(φ) * (sqrt8 - 1 / Math.sin(φ))),
+    sgn(y) * φ
+  ];
+};
+
+(d3.geo.baker = function() { return projection(baker); }).raw = baker;

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

@@ -0,0 +1,60 @@
+var berghausAzimuthalEquidistant = d3.geo.azimuthalEquidistant.raw;
+
+function berghaus(n) {
+  var k = 2 * π / n;
+
+  function forward(λ, φ) {
+    var p = berghausAzimuthalEquidistant(λ, φ);
+    if (Math.abs(λ) > π / 2) { // back hemisphere
+      var θ = Math.atan2(p[1], p[0]),
+          r = Math.sqrt(p[0] * p[0] + p[1] * p[1]),
+          θ0 = k * Math.round((θ - π / 2) / k) + π / 2,
+          α = Math.atan2(Math.sin(θ -= θ0), 2 - Math.cos(θ)); // angle relative to lobe end
+      θ = θ0 + asin(π / r * Math.sin(α)) - α;
+      p[0] = r * Math.cos(θ);
+      p[1] = r * Math.sin(θ);
+    }
+    return p;
+  }
+
+  return forward;
+}
+
+function berghausProjection() {
+  var n = 5,
+      m = projectionMutator(berghaus),
+      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() {
+      sphereStream.polygonStart(), sphereStream.lineStart();
+      var ε = 1e-4;
+      for (var i = 0, δ = 360 / n, φ = 90 - 180 / n; i < n; ++i, φ -= δ) {
+        sphereStream.point(180, 0);
+        if (φ < -90) {
+          sphereStream.point(-90, 180 - φ - ε);
+          sphereStream.point(-90, 180 - φ + ε);
+        } else {
+          sphereStream.point(90, φ + ε);
+          sphereStream.point(90, φ - ε);
+        }
+      }
+      sphereStream.lineEnd(), sphereStream.polygonEnd();
+    };
+    return rotateStream;
+  };
+
+  return p;
+}
+
+(d3.geo.berghaus = berghausProjection).raw = berghaus;

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

@@ -0,0 +1,27 @@
+// @import mollweide
+
+function boggs(λ, φ) {
+  var k = 2.00276,
+      θ = mollweideθ(φ);
+  return [
+    k * λ / (1 / Math.cos(φ) + 1.11072 / Math.cos(θ)),
+    (φ + Math.SQRT2 * Math.sin(θ)) / k
+  ];
+}
+
+boggs.invert = function(x, y) {
+  var k = 2.00276,
+      ky = k * y,
+      θ = y < 0 ? -π / 4 : π / 4, i = 25, δ, φ;
+  do {
+    φ = ky - Math.SQRT2 * Math.sin(θ);
+    θ -= δ = (Math.sin(2 * θ) + 2 * θ - π * Math.sin(φ)) / (2 * Math.cos(2 * θ) + 2 + π * Math.cos(φ) * Math.SQRT2 * Math.cos(θ));
+  } while (Math.abs(δ) > ε && --i > 0);
+  φ = ky - Math.SQRT2 * Math.sin(θ);
+  return [
+    x * (1 / Math.cos(φ) + 1.11072 / Math.cos(θ)) / k,
+    φ
+  ];
+};
+
+(d3.geo.boggs = function() { return projection(boggs); }).raw = boggs;

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

@@ -0,0 +1,29 @@
+// @import parallel1
+// @import sinusoidal
+
+function bonne(φ0) {
+  if (!φ0) return sinusoidal;
+  var cotφ0 = 1 / Math.tan(φ0);
+
+  function forward(λ, φ) {
+    var ρ = cotφ0 + φ0 - φ,
+        E = λ * Math.cos(φ) / ρ;
+    return [
+      ρ * Math.sin(E),
+      cotφ0 - ρ * Math.cos(E)
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var ρ = Math.sqrt(x * x + (y = cotφ0 - y) * y),
+        φ = cotφ0 + φ0 - ρ;
+    return [
+      ρ / Math.cos(φ) * Math.atan2(x, y),
+      φ
+    ];
+  };
+
+  return forward;
+}
+
+(d3.geo.bonne = function() { return parallel1Projection(bonne).parallel(45); }).raw = bonne;

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

@@ -0,0 +1,5 @@
+// @import mollweide
+
+var bromley = mollweideBromley(1, 4 / π, π);
+
+(d3.geo.bromley = function() { return projection(bromley); }).raw = bromley;

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

@@ -0,0 +1,17 @@
+function collignon(λ, φ) {
+  var α = asqrt(1 - Math.sin(φ));
+  return [
+    (2 / sqrtπ) * λ * α,
+    sqrtπ * (1 - α)
+  ];
+}
+
+collignon.invert = function(x, y) {
+  var λ = (λ = y / sqrtπ - 1) * λ;
+  return [
+    λ > 0 ? x * Math.sqrt(π / λ) / 2 : 0,
+    asin(1 - λ)
+  ];
+};
+
+(d3.geo.collignon = function() { return projection(collignon); }).raw = collignon;

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

@@ -0,0 +1,29 @@
+// @import parallel2
+
+function conicConformal(φ0, φ1) {
+  var cosφ0 = Math.cos(φ0),
+      t = function(φ) { return Math.tan(π / 4 + φ / 2); },
+      n = Math.log(cosφ0 / Math.cos(φ1)) / Math.log(t(φ1) / t(φ0)),
+      F = cosφ0 * Math.pow(t(φ0), n) / n;
+
+  function forward(λ, φ) {
+    var ρ = Math.abs(Math.abs(φ) - π / 2) < ε ? 0 : F / Math.pow(t(φ), n);
+    return [
+      ρ * Math.sin(n * λ),
+      F - ρ * Math.cos(n * λ)
+    ];
+  }
+
+  forward.invert = function(x, y) {
+    var ρ0_y = F - y,
+        ρ = sgn(n) * Math.sqrt(x * x + ρ0_y * ρ0_y);
+    return [
+      Math.atan2(x, ρ0_y) / n,
+      2 * Math.atan(Math.pow(F / ρ, 1 / n)) - π / 2
+    ];
+  };
+
+  return forward;
+}
+
+(d3.geo.conicConformal = function() { return parallel2Projection(conicConformal); }).raw = conicConformal;