d3js-plugins-rails 0.0.1

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

@@ -0,0 +1,19 @@
+// @import mollweide
+// @import sinusoidal
+
+var sinuMollweideφ = .7109889596207567,
+    sinuMollweideY = .0528035274542;
+
+function sinuMollweide(λ, φ) {
+  return φ > -sinuMollweideφ
+      ? (λ = mollweide(λ, φ), λ[1] += sinuMollweideY, λ)
+      : sinusoidal(λ, φ);
+}
+
+sinuMollweide.invert = function(x, y) {
+  return y > -sinuMollweideφ
+      ? mollweide.invert(x, y - sinuMollweideY)
+      : sinusoidal.invert(x, y);
+};
+
+(d3.geo.sinuMollweide = function() { return projection(sinuMollweide).rotate([-20, -55]); }).raw = sinuMollweide;

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

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

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

@@ -0,0 +1 @@
+(function() {

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

@@ -0,0 +1,26 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.aitoff");
+
+suite.addBatch({
+  "aitoff": {
+    topic: d3.geo.aitoff,
+    "projections and inverse projections": function(aitoff) {
+      assert.equalInverse(aitoff, [   0,   0], [480,        250]);
+      assert.equalInverse(aitoff, [   0, -90], [480,        485.619449]);
+      assert.equalInverse(aitoff, [   0,  90], [480,         14.380550]);
+      assert.equalInverse(aitoff, [   0, -45], [480,        367.809724]);
+      assert.equalInverse(aitoff, [   0,  45], [480,        132.190275]);
+      assert.equalInverse(aitoff, [-180,   0], [  8.761101, 250]);
+      assert.equalInverse(aitoff, [ 180,   0], [951.238898, 250]);
+      assert.equalInverse(aitoff, [-179,  15], [ 27.261952, 189.342293]);
+      assert.equalInverse(aitoff, [   1,   1], [482.617728, 247.381972]);
+      assert.equalInverse(aitoff, [  45,  87], [489.158099, 21.6821110]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,28 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.armadillo");
+
+suite.addBatch({
+  "armadillo": {
+    topic: d3.geo.armadillo,
+    "projections and inverse projections": function(armadillo) {
+      assert.equalInverse(armadillo, [   0,   0], [480,        250]);
+      // TODO: needs D3 core support
+      // assert.isNaN(armadillo([0, -90])[0]);
+      assert.equalInverse(armadillo, [   0,  90], [480,         57.743085]);
+      assert.equalInverse(armadillo, [   0, -45], [480,        334.643146]);
+      assert.equalInverse(armadillo, [   0,  45], [480,        135.304239]);
+      // TODO figure out why the inverse doesn't match exactly.
+      // assert.equalInverse(armadillo, [-180,   0], [180, 147.393957]);
+      // assert.equalInverse(armadillo, [ 180,   0], [780, 147.393957]);
+      assert.equalInverse(armadillo, [-179,  15], [185.122354, 111.792545]);
+      assert.equalInverse(armadillo, [   1,   1], [482.617761, 247.528295]);
+      assert.equalInverse(armadillo, [  45,  87], [540.406730,  56.511657]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,26 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.baker");
+
+suite.addBatch({
+  "baker": {
+    topic: d3.geo.baker,
+    "projections and inverse projections": function(baker) {
+      assert.equalInverse(baker, [   0,   0], [480,        250]);
+      assert.equalInverse(baker, [   0, -90], [480,        583.216220]);
+      assert.equalInverse(baker, [   0,  90], [480,        -83.216220]);
+      assert.equalInverse(baker, [   0, -45], [480,        382.206038]);
+      assert.equalInverse(baker, [   0,  45], [480,        117.793961]);
+      assert.equalInverse(baker, [-180,   0], [  8.761101, 250]);
+      assert.equalInverse(baker, [ 180,   0], [951.238898, 250]);
+      assert.equalInverse(baker, [-179,  15], [ 11.379095, 210.273662]);
+      assert.equalInverse(baker, [   1,   1], [482.617993, 247.381873]);
+      assert.equalInverse(baker, [  45,  87], [491.265043, -68.859378]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,26 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.boggs");
+
+suite.addBatch({
+  "boggs": {
+    topic: d3.geo.boggs,
+    "projections and inverse projections": function(boggs) {
+      assert.equalInverse(boggs, [   0,   0], [480,        250]);
+      assert.equalInverse(boggs, [   0, -90], [480,        473.567218]);
+      assert.equalInverse(boggs, [   0,  90], [480,         26.432781]);
+      assert.equalInverse(boggs, [   0, -45], [480,        371.532657]);
+      assert.equalInverse(boggs, [   0,  45], [480,        128.467342]);
+      assert.equalInverse(boggs, [-180,   0], [ 32.864228, 250]);
+      assert.equalInverse(boggs, [ 180,   0], [927.135771, 250]);
+      assert.equalInverse(boggs, [-179,  15], [ 47.500957, 208.708722]);
+      assert.equalInverse(boggs, [   1,   1], [482.483785, 247.240908]);
+      assert.equalInverse(boggs, [  45,  87], [488.857270,  31.512628]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,45 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.bonne");
+
+suite.addBatch({
+  "bonne": {
+    "40° parallel": {
+      topic: function() {
+        return d3.geo.bonne().parallel(40);
+      },
+      "projections and inverse projections": function(bonne) {
+        assert.equalInverse(bonne, [   0,   0], [480,         250]);
+        assert.equalInverse(bonne, [   0, -90], [480,         485.619449]);
+        assert.equalInverse(bonne, [   0,  90], [480,          14.380550]);
+        assert.equalInverse(bonne, [   0, -45], [480,         367.809724]);
+        assert.equalInverse(bonne, [   0,  45], [480,         132.190275]);
+        assert.equalInverse(bonne, [-180,   0], [197.703665,  -59.391754]);
+        assert.equalInverse(bonne, [ 180,   0], [762.296334,  -59.391754]);
+        assert.equalInverse(bonne, [-179,  15], [245.482446, -101.610988]);
+        assert.equalInverse(bonne, [   1,   1], [482.617557,  247.369808]);
+      }
+    },
+    "90° parallel (Werner)": {
+      topic: function() {
+        return d3.geo.bonne().parallel(90);
+      },
+      "projections and inverse projections": function(bonne) {
+        assert.equalInverse(bonne, [0, 0], [480, 250]);
+      }
+    },
+    "0° parallel (sinusoidal)": {
+      topic: function() {
+        return d3.geo.bonne().parallel(0);
+      },
+      "projections and inverse projections": function(bonne) {
+        assert.equalInverse(bonne, [0, 0], [480, 250]);
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,25 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.craig");
+
+suite.addBatch({
+  "craig": {
+    topic: d3.geo.craig,
+    "projections and inverse projections": function(craig) {
+      assert.inDelta(craig([   0,   0]), [480,          250], 1e-6);
+      assert.inDelta(craig([   0, -90]), [480,          400], 1e-6);
+      assert.inDelta(craig([   0,  90]), [480,          100], 1e-6);
+      assert.inDelta(craig([   0, -45]), [480,          356.066017], 1e-6);
+      assert.inDelta(craig([   0,  45]), [480,          143.933982], 1e-6);
+      assert.inDelta(craig([-180,   0]), [  8.761101,   250], 1e-6);
+      assert.inDelta(craig([ 180,   0]), [951.238898,   250], 1e-6);
+      assert.inDelta(craig([-179,  15]), [ 11.3790958, 7198.585721], 1e-6);
+      assert.inDelta(craig([   1,   1]), [482.617993,   247.382404], 1e-6);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,25 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.craster");
+
+suite.addBatch({
+  "craster": {
+    topic: d3.geo.craster,
+    "projections and inverse projections": function(craster) {
+      assert.equalInverse(craster, [   0,   0], [480,        250]);
+      assert.equalInverse(craster, [   0, -90], [480,        480.248509]);
+      assert.equalInverse(craster, [   0,  90], [480,         19.751490]);
+      assert.equalInverse(craster, [   0, -45], [480,        369.185398]);
+      assert.equalInverse(craster, [   0,  45], [480,        130.814601]);
+      assert.equalInverse(craster, [-180,   0], [ 19.502981, 250]);
+      assert.equalInverse(craster, [ 180,   0], [940.497018, 250]);
+      assert.equalInverse(craster, [-179,  15], [ 35.975533, 209.865040]);
+      assert.equalInverse(craster, [   1,   1], [482.557970, 247.320952]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,32 @@
+require("d3");
+require("../../../d3.geo.projection");
+
+var assert = require("assert");
+
+assert.inDelta = function(actual, expected, delta, message) {
+  if (!inDelta(actual, expected, delta)) {
+    assert.fail(actual, expected, message || "expected {actual} to be in within *" + delta + "* of {expected}", null, assert.inDelta);
+  }
+};
+
+assert.equalInverse = function(projection, location, point) {
+  var projected;
+  assert.inDelta(projected = projection(location), point, 1e-6);
+  assert.inDelta(projection.invert(projected), location, 1e-6);
+  assert.inDelta(projection(projection.invert(point)), point, 1e-6);
+};
+
+function inDelta(actual, expected, delta) {
+  return (Array.isArray(expected) ? inDeltaArray : inDeltaNumber)(actual, expected, delta);
+}
+
+function inDeltaArray(actual, expected, delta) {
+  var n = expected.length, i = -1;
+  if (actual.length !== n) return false;
+  while (++i < n) if (!inDelta(actual[i], expected[i], delta)) return false;
+  return true;
+}
+
+function inDeltaNumber(actual, expected, delta) {
+  return actual >= expected - delta && actual <= expected + delta;
+}

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

@@ -0,0 +1,97 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.equirectangular");
+
+var π = Math.PI;
+
+suite.addBatch({
+  "equirectangular": {
+    "rotate": {
+      "identity": {
+        topic: function() {
+          return d3.geo.equirectangular().rotate([0, 0]).translate([0, 0]).scale(1);
+        },
+        "projections and inverse projections": function(projection) {
+          assert.equalInverse(projection, [   0,   0], [ 0,  0]);
+          assert.equalInverse(projection, [-180,   0], [-π,  0]);
+          assert.equalInverse(projection, [ 180,   0], [ π,  0]);
+          assert.equalInverse(projection, [   0,  30], [ 0, -π / 6]);
+          assert.equalInverse(projection, [   0, -30], [ 0,  π / 6]);
+          assert.equalInverse(projection, [  30,  30], [ π / 6, -π / 6]);
+          assert.equalInverse(projection, [  30, -30], [ π / 6,  π / 6]);
+          assert.equalInverse(projection, [ -30,  30], [-π / 6, -π / 6]);
+          assert.equalInverse(projection, [ -30, -30], [-π / 6,  π / 6]);
+        }
+      },
+      "[30, 0]": {
+        topic: function() {
+          return d3.geo.equirectangular().rotate([30, 0]).translate([0, 0]).scale(1);
+        },
+        "projections and inverse projections": function(projection) {
+          assert.equalInverse(projection, [   0,   0], [ π / 6,  0]);
+          assert.equalInverse(projection, [-180,   0], [-5 / 6 * π,  0]);
+          assert.inDelta(    projection( [ 180,   0]),[-5 / 6 * π,  0], 1e-6); // inverse is [-180, 0]
+          assert.equalInverse(projection, [   0,  30], [ π / 6, -π / 6]);
+          assert.equalInverse(projection, [   0, -30], [ π / 6,  π / 6]);
+          assert.equalInverse(projection, [  30,  30], [ π / 3, -π / 6]);
+          assert.equalInverse(projection, [  30, -30], [ π / 3,  π / 6]);
+          assert.equalInverse(projection, [ -30,  30], [ 0    , -π / 6]);
+          assert.equalInverse(projection, [ -30, -30], [ 0    ,  π / 6]);
+        }
+      },
+      "[30, 30]": {
+        topic: function() {
+          return d3.geo.equirectangular().rotate([30, 30]).translate([0, 0]).scale(1);
+        },
+        "projections and inverse projections": function(projection) {
+          assert.equalInverse(projection, [   0,   0], [ 0.5880026035475674, -0.44783239692893245]);
+          assert.equalInverse(projection, [-180,   0], [-2.5535900500422257,  0.44783239692893245]);
+          assert.inDelta(    projection( [ 180,   0]),[-2.5535900500422257,  0.44783239692893245], 1e-6); // inverse is [-180, 0]
+          assert.equalInverse(projection, [   0,  30], [ 0.8256075561643480, -0.94077119517052080]);
+          assert.equalInverse(projection, [   0, -30], [ 0.4486429615608479,  0.05804529130778048]);
+          assert.equalInverse(projection, [  30,  30], [ 1.4056476493802694, -0.70695172788721770]);
+          assert.equalInverse(projection, [  30, -30], [ 0.8760580505981933,  0.21823451436745955]);
+          assert.equalInverse(projection, [ -30,  30], [ 0,                  -1.04719755119659760]);
+          assert.equalInverse(projection, [ -30, -30], [ 0,                   0]);
+        }
+      },
+      "[0, 0, 30]": {
+        topic: function() {
+          return d3.geo.equirectangular().rotate([0, 0, 30]).translate([0, 0]).scale(1);
+        },
+        "projections and inverse projections": function(projection) {
+          assert.equalInverse(projection, [   0,   0], [ 0, 0]);
+          assert.equalInverse(projection, [-180,   0], [-π, 0]);
+          assert.equalInverse(projection, [ 180,   0], [ π, 0]);
+          assert.equalInverse(projection, [   0,  30], [-0.2810349015028135, -0.44783239692893245]);
+          assert.equalInverse(projection, [   0, -30], [ 0.2810349015028135,  0.44783239692893245]);
+          assert.equalInverse(projection, [  30,  30], [ 0.1651486774146268, -0.70695172788721760]);
+          assert.equalInverse(projection, [  30, -30], [ 0.6947382761967031,  0.21823451436745964]);
+          assert.equalInverse(projection, [ -30,  30], [-0.6947382761967031, -0.21823451436745964]);
+          assert.equalInverse(projection, [ -30, -30], [-0.1651486774146268,  0.70695172788721760]);
+        }
+      },
+      "[30, 30, 30]": {
+        topic: function() {
+          return d3.geo.equirectangular().rotate([30, 30, 30]).translate([0, 0]).scale(1);
+        },
+        "projections and inverse projections": function(projection) {
+          assert.equalInverse(projection, [   0,   0], [ 0.2810349015028135, -0.67513153293703170]);
+          assert.equalInverse(projection, [-180,   0], [-2.8605577520869800,  0.67513153293703170]);
+          assert.inDelta(    projection( [ 180,   0]),[-2.8605577520869800,  0.67513153293703170], 1e-6); // inverse is [-180, 0]
+          assert.equalInverse(projection, [   0,  30], [-0.0724760059270816, -1.15865677086597720]);
+          assert.equalInverse(projection, [   0, -30], [ 0.4221351552567053, -0.16704161863132252]);
+          assert.equalInverse(projection, [  30,  30], [ 1.2033744221750944, -1.21537512510467320]);
+          assert.equalInverse(projection, [  30, -30], [ 0.8811235701944905, -0.18861638617540410]);
+          assert.equalInverse(projection, [ -30,  30], [-0.7137243789447654, -0.84806207898148100]);
+          assert.equalInverse(projection, [ -30, -30], [ 0,                   0]);
+        }
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,29 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.hammer");
+
+suite.addBatch({
+  "hammer": {
+    "quarticAuthalic": {
+      topic: function() {
+        return d3.geo.hammer().coefficient(Infinity);
+      },
+      "projections and inverse projections": function(quarticAuthalic) {
+        assert.equalInverse(quarticAuthalic, [   0,   0], [480,        250]);
+        assert.equalInverse(quarticAuthalic, [   0, -90], [480,        462.132034]);
+        assert.equalInverse(quarticAuthalic, [   0,  90], [480,         37.867965]);
+        assert.equalInverse(quarticAuthalic, [   0, -45], [480,        364.805029]);
+        assert.equalInverse(quarticAuthalic, [   0,  45], [480,        135.194970]);
+        assert.equalInverse(quarticAuthalic, [-180,   0], [  8.761101, 250]);
+        assert.equalInverse(quarticAuthalic, [ 180,   0], [951.238898, 250]);
+        assert.equalInverse(quarticAuthalic, [-179,  15], [ 23.441040, 210.842142]);
+        assert.equalInverse(quarticAuthalic, [   1,   1], [482.617694, 247.382039]);
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,25 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.hatano");
+
+suite.addBatch({
+  "hatano": {
+    topic: d3.geo.hatano,
+    "projections and inverse projections": function(hatano) {
+      assert.equalInverse(hatano, [   0,   0], [480,        250]);
+      assert.equalInverse(hatano, [   0, -90], [480,        441.538303]);
+      assert.equalInverse(hatano, [   0,  90], [480,         53.383198]);
+      assert.equalInverse(hatano, [   0, -45], [480,        379.209449]);
+      assert.equalInverse(hatano, [   0,  45], [480,        119.704758]);
+      assert.equalInverse(hatano, [-180,   0], [ 79.446936, 250]);
+      assert.equalInverse(hatano, [ 180,   0], [880.553063, 250]);
+      assert.equalInverse(hatano, [-179,  15], [87.7505160, 204.093101]);
+      assert.equalInverse(hatano, [   1,   1], [482.225143, 246.920082]);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,26 @@
+require("./env");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.geo.hill");
+
+suite.addBatch({
+  "hill": {
+    topic: d3.geo.hill,
+    "projections and inverse projections": function(hill) {
+      assert.equalInverse(hill, [   0,   0], [480,        250]);
+      assert.equalInverse(hill, [   0, -90], [480,        416.823782]);
+      assert.equalInverse(hill, [   0,  90], [480,         18.873653]);
+      assert.equalInverse(hill, [   0, -45], [480,        364.499449]);
+      assert.equalInverse(hill, [   0,  45], [480,        113.253357]);
+      assert.equalInverse(hill, [-180,   0], [122.993559,  59.760268]);
+      assert.equalInverse(hill, [ 180,   0], [837.006440,  59.760268]);
+      assert.equalInverse(hill, [-179,  15], [154.461200,  25.636205]);
+      assert.equalInverse(hill, [   1,   1], [482.330467, 247.058682]);
+      assert.equalInverse(hill, [  45,  87], [508.223694,  17.762871]);
+    }
+  }
+});
+
+suite.export(module);