block by micahstubbs 6a366e759f029599678e293521d7e26c

rCharts Examples Sankey Particles

Full Screen

a Sankey Particles visualization of the rCharts Examples data from @timelyportfolio

this bl.ock forks Sankey Particles with only inline styles which in turn is an iteration on the bl.ock Sankey Particles III by @Elijah_Meeks

the #nodejs script createGraph.js reshapes data.json from the Sankey of rCharts Example Gallery bl.ock to the graph.json graph object format expected by our Sankey Particles vis

to run createGraph.js yourself, cd into the directory that contains this bl.ock and run these commands from the terminal:

npm i
node createGraph.js

this will install the dependencies from package.json and then run createGraph.js

Original README.md:

Using particles to indicate flow between reservoirs in a sankey diagram. This time with particles moving at varying speeds and maintaining the color of the source node. You can drag the reservoirs (the rectangles) to adjust the path of the flows.

Other examples of sankeys with particles:

index.html


<!DOCTYPE html>

<html lang="en">
<head>
<meta charset="utf-8" />
<title>Sankey Particles</title>
</head>
<body>
<canvas width="1000" height="1000" ></canvas>
<svg width="1000" height="1000" ></svg>

<script src="https://d3js.org/d3.v3.min.js" charset="utf-8" type="text/javascript"></script>
<script src="d3.sankey.js" charset="utf-8" type="text/javascript"></script>
<script src="https://npmcdn.com/babel-core@5.8.34/browser.min.js"></script>
<script lang='babel' type='text/babel'>
  /* const canvas = */ d3.select('canvas')
    .style('position', 'absolute');

  const margin = { top: 1, right: 1, bottom: 6, left: 1 };
  const width = 960 - margin.left - margin.right;
  const height = 500 - margin.top - margin.bottom;

  const formatNumber = d3.format(',.0f');
  const format = d => `${formatNumber(d)}`;
  const color = d3.scale.category20();

  const svg = d3.select('svg')
    .style('position', 'absolute')
    .attr('width', width + margin.left + margin.right)
    .attr('height', height + margin.top + margin.bottom)
    .append('g')
      .attr('transform', `translate(${margin.left}, ${margin.top})`);

  const sankey = d3.sankey()
    .nodeWidth(15)
    .nodePadding(10)
    .size([width, height]);

  const path = sankey.link();

  /* let freqCounter = 1; */


  d3.json('graph.json', graph => {
    sankey
      .nodes(graph.nodes)
      .links(graph.links)
      .layout(32);

    const link = svg.append('g').selectAll('.link')
      .data(graph.links)
      .enter().append('path')
        .attr('class', 'link')
        .attr('d', path)
        .style('stroke-width', d => Math.max(1, d.dy))
        .style({
          fill: 'none',
          stroke: '#000',
          'stroke-opacity': 0.15
        })
        .sort((a, b) => b.dy - a.dy)

    link
      .on('mouseover', function () {
        d3.select(this)
          .style('stroke-opacity', 0.25);
      })
      .on('mouseout', function () {
        d3.select(this)
          .style('stroke-opacity', 0.15);
      });

    link.append('title')
      .text(d => `${d.source.name} → ${d.target.name}\n${format(d.value)}`);

    const node = svg.append('g').selectAll('.node')
      .data(graph.nodes)
      .enter().append('g')
        .attr('class', 'node')
        .attr('transform', d => `translate(${d.x}, ${d.y})`)
        .call(d3.behavior.drag()
        .origin(d => d)
        .on('dragstart', function () { this.parentNode.appendChild(this); })
        .on('drag', dragmove));

    node.append('rect')
      .attr('height', d => d.dy)
      .attr('width', sankey.nodeWidth())
      .style('fill', d => {
        d.color = color(d.name.replace(/ .*/, ''));
        return d.color;
      })
      .style({
        stroke: 'none',
        cursor: 'move',
        'fill-opacity': 0.9,
        'shape-rendering': 'crispEdges'
      })
      .append('title')
        .text(d => `${d.name}\n${format(d.value)}`);

    node.append('text')
      .attr('x', -6)
      .attr('y', d => d.dy / 2)
      .attr('dy', '.35em')
      .attr('text-anchor', 'end')
      .attr('transform', null)
      .style({
        'pointer-events': 'none',
        'text-shadow': '0 1px 0 #fff'
      })
      .text(d => d.name)
      .filter(d => d.x < width / 2)
        .attr('x', 6 + sankey.nodeWidth())
        .attr('text-anchor', 'start');

    function dragmove(d) {
      d3.select(this)
        .attr('transform', `translate(${d.x}, ${(d.y = Math.max(0, Math.min(height - d.dy, d3.event.y)))})`);
      sankey.relayout();
      link.attr('d', path);
    }

    const linkExtent = d3.extent(graph.links, d => d.value);

    const frequencyScale = d3.scale.linear()
      .domain(linkExtent)
      .range([0.05, 1]);

    /* const particleSize = */ d3.scale.linear()
      .domain(linkExtent)
      .range([1, 5]);

    graph.links.forEach(currentLink => {
      currentLink.freq = frequencyScale(currentLink.value);
      currentLink.particleSize = 2;
      currentLink.particleColor = d3.scale.linear().domain([0, 1])
      .range([currentLink.source.color, currentLink.target.color]);
    });

    /* const t = */ d3.timer(tick, 1000);
    let particles = [];

    function tick(elapsed /* , time */) {
      particles = particles.filter(d => d.current < d.path.getTotalLength());

      d3.selectAll('path.link')
      .each(
        function (d) {
  //        if (d.freq < 1) {
          for (let x = 0; x < 2; x++) {
            const offset = (Math.random() - 0.5) * (d.dy - 4);
            if (Math.random() < d.freq) {
              const length = this.getTotalLength();
              particles.push({
                link: d,
                time: elapsed,
                offset,
                path: this,
                length,
                animateTime: length,
                speed: 0.5 + (Math.random())
              });
            }
          }
  //        }
  /*        else {
            for (let x = 0; x<d.freq; x++) {
              let offset = (Math.random() - .5) * d.dy;
              particles.push({link: d, time: elapsed, offset: offset, path: this})
            }
          } */
        });

      particleEdgeCanvasPath(elapsed);
    }

    function particleEdgeCanvasPath(elapsed) {
      const context = d3.select('canvas').node().getContext('2d');

      context.clearRect(0, 0, 1000, 1000);

      context.fillStyle = 'gray';
      context.lineWidth = '1px';
      for (const x in particles) {
        if ({}.hasOwnProperty.call(particles, x)) {
          const currentTime = elapsed - particles[x].time;
  //        let currentPercent = currentTime / 1000 * particles[x].path.getTotalLength();
          particles[x].current = currentTime * 0.15 * particles[x].speed;
          const currentPos = particles[x].path.getPointAtLength(particles[x].current);
          context.beginPath();
          context.fillStyle = particles[x].link.particleColor(0);
          context.arc(
            currentPos.x,
            currentPos.y + particles[x].offset,
            particles[x].link.particleSize,
            0,
            2 * Math.PI
          );
          context.fill();
        }
      }
    }
  });
</script>
</body>
</html>

createGraph.js

const fs = require('fs');
const _ = require('lodash');
const jsonfile = require('jsonfile');

const inputFile = 'data.json'
const data = JSON.parse(fs.readFileSync(inputFile, 'utf8'));

const nodeNames = _.uniq(_.concat(data.source, data.target));
// console.log('nodeNames', nodeNames);
const nodes = nodeNames.map(function (d) { 
	return { name: d };
});

console.log('data.source.length', data.source.length);
console.log('data.target.length', data.target.length);
console.log('data.value.length', data.value.length);

const links = _.zipWith(data.source, data.target, data.value, (s, t, v) => {
  return {
  	source: nodeNames.indexOf(s),
  	target: nodeNames.indexOf(t),
  	value: v
  };
});

const graph = {
	nodes,
	links
};

const outputFile = 'graph.json';
const outputObject = graph;
jsonfile.spaces = 2;

jsonfile.writeFile(outputFile, outputObject, function (err) {
  console.error(err)
})

d3.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) {
          if (nextNodes.indexOf(link.target) < 0) {
            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;
};

data.json

{  
   "source":[  
      "area",
      "bar chart",
      "block matrix",
      "blog post",
      "bump chart",
      "combination",
      "cumulative line",
      "custom",
      "d3",
      "d3",
      "d3",
      "dashboard",
      "dashifyr",
      "datatables",
      "dimple",
      "dimple",
      "dimple",
      "gallery",
      "highcharts",
      "highcharts",
      "highcharts",
      "highcharts",
      "leaflet",
      "line chart",
      "line chart",
      "map",
      "morris",
      "morris",
      "multiple",
      "multiple",
      "multiple",
      "multiple",
      "nvd3",
      "nvd3",
      "parallel coordinates",
      "parcoords",
      "polychart",
      "polychart",
      "rickshaw",
      "rickshaw",
      "sankey",
      "sankey",
      "sankey",
      "scatter",
      "scatter",
      "scatterplot",
      "shinyapp",
      "standalone visualization",
      "standalone visualization",
      "standalone visualization",
      "standalone visualization",
      "standalone visualization",
      "standalone visualization",
      "table",
      "timeline",
      "timelinejs",
      "tutorial",
      "tutorial"
   ],
   "target":[  
      "standalone visualization",
      "standalone visualization",
      "standalone visualization",
      "TimelyPortfolio",
      "standalone visualization",
      "multiple",
      "tutorial",
      "standalone visualization",
      "cumulative line",
      "custom",
      "sankey",
      "shinyapp",
      "dashboard",
      "table",
      "block matrix",
      "multiple",
      "scatter",
      "TimelyPortfolio",
      "area",
      "bar chart",
      "line chart",
      "scatterplot",
      "map",
      "standalone visualization",
      "tutorial",
      "shinyapp",
      "line chart",
      "multiple",
      "gallery",
      "shinyapp",
      "standalone visualization",
      "tutorial",
      "bar chart",
      "scatterplot",
      "tutorial",
      "parallel coordinates",
      "multiple",
      "scatterplot",
      "bump chart",
      "multiple",
      "blog post",
      "standalone visualization",
      "tutorial",
      "standalone visualization",
      "tutorial",
      "standalone visualization",
      "Ramnath Vaidyanathan",
      "Alex Bresler",
      "Ian Dunham",
      "pssGuy",
      "Ramnath Vaidyanathan",
      "Thomas Reinholdsson",
      "TimelyPortfolio",
      "standalone visualization",
      "standalone visualization",
      "timeline",
      "Ramnath Vaidyanathan",
      "TimelyPortfolio"
   ],
   "value":[  
      2,
      3,
      1,
      1,
      1,
      2,
      1,
      1,
      1,
      1,
      5,
      1,
      1,
      2,
      1,
      2,
      2,
      3,
      2,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      3,
      1,
      1,
      5,
      2,
      1,
      1,
      1,
      4,
      1,
      1,
      1,
      1,
      3,
      1,
      1,
      1,
      3,
      3,
      2,
      1,
      2,
      6,
      2,
      8,
      2,
      2,
      2,
      2,
      8
   ]
}

graph.json

{
  "nodes": [
    {
      "name": "area"
    },
    {
      "name": "bar chart"
    },
    {
      "name": "block matrix"
    },
    {
      "name": "blog post"
    },
    {
      "name": "bump chart"
    },
    {
      "name": "combination"
    },
    {
      "name": "cumulative line"
    },
    {
      "name": "custom"
    },
    {
      "name": "d3"
    },
    {
      "name": "dashboard"
    },
    {
      "name": "dashifyr"
    },
    {
      "name": "datatables"
    },
    {
      "name": "dimple"
    },
    {
      "name": "gallery"
    },
    {
      "name": "highcharts"
    },
    {
      "name": "leaflet"
    },
    {
      "name": "line chart"
    },
    {
      "name": "map"
    },
    {
      "name": "morris"
    },
    {
      "name": "multiple"
    },
    {
      "name": "nvd3"
    },
    {
      "name": "parallel coordinates"
    },
    {
      "name": "parcoords"
    },
    {
      "name": "polychart"
    },
    {
      "name": "rickshaw"
    },
    {
      "name": "sankey"
    },
    {
      "name": "scatter"
    },
    {
      "name": "scatterplot"
    },
    {
      "name": "shinyapp"
    },
    {
      "name": "standalone visualization"
    },
    {
      "name": "table"
    },
    {
      "name": "timeline"
    },
    {
      "name": "timelinejs"
    },
    {
      "name": "tutorial"
    },
    {
      "name": "TimelyPortfolio"
    },
    {
      "name": "Ramnath Vaidyanathan"
    },
    {
      "name": "Alex Bresler"
    },
    {
      "name": "Ian Dunham"
    },
    {
      "name": "pssGuy"
    },
    {
      "name": "Thomas Reinholdsson"
    }
  ],
  "links": [
    {
      "source": 0,
      "target": 29,
      "value": 2
    },
    {
      "source": 1,
      "target": 29,
      "value": 3
    },
    {
      "source": 2,
      "target": 29,
      "value": 1
    },
    {
      "source": 3,
      "target": 34,
      "value": 1
    },
    {
      "source": 4,
      "target": 29,
      "value": 1
    },
    {
      "source": 5,
      "target": 19,
      "value": 2
    },
    {
      "source": 6,
      "target": 33,
      "value": 1
    },
    {
      "source": 7,
      "target": 29,
      "value": 1
    },
    {
      "source": 8,
      "target": 6,
      "value": 1
    },
    {
      "source": 8,
      "target": 7,
      "value": 1
    },
    {
      "source": 8,
      "target": 25,
      "value": 5
    },
    {
      "source": 9,
      "target": 28,
      "value": 1
    },
    {
      "source": 10,
      "target": 9,
      "value": 1
    },
    {
      "source": 11,
      "target": 30,
      "value": 2
    },
    {
      "source": 12,
      "target": 2,
      "value": 1
    },
    {
      "source": 12,
      "target": 19,
      "value": 2
    },
    {
      "source": 12,
      "target": 26,
      "value": 2
    },
    {
      "source": 13,
      "target": 34,
      "value": 3
    },
    {
      "source": 14,
      "target": 0,
      "value": 2
    },
    {
      "source": 14,
      "target": 1,
      "value": 1
    },
    {
      "source": 14,
      "target": 16,
      "value": 1
    },
    {
      "source": 14,
      "target": 27,
      "value": 1
    },
    {
      "source": 15,
      "target": 17,
      "value": 1
    },
    {
      "source": 16,
      "target": 29,
      "value": 1
    },
    {
      "source": 16,
      "target": 33,
      "value": 1
    },
    {
      "source": 17,
      "target": 28,
      "value": 1
    },
    {
      "source": 18,
      "target": 16,
      "value": 1
    },
    {
      "source": 18,
      "target": 19,
      "value": 1
    },
    {
      "source": 19,
      "target": 13,
      "value": 3
    },
    {
      "source": 19,
      "target": 28,
      "value": 1
    },
    {
      "source": 19,
      "target": 29,
      "value": 1
    },
    {
      "source": 19,
      "target": 33,
      "value": 5
    },
    {
      "source": 20,
      "target": 1,
      "value": 2
    },
    {
      "source": 20,
      "target": 27,
      "value": 1
    },
    {
      "source": 21,
      "target": 33,
      "value": 1
    },
    {
      "source": 22,
      "target": 21,
      "value": 1
    },
    {
      "source": 23,
      "target": 19,
      "value": 4
    },
    {
      "source": 23,
      "target": 27,
      "value": 1
    },
    {
      "source": 24,
      "target": 4,
      "value": 1
    },
    {
      "source": 24,
      "target": 19,
      "value": 1
    },
    {
      "source": 25,
      "target": 3,
      "value": 1
    },
    {
      "source": 25,
      "target": 29,
      "value": 3
    },
    {
      "source": 25,
      "target": 33,
      "value": 1
    },
    {
      "source": 26,
      "target": 29,
      "value": 1
    },
    {
      "source": 26,
      "target": 33,
      "value": 1
    },
    {
      "source": 27,
      "target": 29,
      "value": 3
    },
    {
      "source": 28,
      "target": 35,
      "value": 3
    },
    {
      "source": 29,
      "target": 36,
      "value": 2
    },
    {
      "source": 29,
      "target": 37,
      "value": 1
    },
    {
      "source": 29,
      "target": 38,
      "value": 2
    },
    {
      "source": 29,
      "target": 35,
      "value": 6
    },
    {
      "source": 29,
      "target": 39,
      "value": 2
    },
    {
      "source": 29,
      "target": 34,
      "value": 8
    },
    {
      "source": 30,
      "target": 29,
      "value": 2
    },
    {
      "source": 31,
      "target": 29,
      "value": 2
    },
    {
      "source": 32,
      "target": 31,
      "value": 2
    },
    {
      "source": 33,
      "target": 35,
      "value": 2
    },
    {
      "source": 33,
      "target": 34,
      "value": 8
    }
  ]
}

package.json

{
  "name": "rcharts-examples-particle-sankey",
  "version": "1.0.0",
  "description": "Sankey Particles on a new dataset. A fork of [Sankey Particles with only inline styles](http://bl.ocks.org/micahstubbs/3fa3c1a523c8f3c2cfb9) which in turn is an iteration on the bl.ock [Sankey Particles III](http://bl.ocks.org/emeeks/e749224c89f82788cb18) from [emeeks](http://bl.ocks.org/emeeks)",
  "main": "index.html",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "d3js",
    "rcharts",
    "sankey",
    "canvas",
    "particles"
  ],
  "author": "@micahstubbs <micahstubbs@gmail.com> (https://github.com/micahstubbs)",
  "repository" :
  { "type" : "git"
  , "url" : "https://gist.github.com/6a366e759f029599678e293521d7e26c.git"
  },
  "license": "CC0-1.0",
  "devDependencies": {
    "jsonfile": "^2.3.1",
    "lodash": "^4.13.1"
  }
}