Streamgraph
shifting mix
Shifting composition over time. Good for the mix, poor for reading any single value.
- Format.d3
- Length71 lines
- Includesnone
The source
71 lines of D3 JavaScript, and uses only the bundled D3 build. Copy it, or open the template inside Gnomon and render it as it is.
// Streamgraph — a stacked area with a wiggle baseline.
// Good for how a *mix* shifts over time; bad for reading any single value,
// because no series sits on a fixed axis. Use a stacked area if the absolute
// numbers matter.
const keys = ['Orders', 'Catalogue', 'Search', 'Payments', 'Identity'];
const rng = d3.randomLcg(11);
const series = d3.range(0, 36).map(month => {
const row = { month };
keys.forEach((k, i) => {
// A slow sine per series plus seeded noise, so the shape has structure
// rather than looking like static.
row[k] = Math.max(2, 40 + 30 * Math.sin((month + i * 6) / 5) + rng() * 18);
});
return row;
});
const margin = { top: 20, right: 130, bottom: 34, left: 20 };
const stacked = d3.stack()
.keys(keys)
.offset(d3.stackOffsetWiggle)
.order(d3.stackOrderInsideOut)(series);
const x = d3.scaleLinear()
.domain(d3.extent(series, d => d.month))
.range([margin.left, width - margin.right]);
const y = d3.scaleLinear()
.domain([d3.min(stacked, s => d3.min(s, d => d[0])), d3.max(stacked, s => d3.max(s, d => d[1]))])
.range([height - margin.bottom, margin.top]);
const color = d3.scaleOrdinal(keys, theme.palette);
const area = d3.area()
.x(d => x(d.data.month))
.y0(d => y(d[0]))
.y1(d => y(d[1]))
.curve(d3.curveBasis);
const svg = d3.select(container).append('svg')
.attr('viewBox', [0, 0, width, height])
.attr('width', width)
.attr('height', height)
.attr('font-family', 'system-ui, sans-serif')
.attr('font-size', 11);
svg.append('g')
.selectAll('path')
.data(stacked)
.join('path')
.attr('d', area)
.attr('fill', d => color(d.key))
.attr('fill-opacity', 0.9);
svg.append('g')
.attr('transform', `translate(0,${height - margin.bottom})`)
.call(d3.axisBottom(x).ticks(6).tickFormat(d => `M${d}`))
.call(g => g.select('.domain').remove())
.call(g => g.selectAll('text').attr('fill', theme.muted))
.call(g => g.selectAll('line').attr('stroke', theme.muted));
const legend = svg.append('g')
.attr('transform', `translate(${width - margin.right + 16},${margin.top})`);
legend.selectAll('g')
.data(keys)
.join('g')
.attr('transform', (_, i) => `translate(0,${i * 18})`)
.call(g => g.append('rect')
.attr('width', 11).attr('height', 11).attr('rx', 2)
.attr('fill', d => color(d)))
.call(g => g.append('text')
.attr('x', 16).attr('y', 9)
.attr('fill', theme.foreground).text(d => d));Render this offline
This template ships in Gnomon and renders on your machine, with no account and nothing sent to a server. The browser editor is free and needs no install.
Others in D3 visualisations
- Sankey — request flowFlow with volume. The best chart here for "where does it all go".
- Chord — service interactionWho talks to whom, when the traffic is bidirectional.
- Arc diagram — dependenciesNodes on one axis, arcs above. Readable where a force graph is not, provided the ordering means something.
- Adjacency matrix — couplingAdjacency matrix. Unfashionable, and better than a force graph for dense dependencies.
- Edge bundling — module importsHierarchical edge bundling. For import graphs big enough that straight edges become a hairball.
- Sunburst — nested spendNested hierarchy, radially. Prettier than an icicle, harder to compare.
- Icicle — nested spend (linear)A sunburst unrolled flat. Harder to love, much easier to compare siblings.
- Circle packing — nested sizeCircle packing. Nested size when the nesting matters more than reading exact areas.
- Treemap — portfolio costNested size. Good for cost, storage, lines of code.
- Tidy tree — structureA tidy tree. The default for anything with one parent per node.
- Radial tree — structure (radial)The same tree bent into a circle. Fits more depth on a slide, costs you easy comparison.
- Dendrogram — clusteringClustering, with join height carrying the distance. Not merely a tree with curves.
- Indented tree — file/spec outlineA file or spec outline. The chart that looks like the thing it describes.
- Force graph — service mapService map. Use for clusters, not for reading individual edges.
- Force graph — disjoint clustersForce graph that keeps unconnected clusters apart rather than flinging them off screen.
- Force graph — radial tiersForce layout pinned to rings, so tier is a position instead of a colour legend.
- Directed graph — call directionDirected edges with arrowheads. For when direction is the question, not just adjacency.
- Force tree — blast radiusBlast radius from one node: what breaks if this goes.
- Calendar heatmap — daily activityDaily activity over a year: deploys, incidents, commits.
- Gantt — delivery roadmapDelivery roadmap, rendered from data.
- Radar — capability scoringCapability scoring across axes. Fine for one subject, misleading with four overlaid.
- Bullet chart — target vs actualTarget against actual, in one line. The chart a gauge wishes it were.
- Beeswarm — distribution by groupEvery point, grouped, without the overplotting a strip plot suffers.
- Horizon chart — many series, little spaceMany series in little space. Takes a moment to learn, then very dense.
- Slope chart — before and afterBefore and after, two points, one line each. Devastatingly clear.
- Parallel coordinates — multi-criteriaMulti-criteria comparison: for option analysis.
- Box plot — latency distributionLatency distribution. The chart that shows the tail a mean hides.
- Grouped bar — category comparisonCategory comparison. Unglamorous, and usually the right answer.
- Multi-line — metrics over timeMetrics over time. Keep it under about five series, or switch to horizon.