d3js-plugins-rails 0.0.1

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

@@ -0,0 +1,25 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.larrivee");
+
+suite.addBatch({
+  "larrivee": {
+    topic: d3.geo.larrivee,
+    "projections and inverse projections": function(larrivee) {
+      assert.equalInverse(larrivee, [   0,   0], [480,        250]);
+      assert.equalInverse(larrivee, [   0, -90], [480,        583.216220]);
+      assert.equalInverse(larrivee, [   0,  90], [480,        -83.216220]);
+      assert.equalInverse(larrivee, [   0, -45], [480,        377.516326]);
+      assert.equalInverse(larrivee, [   0,  45], [480,        122.483673]);
+      assert.equalInverse(larrivee, [-180,   0], [  8.761101, 250]);
+      assert.equalInverse(larrivee, [ 180,   0], [951.238898, 250]);
+      assert.equalInverse(larrivee, [-179,  15], [ 15.405661, 204.340225]);
+      assert.equalInverse(larrivee, [   1,   1], [482.617894, 247.381895]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,26 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.laskowski");
+
+suite.addBatch({
+  "laskowski": {
+    topic: d3.geo.laskowski,
+    "projections and inverse projections": function(laskowski) {
+      assert.equalInverse(laskowski, [   0,   0], [480,        250]);
+      assert.equalInverse(laskowski, [   0, -90], [480,        474.160635]);
+      assert.equalInverse(laskowski, [   0,  90], [480,         25.839364]);
+      assert.equalInverse(laskowski, [   0, -45], [480,        373.320127]);
+      assert.equalInverse(laskowski, [   0,  45], [480,        126.679872]);
+      assert.equalInverse(laskowski, [-180,   0], [ 20.290432, 250]);
+      assert.equalInverse(laskowski, [ 180,   0], [939.709567, 250]);
+      assert.equalInverse(laskowski, [-179,  15], [ 31.276812, 179.551316]);
+      assert.equalInverse(laskowski, [   1,   1], [482.553846, 247.371809]);
+      assert.equalInverse(laskowski, [  45,  87], [525.904925,  26.307624]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,24 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.littrow");
+
+suite.addBatch({
+  "littrow": {
+    topic: d3.geo.littrow,
+    "projections and inverse projections": function(littrow) {
+      assert.equalInverse(littrow, [  0,   0], [480,        250]);
+      assert.equalInverse(littrow, [  0, -45], [480,        400]);
+      assert.equalInverse(littrow, [  0,  45], [480,        100]);
+      assert.equalInverse(littrow, [-90,   0], [330,        250]);
+      assert.equalInverse(littrow, [ 90,   0], [630,        250]);
+      assert.equalInverse(littrow, [-80,  15], [327.067798, 243.020666]);
+      assert.equalInverse(littrow, [  1,   1], [482.618259, 247.382139]);
+      assert.equalInverse(littrow, [ 15,  45], [534.903810, 105.111126]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,25 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.loximuthal");
+
+suite.addBatch({
+  "loximuthal": {
+    topic: d3.geo.loximuthal,
+    "projections and inverse projections": function(loximuthal) {
+      assert.equalInverse(loximuthal, [   0,   0], [480,        250]);
+      assert.equalInverse(loximuthal, [   0, -90], [480,        485.619449]);
+      assert.equalInverse(loximuthal, [   0,  90], [480,         14.380550]);
+      assert.equalInverse(loximuthal, [   0, -45], [480,        367.809724]);
+      assert.equalInverse(loximuthal, [   0,  45], [480,        132.190275]);
+      assert.equalInverse(loximuthal, [-180,   0], [ 48.773559, 250]);
+      assert.equalInverse(loximuthal, [ 180,   0], [911.226440, 250]);
+      assert.equalInverse(loximuthal, [-179,  15], [69.4643149, 210.730091]);
+      assert.equalInverse(loximuthal, [   1,   1], [482.390500, 247.382006]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,26 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.mollweide");
+
+suite.addBatch({
+  "mollweide": {
+    topic: d3.geo.mollweide,
+    "projections and inverse projections": function(mollweide) {
+      assert.equalInverse(mollweide, [   0,   0], [480,        250]);
+      assert.equalInverse(mollweide, [   0, -90], [480,        462.132034]);
+      assert.equalInverse(mollweide, [   0,  90], [480,         37.867965]);
+      assert.equalInverse(mollweide, [   0, -45], [480,        375.591020]);
+      assert.equalInverse(mollweide, [   0,  45], [480,        124.408979]);
+      assert.equalInverse(mollweide, [-180,   0], [ 55.735931, 250]);
+      assert.equalInverse(mollweide, [ 180,   0], [904.264068, 250]);
+      assert.equalInverse(mollweide, [-179,  15], [ 67.028260, 206.573390]);
+      assert.equalInverse(mollweide, [   1,   1], [482.356801, 247.092196]);
+      assert.equalInverse(mollweide, [  45,  87], [495.642877,  40.187699]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,25 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.mtFlatPolarParabolic");
+
+suite.addBatch({
+  "mtFlatPolarParabolic": {
+    topic: d3.geo.mtFlatPolarParabolic,
+    "projections and inverse projections": function(mtFlatPolarParabolic) {
+      assert.equalInverse(mtFlatPolarParabolic, [   0,   0], [480,        250]);
+      assert.equalInverse(mtFlatPolarParabolic, [   0, -90], [480,        458.309522]);
+      assert.equalInverse(mtFlatPolarParabolic, [   0,  90], [480,         41.690477]);
+      assert.equalInverse(mtFlatPolarParabolic, [   0, -45], [480,        374.430617]);
+      assert.equalInverse(mtFlatPolarParabolic, [   0,  45], [480,        125.569382]);
+      assert.equalInverse(mtFlatPolarParabolic, [-180,   0], [ 43.717556, 250]);
+      assert.equalInverse(mtFlatPolarParabolic, [ 180,   0], [916.282443, 250]);
+      assert.equalInverse(mtFlatPolarParabolic, [-179,  15], [ 58.080254, 207.678319]);
+      assert.equalInverse(mtFlatPolarParabolic, [   1,   1], [482.423493, 247.172271]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,25 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.mtFlatPolarQuartic");
+
+suite.addBatch({
+  "mtFlatPolarQuartic": {
+    topic: d3.geo.mtFlatPolarQuartic,
+    "projections and inverse projections": function(mtFlatPolarQuartic) {
+      assert.equalInverse(mtFlatPolarQuartic, [   0,   0], [480,        250]);
+      assert.equalInverse(mtFlatPolarQuartic, [   0, -90], [480,        448.848144]);
+      assert.equalInverse(mtFlatPolarQuartic, [   0,  90], [480,         51.151855]);
+      assert.equalInverse(mtFlatPolarQuartic, [   0, -45], [480,        371.001020]);
+      assert.equalInverse(mtFlatPolarQuartic, [   0,  45], [480,        128.998979]);
+      assert.equalInverse(mtFlatPolarQuartic, [-180,   0], [146.783779, 250]);
+      assert.equalInverse(mtFlatPolarQuartic, [ 180,   0], [813.216220, 250]);
+      assert.equalInverse(mtFlatPolarQuartic, [-179,  15], [155.997702, 208.275733]);
+      assert.equalInverse(mtFlatPolarQuartic, [   1,   1], [481.851018, 247.207163]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,25 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.mtFlatPolarSinusoidal");
+
+suite.addBatch({
+  "mtFlatPolarSinusoidal": {
+    topic: d3.geo.mtFlatPolarSinusoidal,
+    "projections and inverse projections": function(mtFlatPolarSinusoidal) {
+      assert.equalInverse(mtFlatPolarSinusoidal, [   0,   0], [480,        250]);
+      assert.equalInverse(mtFlatPolarSinusoidal, [   0, -90], [480,        465.967909]);
+      assert.equalInverse(mtFlatPolarSinusoidal, [   0,  90], [480,         34.032090]);
+      assert.equalInverse(mtFlatPolarSinusoidal, [   0, -45], [480,        377.345812]);
+      assert.equalInverse(mtFlatPolarSinusoidal, [   0,  45], [480,        122.654187]);
+      assert.equalInverse(mtFlatPolarSinusoidal, [-180,   0], [ 48.064181, 250]);
+      assert.equalInverse(mtFlatPolarSinusoidal, [ 180,   0], [911.935818, 250]);
+      assert.equalInverse(mtFlatPolarSinusoidal, [-179,  15], [ 64.236235, 207.185461]);
+      assert.equalInverse(mtFlatPolarSinusoidal, [   1,   1], [482.399298, 247.143795]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,26 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.naturalEarth");
+
+suite.addBatch({
+  "naturalEarth": {
+    topic: d3.geo.naturalEarth,
+    "projections and inverse projections": function(naturalEarth) {
+      assert.equalInverse(naturalEarth, [   0,   0], [480,        250]);
+      assert.equalInverse(naturalEarth, [   0, -90], [480,        463.358576]);
+      assert.equalInverse(naturalEarth, [   0,  90], [480,         36.641423]);
+      assert.equalInverse(naturalEarth, [   0, -45], [480,        368.957709]);
+      assert.equalInverse(naturalEarth, [   0,  45], [480,        131.042290]);
+      assert.equalInverse(naturalEarth, [-180,   0], [ 69.692291, 250]);
+      assert.equalInverse(naturalEarth, [ 180,   0], [890.307708, 250]);
+      assert.equalInverse(naturalEarth, [-179,  15], [ 76.241138, 210.406263]);
+      assert.equalInverse(naturalEarth, [   1,   1], [482.279382, 247.363076]);
+      assert.equalInverse(naturalEarth, [  45,  87], [541.511740,  38.772664]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,26 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.robinson");
+
+suite.addBatch({
+  "robinson": {
+    topic: d3.geo.robinson,
+    "projections and inverse projections": function(robinson) {
+      assert.equalInverse(robinson, [   1,   1], [482.617847, 247.036246]);
+      assert.equalInverse(robinson, [  45,  87], [545.397120,  14.047945]);
+      assert.equalInverse(robinson, [   0,   0], [480,        250]);
+      assert.equalInverse(robinson, [   0, -90], [480,        489.012369]);
+      assert.equalInverse(robinson, [   0,  90], [480,         10.987630]);
+      assert.equalInverse(robinson, [   0, -45], [480,        383.153790]);
+      assert.equalInverse(robinson, [   0,  45], [480,        116.846209]);
+      assert.equalInverse(robinson, [-180,   0], [  8.761101, 250]);
+      assert.equalInverse(robinson, [ 180,   0], [951.238898, 250]);
+      assert.equalInverse(robinson, [-179,  15], [ 16.065304, 205.543699]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,25 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.wagner6");
+
+suite.addBatch({
+  "wagner6": {
+    topic: d3.geo.wagner6,
+    "projections and inverse projections": function(wagner6) {
+      assert.equalInverse(wagner6, [   0,   0], [480,        250]);
+      assert.equalInverse(wagner6, [   0, -90], [480,        485.619449]);
+      assert.equalInverse(wagner6, [   0,  90], [480,         14.380550]);
+      assert.equalInverse(wagner6, [   0, -45], [480,        367.809724]);
+      assert.equalInverse(wagner6, [   0,  45], [480,        132.190275]);
+      assert.equalInverse(wagner6, [-180,   0], [  8.761101, 250]);
+      assert.equalInverse(wagner6, [ 180,   0], [951.238898, 250]);
+      assert.equalInverse(wagner6, [-179,  15], [16.2862562, 210.730091]);
+      assert.equalInverse(wagner6, [   1,   1], [482.617872, 247.382006]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,26 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.winkel3");
+
+suite.addBatch({
+  "winkel3": {
+    topic: d3.geo.winkel3,
+    "projections and inverse projections": function(winkel3) {
+      assert.equalInverse(winkel3, [   0,   0], [480,        250]);
+      assert.equalInverse(winkel3, [   0, -90], [480,        485.619449]);
+      assert.equalInverse(winkel3, [   0,  90], [480,         14.380550]);
+      assert.equalInverse(winkel3, [   0, -45], [480,        367.809724]);
+      assert.equalInverse(winkel3, [   0,  45], [480,        132.190275]);
+      assert.equalInverse(winkel3, [-180,   0], [ 94.380550, 250]);
+      assert.equalInverse(winkel3, [ 180,   0], [865.619449, 250]);
+      assert.equalInverse(winkel3, [-179,  15], [104.464309, 200.036192]);
+      assert.equalInverse(winkel3, [   1,   1], [482.142197, 247.381989]);
+      assert.equalInverse(winkel3, [  45,  87], [522.079049,  21.958321]);
+    }
+  }
+});
+
+suite.export(module);

data/vendor/assets/javascripts/d3/plugins/geo/projection/van-der-grinten.js

@@ -0,0 +1,41 @@
+function vanDerGrinten(λ, φ) {
+  if (Math.abs(φ) < ε) return [λ, 0];
+  var sinθ = Math.abs(2 * φ / π),
+      θ = asin(sinθ);
+  if (Math.abs(λ) < ε || Math.abs(Math.abs(φ) - π / 2) < ε) return [0, sgn(φ) * π * Math.tan(θ / 2)];
+  var cosθ = Math.cos(θ),
+      A = Math.abs(π / λ - λ / π) / 2,
+      A2 = A * A,
+      G = cosθ / (sinθ + cosθ - 1),
+      P = G * (2 / sinθ - 1),
+      P2 = P * P,
+      P2_A2 = P2 + A2,
+      G_P2 = G - P2,
+      Q = A2 + G;
+  return [
+    sgn(λ) * π * (A * G_P2 + Math.sqrt(A2 * G_P2 * G_P2 - P2_A2 * (G * G - P2))) / P2_A2,
+    sgn(φ) * π * (P * Q - A * Math.sqrt((A2 + 1) * P2_A2 - Q * Q)) / P2_A2
+  ];
+}
+
+vanDerGrinten.invert = function(x, y) {
+  if (Math.abs(y) < ε) return [x, 0];
+  if (Math.abs(x) < ε) return [0, π / 2 * Math.sin(2 * Math.atan(y / π))];
+  var x2 = (x /= π) * x,
+      y2 = (y /= π) * y,
+      x2_y2 = x2 + y2,
+      z = x2_y2 * x2_y2,
+      c1 = -Math.abs(y) * (1 + x2_y2),
+      c2 = c1 - 2 * y2 + x2,
+      c3 = -2 * c1 + 1 + 2 * y2 + z,
+      d = y2 / c3 + (2 * c2 * c2 * c2 / (c3 * c3 * c3) - 9 * c1 * c2 / (c3 * c3)) / 27,
+      a1 = (c1 - c2 * c2 / (3 * c3)) / c3,
+      m1 = 2 * Math.sqrt(-a1 / 3),
+      θ1 = acos(3 * d / (a1 * m1)) / 3;
+  return [
+    π * (x2_y2 - 1 + Math.sqrt(1 + 2 * (x2 - y2) + z)) / (2 * x),
+    sgn(y) * π * (-m1 * Math.cos(θ1 + π / 3) - c2 / (3 * c3))
+  ];
+};
+
+(d3.geo.vanDerGrinten = function() { return projection(vanDerGrinten); }).raw = vanDerGrinten;

data/vendor/assets/javascripts/d3/plugins/geo/projection/van-der-grinten4.js

@@ -0,0 +1,22 @@
+function vanDerGrinten4(λ, φ) {
+  if (!φ) return [λ, 0];
+  var φ0 = Math.abs(φ);
+  if (!λ || φ0 === π / 2) return [0, φ];
+  var t,
+      B = 2 * φ0 / π,
+      B2 = B * B,
+      C = (8 * B - B2 * (B2 + 2) - 5) / (2 * B2 * (B - 1)),
+      C2 = C * C,
+      BC = B * C,
+      B_C2 = B2 + C2 + 2 * BC,
+      D = sgn(Math.abs(λ) - π / 2) * Math.sqrt((t = (t = 2 * λ / π) + 1 / t) * t - 4),
+      D2 = D * D,
+      F = B_C2 * (B2 + C2 * D2 - 1) + (1 - B2) * (B2 * ((t = B + 3 * C) * t + 4 * C2) + 12 * BC * C2 + 4 * C2 * C2),
+      x1 = (D * (B_C2 + C2 - 1) + 2 * Math.sqrt(F)) / (4 * B_C2 + D2);
+  return [
+    sgn(λ) * π * x1 / 2,
+    sgn(φ) * π / 2 * Math.sqrt(1 + D * Math.abs(x1) - x1 * x1)
+  ];
+}
+
+(d3.geo.vanDerGrinten4 = function() { return projection(vanDerGrinten4); }).raw = vanDerGrinten4;

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

@@ -0,0 +1,9 @@
+// @import mollweide
+
+var wagner4 = (function() {
+  var A = 4 * π + 3 * Math.sqrt(3),
+      B = 2 * Math.sqrt(2 * π * Math.sqrt(3) / A);
+  return mollweideBromley(B * Math.sqrt(3) / π, B, A / 6);
+})();
+
+(d3.geo.wagner4 = function() { return projection(wagner4); }).raw = wagner4;

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

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

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

@@ -0,0 +1,22 @@
+function wagner7(λ, φ) {
+  var s = .90631 * Math.sin(φ),
+      c0 = Math.sqrt(1 - s * s),
+      c1 = Math.sqrt(2 / (1 + c0 * Math.cos(λ /= 3)));
+  return [
+    2.66723 * c0 * c1 * Math.sin(λ),
+    1.24104 * s * c1
+  ];
+}
+
+wagner7.invert = function(x, y) {
+  var t1 = x / 2.66723,
+      t2 = y / 1.24104,
+      p = Math.sqrt(t1 * t1 + t2 * t2),
+      c = 2 * asin(p / 2);
+  return [
+    3 * Math.atan2(x * Math.tan(c), 2.66723 * p),
+    p && asin(y * Math.sin(c) / (1.24104 * 0.90631 * p))
+  ];
+};
+
+(d3.geo.wagner7 = function() { return projection(wagner7); }).raw = wagner7;