Last active
January 22, 2018 00:26
-
-
Save zanarmstrong/7199ed8f71560888eb0cec6f593c5491 to your computer and use it in GitHub Desktop.
perceptual distance for varied colormaps
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| license: mit |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // Bundling using browserify + npm because of needing to import delta E via npm. Better way to do this? | |
| (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ | |
| var DeltaE = require('delta-e'); | |
| var d3 = Object.assign({}, | |
| require("d3-scale"), | |
| require("d3-array"), | |
| require("d3-shape"), | |
| require("d3-color"), | |
| require("d3-format"), | |
| require("d3-axis"), | |
| require("d3-selection"), | |
| require("d3-scale-chromatic") | |
| ); | |
| var height = 250; | |
| var width = 500; | |
| var colorFunctions = { | |
| 'hsl rainbow': function(t) { | |
| return d3.hsl(t * 360, 1, 0.5) + ""; | |
| }, | |
| // source: https://gist.github.com/bagrow/805122 | |
| 'jet*': function(t){ | |
| return d3.scaleLinear() | |
| .domain(d3.range(0,1.125,.125)) | |
| .range([ | |
| d3.color(d3.rgb(0.0 * 255, 0.0 * 255, 0.5 * 255)), | |
| d3.color(d3.rgb(0.0 * 255, 0.0 * 255, 1.0 * 255)), | |
| d3.color(d3.rgb(0.0 * 255, 0.5 * 255, 1.0 * 255)), | |
| d3.color(d3.rgb(0.0 * 255, 1.0 * 255, 1.0 * 255)), | |
| d3.color(d3.rgb(0.5 * 255, 1.0 * 255, 0.5 * 255)), | |
| d3.color(d3.rgb(1.0 * 255, 1.0 * 255, 0.0 * 255)), | |
| d3.color(d3.rgb(1.0 * 255, 0.5 * 255, 0.0 * 255)), | |
| d3.color(d3.rgb(1.0 * 255, 0.0 * 255, 0.0 * 255)), | |
| d3.color(d3.rgb(0.5 * 255, 0.0 * 255, 0.0 * 255)) | |
| ])(t) | |
| }, | |
| "D3's less angry rainbow": d3.interpolateRainbow, | |
| 'viridis': d3["interpolateViridis"], | |
| 'inferno': d3["interpolateInferno"], | |
| 'cube helix': d3.interpolateCubehelixDefault, | |
| 'red blue': d3.interpolateRdBu, | |
| 'blues': d3.interpolateBlues, | |
| 'spectral': d3.interpolateSpectral, | |
| 'brown - white - green': d3.interpolateBrBG, | |
| 'purple - orange': d3.interpolatePuOr | |
| } | |
| function normalizeColorScale(inter) { | |
| "use strict"; | |
| const step = 0.005; | |
| const colDiff = 8; | |
| let parts = []; | |
| let currColor = inter(0); | |
| let currVal = 0; | |
| let totalDist = 0; | |
| for (let x = step; x < 1; x += step) { | |
| let color = inter(x); | |
| let dist = colorDistance(currColor, color); | |
| if (dist >= colDiff) { | |
| parts.push({ start: currVal, | |
| len: x - currVal, | |
| dist: dist }); | |
| totalDist += dist; | |
| currColor = color; | |
| currVal = x; | |
| } | |
| } | |
| let dist = colorDistance(currColor, inter(1)); | |
| parts.push({ start: currVal, | |
| len: 1 - currVal, | |
| dist: dist }); | |
| totalDist += dist; | |
| return function normalizedColorInterpolater(x) { | |
| let dist = x * totalDist; | |
| for (let part of parts) { | |
| if (dist < part.dist) { | |
| return inter(dist / part.dist * part.len + part.start); | |
| } | |
| dist -= part.dist; | |
| } | |
| return inter(x); | |
| }; | |
| } | |
| function colorDistance(a, b) { | |
| function convert(color) { | |
| var lab = d3.lab(color) | |
| return { | |
| "L": lab.l, | |
| "A": lab.a, | |
| "B": lab.b | |
| } | |
| } | |
| return DeltaE.getDeltaE00(convert(a), convert(b)); | |
| } | |
| function perceptionGraph(elem){ | |
| var graph = {} | |
| var distances = [] | |
| graph.colorspace = ''; | |
| graph.colorScale = function(){return 'black'}; | |
| var radius = 8; | |
| var margin = {left: 50, right: 0, bottom: 50} | |
| var pointCount = 30; | |
| var diff = 1/pointCount; | |
| var yScale = d3.scaleLinear().domain([0,22]).range([height - margin.bottom,20]) | |
| var xScale = d3.scaleLinear().domain([0,1]).range([0,width]) | |
| var data = d3.range(diff,1,diff); | |
| var getDistance = function (a,b) { | |
| return colorDistance(graph.colorScale(a), graph.colorScale(b)); | |
| } | |
| var calcYPos = function (d, i){ | |
| var distToPrev = getDistance(d, d-diff); | |
| var distToNext = getDistance(d, d+diff) | |
| distances[i] = distToPrev; | |
| return yScale((distToPrev + distToNext)/ 2) | |
| } | |
| // create svg and append to elem | |
| var chart = d3.select("#viz").append("g") | |
| chart.append("line") | |
| .attr("class", "averageline") | |
| .attr("fill", "none") | |
| .attr("stroke", "grey") | |
| .attr("stroke-dasharray", "5, 5") | |
| .attr("x1", xScale(0)) | |
| .attr("x2", xScale(1)) | |
| .attr("y1", yScale(10)) | |
| .attr("y2", yScale(10)) | |
| chart.append('path') | |
| .attr('fill', 'none') | |
| .attr('stroke', 'lightgrey') | |
| .attr('stroke-width', 2) | |
| .attr("class", "line") | |
| chart.selectAll(".circles") | |
| .data(data).enter() | |
| .append("circle") | |
| .attr("cx", xScale) | |
| .attr("r", radius) | |
| .attr("cy", 0) | |
| .attr("class", "circles") | |
| chart.selectAll(".colorblocks") | |
| .data([0].concat(data)).enter() | |
| .append("rect") | |
| .attr("y", height - margin.bottom) | |
| .attr("x", xScale) | |
| .attr("height", 5) | |
| .attr("width", xScale(diff) -xScale(0)) | |
| .attr("class", "colorblocks") | |
| chart.append("g") | |
| .call(d3.axisLeft(yScale)); | |
| // text label for the y axis | |
| chart.append("text") | |
| .attr("transform", "rotate(-90)") | |
| .attr("y", -38) | |
| .attr("x", -height/2 + 10) | |
| .attr("dy", "1em") | |
| .style("text-anchor", "middle") | |
| .attr("font-size", 12) | |
| .text("Perceived distance to adjacent colors"); | |
| chart.append("text") | |
| .attr("class", "title") | |
| .attr("text", "") | |
| .attr("y", height - 22) | |
| .attr("x", width/2) | |
| .attr("font-size", 20) | |
| .style("text-anchor", "middle") | |
| .attr("font-family", "monospace") | |
| chart.append("text") | |
| .attr("class", "average") | |
| .attr("text", "Average Distance: ") | |
| .attr("y", 30) | |
| .attr("x", 10) | |
| .attr("font-size", 10) | |
| // create axis | |
| graph.render = function(colorspace, colorscale){ | |
| graph.colorspace = colorspace; | |
| graph.colorScale = colorscale; | |
| chart.selectAll('.line') | |
| .attr('d', | |
| d3.line() | |
| .x(xScale) | |
| .y(calcYPos)(data)); | |
| chart.selectAll(".colorblocks") | |
| .attr("fill", graph.colorScale); | |
| chart.selectAll(".circles") | |
| .attr("fill", graph.colorScale) | |
| .attr("cy", calcYPos) | |
| chart.selectAll(".title").text(colorspace) | |
| var average = d3.sum(distances) / (pointCount - 1); | |
| chart.selectAll(".average").text("Average dist: " + d3.format(".1f")(average)); | |
| chart.selectAll(".averageline").attr("y1", yScale(average)).attr('y2', yScale(average)) | |
| } | |
| graph.move = function(left, top){ | |
| chart.attr("transform","translate(" + left + "," + top+ ")") | |
| } | |
| return graph | |
| } | |
| var viz = d3.select('#viz').attr("width", width * 3).attr('height', height * 8 + 1500) | |
| count = 0; | |
| for(colormap in colorFunctions){ | |
| graphColorPerception(colormap, d3.scaleSequential(colorFunctions[colormap]), count*2) | |
| graphColorPerception("normalized " + colormap, d3.scaleSequential(normalizeColorScale(colorFunctions[colormap])), count*2+1) | |
| count += 1; | |
| } | |
| function graphColorPerception(colormap, colorscale, i){ | |
| graph = new perceptionGraph(document.getElementById("viz")) | |
| graph.render(colormap, colorscale) | |
| graph.move(40 + (i % 2) * (width + 50),(height + 5) * Math.floor(i / 2)) | |
| } | |
| },{"d3-array":2,"d3-axis":3,"d3-color":5,"d3-format":6,"d3-scale":10,"d3-scale-chromatic":9,"d3-selection":11,"d3-shape":12,"delta-e":18}],2:[function(require,module,exports){ | |
| // https://d3js.org/d3-array/ Version 1.2.1. Copyright 2017 Mike Bostock. | |
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : | |
| typeof define === 'function' && define.amd ? define(['exports'], factory) : | |
| (factory((global.d3 = global.d3 || {}))); | |
| }(this, (function (exports) { 'use strict'; | |
| var ascending = function(a, b) { | |
| return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; | |
| }; | |
| var bisector = function(compare) { | |
| if (compare.length === 1) compare = ascendingComparator(compare); | |
| return { | |
| left: function(a, x, lo, hi) { | |
| if (lo == null) lo = 0; | |
| if (hi == null) hi = a.length; | |
| while (lo < hi) { | |
| var mid = lo + hi >>> 1; | |
| if (compare(a[mid], x) < 0) lo = mid + 1; | |
| else hi = mid; | |
| } | |
| return lo; | |
| }, | |
| right: function(a, x, lo, hi) { | |
| if (lo == null) lo = 0; | |
| if (hi == null) hi = a.length; | |
| while (lo < hi) { | |
| var mid = lo + hi >>> 1; | |
| if (compare(a[mid], x) > 0) hi = mid; | |
| else lo = mid + 1; | |
| } | |
| return lo; | |
| } | |
| }; | |
| }; | |
| function ascendingComparator(f) { | |
| return function(d, x) { | |
| return ascending(f(d), x); | |
| }; | |
| } | |
| var ascendingBisect = bisector(ascending); | |
| var bisectRight = ascendingBisect.right; | |
| var bisectLeft = ascendingBisect.left; | |
| var pairs = function(array, f) { | |
| if (f == null) f = pair; | |
| var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n); | |
| while (i < n) pairs[i] = f(p, p = array[++i]); | |
| return pairs; | |
| }; | |
| function pair(a, b) { | |
| return [a, b]; | |
| } | |
| var cross = function(values0, values1, reduce) { | |
| var n0 = values0.length, | |
| n1 = values1.length, | |
| values = new Array(n0 * n1), | |
| i0, | |
| i1, | |
| i, | |
| value0; | |
| if (reduce == null) reduce = pair; | |
| for (i0 = i = 0; i0 < n0; ++i0) { | |
| for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i) { | |
| values[i] = reduce(value0, values1[i1]); | |
| } | |
| } | |
| return values; | |
| }; | |
| var descending = function(a, b) { | |
| return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; | |
| }; | |
| var number = function(x) { | |
| return x === null ? NaN : +x; | |
| }; | |
| var variance = function(values, valueof) { | |
| var n = values.length, | |
| m = 0, | |
| i = -1, | |
| mean = 0, | |
| value, | |
| delta, | |
| sum = 0; | |
| if (valueof == null) { | |
| while (++i < n) { | |
| if (!isNaN(value = number(values[i]))) { | |
| delta = value - mean; | |
| mean += delta / ++m; | |
| sum += delta * (value - mean); | |
| } | |
| } | |
| } | |
| else { | |
| while (++i < n) { | |
| if (!isNaN(value = number(valueof(values[i], i, values)))) { | |
| delta = value - mean; | |
| mean += delta / ++m; | |
| sum += delta * (value - mean); | |
| } | |
| } | |
| } | |
| if (m > 1) return sum / (m - 1); | |
| }; | |
| var deviation = function(array, f) { | |
| var v = variance(array, f); | |
| return v ? Math.sqrt(v) : v; | |
| }; | |
| var extent = function(values, valueof) { | |
| var n = values.length, | |
| i = -1, | |
| value, | |
| min, | |
| max; | |
| if (valueof == null) { | |
| while (++i < n) { // Find the first comparable value. | |
| if ((value = values[i]) != null && value >= value) { | |
| min = max = value; | |
| while (++i < n) { // Compare the remaining values. | |
| if ((value = values[i]) != null) { | |
| if (min > value) min = value; | |
| if (max < value) max = value; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| else { | |
| while (++i < n) { // Find the first comparable value. | |
| if ((value = valueof(values[i], i, values)) != null && value >= value) { | |
| min = max = value; | |
| while (++i < n) { // Compare the remaining values. | |
| if ((value = valueof(values[i], i, values)) != null) { | |
| if (min > value) min = value; | |
| if (max < value) max = value; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return [min, max]; | |
| }; | |
| var array = Array.prototype; | |
| var slice = array.slice; | |
| var map = array.map; | |
| var constant = function(x) { | |
| return function() { | |
| return x; | |
| }; | |
| }; | |
| var identity = function(x) { | |
| return x; | |
| }; | |
| var range = function(start, stop, step) { | |
| start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step; | |
| var i = -1, | |
| n = Math.max(0, Math.ceil((stop - start) / step)) | 0, | |
| range = new Array(n); | |
| while (++i < n) { | |
| range[i] = start + i * step; | |
| } | |
| return range; | |
| }; | |
| var e10 = Math.sqrt(50); | |
| var e5 = Math.sqrt(10); | |
| var e2 = Math.sqrt(2); | |
| var ticks = function(start, stop, count) { | |
| var reverse, | |
| i = -1, | |
| n, | |
| ticks, | |
| step; | |
| stop = +stop, start = +start, count = +count; | |
| if (start === stop && count > 0) return [start]; | |
| if (reverse = stop < start) n = start, start = stop, stop = n; | |
| if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return []; | |
| if (step > 0) { | |
| start = Math.ceil(start / step); | |
| stop = Math.floor(stop / step); | |
| ticks = new Array(n = Math.ceil(stop - start + 1)); | |
| while (++i < n) ticks[i] = (start + i) * step; | |
| } else { | |
| start = Math.floor(start * step); | |
| stop = Math.ceil(stop * step); | |
| ticks = new Array(n = Math.ceil(start - stop + 1)); | |
| while (++i < n) ticks[i] = (start - i) / step; | |
| } | |
| if (reverse) ticks.reverse(); | |
| return ticks; | |
| }; | |
| function tickIncrement(start, stop, count) { | |
| var step = (stop - start) / Math.max(0, count), | |
| power = Math.floor(Math.log(step) / Math.LN10), | |
| error = step / Math.pow(10, power); | |
| return power >= 0 | |
| ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power) | |
| : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1); | |
| } | |
| function tickStep(start, stop, count) { | |
| var step0 = Math.abs(stop - start) / Math.max(0, count), | |
| step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)), | |
| error = step0 / step1; | |
| if (error >= e10) step1 *= 10; | |
| else if (error >= e5) step1 *= 5; | |
| else if (error >= e2) step1 *= 2; | |
| return stop < start ? -step1 : step1; | |
| } | |
| var sturges = function(values) { | |
| return Math.ceil(Math.log(values.length) / Math.LN2) + 1; | |
| }; | |
| var histogram = function() { | |
| var value = identity, | |
| domain = extent, | |
| threshold = sturges; | |
| function histogram(data) { | |
| var i, | |
| n = data.length, | |
| x, | |
| values = new Array(n); | |
| for (i = 0; i < n; ++i) { | |
| values[i] = value(data[i], i, data); | |
| } | |
| var xz = domain(values), | |
| x0 = xz[0], | |
| x1 = xz[1], | |
| tz = threshold(values, x0, x1); | |
| // Convert number of thresholds into uniform thresholds. | |
| if (!Array.isArray(tz)) { | |
| tz = tickStep(x0, x1, tz); | |
| tz = range(Math.ceil(x0 / tz) * tz, Math.floor(x1 / tz) * tz, tz); // exclusive | |
| } | |
| // Remove any thresholds outside the domain. | |
| var m = tz.length; | |
| while (tz[0] <= x0) tz.shift(), --m; | |
| while (tz[m - 1] > x1) tz.pop(), --m; | |
| var bins = new Array(m + 1), | |
| bin; | |
| // Initialize bins. | |
| for (i = 0; i <= m; ++i) { | |
| bin = bins[i] = []; | |
| bin.x0 = i > 0 ? tz[i - 1] : x0; | |
| bin.x1 = i < m ? tz[i] : x1; | |
| } | |
| // Assign data to bins by value, ignoring any outside the domain. | |
| for (i = 0; i < n; ++i) { | |
| x = values[i]; | |
| if (x0 <= x && x <= x1) { | |
| bins[bisectRight(tz, x, 0, m)].push(data[i]); | |
| } | |
| } | |
| return bins; | |
| } | |
| histogram.value = function(_) { | |
| return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value; | |
| }; | |
| histogram.domain = function(_) { | |
| return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain; | |
| }; | |
| histogram.thresholds = function(_) { | |
| return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold; | |
| }; | |
| return histogram; | |
| }; | |
| var quantile = function(values, p, valueof) { | |
| if (valueof == null) valueof = number; | |
| if (!(n = values.length)) return; | |
| if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values); | |
| if (p >= 1) return +valueof(values[n - 1], n - 1, values); | |
| var n, | |
| i = (n - 1) * p, | |
| i0 = Math.floor(i), | |
| value0 = +valueof(values[i0], i0, values), | |
| value1 = +valueof(values[i0 + 1], i0 + 1, values); | |
| return value0 + (value1 - value0) * (i - i0); | |
| }; | |
| var freedmanDiaconis = function(values, min, max) { | |
| values = map.call(values, number).sort(ascending); | |
| return Math.ceil((max - min) / (2 * (quantile(values, 0.75) - quantile(values, 0.25)) * Math.pow(values.length, -1 / 3))); | |
| }; | |
| var scott = function(values, min, max) { | |
| return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3))); | |
| }; | |
| var max = function(values, valueof) { | |
| var n = values.length, | |
| i = -1, | |
| value, | |
| max; | |
| if (valueof == null) { | |
| while (++i < n) { // Find the first comparable value. | |
| if ((value = values[i]) != null && value >= value) { | |
| max = value; | |
| while (++i < n) { // Compare the remaining values. | |
| if ((value = values[i]) != null && value > max) { | |
| max = value; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| else { | |
| while (++i < n) { // Find the first comparable value. | |
| if ((value = valueof(values[i], i, values)) != null && value >= value) { | |
| max = value; | |
| while (++i < n) { // Compare the remaining values. | |
| if ((value = valueof(values[i], i, values)) != null && value > max) { | |
| max = value; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return max; | |
| }; | |
| var mean = function(values, valueof) { | |
| var n = values.length, | |
| m = n, | |
| i = -1, | |
| value, | |
| sum = 0; | |
| if (valueof == null) { | |
| while (++i < n) { | |
| if (!isNaN(value = number(values[i]))) sum += value; | |
| else --m; | |
| } | |
| } | |
| else { | |
| while (++i < n) { | |
| if (!isNaN(value = number(valueof(values[i], i, values)))) sum += value; | |
| else --m; | |
| } | |
| } | |
| if (m) return sum / m; | |
| }; | |
| var median = function(values, valueof) { | |
| var n = values.length, | |
| i = -1, | |
| value, | |
| numbers = []; | |
| if (valueof == null) { | |
| while (++i < n) { | |
| if (!isNaN(value = number(values[i]))) { | |
| numbers.push(value); | |
| } | |
| } | |
| } | |
| else { | |
| while (++i < n) { | |
| if (!isNaN(value = number(valueof(values[i], i, values)))) { | |
| numbers.push(value); | |
| } | |
| } | |
| } | |
| return quantile(numbers.sort(ascending), 0.5); | |
| }; | |
| var merge = function(arrays) { | |
| var n = arrays.length, | |
| m, | |
| i = -1, | |
| j = 0, | |
| merged, | |
| array; | |
| while (++i < n) j += arrays[i].length; | |
| merged = new Array(j); | |
| while (--n >= 0) { | |
| array = arrays[n]; | |
| m = array.length; | |
| while (--m >= 0) { | |
| merged[--j] = array[m]; | |
| } | |
| } | |
| return merged; | |
| }; | |
| var min = function(values, valueof) { | |
| var n = values.length, | |
| i = -1, | |
| value, | |
| min; | |
| if (valueof == null) { | |
| while (++i < n) { // Find the first comparable value. | |
| if ((value = values[i]) != null && value >= value) { | |
| min = value; | |
| while (++i < n) { // Compare the remaining values. | |
| if ((value = values[i]) != null && min > value) { | |
| min = value; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| else { | |
| while (++i < n) { // Find the first comparable value. | |
| if ((value = valueof(values[i], i, values)) != null && value >= value) { | |
| min = value; | |
| while (++i < n) { // Compare the remaining values. | |
| if ((value = valueof(values[i], i, values)) != null && min > value) { | |
| min = value; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return min; | |
| }; | |
| var permute = function(array, indexes) { | |
| var i = indexes.length, permutes = new Array(i); | |
| while (i--) permutes[i] = array[indexes[i]]; | |
| return permutes; | |
| }; | |
| var scan = function(values, compare) { | |
| if (!(n = values.length)) return; | |
| var n, | |
| i = 0, | |
| j = 0, | |
| xi, | |
| xj = values[j]; | |
| if (compare == null) compare = ascending; | |
| while (++i < n) { | |
| if (compare(xi = values[i], xj) < 0 || compare(xj, xj) !== 0) { | |
| xj = xi, j = i; | |
| } | |
| } | |
| if (compare(xj, xj) === 0) return j; | |
| }; | |
| var shuffle = function(array, i0, i1) { | |
| var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0), | |
| t, | |
| i; | |
| while (m) { | |
| i = Math.random() * m-- | 0; | |
| t = array[m + i0]; | |
| array[m + i0] = array[i + i0]; | |
| array[i + i0] = t; | |
| } | |
| return array; | |
| }; | |
| var sum = function(values, valueof) { | |
| var n = values.length, | |
| i = -1, | |
| value, | |
| sum = 0; | |
| if (valueof == null) { | |
| while (++i < n) { | |
| if (value = +values[i]) sum += value; // Note: zero and null are equivalent. | |
| } | |
| } | |
| else { | |
| while (++i < n) { | |
| if (value = +valueof(values[i], i, values)) sum += value; | |
| } | |
| } | |
| return sum; | |
| }; | |
| var transpose = function(matrix) { | |
| if (!(n = matrix.length)) return []; | |
| for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) { | |
| for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) { | |
| row[j] = matrix[j][i]; | |
| } | |
| } | |
| return transpose; | |
| }; | |
| function length(d) { | |
| return d.length; | |
| } | |
| var zip = function() { | |
| return transpose(arguments); | |
| }; | |
| exports.bisect = bisectRight; | |
| exports.bisectRight = bisectRight; | |
| exports.bisectLeft = bisectLeft; | |
| exports.ascending = ascending; | |
| exports.bisector = bisector; | |
| exports.cross = cross; | |
| exports.descending = descending; | |
| exports.deviation = deviation; | |
| exports.extent = extent; | |
| exports.histogram = histogram; | |
| exports.thresholdFreedmanDiaconis = freedmanDiaconis; | |
| exports.thresholdScott = scott; | |
| exports.thresholdSturges = sturges; | |
| exports.max = max; | |
| exports.mean = mean; | |
| exports.median = median; | |
| exports.merge = merge; | |
| exports.min = min; | |
| exports.pairs = pairs; | |
| exports.permute = permute; | |
| exports.quantile = quantile; | |
| exports.range = range; | |
| exports.scan = scan; | |
| exports.shuffle = shuffle; | |
| exports.sum = sum; | |
| exports.ticks = ticks; | |
| exports.tickIncrement = tickIncrement; | |
| exports.tickStep = tickStep; | |
| exports.transpose = transpose; | |
| exports.variance = variance; | |
| exports.zip = zip; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| }))); | |
| },{}],3:[function(require,module,exports){ | |
| // https://d3js.org/d3-axis/ Version 1.0.8. Copyright 2017 Mike Bostock. | |
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : | |
| typeof define === 'function' && define.amd ? define(['exports'], factory) : | |
| (factory((global.d3 = global.d3 || {}))); | |
| }(this, (function (exports) { 'use strict'; | |
| var slice = Array.prototype.slice; | |
| var identity = function(x) { | |
| return x; | |
| }; | |
| var top = 1; | |
| var right = 2; | |
| var bottom = 3; | |
| var left = 4; | |
| var epsilon = 1e-6; | |
| function translateX(x) { | |
| return "translate(" + (x + 0.5) + ",0)"; | |
| } | |
| function translateY(y) { | |
| return "translate(0," + (y + 0.5) + ")"; | |
| } | |
| function number(scale) { | |
| return function(d) { | |
| return +scale(d); | |
| }; | |
| } | |
| function center(scale) { | |
| var offset = Math.max(0, scale.bandwidth() - 1) / 2; // Adjust for 0.5px offset. | |
| if (scale.round()) offset = Math.round(offset); | |
| return function(d) { | |
| return +scale(d) + offset; | |
| }; | |
| } | |
| function entering() { | |
| return !this.__axis; | |
| } | |
| function axis(orient, scale) { | |
| var tickArguments = [], | |
| tickValues = null, | |
| tickFormat = null, | |
| tickSizeInner = 6, | |
| tickSizeOuter = 6, | |
| tickPadding = 3, | |
| k = orient === top || orient === left ? -1 : 1, | |
| x = orient === left || orient === right ? "x" : "y", | |
| transform = orient === top || orient === bottom ? translateX : translateY; | |
| function axis(context) { | |
| var values = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) : tickValues, | |
| format = tickFormat == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : identity) : tickFormat, | |
| spacing = Math.max(tickSizeInner, 0) + tickPadding, | |
| range = scale.range(), | |
| range0 = +range[0] + 0.5, | |
| range1 = +range[range.length - 1] + 0.5, | |
| position = (scale.bandwidth ? center : number)(scale.copy()), | |
| selection = context.selection ? context.selection() : context, | |
| path = selection.selectAll(".domain").data([null]), | |
| tick = selection.selectAll(".tick").data(values, scale).order(), | |
| tickExit = tick.exit(), | |
| tickEnter = tick.enter().append("g").attr("class", "tick"), | |
| line = tick.select("line"), | |
| text = tick.select("text"); | |
| path = path.merge(path.enter().insert("path", ".tick") | |
| .attr("class", "domain") | |
| .attr("stroke", "#000")); | |
| tick = tick.merge(tickEnter); | |
| line = line.merge(tickEnter.append("line") | |
| .attr("stroke", "#000") | |
| .attr(x + "2", k * tickSizeInner)); | |
| text = text.merge(tickEnter.append("text") | |
| .attr("fill", "#000") | |
| .attr(x, k * spacing) | |
| .attr("dy", orient === top ? "0em" : orient === bottom ? "0.71em" : "0.32em")); | |
| if (context !== selection) { | |
| path = path.transition(context); | |
| tick = tick.transition(context); | |
| line = line.transition(context); | |
| text = text.transition(context); | |
| tickExit = tickExit.transition(context) | |
| .attr("opacity", epsilon) | |
| .attr("transform", function(d) { return isFinite(d = position(d)) ? transform(d) : this.getAttribute("transform"); }); | |
| tickEnter | |
| .attr("opacity", epsilon) | |
| .attr("transform", function(d) { var p = this.parentNode.__axis; return transform(p && isFinite(p = p(d)) ? p : position(d)); }); | |
| } | |
| tickExit.remove(); | |
| path | |
| .attr("d", orient === left || orient == right | |
| ? "M" + k * tickSizeOuter + "," + range0 + "H0.5V" + range1 + "H" + k * tickSizeOuter | |
| : "M" + range0 + "," + k * tickSizeOuter + "V0.5H" + range1 + "V" + k * tickSizeOuter); | |
| tick | |
| .attr("opacity", 1) | |
| .attr("transform", function(d) { return transform(position(d)); }); | |
| line | |
| .attr(x + "2", k * tickSizeInner); | |
| text | |
| .attr(x, k * spacing) | |
| .text(format); | |
| selection.filter(entering) | |
| .attr("fill", "none") | |
| .attr("font-size", 10) | |
| .attr("font-family", "sans-serif") | |
| .attr("text-anchor", orient === right ? "start" : orient === left ? "end" : "middle"); | |
| selection | |
| .each(function() { this.__axis = position; }); | |
| } | |
| axis.scale = function(_) { | |
| return arguments.length ? (scale = _, axis) : scale; | |
| }; | |
| axis.ticks = function() { | |
| return tickArguments = slice.call(arguments), axis; | |
| }; | |
| axis.tickArguments = function(_) { | |
| return arguments.length ? (tickArguments = _ == null ? [] : slice.call(_), axis) : tickArguments.slice(); | |
| }; | |
| axis.tickValues = function(_) { | |
| return arguments.length ? (tickValues = _ == null ? null : slice.call(_), axis) : tickValues && tickValues.slice(); | |
| }; | |
| axis.tickFormat = function(_) { | |
| return arguments.length ? (tickFormat = _, axis) : tickFormat; | |
| }; | |
| axis.tickSize = function(_) { | |
| return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner; | |
| }; | |
| axis.tickSizeInner = function(_) { | |
| return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner; | |
| }; | |
| axis.tickSizeOuter = function(_) { | |
| return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter; | |
| }; | |
| axis.tickPadding = function(_) { | |
| return arguments.length ? (tickPadding = +_, axis) : tickPadding; | |
| }; | |
| return axis; | |
| } | |
| function axisTop(scale) { | |
| return axis(top, scale); | |
| } | |
| function axisRight(scale) { | |
| return axis(right, scale); | |
| } | |
| function axisBottom(scale) { | |
| return axis(bottom, scale); | |
| } | |
| function axisLeft(scale) { | |
| return axis(left, scale); | |
| } | |
| exports.axisTop = axisTop; | |
| exports.axisRight = axisRight; | |
| exports.axisBottom = axisBottom; | |
| exports.axisLeft = axisLeft; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| }))); | |
| },{}],4:[function(require,module,exports){ | |
| // https://d3js.org/d3-collection/ Version 1.0.4. Copyright 2017 Mike Bostock. | |
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : | |
| typeof define === 'function' && define.amd ? define(['exports'], factory) : | |
| (factory((global.d3 = global.d3 || {}))); | |
| }(this, (function (exports) { 'use strict'; | |
| var prefix = "$"; | |
| function Map() {} | |
| Map.prototype = map.prototype = { | |
| constructor: Map, | |
| has: function(key) { | |
| return (prefix + key) in this; | |
| }, | |
| get: function(key) { | |
| return this[prefix + key]; | |
| }, | |
| set: function(key, value) { | |
| this[prefix + key] = value; | |
| return this; | |
| }, | |
| remove: function(key) { | |
| var property = prefix + key; | |
| return property in this && delete this[property]; | |
| }, | |
| clear: function() { | |
| for (var property in this) if (property[0] === prefix) delete this[property]; | |
| }, | |
| keys: function() { | |
| var keys = []; | |
| for (var property in this) if (property[0] === prefix) keys.push(property.slice(1)); | |
| return keys; | |
| }, | |
| values: function() { | |
| var values = []; | |
| for (var property in this) if (property[0] === prefix) values.push(this[property]); | |
| return values; | |
| }, | |
| entries: function() { | |
| var entries = []; | |
| for (var property in this) if (property[0] === prefix) entries.push({key: property.slice(1), value: this[property]}); | |
| return entries; | |
| }, | |
| size: function() { | |
| var size = 0; | |
| for (var property in this) if (property[0] === prefix) ++size; | |
| return size; | |
| }, | |
| empty: function() { | |
| for (var property in this) if (property[0] === prefix) return false; | |
| return true; | |
| }, | |
| each: function(f) { | |
| for (var property in this) if (property[0] === prefix) f(this[property], property.slice(1), this); | |
| } | |
| }; | |
| function map(object, f) { | |
| var map = new Map; | |
| // Copy constructor. | |
| if (object instanceof Map) object.each(function(value, key) { map.set(key, value); }); | |
| // Index array by numeric index or specified key function. | |
| else if (Array.isArray(object)) { | |
| var i = -1, | |
| n = object.length, | |
| o; | |
| if (f == null) while (++i < n) map.set(i, object[i]); | |
| else while (++i < n) map.set(f(o = object[i], i, object), o); | |
| } | |
| // Convert object to map. | |
| else if (object) for (var key in object) map.set(key, object[key]); | |
| return map; | |
| } | |
| var nest = function() { | |
| var keys = [], | |
| sortKeys = [], | |
| sortValues, | |
| rollup, | |
| nest; | |
| function apply(array, depth, createResult, setResult) { | |
| if (depth >= keys.length) { | |
| if (sortValues != null) array.sort(sortValues); | |
| return rollup != null ? rollup(array) : array; | |
| } | |
| var i = -1, | |
| n = array.length, | |
| key = keys[depth++], | |
| keyValue, | |
| value, | |
| valuesByKey = map(), | |
| values, | |
| result = createResult(); | |
| while (++i < n) { | |
| if (values = valuesByKey.get(keyValue = key(value = array[i]) + "")) { | |
| values.push(value); | |
| } else { | |
| valuesByKey.set(keyValue, [value]); | |
| } | |
| } | |
| valuesByKey.each(function(values, key) { | |
| setResult(result, key, apply(values, depth, createResult, setResult)); | |
| }); | |
| return result; | |
| } | |
| function entries(map$$1, depth) { | |
| if (++depth > keys.length) return map$$1; | |
| var array, sortKey = sortKeys[depth - 1]; | |
| if (rollup != null && depth >= keys.length) array = map$$1.entries(); | |
| else array = [], map$$1.each(function(v, k) { array.push({key: k, values: entries(v, depth)}); }); | |
| return sortKey != null ? array.sort(function(a, b) { return sortKey(a.key, b.key); }) : array; | |
| } | |
| return nest = { | |
| object: function(array) { return apply(array, 0, createObject, setObject); }, | |
| map: function(array) { return apply(array, 0, createMap, setMap); }, | |
| entries: function(array) { return entries(apply(array, 0, createMap, setMap), 0); }, | |
| key: function(d) { keys.push(d); return nest; }, | |
| sortKeys: function(order) { sortKeys[keys.length - 1] = order; return nest; }, | |
| sortValues: function(order) { sortValues = order; return nest; }, | |
| rollup: function(f) { rollup = f; return nest; } | |
| }; | |
| }; | |
| function createObject() { | |
| return {}; | |
| } | |
| function setObject(object, key, value) { | |
| object[key] = value; | |
| } | |
| function createMap() { | |
| return map(); | |
| } | |
| function setMap(map$$1, key, value) { | |
| map$$1.set(key, value); | |
| } | |
| function Set() {} | |
| var proto = map.prototype; | |
| Set.prototype = set.prototype = { | |
| constructor: Set, | |
| has: proto.has, | |
| add: function(value) { | |
| value += ""; | |
| this[prefix + value] = value; | |
| return this; | |
| }, | |
| remove: proto.remove, | |
| clear: proto.clear, | |
| values: proto.keys, | |
| size: proto.size, | |
| empty: proto.empty, | |
| each: proto.each | |
| }; | |
| function set(object, f) { | |
| var set = new Set; | |
| // Copy constructor. | |
| if (object instanceof Set) object.each(function(value) { set.add(value); }); | |
| // Otherwise, assume it’s an array. | |
| else if (object) { | |
| var i = -1, n = object.length; | |
| if (f == null) while (++i < n) set.add(object[i]); | |
| else while (++i < n) set.add(f(object[i], i, object)); | |
| } | |
| return set; | |
| } | |
| var keys = function(map) { | |
| var keys = []; | |
| for (var key in map) keys.push(key); | |
| return keys; | |
| }; | |
| var values = function(map) { | |
| var values = []; | |
| for (var key in map) values.push(map[key]); | |
| return values; | |
| }; | |
| var entries = function(map) { | |
| var entries = []; | |
| for (var key in map) entries.push({key: key, value: map[key]}); | |
| return entries; | |
| }; | |
| exports.nest = nest; | |
| exports.set = set; | |
| exports.map = map; | |
| exports.keys = keys; | |
| exports.values = values; | |
| exports.entries = entries; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| }))); | |
| },{}],5:[function(require,module,exports){ | |
| // https://d3js.org/d3-color/ Version 1.0.3. Copyright 2017 Mike Bostock. | |
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : | |
| typeof define === 'function' && define.amd ? define(['exports'], factory) : | |
| (factory((global.d3 = global.d3 || {}))); | |
| }(this, (function (exports) { 'use strict'; | |
| var define = function(constructor, factory, prototype) { | |
| constructor.prototype = factory.prototype = prototype; | |
| prototype.constructor = constructor; | |
| }; | |
| function extend(parent, definition) { | |
| var prototype = Object.create(parent.prototype); | |
| for (var key in definition) prototype[key] = definition[key]; | |
| return prototype; | |
| } | |
| function Color() {} | |
| var darker = 0.7; | |
| var brighter = 1 / darker; | |
| var reI = "\\s*([+-]?\\d+)\\s*"; | |
| var reN = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*"; | |
| var reP = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*"; | |
| var reHex3 = /^#([0-9a-f]{3})$/; | |
| var reHex6 = /^#([0-9a-f]{6})$/; | |
| var reRgbInteger = new RegExp("^rgb\\(" + [reI, reI, reI] + "\\)$"); | |
| var reRgbPercent = new RegExp("^rgb\\(" + [reP, reP, reP] + "\\)$"); | |
| var reRgbaInteger = new RegExp("^rgba\\(" + [reI, reI, reI, reN] + "\\)$"); | |
| var reRgbaPercent = new RegExp("^rgba\\(" + [reP, reP, reP, reN] + "\\)$"); | |
| var reHslPercent = new RegExp("^hsl\\(" + [reN, reP, reP] + "\\)$"); | |
| var reHslaPercent = new RegExp("^hsla\\(" + [reN, reP, reP, reN] + "\\)$"); | |
| var named = { | |
| aliceblue: 0xf0f8ff, | |
| antiquewhite: 0xfaebd7, | |
| aqua: 0x00ffff, | |
| aquamarine: 0x7fffd4, | |
| azure: 0xf0ffff, | |
| beige: 0xf5f5dc, | |
| bisque: 0xffe4c4, | |
| black: 0x000000, | |
| blanchedalmond: 0xffebcd, | |
| blue: 0x0000ff, | |
| blueviolet: 0x8a2be2, | |
| brown: 0xa52a2a, | |
| burlywood: 0xdeb887, | |
| cadetblue: 0x5f9ea0, | |
| chartreuse: 0x7fff00, | |
| chocolate: 0xd2691e, | |
| coral: 0xff7f50, | |
| cornflowerblue: 0x6495ed, | |
| cornsilk: 0xfff8dc, | |
| crimson: 0xdc143c, | |
| cyan: 0x00ffff, | |
| darkblue: 0x00008b, | |
| darkcyan: 0x008b8b, | |
| darkgoldenrod: 0xb8860b, | |
| darkgray: 0xa9a9a9, | |
| darkgreen: 0x006400, | |
| darkgrey: 0xa9a9a9, | |
| darkkhaki: 0xbdb76b, | |
| darkmagenta: 0x8b008b, | |
| darkolivegreen: 0x556b2f, | |
| darkorange: 0xff8c00, | |
| darkorchid: 0x9932cc, | |
| darkred: 0x8b0000, | |
| darksalmon: 0xe9967a, | |
| darkseagreen: 0x8fbc8f, | |
| darkslateblue: 0x483d8b, | |
| darkslategray: 0x2f4f4f, | |
| darkslategrey: 0x2f4f4f, | |
| darkturquoise: 0x00ced1, | |
| darkviolet: 0x9400d3, | |
| deeppink: 0xff1493, | |
| deepskyblue: 0x00bfff, | |
| dimgray: 0x696969, | |
| dimgrey: 0x696969, | |
| dodgerblue: 0x1e90ff, | |
| firebrick: 0xb22222, | |
| floralwhite: 0xfffaf0, | |
| forestgreen: 0x228b22, | |
| fuchsia: 0xff00ff, | |
| gainsboro: 0xdcdcdc, | |
| ghostwhite: 0xf8f8ff, | |
| gold: 0xffd700, | |
| goldenrod: 0xdaa520, | |
| gray: 0x808080, | |
| green: 0x008000, | |
| greenyellow: 0xadff2f, | |
| grey: 0x808080, | |
| honeydew: 0xf0fff0, | |
| hotpink: 0xff69b4, | |
| indianred: 0xcd5c5c, | |
| indigo: 0x4b0082, | |
| ivory: 0xfffff0, | |
| khaki: 0xf0e68c, | |
| lavender: 0xe6e6fa, | |
| lavenderblush: 0xfff0f5, | |
| lawngreen: 0x7cfc00, | |
| lemonchiffon: 0xfffacd, | |
| lightblue: 0xadd8e6, | |
| lightcoral: 0xf08080, | |
| lightcyan: 0xe0ffff, | |
| lightgoldenrodyellow: 0xfafad2, | |
| lightgray: 0xd3d3d3, | |
| lightgreen: 0x90ee90, | |
| lightgrey: 0xd3d3d3, | |
| lightpink: 0xffb6c1, | |
| lightsalmon: 0xffa07a, | |
| lightseagreen: 0x20b2aa, | |
| lightskyblue: 0x87cefa, | |
| lightslategray: 0x778899, | |
| lightslategrey: 0x778899, | |
| lightsteelblue: 0xb0c4de, | |
| lightyellow: 0xffffe0, | |
| lime: 0x00ff00, | |
| limegreen: 0x32cd32, | |
| linen: 0xfaf0e6, | |
| magenta: 0xff00ff, | |
| maroon: 0x800000, | |
| mediumaquamarine: 0x66cdaa, | |
| mediumblue: 0x0000cd, | |
| mediumorchid: 0xba55d3, | |
| mediumpurple: 0x9370db, | |
| mediumseagreen: 0x3cb371, | |
| mediumslateblue: 0x7b68ee, | |
| mediumspringgreen: 0x00fa9a, | |
| mediumturquoise: 0x48d1cc, | |
| mediumvioletred: 0xc71585, | |
| midnightblue: 0x191970, | |
| mintcream: 0xf5fffa, | |
| mistyrose: 0xffe4e1, | |
| moccasin: 0xffe4b5, | |
| navajowhite: 0xffdead, | |
| navy: 0x000080, | |
| oldlace: 0xfdf5e6, | |
| olive: 0x808000, | |
| olivedrab: 0x6b8e23, | |
| orange: 0xffa500, | |
| orangered: 0xff4500, | |
| orchid: 0xda70d6, | |
| palegoldenrod: 0xeee8aa, | |
| palegreen: 0x98fb98, | |
| paleturquoise: 0xafeeee, | |
| palevioletred: 0xdb7093, | |
| papayawhip: 0xffefd5, | |
| peachpuff: 0xffdab9, | |
| peru: 0xcd853f, | |
| pink: 0xffc0cb, | |
| plum: 0xdda0dd, | |
| powderblue: 0xb0e0e6, | |
| purple: 0x800080, | |
| rebeccapurple: 0x663399, | |
| red: 0xff0000, | |
| rosybrown: 0xbc8f8f, | |
| royalblue: 0x4169e1, | |
| saddlebrown: 0x8b4513, | |
| salmon: 0xfa8072, | |
| sandybrown: 0xf4a460, | |
| seagreen: 0x2e8b57, | |
| seashell: 0xfff5ee, | |
| sienna: 0xa0522d, | |
| silver: 0xc0c0c0, | |
| skyblue: 0x87ceeb, | |
| slateblue: 0x6a5acd, | |
| slategray: 0x708090, | |
| slategrey: 0x708090, | |
| snow: 0xfffafa, | |
| springgreen: 0x00ff7f, | |
| steelblue: 0x4682b4, | |
| tan: 0xd2b48c, | |
| teal: 0x008080, | |
| thistle: 0xd8bfd8, | |
| tomato: 0xff6347, | |
| turquoise: 0x40e0d0, | |
| violet: 0xee82ee, | |
| wheat: 0xf5deb3, | |
| white: 0xffffff, | |
| whitesmoke: 0xf5f5f5, | |
| yellow: 0xffff00, | |
| yellowgreen: 0x9acd32 | |
| }; | |
| define(Color, color, { | |
| displayable: function() { | |
| return this.rgb().displayable(); | |
| }, | |
| toString: function() { | |
| return this.rgb() + ""; | |
| } | |
| }); | |
| function color(format) { | |
| var m; | |
| format = (format + "").trim().toLowerCase(); | |
| return (m = reHex3.exec(format)) ? (m = parseInt(m[1], 16), new Rgb((m >> 8 & 0xf) | (m >> 4 & 0x0f0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1)) // #f00 | |
| : (m = reHex6.exec(format)) ? rgbn(parseInt(m[1], 16)) // #ff0000 | |
| : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0) | |
| : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%) | |
| : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1) | |
| : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1) | |
| : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%) | |
| : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1) | |
| : named.hasOwnProperty(format) ? rgbn(named[format]) | |
| : format === "transparent" ? new Rgb(NaN, NaN, NaN, 0) | |
| : null; | |
| } | |
| function rgbn(n) { | |
| return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1); | |
| } | |
| function rgba(r, g, b, a) { | |
| if (a <= 0) r = g = b = NaN; | |
| return new Rgb(r, g, b, a); | |
| } | |
| function rgbConvert(o) { | |
| if (!(o instanceof Color)) o = color(o); | |
| if (!o) return new Rgb; | |
| o = o.rgb(); | |
| return new Rgb(o.r, o.g, o.b, o.opacity); | |
| } | |
| function rgb(r, g, b, opacity) { | |
| return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity); | |
| } | |
| function Rgb(r, g, b, opacity) { | |
| this.r = +r; | |
| this.g = +g; | |
| this.b = +b; | |
| this.opacity = +opacity; | |
| } | |
| define(Rgb, rgb, extend(Color, { | |
| brighter: function(k) { | |
| k = k == null ? brighter : Math.pow(brighter, k); | |
| return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); | |
| }, | |
| darker: function(k) { | |
| k = k == null ? darker : Math.pow(darker, k); | |
| return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); | |
| }, | |
| rgb: function() { | |
| return this; | |
| }, | |
| displayable: function() { | |
| return (0 <= this.r && this.r <= 255) | |
| && (0 <= this.g && this.g <= 255) | |
| && (0 <= this.b && this.b <= 255) | |
| && (0 <= this.opacity && this.opacity <= 1); | |
| }, | |
| toString: function() { | |
| var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a)); | |
| return (a === 1 ? "rgb(" : "rgba(") | |
| + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", " | |
| + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", " | |
| + Math.max(0, Math.min(255, Math.round(this.b) || 0)) | |
| + (a === 1 ? ")" : ", " + a + ")"); | |
| } | |
| })); | |
| function hsla(h, s, l, a) { | |
| if (a <= 0) h = s = l = NaN; | |
| else if (l <= 0 || l >= 1) h = s = NaN; | |
| else if (s <= 0) h = NaN; | |
| return new Hsl(h, s, l, a); | |
| } | |
| function hslConvert(o) { | |
| if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity); | |
| if (!(o instanceof Color)) o = color(o); | |
| if (!o) return new Hsl; | |
| if (o instanceof Hsl) return o; | |
| o = o.rgb(); | |
| var r = o.r / 255, | |
| g = o.g / 255, | |
| b = o.b / 255, | |
| min = Math.min(r, g, b), | |
| max = Math.max(r, g, b), | |
| h = NaN, | |
| s = max - min, | |
| l = (max + min) / 2; | |
| if (s) { | |
| if (r === max) h = (g - b) / s + (g < b) * 6; | |
| else if (g === max) h = (b - r) / s + 2; | |
| else h = (r - g) / s + 4; | |
| s /= l < 0.5 ? max + min : 2 - max - min; | |
| h *= 60; | |
| } else { | |
| s = l > 0 && l < 1 ? 0 : h; | |
| } | |
| return new Hsl(h, s, l, o.opacity); | |
| } | |
| function hsl(h, s, l, opacity) { | |
| return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity); | |
| } | |
| function Hsl(h, s, l, opacity) { | |
| this.h = +h; | |
| this.s = +s; | |
| this.l = +l; | |
| this.opacity = +opacity; | |
| } | |
| define(Hsl, hsl, extend(Color, { | |
| brighter: function(k) { | |
| k = k == null ? brighter : Math.pow(brighter, k); | |
| return new Hsl(this.h, this.s, this.l * k, this.opacity); | |
| }, | |
| darker: function(k) { | |
| k = k == null ? darker : Math.pow(darker, k); | |
| return new Hsl(this.h, this.s, this.l * k, this.opacity); | |
| }, | |
| rgb: function() { | |
| var h = this.h % 360 + (this.h < 0) * 360, | |
| s = isNaN(h) || isNaN(this.s) ? 0 : this.s, | |
| l = this.l, | |
| m2 = l + (l < 0.5 ? l : 1 - l) * s, | |
| m1 = 2 * l - m2; | |
| return new Rgb( | |
| hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), | |
| hsl2rgb(h, m1, m2), | |
| hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), | |
| this.opacity | |
| ); | |
| }, | |
| displayable: function() { | |
| return (0 <= this.s && this.s <= 1 || isNaN(this.s)) | |
| && (0 <= this.l && this.l <= 1) | |
| && (0 <= this.opacity && this.opacity <= 1); | |
| } | |
| })); | |
| /* From FvD 13.37, CSS Color Module Level 3 */ | |
| function hsl2rgb(h, m1, m2) { | |
| return (h < 60 ? m1 + (m2 - m1) * h / 60 | |
| : h < 180 ? m2 | |
| : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 | |
| : m1) * 255; | |
| } | |
| var deg2rad = Math.PI / 180; | |
| var rad2deg = 180 / Math.PI; | |
| var Kn = 18; | |
| var Xn = 0.950470; | |
| var Yn = 1; | |
| var Zn = 1.088830; | |
| var t0 = 4 / 29; | |
| var t1 = 6 / 29; | |
| var t2 = 3 * t1 * t1; | |
| var t3 = t1 * t1 * t1; | |
| function labConvert(o) { | |
| if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity); | |
| if (o instanceof Hcl) { | |
| var h = o.h * deg2rad; | |
| return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity); | |
| } | |
| if (!(o instanceof Rgb)) o = rgbConvert(o); | |
| var b = rgb2xyz(o.r), | |
| a = rgb2xyz(o.g), | |
| l = rgb2xyz(o.b), | |
| x = xyz2lab((0.4124564 * b + 0.3575761 * a + 0.1804375 * l) / Xn), | |
| y = xyz2lab((0.2126729 * b + 0.7151522 * a + 0.0721750 * l) / Yn), | |
| z = xyz2lab((0.0193339 * b + 0.1191920 * a + 0.9503041 * l) / Zn); | |
| return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity); | |
| } | |
| function lab(l, a, b, opacity) { | |
| return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity); | |
| } | |
| function Lab(l, a, b, opacity) { | |
| this.l = +l; | |
| this.a = +a; | |
| this.b = +b; | |
| this.opacity = +opacity; | |
| } | |
| define(Lab, lab, extend(Color, { | |
| brighter: function(k) { | |
| return new Lab(this.l + Kn * (k == null ? 1 : k), this.a, this.b, this.opacity); | |
| }, | |
| darker: function(k) { | |
| return new Lab(this.l - Kn * (k == null ? 1 : k), this.a, this.b, this.opacity); | |
| }, | |
| rgb: function() { | |
| var y = (this.l + 16) / 116, | |
| x = isNaN(this.a) ? y : y + this.a / 500, | |
| z = isNaN(this.b) ? y : y - this.b / 200; | |
| y = Yn * lab2xyz(y); | |
| x = Xn * lab2xyz(x); | |
| z = Zn * lab2xyz(z); | |
| return new Rgb( | |
| xyz2rgb( 3.2404542 * x - 1.5371385 * y - 0.4985314 * z), // D65 -> sRGB | |
| xyz2rgb(-0.9692660 * x + 1.8760108 * y + 0.0415560 * z), | |
| xyz2rgb( 0.0556434 * x - 0.2040259 * y + 1.0572252 * z), | |
| this.opacity | |
| ); | |
| } | |
| })); | |
| function xyz2lab(t) { | |
| return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0; | |
| } | |
| function lab2xyz(t) { | |
| return t > t1 ? t * t * t : t2 * (t - t0); | |
| } | |
| function xyz2rgb(x) { | |
| return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055); | |
| } | |
| function rgb2xyz(x) { | |
| return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4); | |
| } | |
| function hclConvert(o) { | |
| if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity); | |
| if (!(o instanceof Lab)) o = labConvert(o); | |
| var h = Math.atan2(o.b, o.a) * rad2deg; | |
| return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity); | |
| } | |
| function hcl(h, c, l, opacity) { | |
| return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity); | |
| } | |
| function Hcl(h, c, l, opacity) { | |
| this.h = +h; | |
| this.c = +c; | |
| this.l = +l; | |
| this.opacity = +opacity; | |
| } | |
| define(Hcl, hcl, extend(Color, { | |
| brighter: function(k) { | |
| return new Hcl(this.h, this.c, this.l + Kn * (k == null ? 1 : k), this.opacity); | |
| }, | |
| darker: function(k) { | |
| return new Hcl(this.h, this.c, this.l - Kn * (k == null ? 1 : k), this.opacity); | |
| }, | |
| rgb: function() { | |
| return labConvert(this).rgb(); | |
| } | |
| })); | |
| var A = -0.14861; | |
| var B = +1.78277; | |
| var C = -0.29227; | |
| var D = -0.90649; | |
| var E = +1.97294; | |
| var ED = E * D; | |
| var EB = E * B; | |
| var BC_DA = B * C - D * A; | |
| function cubehelixConvert(o) { | |
| if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity); | |
| if (!(o instanceof Rgb)) o = rgbConvert(o); | |
| var r = o.r / 255, | |
| g = o.g / 255, | |
| b = o.b / 255, | |
| l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB), | |
| bl = b - l, | |
| k = (E * (g - l) - C * bl) / D, | |
| s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1 | |
| h = s ? Math.atan2(k, bl) * rad2deg - 120 : NaN; | |
| return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity); | |
| } | |
| function cubehelix(h, s, l, opacity) { | |
| return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity); | |
| } | |
| function Cubehelix(h, s, l, opacity) { | |
| this.h = +h; | |
| this.s = +s; | |
| this.l = +l; | |
| this.opacity = +opacity; | |
| } | |
| define(Cubehelix, cubehelix, extend(Color, { | |
| brighter: function(k) { | |
| k = k == null ? brighter : Math.pow(brighter, k); | |
| return new Cubehelix(this.h, this.s, this.l * k, this.opacity); | |
| }, | |
| darker: function(k) { | |
| k = k == null ? darker : Math.pow(darker, k); | |
| return new Cubehelix(this.h, this.s, this.l * k, this.opacity); | |
| }, | |
| rgb: function() { | |
| var h = isNaN(this.h) ? 0 : (this.h + 120) * deg2rad, | |
| l = +this.l, | |
| a = isNaN(this.s) ? 0 : this.s * l * (1 - l), | |
| cosh = Math.cos(h), | |
| sinh = Math.sin(h); | |
| return new Rgb( | |
| 255 * (l + a * (A * cosh + B * sinh)), | |
| 255 * (l + a * (C * cosh + D * sinh)), | |
| 255 * (l + a * (E * cosh)), | |
| this.opacity | |
| ); | |
| } | |
| })); | |
| exports.color = color; | |
| exports.rgb = rgb; | |
| exports.hsl = hsl; | |
| exports.lab = lab; | |
| exports.hcl = hcl; | |
| exports.cubehelix = cubehelix; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| }))); | |
| },{}],6:[function(require,module,exports){ | |
| // https://d3js.org/d3-format/ Version 1.2.1. Copyright 2017 Mike Bostock. | |
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : | |
| typeof define === 'function' && define.amd ? define(['exports'], factory) : | |
| (factory((global.d3 = global.d3 || {}))); | |
| }(this, (function (exports) { 'use strict'; | |
| // Computes the decimal coefficient and exponent of the specified number x with | |
| // significant digits p, where x is positive and p is in [1, 21] or undefined. | |
| // For example, formatDecimal(1.23) returns ["123", 0]. | |
| var formatDecimal = function(x, p) { | |
| if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e")) < 0) return null; // NaN, ±Infinity | |
| var i, coefficient = x.slice(0, i); | |
| // The string returned by toExponential either has the form \d\.\d+e[-+]\d+ | |
| // (e.g., 1.2e+3) or the form \de[-+]\d+ (e.g., 1e+3). | |
| return [ | |
| coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient, | |
| +x.slice(i + 1) | |
| ]; | |
| }; | |
| var exponent = function(x) { | |
| return x = formatDecimal(Math.abs(x)), x ? x[1] : NaN; | |
| }; | |
| var formatGroup = function(grouping, thousands) { | |
| return function(value, width) { | |
| var i = value.length, | |
| t = [], | |
| j = 0, | |
| g = grouping[0], | |
| length = 0; | |
| while (i > 0 && g > 0) { | |
| if (length + g + 1 > width) g = Math.max(1, width - length); | |
| t.push(value.substring(i -= g, i + g)); | |
| if ((length += g + 1) > width) break; | |
| g = grouping[j = (j + 1) % grouping.length]; | |
| } | |
| return t.reverse().join(thousands); | |
| }; | |
| }; | |
| var formatNumerals = function(numerals) { | |
| return function(value) { | |
| return value.replace(/[0-9]/g, function(i) { | |
| return numerals[+i]; | |
| }); | |
| }; | |
| }; | |
| var formatDefault = function(x, p) { | |
| x = x.toPrecision(p); | |
| out: for (var n = x.length, i = 1, i0 = -1, i1; i < n; ++i) { | |
| switch (x[i]) { | |
| case ".": i0 = i1 = i; break; | |
| case "0": if (i0 === 0) i0 = i; i1 = i; break; | |
| case "e": break out; | |
| default: if (i0 > 0) i0 = 0; break; | |
| } | |
| } | |
| return i0 > 0 ? x.slice(0, i0) + x.slice(i1 + 1) : x; | |
| }; | |
| var prefixExponent; | |
| var formatPrefixAuto = function(x, p) { | |
| var d = formatDecimal(x, p); | |
| if (!d) return x + ""; | |
| var coefficient = d[0], | |
| exponent = d[1], | |
| i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1, | |
| n = coefficient.length; | |
| return i === n ? coefficient | |
| : i > n ? coefficient + new Array(i - n + 1).join("0") | |
| : i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i) | |
| : "0." + new Array(1 - i).join("0") + formatDecimal(x, Math.max(0, p + i - 1))[0]; // less than 1y! | |
| }; | |
| var formatRounded = function(x, p) { | |
| var d = formatDecimal(x, p); | |
| if (!d) return x + ""; | |
| var coefficient = d[0], | |
| exponent = d[1]; | |
| return exponent < 0 ? "0." + new Array(-exponent).join("0") + coefficient | |
| : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + "." + coefficient.slice(exponent + 1) | |
| : coefficient + new Array(exponent - coefficient.length + 2).join("0"); | |
| }; | |
| var formatTypes = { | |
| "": formatDefault, | |
| "%": function(x, p) { return (x * 100).toFixed(p); }, | |
| "b": function(x) { return Math.round(x).toString(2); }, | |
| "c": function(x) { return x + ""; }, | |
| "d": function(x) { return Math.round(x).toString(10); }, | |
| "e": function(x, p) { return x.toExponential(p); }, | |
| "f": function(x, p) { return x.toFixed(p); }, | |
| "g": function(x, p) { return x.toPrecision(p); }, | |
| "o": function(x) { return Math.round(x).toString(8); }, | |
| "p": function(x, p) { return formatRounded(x * 100, p); }, | |
| "r": formatRounded, | |
| "s": formatPrefixAuto, | |
| "X": function(x) { return Math.round(x).toString(16).toUpperCase(); }, | |
| "x": function(x) { return Math.round(x).toString(16); } | |
| }; | |
| // [[fill]align][sign][symbol][0][width][,][.precision][type] | |
| var re = /^(?:(.)?([<>=^]))?([+\-\( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?([a-z%])?$/i; | |
| function formatSpecifier(specifier) { | |
| return new FormatSpecifier(specifier); | |
| } | |
| formatSpecifier.prototype = FormatSpecifier.prototype; // instanceof | |
| function FormatSpecifier(specifier) { | |
| if (!(match = re.exec(specifier))) throw new Error("invalid format: " + specifier); | |
| var match, | |
| fill = match[1] || " ", | |
| align = match[2] || ">", | |
| sign = match[3] || "-", | |
| symbol = match[4] || "", | |
| zero = !!match[5], | |
| width = match[6] && +match[6], | |
| comma = !!match[7], | |
| precision = match[8] && +match[8].slice(1), | |
| type = match[9] || ""; | |
| // The "n" type is an alias for ",g". | |
| if (type === "n") comma = true, type = "g"; | |
| // Map invalid types to the default format. | |
| else if (!formatTypes[type]) type = ""; | |
| // If zero fill is specified, padding goes after sign and before digits. | |
| if (zero || (fill === "0" && align === "=")) zero = true, fill = "0", align = "="; | |
| this.fill = fill; | |
| this.align = align; | |
| this.sign = sign; | |
| this.symbol = symbol; | |
| this.zero = zero; | |
| this.width = width; | |
| this.comma = comma; | |
| this.precision = precision; | |
| this.type = type; | |
| } | |
| FormatSpecifier.prototype.toString = function() { | |
| return this.fill | |
| + this.align | |
| + this.sign | |
| + this.symbol | |
| + (this.zero ? "0" : "") | |
| + (this.width == null ? "" : Math.max(1, this.width | 0)) | |
| + (this.comma ? "," : "") | |
| + (this.precision == null ? "" : "." + Math.max(0, this.precision | 0)) | |
| + this.type; | |
| }; | |
| var identity = function(x) { | |
| return x; | |
| }; | |
| var prefixes = ["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"]; | |
| var formatLocale = function(locale) { | |
| var group = locale.grouping && locale.thousands ? formatGroup(locale.grouping, locale.thousands) : identity, | |
| currency = locale.currency, | |
| decimal = locale.decimal, | |
| numerals = locale.numerals ? formatNumerals(locale.numerals) : identity, | |
| percent = locale.percent || "%"; | |
| function newFormat(specifier) { | |
| specifier = formatSpecifier(specifier); | |
| var fill = specifier.fill, | |
| align = specifier.align, | |
| sign = specifier.sign, | |
| symbol = specifier.symbol, | |
| zero = specifier.zero, | |
| width = specifier.width, | |
| comma = specifier.comma, | |
| precision = specifier.precision, | |
| type = specifier.type; | |
| // Compute the prefix and suffix. | |
| // For SI-prefix, the suffix is lazily computed. | |
| var prefix = symbol === "$" ? currency[0] : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "", | |
| suffix = symbol === "$" ? currency[1] : /[%p]/.test(type) ? percent : ""; | |
| // What format function should we use? | |
| // Is this an integer type? | |
| // Can this type generate exponential notation? | |
| var formatType = formatTypes[type], | |
| maybeSuffix = !type || /[defgprs%]/.test(type); | |
| // Set the default precision if not specified, | |
| // or clamp the specified precision to the supported range. | |
| // For significant precision, it must be in [1, 21]. | |
| // For fixed precision, it must be in [0, 20]. | |
| precision = precision == null ? (type ? 6 : 12) | |
| : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision)) | |
| : Math.max(0, Math.min(20, precision)); | |
| function format(value) { | |
| var valuePrefix = prefix, | |
| valueSuffix = suffix, | |
| i, n, c; | |
| if (type === "c") { | |
| valueSuffix = formatType(value) + valueSuffix; | |
| value = ""; | |
| } else { | |
| value = +value; | |
| // Perform the initial formatting. | |
| var valueNegative = value < 0; | |
| value = formatType(Math.abs(value), precision); | |
| // If a negative value rounds to zero during formatting, treat as positive. | |
| if (valueNegative && +value === 0) valueNegative = false; | |
| // Compute the prefix and suffix. | |
| valuePrefix = (valueNegative ? (sign === "(" ? sign : "-") : sign === "-" || sign === "(" ? "" : sign) + valuePrefix; | |
| valueSuffix = valueSuffix + (type === "s" ? prefixes[8 + prefixExponent / 3] : "") + (valueNegative && sign === "(" ? ")" : ""); | |
| // Break the formatted value into the integer “value” part that can be | |
| // grouped, and fractional or exponential “suffix” part that is not. | |
| if (maybeSuffix) { | |
| i = -1, n = value.length; | |
| while (++i < n) { | |
| if (c = value.charCodeAt(i), 48 > c || c > 57) { | |
| valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix; | |
| value = value.slice(0, i); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| // If the fill character is not "0", grouping is applied before padding. | |
| if (comma && !zero) value = group(value, Infinity); | |
| // Compute the padding. | |
| var length = valuePrefix.length + value.length + valueSuffix.length, | |
| padding = length < width ? new Array(width - length + 1).join(fill) : ""; | |
| // If the fill character is "0", grouping is applied after padding. | |
| if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = ""; | |
| // Reconstruct the final output based on the desired alignment. | |
| switch (align) { | |
| case "<": value = valuePrefix + value + valueSuffix + padding; break; | |
| case "=": value = valuePrefix + padding + value + valueSuffix; break; | |
| case "^": value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length); break; | |
| default: value = padding + valuePrefix + value + valueSuffix; break; | |
| } | |
| return numerals(value); | |
| } | |
| format.toString = function() { | |
| return specifier + ""; | |
| }; | |
| return format; | |
| } | |
| function formatPrefix(specifier, value) { | |
| var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = "f", specifier)), | |
| e = Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3, | |
| k = Math.pow(10, -e), | |
| prefix = prefixes[8 + e / 3]; | |
| return function(value) { | |
| return f(k * value) + prefix; | |
| }; | |
| } | |
| return { | |
| format: newFormat, | |
| formatPrefix: formatPrefix | |
| }; | |
| }; | |
| var locale; | |
| defaultLocale({ | |
| decimal: ".", | |
| thousands: ",", | |
| grouping: [3], | |
| currency: ["$", ""] | |
| }); | |
| function defaultLocale(definition) { | |
| locale = formatLocale(definition); | |
| exports.format = locale.format; | |
| exports.formatPrefix = locale.formatPrefix; | |
| return locale; | |
| } | |
| var precisionFixed = function(step) { | |
| return Math.max(0, -exponent(Math.abs(step))); | |
| }; | |
| var precisionPrefix = function(step, value) { | |
| return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3 - exponent(Math.abs(step))); | |
| }; | |
| var precisionRound = function(step, max) { | |
| step = Math.abs(step), max = Math.abs(max) - step; | |
| return Math.max(0, exponent(max) - exponent(step)) + 1; | |
| }; | |
| exports.formatDefaultLocale = defaultLocale; | |
| exports.formatLocale = formatLocale; | |
| exports.formatSpecifier = formatSpecifier; | |
| exports.precisionFixed = precisionFixed; | |
| exports.precisionPrefix = precisionPrefix; | |
| exports.precisionRound = precisionRound; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| }))); | |
| },{}],7:[function(require,module,exports){ | |
| // https://d3js.org/d3-interpolate/ Version 1.1.6. Copyright 2017 Mike Bostock. | |
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-color')) : | |
| typeof define === 'function' && define.amd ? define(['exports', 'd3-color'], factory) : | |
| (factory((global.d3 = global.d3 || {}),global.d3)); | |
| }(this, (function (exports,d3Color) { 'use strict'; | |
| function basis(t1, v0, v1, v2, v3) { | |
| var t2 = t1 * t1, t3 = t2 * t1; | |
| return ((1 - 3 * t1 + 3 * t2 - t3) * v0 | |
| + (4 - 6 * t2 + 3 * t3) * v1 | |
| + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2 | |
| + t3 * v3) / 6; | |
| } | |
| var basis$1 = function(values) { | |
| var n = values.length - 1; | |
| return function(t) { | |
| var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n), | |
| v1 = values[i], | |
| v2 = values[i + 1], | |
| v0 = i > 0 ? values[i - 1] : 2 * v1 - v2, | |
| v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1; | |
| return basis((t - i / n) * n, v0, v1, v2, v3); | |
| }; | |
| }; | |
| var basisClosed = function(values) { | |
| var n = values.length; | |
| return function(t) { | |
| var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n), | |
| v0 = values[(i + n - 1) % n], | |
| v1 = values[i % n], | |
| v2 = values[(i + 1) % n], | |
| v3 = values[(i + 2) % n]; | |
| return basis((t - i / n) * n, v0, v1, v2, v3); | |
| }; | |
| }; | |
| var constant = function(x) { | |
| return function() { | |
| return x; | |
| }; | |
| }; | |
| function linear(a, d) { | |
| return function(t) { | |
| return a + t * d; | |
| }; | |
| } | |
| function exponential(a, b, y) { | |
| return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) { | |
| return Math.pow(a + t * b, y); | |
| }; | |
| } | |
| function hue(a, b) { | |
| var d = b - a; | |
| return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : constant(isNaN(a) ? b : a); | |
| } | |
| function gamma(y) { | |
| return (y = +y) === 1 ? nogamma : function(a, b) { | |
| return b - a ? exponential(a, b, y) : constant(isNaN(a) ? b : a); | |
| }; | |
| } | |
| function nogamma(a, b) { | |
| var d = b - a; | |
| return d ? linear(a, d) : constant(isNaN(a) ? b : a); | |
| } | |
| var rgb$1 = ((function rgbGamma(y) { | |
| var color$$1 = gamma(y); | |
| function rgb$$1(start, end) { | |
| var r = color$$1((start = d3Color.rgb(start)).r, (end = d3Color.rgb(end)).r), | |
| g = color$$1(start.g, end.g), | |
| b = color$$1(start.b, end.b), | |
| opacity = nogamma(start.opacity, end.opacity); | |
| return function(t) { | |
| start.r = r(t); | |
| start.g = g(t); | |
| start.b = b(t); | |
| start.opacity = opacity(t); | |
| return start + ""; | |
| }; | |
| } | |
| rgb$$1.gamma = rgbGamma; | |
| return rgb$$1; | |
| }))(1); | |
| function rgbSpline(spline) { | |
| return function(colors) { | |
| var n = colors.length, | |
| r = new Array(n), | |
| g = new Array(n), | |
| b = new Array(n), | |
| i, color$$1; | |
| for (i = 0; i < n; ++i) { | |
| color$$1 = d3Color.rgb(colors[i]); | |
| r[i] = color$$1.r || 0; | |
| g[i] = color$$1.g || 0; | |
| b[i] = color$$1.b || 0; | |
| } | |
| r = spline(r); | |
| g = spline(g); | |
| b = spline(b); | |
| color$$1.opacity = 1; | |
| return function(t) { | |
| color$$1.r = r(t); | |
| color$$1.g = g(t); | |
| color$$1.b = b(t); | |
| return color$$1 + ""; | |
| }; | |
| }; | |
| } | |
| var rgbBasis = rgbSpline(basis$1); | |
| var rgbBasisClosed = rgbSpline(basisClosed); | |
| var array = function(a, b) { | |
| var nb = b ? b.length : 0, | |
| na = a ? Math.min(nb, a.length) : 0, | |
| x = new Array(na), | |
| c = new Array(nb), | |
| i; | |
| for (i = 0; i < na; ++i) x[i] = value(a[i], b[i]); | |
| for (; i < nb; ++i) c[i] = b[i]; | |
| return function(t) { | |
| for (i = 0; i < na; ++i) c[i] = x[i](t); | |
| return c; | |
| }; | |
| }; | |
| var date = function(a, b) { | |
| var d = new Date; | |
| return a = +a, b -= a, function(t) { | |
| return d.setTime(a + b * t), d; | |
| }; | |
| }; | |
| var number = function(a, b) { | |
| return a = +a, b -= a, function(t) { | |
| return a + b * t; | |
| }; | |
| }; | |
| var object = function(a, b) { | |
| var i = {}, | |
| c = {}, | |
| k; | |
| if (a === null || typeof a !== "object") a = {}; | |
| if (b === null || typeof b !== "object") b = {}; | |
| for (k in b) { | |
| if (k in a) { | |
| i[k] = value(a[k], b[k]); | |
| } else { | |
| c[k] = b[k]; | |
| } | |
| } | |
| return function(t) { | |
| for (k in i) c[k] = i[k](t); | |
| return c; | |
| }; | |
| }; | |
| var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g; | |
| var reB = new RegExp(reA.source, "g"); | |
| function zero(b) { | |
| return function() { | |
| return b; | |
| }; | |
| } | |
| function one(b) { | |
| return function(t) { | |
| return b(t) + ""; | |
| }; | |
| } | |
| var string = function(a, b) { | |
| var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b | |
| am, // current match in a | |
| bm, // current match in b | |
| bs, // string preceding current number in b, if any | |
| i = -1, // index in s | |
| s = [], // string constants and placeholders | |
| q = []; // number interpolators | |
| // Coerce inputs to strings. | |
| a = a + "", b = b + ""; | |
| // Interpolate pairs of numbers in a & b. | |
| while ((am = reA.exec(a)) | |
| && (bm = reB.exec(b))) { | |
| if ((bs = bm.index) > bi) { // a string precedes the next number in b | |
| bs = b.slice(bi, bs); | |
| if (s[i]) s[i] += bs; // coalesce with previous string | |
| else s[++i] = bs; | |
| } | |
| if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match | |
| if (s[i]) s[i] += bm; // coalesce with previous string | |
| else s[++i] = bm; | |
| } else { // interpolate non-matching numbers | |
| s[++i] = null; | |
| q.push({i: i, x: number(am, bm)}); | |
| } | |
| bi = reB.lastIndex; | |
| } | |
| // Add remains of b. | |
| if (bi < b.length) { | |
| bs = b.slice(bi); | |
| if (s[i]) s[i] += bs; // coalesce with previous string | |
| else s[++i] = bs; | |
| } | |
| // Special optimization for only a single match. | |
| // Otherwise, interpolate each of the numbers and rejoin the string. | |
| return s.length < 2 ? (q[0] | |
| ? one(q[0].x) | |
| : zero(b)) | |
| : (b = q.length, function(t) { | |
| for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t); | |
| return s.join(""); | |
| }); | |
| }; | |
| var value = function(a, b) { | |
| var t = typeof b, c; | |
| return b == null || t === "boolean" ? constant(b) | |
| : (t === "number" ? number | |
| : t === "string" ? ((c = d3Color.color(b)) ? (b = c, rgb$1) : string) | |
| : b instanceof d3Color.color ? rgb$1 | |
| : b instanceof Date ? date | |
| : Array.isArray(b) ? array | |
| : typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? object | |
| : number)(a, b); | |
| }; | |
| var round = function(a, b) { | |
| return a = +a, b -= a, function(t) { | |
| return Math.round(a + b * t); | |
| }; | |
| }; | |
| var degrees = 180 / Math.PI; | |
| var identity = { | |
| translateX: 0, | |
| translateY: 0, | |
| rotate: 0, | |
| skewX: 0, | |
| scaleX: 1, | |
| scaleY: 1 | |
| }; | |
| var decompose = function(a, b, c, d, e, f) { | |
| var scaleX, scaleY, skewX; | |
| if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX; | |
| if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX; | |
| if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY; | |
| if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX; | |
| return { | |
| translateX: e, | |
| translateY: f, | |
| rotate: Math.atan2(b, a) * degrees, | |
| skewX: Math.atan(skewX) * degrees, | |
| scaleX: scaleX, | |
| scaleY: scaleY | |
| }; | |
| }; | |
| var cssNode; | |
| var cssRoot; | |
| var cssView; | |
| var svgNode; | |
| function parseCss(value) { | |
| if (value === "none") return identity; | |
| if (!cssNode) cssNode = document.createElement("DIV"), cssRoot = document.documentElement, cssView = document.defaultView; | |
| cssNode.style.transform = value; | |
| value = cssView.getComputedStyle(cssRoot.appendChild(cssNode), null).getPropertyValue("transform"); | |
| cssRoot.removeChild(cssNode); | |
| value = value.slice(7, -1).split(","); | |
| return decompose(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]); | |
| } | |
| function parseSvg(value) { | |
| if (value == null) return identity; | |
| if (!svgNode) svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g"); | |
| svgNode.setAttribute("transform", value); | |
| if (!(value = svgNode.transform.baseVal.consolidate())) return identity; | |
| value = value.matrix; | |
| return decompose(value.a, value.b, value.c, value.d, value.e, value.f); | |
| } | |
| function interpolateTransform(parse, pxComma, pxParen, degParen) { | |
| function pop(s) { | |
| return s.length ? s.pop() + " " : ""; | |
| } | |
| function translate(xa, ya, xb, yb, s, q) { | |
| if (xa !== xb || ya !== yb) { | |
| var i = s.push("translate(", null, pxComma, null, pxParen); | |
| q.push({i: i - 4, x: number(xa, xb)}, {i: i - 2, x: number(ya, yb)}); | |
| } else if (xb || yb) { | |
| s.push("translate(" + xb + pxComma + yb + pxParen); | |
| } | |
| } | |
| function rotate(a, b, s, q) { | |
| if (a !== b) { | |
| if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path | |
| q.push({i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: number(a, b)}); | |
| } else if (b) { | |
| s.push(pop(s) + "rotate(" + b + degParen); | |
| } | |
| } | |
| function skewX(a, b, s, q) { | |
| if (a !== b) { | |
| q.push({i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: number(a, b)}); | |
| } else if (b) { | |
| s.push(pop(s) + "skewX(" + b + degParen); | |
| } | |
| } | |
| function scale(xa, ya, xb, yb, s, q) { | |
| if (xa !== xb || ya !== yb) { | |
| var i = s.push(pop(s) + "scale(", null, ",", null, ")"); | |
| q.push({i: i - 4, x: number(xa, xb)}, {i: i - 2, x: number(ya, yb)}); | |
| } else if (xb !== 1 || yb !== 1) { | |
| s.push(pop(s) + "scale(" + xb + "," + yb + ")"); | |
| } | |
| } | |
| return function(a, b) { | |
| var s = [], // string constants and placeholders | |
| q = []; // number interpolators | |
| a = parse(a), b = parse(b); | |
| translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q); | |
| rotate(a.rotate, b.rotate, s, q); | |
| skewX(a.skewX, b.skewX, s, q); | |
| scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q); | |
| a = b = null; // gc | |
| return function(t) { | |
| var i = -1, n = q.length, o; | |
| while (++i < n) s[(o = q[i]).i] = o.x(t); | |
| return s.join(""); | |
| }; | |
| }; | |
| } | |
| var interpolateTransformCss = interpolateTransform(parseCss, "px, ", "px)", "deg)"); | |
| var interpolateTransformSvg = interpolateTransform(parseSvg, ", ", ")", ")"); | |
| var rho = Math.SQRT2; | |
| var rho2 = 2; | |
| var rho4 = 4; | |
| var epsilon2 = 1e-12; | |
| function cosh(x) { | |
| return ((x = Math.exp(x)) + 1 / x) / 2; | |
| } | |
| function sinh(x) { | |
| return ((x = Math.exp(x)) - 1 / x) / 2; | |
| } | |
| function tanh(x) { | |
| return ((x = Math.exp(2 * x)) - 1) / (x + 1); | |
| } | |
| // p0 = [ux0, uy0, w0] | |
| // p1 = [ux1, uy1, w1] | |
| var zoom = function(p0, p1) { | |
| var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], | |
| ux1 = p1[0], uy1 = p1[1], w1 = p1[2], | |
| dx = ux1 - ux0, | |
| dy = uy1 - uy0, | |
| d2 = dx * dx + dy * dy, | |
| i, | |
| S; | |
| // Special case for u0 ≅ u1. | |
| if (d2 < epsilon2) { | |
| S = Math.log(w1 / w0) / rho; | |
| i = function(t) { | |
| return [ | |
| ux0 + t * dx, | |
| uy0 + t * dy, | |
| w0 * Math.exp(rho * t * S) | |
| ]; | |
| }; | |
| } | |
| // General case. | |
| else { | |
| var d1 = Math.sqrt(d2), | |
| b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1), | |
| b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1), | |
| r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), | |
| r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1); | |
| S = (r1 - r0) / rho; | |
| i = function(t) { | |
| var s = t * S, | |
| coshr0 = cosh(r0), | |
| u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0)); | |
| return [ | |
| ux0 + u * dx, | |
| uy0 + u * dy, | |
| w0 * coshr0 / cosh(rho * s + r0) | |
| ]; | |
| }; | |
| } | |
| i.duration = S * 1000; | |
| return i; | |
| }; | |
| function hsl$1(hue$$1) { | |
| return function(start, end) { | |
| var h = hue$$1((start = d3Color.hsl(start)).h, (end = d3Color.hsl(end)).h), | |
| s = nogamma(start.s, end.s), | |
| l = nogamma(start.l, end.l), | |
| opacity = nogamma(start.opacity, end.opacity); | |
| return function(t) { | |
| start.h = h(t); | |
| start.s = s(t); | |
| start.l = l(t); | |
| start.opacity = opacity(t); | |
| return start + ""; | |
| }; | |
| } | |
| } | |
| var hsl$2 = hsl$1(hue); | |
| var hslLong = hsl$1(nogamma); | |
| function lab$1(start, end) { | |
| var l = nogamma((start = d3Color.lab(start)).l, (end = d3Color.lab(end)).l), | |
| a = nogamma(start.a, end.a), | |
| b = nogamma(start.b, end.b), | |
| opacity = nogamma(start.opacity, end.opacity); | |
| return function(t) { | |
| start.l = l(t); | |
| start.a = a(t); | |
| start.b = b(t); | |
| start.opacity = opacity(t); | |
| return start + ""; | |
| }; | |
| } | |
| function hcl$1(hue$$1) { | |
| return function(start, end) { | |
| var h = hue$$1((start = d3Color.hcl(start)).h, (end = d3Color.hcl(end)).h), | |
| c = nogamma(start.c, end.c), | |
| l = nogamma(start.l, end.l), | |
| opacity = nogamma(start.opacity, end.opacity); | |
| return function(t) { | |
| start.h = h(t); | |
| start.c = c(t); | |
| start.l = l(t); | |
| start.opacity = opacity(t); | |
| return start + ""; | |
| }; | |
| } | |
| } | |
| var hcl$2 = hcl$1(hue); | |
| var hclLong = hcl$1(nogamma); | |
| function cubehelix$1(hue$$1) { | |
| return (function cubehelixGamma(y) { | |
| y = +y; | |
| function cubehelix$$1(start, end) { | |
| var h = hue$$1((start = d3Color.cubehelix(start)).h, (end = d3Color.cubehelix(end)).h), | |
| s = nogamma(start.s, end.s), | |
| l = nogamma(start.l, end.l), | |
| opacity = nogamma(start.opacity, end.opacity); | |
| return function(t) { | |
| start.h = h(t); | |
| start.s = s(t); | |
| start.l = l(Math.pow(t, y)); | |
| start.opacity = opacity(t); | |
| return start + ""; | |
| }; | |
| } | |
| cubehelix$$1.gamma = cubehelixGamma; | |
| return cubehelix$$1; | |
| })(1); | |
| } | |
| var cubehelix$2 = cubehelix$1(hue); | |
| var cubehelixLong = cubehelix$1(nogamma); | |
| var quantize = function(interpolator, n) { | |
| var samples = new Array(n); | |
| for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1)); | |
| return samples; | |
| }; | |
| exports.interpolate = value; | |
| exports.interpolateArray = array; | |
| exports.interpolateBasis = basis$1; | |
| exports.interpolateBasisClosed = basisClosed; | |
| exports.interpolateDate = date; | |
| exports.interpolateNumber = number; | |
| exports.interpolateObject = object; | |
| exports.interpolateRound = round; | |
| exports.interpolateString = string; | |
| exports.interpolateTransformCss = interpolateTransformCss; | |
| exports.interpolateTransformSvg = interpolateTransformSvg; | |
| exports.interpolateZoom = zoom; | |
| exports.interpolateRgb = rgb$1; | |
| exports.interpolateRgbBasis = rgbBasis; | |
| exports.interpolateRgbBasisClosed = rgbBasisClosed; | |
| exports.interpolateHsl = hsl$2; | |
| exports.interpolateHslLong = hslLong; | |
| exports.interpolateLab = lab$1; | |
| exports.interpolateHcl = hcl$2; | |
| exports.interpolateHclLong = hclLong; | |
| exports.interpolateCubehelix = cubehelix$2; | |
| exports.interpolateCubehelixLong = cubehelixLong; | |
| exports.quantize = quantize; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| }))); | |
| },{"d3-color":5}],8:[function(require,module,exports){ | |
| // https://d3js.org/d3-path/ Version 1.0.5. Copyright 2017 Mike Bostock. | |
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : | |
| typeof define === 'function' && define.amd ? define(['exports'], factory) : | |
| (factory((global.d3 = global.d3 || {}))); | |
| }(this, (function (exports) { 'use strict'; | |
| var pi = Math.PI; | |
| var tau = 2 * pi; | |
| var epsilon = 1e-6; | |
| var tauEpsilon = tau - epsilon; | |
| function Path() { | |
| this._x0 = this._y0 = // start of current subpath | |
| this._x1 = this._y1 = null; // end of current subpath | |
| this._ = ""; | |
| } | |
| function path() { | |
| return new Path; | |
| } | |
| Path.prototype = path.prototype = { | |
| constructor: Path, | |
| moveTo: function(x, y) { | |
| this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y); | |
| }, | |
| closePath: function() { | |
| if (this._x1 !== null) { | |
| this._x1 = this._x0, this._y1 = this._y0; | |
| this._ += "Z"; | |
| } | |
| }, | |
| lineTo: function(x, y) { | |
| this._ += "L" + (this._x1 = +x) + "," + (this._y1 = +y); | |
| }, | |
| quadraticCurveTo: function(x1, y1, x, y) { | |
| this._ += "Q" + (+x1) + "," + (+y1) + "," + (this._x1 = +x) + "," + (this._y1 = +y); | |
| }, | |
| bezierCurveTo: function(x1, y1, x2, y2, x, y) { | |
| this._ += "C" + (+x1) + "," + (+y1) + "," + (+x2) + "," + (+y2) + "," + (this._x1 = +x) + "," + (this._y1 = +y); | |
| }, | |
| arcTo: function(x1, y1, x2, y2, r) { | |
| x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r; | |
| var x0 = this._x1, | |
| y0 = this._y1, | |
| x21 = x2 - x1, | |
| y21 = y2 - y1, | |
| x01 = x0 - x1, | |
| y01 = y0 - y1, | |
| l01_2 = x01 * x01 + y01 * y01; | |
| // Is the radius negative? Error. | |
| if (r < 0) throw new Error("negative radius: " + r); | |
| // Is this path empty? Move to (x1,y1). | |
| if (this._x1 === null) { | |
| this._ += "M" + (this._x1 = x1) + "," + (this._y1 = y1); | |
| } | |
| // Or, is (x1,y1) coincident with (x0,y0)? Do nothing. | |
| else if (!(l01_2 > epsilon)) {} | |
| // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear? | |
| // Equivalently, is (x1,y1) coincident with (x2,y2)? | |
| // Or, is the radius zero? Line to (x1,y1). | |
| else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon) || !r) { | |
| this._ += "L" + (this._x1 = x1) + "," + (this._y1 = y1); | |
| } | |
| // Otherwise, draw an arc! | |
| else { | |
| var x20 = x2 - x0, | |
| y20 = y2 - y0, | |
| l21_2 = x21 * x21 + y21 * y21, | |
| l20_2 = x20 * x20 + y20 * y20, | |
| l21 = Math.sqrt(l21_2), | |
| l01 = Math.sqrt(l01_2), | |
| l = r * Math.tan((pi - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2), | |
| t01 = l / l01, | |
| t21 = l / l21; | |
| // If the start tangent is not coincident with (x0,y0), line to. | |
| if (Math.abs(t01 - 1) > epsilon) { | |
| this._ += "L" + (x1 + t01 * x01) + "," + (y1 + t01 * y01); | |
| } | |
| this._ += "A" + r + "," + r + ",0,0," + (+(y01 * x20 > x01 * y20)) + "," + (this._x1 = x1 + t21 * x21) + "," + (this._y1 = y1 + t21 * y21); | |
| } | |
| }, | |
| arc: function(x, y, r, a0, a1, ccw) { | |
| x = +x, y = +y, r = +r; | |
| var dx = r * Math.cos(a0), | |
| dy = r * Math.sin(a0), | |
| x0 = x + dx, | |
| y0 = y + dy, | |
| cw = 1 ^ ccw, | |
| da = ccw ? a0 - a1 : a1 - a0; | |
| // Is the radius negative? Error. | |
| if (r < 0) throw new Error("negative radius: " + r); | |
| // Is this path empty? Move to (x0,y0). | |
| if (this._x1 === null) { | |
| this._ += "M" + x0 + "," + y0; | |
| } | |
| // Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0). | |
| else if (Math.abs(this._x1 - x0) > epsilon || Math.abs(this._y1 - y0) > epsilon) { | |
| this._ += "L" + x0 + "," + y0; | |
| } | |
| // Is this arc empty? We’re done. | |
| if (!r) return; | |
| // Does the angle go the wrong way? Flip the direction. | |
| if (da < 0) da = da % tau + tau; | |
| // Is this a complete circle? Draw two arcs to complete the circle. | |
| if (da > tauEpsilon) { | |
| this._ += "A" + r + "," + r + ",0,1," + cw + "," + (x - dx) + "," + (y - dy) + "A" + r + "," + r + ",0,1," + cw + "," + (this._x1 = x0) + "," + (this._y1 = y0); | |
| } | |
| // Is this arc non-empty? Draw an arc! | |
| else if (da > epsilon) { | |
| this._ += "A" + r + "," + r + ",0," + (+(da >= pi)) + "," + cw + "," + (this._x1 = x + r * Math.cos(a1)) + "," + (this._y1 = y + r * Math.sin(a1)); | |
| } | |
| }, | |
| rect: function(x, y, w, h) { | |
| this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y) + "h" + (+w) + "v" + (+h) + "h" + (-w) + "Z"; | |
| }, | |
| toString: function() { | |
| return this._; | |
| } | |
| }; | |
| exports.path = path; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| }))); | |
| },{}],9:[function(require,module,exports){ | |
| // https://d3js.org/d3-scale-chromatic/ Version 1.1.1. Copyright 2017 Mike Bostock. | |
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-interpolate')) : | |
| typeof define === 'function' && define.amd ? define(['exports', 'd3-interpolate'], factory) : | |
| (factory((global.d3 = global.d3 || {}),global.d3)); | |
| }(this, (function (exports,d3Interpolate) { 'use strict'; | |
| var colors = function(specifier) { | |
| var n = specifier.length / 6 | 0, colors = new Array(n), i = 0; | |
| while (i < n) colors[i] = "#" + specifier.slice(i * 6, ++i * 6); | |
| return colors; | |
| }; | |
| var Accent = colors("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666"); | |
| var Dark2 = colors("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666"); | |
| var Paired = colors("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928"); | |
| var Pastel1 = colors("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2"); | |
| var Pastel2 = colors("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc"); | |
| var Set1 = colors("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999"); | |
| var Set2 = colors("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3"); | |
| var Set3 = colors("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f"); | |
| var ramp = function(scheme) { | |
| return d3Interpolate.interpolateRgbBasis(scheme[scheme.length - 1]); | |
| }; | |
| var scheme = new Array(3).concat( | |
| "d8b365f5f5f55ab4ac", | |
| "a6611adfc27d80cdc1018571", | |
| "a6611adfc27df5f5f580cdc1018571", | |
| "8c510ad8b365f6e8c3c7eae55ab4ac01665e", | |
| "8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e", | |
| "8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e", | |
| "8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e", | |
| "5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30", | |
| "5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30" | |
| ).map(colors); | |
| var BrBG = ramp(scheme); | |
| var scheme$1 = new Array(3).concat( | |
| "af8dc3f7f7f77fbf7b", | |
| "7b3294c2a5cfa6dba0008837", | |
| "7b3294c2a5cff7f7f7a6dba0008837", | |
| "762a83af8dc3e7d4e8d9f0d37fbf7b1b7837", | |
| "762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837", | |
| "762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837", | |
| "762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837", | |
| "40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b", | |
| "40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b" | |
| ).map(colors); | |
| var PRGn = ramp(scheme$1); | |
| var scheme$2 = new Array(3).concat( | |
| "e9a3c9f7f7f7a1d76a", | |
| "d01c8bf1b6dab8e1864dac26", | |
| "d01c8bf1b6daf7f7f7b8e1864dac26", | |
| "c51b7de9a3c9fde0efe6f5d0a1d76a4d9221", | |
| "c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221", | |
| "c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221", | |
| "c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221", | |
| "8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419", | |
| "8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419" | |
| ).map(colors); | |
| var PiYG = ramp(scheme$2); | |
| var scheme$3 = new Array(3).concat( | |
| "998ec3f7f7f7f1a340", | |
| "5e3c99b2abd2fdb863e66101", | |
| "5e3c99b2abd2f7f7f7fdb863e66101", | |
| "542788998ec3d8daebfee0b6f1a340b35806", | |
| "542788998ec3d8daebf7f7f7fee0b6f1a340b35806", | |
| "5427888073acb2abd2d8daebfee0b6fdb863e08214b35806", | |
| "5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806", | |
| "2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08", | |
| "2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08" | |
| ).map(colors); | |
| var PuOr = ramp(scheme$3); | |
| var scheme$4 = new Array(3).concat( | |
| "ef8a62f7f7f767a9cf", | |
| "ca0020f4a58292c5de0571b0", | |
| "ca0020f4a582f7f7f792c5de0571b0", | |
| "b2182bef8a62fddbc7d1e5f067a9cf2166ac", | |
| "b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac", | |
| "b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac", | |
| "b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac", | |
| "67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061", | |
| "67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061" | |
| ).map(colors); | |
| var RdBu = ramp(scheme$4); | |
| var scheme$5 = new Array(3).concat( | |
| "ef8a62ffffff999999", | |
| "ca0020f4a582bababa404040", | |
| "ca0020f4a582ffffffbababa404040", | |
| "b2182bef8a62fddbc7e0e0e09999994d4d4d", | |
| "b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d", | |
| "b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d", | |
| "b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d", | |
| "67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a", | |
| "67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a" | |
| ).map(colors); | |
| var RdGy = ramp(scheme$5); | |
| var scheme$6 = new Array(3).concat( | |
| "fc8d59ffffbf91bfdb", | |
| "d7191cfdae61abd9e92c7bb6", | |
| "d7191cfdae61ffffbfabd9e92c7bb6", | |
| "d73027fc8d59fee090e0f3f891bfdb4575b4", | |
| "d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4", | |
| "d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4", | |
| "d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4", | |
| "a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695", | |
| "a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695" | |
| ).map(colors); | |
| var RdYlBu = ramp(scheme$6); | |
| var scheme$7 = new Array(3).concat( | |
| "fc8d59ffffbf91cf60", | |
| "d7191cfdae61a6d96a1a9641", | |
| "d7191cfdae61ffffbfa6d96a1a9641", | |
| "d73027fc8d59fee08bd9ef8b91cf601a9850", | |
| "d73027fc8d59fee08bffffbfd9ef8b91cf601a9850", | |
| "d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850", | |
| "d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850", | |
| "a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837", | |
| "a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837" | |
| ).map(colors); | |
| var RdYlGn = ramp(scheme$7); | |
| var scheme$8 = new Array(3).concat( | |
| "fc8d59ffffbf99d594", | |
| "d7191cfdae61abdda42b83ba", | |
| "d7191cfdae61ffffbfabdda42b83ba", | |
| "d53e4ffc8d59fee08be6f59899d5943288bd", | |
| "d53e4ffc8d59fee08bffffbfe6f59899d5943288bd", | |
| "d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd", | |
| "d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd", | |
| "9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2", | |
| "9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2" | |
| ).map(colors); | |
| var Spectral = ramp(scheme$8); | |
| var scheme$9 = new Array(3).concat( | |
| "e5f5f999d8c92ca25f", | |
| "edf8fbb2e2e266c2a4238b45", | |
| "edf8fbb2e2e266c2a42ca25f006d2c", | |
| "edf8fbccece699d8c966c2a42ca25f006d2c", | |
| "edf8fbccece699d8c966c2a441ae76238b45005824", | |
| "f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824", | |
| "f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b" | |
| ).map(colors); | |
| var BuGn = ramp(scheme$9); | |
| var scheme$10 = new Array(3).concat( | |
| "e0ecf49ebcda8856a7", | |
| "edf8fbb3cde38c96c688419d", | |
| "edf8fbb3cde38c96c68856a7810f7c", | |
| "edf8fbbfd3e69ebcda8c96c68856a7810f7c", | |
| "edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b", | |
| "f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b", | |
| "f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b" | |
| ).map(colors); | |
| var BuPu = ramp(scheme$10); | |
| var scheme$11 = new Array(3).concat( | |
| "e0f3dba8ddb543a2ca", | |
| "f0f9e8bae4bc7bccc42b8cbe", | |
| "f0f9e8bae4bc7bccc443a2ca0868ac", | |
| "f0f9e8ccebc5a8ddb57bccc443a2ca0868ac", | |
| "f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e", | |
| "f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e", | |
| "f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081" | |
| ).map(colors); | |
| var GnBu = ramp(scheme$11); | |
| var scheme$12 = new Array(3).concat( | |
| "fee8c8fdbb84e34a33", | |
| "fef0d9fdcc8afc8d59d7301f", | |
| "fef0d9fdcc8afc8d59e34a33b30000", | |
| "fef0d9fdd49efdbb84fc8d59e34a33b30000", | |
| "fef0d9fdd49efdbb84fc8d59ef6548d7301f990000", | |
| "fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000", | |
| "fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000" | |
| ).map(colors); | |
| var OrRd = ramp(scheme$12); | |
| var scheme$13 = new Array(3).concat( | |
| "ece2f0a6bddb1c9099", | |
| "f6eff7bdc9e167a9cf02818a", | |
| "f6eff7bdc9e167a9cf1c9099016c59", | |
| "f6eff7d0d1e6a6bddb67a9cf1c9099016c59", | |
| "f6eff7d0d1e6a6bddb67a9cf3690c002818a016450", | |
| "fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450", | |
| "fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636" | |
| ).map(colors); | |
| var PuBuGn = ramp(scheme$13); | |
| var scheme$14 = new Array(3).concat( | |
| "ece7f2a6bddb2b8cbe", | |
| "f1eef6bdc9e174a9cf0570b0", | |
| "f1eef6bdc9e174a9cf2b8cbe045a8d", | |
| "f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d", | |
| "f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b", | |
| "fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b", | |
| "fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858" | |
| ).map(colors); | |
| var PuBu = ramp(scheme$14); | |
| var scheme$15 = new Array(3).concat( | |
| "e7e1efc994c7dd1c77", | |
| "f1eef6d7b5d8df65b0ce1256", | |
| "f1eef6d7b5d8df65b0dd1c77980043", | |
| "f1eef6d4b9dac994c7df65b0dd1c77980043", | |
| "f1eef6d4b9dac994c7df65b0e7298ace125691003f", | |
| "f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f", | |
| "f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f" | |
| ).map(colors); | |
| var PuRd = ramp(scheme$15); | |
| var scheme$16 = new Array(3).concat( | |
| "fde0ddfa9fb5c51b8a", | |
| "feebe2fbb4b9f768a1ae017e", | |
| "feebe2fbb4b9f768a1c51b8a7a0177", | |
| "feebe2fcc5c0fa9fb5f768a1c51b8a7a0177", | |
| "feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177", | |
| "fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177", | |
| "fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a" | |
| ).map(colors); | |
| var RdPu = ramp(scheme$16); | |
| var scheme$17 = new Array(3).concat( | |
| "edf8b17fcdbb2c7fb8", | |
| "ffffcca1dab441b6c4225ea8", | |
| "ffffcca1dab441b6c42c7fb8253494", | |
| "ffffccc7e9b47fcdbb41b6c42c7fb8253494", | |
| "ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84", | |
| "ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84", | |
| "ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58" | |
| ).map(colors); | |
| var YlGnBu = ramp(scheme$17); | |
| var scheme$18 = new Array(3).concat( | |
| "f7fcb9addd8e31a354", | |
| "ffffccc2e69978c679238443", | |
| "ffffccc2e69978c67931a354006837", | |
| "ffffccd9f0a3addd8e78c67931a354006837", | |
| "ffffccd9f0a3addd8e78c67941ab5d238443005a32", | |
| "ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32", | |
| "ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529" | |
| ).map(colors); | |
| var YlGn = ramp(scheme$18); | |
| var scheme$19 = new Array(3).concat( | |
| "fff7bcfec44fd95f0e", | |
| "ffffd4fed98efe9929cc4c02", | |
| "ffffd4fed98efe9929d95f0e993404", | |
| "ffffd4fee391fec44ffe9929d95f0e993404", | |
| "ffffd4fee391fec44ffe9929ec7014cc4c028c2d04", | |
| "ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04", | |
| "ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506" | |
| ).map(colors); | |
| var YlOrBr = ramp(scheme$19); | |
| var scheme$20 = new Array(3).concat( | |
| "ffeda0feb24cf03b20", | |
| "ffffb2fecc5cfd8d3ce31a1c", | |
| "ffffb2fecc5cfd8d3cf03b20bd0026", | |
| "ffffb2fed976feb24cfd8d3cf03b20bd0026", | |
| "ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026", | |
| "ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026", | |
| "ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026" | |
| ).map(colors); | |
| var YlOrRd = ramp(scheme$20); | |
| var scheme$21 = new Array(3).concat( | |
| "deebf79ecae13182bd", | |
| "eff3ffbdd7e76baed62171b5", | |
| "eff3ffbdd7e76baed63182bd08519c", | |
| "eff3ffc6dbef9ecae16baed63182bd08519c", | |
| "eff3ffc6dbef9ecae16baed64292c62171b5084594", | |
| "f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594", | |
| "f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b" | |
| ).map(colors); | |
| var Blues = ramp(scheme$21); | |
| var scheme$22 = new Array(3).concat( | |
| "e5f5e0a1d99b31a354", | |
| "edf8e9bae4b374c476238b45", | |
| "edf8e9bae4b374c47631a354006d2c", | |
| "edf8e9c7e9c0a1d99b74c47631a354006d2c", | |
| "edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32", | |
| "f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32", | |
| "f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b" | |
| ).map(colors); | |
| var Greens = ramp(scheme$22); | |
| var scheme$23 = new Array(3).concat( | |
| "f0f0f0bdbdbd636363", | |
| "f7f7f7cccccc969696525252", | |
| "f7f7f7cccccc969696636363252525", | |
| "f7f7f7d9d9d9bdbdbd969696636363252525", | |
| "f7f7f7d9d9d9bdbdbd969696737373525252252525", | |
| "fffffff0f0f0d9d9d9bdbdbd969696737373525252252525", | |
| "fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000" | |
| ).map(colors); | |
| var Greys = ramp(scheme$23); | |
| var scheme$24 = new Array(3).concat( | |
| "efedf5bcbddc756bb1", | |
| "f2f0f7cbc9e29e9ac86a51a3", | |
| "f2f0f7cbc9e29e9ac8756bb154278f", | |
| "f2f0f7dadaebbcbddc9e9ac8756bb154278f", | |
| "f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486", | |
| "fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486", | |
| "fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d" | |
| ).map(colors); | |
| var Purples = ramp(scheme$24); | |
| var scheme$25 = new Array(3).concat( | |
| "fee0d2fc9272de2d26", | |
| "fee5d9fcae91fb6a4acb181d", | |
| "fee5d9fcae91fb6a4ade2d26a50f15", | |
| "fee5d9fcbba1fc9272fb6a4ade2d26a50f15", | |
| "fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d", | |
| "fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d", | |
| "fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d" | |
| ).map(colors); | |
| var Reds = ramp(scheme$25); | |
| var scheme$26 = new Array(3).concat( | |
| "fee6cefdae6be6550d", | |
| "feeddefdbe85fd8d3cd94701", | |
| "feeddefdbe85fd8d3ce6550da63603", | |
| "feeddefdd0a2fdae6bfd8d3ce6550da63603", | |
| "feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04", | |
| "fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04", | |
| "fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704" | |
| ).map(colors); | |
| var Oranges = ramp(scheme$26); | |
| exports.schemeAccent = Accent; | |
| exports.schemeDark2 = Dark2; | |
| exports.schemePaired = Paired; | |
| exports.schemePastel1 = Pastel1; | |
| exports.schemePastel2 = Pastel2; | |
| exports.schemeSet1 = Set1; | |
| exports.schemeSet2 = Set2; | |
| exports.schemeSet3 = Set3; | |
| exports.interpolateBrBG = BrBG; | |
| exports.schemeBrBG = scheme; | |
| exports.interpolatePRGn = PRGn; | |
| exports.schemePRGn = scheme$1; | |
| exports.interpolatePiYG = PiYG; | |
| exports.schemePiYG = scheme$2; | |
| exports.interpolatePuOr = PuOr; | |
| exports.schemePuOr = scheme$3; | |
| exports.interpolateRdBu = RdBu; | |
| exports.schemeRdBu = scheme$4; | |
| exports.interpolateRdGy = RdGy; | |
| exports.schemeRdGy = scheme$5; | |
| exports.interpolateRdYlBu = RdYlBu; | |
| exports.schemeRdYlBu = scheme$6; | |
| exports.interpolateRdYlGn = RdYlGn; | |
| exports.schemeRdYlGn = scheme$7; | |
| exports.interpolateSpectral = Spectral; | |
| exports.schemeSpectral = scheme$8; | |
| exports.interpolateBuGn = BuGn; | |
| exports.schemeBuGn = scheme$9; | |
| exports.interpolateBuPu = BuPu; | |
| exports.schemeBuPu = scheme$10; | |
| exports.interpolateGnBu = GnBu; | |
| exports.schemeGnBu = scheme$11; | |
| exports.interpolateOrRd = OrRd; | |
| exports.schemeOrRd = scheme$12; | |
| exports.interpolatePuBuGn = PuBuGn; | |
| exports.schemePuBuGn = scheme$13; | |
| exports.interpolatePuBu = PuBu; | |
| exports.schemePuBu = scheme$14; | |
| exports.interpolatePuRd = PuRd; | |
| exports.schemePuRd = scheme$15; | |
| exports.interpolateRdPu = RdPu; | |
| exports.schemeRdPu = scheme$16; | |
| exports.interpolateYlGnBu = YlGnBu; | |
| exports.schemeYlGnBu = scheme$17; | |
| exports.interpolateYlGn = YlGn; | |
| exports.schemeYlGn = scheme$18; | |
| exports.interpolateYlOrBr = YlOrBr; | |
| exports.schemeYlOrBr = scheme$19; | |
| exports.interpolateYlOrRd = YlOrRd; | |
| exports.schemeYlOrRd = scheme$20; | |
| exports.interpolateBlues = Blues; | |
| exports.schemeBlues = scheme$21; | |
| exports.interpolateGreens = Greens; | |
| exports.schemeGreens = scheme$22; | |
| exports.interpolateGreys = Greys; | |
| exports.schemeGreys = scheme$23; | |
| exports.interpolatePurples = Purples; | |
| exports.schemePurples = scheme$24; | |
| exports.interpolateReds = Reds; | |
| exports.schemeReds = scheme$25; | |
| exports.interpolateOranges = Oranges; | |
| exports.schemeOranges = scheme$26; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| }))); | |
| },{"d3-interpolate":7}],10:[function(require,module,exports){ | |
| // https://d3js.org/d3-scale/ Version 1.0.7. Copyright 2017 Mike Bostock. | |
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-array'), require('d3-collection'), require('d3-interpolate'), require('d3-format'), require('d3-time'), require('d3-time-format'), require('d3-color')) : | |
| typeof define === 'function' && define.amd ? define(['exports', 'd3-array', 'd3-collection', 'd3-interpolate', 'd3-format', 'd3-time', 'd3-time-format', 'd3-color'], factory) : | |
| (factory((global.d3 = global.d3 || {}),global.d3,global.d3,global.d3,global.d3,global.d3,global.d3,global.d3)); | |
| }(this, (function (exports,d3Array,d3Collection,d3Interpolate,d3Format,d3Time,d3TimeFormat,d3Color) { 'use strict'; | |
| var array = Array.prototype; | |
| var map$1 = array.map; | |
| var slice = array.slice; | |
| var implicit = {name: "implicit"}; | |
| function ordinal(range$$1) { | |
| var index = d3Collection.map(), | |
| domain = [], | |
| unknown = implicit; | |
| range$$1 = range$$1 == null ? [] : slice.call(range$$1); | |
| function scale(d) { | |
| var key = d + "", i = index.get(key); | |
| if (!i) { | |
| if (unknown !== implicit) return unknown; | |
| index.set(key, i = domain.push(d)); | |
| } | |
| return range$$1[(i - 1) % range$$1.length]; | |
| } | |
| scale.domain = function(_) { | |
| if (!arguments.length) return domain.slice(); | |
| domain = [], index = d3Collection.map(); | |
| var i = -1, n = _.length, d, key; | |
| while (++i < n) if (!index.has(key = (d = _[i]) + "")) index.set(key, domain.push(d)); | |
| return scale; | |
| }; | |
| scale.range = function(_) { | |
| return arguments.length ? (range$$1 = slice.call(_), scale) : range$$1.slice(); | |
| }; | |
| scale.unknown = function(_) { | |
| return arguments.length ? (unknown = _, scale) : unknown; | |
| }; | |
| scale.copy = function() { | |
| return ordinal() | |
| .domain(domain) | |
| .range(range$$1) | |
| .unknown(unknown); | |
| }; | |
| return scale; | |
| } | |
| function band() { | |
| var scale = ordinal().unknown(undefined), | |
| domain = scale.domain, | |
| ordinalRange = scale.range, | |
| range$$1 = [0, 1], | |
| step, | |
| bandwidth, | |
| round = false, | |
| paddingInner = 0, | |
| paddingOuter = 0, | |
| align = 0.5; | |
| delete scale.unknown; | |
| function rescale() { | |
| var n = domain().length, | |
| reverse = range$$1[1] < range$$1[0], | |
| start = range$$1[reverse - 0], | |
| stop = range$$1[1 - reverse]; | |
| step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2); | |
| if (round) step = Math.floor(step); | |
| start += (stop - start - step * (n - paddingInner)) * align; | |
| bandwidth = step * (1 - paddingInner); | |
| if (round) start = Math.round(start), bandwidth = Math.round(bandwidth); | |
| var values = d3Array.range(n).map(function(i) { return start + step * i; }); | |
| return ordinalRange(reverse ? values.reverse() : values); | |
| } | |
| scale.domain = function(_) { | |
| return arguments.length ? (domain(_), rescale()) : domain(); | |
| }; | |
| scale.range = function(_) { | |
| return arguments.length ? (range$$1 = [+_[0], +_[1]], rescale()) : range$$1.slice(); | |
| }; | |
| scale.rangeRound = function(_) { | |
| return range$$1 = [+_[0], +_[1]], round = true, rescale(); | |
| }; | |
| scale.bandwidth = function() { | |
| return bandwidth; | |
| }; | |
| scale.step = function() { | |
| return step; | |
| }; | |
| scale.round = function(_) { | |
| return arguments.length ? (round = !!_, rescale()) : round; | |
| }; | |
| scale.padding = function(_) { | |
| return arguments.length ? (paddingInner = paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingInner; | |
| }; | |
| scale.paddingInner = function(_) { | |
| return arguments.length ? (paddingInner = Math.max(0, Math.min(1, _)), rescale()) : paddingInner; | |
| }; | |
| scale.paddingOuter = function(_) { | |
| return arguments.length ? (paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingOuter; | |
| }; | |
| scale.align = function(_) { | |
| return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align; | |
| }; | |
| scale.copy = function() { | |
| return band() | |
| .domain(domain()) | |
| .range(range$$1) | |
| .round(round) | |
| .paddingInner(paddingInner) | |
| .paddingOuter(paddingOuter) | |
| .align(align); | |
| }; | |
| return rescale(); | |
| } | |
| function pointish(scale) { | |
| var copy = scale.copy; | |
| scale.padding = scale.paddingOuter; | |
| delete scale.paddingInner; | |
| delete scale.paddingOuter; | |
| scale.copy = function() { | |
| return pointish(copy()); | |
| }; | |
| return scale; | |
| } | |
| function point() { | |
| return pointish(band().paddingInner(1)); | |
| } | |
| var constant = function(x) { | |
| return function() { | |
| return x; | |
| }; | |
| }; | |
| var number = function(x) { | |
| return +x; | |
| }; | |
| var unit = [0, 1]; | |
| function deinterpolateLinear(a, b) { | |
| return (b -= (a = +a)) | |
| ? function(x) { return (x - a) / b; } | |
| : constant(b); | |
| } | |
| function deinterpolateClamp(deinterpolate) { | |
| return function(a, b) { | |
| var d = deinterpolate(a = +a, b = +b); | |
| return function(x) { return x <= a ? 0 : x >= b ? 1 : d(x); }; | |
| }; | |
| } | |
| function reinterpolateClamp(reinterpolate) { | |
| return function(a, b) { | |
| var r = reinterpolate(a = +a, b = +b); | |
| return function(t) { return t <= 0 ? a : t >= 1 ? b : r(t); }; | |
| }; | |
| } | |
| function bimap(domain, range$$1, deinterpolate, reinterpolate) { | |
| var d0 = domain[0], d1 = domain[1], r0 = range$$1[0], r1 = range$$1[1]; | |
| if (d1 < d0) d0 = deinterpolate(d1, d0), r0 = reinterpolate(r1, r0); | |
| else d0 = deinterpolate(d0, d1), r0 = reinterpolate(r0, r1); | |
| return function(x) { return r0(d0(x)); }; | |
| } | |
| function polymap(domain, range$$1, deinterpolate, reinterpolate) { | |
| var j = Math.min(domain.length, range$$1.length) - 1, | |
| d = new Array(j), | |
| r = new Array(j), | |
| i = -1; | |
| // Reverse descending domains. | |
| if (domain[j] < domain[0]) { | |
| domain = domain.slice().reverse(); | |
| range$$1 = range$$1.slice().reverse(); | |
| } | |
| while (++i < j) { | |
| d[i] = deinterpolate(domain[i], domain[i + 1]); | |
| r[i] = reinterpolate(range$$1[i], range$$1[i + 1]); | |
| } | |
| return function(x) { | |
| var i = d3Array.bisect(domain, x, 1, j) - 1; | |
| return r[i](d[i](x)); | |
| }; | |
| } | |
| function copy(source, target) { | |
| return target | |
| .domain(source.domain()) | |
| .range(source.range()) | |
| .interpolate(source.interpolate()) | |
| .clamp(source.clamp()); | |
| } | |
| // deinterpolate(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1]. | |
| // reinterpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding domain value x in [a,b]. | |
| function continuous(deinterpolate, reinterpolate) { | |
| var domain = unit, | |
| range$$1 = unit, | |
| interpolate$$1 = d3Interpolate.interpolate, | |
| clamp = false, | |
| piecewise, | |
| output, | |
| input; | |
| function rescale() { | |
| piecewise = Math.min(domain.length, range$$1.length) > 2 ? polymap : bimap; | |
| output = input = null; | |
| return scale; | |
| } | |
| function scale(x) { | |
| return (output || (output = piecewise(domain, range$$1, clamp ? deinterpolateClamp(deinterpolate) : deinterpolate, interpolate$$1)))(+x); | |
| } | |
| scale.invert = function(y) { | |
| return (input || (input = piecewise(range$$1, domain, deinterpolateLinear, clamp ? reinterpolateClamp(reinterpolate) : reinterpolate)))(+y); | |
| }; | |
| scale.domain = function(_) { | |
| return arguments.length ? (domain = map$1.call(_, number), rescale()) : domain.slice(); | |
| }; | |
| scale.range = function(_) { | |
| return arguments.length ? (range$$1 = slice.call(_), rescale()) : range$$1.slice(); | |
| }; | |
| scale.rangeRound = function(_) { | |
| return range$$1 = slice.call(_), interpolate$$1 = d3Interpolate.interpolateRound, rescale(); | |
| }; | |
| scale.clamp = function(_) { | |
| return arguments.length ? (clamp = !!_, rescale()) : clamp; | |
| }; | |
| scale.interpolate = function(_) { | |
| return arguments.length ? (interpolate$$1 = _, rescale()) : interpolate$$1; | |
| }; | |
| return rescale(); | |
| } | |
| var tickFormat = function(domain, count, specifier) { | |
| var start = domain[0], | |
| stop = domain[domain.length - 1], | |
| step = d3Array.tickStep(start, stop, count == null ? 10 : count), | |
| precision; | |
| specifier = d3Format.formatSpecifier(specifier == null ? ",f" : specifier); | |
| switch (specifier.type) { | |
| case "s": { | |
| var value = Math.max(Math.abs(start), Math.abs(stop)); | |
| if (specifier.precision == null && !isNaN(precision = d3Format.precisionPrefix(step, value))) specifier.precision = precision; | |
| return d3Format.formatPrefix(specifier, value); | |
| } | |
| case "": | |
| case "e": | |
| case "g": | |
| case "p": | |
| case "r": { | |
| if (specifier.precision == null && !isNaN(precision = d3Format.precisionRound(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e"); | |
| break; | |
| } | |
| case "f": | |
| case "%": { | |
| if (specifier.precision == null && !isNaN(precision = d3Format.precisionFixed(step))) specifier.precision = precision - (specifier.type === "%") * 2; | |
| break; | |
| } | |
| } | |
| return d3Format.format(specifier); | |
| }; | |
| function linearish(scale) { | |
| var domain = scale.domain; | |
| scale.ticks = function(count) { | |
| var d = domain(); | |
| return d3Array.ticks(d[0], d[d.length - 1], count == null ? 10 : count); | |
| }; | |
| scale.tickFormat = function(count, specifier) { | |
| return tickFormat(domain(), count, specifier); | |
| }; | |
| scale.nice = function(count) { | |
| if (count == null) count = 10; | |
| var d = domain(), | |
| i0 = 0, | |
| i1 = d.length - 1, | |
| start = d[i0], | |
| stop = d[i1], | |
| step; | |
| if (stop < start) { | |
| step = start, start = stop, stop = step; | |
| step = i0, i0 = i1, i1 = step; | |
| } | |
| step = d3Array.tickIncrement(start, stop, count); | |
| if (step > 0) { | |
| start = Math.floor(start / step) * step; | |
| stop = Math.ceil(stop / step) * step; | |
| step = d3Array.tickIncrement(start, stop, count); | |
| } else if (step < 0) { | |
| start = Math.ceil(start * step) / step; | |
| stop = Math.floor(stop * step) / step; | |
| step = d3Array.tickIncrement(start, stop, count); | |
| } | |
| if (step > 0) { | |
| d[i0] = Math.floor(start / step) * step; | |
| d[i1] = Math.ceil(stop / step) * step; | |
| domain(d); | |
| } else if (step < 0) { | |
| d[i0] = Math.ceil(start * step) / step; | |
| d[i1] = Math.floor(stop * step) / step; | |
| domain(d); | |
| } | |
| return scale; | |
| }; | |
| return scale; | |
| } | |
| function linear() { | |
| var scale = continuous(deinterpolateLinear, d3Interpolate.interpolateNumber); | |
| scale.copy = function() { | |
| return copy(scale, linear()); | |
| }; | |
| return linearish(scale); | |
| } | |
| function identity() { | |
| var domain = [0, 1]; | |
| function scale(x) { | |
| return +x; | |
| } | |
| scale.invert = scale; | |
| scale.domain = scale.range = function(_) { | |
| return arguments.length ? (domain = map$1.call(_, number), scale) : domain.slice(); | |
| }; | |
| scale.copy = function() { | |
| return identity().domain(domain); | |
| }; | |
| return linearish(scale); | |
| } | |
| var nice = function(domain, interval) { | |
| domain = domain.slice(); | |
| var i0 = 0, | |
| i1 = domain.length - 1, | |
| x0 = domain[i0], | |
| x1 = domain[i1], | |
| t; | |
| if (x1 < x0) { | |
| t = i0, i0 = i1, i1 = t; | |
| t = x0, x0 = x1, x1 = t; | |
| } | |
| domain[i0] = interval.floor(x0); | |
| domain[i1] = interval.ceil(x1); | |
| return domain; | |
| }; | |
| function deinterpolate(a, b) { | |
| return (b = Math.log(b / a)) | |
| ? function(x) { return Math.log(x / a) / b; } | |
| : constant(b); | |
| } | |
| function reinterpolate(a, b) { | |
| return a < 0 | |
| ? function(t) { return -Math.pow(-b, t) * Math.pow(-a, 1 - t); } | |
| : function(t) { return Math.pow(b, t) * Math.pow(a, 1 - t); }; | |
| } | |
| function pow10(x) { | |
| return isFinite(x) ? +("1e" + x) : x < 0 ? 0 : x; | |
| } | |
| function powp(base) { | |
| return base === 10 ? pow10 | |
| : base === Math.E ? Math.exp | |
| : function(x) { return Math.pow(base, x); }; | |
| } | |
| function logp(base) { | |
| return base === Math.E ? Math.log | |
| : base === 10 && Math.log10 | |
| || base === 2 && Math.log2 | |
| || (base = Math.log(base), function(x) { return Math.log(x) / base; }); | |
| } | |
| function reflect(f) { | |
| return function(x) { | |
| return -f(-x); | |
| }; | |
| } | |
| function log() { | |
| var scale = continuous(deinterpolate, reinterpolate).domain([1, 10]), | |
| domain = scale.domain, | |
| base = 10, | |
| logs = logp(10), | |
| pows = powp(10); | |
| function rescale() { | |
| logs = logp(base), pows = powp(base); | |
| if (domain()[0] < 0) logs = reflect(logs), pows = reflect(pows); | |
| return scale; | |
| } | |
| scale.base = function(_) { | |
| return arguments.length ? (base = +_, rescale()) : base; | |
| }; | |
| scale.domain = function(_) { | |
| return arguments.length ? (domain(_), rescale()) : domain(); | |
| }; | |
| scale.ticks = function(count) { | |
| var d = domain(), | |
| u = d[0], | |
| v = d[d.length - 1], | |
| r; | |
| if (r = v < u) i = u, u = v, v = i; | |
| var i = logs(u), | |
| j = logs(v), | |
| p, | |
| k, | |
| t, | |
| n = count == null ? 10 : +count, | |
| z = []; | |
| if (!(base % 1) && j - i < n) { | |
| i = Math.round(i) - 1, j = Math.round(j) + 1; | |
| if (u > 0) for (; i < j; ++i) { | |
| for (k = 1, p = pows(i); k < base; ++k) { | |
| t = p * k; | |
| if (t < u) continue; | |
| if (t > v) break; | |
| z.push(t); | |
| } | |
| } else for (; i < j; ++i) { | |
| for (k = base - 1, p = pows(i); k >= 1; --k) { | |
| t = p * k; | |
| if (t < u) continue; | |
| if (t > v) break; | |
| z.push(t); | |
| } | |
| } | |
| } else { | |
| z = d3Array.ticks(i, j, Math.min(j - i, n)).map(pows); | |
| } | |
| return r ? z.reverse() : z; | |
| }; | |
| scale.tickFormat = function(count, specifier) { | |
| if (specifier == null) specifier = base === 10 ? ".0e" : ","; | |
| if (typeof specifier !== "function") specifier = d3Format.format(specifier); | |
| if (count === Infinity) return specifier; | |
| if (count == null) count = 10; | |
| var k = Math.max(1, base * count / scale.ticks().length); // TODO fast estimate? | |
| return function(d) { | |
| var i = d / pows(Math.round(logs(d))); | |
| if (i * base < base - 0.5) i *= base; | |
| return i <= k ? specifier(d) : ""; | |
| }; | |
| }; | |
| scale.nice = function() { | |
| return domain(nice(domain(), { | |
| floor: function(x) { return pows(Math.floor(logs(x))); }, | |
| ceil: function(x) { return pows(Math.ceil(logs(x))); } | |
| })); | |
| }; | |
| scale.copy = function() { | |
| return copy(scale, log().base(base)); | |
| }; | |
| return scale; | |
| } | |
| function raise(x, exponent) { | |
| return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent); | |
| } | |
| function pow() { | |
| var exponent = 1, | |
| scale = continuous(deinterpolate, reinterpolate), | |
| domain = scale.domain; | |
| function deinterpolate(a, b) { | |
| return (b = raise(b, exponent) - (a = raise(a, exponent))) | |
| ? function(x) { return (raise(x, exponent) - a) / b; } | |
| : constant(b); | |
| } | |
| function reinterpolate(a, b) { | |
| b = raise(b, exponent) - (a = raise(a, exponent)); | |
| return function(t) { return raise(a + b * t, 1 / exponent); }; | |
| } | |
| scale.exponent = function(_) { | |
| return arguments.length ? (exponent = +_, domain(domain())) : exponent; | |
| }; | |
| scale.copy = function() { | |
| return copy(scale, pow().exponent(exponent)); | |
| }; | |
| return linearish(scale); | |
| } | |
| function sqrt() { | |
| return pow().exponent(0.5); | |
| } | |
| function quantile$1() { | |
| var domain = [], | |
| range$$1 = [], | |
| thresholds = []; | |
| function rescale() { | |
| var i = 0, n = Math.max(1, range$$1.length); | |
| thresholds = new Array(n - 1); | |
| while (++i < n) thresholds[i - 1] = d3Array.quantile(domain, i / n); | |
| return scale; | |
| } | |
| function scale(x) { | |
| if (!isNaN(x = +x)) return range$$1[d3Array.bisect(thresholds, x)]; | |
| } | |
| scale.invertExtent = function(y) { | |
| var i = range$$1.indexOf(y); | |
| return i < 0 ? [NaN, NaN] : [ | |
| i > 0 ? thresholds[i - 1] : domain[0], | |
| i < thresholds.length ? thresholds[i] : domain[domain.length - 1] | |
| ]; | |
| }; | |
| scale.domain = function(_) { | |
| if (!arguments.length) return domain.slice(); | |
| domain = []; | |
| for (var i = 0, n = _.length, d; i < n; ++i) if (d = _[i], d != null && !isNaN(d = +d)) domain.push(d); | |
| domain.sort(d3Array.ascending); | |
| return rescale(); | |
| }; | |
| scale.range = function(_) { | |
| return arguments.length ? (range$$1 = slice.call(_), rescale()) : range$$1.slice(); | |
| }; | |
| scale.quantiles = function() { | |
| return thresholds.slice(); | |
| }; | |
| scale.copy = function() { | |
| return quantile$1() | |
| .domain(domain) | |
| .range(range$$1); | |
| }; | |
| return scale; | |
| } | |
| function quantize() { | |
| var x0 = 0, | |
| x1 = 1, | |
| n = 1, | |
| domain = [0.5], | |
| range$$1 = [0, 1]; | |
| function scale(x) { | |
| if (x <= x) return range$$1[d3Array.bisect(domain, x, 0, n)]; | |
| } | |
| function rescale() { | |
| var i = -1; | |
| domain = new Array(n); | |
| while (++i < n) domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1); | |
| return scale; | |
| } | |
| scale.domain = function(_) { | |
| return arguments.length ? (x0 = +_[0], x1 = +_[1], rescale()) : [x0, x1]; | |
| }; | |
| scale.range = function(_) { | |
| return arguments.length ? (n = (range$$1 = slice.call(_)).length - 1, rescale()) : range$$1.slice(); | |
| }; | |
| scale.invertExtent = function(y) { | |
| var i = range$$1.indexOf(y); | |
| return i < 0 ? [NaN, NaN] | |
| : i < 1 ? [x0, domain[0]] | |
| : i >= n ? [domain[n - 1], x1] | |
| : [domain[i - 1], domain[i]]; | |
| }; | |
| scale.copy = function() { | |
| return quantize() | |
| .domain([x0, x1]) | |
| .range(range$$1); | |
| }; | |
| return linearish(scale); | |
| } | |
| function threshold() { | |
| var domain = [0.5], | |
| range$$1 = [0, 1], | |
| n = 1; | |
| function scale(x) { | |
| if (x <= x) return range$$1[d3Array.bisect(domain, x, 0, n)]; | |
| } | |
| scale.domain = function(_) { | |
| return arguments.length ? (domain = slice.call(_), n = Math.min(domain.length, range$$1.length - 1), scale) : domain.slice(); | |
| }; | |
| scale.range = function(_) { | |
| return arguments.length ? (range$$1 = slice.call(_), n = Math.min(domain.length, range$$1.length - 1), scale) : range$$1.slice(); | |
| }; | |
| scale.invertExtent = function(y) { | |
| var i = range$$1.indexOf(y); | |
| return [domain[i - 1], domain[i]]; | |
| }; | |
| scale.copy = function() { | |
| return threshold() | |
| .domain(domain) | |
| .range(range$$1); | |
| }; | |
| return scale; | |
| } | |
| var durationSecond = 1000; | |
| var durationMinute = durationSecond * 60; | |
| var durationHour = durationMinute * 60; | |
| var durationDay = durationHour * 24; | |
| var durationWeek = durationDay * 7; | |
| var durationMonth = durationDay * 30; | |
| var durationYear = durationDay * 365; | |
| function date(t) { | |
| return new Date(t); | |
| } | |
| function number$1(t) { | |
| return t instanceof Date ? +t : +new Date(+t); | |
| } | |
| function calendar(year, month, week, day, hour, minute, second, millisecond, format$$1) { | |
| var scale = continuous(deinterpolateLinear, d3Interpolate.interpolateNumber), | |
| invert = scale.invert, | |
| domain = scale.domain; | |
| var formatMillisecond = format$$1(".%L"), | |
| formatSecond = format$$1(":%S"), | |
| formatMinute = format$$1("%I:%M"), | |
| formatHour = format$$1("%I %p"), | |
| formatDay = format$$1("%a %d"), | |
| formatWeek = format$$1("%b %d"), | |
| formatMonth = format$$1("%B"), | |
| formatYear = format$$1("%Y"); | |
| var tickIntervals = [ | |
| [second, 1, durationSecond], | |
| [second, 5, 5 * durationSecond], | |
| [second, 15, 15 * durationSecond], | |
| [second, 30, 30 * durationSecond], | |
| [minute, 1, durationMinute], | |
| [minute, 5, 5 * durationMinute], | |
| [minute, 15, 15 * durationMinute], | |
| [minute, 30, 30 * durationMinute], | |
| [ hour, 1, durationHour ], | |
| [ hour, 3, 3 * durationHour ], | |
| [ hour, 6, 6 * durationHour ], | |
| [ hour, 12, 12 * durationHour ], | |
| [ day, 1, durationDay ], | |
| [ day, 2, 2 * durationDay ], | |
| [ week, 1, durationWeek ], | |
| [ month, 1, durationMonth ], | |
| [ month, 3, 3 * durationMonth ], | |
| [ year, 1, durationYear ] | |
| ]; | |
| function tickFormat(date) { | |
| return (second(date) < date ? formatMillisecond | |
| : minute(date) < date ? formatSecond | |
| : hour(date) < date ? formatMinute | |
| : day(date) < date ? formatHour | |
| : month(date) < date ? (week(date) < date ? formatDay : formatWeek) | |
| : year(date) < date ? formatMonth | |
| : formatYear)(date); | |
| } | |
| function tickInterval(interval, start, stop, step) { | |
| if (interval == null) interval = 10; | |
| // If a desired tick count is specified, pick a reasonable tick interval | |
| // based on the extent of the domain and a rough estimate of tick size. | |
| // Otherwise, assume interval is already a time interval and use it. | |
| if (typeof interval === "number") { | |
| var target = Math.abs(stop - start) / interval, | |
| i = d3Array.bisector(function(i) { return i[2]; }).right(tickIntervals, target); | |
| if (i === tickIntervals.length) { | |
| step = d3Array.tickStep(start / durationYear, stop / durationYear, interval); | |
| interval = year; | |
| } else if (i) { | |
| i = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i]; | |
| step = i[1]; | |
| interval = i[0]; | |
| } else { | |
| step = Math.max(d3Array.tickStep(start, stop, interval), 1); | |
| interval = millisecond; | |
| } | |
| } | |
| return step == null ? interval : interval.every(step); | |
| } | |
| scale.invert = function(y) { | |
| return new Date(invert(y)); | |
| }; | |
| scale.domain = function(_) { | |
| return arguments.length ? domain(map$1.call(_, number$1)) : domain().map(date); | |
| }; | |
| scale.ticks = function(interval, step) { | |
| var d = domain(), | |
| t0 = d[0], | |
| t1 = d[d.length - 1], | |
| r = t1 < t0, | |
| t; | |
| if (r) t = t0, t0 = t1, t1 = t; | |
| t = tickInterval(interval, t0, t1, step); | |
| t = t ? t.range(t0, t1 + 1) : []; // inclusive stop | |
| return r ? t.reverse() : t; | |
| }; | |
| scale.tickFormat = function(count, specifier) { | |
| return specifier == null ? tickFormat : format$$1(specifier); | |
| }; | |
| scale.nice = function(interval, step) { | |
| var d = domain(); | |
| return (interval = tickInterval(interval, d[0], d[d.length - 1], step)) | |
| ? domain(nice(d, interval)) | |
| : scale; | |
| }; | |
| scale.copy = function() { | |
| return copy(scale, calendar(year, month, week, day, hour, minute, second, millisecond, format$$1)); | |
| }; | |
| return scale; | |
| } | |
| var time = function() { | |
| return calendar(d3Time.timeYear, d3Time.timeMonth, d3Time.timeWeek, d3Time.timeDay, d3Time.timeHour, d3Time.timeMinute, d3Time.timeSecond, d3Time.timeMillisecond, d3TimeFormat.timeFormat).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]); | |
| }; | |
| var utcTime = function() { | |
| return calendar(d3Time.utcYear, d3Time.utcMonth, d3Time.utcWeek, d3Time.utcDay, d3Time.utcHour, d3Time.utcMinute, d3Time.utcSecond, d3Time.utcMillisecond, d3TimeFormat.utcFormat).domain([Date.UTC(2000, 0, 1), Date.UTC(2000, 0, 2)]); | |
| }; | |
| var colors = function(s) { | |
| return s.match(/.{6}/g).map(function(x) { | |
| return "#" + x; | |
| }); | |
| }; | |
| var category10 = colors("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf"); | |
| var category20b = colors("393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6"); | |
| var category20c = colors("3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9"); | |
| var category20 = colors("1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5"); | |
| var cubehelix$1 = d3Interpolate.interpolateCubehelixLong(d3Color.cubehelix(300, 0.5, 0.0), d3Color.cubehelix(-240, 0.5, 1.0)); | |
| var warm = d3Interpolate.interpolateCubehelixLong(d3Color.cubehelix(-100, 0.75, 0.35), d3Color.cubehelix(80, 1.50, 0.8)); | |
| var cool = d3Interpolate.interpolateCubehelixLong(d3Color.cubehelix(260, 0.75, 0.35), d3Color.cubehelix(80, 1.50, 0.8)); | |
| var rainbow = d3Color.cubehelix(); | |
| var rainbow$1 = function(t) { | |
| if (t < 0 || t > 1) t -= Math.floor(t); | |
| var ts = Math.abs(t - 0.5); | |
| rainbow.h = 360 * t - 100; | |
| rainbow.s = 1.5 - 1.5 * ts; | |
| rainbow.l = 0.8 - 0.9 * ts; | |
| return rainbow + ""; | |
| }; | |
| function ramp(range$$1) { | |
| var n = range$$1.length; | |
| return function(t) { | |
| return range$$1[Math.max(0, Math.min(n - 1, Math.floor(t * n)))]; | |
| }; | |
| } | |
| var viridis = ramp(colors("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")); | |
| var magma = ramp(colors("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")); | |
| var inferno = ramp(colors("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")); | |
| var plasma = ramp(colors("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921")); | |
| function sequential(interpolator) { | |
| var x0 = 0, | |
| x1 = 1, | |
| clamp = false; | |
| function scale(x) { | |
| var t = (x - x0) / (x1 - x0); | |
| return interpolator(clamp ? Math.max(0, Math.min(1, t)) : t); | |
| } | |
| scale.domain = function(_) { | |
| return arguments.length ? (x0 = +_[0], x1 = +_[1], scale) : [x0, x1]; | |
| }; | |
| scale.clamp = function(_) { | |
| return arguments.length ? (clamp = !!_, scale) : clamp; | |
| }; | |
| scale.interpolator = function(_) { | |
| return arguments.length ? (interpolator = _, scale) : interpolator; | |
| }; | |
| scale.copy = function() { | |
| return sequential(interpolator).domain([x0, x1]).clamp(clamp); | |
| }; | |
| return linearish(scale); | |
| } | |
| exports.scaleBand = band; | |
| exports.scalePoint = point; | |
| exports.scaleIdentity = identity; | |
| exports.scaleLinear = linear; | |
| exports.scaleLog = log; | |
| exports.scaleOrdinal = ordinal; | |
| exports.scaleImplicit = implicit; | |
| exports.scalePow = pow; | |
| exports.scaleSqrt = sqrt; | |
| exports.scaleQuantile = quantile$1; | |
| exports.scaleQuantize = quantize; | |
| exports.scaleThreshold = threshold; | |
| exports.scaleTime = time; | |
| exports.scaleUtc = utcTime; | |
| exports.schemeCategory10 = category10; | |
| exports.schemeCategory20b = category20b; | |
| exports.schemeCategory20c = category20c; | |
| exports.schemeCategory20 = category20; | |
| exports.interpolateCubehelixDefault = cubehelix$1; | |
| exports.interpolateRainbow = rainbow$1; | |
| exports.interpolateWarm = warm; | |
| exports.interpolateCool = cool; | |
| exports.interpolateViridis = viridis; | |
| exports.interpolateMagma = magma; | |
| exports.interpolateInferno = inferno; | |
| exports.interpolatePlasma = plasma; | |
| exports.scaleSequential = sequential; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| }))); | |
| },{"d3-array":2,"d3-collection":4,"d3-color":5,"d3-format":6,"d3-interpolate":7,"d3-time":14,"d3-time-format":13}],11:[function(require,module,exports){ | |
| // https://d3js.org/d3-selection/ Version 1.2.0. Copyright 2017 Mike Bostock. | |
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : | |
| typeof define === 'function' && define.amd ? define(['exports'], factory) : | |
| (factory((global.d3 = global.d3 || {}))); | |
| }(this, (function (exports) { 'use strict'; | |
| var xhtml = "http://www.w3.org/1999/xhtml"; | |
| var namespaces = { | |
| svg: "http://www.w3.org/2000/svg", | |
| xhtml: xhtml, | |
| xlink: "http://www.w3.org/1999/xlink", | |
| xml: "http://www.w3.org/XML/1998/namespace", | |
| xmlns: "http://www.w3.org/2000/xmlns/" | |
| }; | |
| var namespace = function(name) { | |
| var prefix = name += "", i = prefix.indexOf(":"); | |
| if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1); | |
| return namespaces.hasOwnProperty(prefix) ? {space: namespaces[prefix], local: name} : name; | |
| }; | |
| function creatorInherit(name) { | |
| return function() { | |
| var document = this.ownerDocument, | |
| uri = this.namespaceURI; | |
| return uri === xhtml && document.documentElement.namespaceURI === xhtml | |
| ? document.createElement(name) | |
| : document.createElementNS(uri, name); | |
| }; | |
| } | |
| function creatorFixed(fullname) { | |
| return function() { | |
| return this.ownerDocument.createElementNS(fullname.space, fullname.local); | |
| }; | |
| } | |
| var creator = function(name) { | |
| var fullname = namespace(name); | |
| return (fullname.local | |
| ? creatorFixed | |
| : creatorInherit)(fullname); | |
| }; | |
| var nextId = 0; | |
| function local() { | |
| return new Local; | |
| } | |
| function Local() { | |
| this._ = "@" + (++nextId).toString(36); | |
| } | |
| Local.prototype = local.prototype = { | |
| constructor: Local, | |
| get: function(node) { | |
| var id = this._; | |
| while (!(id in node)) if (!(node = node.parentNode)) return; | |
| return node[id]; | |
| }, | |
| set: function(node, value) { | |
| return node[this._] = value; | |
| }, | |
| remove: function(node) { | |
| return this._ in node && delete node[this._]; | |
| }, | |
| toString: function() { | |
| return this._; | |
| } | |
| }; | |
| var matcher = function(selector) { | |
| return function() { | |
| return this.matches(selector); | |
| }; | |
| }; | |
| if (typeof document !== "undefined") { | |
| var element = document.documentElement; | |
| if (!element.matches) { | |
| var vendorMatches = element.webkitMatchesSelector | |
| || element.msMatchesSelector | |
| || element.mozMatchesSelector | |
| || element.oMatchesSelector; | |
| matcher = function(selector) { | |
| return function() { | |
| return vendorMatches.call(this, selector); | |
| }; | |
| }; | |
| } | |
| } | |
| var matcher$1 = matcher; | |
| var filterEvents = {}; | |
| exports.event = null; | |
| if (typeof document !== "undefined") { | |
| var element$1 = document.documentElement; | |
| if (!("onmouseenter" in element$1)) { | |
| filterEvents = {mouseenter: "mouseover", mouseleave: "mouseout"}; | |
| } | |
| } | |
| function filterContextListener(listener, index, group) { | |
| listener = contextListener(listener, index, group); | |
| return function(event) { | |
| var related = event.relatedTarget; | |
| if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) { | |
| listener.call(this, event); | |
| } | |
| }; | |
| } | |
| function contextListener(listener, index, group) { | |
| return function(event1) { | |
| var event0 = exports.event; // Events can be reentrant (e.g., focus). | |
| exports.event = event1; | |
| try { | |
| listener.call(this, this.__data__, index, group); | |
| } finally { | |
| exports.event = event0; | |
| } | |
| }; | |
| } | |
| function parseTypenames(typenames) { | |
| return typenames.trim().split(/^|\s+/).map(function(t) { | |
| var name = "", i = t.indexOf("."); | |
| if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i); | |
| return {type: t, name: name}; | |
| }); | |
| } | |
| function onRemove(typename) { | |
| return function() { | |
| var on = this.__on; | |
| if (!on) return; | |
| for (var j = 0, i = -1, m = on.length, o; j < m; ++j) { | |
| if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) { | |
| this.removeEventListener(o.type, o.listener, o.capture); | |
| } else { | |
| on[++i] = o; | |
| } | |
| } | |
| if (++i) on.length = i; | |
| else delete this.__on; | |
| }; | |
| } | |
| function onAdd(typename, value, capture) { | |
| var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener; | |
| return function(d, i, group) { | |
| var on = this.__on, o, listener = wrap(value, i, group); | |
| if (on) for (var j = 0, m = on.length; j < m; ++j) { | |
| if ((o = on[j]).type === typename.type && o.name === typename.name) { | |
| this.removeEventListener(o.type, o.listener, o.capture); | |
| this.addEventListener(o.type, o.listener = listener, o.capture = capture); | |
| o.value = value; | |
| return; | |
| } | |
| } | |
| this.addEventListener(typename.type, listener, capture); | |
| o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture}; | |
| if (!on) this.__on = [o]; | |
| else on.push(o); | |
| }; | |
| } | |
| var selection_on = function(typename, value, capture) { | |
| var typenames = parseTypenames(typename + ""), i, n = typenames.length, t; | |
| if (arguments.length < 2) { | |
| var on = this.node().__on; | |
| if (on) for (var j = 0, m = on.length, o; j < m; ++j) { | |
| for (i = 0, o = on[j]; i < n; ++i) { | |
| if ((t = typenames[i]).type === o.type && t.name === o.name) { | |
| return o.value; | |
| } | |
| } | |
| } | |
| return; | |
| } | |
| on = value ? onAdd : onRemove; | |
| if (capture == null) capture = false; | |
| for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture)); | |
| return this; | |
| }; | |
| function customEvent(event1, listener, that, args) { | |
| var event0 = exports.event; | |
| event1.sourceEvent = exports.event; | |
| exports.event = event1; | |
| try { | |
| return listener.apply(that, args); | |
| } finally { | |
| exports.event = event0; | |
| } | |
| } | |
| var sourceEvent = function() { | |
| var current = exports.event, source; | |
| while (source = current.sourceEvent) current = source; | |
| return current; | |
| }; | |
| var point = function(node, event) { | |
| var svg = node.ownerSVGElement || node; | |
| if (svg.createSVGPoint) { | |
| var point = svg.createSVGPoint(); | |
| point.x = event.clientX, point.y = event.clientY; | |
| point = point.matrixTransform(node.getScreenCTM().inverse()); | |
| return [point.x, point.y]; | |
| } | |
| var rect = node.getBoundingClientRect(); | |
| return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop]; | |
| }; | |
| var mouse = function(node) { | |
| var event = sourceEvent(); | |
| if (event.changedTouches) event = event.changedTouches[0]; | |
| return point(node, event); | |
| }; | |
| function none() {} | |
| var selector = function(selector) { | |
| return selector == null ? none : function() { | |
| return this.querySelector(selector); | |
| }; | |
| }; | |
| var selection_select = function(select) { | |
| if (typeof select !== "function") select = selector(select); | |
| for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) { | |
| if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) { | |
| if ("__data__" in node) subnode.__data__ = node.__data__; | |
| subgroup[i] = subnode; | |
| } | |
| } | |
| } | |
| return new Selection(subgroups, this._parents); | |
| }; | |
| function empty() { | |
| return []; | |
| } | |
| var selectorAll = function(selector) { | |
| return selector == null ? empty : function() { | |
| return this.querySelectorAll(selector); | |
| }; | |
| }; | |
| var selection_selectAll = function(select) { | |
| if (typeof select !== "function") select = selectorAll(select); | |
| for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { | |
| if (node = group[i]) { | |
| subgroups.push(select.call(node, node.__data__, i, group)); | |
| parents.push(node); | |
| } | |
| } | |
| } | |
| return new Selection(subgroups, parents); | |
| }; | |
| var selection_filter = function(match) { | |
| if (typeof match !== "function") match = matcher$1(match); | |
| for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) { | |
| if ((node = group[i]) && match.call(node, node.__data__, i, group)) { | |
| subgroup.push(node); | |
| } | |
| } | |
| } | |
| return new Selection(subgroups, this._parents); | |
| }; | |
| var sparse = function(update) { | |
| return new Array(update.length); | |
| }; | |
| var selection_enter = function() { | |
| return new Selection(this._enter || this._groups.map(sparse), this._parents); | |
| }; | |
| function EnterNode(parent, datum) { | |
| this.ownerDocument = parent.ownerDocument; | |
| this.namespaceURI = parent.namespaceURI; | |
| this._next = null; | |
| this._parent = parent; | |
| this.__data__ = datum; | |
| } | |
| EnterNode.prototype = { | |
| constructor: EnterNode, | |
| appendChild: function(child) { return this._parent.insertBefore(child, this._next); }, | |
| insertBefore: function(child, next) { return this._parent.insertBefore(child, next); }, | |
| querySelector: function(selector) { return this._parent.querySelector(selector); }, | |
| querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); } | |
| }; | |
| var constant = function(x) { | |
| return function() { | |
| return x; | |
| }; | |
| }; | |
| var keyPrefix = "$"; // Protect against keys like “__proto__”. | |
| function bindIndex(parent, group, enter, update, exit, data) { | |
| var i = 0, | |
| node, | |
| groupLength = group.length, | |
| dataLength = data.length; | |
| // Put any non-null nodes that fit into update. | |
| // Put any null nodes into enter. | |
| // Put any remaining data into enter. | |
| for (; i < dataLength; ++i) { | |
| if (node = group[i]) { | |
| node.__data__ = data[i]; | |
| update[i] = node; | |
| } else { | |
| enter[i] = new EnterNode(parent, data[i]); | |
| } | |
| } | |
| // Put any non-null nodes that don’t fit into exit. | |
| for (; i < groupLength; ++i) { | |
| if (node = group[i]) { | |
| exit[i] = node; | |
| } | |
| } | |
| } | |
| function bindKey(parent, group, enter, update, exit, data, key) { | |
| var i, | |
| node, | |
| nodeByKeyValue = {}, | |
| groupLength = group.length, | |
| dataLength = data.length, | |
| keyValues = new Array(groupLength), | |
| keyValue; | |
| // Compute the key for each node. | |
| // If multiple nodes have the same key, the duplicates are added to exit. | |
| for (i = 0; i < groupLength; ++i) { | |
| if (node = group[i]) { | |
| keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group); | |
| if (keyValue in nodeByKeyValue) { | |
| exit[i] = node; | |
| } else { | |
| nodeByKeyValue[keyValue] = node; | |
| } | |
| } | |
| } | |
| // Compute the key for each datum. | |
| // If there a node associated with this key, join and add it to update. | |
| // If there is not (or the key is a duplicate), add it to enter. | |
| for (i = 0; i < dataLength; ++i) { | |
| keyValue = keyPrefix + key.call(parent, data[i], i, data); | |
| if (node = nodeByKeyValue[keyValue]) { | |
| update[i] = node; | |
| node.__data__ = data[i]; | |
| nodeByKeyValue[keyValue] = null; | |
| } else { | |
| enter[i] = new EnterNode(parent, data[i]); | |
| } | |
| } | |
| // Add any remaining nodes that were not bound to data to exit. | |
| for (i = 0; i < groupLength; ++i) { | |
| if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) { | |
| exit[i] = node; | |
| } | |
| } | |
| } | |
| var selection_data = function(value, key) { | |
| if (!value) { | |
| data = new Array(this.size()), j = -1; | |
| this.each(function(d) { data[++j] = d; }); | |
| return data; | |
| } | |
| var bind = key ? bindKey : bindIndex, | |
| parents = this._parents, | |
| groups = this._groups; | |
| if (typeof value !== "function") value = constant(value); | |
| for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) { | |
| var parent = parents[j], | |
| group = groups[j], | |
| groupLength = group.length, | |
| data = value.call(parent, parent && parent.__data__, j, parents), | |
| dataLength = data.length, | |
| enterGroup = enter[j] = new Array(dataLength), | |
| updateGroup = update[j] = new Array(dataLength), | |
| exitGroup = exit[j] = new Array(groupLength); | |
| bind(parent, group, enterGroup, updateGroup, exitGroup, data, key); | |
| // Now connect the enter nodes to their following update node, such that | |
| // appendChild can insert the materialized enter node before this node, | |
| // rather than at the end of the parent node. | |
| for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) { | |
| if (previous = enterGroup[i0]) { | |
| if (i0 >= i1) i1 = i0 + 1; | |
| while (!(next = updateGroup[i1]) && ++i1 < dataLength); | |
| previous._next = next || null; | |
| } | |
| } | |
| } | |
| update = new Selection(update, parents); | |
| update._enter = enter; | |
| update._exit = exit; | |
| return update; | |
| }; | |
| var selection_exit = function() { | |
| return new Selection(this._exit || this._groups.map(sparse), this._parents); | |
| }; | |
| var selection_merge = function(selection) { | |
| for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) { | |
| for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) { | |
| if (node = group0[i] || group1[i]) { | |
| merge[i] = node; | |
| } | |
| } | |
| } | |
| for (; j < m0; ++j) { | |
| merges[j] = groups0[j]; | |
| } | |
| return new Selection(merges, this._parents); | |
| }; | |
| var selection_order = function() { | |
| for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) { | |
| for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) { | |
| if (node = group[i]) { | |
| if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next); | |
| next = node; | |
| } | |
| } | |
| } | |
| return this; | |
| }; | |
| var selection_sort = function(compare) { | |
| if (!compare) compare = ascending; | |
| function compareNode(a, b) { | |
| return a && b ? compare(a.__data__, b.__data__) : !a - !b; | |
| } | |
| for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) { | |
| for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) { | |
| if (node = group[i]) { | |
| sortgroup[i] = node; | |
| } | |
| } | |
| sortgroup.sort(compareNode); | |
| } | |
| return new Selection(sortgroups, this._parents).order(); | |
| }; | |
| function ascending(a, b) { | |
| return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; | |
| } | |
| var selection_call = function() { | |
| var callback = arguments[0]; | |
| arguments[0] = this; | |
| callback.apply(null, arguments); | |
| return this; | |
| }; | |
| var selection_nodes = function() { | |
| var nodes = new Array(this.size()), i = -1; | |
| this.each(function() { nodes[++i] = this; }); | |
| return nodes; | |
| }; | |
| var selection_node = function() { | |
| for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { | |
| for (var group = groups[j], i = 0, n = group.length; i < n; ++i) { | |
| var node = group[i]; | |
| if (node) return node; | |
| } | |
| } | |
| return null; | |
| }; | |
| var selection_size = function() { | |
| var size = 0; | |
| this.each(function() { ++size; }); | |
| return size; | |
| }; | |
| var selection_empty = function() { | |
| return !this.node(); | |
| }; | |
| var selection_each = function(callback) { | |
| for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { | |
| for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) { | |
| if (node = group[i]) callback.call(node, node.__data__, i, group); | |
| } | |
| } | |
| return this; | |
| }; | |
| function attrRemove(name) { | |
| return function() { | |
| this.removeAttribute(name); | |
| }; | |
| } | |
| function attrRemoveNS(fullname) { | |
| return function() { | |
| this.removeAttributeNS(fullname.space, fullname.local); | |
| }; | |
| } | |
| function attrConstant(name, value) { | |
| return function() { | |
| this.setAttribute(name, value); | |
| }; | |
| } | |
| function attrConstantNS(fullname, value) { | |
| return function() { | |
| this.setAttributeNS(fullname.space, fullname.local, value); | |
| }; | |
| } | |
| function attrFunction(name, value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| if (v == null) this.removeAttribute(name); | |
| else this.setAttribute(name, v); | |
| }; | |
| } | |
| function attrFunctionNS(fullname, value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| if (v == null) this.removeAttributeNS(fullname.space, fullname.local); | |
| else this.setAttributeNS(fullname.space, fullname.local, v); | |
| }; | |
| } | |
| var selection_attr = function(name, value) { | |
| var fullname = namespace(name); | |
| if (arguments.length < 2) { | |
| var node = this.node(); | |
| return fullname.local | |
| ? node.getAttributeNS(fullname.space, fullname.local) | |
| : node.getAttribute(fullname); | |
| } | |
| return this.each((value == null | |
| ? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === "function" | |
| ? (fullname.local ? attrFunctionNS : attrFunction) | |
| : (fullname.local ? attrConstantNS : attrConstant)))(fullname, value)); | |
| }; | |
| var defaultView = function(node) { | |
| return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node | |
| || (node.document && node) // node is a Window | |
| || node.defaultView; // node is a Document | |
| }; | |
| function styleRemove(name) { | |
| return function() { | |
| this.style.removeProperty(name); | |
| }; | |
| } | |
| function styleConstant(name, value, priority) { | |
| return function() { | |
| this.style.setProperty(name, value, priority); | |
| }; | |
| } | |
| function styleFunction(name, value, priority) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| if (v == null) this.style.removeProperty(name); | |
| else this.style.setProperty(name, v, priority); | |
| }; | |
| } | |
| var selection_style = function(name, value, priority) { | |
| return arguments.length > 1 | |
| ? this.each((value == null | |
| ? styleRemove : typeof value === "function" | |
| ? styleFunction | |
| : styleConstant)(name, value, priority == null ? "" : priority)) | |
| : styleValue(this.node(), name); | |
| }; | |
| function styleValue(node, name) { | |
| return node.style.getPropertyValue(name) | |
| || defaultView(node).getComputedStyle(node, null).getPropertyValue(name); | |
| } | |
| function propertyRemove(name) { | |
| return function() { | |
| delete this[name]; | |
| }; | |
| } | |
| function propertyConstant(name, value) { | |
| return function() { | |
| this[name] = value; | |
| }; | |
| } | |
| function propertyFunction(name, value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| if (v == null) delete this[name]; | |
| else this[name] = v; | |
| }; | |
| } | |
| var selection_property = function(name, value) { | |
| return arguments.length > 1 | |
| ? this.each((value == null | |
| ? propertyRemove : typeof value === "function" | |
| ? propertyFunction | |
| : propertyConstant)(name, value)) | |
| : this.node()[name]; | |
| }; | |
| function classArray(string) { | |
| return string.trim().split(/^|\s+/); | |
| } | |
| function classList(node) { | |
| return node.classList || new ClassList(node); | |
| } | |
| function ClassList(node) { | |
| this._node = node; | |
| this._names = classArray(node.getAttribute("class") || ""); | |
| } | |
| ClassList.prototype = { | |
| add: function(name) { | |
| var i = this._names.indexOf(name); | |
| if (i < 0) { | |
| this._names.push(name); | |
| this._node.setAttribute("class", this._names.join(" ")); | |
| } | |
| }, | |
| remove: function(name) { | |
| var i = this._names.indexOf(name); | |
| if (i >= 0) { | |
| this._names.splice(i, 1); | |
| this._node.setAttribute("class", this._names.join(" ")); | |
| } | |
| }, | |
| contains: function(name) { | |
| return this._names.indexOf(name) >= 0; | |
| } | |
| }; | |
| function classedAdd(node, names) { | |
| var list = classList(node), i = -1, n = names.length; | |
| while (++i < n) list.add(names[i]); | |
| } | |
| function classedRemove(node, names) { | |
| var list = classList(node), i = -1, n = names.length; | |
| while (++i < n) list.remove(names[i]); | |
| } | |
| function classedTrue(names) { | |
| return function() { | |
| classedAdd(this, names); | |
| }; | |
| } | |
| function classedFalse(names) { | |
| return function() { | |
| classedRemove(this, names); | |
| }; | |
| } | |
| function classedFunction(names, value) { | |
| return function() { | |
| (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names); | |
| }; | |
| } | |
| var selection_classed = function(name, value) { | |
| var names = classArray(name + ""); | |
| if (arguments.length < 2) { | |
| var list = classList(this.node()), i = -1, n = names.length; | |
| while (++i < n) if (!list.contains(names[i])) return false; | |
| return true; | |
| } | |
| return this.each((typeof value === "function" | |
| ? classedFunction : value | |
| ? classedTrue | |
| : classedFalse)(names, value)); | |
| }; | |
| function textRemove() { | |
| this.textContent = ""; | |
| } | |
| function textConstant(value) { | |
| return function() { | |
| this.textContent = value; | |
| }; | |
| } | |
| function textFunction(value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| this.textContent = v == null ? "" : v; | |
| }; | |
| } | |
| var selection_text = function(value) { | |
| return arguments.length | |
| ? this.each(value == null | |
| ? textRemove : (typeof value === "function" | |
| ? textFunction | |
| : textConstant)(value)) | |
| : this.node().textContent; | |
| }; | |
| function htmlRemove() { | |
| this.innerHTML = ""; | |
| } | |
| function htmlConstant(value) { | |
| return function() { | |
| this.innerHTML = value; | |
| }; | |
| } | |
| function htmlFunction(value) { | |
| return function() { | |
| var v = value.apply(this, arguments); | |
| this.innerHTML = v == null ? "" : v; | |
| }; | |
| } | |
| var selection_html = function(value) { | |
| return arguments.length | |
| ? this.each(value == null | |
| ? htmlRemove : (typeof value === "function" | |
| ? htmlFunction | |
| : htmlConstant)(value)) | |
| : this.node().innerHTML; | |
| }; | |
| function raise() { | |
| if (this.nextSibling) this.parentNode.appendChild(this); | |
| } | |
| var selection_raise = function() { | |
| return this.each(raise); | |
| }; | |
| function lower() { | |
| if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild); | |
| } | |
| var selection_lower = function() { | |
| return this.each(lower); | |
| }; | |
| var selection_append = function(name) { | |
| var create = typeof name === "function" ? name : creator(name); | |
| return this.select(function() { | |
| return this.appendChild(create.apply(this, arguments)); | |
| }); | |
| }; | |
| function constantNull() { | |
| return null; | |
| } | |
| var selection_insert = function(name, before) { | |
| var create = typeof name === "function" ? name : creator(name), | |
| select = before == null ? constantNull : typeof before === "function" ? before : selector(before); | |
| return this.select(function() { | |
| return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null); | |
| }); | |
| }; | |
| function remove() { | |
| var parent = this.parentNode; | |
| if (parent) parent.removeChild(this); | |
| } | |
| var selection_remove = function() { | |
| return this.each(remove); | |
| }; | |
| var selection_datum = function(value) { | |
| return arguments.length | |
| ? this.property("__data__", value) | |
| : this.node().__data__; | |
| }; | |
| function dispatchEvent(node, type, params) { | |
| var window = defaultView(node), | |
| event = window.CustomEvent; | |
| if (typeof event === "function") { | |
| event = new event(type, params); | |
| } else { | |
| event = window.document.createEvent("Event"); | |
| if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail; | |
| else event.initEvent(type, false, false); | |
| } | |
| node.dispatchEvent(event); | |
| } | |
| function dispatchConstant(type, params) { | |
| return function() { | |
| return dispatchEvent(this, type, params); | |
| }; | |
| } | |
| function dispatchFunction(type, params) { | |
| return function() { | |
| return dispatchEvent(this, type, params.apply(this, arguments)); | |
| }; | |
| } | |
| var selection_dispatch = function(type, params) { | |
| return this.each((typeof params === "function" | |
| ? dispatchFunction | |
| : dispatchConstant)(type, params)); | |
| }; | |
| var root = [null]; | |
| function Selection(groups, parents) { | |
| this._groups = groups; | |
| this._parents = parents; | |
| } | |
| function selection() { | |
| return new Selection([[document.documentElement]], root); | |
| } | |
| Selection.prototype = selection.prototype = { | |
| constructor: Selection, | |
| select: selection_select, | |
| selectAll: selection_selectAll, | |
| filter: selection_filter, | |
| data: selection_data, | |
| enter: selection_enter, | |
| exit: selection_exit, | |
| merge: selection_merge, | |
| order: selection_order, | |
| sort: selection_sort, | |
| call: selection_call, | |
| nodes: selection_nodes, | |
| node: selection_node, | |
| size: selection_size, | |
| empty: selection_empty, | |
| each: selection_each, | |
| attr: selection_attr, | |
| style: selection_style, | |
| property: selection_property, | |
| classed: selection_classed, | |
| text: selection_text, | |
| html: selection_html, | |
| raise: selection_raise, | |
| lower: selection_lower, | |
| append: selection_append, | |
| insert: selection_insert, | |
| remove: selection_remove, | |
| datum: selection_datum, | |
| on: selection_on, | |
| dispatch: selection_dispatch | |
| }; | |
| var select = function(selector) { | |
| return typeof selector === "string" | |
| ? new Selection([[document.querySelector(selector)]], [document.documentElement]) | |
| : new Selection([[selector]], root); | |
| }; | |
| var selectAll = function(selector) { | |
| return typeof selector === "string" | |
| ? new Selection([document.querySelectorAll(selector)], [document.documentElement]) | |
| : new Selection([selector == null ? [] : selector], root); | |
| }; | |
| var touch = function(node, touches, identifier) { | |
| if (arguments.length < 3) identifier = touches, touches = sourceEvent().changedTouches; | |
| for (var i = 0, n = touches ? touches.length : 0, touch; i < n; ++i) { | |
| if ((touch = touches[i]).identifier === identifier) { | |
| return point(node, touch); | |
| } | |
| } | |
| return null; | |
| }; | |
| var touches = function(node, touches) { | |
| if (touches == null) touches = sourceEvent().touches; | |
| for (var i = 0, n = touches ? touches.length : 0, points = new Array(n); i < n; ++i) { | |
| points[i] = point(node, touches[i]); | |
| } | |
| return points; | |
| }; | |
| exports.creator = creator; | |
| exports.local = local; | |
| exports.matcher = matcher$1; | |
| exports.mouse = mouse; | |
| exports.namespace = namespace; | |
| exports.namespaces = namespaces; | |
| exports.clientPoint = point; | |
| exports.select = select; | |
| exports.selectAll = selectAll; | |
| exports.selection = selection; | |
| exports.selector = selector; | |
| exports.selectorAll = selectorAll; | |
| exports.style = styleValue; | |
| exports.touch = touch; | |
| exports.touches = touches; | |
| exports.window = defaultView; | |
| exports.customEvent = customEvent; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| }))); | |
| },{}],12:[function(require,module,exports){ | |
| // https://d3js.org/d3-shape/ Version 1.2.0. Copyright 2017 Mike Bostock. | |
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-path')) : | |
| typeof define === 'function' && define.amd ? define(['exports', 'd3-path'], factory) : | |
| (factory((global.d3 = global.d3 || {}),global.d3)); | |
| }(this, (function (exports,d3Path) { 'use strict'; | |
| var constant = function(x) { | |
| return function constant() { | |
| return x; | |
| }; | |
| }; | |
| var abs = Math.abs; | |
| var atan2 = Math.atan2; | |
| var cos = Math.cos; | |
| var max = Math.max; | |
| var min = Math.min; | |
| var sin = Math.sin; | |
| var sqrt = Math.sqrt; | |
| var epsilon = 1e-12; | |
| var pi = Math.PI; | |
| var halfPi = pi / 2; | |
| var tau = 2 * pi; | |
| function acos(x) { | |
| return x > 1 ? 0 : x < -1 ? pi : Math.acos(x); | |
| } | |
| function asin(x) { | |
| return x >= 1 ? halfPi : x <= -1 ? -halfPi : Math.asin(x); | |
| } | |
| function arcInnerRadius(d) { | |
| return d.innerRadius; | |
| } | |
| function arcOuterRadius(d) { | |
| return d.outerRadius; | |
| } | |
| function arcStartAngle(d) { | |
| return d.startAngle; | |
| } | |
| function arcEndAngle(d) { | |
| return d.endAngle; | |
| } | |
| function arcPadAngle(d) { | |
| return d && d.padAngle; // Note: optional! | |
| } | |
| function intersect(x0, y0, x1, y1, x2, y2, x3, y3) { | |
| var x10 = x1 - x0, y10 = y1 - y0, | |
| x32 = x3 - x2, y32 = y3 - y2, | |
| t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / (y32 * x10 - x32 * y10); | |
| return [x0 + t * x10, y0 + t * y10]; | |
| } | |
| // Compute perpendicular offset line of length rc. | |
| // http://mathworld.wolfram.com/Circle-LineIntersection.html | |
| function cornerTangents(x0, y0, x1, y1, r1, rc, cw) { | |
| var x01 = x0 - x1, | |
| y01 = y0 - y1, | |
| lo = (cw ? rc : -rc) / sqrt(x01 * x01 + y01 * y01), | |
| ox = lo * y01, | |
| oy = -lo * x01, | |
| x11 = x0 + ox, | |
| y11 = y0 + oy, | |
| x10 = x1 + ox, | |
| y10 = y1 + oy, | |
| x00 = (x11 + x10) / 2, | |
| y00 = (y11 + y10) / 2, | |
| dx = x10 - x11, | |
| dy = y10 - y11, | |
| d2 = dx * dx + dy * dy, | |
| r = r1 - rc, | |
| D = x11 * y10 - x10 * y11, | |
| d = (dy < 0 ? -1 : 1) * sqrt(max(0, r * r * d2 - D * D)), | |
| cx0 = (D * dy - dx * d) / d2, | |
| cy0 = (-D * dx - dy * d) / d2, | |
| cx1 = (D * dy + dx * d) / d2, | |
| cy1 = (-D * dx + dy * d) / d2, | |
| dx0 = cx0 - x00, | |
| dy0 = cy0 - y00, | |
| dx1 = cx1 - x00, | |
| dy1 = cy1 - y00; | |
| // Pick the closer of the two intersection points. | |
| // TODO Is there a faster way to determine which intersection to use? | |
| if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1; | |
| return { | |
| cx: cx0, | |
| cy: cy0, | |
| x01: -ox, | |
| y01: -oy, | |
| x11: cx0 * (r1 / r - 1), | |
| y11: cy0 * (r1 / r - 1) | |
| }; | |
| } | |
| var arc = function() { | |
| var innerRadius = arcInnerRadius, | |
| outerRadius = arcOuterRadius, | |
| cornerRadius = constant(0), | |
| padRadius = null, | |
| startAngle = arcStartAngle, | |
| endAngle = arcEndAngle, | |
| padAngle = arcPadAngle, | |
| context = null; | |
| function arc() { | |
| var buffer, | |
| r, | |
| r0 = +innerRadius.apply(this, arguments), | |
| r1 = +outerRadius.apply(this, arguments), | |
| a0 = startAngle.apply(this, arguments) - halfPi, | |
| a1 = endAngle.apply(this, arguments) - halfPi, | |
| da = abs(a1 - a0), | |
| cw = a1 > a0; | |
| if (!context) context = buffer = d3Path.path(); | |
| // Ensure that the outer radius is always larger than the inner radius. | |
| if (r1 < r0) r = r1, r1 = r0, r0 = r; | |
| // Is it a point? | |
| if (!(r1 > epsilon)) context.moveTo(0, 0); | |
| // Or is it a circle or annulus? | |
| else if (da > tau - epsilon) { | |
| context.moveTo(r1 * cos(a0), r1 * sin(a0)); | |
| context.arc(0, 0, r1, a0, a1, !cw); | |
| if (r0 > epsilon) { | |
| context.moveTo(r0 * cos(a1), r0 * sin(a1)); | |
| context.arc(0, 0, r0, a1, a0, cw); | |
| } | |
| } | |
| // Or is it a circular or annular sector? | |
| else { | |
| var a01 = a0, | |
| a11 = a1, | |
| a00 = a0, | |
| a10 = a1, | |
| da0 = da, | |
| da1 = da, | |
| ap = padAngle.apply(this, arguments) / 2, | |
| rp = (ap > epsilon) && (padRadius ? +padRadius.apply(this, arguments) : sqrt(r0 * r0 + r1 * r1)), | |
| rc = min(abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments)), | |
| rc0 = rc, | |
| rc1 = rc, | |
| t0, | |
| t1; | |
| // Apply padding? Note that since r1 ≥ r0, da1 ≥ da0. | |
| if (rp > epsilon) { | |
| var p0 = asin(rp / r0 * sin(ap)), | |
| p1 = asin(rp / r1 * sin(ap)); | |
| if ((da0 -= p0 * 2) > epsilon) p0 *= (cw ? 1 : -1), a00 += p0, a10 -= p0; | |
| else da0 = 0, a00 = a10 = (a0 + a1) / 2; | |
| if ((da1 -= p1 * 2) > epsilon) p1 *= (cw ? 1 : -1), a01 += p1, a11 -= p1; | |
| else da1 = 0, a01 = a11 = (a0 + a1) / 2; | |
| } | |
| var x01 = r1 * cos(a01), | |
| y01 = r1 * sin(a01), | |
| x10 = r0 * cos(a10), | |
| y10 = r0 * sin(a10); | |
| // Apply rounded corners? | |
| if (rc > epsilon) { | |
| var x11 = r1 * cos(a11), | |
| y11 = r1 * sin(a11), | |
| x00 = r0 * cos(a00), | |
| y00 = r0 * sin(a00); | |
| // Restrict the corner radius according to the sector angle. | |
| if (da < pi) { | |
| var oc = da0 > epsilon ? intersect(x01, y01, x00, y00, x11, y11, x10, y10) : [x10, y10], | |
| ax = x01 - oc[0], | |
| ay = y01 - oc[1], | |
| bx = x11 - oc[0], | |
| by = y11 - oc[1], | |
| kc = 1 / sin(acos((ax * bx + ay * by) / (sqrt(ax * ax + ay * ay) * sqrt(bx * bx + by * by))) / 2), | |
| lc = sqrt(oc[0] * oc[0] + oc[1] * oc[1]); | |
| rc0 = min(rc, (r0 - lc) / (kc - 1)); | |
| rc1 = min(rc, (r1 - lc) / (kc + 1)); | |
| } | |
| } | |
| // Is the sector collapsed to a line? | |
| if (!(da1 > epsilon)) context.moveTo(x01, y01); | |
| // Does the sector’s outer ring have rounded corners? | |
| else if (rc1 > epsilon) { | |
| t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw); | |
| t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw); | |
| context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01); | |
| // Have the corners merged? | |
| if (rc1 < rc) context.arc(t0.cx, t0.cy, rc1, atan2(t0.y01, t0.x01), atan2(t1.y01, t1.x01), !cw); | |
| // Otherwise, draw the two corners and the ring. | |
| else { | |
| context.arc(t0.cx, t0.cy, rc1, atan2(t0.y01, t0.x01), atan2(t0.y11, t0.x11), !cw); | |
| context.arc(0, 0, r1, atan2(t0.cy + t0.y11, t0.cx + t0.x11), atan2(t1.cy + t1.y11, t1.cx + t1.x11), !cw); | |
| context.arc(t1.cx, t1.cy, rc1, atan2(t1.y11, t1.x11), atan2(t1.y01, t1.x01), !cw); | |
| } | |
| } | |
| // Or is the outer ring just a circular arc? | |
| else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw); | |
| // Is there no inner ring, and it’s a circular sector? | |
| // Or perhaps it’s an annular sector collapsed due to padding? | |
| if (!(r0 > epsilon) || !(da0 > epsilon)) context.lineTo(x10, y10); | |
| // Does the sector’s inner ring (or point) have rounded corners? | |
| else if (rc0 > epsilon) { | |
| t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw); | |
| t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw); | |
| context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01); | |
| // Have the corners merged? | |
| if (rc0 < rc) context.arc(t0.cx, t0.cy, rc0, atan2(t0.y01, t0.x01), atan2(t1.y01, t1.x01), !cw); | |
| // Otherwise, draw the two corners and the ring. | |
| else { | |
| context.arc(t0.cx, t0.cy, rc0, atan2(t0.y01, t0.x01), atan2(t0.y11, t0.x11), !cw); | |
| context.arc(0, 0, r0, atan2(t0.cy + t0.y11, t0.cx + t0.x11), atan2(t1.cy + t1.y11, t1.cx + t1.x11), cw); | |
| context.arc(t1.cx, t1.cy, rc0, atan2(t1.y11, t1.x11), atan2(t1.y01, t1.x01), !cw); | |
| } | |
| } | |
| // Or is the inner ring just a circular arc? | |
| else context.arc(0, 0, r0, a10, a00, cw); | |
| } | |
| context.closePath(); | |
| if (buffer) return context = null, buffer + "" || null; | |
| } | |
| arc.centroid = function() { | |
| var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, | |
| a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi / 2; | |
| return [cos(a) * r, sin(a) * r]; | |
| }; | |
| arc.innerRadius = function(_) { | |
| return arguments.length ? (innerRadius = typeof _ === "function" ? _ : constant(+_), arc) : innerRadius; | |
| }; | |
| arc.outerRadius = function(_) { | |
| return arguments.length ? (outerRadius = typeof _ === "function" ? _ : constant(+_), arc) : outerRadius; | |
| }; | |
| arc.cornerRadius = function(_) { | |
| return arguments.length ? (cornerRadius = typeof _ === "function" ? _ : constant(+_), arc) : cornerRadius; | |
| }; | |
| arc.padRadius = function(_) { | |
| return arguments.length ? (padRadius = _ == null ? null : typeof _ === "function" ? _ : constant(+_), arc) : padRadius; | |
| }; | |
| arc.startAngle = function(_) { | |
| return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant(+_), arc) : startAngle; | |
| }; | |
| arc.endAngle = function(_) { | |
| return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant(+_), arc) : endAngle; | |
| }; | |
| arc.padAngle = function(_) { | |
| return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant(+_), arc) : padAngle; | |
| }; | |
| arc.context = function(_) { | |
| return arguments.length ? ((context = _ == null ? null : _), arc) : context; | |
| }; | |
| return arc; | |
| }; | |
| function Linear(context) { | |
| this._context = context; | |
| } | |
| Linear.prototype = { | |
| areaStart: function() { | |
| this._line = 0; | |
| }, | |
| areaEnd: function() { | |
| this._line = NaN; | |
| }, | |
| lineStart: function() { | |
| this._point = 0; | |
| }, | |
| lineEnd: function() { | |
| if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); | |
| this._line = 1 - this._line; | |
| }, | |
| point: function(x, y) { | |
| x = +x, y = +y; | |
| switch (this._point) { | |
| case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; | |
| case 1: this._point = 2; // proceed | |
| default: this._context.lineTo(x, y); break; | |
| } | |
| } | |
| }; | |
| var curveLinear = function(context) { | |
| return new Linear(context); | |
| }; | |
| function x(p) { | |
| return p[0]; | |
| } | |
| function y(p) { | |
| return p[1]; | |
| } | |
| var line = function() { | |
| var x$$1 = x, | |
| y$$1 = y, | |
| defined = constant(true), | |
| context = null, | |
| curve = curveLinear, | |
| output = null; | |
| function line(data) { | |
| var i, | |
| n = data.length, | |
| d, | |
| defined0 = false, | |
| buffer; | |
| if (context == null) output = curve(buffer = d3Path.path()); | |
| for (i = 0; i <= n; ++i) { | |
| if (!(i < n && defined(d = data[i], i, data)) === defined0) { | |
| if (defined0 = !defined0) output.lineStart(); | |
| else output.lineEnd(); | |
| } | |
| if (defined0) output.point(+x$$1(d, i, data), +y$$1(d, i, data)); | |
| } | |
| if (buffer) return output = null, buffer + "" || null; | |
| } | |
| line.x = function(_) { | |
| return arguments.length ? (x$$1 = typeof _ === "function" ? _ : constant(+_), line) : x$$1; | |
| }; | |
| line.y = function(_) { | |
| return arguments.length ? (y$$1 = typeof _ === "function" ? _ : constant(+_), line) : y$$1; | |
| }; | |
| line.defined = function(_) { | |
| return arguments.length ? (defined = typeof _ === "function" ? _ : constant(!!_), line) : defined; | |
| }; | |
| line.curve = function(_) { | |
| return arguments.length ? (curve = _, context != null && (output = curve(context)), line) : curve; | |
| }; | |
| line.context = function(_) { | |
| return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), line) : context; | |
| }; | |
| return line; | |
| }; | |
| var area = function() { | |
| var x0 = x, | |
| x1 = null, | |
| y0 = constant(0), | |
| y1 = y, | |
| defined = constant(true), | |
| context = null, | |
| curve = curveLinear, | |
| output = null; | |
| function area(data) { | |
| var i, | |
| j, | |
| k, | |
| n = data.length, | |
| d, | |
| defined0 = false, | |
| buffer, | |
| x0z = new Array(n), | |
| y0z = new Array(n); | |
| if (context == null) output = curve(buffer = d3Path.path()); | |
| for (i = 0; i <= n; ++i) { | |
| if (!(i < n && defined(d = data[i], i, data)) === defined0) { | |
| if (defined0 = !defined0) { | |
| j = i; | |
| output.areaStart(); | |
| output.lineStart(); | |
| } else { | |
| output.lineEnd(); | |
| output.lineStart(); | |
| for (k = i - 1; k >= j; --k) { | |
| output.point(x0z[k], y0z[k]); | |
| } | |
| output.lineEnd(); | |
| output.areaEnd(); | |
| } | |
| } | |
| if (defined0) { | |
| x0z[i] = +x0(d, i, data), y0z[i] = +y0(d, i, data); | |
| output.point(x1 ? +x1(d, i, data) : x0z[i], y1 ? +y1(d, i, data) : y0z[i]); | |
| } | |
| } | |
| if (buffer) return output = null, buffer + "" || null; | |
| } | |
| function arealine() { | |
| return line().defined(defined).curve(curve).context(context); | |
| } | |
| area.x = function(_) { | |
| return arguments.length ? (x0 = typeof _ === "function" ? _ : constant(+_), x1 = null, area) : x0; | |
| }; | |
| area.x0 = function(_) { | |
| return arguments.length ? (x0 = typeof _ === "function" ? _ : constant(+_), area) : x0; | |
| }; | |
| area.x1 = function(_) { | |
| return arguments.length ? (x1 = _ == null ? null : typeof _ === "function" ? _ : constant(+_), area) : x1; | |
| }; | |
| area.y = function(_) { | |
| return arguments.length ? (y0 = typeof _ === "function" ? _ : constant(+_), y1 = null, area) : y0; | |
| }; | |
| area.y0 = function(_) { | |
| return arguments.length ? (y0 = typeof _ === "function" ? _ : constant(+_), area) : y0; | |
| }; | |
| area.y1 = function(_) { | |
| return arguments.length ? (y1 = _ == null ? null : typeof _ === "function" ? _ : constant(+_), area) : y1; | |
| }; | |
| area.lineX0 = | |
| area.lineY0 = function() { | |
| return arealine().x(x0).y(y0); | |
| }; | |
| area.lineY1 = function() { | |
| return arealine().x(x0).y(y1); | |
| }; | |
| area.lineX1 = function() { | |
| return arealine().x(x1).y(y0); | |
| }; | |
| area.defined = function(_) { | |
| return arguments.length ? (defined = typeof _ === "function" ? _ : constant(!!_), area) : defined; | |
| }; | |
| area.curve = function(_) { | |
| return arguments.length ? (curve = _, context != null && (output = curve(context)), area) : curve; | |
| }; | |
| area.context = function(_) { | |
| return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), area) : context; | |
| }; | |
| return area; | |
| }; | |
| var descending = function(a, b) { | |
| return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; | |
| }; | |
| var identity = function(d) { | |
| return d; | |
| }; | |
| var pie = function() { | |
| var value = identity, | |
| sortValues = descending, | |
| sort = null, | |
| startAngle = constant(0), | |
| endAngle = constant(tau), | |
| padAngle = constant(0); | |
| function pie(data) { | |
| var i, | |
| n = data.length, | |
| j, | |
| k, | |
| sum = 0, | |
| index = new Array(n), | |
| arcs = new Array(n), | |
| a0 = +startAngle.apply(this, arguments), | |
| da = Math.min(tau, Math.max(-tau, endAngle.apply(this, arguments) - a0)), | |
| a1, | |
| p = Math.min(Math.abs(da) / n, padAngle.apply(this, arguments)), | |
| pa = p * (da < 0 ? -1 : 1), | |
| v; | |
| for (i = 0; i < n; ++i) { | |
| if ((v = arcs[index[i] = i] = +value(data[i], i, data)) > 0) { | |
| sum += v; | |
| } | |
| } | |
| // Optionally sort the arcs by previously-computed values or by data. | |
| if (sortValues != null) index.sort(function(i, j) { return sortValues(arcs[i], arcs[j]); }); | |
| else if (sort != null) index.sort(function(i, j) { return sort(data[i], data[j]); }); | |
| // Compute the arcs! They are stored in the original data's order. | |
| for (i = 0, k = sum ? (da - n * pa) / sum : 0; i < n; ++i, a0 = a1) { | |
| j = index[i], v = arcs[j], a1 = a0 + (v > 0 ? v * k : 0) + pa, arcs[j] = { | |
| data: data[j], | |
| index: i, | |
| value: v, | |
| startAngle: a0, | |
| endAngle: a1, | |
| padAngle: p | |
| }; | |
| } | |
| return arcs; | |
| } | |
| pie.value = function(_) { | |
| return arguments.length ? (value = typeof _ === "function" ? _ : constant(+_), pie) : value; | |
| }; | |
| pie.sortValues = function(_) { | |
| return arguments.length ? (sortValues = _, sort = null, pie) : sortValues; | |
| }; | |
| pie.sort = function(_) { | |
| return arguments.length ? (sort = _, sortValues = null, pie) : sort; | |
| }; | |
| pie.startAngle = function(_) { | |
| return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant(+_), pie) : startAngle; | |
| }; | |
| pie.endAngle = function(_) { | |
| return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant(+_), pie) : endAngle; | |
| }; | |
| pie.padAngle = function(_) { | |
| return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant(+_), pie) : padAngle; | |
| }; | |
| return pie; | |
| }; | |
| var curveRadialLinear = curveRadial(curveLinear); | |
| function Radial(curve) { | |
| this._curve = curve; | |
| } | |
| Radial.prototype = { | |
| areaStart: function() { | |
| this._curve.areaStart(); | |
| }, | |
| areaEnd: function() { | |
| this._curve.areaEnd(); | |
| }, | |
| lineStart: function() { | |
| this._curve.lineStart(); | |
| }, | |
| lineEnd: function() { | |
| this._curve.lineEnd(); | |
| }, | |
| point: function(a, r) { | |
| this._curve.point(r * Math.sin(a), r * -Math.cos(a)); | |
| } | |
| }; | |
| function curveRadial(curve) { | |
| function radial(context) { | |
| return new Radial(curve(context)); | |
| } | |
| radial._curve = curve; | |
| return radial; | |
| } | |
| function lineRadial(l) { | |
| var c = l.curve; | |
| l.angle = l.x, delete l.x; | |
| l.radius = l.y, delete l.y; | |
| l.curve = function(_) { | |
| return arguments.length ? c(curveRadial(_)) : c()._curve; | |
| }; | |
| return l; | |
| } | |
| var lineRadial$1 = function() { | |
| return lineRadial(line().curve(curveRadialLinear)); | |
| }; | |
| var areaRadial = function() { | |
| var a = area().curve(curveRadialLinear), | |
| c = a.curve, | |
| x0 = a.lineX0, | |
| x1 = a.lineX1, | |
| y0 = a.lineY0, | |
| y1 = a.lineY1; | |
| a.angle = a.x, delete a.x; | |
| a.startAngle = a.x0, delete a.x0; | |
| a.endAngle = a.x1, delete a.x1; | |
| a.radius = a.y, delete a.y; | |
| a.innerRadius = a.y0, delete a.y0; | |
| a.outerRadius = a.y1, delete a.y1; | |
| a.lineStartAngle = function() { return lineRadial(x0()); }, delete a.lineX0; | |
| a.lineEndAngle = function() { return lineRadial(x1()); }, delete a.lineX1; | |
| a.lineInnerRadius = function() { return lineRadial(y0()); }, delete a.lineY0; | |
| a.lineOuterRadius = function() { return lineRadial(y1()); }, delete a.lineY1; | |
| a.curve = function(_) { | |
| return arguments.length ? c(curveRadial(_)) : c()._curve; | |
| }; | |
| return a; | |
| }; | |
| var pointRadial = function(x, y) { | |
| return [(y = +y) * Math.cos(x -= Math.PI / 2), y * Math.sin(x)]; | |
| }; | |
| var slice = Array.prototype.slice; | |
| function linkSource(d) { | |
| return d.source; | |
| } | |
| function linkTarget(d) { | |
| return d.target; | |
| } | |
| function link(curve) { | |
| var source = linkSource, | |
| target = linkTarget, | |
| x$$1 = x, | |
| y$$1 = y, | |
| context = null; | |
| function link() { | |
| var buffer, argv = slice.call(arguments), s = source.apply(this, argv), t = target.apply(this, argv); | |
| if (!context) context = buffer = d3Path.path(); | |
| curve(context, +x$$1.apply(this, (argv[0] = s, argv)), +y$$1.apply(this, argv), +x$$1.apply(this, (argv[0] = t, argv)), +y$$1.apply(this, argv)); | |
| if (buffer) return context = null, buffer + "" || null; | |
| } | |
| link.source = function(_) { | |
| return arguments.length ? (source = _, link) : source; | |
| }; | |
| link.target = function(_) { | |
| return arguments.length ? (target = _, link) : target; | |
| }; | |
| link.x = function(_) { | |
| return arguments.length ? (x$$1 = typeof _ === "function" ? _ : constant(+_), link) : x$$1; | |
| }; | |
| link.y = function(_) { | |
| return arguments.length ? (y$$1 = typeof _ === "function" ? _ : constant(+_), link) : y$$1; | |
| }; | |
| link.context = function(_) { | |
| return arguments.length ? ((context = _ == null ? null : _), link) : context; | |
| }; | |
| return link; | |
| } | |
| function curveHorizontal(context, x0, y0, x1, y1) { | |
| context.moveTo(x0, y0); | |
| context.bezierCurveTo(x0 = (x0 + x1) / 2, y0, x0, y1, x1, y1); | |
| } | |
| function curveVertical(context, x0, y0, x1, y1) { | |
| context.moveTo(x0, y0); | |
| context.bezierCurveTo(x0, y0 = (y0 + y1) / 2, x1, y0, x1, y1); | |
| } | |
| function curveRadial$1(context, x0, y0, x1, y1) { | |
| var p0 = pointRadial(x0, y0), | |
| p1 = pointRadial(x0, y0 = (y0 + y1) / 2), | |
| p2 = pointRadial(x1, y0), | |
| p3 = pointRadial(x1, y1); | |
| context.moveTo(p0[0], p0[1]); | |
| context.bezierCurveTo(p1[0], p1[1], p2[0], p2[1], p3[0], p3[1]); | |
| } | |
| function linkHorizontal() { | |
| return link(curveHorizontal); | |
| } | |
| function linkVertical() { | |
| return link(curveVertical); | |
| } | |
| function linkRadial() { | |
| var l = link(curveRadial$1); | |
| l.angle = l.x, delete l.x; | |
| l.radius = l.y, delete l.y; | |
| return l; | |
| } | |
| var circle = { | |
| draw: function(context, size) { | |
| var r = Math.sqrt(size / pi); | |
| context.moveTo(r, 0); | |
| context.arc(0, 0, r, 0, tau); | |
| } | |
| }; | |
| var cross = { | |
| draw: function(context, size) { | |
| var r = Math.sqrt(size / 5) / 2; | |
| context.moveTo(-3 * r, -r); | |
| context.lineTo(-r, -r); | |
| context.lineTo(-r, -3 * r); | |
| context.lineTo(r, -3 * r); | |
| context.lineTo(r, -r); | |
| context.lineTo(3 * r, -r); | |
| context.lineTo(3 * r, r); | |
| context.lineTo(r, r); | |
| context.lineTo(r, 3 * r); | |
| context.lineTo(-r, 3 * r); | |
| context.lineTo(-r, r); | |
| context.lineTo(-3 * r, r); | |
| context.closePath(); | |
| } | |
| }; | |
| var tan30 = Math.sqrt(1 / 3); | |
| var tan30_2 = tan30 * 2; | |
| var diamond = { | |
| draw: function(context, size) { | |
| var y = Math.sqrt(size / tan30_2), | |
| x = y * tan30; | |
| context.moveTo(0, -y); | |
| context.lineTo(x, 0); | |
| context.lineTo(0, y); | |
| context.lineTo(-x, 0); | |
| context.closePath(); | |
| } | |
| }; | |
| var ka = 0.89081309152928522810; | |
| var kr = Math.sin(pi / 10) / Math.sin(7 * pi / 10); | |
| var kx = Math.sin(tau / 10) * kr; | |
| var ky = -Math.cos(tau / 10) * kr; | |
| var star = { | |
| draw: function(context, size) { | |
| var r = Math.sqrt(size * ka), | |
| x = kx * r, | |
| y = ky * r; | |
| context.moveTo(0, -r); | |
| context.lineTo(x, y); | |
| for (var i = 1; i < 5; ++i) { | |
| var a = tau * i / 5, | |
| c = Math.cos(a), | |
| s = Math.sin(a); | |
| context.lineTo(s * r, -c * r); | |
| context.lineTo(c * x - s * y, s * x + c * y); | |
| } | |
| context.closePath(); | |
| } | |
| }; | |
| var square = { | |
| draw: function(context, size) { | |
| var w = Math.sqrt(size), | |
| x = -w / 2; | |
| context.rect(x, x, w, w); | |
| } | |
| }; | |
| var sqrt3 = Math.sqrt(3); | |
| var triangle = { | |
| draw: function(context, size) { | |
| var y = -Math.sqrt(size / (sqrt3 * 3)); | |
| context.moveTo(0, y * 2); | |
| context.lineTo(-sqrt3 * y, -y); | |
| context.lineTo(sqrt3 * y, -y); | |
| context.closePath(); | |
| } | |
| }; | |
| var c = -0.5; | |
| var s = Math.sqrt(3) / 2; | |
| var k = 1 / Math.sqrt(12); | |
| var a = (k / 2 + 1) * 3; | |
| var wye = { | |
| draw: function(context, size) { | |
| var r = Math.sqrt(size / a), | |
| x0 = r / 2, | |
| y0 = r * k, | |
| x1 = x0, | |
| y1 = r * k + r, | |
| x2 = -x1, | |
| y2 = y1; | |
| context.moveTo(x0, y0); | |
| context.lineTo(x1, y1); | |
| context.lineTo(x2, y2); | |
| context.lineTo(c * x0 - s * y0, s * x0 + c * y0); | |
| context.lineTo(c * x1 - s * y1, s * x1 + c * y1); | |
| context.lineTo(c * x2 - s * y2, s * x2 + c * y2); | |
| context.lineTo(c * x0 + s * y0, c * y0 - s * x0); | |
| context.lineTo(c * x1 + s * y1, c * y1 - s * x1); | |
| context.lineTo(c * x2 + s * y2, c * y2 - s * x2); | |
| context.closePath(); | |
| } | |
| }; | |
| var symbols = [ | |
| circle, | |
| cross, | |
| diamond, | |
| square, | |
| star, | |
| triangle, | |
| wye | |
| ]; | |
| var symbol = function() { | |
| var type = constant(circle), | |
| size = constant(64), | |
| context = null; | |
| function symbol() { | |
| var buffer; | |
| if (!context) context = buffer = d3Path.path(); | |
| type.apply(this, arguments).draw(context, +size.apply(this, arguments)); | |
| if (buffer) return context = null, buffer + "" || null; | |
| } | |
| symbol.type = function(_) { | |
| return arguments.length ? (type = typeof _ === "function" ? _ : constant(_), symbol) : type; | |
| }; | |
| symbol.size = function(_) { | |
| return arguments.length ? (size = typeof _ === "function" ? _ : constant(+_), symbol) : size; | |
| }; | |
| symbol.context = function(_) { | |
| return arguments.length ? (context = _ == null ? null : _, symbol) : context; | |
| }; | |
| return symbol; | |
| }; | |
| var noop = function() {}; | |
| function point(that, x, y) { | |
| that._context.bezierCurveTo( | |
| (2 * that._x0 + that._x1) / 3, | |
| (2 * that._y0 + that._y1) / 3, | |
| (that._x0 + 2 * that._x1) / 3, | |
| (that._y0 + 2 * that._y1) / 3, | |
| (that._x0 + 4 * that._x1 + x) / 6, | |
| (that._y0 + 4 * that._y1 + y) / 6 | |
| ); | |
| } | |
| function Basis(context) { | |
| this._context = context; | |
| } | |
| Basis.prototype = { | |
| areaStart: function() { | |
| this._line = 0; | |
| }, | |
| areaEnd: function() { | |
| this._line = NaN; | |
| }, | |
| lineStart: function() { | |
| this._x0 = this._x1 = | |
| this._y0 = this._y1 = NaN; | |
| this._point = 0; | |
| }, | |
| lineEnd: function() { | |
| switch (this._point) { | |
| case 3: point(this, this._x1, this._y1); // proceed | |
| case 2: this._context.lineTo(this._x1, this._y1); break; | |
| } | |
| if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); | |
| this._line = 1 - this._line; | |
| }, | |
| point: function(x, y) { | |
| x = +x, y = +y; | |
| switch (this._point) { | |
| case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; | |
| case 1: this._point = 2; break; | |
| case 2: this._point = 3; this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6); // proceed | |
| default: point(this, x, y); break; | |
| } | |
| this._x0 = this._x1, this._x1 = x; | |
| this._y0 = this._y1, this._y1 = y; | |
| } | |
| }; | |
| var basis = function(context) { | |
| return new Basis(context); | |
| }; | |
| function BasisClosed(context) { | |
| this._context = context; | |
| } | |
| BasisClosed.prototype = { | |
| areaStart: noop, | |
| areaEnd: noop, | |
| lineStart: function() { | |
| this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = | |
| this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN; | |
| this._point = 0; | |
| }, | |
| lineEnd: function() { | |
| switch (this._point) { | |
| case 1: { | |
| this._context.moveTo(this._x2, this._y2); | |
| this._context.closePath(); | |
| break; | |
| } | |
| case 2: { | |
| this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3); | |
| this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3); | |
| this._context.closePath(); | |
| break; | |
| } | |
| case 3: { | |
| this.point(this._x2, this._y2); | |
| this.point(this._x3, this._y3); | |
| this.point(this._x4, this._y4); | |
| break; | |
| } | |
| } | |
| }, | |
| point: function(x, y) { | |
| x = +x, y = +y; | |
| switch (this._point) { | |
| case 0: this._point = 1; this._x2 = x, this._y2 = y; break; | |
| case 1: this._point = 2; this._x3 = x, this._y3 = y; break; | |
| case 2: this._point = 3; this._x4 = x, this._y4 = y; this._context.moveTo((this._x0 + 4 * this._x1 + x) / 6, (this._y0 + 4 * this._y1 + y) / 6); break; | |
| default: point(this, x, y); break; | |
| } | |
| this._x0 = this._x1, this._x1 = x; | |
| this._y0 = this._y1, this._y1 = y; | |
| } | |
| }; | |
| var basisClosed = function(context) { | |
| return new BasisClosed(context); | |
| }; | |
| function BasisOpen(context) { | |
| this._context = context; | |
| } | |
| BasisOpen.prototype = { | |
| areaStart: function() { | |
| this._line = 0; | |
| }, | |
| areaEnd: function() { | |
| this._line = NaN; | |
| }, | |
| lineStart: function() { | |
| this._x0 = this._x1 = | |
| this._y0 = this._y1 = NaN; | |
| this._point = 0; | |
| }, | |
| lineEnd: function() { | |
| if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath(); | |
| this._line = 1 - this._line; | |
| }, | |
| point: function(x, y) { | |
| x = +x, y = +y; | |
| switch (this._point) { | |
| case 0: this._point = 1; break; | |
| case 1: this._point = 2; break; | |
| case 2: this._point = 3; var x0 = (this._x0 + 4 * this._x1 + x) / 6, y0 = (this._y0 + 4 * this._y1 + y) / 6; this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0); break; | |
| case 3: this._point = 4; // proceed | |
| default: point(this, x, y); break; | |
| } | |
| this._x0 = this._x1, this._x1 = x; | |
| this._y0 = this._y1, this._y1 = y; | |
| } | |
| }; | |
| var basisOpen = function(context) { | |
| return new BasisOpen(context); | |
| }; | |
| function Bundle(context, beta) { | |
| this._basis = new Basis(context); | |
| this._beta = beta; | |
| } | |
| Bundle.prototype = { | |
| lineStart: function() { | |
| this._x = []; | |
| this._y = []; | |
| this._basis.lineStart(); | |
| }, | |
| lineEnd: function() { | |
| var x = this._x, | |
| y = this._y, | |
| j = x.length - 1; | |
| if (j > 0) { | |
| var x0 = x[0], | |
| y0 = y[0], | |
| dx = x[j] - x0, | |
| dy = y[j] - y0, | |
| i = -1, | |
| t; | |
| while (++i <= j) { | |
| t = i / j; | |
| this._basis.point( | |
| this._beta * x[i] + (1 - this._beta) * (x0 + t * dx), | |
| this._beta * y[i] + (1 - this._beta) * (y0 + t * dy) | |
| ); | |
| } | |
| } | |
| this._x = this._y = null; | |
| this._basis.lineEnd(); | |
| }, | |
| point: function(x, y) { | |
| this._x.push(+x); | |
| this._y.push(+y); | |
| } | |
| }; | |
| var bundle = ((function custom(beta) { | |
| function bundle(context) { | |
| return beta === 1 ? new Basis(context) : new Bundle(context, beta); | |
| } | |
| bundle.beta = function(beta) { | |
| return custom(+beta); | |
| }; | |
| return bundle; | |
| }))(0.85); | |
| function point$1(that, x, y) { | |
| that._context.bezierCurveTo( | |
| that._x1 + that._k * (that._x2 - that._x0), | |
| that._y1 + that._k * (that._y2 - that._y0), | |
| that._x2 + that._k * (that._x1 - x), | |
| that._y2 + that._k * (that._y1 - y), | |
| that._x2, | |
| that._y2 | |
| ); | |
| } | |
| function Cardinal(context, tension) { | |
| this._context = context; | |
| this._k = (1 - tension) / 6; | |
| } | |
| Cardinal.prototype = { | |
| areaStart: function() { | |
| this._line = 0; | |
| }, | |
| areaEnd: function() { | |
| this._line = NaN; | |
| }, | |
| lineStart: function() { | |
| this._x0 = this._x1 = this._x2 = | |
| this._y0 = this._y1 = this._y2 = NaN; | |
| this._point = 0; | |
| }, | |
| lineEnd: function() { | |
| switch (this._point) { | |
| case 2: this._context.lineTo(this._x2, this._y2); break; | |
| case 3: point$1(this, this._x1, this._y1); break; | |
| } | |
| if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); | |
| this._line = 1 - this._line; | |
| }, | |
| point: function(x, y) { | |
| x = +x, y = +y; | |
| switch (this._point) { | |
| case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; | |
| case 1: this._point = 2; this._x1 = x, this._y1 = y; break; | |
| case 2: this._point = 3; // proceed | |
| default: point$1(this, x, y); break; | |
| } | |
| this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; | |
| this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; | |
| } | |
| }; | |
| var cardinal = ((function custom(tension) { | |
| function cardinal(context) { | |
| return new Cardinal(context, tension); | |
| } | |
| cardinal.tension = function(tension) { | |
| return custom(+tension); | |
| }; | |
| return cardinal; | |
| }))(0); | |
| function CardinalClosed(context, tension) { | |
| this._context = context; | |
| this._k = (1 - tension) / 6; | |
| } | |
| CardinalClosed.prototype = { | |
| areaStart: noop, | |
| areaEnd: noop, | |
| lineStart: function() { | |
| this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = | |
| this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN; | |
| this._point = 0; | |
| }, | |
| lineEnd: function() { | |
| switch (this._point) { | |
| case 1: { | |
| this._context.moveTo(this._x3, this._y3); | |
| this._context.closePath(); | |
| break; | |
| } | |
| case 2: { | |
| this._context.lineTo(this._x3, this._y3); | |
| this._context.closePath(); | |
| break; | |
| } | |
| case 3: { | |
| this.point(this._x3, this._y3); | |
| this.point(this._x4, this._y4); | |
| this.point(this._x5, this._y5); | |
| break; | |
| } | |
| } | |
| }, | |
| point: function(x, y) { | |
| x = +x, y = +y; | |
| switch (this._point) { | |
| case 0: this._point = 1; this._x3 = x, this._y3 = y; break; | |
| case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break; | |
| case 2: this._point = 3; this._x5 = x, this._y5 = y; break; | |
| default: point$1(this, x, y); break; | |
| } | |
| this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; | |
| this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; | |
| } | |
| }; | |
| var cardinalClosed = ((function custom(tension) { | |
| function cardinal(context) { | |
| return new CardinalClosed(context, tension); | |
| } | |
| cardinal.tension = function(tension) { | |
| return custom(+tension); | |
| }; | |
| return cardinal; | |
| }))(0); | |
| function CardinalOpen(context, tension) { | |
| this._context = context; | |
| this._k = (1 - tension) / 6; | |
| } | |
| CardinalOpen.prototype = { | |
| areaStart: function() { | |
| this._line = 0; | |
| }, | |
| areaEnd: function() { | |
| this._line = NaN; | |
| }, | |
| lineStart: function() { | |
| this._x0 = this._x1 = this._x2 = | |
| this._y0 = this._y1 = this._y2 = NaN; | |
| this._point = 0; | |
| }, | |
| lineEnd: function() { | |
| if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath(); | |
| this._line = 1 - this._line; | |
| }, | |
| point: function(x, y) { | |
| x = +x, y = +y; | |
| switch (this._point) { | |
| case 0: this._point = 1; break; | |
| case 1: this._point = 2; break; | |
| case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break; | |
| case 3: this._point = 4; // proceed | |
| default: point$1(this, x, y); break; | |
| } | |
| this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; | |
| this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; | |
| } | |
| }; | |
| var cardinalOpen = ((function custom(tension) { | |
| function cardinal(context) { | |
| return new CardinalOpen(context, tension); | |
| } | |
| cardinal.tension = function(tension) { | |
| return custom(+tension); | |
| }; | |
| return cardinal; | |
| }))(0); | |
| function point$2(that, x, y) { | |
| var x1 = that._x1, | |
| y1 = that._y1, | |
| x2 = that._x2, | |
| y2 = that._y2; | |
| if (that._l01_a > epsilon) { | |
| var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a, | |
| n = 3 * that._l01_a * (that._l01_a + that._l12_a); | |
| x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n; | |
| y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n; | |
| } | |
| if (that._l23_a > epsilon) { | |
| var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a, | |
| m = 3 * that._l23_a * (that._l23_a + that._l12_a); | |
| x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m; | |
| y2 = (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / m; | |
| } | |
| that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2); | |
| } | |
| function CatmullRom(context, alpha) { | |
| this._context = context; | |
| this._alpha = alpha; | |
| } | |
| CatmullRom.prototype = { | |
| areaStart: function() { | |
| this._line = 0; | |
| }, | |
| areaEnd: function() { | |
| this._line = NaN; | |
| }, | |
| lineStart: function() { | |
| this._x0 = this._x1 = this._x2 = | |
| this._y0 = this._y1 = this._y2 = NaN; | |
| this._l01_a = this._l12_a = this._l23_a = | |
| this._l01_2a = this._l12_2a = this._l23_2a = | |
| this._point = 0; | |
| }, | |
| lineEnd: function() { | |
| switch (this._point) { | |
| case 2: this._context.lineTo(this._x2, this._y2); break; | |
| case 3: this.point(this._x2, this._y2); break; | |
| } | |
| if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); | |
| this._line = 1 - this._line; | |
| }, | |
| point: function(x, y) { | |
| x = +x, y = +y; | |
| if (this._point) { | |
| var x23 = this._x2 - x, | |
| y23 = this._y2 - y; | |
| this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha)); | |
| } | |
| switch (this._point) { | |
| case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; | |
| case 1: this._point = 2; break; | |
| case 2: this._point = 3; // proceed | |
| default: point$2(this, x, y); break; | |
| } | |
| this._l01_a = this._l12_a, this._l12_a = this._l23_a; | |
| this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a; | |
| this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; | |
| this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; | |
| } | |
| }; | |
| var catmullRom = ((function custom(alpha) { | |
| function catmullRom(context) { | |
| return alpha ? new CatmullRom(context, alpha) : new Cardinal(context, 0); | |
| } | |
| catmullRom.alpha = function(alpha) { | |
| return custom(+alpha); | |
| }; | |
| return catmullRom; | |
| }))(0.5); | |
| function CatmullRomClosed(context, alpha) { | |
| this._context = context; | |
| this._alpha = alpha; | |
| } | |
| CatmullRomClosed.prototype = { | |
| areaStart: noop, | |
| areaEnd: noop, | |
| lineStart: function() { | |
| this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = | |
| this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN; | |
| this._l01_a = this._l12_a = this._l23_a = | |
| this._l01_2a = this._l12_2a = this._l23_2a = | |
| this._point = 0; | |
| }, | |
| lineEnd: function() { | |
| switch (this._point) { | |
| case 1: { | |
| this._context.moveTo(this._x3, this._y3); | |
| this._context.closePath(); | |
| break; | |
| } | |
| case 2: { | |
| this._context.lineTo(this._x3, this._y3); | |
| this._context.closePath(); | |
| break; | |
| } | |
| case 3: { | |
| this.point(this._x3, this._y3); | |
| this.point(this._x4, this._y4); | |
| this.point(this._x5, this._y5); | |
| break; | |
| } | |
| } | |
| }, | |
| point: function(x, y) { | |
| x = +x, y = +y; | |
| if (this._point) { | |
| var x23 = this._x2 - x, | |
| y23 = this._y2 - y; | |
| this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha)); | |
| } | |
| switch (this._point) { | |
| case 0: this._point = 1; this._x3 = x, this._y3 = y; break; | |
| case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break; | |
| case 2: this._point = 3; this._x5 = x, this._y5 = y; break; | |
| default: point$2(this, x, y); break; | |
| } | |
| this._l01_a = this._l12_a, this._l12_a = this._l23_a; | |
| this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a; | |
| this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; | |
| this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; | |
| } | |
| }; | |
| var catmullRomClosed = ((function custom(alpha) { | |
| function catmullRom(context) { | |
| return alpha ? new CatmullRomClosed(context, alpha) : new CardinalClosed(context, 0); | |
| } | |
| catmullRom.alpha = function(alpha) { | |
| return custom(+alpha); | |
| }; | |
| return catmullRom; | |
| }))(0.5); | |
| function CatmullRomOpen(context, alpha) { | |
| this._context = context; | |
| this._alpha = alpha; | |
| } | |
| CatmullRomOpen.prototype = { | |
| areaStart: function() { | |
| this._line = 0; | |
| }, | |
| areaEnd: function() { | |
| this._line = NaN; | |
| }, | |
| lineStart: function() { | |
| this._x0 = this._x1 = this._x2 = | |
| this._y0 = this._y1 = this._y2 = NaN; | |
| this._l01_a = this._l12_a = this._l23_a = | |
| this._l01_2a = this._l12_2a = this._l23_2a = | |
| this._point = 0; | |
| }, | |
| lineEnd: function() { | |
| if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath(); | |
| this._line = 1 - this._line; | |
| }, | |
| point: function(x, y) { | |
| x = +x, y = +y; | |
| if (this._point) { | |
| var x23 = this._x2 - x, | |
| y23 = this._y2 - y; | |
| this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha)); | |
| } | |
| switch (this._point) { | |
| case 0: this._point = 1; break; | |
| case 1: this._point = 2; break; | |
| case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break; | |
| case 3: this._point = 4; // proceed | |
| default: point$2(this, x, y); break; | |
| } | |
| this._l01_a = this._l12_a, this._l12_a = this._l23_a; | |
| this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a; | |
| this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; | |
| this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; | |
| } | |
| }; | |
| var catmullRomOpen = ((function custom(alpha) { | |
| function catmullRom(context) { | |
| return alpha ? new CatmullRomOpen(context, alpha) : new CardinalOpen(context, 0); | |
| } | |
| catmullRom.alpha = function(alpha) { | |
| return custom(+alpha); | |
| }; | |
| return catmullRom; | |
| }))(0.5); | |
| function LinearClosed(context) { | |
| this._context = context; | |
| } | |
| LinearClosed.prototype = { | |
| areaStart: noop, | |
| areaEnd: noop, | |
| lineStart: function() { | |
| this._point = 0; | |
| }, | |
| lineEnd: function() { | |
| if (this._point) this._context.closePath(); | |
| }, | |
| point: function(x, y) { | |
| x = +x, y = +y; | |
| if (this._point) this._context.lineTo(x, y); | |
| else this._point = 1, this._context.moveTo(x, y); | |
| } | |
| }; | |
| var linearClosed = function(context) { | |
| return new LinearClosed(context); | |
| }; | |
| function sign(x) { | |
| return x < 0 ? -1 : 1; | |
| } | |
| // Calculate the slopes of the tangents (Hermite-type interpolation) based on | |
| // the following paper: Steffen, M. 1990. A Simple Method for Monotonic | |
| // Interpolation in One Dimension. Astronomy and Astrophysics, Vol. 239, NO. | |
| // NOV(II), P. 443, 1990. | |
| function slope3(that, x2, y2) { | |
| var h0 = that._x1 - that._x0, | |
| h1 = x2 - that._x1, | |
| s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0), | |
| s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0), | |
| p = (s0 * h1 + s1 * h0) / (h0 + h1); | |
| return (sign(s0) + sign(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p)) || 0; | |
| } | |
| // Calculate a one-sided slope. | |
| function slope2(that, t) { | |
| var h = that._x1 - that._x0; | |
| return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t; | |
| } | |
| // According to https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Representations | |
| // "you can express cubic Hermite interpolation in terms of cubic Bézier curves | |
| // with respect to the four values p0, p0 + m0 / 3, p1 - m1 / 3, p1". | |
| function point$3(that, t0, t1) { | |
| var x0 = that._x0, | |
| y0 = that._y0, | |
| x1 = that._x1, | |
| y1 = that._y1, | |
| dx = (x1 - x0) / 3; | |
| that._context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1); | |
| } | |
| function MonotoneX(context) { | |
| this._context = context; | |
| } | |
| MonotoneX.prototype = { | |
| areaStart: function() { | |
| this._line = 0; | |
| }, | |
| areaEnd: function() { | |
| this._line = NaN; | |
| }, | |
| lineStart: function() { | |
| this._x0 = this._x1 = | |
| this._y0 = this._y1 = | |
| this._t0 = NaN; | |
| this._point = 0; | |
| }, | |
| lineEnd: function() { | |
| switch (this._point) { | |
| case 2: this._context.lineTo(this._x1, this._y1); break; | |
| case 3: point$3(this, this._t0, slope2(this, this._t0)); break; | |
| } | |
| if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); | |
| this._line = 1 - this._line; | |
| }, | |
| point: function(x, y) { | |
| var t1 = NaN; | |
| x = +x, y = +y; | |
| if (x === this._x1 && y === this._y1) return; // Ignore coincident points. | |
| switch (this._point) { | |
| case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; | |
| case 1: this._point = 2; break; | |
| case 2: this._point = 3; point$3(this, slope2(this, t1 = slope3(this, x, y)), t1); break; | |
| default: point$3(this, this._t0, t1 = slope3(this, x, y)); break; | |
| } | |
| this._x0 = this._x1, this._x1 = x; | |
| this._y0 = this._y1, this._y1 = y; | |
| this._t0 = t1; | |
| } | |
| }; | |
| function MonotoneY(context) { | |
| this._context = new ReflectContext(context); | |
| } | |
| (MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x, y) { | |
| MonotoneX.prototype.point.call(this, y, x); | |
| }; | |
| function ReflectContext(context) { | |
| this._context = context; | |
| } | |
| ReflectContext.prototype = { | |
| moveTo: function(x, y) { this._context.moveTo(y, x); }, | |
| closePath: function() { this._context.closePath(); }, | |
| lineTo: function(x, y) { this._context.lineTo(y, x); }, | |
| bezierCurveTo: function(x1, y1, x2, y2, x, y) { this._context.bezierCurveTo(y1, x1, y2, x2, y, x); } | |
| }; | |
| function monotoneX(context) { | |
| return new MonotoneX(context); | |
| } | |
| function monotoneY(context) { | |
| return new MonotoneY(context); | |
| } | |
| function Natural(context) { | |
| this._context = context; | |
| } | |
| Natural.prototype = { | |
| areaStart: function() { | |
| this._line = 0; | |
| }, | |
| areaEnd: function() { | |
| this._line = NaN; | |
| }, | |
| lineStart: function() { | |
| this._x = []; | |
| this._y = []; | |
| }, | |
| lineEnd: function() { | |
| var x = this._x, | |
| y = this._y, | |
| n = x.length; | |
| if (n) { | |
| this._line ? this._context.lineTo(x[0], y[0]) : this._context.moveTo(x[0], y[0]); | |
| if (n === 2) { | |
| this._context.lineTo(x[1], y[1]); | |
| } else { | |
| var px = controlPoints(x), | |
| py = controlPoints(y); | |
| for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) { | |
| this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x[i1], y[i1]); | |
| } | |
| } | |
| } | |
| if (this._line || (this._line !== 0 && n === 1)) this._context.closePath(); | |
| this._line = 1 - this._line; | |
| this._x = this._y = null; | |
| }, | |
| point: function(x, y) { | |
| this._x.push(+x); | |
| this._y.push(+y); | |
| } | |
| }; | |
| // See https://www.particleincell.com/2012/bezier-splines/ for derivation. | |
| function controlPoints(x) { | |
| var i, | |
| n = x.length - 1, | |
| m, | |
| a = new Array(n), | |
| b = new Array(n), | |
| r = new Array(n); | |
| a[0] = 0, b[0] = 2, r[0] = x[0] + 2 * x[1]; | |
| for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x[i] + 2 * x[i + 1]; | |
| a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x[n - 1] + x[n]; | |
| for (i = 1; i < n; ++i) m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1]; | |
| a[n - 1] = r[n - 1] / b[n - 1]; | |
| for (i = n - 2; i >= 0; --i) a[i] = (r[i] - a[i + 1]) / b[i]; | |
| b[n - 1] = (x[n] + a[n - 1]) / 2; | |
| for (i = 0; i < n - 1; ++i) b[i] = 2 * x[i + 1] - a[i + 1]; | |
| return [a, b]; | |
| } | |
| var natural = function(context) { | |
| return new Natural(context); | |
| }; | |
| function Step(context, t) { | |
| this._context = context; | |
| this._t = t; | |
| } | |
| Step.prototype = { | |
| areaStart: function() { | |
| this._line = 0; | |
| }, | |
| areaEnd: function() { | |
| this._line = NaN; | |
| }, | |
| lineStart: function() { | |
| this._x = this._y = NaN; | |
| this._point = 0; | |
| }, | |
| lineEnd: function() { | |
| if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y); | |
| if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); | |
| if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line; | |
| }, | |
| point: function(x, y) { | |
| x = +x, y = +y; | |
| switch (this._point) { | |
| case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; | |
| case 1: this._point = 2; // proceed | |
| default: { | |
| if (this._t <= 0) { | |
| this._context.lineTo(this._x, y); | |
| this._context.lineTo(x, y); | |
| } else { | |
| var x1 = this._x * (1 - this._t) + x * this._t; | |
| this._context.lineTo(x1, this._y); | |
| this._context.lineTo(x1, y); | |
| } | |
| break; | |
| } | |
| } | |
| this._x = x, this._y = y; | |
| } | |
| }; | |
| var step = function(context) { | |
| return new Step(context, 0.5); | |
| }; | |
| function stepBefore(context) { | |
| return new Step(context, 0); | |
| } | |
| function stepAfter(context) { | |
| return new Step(context, 1); | |
| } | |
| var none = function(series, order) { | |
| if (!((n = series.length) > 1)) return; | |
| for (var i = 1, j, s0, s1 = series[order[0]], n, m = s1.length; i < n; ++i) { | |
| s0 = s1, s1 = series[order[i]]; | |
| for (j = 0; j < m; ++j) { | |
| s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1]; | |
| } | |
| } | |
| }; | |
| var none$1 = function(series) { | |
| var n = series.length, o = new Array(n); | |
| while (--n >= 0) o[n] = n; | |
| return o; | |
| }; | |
| function stackValue(d, key) { | |
| return d[key]; | |
| } | |
| var stack = function() { | |
| var keys = constant([]), | |
| order = none$1, | |
| offset = none, | |
| value = stackValue; | |
| function stack(data) { | |
| var kz = keys.apply(this, arguments), | |
| i, | |
| m = data.length, | |
| n = kz.length, | |
| sz = new Array(n), | |
| oz; | |
| for (i = 0; i < n; ++i) { | |
| for (var ki = kz[i], si = sz[i] = new Array(m), j = 0, sij; j < m; ++j) { | |
| si[j] = sij = [0, +value(data[j], ki, j, data)]; | |
| sij.data = data[j]; | |
| } | |
| si.key = ki; | |
| } | |
| for (i = 0, oz = order(sz); i < n; ++i) { | |
| sz[oz[i]].index = i; | |
| } | |
| offset(sz, oz); | |
| return sz; | |
| } | |
| stack.keys = function(_) { | |
| return arguments.length ? (keys = typeof _ === "function" ? _ : constant(slice.call(_)), stack) : keys; | |
| }; | |
| stack.value = function(_) { | |
| return arguments.length ? (value = typeof _ === "function" ? _ : constant(+_), stack) : value; | |
| }; | |
| stack.order = function(_) { | |
| return arguments.length ? (order = _ == null ? none$1 : typeof _ === "function" ? _ : constant(slice.call(_)), stack) : order; | |
| }; | |
| stack.offset = function(_) { | |
| return arguments.length ? (offset = _ == null ? none : _, stack) : offset; | |
| }; | |
| return stack; | |
| }; | |
| var expand = function(series, order) { | |
| if (!((n = series.length) > 0)) return; | |
| for (var i, n, j = 0, m = series[0].length, y; j < m; ++j) { | |
| for (y = i = 0; i < n; ++i) y += series[i][j][1] || 0; | |
| if (y) for (i = 0; i < n; ++i) series[i][j][1] /= y; | |
| } | |
| none(series, order); | |
| }; | |
| var diverging = function(series, order) { | |
| if (!((n = series.length) > 1)) return; | |
| for (var i, j = 0, d, dy, yp, yn, n, m = series[order[0]].length; j < m; ++j) { | |
| for (yp = yn = 0, i = 0; i < n; ++i) { | |
| if ((dy = (d = series[order[i]][j])[1] - d[0]) >= 0) { | |
| d[0] = yp, d[1] = yp += dy; | |
| } else if (dy < 0) { | |
| d[1] = yn, d[0] = yn += dy; | |
| } else { | |
| d[0] = yp; | |
| } | |
| } | |
| } | |
| }; | |
| var silhouette = function(series, order) { | |
| if (!((n = series.length) > 0)) return; | |
| for (var j = 0, s0 = series[order[0]], n, m = s0.length; j < m; ++j) { | |
| for (var i = 0, y = 0; i < n; ++i) y += series[i][j][1] || 0; | |
| s0[j][1] += s0[j][0] = -y / 2; | |
| } | |
| none(series, order); | |
| }; | |
| var wiggle = function(series, order) { | |
| if (!((n = series.length) > 0) || !((m = (s0 = series[order[0]]).length) > 0)) return; | |
| for (var y = 0, j = 1, s0, m, n; j < m; ++j) { | |
| for (var i = 0, s1 = 0, s2 = 0; i < n; ++i) { | |
| var si = series[order[i]], | |
| sij0 = si[j][1] || 0, | |
| sij1 = si[j - 1][1] || 0, | |
| s3 = (sij0 - sij1) / 2; | |
| for (var k = 0; k < i; ++k) { | |
| var sk = series[order[k]], | |
| skj0 = sk[j][1] || 0, | |
| skj1 = sk[j - 1][1] || 0; | |
| s3 += skj0 - skj1; | |
| } | |
| s1 += sij0, s2 += s3 * sij0; | |
| } | |
| s0[j - 1][1] += s0[j - 1][0] = y; | |
| if (s1) y -= s2 / s1; | |
| } | |
| s0[j - 1][1] += s0[j - 1][0] = y; | |
| none(series, order); | |
| }; | |
| var ascending = function(series) { | |
| var sums = series.map(sum); | |
| return none$1(series).sort(function(a, b) { return sums[a] - sums[b]; }); | |
| }; | |
| function sum(series) { | |
| var s = 0, i = -1, n = series.length, v; | |
| while (++i < n) if (v = +series[i][1]) s += v; | |
| return s; | |
| } | |
| var descending$1 = function(series) { | |
| return ascending(series).reverse(); | |
| }; | |
| var insideOut = function(series) { | |
| var n = series.length, | |
| i, | |
| j, | |
| sums = series.map(sum), | |
| order = none$1(series).sort(function(a, b) { return sums[b] - sums[a]; }), | |
| top = 0, | |
| bottom = 0, | |
| tops = [], | |
| bottoms = []; | |
| for (i = 0; i < n; ++i) { | |
| j = order[i]; | |
| if (top < bottom) { | |
| top += sums[j]; | |
| tops.push(j); | |
| } else { | |
| bottom += sums[j]; | |
| bottoms.push(j); | |
| } | |
| } | |
| return bottoms.reverse().concat(tops); | |
| }; | |
| var reverse = function(series) { | |
| return none$1(series).reverse(); | |
| }; | |
| exports.arc = arc; | |
| exports.area = area; | |
| exports.line = line; | |
| exports.pie = pie; | |
| exports.areaRadial = areaRadial; | |
| exports.radialArea = areaRadial; | |
| exports.lineRadial = lineRadial$1; | |
| exports.radialLine = lineRadial$1; | |
| exports.pointRadial = pointRadial; | |
| exports.linkHorizontal = linkHorizontal; | |
| exports.linkVertical = linkVertical; | |
| exports.linkRadial = linkRadial; | |
| exports.symbol = symbol; | |
| exports.symbols = symbols; | |
| exports.symbolCircle = circle; | |
| exports.symbolCross = cross; | |
| exports.symbolDiamond = diamond; | |
| exports.symbolSquare = square; | |
| exports.symbolStar = star; | |
| exports.symbolTriangle = triangle; | |
| exports.symbolWye = wye; | |
| exports.curveBasisClosed = basisClosed; | |
| exports.curveBasisOpen = basisOpen; | |
| exports.curveBasis = basis; | |
| exports.curveBundle = bundle; | |
| exports.curveCardinalClosed = cardinalClosed; | |
| exports.curveCardinalOpen = cardinalOpen; | |
| exports.curveCardinal = cardinal; | |
| exports.curveCatmullRomClosed = catmullRomClosed; | |
| exports.curveCatmullRomOpen = catmullRomOpen; | |
| exports.curveCatmullRom = catmullRom; | |
| exports.curveLinearClosed = linearClosed; | |
| exports.curveLinear = curveLinear; | |
| exports.curveMonotoneX = monotoneX; | |
| exports.curveMonotoneY = monotoneY; | |
| exports.curveNatural = natural; | |
| exports.curveStep = step; | |
| exports.curveStepAfter = stepAfter; | |
| exports.curveStepBefore = stepBefore; | |
| exports.stack = stack; | |
| exports.stackOffsetExpand = expand; | |
| exports.stackOffsetDiverging = diverging; | |
| exports.stackOffsetNone = none; | |
| exports.stackOffsetSilhouette = silhouette; | |
| exports.stackOffsetWiggle = wiggle; | |
| exports.stackOrderAscending = ascending; | |
| exports.stackOrderDescending = descending$1; | |
| exports.stackOrderInsideOut = insideOut; | |
| exports.stackOrderNone = none$1; | |
| exports.stackOrderReverse = reverse; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| }))); | |
| },{"d3-path":8}],13:[function(require,module,exports){ | |
| // https://d3js.org/d3-time-format/ Version 2.1.1. Copyright 2017 Mike Bostock. | |
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-time')) : | |
| typeof define === 'function' && define.amd ? define(['exports', 'd3-time'], factory) : | |
| (factory((global.d3 = global.d3 || {}),global.d3)); | |
| }(this, (function (exports,d3Time) { 'use strict'; | |
| function localDate(d) { | |
| if (0 <= d.y && d.y < 100) { | |
| var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L); | |
| date.setFullYear(d.y); | |
| return date; | |
| } | |
| return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L); | |
| } | |
| function utcDate(d) { | |
| if (0 <= d.y && d.y < 100) { | |
| var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L)); | |
| date.setUTCFullYear(d.y); | |
| return date; | |
| } | |
| return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L)); | |
| } | |
| function newYear(y) { | |
| return {y: y, m: 0, d: 1, H: 0, M: 0, S: 0, L: 0}; | |
| } | |
| function formatLocale(locale) { | |
| var locale_dateTime = locale.dateTime, | |
| locale_date = locale.date, | |
| locale_time = locale.time, | |
| locale_periods = locale.periods, | |
| locale_weekdays = locale.days, | |
| locale_shortWeekdays = locale.shortDays, | |
| locale_months = locale.months, | |
| locale_shortMonths = locale.shortMonths; | |
| var periodRe = formatRe(locale_periods), | |
| periodLookup = formatLookup(locale_periods), | |
| weekdayRe = formatRe(locale_weekdays), | |
| weekdayLookup = formatLookup(locale_weekdays), | |
| shortWeekdayRe = formatRe(locale_shortWeekdays), | |
| shortWeekdayLookup = formatLookup(locale_shortWeekdays), | |
| monthRe = formatRe(locale_months), | |
| monthLookup = formatLookup(locale_months), | |
| shortMonthRe = formatRe(locale_shortMonths), | |
| shortMonthLookup = formatLookup(locale_shortMonths); | |
| var formats = { | |
| "a": formatShortWeekday, | |
| "A": formatWeekday, | |
| "b": formatShortMonth, | |
| "B": formatMonth, | |
| "c": null, | |
| "d": formatDayOfMonth, | |
| "e": formatDayOfMonth, | |
| "f": formatMicroseconds, | |
| "H": formatHour24, | |
| "I": formatHour12, | |
| "j": formatDayOfYear, | |
| "L": formatMilliseconds, | |
| "m": formatMonthNumber, | |
| "M": formatMinutes, | |
| "p": formatPeriod, | |
| "Q": formatUnixTimestamp, | |
| "s": formatUnixTimestampSeconds, | |
| "S": formatSeconds, | |
| "u": formatWeekdayNumberMonday, | |
| "U": formatWeekNumberSunday, | |
| "V": formatWeekNumberISO, | |
| "w": formatWeekdayNumberSunday, | |
| "W": formatWeekNumberMonday, | |
| "x": null, | |
| "X": null, | |
| "y": formatYear, | |
| "Y": formatFullYear, | |
| "Z": formatZone, | |
| "%": formatLiteralPercent | |
| }; | |
| var utcFormats = { | |
| "a": formatUTCShortWeekday, | |
| "A": formatUTCWeekday, | |
| "b": formatUTCShortMonth, | |
| "B": formatUTCMonth, | |
| "c": null, | |
| "d": formatUTCDayOfMonth, | |
| "e": formatUTCDayOfMonth, | |
| "f": formatUTCMicroseconds, | |
| "H": formatUTCHour24, | |
| "I": formatUTCHour12, | |
| "j": formatUTCDayOfYear, | |
| "L": formatUTCMilliseconds, | |
| "m": formatUTCMonthNumber, | |
| "M": formatUTCMinutes, | |
| "p": formatUTCPeriod, | |
| "Q": formatUnixTimestamp, | |
| "s": formatUnixTimestampSeconds, | |
| "S": formatUTCSeconds, | |
| "u": formatUTCWeekdayNumberMonday, | |
| "U": formatUTCWeekNumberSunday, | |
| "V": formatUTCWeekNumberISO, | |
| "w": formatUTCWeekdayNumberSunday, | |
| "W": formatUTCWeekNumberMonday, | |
| "x": null, | |
| "X": null, | |
| "y": formatUTCYear, | |
| "Y": formatUTCFullYear, | |
| "Z": formatUTCZone, | |
| "%": formatLiteralPercent | |
| }; | |
| var parses = { | |
| "a": parseShortWeekday, | |
| "A": parseWeekday, | |
| "b": parseShortMonth, | |
| "B": parseMonth, | |
| "c": parseLocaleDateTime, | |
| "d": parseDayOfMonth, | |
| "e": parseDayOfMonth, | |
| "f": parseMicroseconds, | |
| "H": parseHour24, | |
| "I": parseHour24, | |
| "j": parseDayOfYear, | |
| "L": parseMilliseconds, | |
| "m": parseMonthNumber, | |
| "M": parseMinutes, | |
| "p": parsePeriod, | |
| "Q": parseUnixTimestamp, | |
| "s": parseUnixTimestampSeconds, | |
| "S": parseSeconds, | |
| "u": parseWeekdayNumberMonday, | |
| "U": parseWeekNumberSunday, | |
| "V": parseWeekNumberISO, | |
| "w": parseWeekdayNumberSunday, | |
| "W": parseWeekNumberMonday, | |
| "x": parseLocaleDate, | |
| "X": parseLocaleTime, | |
| "y": parseYear, | |
| "Y": parseFullYear, | |
| "Z": parseZone, | |
| "%": parseLiteralPercent | |
| }; | |
| // These recursive directive definitions must be deferred. | |
| formats.x = newFormat(locale_date, formats); | |
| formats.X = newFormat(locale_time, formats); | |
| formats.c = newFormat(locale_dateTime, formats); | |
| utcFormats.x = newFormat(locale_date, utcFormats); | |
| utcFormats.X = newFormat(locale_time, utcFormats); | |
| utcFormats.c = newFormat(locale_dateTime, utcFormats); | |
| function newFormat(specifier, formats) { | |
| return function(date) { | |
| var string = [], | |
| i = -1, | |
| j = 0, | |
| n = specifier.length, | |
| c, | |
| pad, | |
| format; | |
| if (!(date instanceof Date)) date = new Date(+date); | |
| while (++i < n) { | |
| if (specifier.charCodeAt(i) === 37) { | |
| string.push(specifier.slice(j, i)); | |
| if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i); | |
| else pad = c === "e" ? " " : "0"; | |
| if (format = formats[c]) c = format(date, pad); | |
| string.push(c); | |
| j = i + 1; | |
| } | |
| } | |
| string.push(specifier.slice(j, i)); | |
| return string.join(""); | |
| }; | |
| } | |
| function newParse(specifier, newDate) { | |
| return function(string) { | |
| var d = newYear(1900), | |
| i = parseSpecifier(d, specifier, string += "", 0), | |
| week, day; | |
| if (i != string.length) return null; | |
| // If a UNIX timestamp is specified, return it. | |
| if ("Q" in d) return new Date(d.Q); | |
| // The am-pm flag is 0 for AM, and 1 for PM. | |
| if ("p" in d) d.H = d.H % 12 + d.p * 12; | |
| // Convert day-of-week and week-of-year to day-of-year. | |
| if ("V" in d) { | |
| if (d.V < 1 || d.V > 53) return null; | |
| if (!("w" in d)) d.w = 1; | |
| if ("Z" in d) { | |
| week = utcDate(newYear(d.y)), day = week.getUTCDay(); | |
| week = day > 4 || day === 0 ? d3Time.utcMonday.ceil(week) : d3Time.utcMonday(week); | |
| week = d3Time.utcDay.offset(week, (d.V - 1) * 7); | |
| d.y = week.getUTCFullYear(); | |
| d.m = week.getUTCMonth(); | |
| d.d = week.getUTCDate() + (d.w + 6) % 7; | |
| } else { | |
| week = newDate(newYear(d.y)), day = week.getDay(); | |
| week = day > 4 || day === 0 ? d3Time.timeMonday.ceil(week) : d3Time.timeMonday(week); | |
| week = d3Time.timeDay.offset(week, (d.V - 1) * 7); | |
| d.y = week.getFullYear(); | |
| d.m = week.getMonth(); | |
| d.d = week.getDate() + (d.w + 6) % 7; | |
| } | |
| } else if ("W" in d || "U" in d) { | |
| if (!("w" in d)) d.w = "u" in d ? d.u % 7 : "W" in d ? 1 : 0; | |
| day = "Z" in d ? utcDate(newYear(d.y)).getUTCDay() : newDate(newYear(d.y)).getDay(); | |
| d.m = 0; | |
| d.d = "W" in d ? (d.w + 6) % 7 + d.W * 7 - (day + 5) % 7 : d.w + d.U * 7 - (day + 6) % 7; | |
| } | |
| // If a time zone is specified, all fields are interpreted as UTC and then | |
| // offset according to the specified time zone. | |
| if ("Z" in d) { | |
| d.H += d.Z / 100 | 0; | |
| d.M += d.Z % 100; | |
| return utcDate(d); | |
| } | |
| // Otherwise, all fields are in local time. | |
| return newDate(d); | |
| }; | |
| } | |
| function parseSpecifier(d, specifier, string, j) { | |
| var i = 0, | |
| n = specifier.length, | |
| m = string.length, | |
| c, | |
| parse; | |
| while (i < n) { | |
| if (j >= m) return -1; | |
| c = specifier.charCodeAt(i++); | |
| if (c === 37) { | |
| c = specifier.charAt(i++); | |
| parse = parses[c in pads ? specifier.charAt(i++) : c]; | |
| if (!parse || ((j = parse(d, string, j)) < 0)) return -1; | |
| } else if (c != string.charCodeAt(j++)) { | |
| return -1; | |
| } | |
| } | |
| return j; | |
| } | |
| function parsePeriod(d, string, i) { | |
| var n = periodRe.exec(string.slice(i)); | |
| return n ? (d.p = periodLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
| } | |
| function parseShortWeekday(d, string, i) { | |
| var n = shortWeekdayRe.exec(string.slice(i)); | |
| return n ? (d.w = shortWeekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
| } | |
| function parseWeekday(d, string, i) { | |
| var n = weekdayRe.exec(string.slice(i)); | |
| return n ? (d.w = weekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
| } | |
| function parseShortMonth(d, string, i) { | |
| var n = shortMonthRe.exec(string.slice(i)); | |
| return n ? (d.m = shortMonthLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
| } | |
| function parseMonth(d, string, i) { | |
| var n = monthRe.exec(string.slice(i)); | |
| return n ? (d.m = monthLookup[n[0].toLowerCase()], i + n[0].length) : -1; | |
| } | |
| function parseLocaleDateTime(d, string, i) { | |
| return parseSpecifier(d, locale_dateTime, string, i); | |
| } | |
| function parseLocaleDate(d, string, i) { | |
| return parseSpecifier(d, locale_date, string, i); | |
| } | |
| function parseLocaleTime(d, string, i) { | |
| return parseSpecifier(d, locale_time, string, i); | |
| } | |
| function formatShortWeekday(d) { | |
| return locale_shortWeekdays[d.getDay()]; | |
| } | |
| function formatWeekday(d) { | |
| return locale_weekdays[d.getDay()]; | |
| } | |
| function formatShortMonth(d) { | |
| return locale_shortMonths[d.getMonth()]; | |
| } | |
| function formatMonth(d) { | |
| return locale_months[d.getMonth()]; | |
| } | |
| function formatPeriod(d) { | |
| return locale_periods[+(d.getHours() >= 12)]; | |
| } | |
| function formatUTCShortWeekday(d) { | |
| return locale_shortWeekdays[d.getUTCDay()]; | |
| } | |
| function formatUTCWeekday(d) { | |
| return locale_weekdays[d.getUTCDay()]; | |
| } | |
| function formatUTCShortMonth(d) { | |
| return locale_shortMonths[d.getUTCMonth()]; | |
| } | |
| function formatUTCMonth(d) { | |
| return locale_months[d.getUTCMonth()]; | |
| } | |
| function formatUTCPeriod(d) { | |
| return locale_periods[+(d.getUTCHours() >= 12)]; | |
| } | |
| return { | |
| format: function(specifier) { | |
| var f = newFormat(specifier += "", formats); | |
| f.toString = function() { return specifier; }; | |
| return f; | |
| }, | |
| parse: function(specifier) { | |
| var p = newParse(specifier += "", localDate); | |
| p.toString = function() { return specifier; }; | |
| return p; | |
| }, | |
| utcFormat: function(specifier) { | |
| var f = newFormat(specifier += "", utcFormats); | |
| f.toString = function() { return specifier; }; | |
| return f; | |
| }, | |
| utcParse: function(specifier) { | |
| var p = newParse(specifier, utcDate); | |
| p.toString = function() { return specifier; }; | |
| return p; | |
| } | |
| }; | |
| } | |
| var pads = {"-": "", "_": " ", "0": "0"}; | |
| var numberRe = /^\s*\d+/; | |
| var percentRe = /^%/; | |
| var requoteRe = /[\\^$*+?|[\]().{}]/g; | |
| function pad(value, fill, width) { | |
| var sign = value < 0 ? "-" : "", | |
| string = (sign ? -value : value) + "", | |
| length = string.length; | |
| return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string); | |
| } | |
| function requote(s) { | |
| return s.replace(requoteRe, "\\$&"); | |
| } | |
| function formatRe(names) { | |
| return new RegExp("^(?:" + names.map(requote).join("|") + ")", "i"); | |
| } | |
| function formatLookup(names) { | |
| var map = {}, i = -1, n = names.length; | |
| while (++i < n) map[names[i].toLowerCase()] = i; | |
| return map; | |
| } | |
| function parseWeekdayNumberSunday(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 1)); | |
| return n ? (d.w = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseWeekdayNumberMonday(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 1)); | |
| return n ? (d.u = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseWeekNumberSunday(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.U = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseWeekNumberISO(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.V = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseWeekNumberMonday(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.W = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseFullYear(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 4)); | |
| return n ? (d.y = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseYear(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1; | |
| } | |
| function parseZone(d, string, i) { | |
| var n = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(string.slice(i, i + 6)); | |
| return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || "00")), i + n[0].length) : -1; | |
| } | |
| function parseMonthNumber(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.m = n[0] - 1, i + n[0].length) : -1; | |
| } | |
| function parseDayOfMonth(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.d = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseDayOfYear(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 3)); | |
| return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseHour24(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.H = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseMinutes(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.M = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseSeconds(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 2)); | |
| return n ? (d.S = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseMilliseconds(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 3)); | |
| return n ? (d.L = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseMicroseconds(d, string, i) { | |
| var n = numberRe.exec(string.slice(i, i + 6)); | |
| return n ? (d.L = Math.floor(n[0] / 1000), i + n[0].length) : -1; | |
| } | |
| function parseLiteralPercent(d, string, i) { | |
| var n = percentRe.exec(string.slice(i, i + 1)); | |
| return n ? i + n[0].length : -1; | |
| } | |
| function parseUnixTimestamp(d, string, i) { | |
| var n = numberRe.exec(string.slice(i)); | |
| return n ? (d.Q = +n[0], i + n[0].length) : -1; | |
| } | |
| function parseUnixTimestampSeconds(d, string, i) { | |
| var n = numberRe.exec(string.slice(i)); | |
| return n ? (d.Q = (+n[0]) * 1000, i + n[0].length) : -1; | |
| } | |
| function formatDayOfMonth(d, p) { | |
| return pad(d.getDate(), p, 2); | |
| } | |
| function formatHour24(d, p) { | |
| return pad(d.getHours(), p, 2); | |
| } | |
| function formatHour12(d, p) { | |
| return pad(d.getHours() % 12 || 12, p, 2); | |
| } | |
| function formatDayOfYear(d, p) { | |
| return pad(1 + d3Time.timeDay.count(d3Time.timeYear(d), d), p, 3); | |
| } | |
| function formatMilliseconds(d, p) { | |
| return pad(d.getMilliseconds(), p, 3); | |
| } | |
| function formatMicroseconds(d, p) { | |
| return formatMilliseconds(d, p) + "000"; | |
| } | |
| function formatMonthNumber(d, p) { | |
| return pad(d.getMonth() + 1, p, 2); | |
| } | |
| function formatMinutes(d, p) { | |
| return pad(d.getMinutes(), p, 2); | |
| } | |
| function formatSeconds(d, p) { | |
| return pad(d.getSeconds(), p, 2); | |
| } | |
| function formatWeekdayNumberMonday(d) { | |
| var day = d.getDay(); | |
| return day === 0 ? 7 : day; | |
| } | |
| function formatWeekNumberSunday(d, p) { | |
| return pad(d3Time.timeSunday.count(d3Time.timeYear(d), d), p, 2); | |
| } | |
| function formatWeekNumberISO(d, p) { | |
| var day = d.getDay(); | |
| d = (day >= 4 || day === 0) ? d3Time.timeThursday(d) : d3Time.timeThursday.ceil(d); | |
| return pad(d3Time.timeThursday.count(d3Time.timeYear(d), d) + (d3Time.timeYear(d).getDay() === 4), p, 2); | |
| } | |
| function formatWeekdayNumberSunday(d) { | |
| return d.getDay(); | |
| } | |
| function formatWeekNumberMonday(d, p) { | |
| return pad(d3Time.timeMonday.count(d3Time.timeYear(d), d), p, 2); | |
| } | |
| function formatYear(d, p) { | |
| return pad(d.getFullYear() % 100, p, 2); | |
| } | |
| function formatFullYear(d, p) { | |
| return pad(d.getFullYear() % 10000, p, 4); | |
| } | |
| function formatZone(d) { | |
| var z = d.getTimezoneOffset(); | |
| return (z > 0 ? "-" : (z *= -1, "+")) | |
| + pad(z / 60 | 0, "0", 2) | |
| + pad(z % 60, "0", 2); | |
| } | |
| function formatUTCDayOfMonth(d, p) { | |
| return pad(d.getUTCDate(), p, 2); | |
| } | |
| function formatUTCHour24(d, p) { | |
| return pad(d.getUTCHours(), p, 2); | |
| } | |
| function formatUTCHour12(d, p) { | |
| return pad(d.getUTCHours() % 12 || 12, p, 2); | |
| } | |
| function formatUTCDayOfYear(d, p) { | |
| return pad(1 + d3Time.utcDay.count(d3Time.utcYear(d), d), p, 3); | |
| } | |
| function formatUTCMilliseconds(d, p) { | |
| return pad(d.getUTCMilliseconds(), p, 3); | |
| } | |
| function formatUTCMicroseconds(d, p) { | |
| return formatUTCMilliseconds(d, p) + "000"; | |
| } | |
| function formatUTCMonthNumber(d, p) { | |
| return pad(d.getUTCMonth() + 1, p, 2); | |
| } | |
| function formatUTCMinutes(d, p) { | |
| return pad(d.getUTCMinutes(), p, 2); | |
| } | |
| function formatUTCSeconds(d, p) { | |
| return pad(d.getUTCSeconds(), p, 2); | |
| } | |
| function formatUTCWeekdayNumberMonday(d) { | |
| var dow = d.getUTCDay(); | |
| return dow === 0 ? 7 : dow; | |
| } | |
| function formatUTCWeekNumberSunday(d, p) { | |
| return pad(d3Time.utcSunday.count(d3Time.utcYear(d), d), p, 2); | |
| } | |
| function formatUTCWeekNumberISO(d, p) { | |
| var day = d.getUTCDay(); | |
| d = (day >= 4 || day === 0) ? d3Time.utcThursday(d) : d3Time.utcThursday.ceil(d); | |
| return pad(d3Time.utcThursday.count(d3Time.utcYear(d), d) + (d3Time.utcYear(d).getUTCDay() === 4), p, 2); | |
| } | |
| function formatUTCWeekdayNumberSunday(d) { | |
| return d.getUTCDay(); | |
| } | |
| function formatUTCWeekNumberMonday(d, p) { | |
| return pad(d3Time.utcMonday.count(d3Time.utcYear(d), d), p, 2); | |
| } | |
| function formatUTCYear(d, p) { | |
| return pad(d.getUTCFullYear() % 100, p, 2); | |
| } | |
| function formatUTCFullYear(d, p) { | |
| return pad(d.getUTCFullYear() % 10000, p, 4); | |
| } | |
| function formatUTCZone() { | |
| return "+0000"; | |
| } | |
| function formatLiteralPercent() { | |
| return "%"; | |
| } | |
| function formatUnixTimestamp(d) { | |
| return +d; | |
| } | |
| function formatUnixTimestampSeconds(d) { | |
| return Math.floor(+d / 1000); | |
| } | |
| var locale; | |
| defaultLocale({ | |
| dateTime: "%x, %X", | |
| date: "%-m/%-d/%Y", | |
| time: "%-I:%M:%S %p", | |
| periods: ["AM", "PM"], | |
| days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], | |
| shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], | |
| months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], | |
| shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] | |
| }); | |
| function defaultLocale(definition) { | |
| locale = formatLocale(definition); | |
| exports.timeFormat = locale.format; | |
| exports.timeParse = locale.parse; | |
| exports.utcFormat = locale.utcFormat; | |
| exports.utcParse = locale.utcParse; | |
| return locale; | |
| } | |
| var isoSpecifier = "%Y-%m-%dT%H:%M:%S.%LZ"; | |
| function formatIsoNative(date) { | |
| return date.toISOString(); | |
| } | |
| var formatIso = Date.prototype.toISOString | |
| ? formatIsoNative | |
| : exports.utcFormat(isoSpecifier); | |
| function parseIsoNative(string) { | |
| var date = new Date(string); | |
| return isNaN(date) ? null : date; | |
| } | |
| var parseIso = +new Date("2000-01-01T00:00:00.000Z") | |
| ? parseIsoNative | |
| : exports.utcParse(isoSpecifier); | |
| exports.timeFormatDefaultLocale = defaultLocale; | |
| exports.timeFormatLocale = formatLocale; | |
| exports.isoFormat = formatIso; | |
| exports.isoParse = parseIso; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| }))); | |
| },{"d3-time":14}],14:[function(require,module,exports){ | |
| // https://d3js.org/d3-time/ Version 1.0.8. Copyright 2017 Mike Bostock. | |
| (function (global, factory) { | |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : | |
| typeof define === 'function' && define.amd ? define(['exports'], factory) : | |
| (factory((global.d3 = global.d3 || {}))); | |
| }(this, (function (exports) { 'use strict'; | |
| var t0 = new Date; | |
| var t1 = new Date; | |
| function newInterval(floori, offseti, count, field) { | |
| function interval(date) { | |
| return floori(date = new Date(+date)), date; | |
| } | |
| interval.floor = interval; | |
| interval.ceil = function(date) { | |
| return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date; | |
| }; | |
| interval.round = function(date) { | |
| var d0 = interval(date), | |
| d1 = interval.ceil(date); | |
| return date - d0 < d1 - date ? d0 : d1; | |
| }; | |
| interval.offset = function(date, step) { | |
| return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date; | |
| }; | |
| interval.range = function(start, stop, step) { | |
| var range = [], previous; | |
| start = interval.ceil(start); | |
| step = step == null ? 1 : Math.floor(step); | |
| if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date | |
| do range.push(previous = new Date(+start)), offseti(start, step), floori(start); | |
| while (previous < start && start < stop); | |
| return range; | |
| }; | |
| interval.filter = function(test) { | |
| return newInterval(function(date) { | |
| if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1); | |
| }, function(date, step) { | |
| if (date >= date) { | |
| if (step < 0) while (++step <= 0) { | |
| while (offseti(date, -1), !test(date)) {} // eslint-disable-line no-empty | |
| } else while (--step >= 0) { | |
| while (offseti(date, +1), !test(date)) {} // eslint-disable-line no-empty | |
| } | |
| } | |
| }); | |
| }; | |
| if (count) { | |
| interval.count = function(start, end) { | |
| t0.setTime(+start), t1.setTime(+end); | |
| floori(t0), floori(t1); | |
| return Math.floor(count(t0, t1)); | |
| }; | |
| interval.every = function(step) { | |
| step = Math.floor(step); | |
| return !isFinite(step) || !(step > 0) ? null | |
| : !(step > 1) ? interval | |
| : interval.filter(field | |
| ? function(d) { return field(d) % step === 0; } | |
| : function(d) { return interval.count(0, d) % step === 0; }); | |
| }; | |
| } | |
| return interval; | |
| } | |
| var millisecond = newInterval(function() { | |
| // noop | |
| }, function(date, step) { | |
| date.setTime(+date + step); | |
| }, function(start, end) { | |
| return end - start; | |
| }); | |
| // An optimized implementation for this simple case. | |
| millisecond.every = function(k) { | |
| k = Math.floor(k); | |
| if (!isFinite(k) || !(k > 0)) return null; | |
| if (!(k > 1)) return millisecond; | |
| return newInterval(function(date) { | |
| date.setTime(Math.floor(date / k) * k); | |
| }, function(date, step) { | |
| date.setTime(+date + step * k); | |
| }, function(start, end) { | |
| return (end - start) / k; | |
| }); | |
| }; | |
| var milliseconds = millisecond.range; | |
| var durationSecond = 1e3; | |
| var durationMinute = 6e4; | |
| var durationHour = 36e5; | |
| var durationDay = 864e5; | |
| var durationWeek = 6048e5; | |
| var second = newInterval(function(date) { | |
| date.setTime(Math.floor(date / durationSecond) * durationSecond); | |
| }, function(date, step) { | |
| date.setTime(+date + step * durationSecond); | |
| }, function(start, end) { | |
| return (end - start) / durationSecond; | |
| }, function(date) { | |
| return date.getUTCSeconds(); | |
| }); | |
| var seconds = second.range; | |
| var minute = newInterval(function(date) { | |
| date.setTime(Math.floor(date / durationMinute) * durationMinute); | |
| }, function(date, step) { | |
| date.setTime(+date + step * durationMinute); | |
| }, function(start, end) { | |
| return (end - start) / durationMinute; | |
| }, function(date) { | |
| return date.getMinutes(); | |
| }); | |
| var minutes = minute.range; | |
| var hour = newInterval(function(date) { | |
| var offset = date.getTimezoneOffset() * durationMinute % durationHour; | |
| if (offset < 0) offset += durationHour; | |
| date.setTime(Math.floor((+date - offset) / durationHour) * durationHour + offset); | |
| }, function(date, step) { | |
| date.setTime(+date + step * durationHour); | |
| }, function(start, end) { | |
| return (end - start) / durationHour; | |
| }, function(date) { | |
| return date.getHours(); | |
| }); | |
| var hours = hour.range; | |
| var day = newInterval(function(date) { | |
| date.setHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setDate(date.getDate() + step); | |
| }, function(start, end) { | |
| return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationDay; | |
| }, function(date) { | |
| return date.getDate() - 1; | |
| }); | |
| var days = day.range; | |
| function weekday(i) { | |
| return newInterval(function(date) { | |
| date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7); | |
| date.setHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setDate(date.getDate() + step * 7); | |
| }, function(start, end) { | |
| return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * durationMinute) / durationWeek; | |
| }); | |
| } | |
| var sunday = weekday(0); | |
| var monday = weekday(1); | |
| var tuesday = weekday(2); | |
| var wednesday = weekday(3); | |
| var thursday = weekday(4); | |
| var friday = weekday(5); | |
| var saturday = weekday(6); | |
| var sundays = sunday.range; | |
| var mondays = monday.range; | |
| var tuesdays = tuesday.range; | |
| var wednesdays = wednesday.range; | |
| var thursdays = thursday.range; | |
| var fridays = friday.range; | |
| var saturdays = saturday.range; | |
| var month = newInterval(function(date) { | |
| date.setDate(1); | |
| date.setHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setMonth(date.getMonth() + step); | |
| }, function(start, end) { | |
| return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12; | |
| }, function(date) { | |
| return date.getMonth(); | |
| }); | |
| var months = month.range; | |
| var year = newInterval(function(date) { | |
| date.setMonth(0, 1); | |
| date.setHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setFullYear(date.getFullYear() + step); | |
| }, function(start, end) { | |
| return end.getFullYear() - start.getFullYear(); | |
| }, function(date) { | |
| return date.getFullYear(); | |
| }); | |
| // An optimized implementation for this simple case. | |
| year.every = function(k) { | |
| return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) { | |
| date.setFullYear(Math.floor(date.getFullYear() / k) * k); | |
| date.setMonth(0, 1); | |
| date.setHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setFullYear(date.getFullYear() + step * k); | |
| }); | |
| }; | |
| var years = year.range; | |
| var utcMinute = newInterval(function(date) { | |
| date.setUTCSeconds(0, 0); | |
| }, function(date, step) { | |
| date.setTime(+date + step * durationMinute); | |
| }, function(start, end) { | |
| return (end - start) / durationMinute; | |
| }, function(date) { | |
| return date.getUTCMinutes(); | |
| }); | |
| var utcMinutes = utcMinute.range; | |
| var utcHour = newInterval(function(date) { | |
| date.setUTCMinutes(0, 0, 0); | |
| }, function(date, step) { | |
| date.setTime(+date + step * durationHour); | |
| }, function(start, end) { | |
| return (end - start) / durationHour; | |
| }, function(date) { | |
| return date.getUTCHours(); | |
| }); | |
| var utcHours = utcHour.range; | |
| var utcDay = newInterval(function(date) { | |
| date.setUTCHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setUTCDate(date.getUTCDate() + step); | |
| }, function(start, end) { | |
| return (end - start) / durationDay; | |
| }, function(date) { | |
| return date.getUTCDate() - 1; | |
| }); | |
| var utcDays = utcDay.range; | |
| function utcWeekday(i) { | |
| return newInterval(function(date) { | |
| date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7); | |
| date.setUTCHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setUTCDate(date.getUTCDate() + step * 7); | |
| }, function(start, end) { | |
| return (end - start) / durationWeek; | |
| }); | |
| } | |
| var utcSunday = utcWeekday(0); | |
| var utcMonday = utcWeekday(1); | |
| var utcTuesday = utcWeekday(2); | |
| var utcWednesday = utcWeekday(3); | |
| var utcThursday = utcWeekday(4); | |
| var utcFriday = utcWeekday(5); | |
| var utcSaturday = utcWeekday(6); | |
| var utcSundays = utcSunday.range; | |
| var utcMondays = utcMonday.range; | |
| var utcTuesdays = utcTuesday.range; | |
| var utcWednesdays = utcWednesday.range; | |
| var utcThursdays = utcThursday.range; | |
| var utcFridays = utcFriday.range; | |
| var utcSaturdays = utcSaturday.range; | |
| var utcMonth = newInterval(function(date) { | |
| date.setUTCDate(1); | |
| date.setUTCHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setUTCMonth(date.getUTCMonth() + step); | |
| }, function(start, end) { | |
| return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12; | |
| }, function(date) { | |
| return date.getUTCMonth(); | |
| }); | |
| var utcMonths = utcMonth.range; | |
| var utcYear = newInterval(function(date) { | |
| date.setUTCMonth(0, 1); | |
| date.setUTCHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setUTCFullYear(date.getUTCFullYear() + step); | |
| }, function(start, end) { | |
| return end.getUTCFullYear() - start.getUTCFullYear(); | |
| }, function(date) { | |
| return date.getUTCFullYear(); | |
| }); | |
| // An optimized implementation for this simple case. | |
| utcYear.every = function(k) { | |
| return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : newInterval(function(date) { | |
| date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k); | |
| date.setUTCMonth(0, 1); | |
| date.setUTCHours(0, 0, 0, 0); | |
| }, function(date, step) { | |
| date.setUTCFullYear(date.getUTCFullYear() + step * k); | |
| }); | |
| }; | |
| var utcYears = utcYear.range; | |
| exports.timeInterval = newInterval; | |
| exports.timeMillisecond = millisecond; | |
| exports.timeMilliseconds = milliseconds; | |
| exports.utcMillisecond = millisecond; | |
| exports.utcMilliseconds = milliseconds; | |
| exports.timeSecond = second; | |
| exports.timeSeconds = seconds; | |
| exports.utcSecond = second; | |
| exports.utcSeconds = seconds; | |
| exports.timeMinute = minute; | |
| exports.timeMinutes = minutes; | |
| exports.timeHour = hour; | |
| exports.timeHours = hours; | |
| exports.timeDay = day; | |
| exports.timeDays = days; | |
| exports.timeWeek = sunday; | |
| exports.timeWeeks = sundays; | |
| exports.timeSunday = sunday; | |
| exports.timeSundays = sundays; | |
| exports.timeMonday = monday; | |
| exports.timeMondays = mondays; | |
| exports.timeTuesday = tuesday; | |
| exports.timeTuesdays = tuesdays; | |
| exports.timeWednesday = wednesday; | |
| exports.timeWednesdays = wednesdays; | |
| exports.timeThursday = thursday; | |
| exports.timeThursdays = thursdays; | |
| exports.timeFriday = friday; | |
| exports.timeFridays = fridays; | |
| exports.timeSaturday = saturday; | |
| exports.timeSaturdays = saturdays; | |
| exports.timeMonth = month; | |
| exports.timeMonths = months; | |
| exports.timeYear = year; | |
| exports.timeYears = years; | |
| exports.utcMinute = utcMinute; | |
| exports.utcMinutes = utcMinutes; | |
| exports.utcHour = utcHour; | |
| exports.utcHours = utcHours; | |
| exports.utcDay = utcDay; | |
| exports.utcDays = utcDays; | |
| exports.utcWeek = utcSunday; | |
| exports.utcWeeks = utcSundays; | |
| exports.utcSunday = utcSunday; | |
| exports.utcSundays = utcSundays; | |
| exports.utcMonday = utcMonday; | |
| exports.utcMondays = utcMondays; | |
| exports.utcTuesday = utcTuesday; | |
| exports.utcTuesdays = utcTuesdays; | |
| exports.utcWednesday = utcWednesday; | |
| exports.utcWednesdays = utcWednesdays; | |
| exports.utcThursday = utcThursday; | |
| exports.utcThursdays = utcThursdays; | |
| exports.utcFriday = utcFriday; | |
| exports.utcFridays = utcFridays; | |
| exports.utcSaturday = utcSaturday; | |
| exports.utcSaturdays = utcSaturdays; | |
| exports.utcMonth = utcMonth; | |
| exports.utcMonths = utcMonths; | |
| exports.utcYear = utcYear; | |
| exports.utcYears = utcYears; | |
| Object.defineProperty(exports, '__esModule', { value: true }); | |
| }))); | |
| },{}],15:[function(require,module,exports){ | |
| 'use strict'; | |
| /** | |
| * @class dE00 | |
| * @classdesc | |
| * The CIE2000 color difference algorithm. | |
| * http://en.wikipedia.org/wiki/Color_difference#CIEDE2000 | |
| * @constructs dE00 | |
| * @memberOf DeltaE | |
| * @property {object} x1 The LAB color configuration object. | |
| * @property {number} x1.L The lightness value, on scale of 0-100. | |
| * @property {number} x1.A The chroma value, on scale of -128 to 128. | |
| * @property {number} x1.B The hue value, on scale of -128 to 128. | |
| * @property {object} x2 The LAB color configuration object. | |
| * @property {number} x2.L The lightness value, on scale of 0-100. | |
| * @property {number} x2.A The chroma value, on scale of -128 to 128. | |
| * @property {number} x2.B The hue value, on scale of -128 to 128. | |
| * @property {object} weights The weights configuration object. | |
| * @property {number} weights.lightness A weight factor to apply to lightness. | |
| * @property {number} weights.chroma A weight factor to apply to chroma. | |
| * @property {number} weights.hue A weight factor to apply to hue. | |
| * @example | |
| * var deltaE = new dE00( | |
| * {L:50, A:50, B:50}, | |
| * {L:100, A:50, B:50}, | |
| * ); | |
| * console.log(deltaE.getDeltaE()); | |
| */ | |
| function dE00(x1, x2, weights) { | |
| var sqrt = Math.sqrt; | |
| var pow = Math.pow; | |
| this.x1 = x1; | |
| this.x2 = x2; | |
| this.weights = weights || {}; | |
| this.ksubL = this.weights.lightness || 1; | |
| this.ksubC = this.weights.chroma || 1; | |
| this.ksubH = this.weights.hue || 1; | |
| // Delta L Prime | |
| this.deltaLPrime = x2.L - x1.L; | |
| // L Bar | |
| this.LBar = (x1.L + x2.L) / 2; | |
| // C1 & C2 | |
| this.C1 = sqrt(pow(x1.A, 2) + pow(x1.B, 2)); | |
| this.C2 = sqrt(pow(x2.A, 2) + pow(x2.B, 2)); | |
| // C Bar | |
| this.CBar = (this.C1 + this.C2) / 2; | |
| // A Prime 1 | |
| this.aPrime1 = x1.A + | |
| (x1.A / 2) * | |
| (1 - sqrt( | |
| pow(this.CBar, 7) / | |
| (pow(this.CBar, 7) + pow(25, 7)) | |
| )); | |
| // A Prime 2 | |
| this.aPrime2 = x2.A + | |
| (x2.A / 2) * | |
| (1 - sqrt( | |
| pow(this.CBar, 7) / | |
| (pow(this.CBar, 7) + pow(25, 7)) | |
| )); | |
| // C Prime 1 | |
| this.CPrime1 = sqrt( | |
| pow(this.aPrime1, 2) + | |
| pow(x1.B, 2) | |
| ); | |
| // C Prime 2 | |
| this.CPrime2 = sqrt( | |
| pow(this.aPrime2, 2) + | |
| pow(x2.B, 2) | |
| ); | |
| // C Bar Prime | |
| this.CBarPrime = (this.CPrime1 + this.CPrime2) / 2; | |
| // Delta C Prime | |
| this.deltaCPrime = this.CPrime2 - this.CPrime1; | |
| // S sub L | |
| this.SsubL = 1 + ( | |
| (0.015 * pow(this.LBar - 50, 2)) / | |
| sqrt(20 + pow(this.LBar - 50, 2)) | |
| ); | |
| // S sub C | |
| this.SsubC = 1 + 0.045 * this.CBarPrime; | |
| /** | |
| * Properties set in getDeltaE method, for access to convenience functions | |
| */ | |
| // h Prime 1 | |
| this.hPrime1 = 0; | |
| // h Prime 2 | |
| this.hPrime2 = 0; | |
| // Delta h Prime | |
| this.deltahPrime = 0; | |
| // Delta H Prime | |
| this.deltaHPrime = 0; | |
| // H Bar Prime | |
| this.HBarPrime = 0; | |
| // T | |
| this.T = 0; | |
| // S sub H | |
| this.SsubH = 0; | |
| // R sub T | |
| this.RsubT = 0; | |
| } | |
| /** | |
| * Returns the deltaE value. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE00.prototype.getDeltaE = function() { | |
| var sqrt = Math.sqrt; | |
| var sin = Math.sin; | |
| var pow = Math.pow; | |
| // h Prime 1 | |
| this.hPrime1 = this.gethPrime1(); | |
| // h Prime 2 | |
| this.hPrime2 = this.gethPrime2(); | |
| // Delta h Prime | |
| this.deltahPrime = this.getDeltahPrime(); | |
| // Delta H Prime | |
| this.deltaHPrime = 2 * sqrt(this.CPrime1 * this.CPrime2) * sin(this.degreesToRadians(this.deltahPrime) / 2); | |
| // H Bar Prime | |
| this.HBarPrime = this.getHBarPrime(); | |
| // T | |
| this.T = this.getT(); | |
| // S sub H | |
| this.SsubH = 1 + 0.015 * this.CBarPrime * this.T; | |
| // R sub T | |
| this.RsubT = this.getRsubT(); | |
| // Put it all together! | |
| var lightness = this.deltaLPrime / (this.ksubL * this.SsubL); | |
| var chroma = this.deltaCPrime / (this.ksubC * this.SsubC); | |
| var hue = this.deltaHPrime / (this.ksubH * this.SsubH); | |
| return sqrt( | |
| pow(lightness, 2) + | |
| pow(chroma, 2) + | |
| pow(hue, 2) + | |
| this.RsubT * chroma * hue | |
| ); | |
| }; | |
| /** | |
| * Returns the RT variable calculation. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE00.prototype.getRsubT = function() { | |
| var sin = Math.sin; | |
| var sqrt = Math.sqrt; | |
| var pow = Math.pow; | |
| var exp = Math.exp; | |
| return -2 * | |
| sqrt( | |
| pow(this.CBarPrime, 7) / | |
| (pow(this.CBarPrime, 7) + pow(25, 7)) | |
| ) * | |
| sin(this.degreesToRadians( | |
| 60 * | |
| exp( | |
| -( | |
| pow( | |
| (this.HBarPrime - 275) / 25, 2 | |
| ) | |
| ) | |
| ) | |
| )); | |
| }; | |
| /** | |
| * Returns the T variable calculation. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE00.prototype.getT = function() { | |
| var cos = Math.cos; | |
| return 1 - | |
| 0.17 * cos(this.degreesToRadians(this.HBarPrime - 30)) + | |
| 0.24 * cos(this.degreesToRadians(2 * this.HBarPrime)) + | |
| 0.32 * cos(this.degreesToRadians(3 * this.HBarPrime + 6)) - | |
| 0.20 * cos(this.degreesToRadians(4 * this.HBarPrime - 63)); | |
| }; | |
| /** | |
| * Returns the H Bar Prime variable calculation. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE00.prototype.getHBarPrime= function() { | |
| var abs = Math.abs; | |
| if (abs(this.hPrime1 - this.hPrime2) > 180) { | |
| return (this.hPrime1 + this.hPrime2 + 360) / 2 | |
| } | |
| return (this.hPrime1 + this.hPrime2) / 2 | |
| }; | |
| /** | |
| * Returns the Delta h Prime variable calculation. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE00.prototype.getDeltahPrime = function() { | |
| var abs = Math.abs; | |
| // When either C′1 or C′2 is zero, then Δh′ is irrelevant and may be set to | |
| // zero. | |
| if (0 === this.C1 || 0 === this.C2) { | |
| return 0; | |
| } | |
| if (abs(this.hPrime1 - this.hPrime2) <= 180) { | |
| return this.hPrime2 - this.hPrime1; | |
| } | |
| if (this.hPrime2 <= this.hPrime1) { | |
| return this.hPrime2 - this.hPrime1 + 360; | |
| } else { | |
| return this.hPrime2 - this.hPrime1 - 360; | |
| } | |
| }; | |
| /** | |
| * Returns the h Prime 1 variable calculation. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE00.prototype.gethPrime1 = function() { | |
| return this._gethPrimeFn(this.x1.B, this.aPrime1); | |
| }; | |
| /** | |
| * Returns the h Prime 2 variable calculation. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE00.prototype.gethPrime2 = function() { | |
| return this._gethPrimeFn(this.x2.B, this.aPrime2); | |
| }; | |
| /** | |
| * A helper function to calculate the h Prime 1 and h Prime 2 values. | |
| * @method | |
| * @private | |
| * @returns {number} | |
| */ | |
| dE00.prototype._gethPrimeFn = function(x, y) { | |
| var hueAngle; | |
| if (x === 0 && y === 0) { | |
| return 0; | |
| } | |
| hueAngle = this.radiansToDegrees(Math.atan2(x, y)); | |
| if (hueAngle >= 0) { | |
| return hueAngle; | |
| } else { | |
| return hueAngle + 360; | |
| } | |
| }; | |
| /** | |
| * Gives the radian equivalent of a specified degree angle. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE00.prototype.radiansToDegrees = function(radians) { | |
| return radians * (180 / Math.PI); | |
| }; | |
| /** | |
| * Gives the degree equivalent of a specified radian. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE00.prototype.degreesToRadians = function(degrees) { | |
| return degrees * (Math.PI / 180); | |
| }; | |
| module.exports = dE00; | |
| },{}],16:[function(require,module,exports){ | |
| 'use strict'; | |
| /** | |
| * @class dE76 | |
| * @classdesc | |
| * The CIE76 color difference algorithm: a simple euclidean distance calculation. | |
| * http://en.wikipedia.org/wiki/Color_difference#CIE76 | |
| * @constructs dE76 | |
| * @memberOf DeltaE | |
| * @property {object} x1 The LAB color configuration object. | |
| * @property {number} x1.L The lightness value, on scale of 0-100. | |
| * @property {number} x1.A The chroma value, on scale of -128 to 128. | |
| * @property {number} x1.B The hue value, on scale of -128 to 128. | |
| * @property {object} x2 The LAB color configuration object. | |
| * @property {number} x2.L The lightness value, on scale of 0-100. | |
| * @property {number} x2.A The chroma value, on scale of -128 to 128. | |
| * @property {number} x2.B The hue value, on scale of -128 to 128. | |
| * @example | |
| * var deltaE = new dE76( | |
| * {L:50, A:50, B:50}, | |
| * {L:100, A:50, B:50}, | |
| * ); | |
| * console.log(deltaE.getDeltaE()); | |
| */ | |
| function dE76(x1, x2) { | |
| this.x1 = x1; | |
| this.x2 = x2; | |
| } | |
| /** | |
| * Returns the dE76 value. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE76.prototype.getDeltaE = function() { | |
| var x1 = this.x1; | |
| var x2 = this.x2; | |
| return Math.sqrt( | |
| Math.pow(x2.L - x1.L, 2) + | |
| Math.pow(x2.A - x1.A, 2) + | |
| Math.pow(x2.B - x1.B, 2) | |
| ); | |
| }; | |
| module.exports = dE76; | |
| },{}],17:[function(require,module,exports){ | |
| 'use strict'; | |
| /** | |
| * @class dE94 | |
| * @classdesc | |
| * The CIE94 algorithm: an iteration of the CIE76 algorithm. | |
| * http://en.wikipedia.org/wiki/Color_difference#CIE94 | |
| * @constructs dE94 | |
| * @memberOf DeltaE | |
| * @property {object} x1 The LAB color configuration object. | |
| * @property {number} x1.L The lightness value, on scale of 0-100. | |
| * @property {number} x1.A The chroma value, on scale of -128 to 128. | |
| * @property {number} x1.B The hue value, on scale of -128 to 128. | |
| * @property {object} x2 The LAB color configuration object. | |
| * @property {number} x2.L The lightness value, on scale of 0-100. | |
| * @property {number} x2.A The chroma value, on scale of -128 to 128. | |
| * @property {number} x2.B The hue value, on scale of -128 to 128. | |
| * @property {object} weights The weights configuration object. | |
| * @property {number} weights.lightness A weight factor to apply to lightness. | |
| * @property {number} weights.chroma A weight factor to apply to chroma. | |
| * @property {number} weights.hue A weight factor to apply to hue. | |
| * @example | |
| * var deltaE = new dE94( | |
| * {L:50, A:50, B:50}, | |
| * {L:100, A:50, B:50}, | |
| * ); | |
| * console.log(deltaE.getDeltaE()); | |
| */ | |
| function dE94(x1, x2, weights) { | |
| this.x1 = x1; | |
| this.x2 = x2; | |
| this.weights = weights || {}; | |
| this.weights.lightness = this.weights.lightness || 1; | |
| this.weights.chroma = this.weights.chroma || 1; | |
| this.weights.hue = this.weights.hue || 1; | |
| if (1 === this.weights.lightness) { | |
| this.weights.K1 = 0.045; | |
| this.weights.K2 = 0.015; | |
| } else { | |
| this.weights.K1 = 0.048; | |
| this.weights.K2 = 0.014; | |
| } | |
| } | |
| /** | |
| * Returns the dE94 value. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE94.prototype.getDeltaE = function() { | |
| var x1 = this.x1; | |
| var x2 = this.x2; | |
| var sqrt = Math.sqrt; | |
| var pow = Math.pow; | |
| return sqrt( | |
| pow(this.calculateL(x1, x2), 2) + | |
| pow(this.calculateA(x1, x2), 2) + | |
| pow(this.calculateB(x1, x2), 2) | |
| ); | |
| }; | |
| /** | |
| * Calculates the lightness value. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE94.prototype.calculateL = function(x1, x2) { | |
| return (x1.L - x2.L) / this.weights.lightness; | |
| }; | |
| /** | |
| * Calculates the chroma value. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE94.prototype.calculateA = function(x1, x2) { | |
| var sqrt = Math.sqrt; | |
| var pow = Math.pow; | |
| //top | |
| var c1 = sqrt(pow(x1.A, 2) + pow(x1.B, 2)); | |
| var c2 = sqrt(pow(x2.A, 2) + pow(x2.B, 2)); | |
| var cab = c1 - c2; | |
| // bottom | |
| var sc = 1 + (this.weights.K1 * c1); | |
| return cab / (this.weights.chroma * sc); | |
| }; | |
| /** | |
| * Calculates the hue value. | |
| * @method | |
| * @returns {number} | |
| */ | |
| dE94.prototype.calculateB = function(x1, x2) { | |
| var sqrt = Math.sqrt; | |
| var pow = Math.pow; | |
| // cab | |
| var c1 = sqrt(pow(x1.A, 2) + pow(x1.B, 2)); | |
| var c2 = sqrt(pow(x2.A, 2) + pow(x2.B, 2)); | |
| var cab = c1 - c2; | |
| // top | |
| var a = x1.A - x2.A; | |
| var b = x1.B - x2.B; | |
| var hab = sqrt( | |
| pow(a, 2) + | |
| pow(b, 2) - | |
| pow(cab, 2) | |
| ); | |
| // bottom | |
| var c1 = sqrt(pow(x1.A, 2) + pow(x1.B, 2)); | |
| var sh = 1 + (this.weights.K2 * c1); | |
| return hab / sh; | |
| }; | |
| module.exports = dE94; | |
| },{}],18:[function(require,module,exports){ | |
| 'use strict'; | |
| /** | |
| * @class DeltaE | |
| * @classdesc | |
| * A package of dE76, dE94, and dE00 algorithms. | |
| * @constructs DeltaE | |
| * @example | |
| * var DeltaE = new DeltaE(); | |
| * var labColor1 = {L: 50, A: 50, B: 50}; | |
| * var labColor2 = {L: 20, A: 20, B: 20}; | |
| * | |
| * DeltaE.getDeltaE94(labColor1, labColor2); | |
| */ | |
| var dE76 = require('./dE76'); | |
| var dE94 = require('./dE94'); | |
| var dE00 = require('./dE00'); | |
| function DeltaE() {} | |
| /** | |
| * The CIE76 color difference algorithm: a simple euclidean distance calculation. | |
| * http://en.wikipedia.org/wiki/Color_difference#CIE76 | |
| * @property {object} x1 The LAB color configuration object. | |
| * @property {number} x1.L The lightness value, on scale of 0-100. | |
| * @property {number} x1.A The chroma value, on scale of -128 to 128. | |
| * @property {number} x1.B The hue value, on scale of -128 to 128. | |
| * @property {object} x2 The LAB color configuration object. | |
| * @property {number} x2.L The lightness value, on scale of 0-100. | |
| * @property {number} x2.A The chroma value, on scale of -128 to 128. | |
| * @property {number} x2.B The hue value, on scale of -128 to 128. | |
| * @returns {number} The computed dE76 value. | |
| * @example | |
| * var labColor1 = {L: 50, A: 50, B: 50}; | |
| * var labColor2 = {L: 20, A: 20, B: 20}; | |
| * | |
| * DeltaE.getDeltaE76(labColor1, labColor2); | |
| */ | |
| DeltaE.prototype.getDeltaE76 = function(lab1, lab2) { | |
| var deltaE = new dE76(lab1, lab2); | |
| return deltaE.getDeltaE(); | |
| }; | |
| /** | |
| * The CIE94 algorithm: an iteration of the CIE76 algorithm. | |
| * http://en.wikipedia.org/wiki/Color_difference#CIE94 | |
| * @property {object} x1 The LAB color configuration object. | |
| * @property {number} x1.L The lightness value, on scale of 0-100. | |
| * @property {number} x1.A The chroma value, on scale of -128 to 128. | |
| * @property {number} x1.B The hue value, on scale of -128 to 128. | |
| * @property {object} x2 The LAB color configuration object. | |
| * @property {number} x2.L The lightness value, on scale of 0-100. | |
| * @property {number} x2.A The chroma value, on scale of -128 to 128. | |
| * @property {number} x2.B The hue value, on scale of -128 to 128. | |
| * @property {object} weights The weights configuration object. | |
| * @property {number} weights.lightness A weight factor to apply to lightness. | |
| * @property {number} weights.chroma A weight factor to apply to chroma. | |
| * @property {number} weights.hue A weight factor to apply to hue. | |
| * @returns {number} The computed dE94 value. | |
| * @example | |
| * var labColor1 = {L: 50, A: 50, B: 50}; | |
| * var labColor2 = {L: 20, A: 20, B: 20}; | |
| * | |
| * DeltaE.getDeltaE94(labColor1, labColor2); | |
| */ | |
| DeltaE.prototype.getDeltaE94 = function(lab1, lab2) { | |
| var deltaE = new dE94(lab1, lab2); | |
| return deltaE.getDeltaE(); | |
| }; | |
| /** | |
| * The CIE2000 color difference algorithm. | |
| * http://en.wikipedia.org/wiki/Color_difference#CIEDE2000 | |
| * @property {object} x1 The LAB color configuration object. | |
| * @property {number} x1.L The lightness value, on scale of 0-100. | |
| * @property {number} x1.A The chroma value, on scale of -128 to 128. | |
| * @property {number} x1.B The hue value, on scale of -128 to 128. | |
| * @property {object} x2 The LAB color configuration object. | |
| * @property {number} x2.L The lightness value, on scale of 0-100. | |
| * @property {number} x2.A The chroma value, on scale of -128 to 128. | |
| * @property {number} x2.B The hue value, on scale of -128 to 128. | |
| * @property {object} weights The weights configuration object. | |
| * @property {number} weights.lightness A weight factor to apply to lightness. | |
| * @property {number} weights.chroma A weight factor to apply to chroma. | |
| * @property {number} weights.hue A weight factor to apply to hue. | |
| * @returns {number} The computed dE00 value. | |
| * @example | |
| * var labColor1 = {L: 50, A: 50, B: 50}; | |
| * var labColor2 = {L: 20, A: 20, B: 20}; | |
| * | |
| * DeltaE.getDeltaE00(labColor1, labColor2); | |
| */ | |
| DeltaE.prototype.getDeltaE00 = function(lab1, lab2) { | |
| var deltaE = new dE00(lab1, lab2); | |
| return deltaE.getDeltaE(); | |
| }; | |
| module.exports = new DeltaE; | |
| },{"./dE00":15,"./dE76":16,"./dE94":17}]},{},[1]); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <!DOCTYPE html> | |
| <html> | |
| <head> | |
| <title>test</title> | |
| </head> | |
| <style> | |
| #title { | |
| font-size: 22px; | |
| font-family: Kavivanar; | |
| font-weight: 500; | |
| } | |
| text { | |
| font-family: Kavivanar; | |
| } | |
| p { | |
| font-family: Alegreya; | |
| font-size: 15px; | |
| } | |
| span { | |
| font-weight: 700; | |
| } | |
| </style> | |
| <body> | |
| <link href="https://fonts.googleapis.com/css?family=Alegreya|Kavivanar" rel="stylesheet"> | |
| <h1 id="title">Perceptual Distances in Color Spaces</h1> | |
| <p><span>On the left:</span> Perceptual distances between adjacent colors are shown for 3 versions of the "rainbow" colormap as well as a number of popular sequential or diverging alternative colormaps. Perceptual distance is calculated based on the DeltaE 2000 defined in Zachary Schuessler's <a href="https://zschuessler.github.io/DeltaE/learn/#toc-delta-e-2000">DeltaE node package</a>. The higher the point on the graph, the greater the perceived distance (for people who are not colorblind) between that color and its immediate neighbors.</p> | |
| <p><span>On the right:</span> These are normalized versions of each colormap. Each walks through the same set of hues as the original colormap and with the same average perceptual distance between adjacent points, but are normalized to be perceptually uniform.</p> | |
| <p><span>The colormaps:</span> "Jet" is the former default color scheme used by MatLab. HSL walks through the full set of hues in the HSL space, with full saturation and 0.5 lightness. The "less angry rainbow" is the <a href="https://github.com/d3/d3-scale#interpolateRainbow">interpolateRainbow</a> defined in D3. The rest of the color schemes can be found in the <a href="https://github.com/d3/d3-scale">D3-scale documentation</a> or <a href="https://github.com/d3/d3-scale-chromatic">D3-scale-chromatic</a>.</p> | |
| <p><span>Learn more:</span> A blog post discussing this visualization is in the works.</p> | |
| <p><em>By Zan Armstrong and Jonas Sicking</em></p> | |
| <svg id="viz"></svg> | |
| <script type="text/javascript" src="distbundle.js"></script> | |
| </body> | |
| </html> |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment