Greenhouse Gases Sankey Particles

.block

license: CC0-1.0
border: none

.gitignore

node_modules

README.md

a Sankey Particles visualization of the greenhouse gas production data from @d3noob

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 modifies sankeygreenhouse.json from the Sankey diagram of greenhouse gas production in 2005 bl.ock to use the node indices as values for the link source and target properties (rather than using the node names). the result is graph.json, a graph object in the 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

---

further research

in this example some link paths occlude other link paths. Node labels that are drawn over links present further occlusion issues. I'd like to see a method to resolve this occlusion, or element-overlap. using a scale based on the number of nodes at each depth level of the graph to set the font size could help. for this example, we manually set the font-size to 12px.

using an interaction to only show certain links or certains sets of related links may also reduce path occlusion and improve legibility.

please do share ideas + iterations with me on twitter @micahstubbs

---

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:

• Fixed speed particles transitioning in color from source node color to target node color.

• Particles of differing sizes and differing speeds moving in "bursts" between nodes.

createGraph.js

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

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

const nodeNames = data.nodes.map(d => d.name);
// console.log('nodeNames', nodeNames);

const links = data.links.map((d) => {
  return {
  	source: nodeNames.indexOf(d.source),
  	target: nodeNames.indexOf(d.target),
  	value: d.value
  };
});

const graph = {
	nodes: data.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;
};

graph.json

{
  "nodes": [
    {
      "name": "Energy"
    },
    {
      "name": "Industrial Processes"
    },
    {
      "name": "Electricity and heat"
    },
    {
      "name": "Industry"
    },
    {
      "name": "Land Use Change"
    },
    {
      "name": "Agriculture"
    },
    {
      "name": "Waste"
    },
    {
      "name": "Transportation"
    },
    {
      "name": "Other Fuel Combustion"
    },
    {
      "name": "Fugitive Emissions"
    },
    {
      "name": "Road"
    },
    {
      "name": "Air"
    },
    {
      "name": "Rail - Ship and Other Transport"
    },
    {
      "name": "Residential Buildings"
    },
    {
      "name": "Commercial Buildings"
    },
    {
      "name": "Unallocated Fuel Combustion"
    },
    {
      "name": "Iron and Steel"
    },
    {
      "name": "Aluminium Non-Ferrous Metals"
    },
    {
      "name": "Machinery"
    },
    {
      "name": "Pulp - Paper and Printing"
    },
    {
      "name": "Food and Tobacco"
    },
    {
      "name": "Chemicals"
    },
    {
      "name": "Cement"
    },
    {
      "name": "Other Industry"
    },
    {
      "name": "T and D Losses"
    },
    {
      "name": "Coal Mining"
    },
    {
      "name": "Oil and Gas Processing"
    },
    {
      "name": "Deforestation"
    },
    {
      "name": "Harvest / Management"
    },
    {
      "name": "Agricultural Energy Use"
    },
    {
      "name": "Agriculture Soils"
    },
    {
      "name": "Livestock and Manure"
    },
    {
      "name": "Rice Cultivation"
    },
    {
      "name": "Other Agriculture"
    },
    {
      "name": "Landfills"
    },
    {
      "name": "Waste water - Other Waste"
    },
    {
      "name": "Carbon Dioxide"
    },
    {
      "name": "HFCs - PFCs"
    },
    {
      "name": "Methane"
    },
    {
      "name": "Nitrous Oxide"
    }
  ],
  "links": [
    {
      "source": 29,
      "target": 36,
      "value": "1.4"
    },
    {
      "source": 5,
      "target": 30,
      "value": "5.2"
    },
    {
      "source": 5,
      "target": 31,
      "value": "5.4"
    },
    {
      "source": 5,
      "target": 33,
      "value": "1.7"
    },
    {
      "source": 5,
      "target": 32,
      "value": "1.5"
    },
    {
      "source": 30,
      "target": 39,
      "value": "5.2"
    },
    {
      "source": 11,
      "target": 36,
      "value": "1.7"
    },
    {
      "source": 17,
      "target": 36,
      "value": "1.0"
    },
    {
      "source": 17,
      "target": 37,
      "value": "0.2"
    },
    {
      "source": 22,
      "target": 36,
      "value": "5.0"
    },
    {
      "source": 21,
      "target": 36,
      "value": "3.4"
    },
    {
      "source": 21,
      "target": 37,
      "value": "0.5"
    },
    {
      "source": 21,
      "target": 39,
      "value": "0.2"
    },
    {
      "source": 25,
      "target": 36,
      "value": "0.1"
    },
    {
      "source": 25,
      "target": 38,
      "value": "1.2"
    },
    {
      "source": 14,
      "target": 36,
      "value": "6.3"
    },
    {
      "source": 27,
      "target": 36,
      "value": "10.9"
    },
    {
      "source": 2,
      "target": 29,
      "value": "0.4"
    },
    {
      "source": 2,
      "target": 17,
      "value": "0.4"
    },
    {
      "source": 2,
      "target": 22,
      "value": "0.3"
    },
    {
      "source": 2,
      "target": 21,
      "value": "1.3"
    },
    {
      "source": 2,
      "target": 14,
      "value": "5.0"
    },
    {
      "source": 2,
      "target": 20,
      "value": "0.5"
    },
    {
      "source": 2,
      "target": 16,
      "value": "1.0"
    },
    {
      "source": 2,
      "target": 18,
      "value": "1.0"
    },
    {
      "source": 2,
      "target": 26,
      "value": "0.4"
    },
    {
      "source": 2,
      "target": 23,
      "value": "2.7"
    },
    {
      "source": 2,
      "target": 19,
      "value": "0.6"
    },
    {
      "source": 2,
      "target": 13,
      "value": "5.2"
    },
    {
      "source": 2,
      "target": 24,
      "value": "2.2"
    },
    {
      "source": 2,
      "target": 15,
      "value": "2.0"
    },
    {
      "source": 0,
      "target": 2,
      "value": "24.9"
    },
    {
      "source": 0,
      "target": 9,
      "value": "4.0"
    },
    {
      "source": 0,
      "target": 3,
      "value": "14.7"
    },
    {
      "source": 0,
      "target": 8,
      "value": "8.6"
    },
    {
      "source": 0,
      "target": 7,
      "value": "14.3"
    },
    {
      "source": 20,
      "target": 36,
      "value": "1.0"
    },
    {
      "source": 9,
      "target": 25,
      "value": "1.3"
    },
    {
      "source": 9,
      "target": 26,
      "value": "3.2"
    },
    {
      "source": 28,
      "target": 36,
      "value": "1.3"
    },
    {
      "source": 1,
      "target": 17,
      "value": "0.4"
    },
    {
      "source": 1,
      "target": 22,
      "value": "2.8"
    },
    {
      "source": 1,
      "target": 21,
      "value": "1.4"
    },
    {
      "source": 1,
      "target": 23,
      "value": "0.5"
    },
    {
      "source": 3,
      "target": 17,
      "value": "0.4"
    },
    {
      "source": 3,
      "target": 22,
      "value": "1.9"
    },
    {
      "source": 3,
      "target": 21,
      "value": "1.4"
    },
    {
      "source": 3,
      "target": 20,
      "value": "0.5"
    },
    {
      "source": 3,
      "target": 16,
      "value": "3.0"
    },
    {
      "source": 3,
      "target": 26,
      "value": "2.8"
    },
    {
      "source": 3,
      "target": 23,
      "value": "3.8"
    },
    {
      "source": 3,
      "target": 19,
      "value": "0.5"
    },
    {
      "source": 16,
      "target": 36,
      "value": "4.0"
    },
    {
      "source": 4,
      "target": 27,
      "value": "10.9"
    },
    {
      "source": 4,
      "target": 28,
      "value": "1.3"
    },
    {
      "source": 34,
      "target": 38,
      "value": "1.7"
    },
    {
      "source": 31,
      "target": 38,
      "value": "5.1"
    },
    {
      "source": 31,
      "target": 39,
      "value": "0.3"
    },
    {
      "source": 18,
      "target": 36,
      "value": "1.0"
    },
    {
      "source": 26,
      "target": 36,
      "value": "3.6"
    },
    {
      "source": 26,
      "target": 38,
      "value": "2.8"
    },
    {
      "source": 33,
      "target": 38,
      "value": "1.4"
    },
    {
      "source": 33,
      "target": 39,
      "value": "0.3"
    },
    {
      "source": 8,
      "target": 29,
      "value": "1.0"
    },
    {
      "source": 8,
      "target": 14,
      "value": "1.3"
    },
    {
      "source": 8,
      "target": 13,
      "value": "5.0"
    },
    {
      "source": 8,
      "target": 15,
      "value": "1.8"
    },
    {
      "source": 23,
      "target": 36,
      "value": "6.6"
    },
    {
      "source": 23,
      "target": 37,
      "value": "0.4"
    },
    {
      "source": 19,
      "target": 36,
      "value": "1.1"
    },
    {
      "source": 12,
      "target": 36,
      "value": "2.5"
    },
    {
      "source": 13,
      "target": 36,
      "value": "10.2"
    },
    {
      "source": 32,
      "target": 38,
      "value": "1.5"
    },
    {
      "source": 10,
      "target": 36,
      "value": "10.5"
    },
    {
      "source": 24,
      "target": 36,
      "value": "2.2"
    },
    {
      "source": 7,
      "target": 11,
      "value": "1.7"
    },
    {
      "source": 7,
      "target": 12,
      "value": "2.5"
    },
    {
      "source": 7,
      "target": 10,
      "value": "10.5"
    },
    {
      "source": 15,
      "target": 36,
      "value": "3.0"
    },
    {
      "source": 15,
      "target": 38,
      "value": "0.4"
    },
    {
      "source": 15,
      "target": 39,
      "value": "0.4"
    },
    {
      "source": 6,
      "target": 34,
      "value": "1.7"
    },
    {
      "source": 6,
      "target": 35,
      "value": "1.5"
    },
    {
      "source": 35,
      "target": 38,
      "value": "1.2"
    },
    {
      "source": 35,
      "target": 39,
      "value": "0.3"
    }
  ]
}

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',
        'font-size': '12px'

      })
      .text(d => d.name)
      .filter(d => d.x < width / 2)
        .attr('x', 6 + sankey.nodeWidth())
        .attr('text-anchor', 'start')
        .style('font-size', '12px');

    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>

package.json

{
  "name": "greenhouse-gases-sankey-particles",
  "version": "1.0.0",
  "description": "a Sankey Particles visualization of the greenhouse gas production data from @d3noob",
  "main": "index.html",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "d3js",
    "greenhousee",
    "gas",
    "sankey",
    "canvas",
    "particles"
  ],
  "author": "@micahstubbs <micahstubbs@gmail.com> (https://github.com/micahstubbs)",
  "license": "CC0-1.0",
  "devDependencies": {
    "jsonfile": "^2.3.1"
  }
}

preview.png

preview.xcf

sankeygreenhouse.json

thumbnail.png