d3js-plugins-rails 0.0.1

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

@@ -0,0 +1,54 @@
+# d3.cie
+
+A plugin for CIE Lab and LCH color spaces. For an example, see
+
+* http://bl.ocks.org/3014589
+
+This plugin was incorporated into D3 2.10.0 on August 9, 2012 and can now be used directly as d3.hcl and d3.lab!
+
+## Old Documentation
+
+To create a Lab color, use the `d3.cie.lab` constructor. To create an LCH color, use the `d3.cie.lch` constructor. For example, here are two ugly colors:
+
+```js
+var green = d3.cie.lab(46.23, -51.70, 49.90),
+    blue = d3.cie.lch(32.30, 133.81, -53.72);
+```
+
+To convert from RGB to Lab (or LCH), simply specify an RGB color to the constructor. You can use the same technique to convert from HSV; D3 first converts the HSV color to RGB, and then then d3.cie plugin converts from RGB to Lab or LCH. The following three statements are equivalent:
+
+```js
+var color = d3.cie.lab("#048F07");
+var color = d3.cie.lab("rgb(4,143,7)");
+var color = d3.cie.lab(d3.rgb(4, 143, 7));
+```
+
+To convert from Lab (or LCH) to RGB, simply stringify the color. For example, you can pass a Lab color to [selection.attr](/mbostock/d3/wiki/Selections#wiki-attr) and [selection.style](/mbostock/d3/wiki/Selections#wiki-attr):
+
+```js
+d3.select("body").style("background", d3.cie.lab(46.23, -51.70, 49.90));
+```
+
+The Lab and LCH color classes support custom [brighter](/mbostock/d3/wiki/Colors#wiki-rgb_brighter) and [darker](/mbostock/d3/wiki/Colors#wiki-rgb_brighter) implementations that only modify the L (*lightness*) channel. This tends to produce better results than the RGB or HSL equivalents.
+
+The d3.cie plugin also lets you interpolates in Lab or LCH space. For example:
+
+```js
+var x = d3.scale.linear()
+    .domain([0, 100])
+    .range(["brown", "steelblue"])
+    .interpolate(d3.cie.interpolateLab);
+```
+
+The d3.cie plugin does not support parsing CSS3-style color names for Lab and LCH, so you can't say `d3.rgb("lch(32, 133, -53")`; you must use the d3.cie.lab or d3.cie.lch constructors.
+
+## Thank You
+
+Various people contributed and helped in implementing this plugin.
+
+* [Jeffery Heer](/jheer)
+* [Justin Cormack](/justincormack)
+* [Alex Gaynor](/alex)
+* [Jacob Rus](/jrus)
+
+If you like this, you might also like [Gregor Aisch](/gka)’s [Chroma.js](/gka/chroma.js).

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

@@ -0,0 +1,155 @@
+(function(d3) {
+  var cie = d3.cie = {};
+
+  cie.lab = function(l, a, b) {
+    return arguments.length === 1
+        ? (l instanceof Lab ? lab(l.l, l.a, l.b)
+        : (l instanceof Lch ? lch_lab(l.l, l.c, l.h)
+        : rgb_lab((l = d3.rgb(l)).r, l.g, l.b)))
+        : lab(+l, +a, +b);
+  };
+
+  cie.lch = function(l, c, h) {
+    return arguments.length === 1
+        ? (l instanceof Lch ? lch(l.l, l.c, l.h)
+        : (l instanceof Lab ? lab_lch(l.l, l.a, l.b)
+        : lab_lch((l = rgb_lab((l = d3.rgb(l)).r, l.g, l.b)).l, l.a, l.b)))
+        : lch(+l, +c, +h);
+  };
+
+  cie.interpolateLab = function(a, b) {
+    a = cie.lab(a);
+    b = cie.lab(b);
+    var al = a.l,
+        aa = a.a,
+        ab = a.b,
+        bl = b.l - al,
+        ba = b.a - aa,
+        bb = b.b - ab;
+    return function(t) {
+      return lab_rgb(al + bl * t, aa + ba * t, ab + bb * t) + "";
+    };
+  };
+
+  cie.interpolateLch = function(a, b) {
+    a = cie.lch(a);
+    b = cie.lch(b);
+    var al = a.l,
+        ac = a.c,
+        ah = a.h,
+        bl = b.l - al,
+        bc = b.c - ac,
+        bh = b.h - ah;
+    if (bh > 180) bh -= 360; else if (bh < -180) bh += 360; // shortest path
+    return function(t) {
+      return lch_lab(al + bl * t, ac + bc * t, ah + bh * t) + "";
+    };
+  };
+
+  function lab(l, a, b) {
+    return new Lab(l, a, b);
+  }
+
+  function Lab(l, a, b) {
+    this.l = l;
+    this.a = a;
+    this.b = b;
+  }
+
+  Lab.prototype.brighter = function(k) {
+    return lab(Math.min(100, this.l + K * (arguments.length ? k : 1)), this.a, this.b);
+  };
+
+  Lab.prototype.darker = function(k) {
+    return lab(Math.max(0, this.l - K * (arguments.length ? k : 1)), this.a, this.b);
+  };
+
+  Lab.prototype.rgb = function() {
+    return lab_rgb(this.l, this.a, this.b);
+  };
+
+  Lab.prototype.toString = function() {
+    return this.rgb() + "";
+  };
+
+  function lch(l, c, h) {
+    return new Lch(l, c, h);
+  }
+
+  function Lch(l, c, h) {
+    this.l = l;
+    this.c = c;
+    this.h = h;
+  }
+
+  Lch.prototype.brighter = function(k) {
+    return lch(Math.min(100, this.l + K * (arguments.length ? k : 1)), this.c, this.h);
+  };
+
+  Lch.prototype.darker = function(k) {
+    return lch(Math.max(0, this.l - K * (arguments.length ? k : 1)), this.c, this.h);
+  };
+
+  Lch.prototype.rgb = function() {
+    return lch_lab(this.l, this.c, this.h).rgb();
+  };
+
+  Lch.prototype.toString = function() {
+    return this.rgb() + "";
+  };
+
+  // Corresponds roughly to RGB brighter/darker
+  var K = 18;
+
+  // D65 standard referent
+  var X = 0.950470, Y = 1, Z = 1.088830;
+
+  function lab_rgb(l, a, b) {
+    var y = (l + 16) / 116, x = y + a / 500, z = y - b / 200;
+    x = lab_xyz(x) * X;
+    y = lab_xyz(y) * Y;
+    z = lab_xyz(z) * Z;
+    return d3.rgb(
+      xyz_rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z),
+      xyz_rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z),
+      xyz_rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z)
+    );
+  }
+
+  function rgb_lab(r, g, b) {
+    r = rgb_xyz(r);
+    g = rgb_xyz(g);
+    b = rgb_xyz(b);
+    var x = xyz_lab((0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / X),
+        y = xyz_lab((0.2126729 * r + 0.7151522 * g + 0.0721750 * b) / Y),
+        z = xyz_lab((0.0193339 * r + 0.1191920 * g + 0.9503041 * b) / Z);
+    return lab(116 * y - 16, 500 * (x - y), 200 * (y - z));
+  }
+
+  function lab_lch(l, a, b) {
+    var c = Math.sqrt(a * a + b * b),
+        h = Math.atan2(b, a) / Math.PI * 180;
+    return lch(l, c, h);
+  }
+
+  function lch_lab(l, c, h) {
+    h = h * Math.PI / 180;
+    return lab(l, Math.cos(h) * c, Math.sin(h) * c);
+  }
+
+  function lab_xyz(x) {
+    return x > 0.206893034 ? x * x * x : (x - 4 / 29) / 7.787037;
+  }
+
+  function xyz_lab(x) {
+    return x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29;
+  }
+
+  function xyz_rgb(r) {
+    return Math.round(255 * (r <= 0.00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - 0.055));
+  }
+
+  function rgb_xyz(r) {
+    return (r /= 255) <= 0.04045 ? r / 12.92 : Math.pow((r + 0.055) / 1.055, 2.4);
+  }
+})(d3);

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

@@ -0,0 +1,43 @@
+# Fisheye Distortion
+
+Demo: <http://bost.ocks.org/mike/fisheye/>
+
+Implements a fisheye distortion for two-dimensional layouts. Based on Sarkar and Brown’s [Graphical Fisheye Views of Graphs](http://dl.acm.org/citation.cfm?id=142763) (CHI '92), as well as [Flare](http://flare.prefuse.org/)'s [FisheyeDistortion](http://flare.prefuse.org/api/flare/vis/operator/distortion/FisheyeDistortion.html) and [Sigma.js](http://sigmajs.org/)'s [fisheye example](http://sigmajs.org/examples/a_plugin_example_advanced.html).
+
+When constructing a fisheye distortion, you can specify the radius and distortion factor:
+
+```js
+var fisheye = d3.fisheye.circular()
+    .radius(200)
+    .distortion(2);
+```
+
+Typically, you then update the focal point of the distortion on mousemove:
+
+```js
+svg.on("mousemove", function() {
+  fisheye.focus(d3.mouse(this));
+});
+```
+
+The distortion operator takes as input an object with `x` and `y` attributes, and returns a new object with `x`, `y` and `z` attributes. The returned object represents the distorted position of the input object; the `z` property is a scaling factor so that you can optionally distort the size of elements as well.
+
+For example, to apply fisheye distortion to a force layout, stash the distorted positions in a `display` property on each node, and then use the distorted positions to update the nodes and links:
+
+```js
+svg.on("mousemove", function() {
+  fisheye.focus(d3.mouse(this));
+
+  node.each(function(d) { d.fisheye = fisheye(d); })
+      .attr("cx", function(d) { return d.fisheye.x; })
+      .attr("cy", function(d) { return d.fisheye.y; })
+      .attr("r", function(d) { return d.fisheye.z * 4.5; });
+
+  link.attr("x1", function(d) { return d.source.fisheye.x; })
+      .attr("y1", function(d) { return d.source.fisheye.y; })
+      .attr("x2", function(d) { return d.target.fisheye.x; })
+      .attr("y2", function(d) { return d.target.fisheye.y; });
+});
+```
+
+There's also a d3.fisheye.scale for Cartesian distortion; see the above demo for an example.

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

@@ -0,0 +1,85 @@
+(function() {
+  d3.fisheye = {
+    scale: function(scaleType) {
+      return d3_fisheye_scale(scaleType(), 3, 0);
+    },
+    circular: function() {
+      var radius = 200,
+          distortion = 2,
+          k0,
+          k1,
+          focus = [0, 0];
+
+      function fisheye(d) {
+        var dx = d.x - focus[0],
+            dy = d.y - focus[1],
+            dd = Math.sqrt(dx * dx + dy * dy);
+        if (!dd || dd >= radius) return {x: d.x, y: d.y, z: 1};
+        var k = k0 * (1 - Math.exp(-dd * k1)) / dd * .75 + .25;
+        return {x: focus[0] + dx * k, y: focus[1] + dy * k, z: Math.min(k, 10)};
+      }
+
+      function rescale() {
+        k0 = Math.exp(distortion);
+        k0 = k0 / (k0 - 1) * radius;
+        k1 = distortion / radius;
+        return fisheye;
+      }
+
+      fisheye.radius = function(_) {
+        if (!arguments.length) return radius;
+        radius = +_;
+        return rescale();
+      };
+
+      fisheye.distortion = function(_) {
+        if (!arguments.length) return distortion;
+        distortion = +_;
+        return rescale();
+      };
+
+      fisheye.focus = function(_) {
+        if (!arguments.length) return focus;
+        focus = _;
+        return fisheye;
+      };
+
+      return rescale();
+    }
+  };
+
+  function d3_fisheye_scale(scale, d, a) {
+
+    function fisheye(_) {
+      var x = scale(_),
+          left = x < a,
+          range = d3.extent(scale.range()),
+          min = range[0],
+          max = range[1],
+          m = left ? a - min : max - a;
+      if (m == 0) m = max - min;
+      return (left ? -1 : 1) * m * (d + 1) / (d + (m / Math.abs(x - a))) + a;
+    }
+
+    fisheye.distortion = function(_) {
+      if (!arguments.length) return d;
+      d = +_;
+      return fisheye;
+    };
+
+    fisheye.focus = function(_) {
+      if (!arguments.length) return a;
+      a = +_;
+      return fisheye;
+    };
+
+    fisheye.copy = function() {
+      return d3_fisheye_scale(scale.copy(), d, a);
+    };
+
+    fisheye.nice = scale.nice;
+    fisheye.ticks = scale.ticks;
+    fisheye.tickFormat = scale.tickFormat;
+    return d3.rebind(fisheye, scale, "domain", "range");
+  }
+})();

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

@@ -0,0 +1,29 @@
+# D3 Force Labels v 0.1
+
+Demo: <http://bl.ocks.org/1691430/>
+
+Generates an automatic and dynamic positioning for labels, using the d3 force layout.   Once a```force_labels``` object has been created, simply call the bound function ```update``` with a selection of the objects you want to attach labels to as an argument.  The force_labels object is a d3.force object which allows full control over the charge, gravity, theta etc.   
+
+At each tick the following occurs:
+
+  - Center of each object (anchor position) is determined by the SVG Bounding Box of that object and stored in object ```anchorPos``` under x,y
+  - The position of the label element is determined by a force layout where anchors are fixed nodes and labels are floating.  New position for each label is stored in object ```labelPos``` under x,y
+
+Both the ```anchorPos``` and ```labelPos``` are inserted in the ```__data__``` variable of the object being labeled.  This allows easy access when drawing the labels and connectors.
+
+In the demo the label and link are created as svg objects on the same data selection as the anchors.  As the position information is embedded in ```__data__``` the redraw function is simply:
+
+```js
+function redrawLabels() {
+    labelBox
+        .attr("transform",function(d) { return "translate("+d.labelPos.x+" "+d.labelPos.y+")"});
+
+    links
+        .attr("x1",function(d) { return d.anchorPos.x})
+        .attr("y1",function(d) { return d.anchorPos.y})
+        .attr("x2",function(d) { return d.labelPos.x})
+        .attr("y2",function(d) { return d.labelPos.y});
+}
+```  
+
+<https://github.com/ZJONSSON>

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

@@ -0,0 +1,56 @@
+(function() {
+  d3.force_labels = function force_labels() {    
+    var labels = d3.layout.force()
+      
+    // Update the position of the anchor based on the center of bounding box
+    function updateAnchor() {
+      if (!labels.selection) return
+      labels.selection.each(function(d) {
+        var bbox = this.getBBox(),
+            x=bbox.x+bbox.width/2,
+            y=bbox.y+bbox.height/2
+
+        d.anchorPos.x=x
+        d.anchorPos.y=y
+       
+        // If a label position does not exist, set it to be the anchor position 
+        if (d.labelPos.x==null) {
+          d.labelPos.x=x
+          d.labelPos.y=y
+        }
+      })
+    }
+    
+    //The anchor position should be updated on each tick
+    labels.on("tick.labels",updateAnchor)
+    
+    // This updates all nodes/links - retaining any previous labelPos on updated nodes
+    labels.update = function(selection) {
+      labels.selection = selection
+      var nodes=[],links=[];
+      selection[0].forEach(function(d) {    
+        if(d && d.__data__) {
+          var data = d.__data__
+          
+          if (!d.labelPos) d.labelPos =  {fixed:false}
+          if (!d.anchorPos) d.anchorPos = {fixed:true}
+          
+          // Place position objects in __data__ to make them available through 
+          // d.labelPos/d.anchorPos for different elements
+          data.labelPos = d.labelPos
+          data.anchorPos = d.anchorPos
+          
+          links.push({target:d.anchorPos,source:d.labelPos})
+          nodes.push(d.anchorPos)
+          nodes.push(d.labelPos)
+        }
+      })
+      labels.stop()
+        .nodes(nodes)
+        .links(links)
+      updateAnchor()
+      labels.start()
+    }
+    return labels
+  }
+})()

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

@@ -0,0 +1,7 @@
+# Polyhedral Geographic Projections
+
+Examples:
+
+ * [Gnomonic Butterfly Map](http://www.jasondavies.com/maps/gnomonic-butterfly/)
+ * [Waterman Butterfly Map](http://www.jasondavies.com/maps/waterman-butterfly/)
+ * [Collignon Butterfly Map](http://www.jasondavies.com/maps/collignon-butterfly/)

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

@@ -0,0 +1,436 @@
+(function() {
+
+var ε = 1e-6,
+    π = Math.PI,
+    radians = π / 180,
+    degrees = 180 / π;
+
+// Creates a polyhedral projection.
+//  * root: a spanning tree of polygon faces.  Nodes are automatically
+//    augmented with a transform matrix.
+//  * face: a function that returns the appropriate node for a given {λ, φ}
+//    point (radians).
+//  * r: rotation angle for final polyhedron net.  Defaults to -π / 6 (for
+//    butterflies).
+d3.geo.polyhedron = function(root, face, r) {
+
+  r = r == null ? -π / 6 : r; // TODO automate
+
+  recurse(root, {transform: [
+    Math.cos(r), Math.sin(r), 0,
+    -Math.sin(r), Math.cos(r), 0
+  ]});
+
+  function recurse(node, parent) {
+    node.edges = faceEdges(node.face);
+    if (parent) {
+      // Find shared edge.
+      if (parent.face) {
+        var shared = node.shared = sharedEdge(node.face, parent.face),
+            m = matrix(shared.map(parent.project), shared.map(node.project));
+        node.transform = parent.transform ? multiply(parent.transform, m) : m;
+        // Replace shared edge in parent edges array.
+        var edges = parent.edges;
+        for (var i = 0, n = edges.length; i < n; ++i) {
+          if (pointEqual(shared[0], edges[i][1]) && pointEqual(shared[1], edges[i][0])) edges[i] = node;
+          if (pointEqual(shared[0], edges[i][0]) && pointEqual(shared[1], edges[i][1])) edges[i] = node;
+        }
+        var edges = node.edges;
+        for (var i = 0, n = edges.length; i < n; ++i) {
+          if (pointEqual(shared[0], edges[i][0]) && pointEqual(shared[1], edges[i][1])) edges[i] = parent;
+          if (pointEqual(shared[0], edges[i][1]) && pointEqual(shared[1], edges[i][0])) edges[i] = parent;
+        }
+      } else {
+        node.transform = parent.transform;
+      }
+    }
+    if (node.children) {
+      node.children.forEach(function(child) {
+        recurse(child, node);
+      });
+    }
+    return node;
+  }
+
+  function forward(λ, φ) {
+    var node = face(λ, φ),
+        point = node.project([λ * degrees, φ * degrees]),
+        t;
+    if (t = node.transform) {
+      return [
+        t[0] * point[0] + t[1] * point[1] + t[2],
+        -(t[3] * point[0] + t[4] * point[1] + t[5])
+      ];
+    }
+    point[1] = -point[1];
+    return point;
+  }
+
+  // Naive inverse!  A faster solution would use bounding boxes, or even a
+  // polygonal quadtree.
+  if (hasInverse(root)) forward.invert = function(x, y) {
+    var coordinates = faceInvert(root, [x, -y]);
+    return coordinates && (coordinates[0] *= radians, coordinates[1] *= radians, coordinates);
+  };
+
+  function faceInvert(node, coordinates) {
+    var invert = node.project.invert,
+        t = node.transform,
+        point = coordinates;
+    if (t) {
+      t = inverseTransform(t);
+      point = [
+        t[0] * point[0] + t[1] * point[1] + t[2],
+        (t[3] * point[0] + t[4] * point[1] + t[5])
+      ];
+    }
+    if (invert && node === faceDegrees(p = invert(point))) return p;
+    var p,
+        children = node.children;
+    for (var i = 0, n = children && children.length; i < n; ++i) {
+      if (p = faceInvert(children[i], coordinates)) return p;
+    }
+  }
+
+  function faceDegrees(coordinates) {
+    return face(coordinates[0] * radians, coordinates[1] * radians);
+  }
+
+  var projection = d3.geo.projection(forward),
+      stream_ = projection.stream;
+
+  projection.stream = function(stream) {
+    var rotate = projection.rotate(),
+        rotateStream = stream_(stream),
+        sphereStream = (projection.rotate([0, 0]), stream_(stream));
+    projection.rotate(rotate);
+    rotateStream.sphere = function() {
+      sphereStream.polygonStart();
+      sphereStream.lineStart();
+      outline(sphereStream, root);
+      sphereStream.lineEnd();
+      sphereStream.polygonEnd();
+    };
+    return rotateStream;
+  };
+
+  return projection;
+};
+
+d3.geo.polyhedron.butterfly = function(faceProjection) {
+
+  faceProjection = faceProjection || function(face) {
+    var centroid = d3.geo.centroid({type: "MultiPoint", coordinates: face});
+    return d3.geo.gnomonic().scale(1).translate([0, 0]).rotate([-centroid[0], -centroid[1]]);
+  };
+
+  var faces = d3.geo.polyhedron.octahedron.map(function(face) {
+    return {face: face, project: faceProjection(face)};
+  });
+
+  [-1, 0, 0, 1, 0, 1, 4, 5].forEach(function(d, i) {
+    var node = faces[d];
+    node && (node.children || (node.children = [])).push(faces[i]);
+  });
+
+  return d3.geo.polyhedron(faces[0], function(λ, φ) {
+    return faces[
+        λ < -π / 2 ? φ < 0 ? 6 : 4
+        : λ < 0 ? φ < 0 ? 2 : 0
+        : λ < π / 2 ? φ < 0 ? 3 : 1
+        : φ < 0 ? 7 : 5];
+  });
+};
+
+d3.geo.polyhedron.waterman = function(faceProjection) {
+
+  faceProjection = faceProjection || function(face) {
+    var centroid = face.length === 6 ? d3.geo.centroid({type: "MultiPoint", coordinates: face}) : face[0];
+    return d3.geo.gnomonic().scale(1).translate([0, 0]).rotate([-centroid[0], -centroid[1]]);
+  };
+
+  var octahedron = d3.geo.polyhedron.octahedron;
+
+  var w5 = octahedron.map(function(face) {
+    var xyz = face.map(cartesian),
+        n = xyz.length,
+        a = xyz[n - 1],
+        b,
+        hexagon = [];
+    for (var i = 0; i < n; ++i) {
+      b = xyz[i];
+      hexagon.push(spherical([
+        a[0] * 0.9486832980505138 + b[0] * 0.31622776601683794,
+        a[1] * 0.9486832980505138 + b[1] * 0.31622776601683794,
+        a[2] * 0.9486832980505138 + b[2] * 0.31622776601683794
+      ]), spherical([
+        b[0] * 0.9486832980505138 + a[0] * 0.31622776601683794,
+        b[1] * 0.9486832980505138 + a[1] * 0.31622776601683794,
+        b[2] * 0.9486832980505138 + a[2] * 0.31622776601683794
+      ]));
+      a = b;
+    }
+    return hexagon;
+  });
+
+  var cornerNormals = [];
+
+  var parents = [-1, 0, 0, 1, 0, 1, 4, 5];
+
+  w5.forEach(function(hexagon, j) {
+    var face = octahedron[j],
+        n = face.length,
+        normals = cornerNormals[j] = [];
+    for (var i = 0; i < n; ++i) {
+      w5.push([
+        face[i],
+        hexagon[(i * 2 + 2) % (2 * n)],
+        hexagon[(i * 2 + 1) % (2 * n)]
+      ]);
+      parents.push(j);
+      normals.push(cross(
+        cartesian(hexagon[(i * 2 + 2) % (2 * n)]),
+        cartesian(hexagon[(i * 2 + 1) % (2 * n)])
+      ));
+    }
+  });
+
+  var faces = w5.map(function(face) {
+    return {
+      project: faceProjection(face),
+      face: face
+    };
+  });
+
+  parents.forEach(function(d, i) {
+    var parent = faces[d];
+    parent && (parent.children || (parent.children = [])).push(faces[i]);
+  });
+
+  return d3.geo.polyhedron(faces[0], face).center([0, 45]);
+
+  function face(λ, φ) {
+    var cosφ = Math.cos(φ),
+        p = [cosφ * Math.cos(λ), cosφ * Math.sin(λ), Math.sin(φ)];
+
+    var hexagon = λ < -π / 2 ? φ < 0 ? 6 : 4
+        : λ < 0 ? φ < 0 ? 2 : 0
+        : λ < π / 2 ? φ < 0 ? 3 : 1
+        : φ < 0 ? 7 : 5;
+
+    var n = cornerNormals[hexagon];
+
+    return faces[
+        dot(n[0], p) < 0 ? 8 + 3 * hexagon
+      : dot(n[1], p) < 0 ? 8 + 3 * hexagon + 1
+      : dot(n[2], p) < 0 ? 8 + 3 * hexagon + 2
+      : hexagon];
+  }
+};
+
+function outline(stream, node, parent) {
+  var point,
+      edges = node.edges,
+      n = edges.length,
+      edge,
+      multiPoint = {type: "MultiPoint", coordinates: node.face},
+      notPoles = node.face.filter(function(d) { return Math.abs(d[1]) !== 90; }),
+      bounds = d3.geo.bounds({type: "MultiPoint", coordinates: notPoles}),
+      inside = false,
+      j = -1,
+      dx = bounds[1][0] - bounds[0][0];
+  // TODO
+  var centroid = dx === 180 || dx === 360
+      ? [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2]
+      : d3.geo.centroid(multiPoint);
+  // First find the shared edge…
+  if (parent) while (++j < n) {
+    if (edges[j] === parent) break;
+  }
+  ++j;
+  for (var i = 0; i < n; ++i) {
+    edge = edges[(i + j) % n];
+    if (Array.isArray(edge)) {
+      if (!inside) {
+        stream.point((point = d3.geo.interpolate(edge[0], centroid)(ε))[0], point[1]);
+        inside = true;
+      }
+      stream.point((point = d3.geo.interpolate(edge[1], centroid)(ε))[0], point[1]);
+    } else {
+      inside = false;
+      if (edge !== parent) outline(stream, edge, node);
+    }
+  }
+}
+
+// TODO generate on-the-fly to avoid external modification.
+var octahedron = [
+  [0, 90],
+  [-90, 0], [0, 0], [90, 0], [180, 0],
+  [0, -90]
+];
+
+d3.geo.polyhedron.octahedron = [
+  [0, 2, 1],
+  [0, 3, 2],
+  [5, 1, 2],
+  [5, 2, 3],
+  [0, 1, 4],
+  [0, 4, 3],
+  [5, 4, 1],
+  [5, 3, 4]
+].map(function(face) {
+  return face.map(function(i) {
+    return octahedron[i];
+  });
+});
+
+var φ1 = Math.atan(Math.SQRT1_2) * degrees;
+
+var cube = [
+  [0, φ1], [90, φ1], [180, φ1], [-90, φ1],
+  [0, -φ1], [90, -φ1], [180, -φ1], [-90, -φ1]
+];
+
+d3.geo.polyhedron.cube = [
+  [0, 3, 2, 1], // N
+  [0, 1, 5, 4],
+  [1, 2, 6, 5],
+  [2, 3, 7, 6],
+  [3, 0, 4, 7],
+  [4, 5, 6, 7] // S
+].map(function(face) {
+  return face.map(function(i) {
+    return cube[i];
+  });
+});
+
+// Finds a shared edge given two clockwise polygons.
+function sharedEdge(a, b) {
+  var x, y, n = a.length, found = null;
+  for (var i = 0; i < n; ++i) {
+    x = a[i];
+    for (var j = b.length; --j >= 0;) {
+      y = b[j];
+      if (x[0] === y[0] && x[1] === y[1]) {
+        if (found) return [found, x];
+        found = x;
+      }
+    }
+  }
+}
+
+// Note: 6-element arrays are used to denote the 3x3 affine transform matrix:
+// [a, b, c,
+//  d, e, f,
+//  0, 0, 1] - this redundant row is left out.
+
+// Transform matrix for [a0, a1] -> [b0, b1].
+function matrix(a, b) {
+  var u = subtract(a[1], a[0]),
+      v = subtract(b[1], b[0]),
+      φ = angle(u, v),
+      s = length(u) / length(v);
+
+  return multiply([
+    1, 0, a[0][0],
+    0, 1, a[0][1]
+  ], multiply([
+    s, 0, 0,
+    0, s, 0
+  ], multiply([
+    Math.cos(φ), Math.sin(φ), 0,
+    -Math.sin(φ), Math.cos(φ), 0
+  ], [
+    1, 0, -b[0][0],
+    0, 1, -b[0][1]
+  ])));
+}
+
+// Inverts a transform matrix.
+function inverseTransform(m) {
+  var k = 1 / (m[0] * m[4] - m[1] * m[3]);
+  return [
+    k * m[4], -k * m[1], k * (m[1] * m[5] - m[2] * m[4]),
+    -k * m[3], k * m[0], k * (m[2] * m[3] - m[0] * m[5])
+  ];
+}
+
+// Multiplies two 3x2 matrices.
+function multiply(a, b) {
+  return [
+    a[0] * b[0] + a[1] * b[3],
+    a[0] * b[1] + a[1] * b[4],
+    a[0] * b[2] + a[1] * b[5] + a[2],
+    a[3] * b[0] + a[4] * b[3],
+    a[3] * b[1] + a[4] * b[4],
+    a[3] * b[2] + a[4] * b[5] + a[5]
+  ];
+}
+
+// Subtracts 2D vectors.
+function subtract(a, b) {
+  return [a[0] - b[0], a[1] - b[1]];
+}
+
+// Magnitude of a 2D vector.
+function length(v) {
+  return Math.sqrt(v[0] * v[0] + v[1] * v[1]);
+}
+
+// Angle between two 2D vectors.
+function angle(a, b) {
+  return Math.atan2(a[0] * b[1] - a[1] * b[0], a[0] * b[0] + a[1] * b[1]);
+}
+
+function dot(a, b) {
+  for (var i = 0, n = a.length, s = 0; i < n; ++i) s += a[i] * b[i];
+  return s;
+}
+
+function cross(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+
+// Converts 3D Cartesian to spherical coordinates (degrees).
+function spherical(cartesian) {
+  return [
+    Math.atan2(cartesian[1], cartesian[0]) * degrees,
+    Math.asin(Math.max(-1, Math.min(1, cartesian[2]))) * degrees
+  ];
+}
+
+// Converts spherical coordinates (degrees) to 3D Cartesian.
+function cartesian(coordinates) {
+  var λ = coordinates[0] * radians,
+      φ = coordinates[1] * radians,
+      cosφ = Math.cos(φ);
+  return [
+    cosφ * Math.cos(λ),
+    cosφ * Math.sin(λ),
+    Math.sin(φ)
+  ];
+}
+
+// Tests equality of two spherical points.
+function pointEqual(a, b) {
+  return a && b && a[0] === b[0] && a[1] === b[1];
+}
+
+// Converts an array of n face vertices to an array of n + 1 edges.
+function faceEdges(face) {
+  var n = face.length,
+      edges = [];
+  for (var a = face[n - 1], i = 0; i < n; ++i) edges.push([a, a = face[i]]);
+  return edges;
+}
+
+function hasInverse(node) {
+  return node.project.invert || node.children && node.children.some(hasInverse);
+}
+
+})();