d3js-plugins-rails 0.0.1

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

@@ -0,0 +1,14 @@
+function wiechel(λ, φ) {
+  var cosφ = Math.cos(φ),
+      sinφ = Math.cos(λ) * cosφ,
+      sin1_φ = 1 - sinφ,
+      cosλ = Math.cos(λ = Math.atan2(Math.sin(λ) * cosφ, -Math.sin(φ))),
+      sinλ = Math.sin(λ);
+  cosφ = asqrt(1 - sinφ * sinφ);
+  return [
+    sinλ * cosφ - cosλ * sin1_φ,
+    -cosλ * cosφ - sinλ * sin1_φ
+  ];
+}
+
+(d3.geo.wiechel = function() { return projection(wiechel); }).raw = wiechel;

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

@@ -0,0 +1,40 @@
+// @import aitoff
+
+function winkel3(λ, φ) {
+  var coordinates = aitoff(λ, φ);
+  return [
+    (coordinates[0] + λ * 2 / π) / 2,
+    (coordinates[1] + φ) / 2
+  ];
+}
+
+winkel3.invert = function(x, y) {
+  var λ = x, φ = y, i = 25;
+  do {
+    var cosφ = Math.cos(φ),
+        sinφ = Math.sin(φ),
+        sin_2φ = Math.sin(2 * φ),
+        sin2φ = sinφ * sinφ,
+        cos2φ = cosφ * cosφ,
+        sinλ = Math.sin(λ),
+        cosλ_2 = Math.cos(λ / 2),
+        sinλ_2 = Math.sin(λ / 2),
+        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 = .5 * (2 * E * cosφ * sinλ_2 + λ * 2 / π) - x,
+        fy = .5 * (E * sinφ + φ) - y,
+        δxδλ = .5 * F * (cos2φ * sin2λ_2 + E * cosφ * cosλ_2 * sin2φ) + .5 * 2 / π,
+        δxδφ = F * (sinλ * sin_2φ / 4 - E * sinφ * sinλ_2),
+        δyδλ = .125 * F * (sin_2φ * sinλ_2 - E * sinφ * cos2φ * sinλ),
+        δyδφ = .5 * F * (sin2φ * cosλ_2 + E * sin2λ_2 * cosφ) + .5,
+        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.winkel3 = function() { return projection(winkel3); }).raw = winkel3;

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

@@ -0,0 +1,6 @@
+# Zoomable Tiles
+
+* Panning & Zooming Demo: <http://bl.ocks.org/4132797>
+* Clipping Demo: <http://bl.ocks.org/4150951>
+
+A layout for determining which 256x256 quadtree tiles to display in a rectangular viewport, based on a scale and translate. This layout can be used to create a simple slippy map, or render standard map tiles (e.g., MapBox, CloudMade) as a base layer behind a geographic projection.

data/vendor/assets/javascripts/d3/plugins/geo/tile/tile.js

@@ -0,0 +1,53 @@
+d3.geo.tile = function() {
+  var size = [960, 500],
+      scale = 256,
+      translate = [size[0] / 2, size[1] / 2],
+      zoomDelta = 0;
+
+  function tile() {
+    var z = Math.max(Math.log(scale) / Math.LN2 - 8, 0),
+        z0 = Math.round(z + zoomDelta),
+        k = Math.pow(2, z - z0 + 8),
+        origin = [(translate[0] - scale / 2) / k, (translate[1] - scale / 2) / k],
+        tiles = [],
+        cols = d3.range(Math.max(0, Math.floor(-origin[0])), Math.max(0, Math.ceil(size[0] / k - origin[0]))),
+        rows = d3.range(Math.max(0, Math.floor(-origin[1])), Math.max(0, Math.ceil(size[1] / k - origin[1])));
+
+    rows.forEach(function(y) {
+      cols.forEach(function(x) {
+        tiles.push([x, y, z0]);
+      });
+    });
+
+    tiles.translate = origin;
+    tiles.scale = k;
+
+    return tiles;
+  }
+
+  tile.size = function(_) {
+    if (!arguments.length) return size;
+    size = _;
+    return tile;
+  };
+
+  tile.scale = function(_) {
+    if (!arguments.length) return scale;
+    scale = _;
+    return tile;
+  };
+
+  tile.translate = function(_) {
+    if (!arguments.length) return translate;
+    translate = _;
+    return tile;
+  };
+
+  tile.zoomDelta = function(_) {
+    if (!arguments.length) return zoomDelta;
+    zoomDelta = +_;
+    return tile;
+  };
+
+  return tile;
+};

data/vendor/assets/javascripts/d3/plugins/geodesic/README.md

@@ -0,0 +1,3 @@
+# Geodesic Grid
+
+Example: <http://bl.ocks.org/3057239>

data/vendor/assets/javascripts/d3/plugins/geodesic/geodesic.js

@@ -0,0 +1,130 @@
+(function() {
+  var φ = 1.618033988749895,
+      ρ = 180 / Math.PI;
+
+  var vertices = [
+    [1,φ,0], [-1,φ,0], [1,-φ,0], [-1,-φ,0],
+    [0,1,φ], [0,-1,φ], [0,1,-φ], [0,-1,-φ],
+    [φ,0,1], [-φ,0,1], [φ,0,-1], [-φ,0,-1]
+  ];
+
+  var faces = [
+    [0,1,4],  [1,9,4],  [4,9,5],  [5,9,3],  [2,3,7],
+    [3,2,5],  [7,10,2], [0,8,10], [0,4,8],  [8,2,10],
+    [8,4,5],  [8,5,2],  [1,0,6],  [11,1,6], [3,9,11],
+    [6,10,7], [3,11,7], [11,6,7], [6,0,10], [9,1,11]
+  ].map(function(face) {
+    return face.map(function(i) {
+      return vertices[i];
+    });
+  });
+
+  d3.geodesic = {
+    multipolygon: function(n) {
+      return {
+        type: "MultiPolygon",
+        coordinates: subdivideFaces(~~n).map(function(face) {
+          face = face.map(project);
+          face.push(face[0]);
+          return [face];
+        })
+      };
+    },
+    polygons: function(n) {
+      return d3.geodesic.multipolygon(~~n).coordinates.map(function(face) {
+        return {type: "Polygon", coordinates: face};
+      });
+    },
+    multilinestring: function(n) {
+      return {
+        type: "MultiLineString",
+        coordinates: subdivideEdges(~~n).map(function(edge) {
+          return edge.map(project);
+        })
+      };
+    }
+  };
+
+  function subdivideFaces(n) {
+    return d3.merge(faces.map(function(face) {
+      var i01 = interpolate(face[0], face[1]),
+          i02 = interpolate(face[0], face[2]),
+          faces = [];
+
+      faces.push([
+        face[0],
+        i01(1 / n),
+        i02(1 / n)
+      ]);
+
+      for (var i = 1; i < n; ++i) {
+        var i1 = interpolate(i01(i / n), i02(i / n)),
+            i2 = interpolate(i01((i + 1) / n), i02((i + 1) / n));
+        for (var j = 0; j <= i; ++j) {
+          faces.push([
+            i1(j / i),
+            i2(j / (i + 1)),
+            i2((j + 1) / (i + 1))
+          ]);
+        }
+        for (var j = 0; j < i; ++j) {
+          faces.push([
+            i1(j / i),
+            i1((j + 1) / i),
+            i2((j + 1) / (i + 1))
+          ]);
+        }
+      }
+
+      return faces;
+    }));
+  }
+
+  function subdivideEdges(n) {
+    var edges = {};
+
+    subdivideFaces(n).forEach(function(face) {
+      add(face[0], face[1]);
+      add(face[1], face[2]);
+      add(face[2], face[0]);
+    });
+
+    function add(p0, p1) {
+      var t;
+      if (p0[0] < p1[0] || (p0[0] == p1[0] && (p0[1] < p1[1] || (p0[1] == p1[1] && p0[2] < p1[2])))) t = p0, p0 = p1, p1 = t;
+      edges[p0.map(round) + " " + p1.map(round)] = [p0, p1];
+    }
+
+    function round(d) {
+      return d3.round(d, 4);
+    }
+
+    return d3.values(edges);
+  }
+
+  function interpolate(p0, p1) {
+    var x0 = p0[0],
+        y0 = p0[1],
+        z0 = p0[2],
+        x1 = p1[0] - x0,
+        y1 = p1[1] - y0,
+        z1 = p1[2] - z0;
+    return function(t) {
+      return [
+        x0 + t * x1,
+        y0 + t * y1,
+        z0 + t * z1
+      ];
+    };
+  }
+
+  function project(p) {
+    var x = p[0],
+        y = p[1],
+        z = p[2];
+    return [
+      Math.atan2(y, x) * ρ,
+      Math.acos(z / Math.sqrt(x * x + y * y + z * z)) * ρ - 90
+    ];
+  }
+})();

data/vendor/assets/javascripts/d3/plugins/geom/contour/README.md

@@ -0,0 +1,5 @@
+# Contour Plots
+
+Demo: <http://bl.ocks.org/4241134>
+
+Computes a contour for a given *grid function* using the [marching squares](http://en.wikipedia.org/wiki/Marching_squares) algorithm. Returns the contour polygon as an array of points. The grid function takes two arguments, *x* and *y*, and returns true if the specified point is inside the contour, and false for points outside the contour. The contour plugin can also take an optional starting point [x, y] on the grid.

data/vendor/assets/javascripts/d3/plugins/geom/contour/contour.js

@@ -0,0 +1,72 @@
+(function() {
+
+d3.geom.contour = function(grid, start) {
+  var s = start || d3_geom_contourStart(grid), // starting point
+      c = [],    // contour polygon
+      x = s[0],  // current x position
+      y = s[1],  // current y position
+      dx = 0,    // next x direction
+      dy = 0,    // next y direction
+      pdx = NaN, // previous x direction
+      pdy = NaN, // previous y direction
+      i = 0;
+
+  do {
+    // determine marching squares index
+    i = 0;
+    if (grid(x-1, y-1)) i += 1;
+    if (grid(x,   y-1)) i += 2;
+    if (grid(x-1, y  )) i += 4;
+    if (grid(x,   y  )) i += 8;
+
+    // determine next direction
+    if (i === 6) {
+      dx = pdy === -1 ? -1 : 1;
+      dy = 0;
+    } else if (i === 9) {
+      dx = 0;
+      dy = pdx === 1 ? -1 : 1;
+    } else {
+      dx = d3_geom_contourDx[i];
+      dy = d3_geom_contourDy[i];
+    }
+
+    // update contour polygon
+    if (dx != pdx && dy != pdy) {
+      c.push([x, y]);
+      pdx = dx;
+      pdy = dy;
+    }
+
+    x += dx;
+    y += dy;
+  } while (s[0] != x || s[1] != y);
+
+  return c;
+};
+
+// lookup tables for marching directions
+var d3_geom_contourDx = [1, 0, 1, 1,-1, 0,-1, 1,0, 0,0,0,-1, 0,-1,NaN],
+    d3_geom_contourDy = [0,-1, 0, 0, 0,-1, 0, 0,1,-1,1,1, 0,-1, 0,NaN];
+
+function d3_geom_contourStart(grid) {
+  var x = 0,
+      y = 0;
+
+  // search for a starting point; begin at origin
+  // and proceed along outward-expanding diagonals
+  while (true) {
+    if (grid(x,y)) {
+      return [x,y];
+    }
+    if (x === 0) {
+      x = y + 1;
+      y = 0;
+    } else {
+      x = x - 1;
+      y = y + 1;
+    }
+  }
+}
+
+})();

data/vendor/assets/javascripts/d3/plugins/graph/README.md

@@ -0,0 +1,148 @@
+# d3.graph
+
+A plugin for manipulating [graph data structures](http://opendatastructures.org/ods-cpp/12_Graphs.html). This plugin is unstable and in development.
+
+## Todo
+
+* link nodes by name. see this [discussion on the force layout](https://groups.google.com/forum/?fromgroups#!topic/d3-js/LWuhBeEipz4)
+
+* adjacency list
+* graph traversal
+* hypergraph
+
+## Matrix
+
+Create a matrix
+
+```js
+  var matrix = d3.graph.matrix([
+    [1,1,0],
+    [0,0,0],
+    [2,1,1]
+  ]);
+```
+
+Get an edge value
+
+```js
+matrix(i,j)
+```
+
+Check if edge exists (non-zero)
+
+```js
+matrix.has(i,j)
+```
+
+Set an edge value
+
+```js
+matrix.set(i,j,value)
+```
+
+Remove an edge
+
+```js
+matrix.remove(i,j)
+```
+
+Get outgoing edge indices
+
+```js
+matrix.outE(i)
+```
+
+Get incoming edge indices
+
+```js
+matrix.inE(i)
+```
+
+### todo
+
+* documentation
+* changing size
+
+## Basics
+
+Convert [matrix](http://en.wikipedia.org/wiki/Adjacency_matrix) to [list](http://opendatastructures.org/ods-cpp/12_2_Graph_as_Collection_Li.html)
+
+```js
+d3.graph.matrixToList([
+  [0,1,0],
+  [1,0,0],
+  [1,1,1]
+])
+/*
+[
+  {"source":0,"target":0,"value":0},{"source":0,"target":1,"value":1},{"source":0,"target":2,"value":0},
+  {"source":1,"target":0,"value":1},{"source":1,"target":1,"value":0},{"source":1,"target":2,"value":0},
+  {"source":2,"target":0,"value":1},{"source":2,"target":1,"value":1},{"source":2,"target":2,"value":1}
+]
+*/
+```
+
+Convert list to matrix
+
+```js
+d3.graph.listToMatrix([
+  {"source":0,"target":1,"value":1},
+  {"source":1,"target":0,"value":1},
+  {"source":2,"target":0,"value":1},
+  {"source":2,"target":1,"value":1},
+  {"source":2,"target":2,"value":1}
+])
+/*
+  [0,1,0],
+  [1,0,0],
+  [1,1,1]
+*/
+```
+
+## Stateful Use
+
+```js
+var graph = d3.graph();
+```
+
+Load a matrix
+
+```js
+graph.matrix([
+  [0,1,0],
+  [1,0,0],
+  [1,1,1]
+]);
+```
+
+Get the graph as list of links
+
+```js
+graph.links();
+```
+
+Get the graph as matrix
+
+```js
+graph.matrix();
+```
+
+Nodes and links can be modified by passing in a value. This will overwrite existing data.
+
+```js
+graph.nodes(['red', 'purple', 'orange']);
+graph.links([{"source":0,"target":0,"value":0},{"source":0,"target":1,"value":1},{"source":0,"target":2,"value":0}]);
+```
+
+Get a description of the graph
+
+```js
+graph.description();
+// "d3.graph with 3 nodes and 9 links"
+```
+
+Basic node filters. These currently filter the original node set, so subsequent filters won't stack. See [Gremlin](https://github.com/tinkerpop/gremlin/wiki/Basic-Graph-Traversals).
+
+```js
+graph.traverse().filter(function(d) { return d.indexOf('urp') > -1 }).value();
+```