BarakChamo · April 5, 2013 16:39
diff --git a/readme.md b/readme.md
diff --git a/d3noob_energy.csv b/d3noob_energy.csv
diff --git a/d3noob_example.csv b/d3noob_example.csv
diff --git a/index.html b/index.html
 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>SANKEY Experiment</title>
 <style>
 
 .node rect {
  cursor: move;
  fill-opacity: .9;
  shape-rendering: crispEdges;
 }
 
 .node text {
  pointer-events: none;
  text-shadow: 0 1px 0 #fff;
 }
 
 .link {
  fill: none;
  stroke: #000;
  stroke-opacity: .2;
 }
 
 .link:hover {
  stroke-opacity: .5;
 }
 
 </style>
 <body>
 
 <p id="chart">
 
 <script src="http://d3js.org/d3.v3.js"></script>
 <script src="sankey.js"></script>
 <script>
  
 var units = "Units";
 
 var margin = {top: 10, right: 10, bottom: 10, left: 10},
    width = 1400 - margin.left - margin.right,
    height = 740 - margin.top - margin.bottom;
 
 var formatNumber = d3.format(",.0f"),    // zero decimal places
    format = function(d) { return formatNumber(d) + " " + units; },
    color = d3.scale.category20();
 
 // append the svg canvas to the page
 var svg = d3.select("#chart").append("svg")
    .attr("width", width + margin.left + margin.right)
    .attr("height", height + margin.top + margin.bottom)
  .append("g")
    .attr("transform", 
          "translate(" + margin.left + "," + margin.top + ")");
 
 // Set the sankey diagram properties
 var sankey = d3.sankey()
    .nodeWidth(36)
    .nodePadding(10)
    .size([width, height]);
 
 var path = sankey.link();
 
 // load the data with d3.csv instead of d3.json
 //for another much simpler example uncomment the below
 // d3.csv("d3noob_example.csv", function(error, data) {
 d3.csv("d3noob_energy.csv", function(error, data) {
 		//set up graph in same style as original example but empty
  		graph = {"nodes" : [], "links" : []};
  
                data.forEach(function (d) {
                    graph.nodes.push({ "name": d.source });
                    graph.nodes.push({ "name": d.target });

                    graph.links.push({ "source": d.source, "target": d.target, "value": +d.value });
                });

                //thanks Mike Bostock https://groups.google.com/d/msg/d3-js/pl297cFtIQk/Eso4q_eBu1IJ
                //this handy little function returns only the distinct / unique nodes
                graph.nodes = d3.keys(d3.nest()
                         .key(function (d) { return d.name; })
                         .map(graph.nodes));

                //it appears d3 with force layout wants a numeric source and target
                //so loop through each link replacing the text with its index from node
                graph.links.forEach(function (d, i) {
                    graph.links[i].source = graph.nodes.indexOf(graph.links[i].source);
                    graph.links[i].target = graph.nodes.indexOf(graph.links[i].target);
                });

                //now loop through each nodes to make nodes an array of objects rather than an array of strings
                graph.nodes.forEach(function (d, i) {
                    graph.nodes[i] = { "name": d };
                });
 
  sankey
      .nodes(graph.nodes)
      .links(graph.links)
      .layout(32);
 
 // add in the links
  var link = svg.append("g").selectAll(".link")
      .data(graph.links)
    .enter().append("path")
      .attr("class", "link")
      .attr("d", path)
      .style("stroke-width", function(d) { return Math.max(1, d.dy); })
      .sort(function(a, b) { return b.dy - a.dy; });
 
 // add the link titles
  link.append("title")
        .text(function(d) {
      	return d.source.name + " → " + 
                d.target.name + "\n" + format(d.value); });
 
 // add in the nodes
  var node = svg.append("g").selectAll(".node")
      .data(graph.nodes)
    .enter().append("g")
      .attr("class", "node")
      .attr("transform", function(d) { 
 		  return "translate(" + d.x + "," + d.y + ")"; })
    .call(d3.behavior.drag()
      .origin(function(d) { return d; })
      .on("dragstart", function() { 
 		  this.parentNode.appendChild(this); })
      .on("drag", dragmove));
 
 // add the rectangles for the nodes
  node.append("rect")
      .attr("height", function(d) { return d.dy; })
      .attr("width", sankey.nodeWidth())
      .style("fill", function(d) { 
 		  return d.color = color(d.name.replace(/ .*/, "")); })
      .style("stroke", function(d) { 
 		  return d3.rgb(d.color).darker(2); })
    .append("title")
      .text(function(d) { 
 		  return d.name + "\n" + format(d.value); });
 
 // add in the title for the nodes
  node.append("text")
      .attr("x", -6)
      .attr("y", function(d) { return d.dy / 2; })
      .attr("dy", ".35em")
      .attr("text-anchor", "end")
      .attr("transform", null)
      .text(function(d) { return d.name; })
    .filter(function(d) { return d.x < width / 2; })
      .attr("x", 6 + sankey.nodeWidth())
      .attr("text-anchor", "start");
 
 // the function for moving the nodes
  function dragmove(d) {
    d3.select(this).attr("transform", 
        "translate(" + (
        	   d.x = Math.max(0, Math.min(width - d.dx, d3.event.x))
        	) + "," + (
                   d.y = Math.max(0, Math.min(height - d.dy, d3.event.y))
            ) + ")");
    sankey.relayout();
    link.attr("d", path);
  }
 });
 
 </script>
 
 </body>
 </html>
diff --git a/sankey.js b/sankey.js
 //from Mike Bostock

 d3.sankey = function() {
  var sankey = {},
      nodeWidth = 24,
      nodePadding = 8,
      size = [1, 1],
      nodes = [],
      links = [];
 
  sankey.nodeWidth = function(_) {
    if (!arguments.length) return nodeWidth;
    nodeWidth = +_;
    return sankey;
  };
 
  sankey.nodePadding = function(_) {
    if (!arguments.length) return nodePadding;
    nodePadding = +_;
    return sankey;
  };
 
  sankey.nodes = function(_) {
    if (!arguments.length) return nodes;
    nodes = _;
    return sankey;
  };
 
  sankey.links = function(_) {
    if (!arguments.length) return links;
    links = _;
    return sankey;
  };
 
  sankey.size = function(_) {
    if (!arguments.length) return size;
    size = _;
    return sankey;
  };
 
  sankey.layout = function(iterations) {
    computeNodeLinks();
    computeNodeValues();
    computeNodeBreadths();
    computeNodeDepths(iterations);
    computeLinkDepths();
    return sankey;
  };
 
  sankey.relayout = function() {
    computeLinkDepths();
    return sankey;
  };
 
  sankey.link = function() {
    var curvature = .5;
 
    function link(d) {
      var x0 = d.source.x + d.source.dx,
          x1 = d.target.x,
          xi = d3.interpolateNumber(x0, x1),
          x2 = xi(curvature),
          x3 = xi(1 - curvature),
          y0 = d.source.y + d.sy + d.dy / 2,
          y1 = d.target.y + d.ty + d.dy / 2;
      return "M" + x0 + "," + y0
           + "C" + x2 + "," + y0
           + " " + x3 + "," + y1
           + " " + x1 + "," + y1;
    }
 
    link.curvature = function(_) {
      if (!arguments.length) return curvature;
      curvature = +_;
      return link;
    };
 
    return link;
  };
 
  // Populate the sourceLinks and targetLinks for each node.
  // Also, if the source and target are not objects, assume they are indices.
  function computeNodeLinks() {
    nodes.forEach(function(node) {
      node.sourceLinks = [];
      node.targetLinks = [];
    });
    links.forEach(function(link) {
      var source = link.source,
          target = link.target;
      if (typeof source === "number") source = link.source = nodes[link.source];
      if (typeof target === "number") target = link.target = nodes[link.target];
      source.sourceLinks.push(link);
      target.targetLinks.push(link);
    });
  }
 
  // Compute the value (size) of each node by summing the associated links.
  function computeNodeValues() {
    nodes.forEach(function(node) {
      node.value = Math.max(
        d3.sum(node.sourceLinks, value),
        d3.sum(node.targetLinks, value)
      );
    });
  }
 
  // Iteratively assign the breadth (x-position) for each node.
  // Nodes are assigned the maximum breadth of incoming neighbors plus one;
  // nodes with no incoming links are assigned breadth zero, while
  // nodes with no outgoing links are assigned the maximum breadth.
  function computeNodeBreadths() {
    var remainingNodes = nodes,
        nextNodes,
        x = 0;
 
    while (remainingNodes.length) {
      nextNodes = [];
      remainingNodes.forEach(function(node) {
        node.x = x;
        node.dx = nodeWidth;
        node.sourceLinks.forEach(function(link) {
          nextNodes.push(link.target);
        });
      });
      remainingNodes = nextNodes;
      ++x;
    }
 
    //
    moveSinksRight(x);
    scaleNodeBreadths((size[0] - nodeWidth) / (x - 1));
  }
 
  function moveSourcesRight() {
    nodes.forEach(function(node) {
      if (!node.targetLinks.length) {
        node.x = d3.min(node.sourceLinks, function(d) { return d.target.x; }) - 1;
      }
    });
  }
 
  function moveSinksRight(x) {
    nodes.forEach(function(node) {
      if (!node.sourceLinks.length) {
        node.x = x - 1;
      }
    });
  }
 
  function scaleNodeBreadths(kx) {
    nodes.forEach(function(node) {
      node.x *= kx;
    });
  }
 
  function computeNodeDepths(iterations) {
    var nodesByBreadth = d3.nest()
        .key(function(d) { return d.x; })
        .sortKeys(d3.ascending)
        .entries(nodes)
        .map(function(d) { return d.values; });
 
    //
    initializeNodeDepth();
    resolveCollisions();
    for (var alpha = 1; iterations > 0; --iterations) {
      relaxRightToLeft(alpha *= .99);
      resolveCollisions();
      relaxLeftToRight(alpha);
      resolveCollisions();
    }
 
    function initializeNodeDepth() {
      var ky = d3.min(nodesByBreadth, function(nodes) {
        return (size[1] - (nodes.length - 1) * nodePadding) / d3.sum(nodes, value);
      });
 
      nodesByBreadth.forEach(function(nodes) {
        nodes.forEach(function(node, i) {
          node.y = i;
          node.dy = node.value * ky;
        });
      });
 
      links.forEach(function(link) {
        link.dy = link.value * ky;
      });
    }
 
    function relaxLeftToRight(alpha) {
      nodesByBreadth.forEach(function(nodes, breadth) {
        nodes.forEach(function(node) {
          if (node.targetLinks.length) {
            var y = d3.sum(node.targetLinks, weightedSource) / d3.sum(node.targetLinks, value);
            node.y += (y - center(node)) * alpha;
          }
        });
      });
 
      function weightedSource(link) {
        return center(link.source) * link.value;
      }
    }
 
    function relaxRightToLeft(alpha) {
      nodesByBreadth.slice().reverse().forEach(function(nodes) {
        nodes.forEach(function(node) {
          if (node.sourceLinks.length) {
            var y = d3.sum(node.sourceLinks, weightedTarget) / d3.sum(node.sourceLinks, value);
            node.y += (y - center(node)) * alpha;
          }
        });
      });
 
      function weightedTarget(link) {
        return center(link.target) * link.value;
      }
    }
 
    function resolveCollisions() {
      nodesByBreadth.forEach(function(nodes) {
        var node,
            dy,
            y0 = 0,
            n = nodes.length,
            i;
 
        // Push any overlapping nodes down.
        nodes.sort(ascendingDepth);
        for (i = 0; i < n; ++i) {
          node = nodes[i];
          dy = y0 - node.y;
          if (dy > 0) node.y += dy;
          y0 = node.y + node.dy + nodePadding;
        }
 
        // If the bottommost node goes outside the bounds, push it back up.
        dy = y0 - nodePadding - size[1];
        if (dy > 0) {
          y0 = node.y -= dy;
 
          // Push any overlapping nodes back up.
          for (i = n - 2; i >= 0; --i) {
            node = nodes[i];
            dy = node.y + node.dy + nodePadding - y0;
            if (dy > 0) node.y -= dy;
            y0 = node.y;
          }
        }
      });
    }
 
    function ascendingDepth(a, b) {
      return a.y - b.y;
    }
  }
 
  function computeLinkDepths() {
    nodes.forEach(function(node) {
      node.sourceLinks.sort(ascendingTargetDepth);
      node.targetLinks.sort(ascendingSourceDepth);
    });
    nodes.forEach(function(node) {
      var sy = 0, ty = 0;
      node.sourceLinks.forEach(function(link) {
        link.sy = sy;
        sy += link.dy;
      });
      node.targetLinks.forEach(function(link) {
        link.ty = ty;
        ty += link.dy;
      });
    });
 
    function ascendingSourceDepth(a, b) {
      return a.source.y - b.source.y;
    }
 
    function ascendingTargetDepth(a, b) {
      return a.target.y - b.target.y;
    }
  }
 
  function center(node) {
    return node.y + node.dy / 2;
  }
 
  function value(link) {
    return link.value;
  }
 
  return sankey;
 };
source	target	value
Agricultural Energy Use	Carbon Dioxide	1.4
Agriculture	Agriculture Soils	5.2
Agriculture	Livestock and Manure	5.4
Agriculture	Other Agriculture	1.7
Agriculture	Rice Cultivation	1.5
Agriculture Soils	Nitrous Oxide	5.2
Air	Carbon Dioxide	1.7
Aluminium Non-Ferrous Metals	Carbon Dioxide	1
Aluminium Non-Ferrous Metals	HFCs - PFCs	0.2
Cement	Carbon Dioxide	5
Chemicals	Carbon Dioxide	3.4
Chemicals	HFCs - PFCs	0.5
Chemicals	Nitrous Oxide	0.2
Coal Mining	Carbon Dioxide	0.1
Coal Mining	Methane	1.2
Commercial Buildings	Carbon Dioxide	6.3
Deforestation	Carbon Dioxide	10.9
Electricity and heat	Agricultural Energy Use	0.4
Electricity and heat	Aluminium Non-Ferrous Metals	0.4
Electricity and heat	Cement	0.3
Electricity and heat	Chemicals	1.3
Electricity and heat	Commercial Buildings	5
Electricity and heat	Food and Tobacco	0.5
Electricity and heat	Iron and Steel	1
Electricity and heat	Machinery	1
Electricity and heat	Oil and Gas Processing	0.4
Electricity and heat	Other Industry	2.7
Electricity and heat	Pulp - Paper and Printing	0.6
Electricity and heat	Residential Buildings	5.2
Electricity and heat	T and D Losses	2.2
Electricity and heat	Unallocated Fuel Combustion	2
Energy	Electricity and heat	24.9
Energy	Fugitive Emissions	4
Energy	Industry	14.7
Energy	Other Fuel Combustion	8.6
Energy	Transportation	14.3
Food and Tobacco	Carbon Dioxide	1
Fugitive Emissions	Coal Mining	1.3
Fugitive Emissions	Oil and Gas Processing	3.2
Harvest \/ Management	Carbon Dioxide	1.3
Industrial Processes	Aluminium Non-Ferrous Metals	0.4
Industrial Processes	Cement	2.8
Industrial Processes	Chemicals	1.4
Industrial Processes	Other Industry	0.5
Industry	Aluminium Non-Ferrous Metals	0.4
Industry	Cement	1.9
Industry	Chemicals	1.4
Industry	Food and Tobacco	0.5
Industry	Iron and Steel	3
Industry	Oil and Gas Processing	2.8
Industry	Other Industry	3.8
Industry	Pulp - Paper and Printing	0.5
Iron and Steel	Carbon Dioxide	4
Land Use Change	Deforestation	10.9
Land Use Change	Harvest \/ Management	1.3
Landfills	Methane	1.7
Livestock and Manure	Methane	5.1
Livestock and Manure	Nitrous Oxide	0.3
Machinery	Carbon Dioxide	1
Oil and Gas Processing	Carbon Dioxide	3.6
Oil and Gas Processing	Methane	2.8
Other Agriculture	Methane	1.4
Other Agriculture	Nitrous Oxide	0.3
Other Fuel Combustion	Agricultural Energy Use	1
Other Fuel Combustion	Commercial Buildings	1.3
Other Fuel Combustion	Residential Buildings	5
Other Fuel Combustion	Unallocated Fuel Combustion	1.8
Other Industry	Carbon Dioxide	6.6
Other Industry	HFCs - PFCs	0.4
Pulp - Paper and Printing	Carbon Dioxide	1.1
Rail - Ship and Other Transport	Carbon Dioxide	2.5
Residential Buildings	Carbon Dioxide	10.2
Rice Cultivation	Methane	1.5
Road	Carbon Dioxide	10.5
T and D Losses	Carbon Dioxide	2.2
Transportation	Air	1.7
Transportation	Rail - Ship and Other Transport	2.5
Transportation	Road	10.5
Unallocated Fuel Combustion	Carbon Dioxide	3
Unallocated Fuel Combustion	Methane	0.4
Unallocated Fuel Combustion	Nitrous Oxide	0.4
Waste	Landfills	1.7
Waste	Waste water - Other Waste	1.5
Waste water - Other Waste	Methane	1.2
Waste water - Other Waste	Nitrous Oxide	0.3
	<!DOCTYPE html>
	<meta charset="utf-8">
	<title>SANKEY Experiment</title>
	<style>

	.node rect {
	cursor: move;
	fill-opacity: .9;
	shape-rendering: crispEdges;
	}

	.node text {
	pointer-events: none;
	text-shadow: 0 1px 0 #fff;
	}

	.link {
	fill: none;
	stroke: #000;
	stroke-opacity: .2;
	}

	.link:hover {
	stroke-opacity: .5;
	}

	</style>
	<body>

	<p id="chart">

	<script src="http://d3js.org/d3.v3.js"></script>
	<script src="sankey.js"></script>
	<script>

	var units = "Units";

	var margin = {top: 10, right: 10, bottom: 10, left: 10},
	width = 1400 - margin.left - margin.right,
	height = 740 - margin.top - margin.bottom;

	var formatNumber = d3.format(",.0f"), // zero decimal places
	format = function(d) { return formatNumber(d) + " " + units; },
	color = d3.scale.category20();

	// append the svg canvas to the page
	var svg = d3.select("#chart").append("svg")
	.attr("width", width + margin.left + margin.right)
	.attr("height", height + margin.top + margin.bottom)
	.append("g")
	.attr("transform",
	"translate(" + margin.left + "," + margin.top + ")");

	// Set the sankey diagram properties
	var sankey = d3.sankey()
	.nodeWidth(36)
	.nodePadding(10)
	.size([width, height]);

	var path = sankey.link();

	// load the data with d3.csv instead of d3.json
	//for another much simpler example uncomment the below
	// d3.csv("d3noob_example.csv", function(error, data) {
	d3.csv("d3noob_energy.csv", function(error, data) {
	//set up graph in same style as original example but empty
	graph = {"nodes" : [], "links" : []};

	data.forEach(function (d) {
	graph.nodes.push({ "name": d.source });
	graph.nodes.push({ "name": d.target });

	graph.links.push({ "source": d.source, "target": d.target, "value": +d.value });
	});

	//thanks Mike Bostock https://groups.google.com/d/msg/d3-js/pl297cFtIQk/Eso4q_eBu1IJ
	//this handy little function returns only the distinct / unique nodes
	graph.nodes = d3.keys(d3.nest()
	.key(function (d) { return d.name; })
	.map(graph.nodes));

	//it appears d3 with force layout wants a numeric source and target
	//so loop through each link replacing the text with its index from node
	graph.links.forEach(function (d, i) {
	graph.links[i].source = graph.nodes.indexOf(graph.links[i].source);
	graph.links[i].target = graph.nodes.indexOf(graph.links[i].target);
	});

	//now loop through each nodes to make nodes an array of objects rather than an array of strings
	graph.nodes.forEach(function (d, i) {
	graph.nodes[i] = { "name": d };
	});

	sankey
	.nodes(graph.nodes)
	.links(graph.links)
	.layout(32);

	// add in the links
	var link = svg.append("g").selectAll(".link")
	.data(graph.links)
	.enter().append("path")
	.attr("class", "link")
	.attr("d", path)
	.style("stroke-width", function(d) { return Math.max(1, d.dy); })
	.sort(function(a, b) { return b.dy - a.dy; });

	// add the link titles
	link.append("title")
	.text(function(d) {
	return d.source.name + " → " +
	d.target.name + "\n" + format(d.value); });

	// add in the nodes
	var node = svg.append("g").selectAll(".node")
	.data(graph.nodes)
	.enter().append("g")
	.attr("class", "node")
	.attr("transform", function(d) {
	return "translate(" + d.x + "," + d.y + ")"; })
	.call(d3.behavior.drag()
	.origin(function(d) { return d; })
	.on("dragstart", function() {
	this.parentNode.appendChild(this); })
	.on("drag", dragmove));

	// add the rectangles for the nodes
	node.append("rect")
	.attr("height", function(d) { return d.dy; })
	.attr("width", sankey.nodeWidth())
	.style("fill", function(d) {
	return d.color = color(d.name.replace(/ .*/, "")); })
	.style("stroke", function(d) {
	return d3.rgb(d.color).darker(2); })
	.append("title")
	.text(function(d) {
	return d.name + "\n" + format(d.value); });

	// add in the title for the nodes
	node.append("text")
	.attr("x", -6)
	.attr("y", function(d) { return d.dy / 2; })
	.attr("dy", ".35em")
	.attr("text-anchor", "end")
	.attr("transform", null)
	.text(function(d) { return d.name; })
	.filter(function(d) { return d.x < width / 2; })
	.attr("x", 6 + sankey.nodeWidth())
	.attr("text-anchor", "start");

	// the function for moving the nodes
	function dragmove(d) {
	d3.select(this).attr("transform",
	"translate(" + (
	d.x = Math.max(0, Math.min(width - d.dx, d3.event.x))
	) + "," + (
	d.y = Math.max(0, Math.min(height - d.dy, d3.event.y))
	) + ")");
	sankey.relayout();
	link.attr("d", path);
	}
	});

	</script>

	</body>
	</html>
	//from Mike Bostock

	d3.sankey = function() {
	var sankey = {},
	nodeWidth = 24,
	nodePadding = 8,
	size = [1, 1],
	nodes = [],
	links = [];

	sankey.nodeWidth = function(_) {
	if (!arguments.length) return nodeWidth;
	nodeWidth = +_;
	return sankey;
	};

	sankey.nodePadding = function(_) {
	if (!arguments.length) return nodePadding;
	nodePadding = +_;
	return sankey;
	};

	sankey.nodes = function(_) {
	if (!arguments.length) return nodes;
	nodes = _;
	return sankey;
	};

	sankey.links = function(_) {
	if (!arguments.length) return links;
	links = _;
	return sankey;
	};

	sankey.size = function(_) {
	if (!arguments.length) return size;
	size = _;
	return sankey;
	};

	sankey.layout = function(iterations) {
	computeNodeLinks();
	computeNodeValues();
	computeNodeBreadths();
	computeNodeDepths(iterations);
	computeLinkDepths();
	return sankey;
	};

	sankey.relayout = function() {
	computeLinkDepths();
	return sankey;
	};

	sankey.link = function() {
	var curvature = .5;

	function link(d) {
	var x0 = d.source.x + d.source.dx,
	x1 = d.target.x,
	xi = d3.interpolateNumber(x0, x1),
	x2 = xi(curvature),
	x3 = xi(1 - curvature),
	y0 = d.source.y + d.sy + d.dy / 2,
	y1 = d.target.y + d.ty + d.dy / 2;
	return "M" + x0 + "," + y0
	+ "C" + x2 + "," + y0
	+ " " + x3 + "," + y1
	+ " " + x1 + "," + y1;
	}

	link.curvature = function(_) {
	if (!arguments.length) return curvature;
	curvature = +_;
	return link;
	};

	return link;
	};

	// Populate the sourceLinks and targetLinks for each node.
	// Also, if the source and target are not objects, assume they are indices.
	function computeNodeLinks() {
	nodes.forEach(function(node) {
	node.sourceLinks = [];
	node.targetLinks = [];
	});
	links.forEach(function(link) {
	var source = link.source,
	target = link.target;
	if (typeof source === "number") source = link.source = nodes[link.source];
	if (typeof target === "number") target = link.target = nodes[link.target];
	source.sourceLinks.push(link);
	target.targetLinks.push(link);
	});
	}

	// Compute the value (size) of each node by summing the associated links.
	function computeNodeValues() {
	nodes.forEach(function(node) {
	node.value = Math.max(
	d3.sum(node.sourceLinks, value),
	d3.sum(node.targetLinks, value)
	);
	});
	}

	// Iteratively assign the breadth (x-position) for each node.
	// Nodes are assigned the maximum breadth of incoming neighbors plus one;
	// nodes with no incoming links are assigned breadth zero, while
	// nodes with no outgoing links are assigned the maximum breadth.
	function computeNodeBreadths() {
	var remainingNodes = nodes,
	nextNodes,
	x = 0;

	while (remainingNodes.length) {
	nextNodes = [];
	remainingNodes.forEach(function(node) {
	node.x = x;
	node.dx = nodeWidth;
	node.sourceLinks.forEach(function(link) {
	nextNodes.push(link.target);
	});
	});
	remainingNodes = nextNodes;
	++x;
	}

	//
	moveSinksRight(x);
	scaleNodeBreadths((size[0] - nodeWidth) / (x - 1));
	}

	function moveSourcesRight() {
	nodes.forEach(function(node) {
	if (!node.targetLinks.length) {
	node.x = d3.min(node.sourceLinks, function(d) { return d.target.x; }) - 1;
	}
	});
	}

	function moveSinksRight(x) {
	nodes.forEach(function(node) {
	if (!node.sourceLinks.length) {
	node.x = x - 1;
	}
	});
	}

	function scaleNodeBreadths(kx) {
	nodes.forEach(function(node) {
	node.x *= kx;
	});
	}

	function computeNodeDepths(iterations) {
	var nodesByBreadth = d3.nest()
	.key(function(d) { return d.x; })
	.sortKeys(d3.ascending)
	.entries(nodes)
	.map(function(d) { return d.values; });

	//
	initializeNodeDepth();
	resolveCollisions();
	for (var alpha = 1; iterations > 0; --iterations) {
	relaxRightToLeft(alpha *= .99);
	resolveCollisions();
	relaxLeftToRight(alpha);
	resolveCollisions();
	}

	function initializeNodeDepth() {
	var ky = d3.min(nodesByBreadth, function(nodes) {
	return (size[1] - (nodes.length - 1) * nodePadding) / d3.sum(nodes, value);
	});

	nodesByBreadth.forEach(function(nodes) {
	nodes.forEach(function(node, i) {
	node.y = i;
	node.dy = node.value * ky;
	});
	});

	links.forEach(function(link) {
	link.dy = link.value * ky;
	});
	}

	function relaxLeftToRight(alpha) {
	nodesByBreadth.forEach(function(nodes, breadth) {
	nodes.forEach(function(node) {
	if (node.targetLinks.length) {
	var y = d3.sum(node.targetLinks, weightedSource) / d3.sum(node.targetLinks, value);
	node.y += (y - center(node)) * alpha;
	}
	});
	});

	function weightedSource(link) {
	return center(link.source) * link.value;
	}
	}

	function relaxRightToLeft(alpha) {
	nodesByBreadth.slice().reverse().forEach(function(nodes) {
	nodes.forEach(function(node) {
	if (node.sourceLinks.length) {
	var y = d3.sum(node.sourceLinks, weightedTarget) / d3.sum(node.sourceLinks, value);
	node.y += (y - center(node)) * alpha;
	}
	});
	});

	function weightedTarget(link) {
	return center(link.target) * link.value;
	}
	}

	function resolveCollisions() {
	nodesByBreadth.forEach(function(nodes) {
	var node,
	dy,
	y0 = 0,
	n = nodes.length,
	i;

	// Push any overlapping nodes down.
	nodes.sort(ascendingDepth);
	for (i = 0; i < n; ++i) {
	node = nodes[i];
	dy = y0 - node.y;
	if (dy > 0) node.y += dy;
	y0 = node.y + node.dy + nodePadding;
	}

	// If the bottommost node goes outside the bounds, push it back up.
	dy = y0 - nodePadding - size[1];
	if (dy > 0) {
	y0 = node.y -= dy;

	// Push any overlapping nodes back up.
	for (i = n - 2; i >= 0; --i) {
	node = nodes[i];
	dy = node.y + node.dy + nodePadding - y0;
	if (dy > 0) node.y -= dy;
	y0 = node.y;
	}
	}
	});
	}

	function ascendingDepth(a, b) {
	return a.y - b.y;
	}
	}

	function computeLinkDepths() {
	nodes.forEach(function(node) {
	node.sourceLinks.sort(ascendingTargetDepth);
	node.targetLinks.sort(ascendingSourceDepth);
	});
	nodes.forEach(function(node) {
	var sy = 0, ty = 0;
	node.sourceLinks.forEach(function(link) {
	link.sy = sy;
	sy += link.dy;
	});
	node.targetLinks.forEach(function(link) {
	link.ty = ty;
	ty += link.dy;
	});
	});

	function ascendingSourceDepth(a, b) {
	return a.source.y - b.source.y;
	}

	function ascendingTargetDepth(a, b) {
	return a.target.y - b.target.y;
	}
	}

	function center(node) {
	return node.y + node.dy / 2;
	}

	function value(link) {
	return link.value;
	}

	return sankey;
	};