markarios/.gistup

## .gistup
gistup

## index.html
<!DOCTYPE html>
<html>
<!-- original by Michael Bostock, http://bost.ocks.org/mike/sankey/ -->
<head>
<title>Paxata Sankey</title>
<meta charset="utf-8">
<script type="text/javascript" src="http://d3js.org/d3.v3.min.js"></script>
<!-- <script type="text/javascript" src="http://d3js.org/d3.v3.min.js"></script> -->
<script src = "sankey.js"></script>
<style type="text/css">
/* upon hover rect appears movable */
/* other options at http://www.echoecho.com/csscursors.htm */
.node rect {
    cursor: move;
  	fill-opacity: .9;
  	shape-rendering: crispEdges;
  }

/* ingore text on mouse overs*/
/* apply shaddow for reliability */
.node text {
  	pointer-events: none;
  	text-shadow: 0 1px 0 #fff;
    font-family: sans-serif;
  }

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

.link:hover {
  	stroke-opacity: .2;
  }
</style>

</head>

<body>
<header>
  <aside>April 12, 2014</aside> Mark Rios
</header>

<h1>Paxata Sankey Diagram</h1>

<p id = "chart">

<aside>Drag to rearrange nodes.</aside>

<p class="attribution">Source: <a href="http://www.paxata.com/our-solutions">Paxata Solutions Overview</a>.


<script>

var units = "Adaptive Data Preparation";

var margin = {top: 50, right: 300, bottom: 50, left:10},
    width = 1600- margin.left - margin.right,
    height = 450 - margin.top - margin.bottom;

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

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 + ")");

var sankey = d3.sankey()  // set sankey variables
    .nodeWidth(10)
    .nodePadding(40)
    .size([width, height]);


var path = sankey.link(); // pointer to sankey function


d3.csv("sankey.csv", function(error,data){

console.log(data);

graph = {"nodes": [], "links": []};


data.forEach(function (d) {  // nodes and links based on the csv
    graph.nodes.push({ "name": d.source});
    graph.nodes.push({ "name": d.target});
    graph.links.push({ "source": d.source, "target": d.target, "value": +d.value}); });


graph.nodes = d3.keys(d3.nest() //  nest only unique nodes as keys.
    .key(function (d) { return d.name;})
    .map(graph.nodes));


graph.links.forEach(function (d,i){  // assign link and source to the proper node.
    graph.links[i].source = graph.nodes.indexOf(graph.links[i].source);
    graph.links[i].target = graph.nodes.indexOf(graph.links[i].target);});

graph.nodes.forEach(function (d,i){graph.nodes[i] = { "name":d };}); // array of objects

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

console.log(sankey);

 var link = svg.append("g").selectAll(".link") // add links to diagram
    .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;});

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

var node = svg.append("g").selectAll("node") // allow nodes to be rearranged
    .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));

node.append("rect") // sankey.js sets width
    .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); });

node.append("text") // add node titles to the left of the nodes
    .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");

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>

## sankey.csv

          
            source
            target
            value

            
              Import
              Version Control
              .5

            
              Import
              Data Types
              .5

            
              Import
              Sharing
              .5

            
              Import
              Error Detection
              .5

            
              Import
              Suggested Transformations
              .5

            
              Import
              Merge Data Sources
              .5

            
              Merge Data Sources
              Exploration
              .2

            
              Version Control
              Exploration
              .3

            
              Data Types
              Exploration
              .3

            
              Sharing
              Exploration
              .3

            
              Error Detection
              Exploration
              .3

            
              Suggested Transformations
              Exploration
              .3

            
              Exploration
              Data Visualization
              .5

            
              Exploration
              Transformations
              .6

            
              Exploration
              Ad Hoc Analysis
              .5

            
              Exploration
              Filter
              .5

            
              Filter
              Enrich
              .2

            
              Data Visualization
              Enrich
              .5

            
              Transformations
              Enrich
              .5

            
              Ad Hoc Analysis
              Enrich
              .5

            
              Enrich
              Data Libraries
              .5

            
              Enrich
              Combine
              .5

            
              Enrich
              Share
              .5

            
              Enrich
              Readability
              .5

            
              Readability
              Answer Set
              .5

            
              Data Libraries
              Answer Set
              .5

            
              Combine
              Answer Set
              .5

            
              Share
              Answer Set
              .5

            
              Answer Set
              Tableau
              .5

            
              Answer Set
              Qlickview
              .5

            
              Answer Set
              ODBE BI Systems
              .5

            
              Answer Set
              Excel
              .5

            
              Tableau
              Publish
              .5

            
              Qlickview
              Publish
              .5

            
              ODBE BI Systems
              Publish
              .5

            
              Excel
              Publish
              .5

## sankey.js
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;
};

## thumbnail.png

      
    Raw
  

              thumbnail.png
	<!DOCTYPE html>
	<html>
	<!-- original by Michael Bostock, http://bost.ocks.org/mike/sankey/ -->
	<head>
	<title>Paxata Sankey</title>
	<meta charset="utf-8">
	<script type="text/javascript" src="http://d3js.org/d3.v3.min.js"></script>
	<!-- <script type="text/javascript" src="http://d3js.org/d3.v3.min.js"></script> -->
	<script src = "sankey.js"></script>
	<style type="text/css">
	/* upon hover rect appears movable */
	/* other options at http://www.echoecho.com/csscursors.htm */
	.node rect {
	cursor: move;
	fill-opacity: .9;
	shape-rendering: crispEdges;
	}

	/* ingore text on mouse overs*/
	/* apply shaddow for reliability */
	.node text {
	pointer-events: none;
	text-shadow: 0 1px 0 #fff;
	font-family: sans-serif;
	}

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

	.link:hover {
	stroke-opacity: .2;
	}
	</style>

	</head>

	<body>
	<header>
	<aside>April 12, 2014</aside> Mark Rios
	</header>

	<h1>Paxata Sankey Diagram</h1>

	<p id = "chart">

	<aside>Drag to rearrange nodes.</aside>

	<p class="attribution">Source: <a href="http://www.paxata.com/our-solutions">Paxata Solutions Overview</a>.


	<script>

	var units = "Adaptive Data Preparation";

	var margin = {top: 50, right: 300, bottom: 50, left:10},
	width = 1600- margin.left - margin.right,
	height = 450 - margin.top - margin.bottom;

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

	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 + ")");

	var sankey = d3.sankey() // set sankey variables
	.nodeWidth(10)
	.nodePadding(40)
	.size([width, height]);


	var path = sankey.link(); // pointer to sankey function


	d3.csv("sankey.csv", function(error,data){

	console.log(data);

	graph = {"nodes": [], "links": []};


	data.forEach(function (d) { // nodes and links based on the csv
	graph.nodes.push({ "name": d.source});
	graph.nodes.push({ "name": d.target});
	graph.links.push({ "source": d.source, "target": d.target, "value": +d.value}); });


	graph.nodes = d3.keys(d3.nest() // nest only unique nodes as keys.
	.key(function (d) { return d.name;})
	.map(graph.nodes));


	graph.links.forEach(function (d,i){ // assign link and source to the proper node.
	graph.links[i].source = graph.nodes.indexOf(graph.links[i].source);
	graph.links[i].target = graph.nodes.indexOf(graph.links[i].target);});

	graph.nodes.forEach(function (d,i){graph.nodes[i] = { "name":d };}); // array of objects

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

	console.log(sankey);

	var link = svg.append("g").selectAll(".link") // add links to diagram
	.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;});

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

	var node = svg.append("g").selectAll("node") // allow nodes to be rearranged
	.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));

	node.append("rect") // sankey.js sets width
	.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); });

	node.append("text") // add node titles to the left of the nodes
	.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");

	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>
source	target	value
Import	Version Control	.5
Import	Data Types	.5
Import	Sharing	.5
Import	Error Detection	.5
Import	Suggested Transformations	.5
Import	Merge Data Sources	.5
Merge Data Sources	Exploration	.2
Version Control	Exploration	.3
Data Types	Exploration	.3
Sharing	Exploration	.3
Error Detection	Exploration	.3
Suggested Transformations	Exploration	.3
Exploration	Data Visualization	.5
Exploration	Transformations	.6
Exploration	Ad Hoc Analysis	.5
Exploration	Filter	.5
Filter	Enrich	.2
Data Visualization	Enrich	.5
Transformations	Enrich	.5
Ad Hoc Analysis	Enrich	.5
Enrich	Data Libraries	.5
Enrich	Combine	.5
Enrich	Share	.5
Enrich	Readability	.5
Readability	Answer Set	.5
Data Libraries	Answer Set	.5
Combine	Answer Set	.5
Share	Answer Set	.5
Answer Set	Tableau	.5
Answer Set	Qlickview	.5
Answer Set	ODBE BI Systems	.5
Answer Set	Excel	.5
Tableau	Publish	.5
Qlickview	Publish	.5
ODBE BI Systems	Publish	.5
Excel	Publish	.5
	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;
	};