Early/simplifed version of You Draw It: What Got Better or Worse During Obama’s Presidency
d3.drag is pretty great!
Early/simplifed version of You Draw It: What Got Better or Worse During Obama’s Presidency
d3.drag is pretty great!
var data = [ | |
{"year": 2001, "debt": 31.4}, | |
{"year": 2002, "debt": 32.6}, | |
{"year": 2003, "debt": 34.5}, | |
{"year": 2004, "debt": 35.5}, | |
{"year": 2005, "debt": 35.6}, | |
{"year": 2006, "debt": 35.3}, | |
{"year": 2007, "debt": 35.2}, | |
{"year": 2008, "debt": 39.3}, | |
{"year": 2009, "debt": 52.3}, | |
{"year": 2010, "debt": 60.9}, | |
{"year": 2011, "debt": 65.9}, | |
{"year": 2012, "debt": 70.4}, | |
{"year": 2013, "debt": 72.6}, | |
{"year": 2014, "debt": 74.4}, | |
{"year": 2015, "debt": 73.6}, | |
] | |
var ƒ = d3.f | |
var sel = d3.select('body').html('') | |
var c = d3.conventions({ | |
parentSel: sel, | |
totalWidth: sel.node().offsetWidth, | |
height: 400, | |
margin: {left: 50, right: 50, top: 30, bottom: 30} | |
}) | |
c.svg.append('rect').at({width: c.width, height: c.height, opacity: 0}) | |
c.x.domain([2001, 2015]) | |
c.y.domain([0, 100]) | |
c.xAxis.ticks(4).tickFormat(ƒ()) | |
c.yAxis.ticks(5).tickFormat(d => d + '%') | |
var area = d3.area().x(ƒ('year', c.x)).y0(ƒ('debt', c.y)).y1(c.height) | |
var line = d3.area().x(ƒ('year', c.x)).y(ƒ('debt', c.y)) | |
var clipRect = c.svg | |
.append('clipPath#clip') | |
.append('rect') | |
.at({width: c.x(2008) - 2, height: c.height}) | |
var correctSel = c.svg.append('g').attr('clip-path', 'url(#clip)') | |
correctSel.append('path.area').at({d: area(data)}) | |
correctSel.append('path.line').at({d: line(data)}) | |
yourDataSel = c.svg.append('path.your-line') | |
c.drawAxis() | |
yourData = data | |
.map(function(d){ return {year: d.year, debt: d.debt, defined: 0} }) | |
.filter(function(d){ | |
if (d.year == 2008) d.defined = true | |
return d.year >= 2008 | |
}) | |
var completed = false | |
var drag = d3.drag() | |
.on('drag', function(){ | |
var pos = d3.mouse(this) | |
var year = clamp(2009, 2016, c.x.invert(pos[0])) | |
var debt = clamp(0, c.y.domain()[1], c.y.invert(pos[1])) | |
yourData.forEach(function(d){ | |
if (Math.abs(d.year - year) < .5){ | |
d.debt = debt | |
d.defined = true | |
} | |
}) | |
yourDataSel.at({d: line.defined(ƒ('defined'))(yourData)}) | |
if (!completed && d3.mean(yourData, ƒ('defined')) == 1){ | |
completed = true | |
clipRect.transition().duration(1000).attr('width', c.x(2015)) | |
} | |
}) | |
c.svg.call(drag) | |
function clamp(a, b, c){ return Math.max(a, Math.min(b, c)) } |
(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'; | |
function ascending(a, b) { | |
return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; | |
} | |
function bisector(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; | |
function descending(a, b) { | |
return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; | |
} | |
function number(x) { | |
return x === null ? NaN : +x; | |
} | |
function variance(array, f) { | |
var n = array.length, | |
m = 0, | |
a, | |
d, | |
s = 0, | |
i = -1, | |
j = 0; | |
if (f == null) { | |
while (++i < n) { | |
if (!isNaN(a = number(array[i]))) { | |
d = a - m; | |
m += d / ++j; | |
s += d * (a - m); | |
} | |
} | |
} | |
else { | |
while (++i < n) { | |
if (!isNaN(a = number(f(array[i], i, array)))) { | |
d = a - m; | |
m += d / ++j; | |
s += d * (a - m); | |
} | |
} | |
} | |
if (j > 1) return s / (j - 1); | |
} | |
function deviation(array, f) { | |
var v = variance(array, f); | |
return v ? Math.sqrt(v) : v; | |
} | |
function extent(array, f) { | |
var i = -1, | |
n = array.length, | |
a, | |
b, | |
c; | |
if (f == null) { | |
while (++i < n) if ((b = array[i]) != null && b >= b) { a = c = b; break; } | |
while (++i < n) if ((b = array[i]) != null) { | |
if (a > b) a = b; | |
if (c < b) c = b; | |
} | |
} | |
else { | |
while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = c = b; break; } | |
while (++i < n) if ((b = f(array[i], i, array)) != null) { | |
if (a > b) a = b; | |
if (c < b) c = b; | |
} | |
} | |
return [a, c]; | |
} | |
var array = Array.prototype; | |
var slice = array.slice; | |
var map = array.map; | |
function constant(x) { | |
return function() { | |
return x; | |
}; | |
} | |
function identity(x) { | |
return x; | |
} | |
function range(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); | |
function ticks(start, stop, count) { | |
var step = tickStep(start, stop, count); | |
return range( | |
Math.ceil(start / step) * step, | |
Math.floor(stop / step) * step + step / 2, // inclusive | |
step | |
); | |
} | |
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; | |
} | |
function sturges(values) { | |
return Math.ceil(Math.log(values.length) / Math.LN2) + 1; | |
} | |
function histogram() { | |
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 = ticks(x0, x1, tz); | |
// 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; | |
} | |
function threshold(array, p, f) { | |
if (f == null) f = number; | |
if (!(n = array.length)) return; | |
if ((p = +p) <= 0 || n < 2) return +f(array[0], 0, array); | |
if (p >= 1) return +f(array[n - 1], n - 1, array); | |
var n, | |
h = (n - 1) * p, | |
i = Math.floor(h), | |
a = +f(array[i], i, array), | |
b = +f(array[i + 1], i + 1, array); | |
return a + (b - a) * (h - i); | |
} | |
function freedmanDiaconis(values, min, max) { | |
values = map.call(values, number).sort(ascending); | |
return Math.ceil((max - min) / (2 * (threshold(values, 0.75) - threshold(values, 0.25)) * Math.pow(values.length, -1 / 3))); | |
} | |
function scott(values, min, max) { | |
return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(values.length, -1 / 3))); | |
} | |
function max(array, f) { | |
var i = -1, | |
n = array.length, | |
a, | |
b; | |
if (f == null) { | |
while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; } | |
while (++i < n) if ((b = array[i]) != null && b > a) a = b; | |
} | |
else { | |
while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; } | |
while (++i < n) if ((b = f(array[i], i, array)) != null && b > a) a = b; | |
} | |
return a; | |
} | |
function mean(array, f) { | |
var s = 0, | |
n = array.length, | |
a, | |
i = -1, | |
j = n; | |
if (f == null) { | |
while (++i < n) if (!isNaN(a = number(array[i]))) s += a; else --j; | |
} | |
else { | |
while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) s += a; else --j; | |
} | |
if (j) return s / j; | |
} | |
function median(array, f) { | |
var numbers = [], | |
n = array.length, | |
a, | |
i = -1; | |
if (f == null) { | |
while (++i < n) if (!isNaN(a = number(array[i]))) numbers.push(a); | |
} | |
else { | |
while (++i < n) if (!isNaN(a = number(f(array[i], i, array)))) numbers.push(a); | |
} | |
return threshold(numbers.sort(ascending), 0.5); | |
} | |
function merge(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; | |
} | |
function min(array, f) { | |
var i = -1, | |
n = array.length, | |
a, | |
b; | |
if (f == null) { | |
while (++i < n) if ((b = array[i]) != null && b >= b) { a = b; break; } | |
while (++i < n) if ((b = array[i]) != null && a > b) a = b; | |
} | |
else { | |
while (++i < n) if ((b = f(array[i], i, array)) != null && b >= b) { a = b; break; } | |
while (++i < n) if ((b = f(array[i], i, array)) != null && a > b) a = b; | |
} | |
return a; | |
} | |
function pairs(array) { | |
var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n); | |
while (i < n) pairs[i] = [p, p = array[++i]]; | |
return pairs; | |
} | |
function permute(array, indexes) { | |
var i = indexes.length, permutes = new Array(i); | |
while (i--) permutes[i] = array[indexes[i]]; | |
return permutes; | |
} | |
function scan(array, compare) { | |
if (!(n = array.length)) return; | |
var i = 0, | |
n, | |
j = 0, | |
xi, | |
xj = array[j]; | |
if (!compare) compare = ascending; | |
while (++i < n) if (compare(xi = array[i], xj) < 0 || compare(xj, xj) !== 0) xj = xi, j = i; | |
if (compare(xj, xj) === 0) return j; | |
} | |
function shuffle(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; | |
} | |
function sum(array, f) { | |
var s = 0, | |
n = array.length, | |
a, | |
i = -1; | |
if (f == null) { | |
while (++i < n) if (a = +array[i]) s += a; // Note: zero and null are equivalent. | |
} | |
else { | |
while (++i < n) if (a = +f(array[i], i, array)) s += a; | |
} | |
return s; | |
} | |
function transpose(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; | |
} | |
function zip() { | |
return transpose(arguments); | |
} | |
var prefix = "$"; | |
function Map() {} | |
Map.prototype = map$1.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$1(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; | |
} | |
function nest() { | |
var keys = [], | |
sortKeys = [], | |
sortValues, | |
rollup, | |
nest; | |
function apply(array, depth, createResult, setResult) { | |
if (depth >= keys.length) return rollup != null | |
? rollup(array) : (sortValues != null | |
? array.sort(sortValues) | |
: array); | |
var i = -1, | |
n = array.length, | |
key = keys[depth++], | |
keyValue, | |
value, | |
valuesByKey = map$1(), | |
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, depth) { | |
if (++depth > keys.length) return map; | |
var array, sortKey = sortKeys[depth - 1]; | |
if (rollup != null && depth >= keys.length) array = map.entries(); | |
else array = [], map.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$1(); | |
} | |
function setMap(map, key, value) { | |
map.set(key, value); | |
} | |
function Set() {} | |
var proto = map$1.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; | |
} | |
function d3keys(map) { | |
var keys = []; | |
for (var key in map) keys.push(key); | |
return keys; | |
} | |
function values(map) { | |
var values = []; | |
for (var key in map) values.push(map[key]); | |
return values; | |
} | |
function entries(map) { | |
var entries = []; | |
for (var key in map) entries.push({key: key, value: map[key]}); | |
return entries; | |
} | |
function uniform(min, max) { | |
min = min == null ? 0 : +min; | |
max = max == null ? 1 : +max; | |
if (arguments.length === 1) max = min, min = 0; | |
else max -= min; | |
return function() { | |
return Math.random() * max + min; | |
}; | |
} | |
function normal(mu, sigma) { | |
var x, r; | |
mu = mu == null ? 0 : +mu; | |
sigma = sigma == null ? 1 : +sigma; | |
return function() { | |
var y; | |
// If available, use the second previously-generated uniform random. | |
if (x != null) y = x, x = null; | |
// Otherwise, generate a new x and y. | |
else do { | |
x = Math.random() * 2 - 1; | |
y = Math.random() * 2 - 1; | |
r = x * x + y * y; | |
} while (!r || r > 1); | |
return mu + sigma * y * Math.sqrt(-2 * Math.log(r) / r); | |
}; | |
} | |
function logNormal() { | |
var randomNormal = normal.apply(this, arguments); | |
return function() { | |
return Math.exp(randomNormal()); | |
}; | |
} | |
function irwinHall(n) { | |
return function() { | |
for (var sum = 0, i = 0; i < n; ++i) sum += Math.random(); | |
return sum; | |
}; | |
} | |
function bates(n) { | |
var randomIrwinHall = irwinHall(n); | |
return function() { | |
return randomIrwinHall() / n; | |
}; | |
} | |
function exponential(lambda) { | |
return function() { | |
return -Math.log(1 - Math.random()) / lambda; | |
}; | |
} | |
function linear(t) { | |
return +t; | |
} | |
function quadIn(t) { | |
return t * t; | |
} | |
function quadOut(t) { | |
return t * (2 - t); | |
} | |
function quadInOut(t) { | |
return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2; | |
} | |
function cubicIn(t) { | |
return t * t * t; | |
} | |
function cubicOut(t) { | |
return --t * t * t + 1; | |
} | |
function easeCubicInOut(t) { | |
return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2; | |
} | |
var exponent = 3; | |
var polyIn = (function custom(e) { | |
e = +e; | |
function polyIn(t) { | |
return Math.pow(t, e); | |
} | |
polyIn.exponent = custom; | |
return polyIn; | |
})(exponent); | |
var polyOut = (function custom(e) { | |
e = +e; | |
function polyOut(t) { | |
return 1 - Math.pow(1 - t, e); | |
} | |
polyOut.exponent = custom; | |
return polyOut; | |
})(exponent); | |
var polyInOut = (function custom(e) { | |
e = +e; | |
function polyInOut(t) { | |
return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2; | |
} | |
polyInOut.exponent = custom; | |
return polyInOut; | |
})(exponent); | |
var pi = Math.PI; | |
var halfPi = pi / 2; | |
function sinIn(t) { | |
return 1 - Math.cos(t * halfPi); | |
} | |
function sinOut(t) { | |
return Math.sin(t * halfPi); | |
} | |
function sinInOut(t) { | |
return (1 - Math.cos(pi * t)) / 2; | |
} | |
function expIn(t) { | |
return Math.pow(2, 10 * t - 10); | |
} | |
function expOut(t) { | |
return 1 - Math.pow(2, -10 * t); | |
} | |
function expInOut(t) { | |
return ((t *= 2) <= 1 ? Math.pow(2, 10 * t - 10) : 2 - Math.pow(2, 10 - 10 * t)) / 2; | |
} | |
function circleIn(t) { | |
return 1 - Math.sqrt(1 - t * t); | |
} | |
function circleOut(t) { | |
return Math.sqrt(1 - --t * t); | |
} | |
function circleInOut(t) { | |
return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2; | |
} | |
var b1 = 4 / 11; | |
var b2 = 6 / 11; | |
var b3 = 8 / 11; | |
var b4 = 3 / 4; | |
var b5 = 9 / 11; | |
var b6 = 10 / 11; | |
var b7 = 15 / 16; | |
var b8 = 21 / 22; | |
var b9 = 63 / 64; | |
var b0 = 1 / b1 / b1; | |
function bounceIn(t) { | |
return 1 - bounceOut(1 - t); | |
} | |
function bounceOut(t) { | |
return (t = +t) < b1 ? b0 * t * t : t < b3 ? b0 * (t -= b2) * t + b4 : t < b6 ? b0 * (t -= b5) * t + b7 : b0 * (t -= b8) * t + b9; | |
} | |
function bounceInOut(t) { | |
return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2; | |
} | |
var overshoot = 1.70158; | |
var backIn = (function custom(s) { | |
s = +s; | |
function backIn(t) { | |
return t * t * ((s + 1) * t - s); | |
} | |
backIn.overshoot = custom; | |
return backIn; | |
})(overshoot); | |
var backOut = (function custom(s) { | |
s = +s; | |
function backOut(t) { | |
return --t * t * ((s + 1) * t + s) + 1; | |
} | |
backOut.overshoot = custom; | |
return backOut; | |
})(overshoot); | |
var backInOut = (function custom(s) { | |
s = +s; | |
function backInOut(t) { | |
return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2; | |
} | |
backInOut.overshoot = custom; | |
return backInOut; | |
})(overshoot); | |
var tau = 2 * Math.PI; | |
var amplitude = 1; | |
var period = 0.3; | |
var elasticIn = (function custom(a, p) { | |
var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); | |
function elasticIn(t) { | |
return a * Math.pow(2, 10 * --t) * Math.sin((s - t) / p); | |
} | |
elasticIn.amplitude = function(a) { return custom(a, p * tau); }; | |
elasticIn.period = function(p) { return custom(a, p); }; | |
return elasticIn; | |
})(amplitude, period); | |
var elasticOut = (function custom(a, p) { | |
var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); | |
function elasticOut(t) { | |
return 1 - a * Math.pow(2, -10 * (t = +t)) * Math.sin((t + s) / p); | |
} | |
elasticOut.amplitude = function(a) { return custom(a, p * tau); }; | |
elasticOut.period = function(p) { return custom(a, p); }; | |
return elasticOut; | |
})(amplitude, period); | |
var elasticInOut = (function custom(a, p) { | |
var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); | |
function elasticInOut(t) { | |
return ((t = t * 2 - 1) < 0 | |
? a * Math.pow(2, 10 * t) * Math.sin((s - t) / p) | |
: 2 - a * Math.pow(2, -10 * t) * Math.sin((s + t) / p)) / 2; | |
} | |
elasticInOut.amplitude = function(a) { return custom(a, p * tau); }; | |
elasticInOut.period = function(p) { return custom(a, p); }; | |
return elasticInOut; | |
})(amplitude, period); | |
function area(polygon) { | |
var i = -1, | |
n = polygon.length, | |
a, | |
b = polygon[n - 1], | |
area = 0; | |
while (++i < n) { | |
a = b; | |
b = polygon[i]; | |
area += a[1] * b[0] - a[0] * b[1]; | |
} | |
return area / 2; | |
} | |
function centroid(polygon) { | |
var i = -1, | |
n = polygon.length, | |
x = 0, | |
y = 0, | |
a, | |
b = polygon[n - 1], | |
c, | |
k = 0; | |
while (++i < n) { | |
a = b; | |
b = polygon[i]; | |
k += c = a[0] * b[1] - b[0] * a[1]; | |
x += (a[0] + b[0]) * c; | |
y += (a[1] + b[1]) * c; | |
} | |
return k *= 3, [x / k, y / k]; | |
} | |
// Returns the 2D cross product of AB and AC vectors, i.e., the z-component of | |
// the 3D cross product in a quadrant I Cartesian coordinate system (+x is | |
// right, +y is up). Returns a positive value if ABC is counter-clockwise, | |
// negative if clockwise, and zero if the points are collinear. | |
function cross(a, b, c) { | |
return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]); | |
} | |
function lexicographicOrder(a, b) { | |
return a[0] - b[0] || a[1] - b[1]; | |
} | |
// Computes the upper convex hull per the monotone chain algorithm. | |
// Assumes points.length >= 3, is sorted by x, unique in y. | |
// Returns an array of indices into points in left-to-right order. | |
function computeUpperHullIndexes(points) { | |
var n = points.length, | |
indexes = [0, 1], | |
size = 2; | |
for (var i = 2; i < n; ++i) { | |
while (size > 1 && cross(points[indexes[size - 2]], points[indexes[size - 1]], points[i]) <= 0) --size; | |
indexes[size++] = i; | |
} | |
return indexes.slice(0, size); // remove popped points | |
} | |
function hull(points) { | |
if ((n = points.length) < 3) return null; | |
var i, | |
n, | |
sortedPoints = new Array(n), | |
flippedPoints = new Array(n); | |
for (i = 0; i < n; ++i) sortedPoints[i] = [+points[i][0], +points[i][1], i]; | |
sortedPoints.sort(lexicographicOrder); | |
for (i = 0; i < n; ++i) flippedPoints[i] = [sortedPoints[i][0], -sortedPoints[i][1]]; | |
var upperIndexes = computeUpperHullIndexes(sortedPoints), | |
lowerIndexes = computeUpperHullIndexes(flippedPoints); | |
// Construct the hull polygon, removing possible duplicate endpoints. | |
var skipLeft = lowerIndexes[0] === upperIndexes[0], | |
skipRight = lowerIndexes[lowerIndexes.length - 1] === upperIndexes[upperIndexes.length - 1], | |
hull = []; | |
// Add upper hull in right-to-l order. | |
// Then add lower hull in left-to-right order. | |
for (i = upperIndexes.length - 1; i >= 0; --i) hull.push(points[sortedPoints[upperIndexes[i]][2]]); | |
for (i = +skipLeft; i < lowerIndexes.length - skipRight; ++i) hull.push(points[sortedPoints[lowerIndexes[i]][2]]); | |
return hull; | |
} | |
function contains(polygon, point) { | |
var n = polygon.length, | |
p = polygon[n - 1], | |
x = point[0], y = point[1], | |
x0 = p[0], y0 = p[1], | |
x1, y1, | |
inside = false; | |
for (var i = 0; i < n; ++i) { | |
p = polygon[i], x1 = p[0], y1 = p[1]; | |
if (((y1 > y) !== (y0 > y)) && (x < (x0 - x1) * (y - y1) / (y0 - y1) + x1)) inside = !inside; | |
x0 = x1, y0 = y1; | |
} | |
return inside; | |
} | |
function length$1(polygon) { | |
var i = -1, | |
n = polygon.length, | |
b = polygon[n - 1], | |
xa, | |
ya, | |
xb = b[0], | |
yb = b[1], | |
perimeter = 0; | |
while (++i < n) { | |
xa = xb; | |
ya = yb; | |
b = polygon[i]; | |
xb = b[0]; | |
yb = b[1]; | |
xa -= xb; | |
ya -= yb; | |
perimeter += Math.sqrt(xa * xa + ya * ya); | |
} | |
return perimeter; | |
} | |
var pi$1 = Math.PI; | |
var tau$1 = 2 * pi$1; | |
var epsilon = 1e-6; | |
var tauEpsilon = tau$1 - 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._.push("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._.push("Z"); | |
} | |
}, | |
lineTo: function(x, y) { | |
this._.push("L", this._x1 = +x, ",", this._y1 = +y); | |
}, | |
quadraticCurveTo: function(x1, y1, x, y) { | |
this._.push("Q", +x1, ",", +y1, ",", this._x1 = +x, ",", this._y1 = +y); | |
}, | |
bezierCurveTo: function(x1, y1, x2, y2, x, y) { | |
this._.push("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._.push( | |
"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._.push( | |
"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$1 - 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._.push( | |
"L", x1 + t01 * x01, ",", y1 + t01 * y01 | |
); | |
} | |
this._.push( | |
"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._.push( | |
"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._.push( | |
"L", x0, ",", y0 | |
); | |
} | |
// Is this arc empty? We’re done. | |
if (!r) return; | |
// Is this a complete circle? Draw two arcs to complete the circle. | |
if (da > tauEpsilon) { | |
this._.push( | |
"A", r, ",", r, ",0,1,", cw, ",", x - dx, ",", y - dy, | |
"A", r, ",", r, ",0,1,", cw, ",", this._x1 = x0, ",", this._y1 = y0 | |
); | |
} | |
// Otherwise, draw an arc! | |
else { | |
if (da < 0) da = da % tau$1 + tau$1; | |
this._.push( | |
"A", r, ",", r, ",0,", +(da >= pi$1), ",", cw, ",", this._x1 = x + r * Math.cos(a1), ",", this._y1 = y + r * Math.sin(a1) | |
); | |
} | |
}, | |
rect: function(x, y, w, h) { | |
this._.push("M", this._x0 = this._x1 = +x, ",", this._y0 = this._y1 = +y, "h", +w, "v", +h, "h", -w, "Z"); | |
}, | |
toString: function() { | |
return this._.join(""); | |
} | |
}; | |
function tree_add(d) { | |
var x = +this._x.call(null, d), | |
y = +this._y.call(null, d); | |
return add(this.cover(x, y), x, y, d); | |
} | |
function add(tree, x, y, d) { | |
if (isNaN(x) || isNaN(y)) return tree; // ignore invalid points | |
var parent, | |
node = tree._root, | |
leaf = {data: d}, | |
x0 = tree._x0, | |
y0 = tree._y0, | |
x1 = tree._x1, | |
y1 = tree._y1, | |
xm, | |
ym, | |
xp, | |
yp, | |
right, | |
bottom, | |
i, | |
j; | |
// If the tree is empty, initialize the root as a leaf. | |
if (!node) return tree._root = leaf, tree; | |
// Find the existing leaf for the new point, or add it. | |
while (node.length) { | |
if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; | |
if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; | |
if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree; | |
} | |
// Is the new point is exactly coincident with the existing point? | |
xp = +tree._x.call(null, node.data); | |
yp = +tree._y.call(null, node.data); | |
if (x === xp && y === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree; | |
// Otherwise, split the leaf node until the old and new point are separated. | |
do { | |
parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4); | |
if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; | |
if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; | |
} while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | (xp >= xm))); | |
return parent[j] = node, parent[i] = leaf, tree; | |
} | |
function addAll(data) { | |
var d, i, n = data.length, | |
x, | |
y, | |
xz = new Array(n), | |
yz = new Array(n), | |
x0 = Infinity, | |
y0 = Infinity, | |
x1 = -Infinity, | |
y1 = -Infinity; | |
// Compute the points and their extent. | |
for (i = 0; i < n; ++i) { | |
if (isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d))) continue; | |
xz[i] = x; | |
yz[i] = y; | |
if (x < x0) x0 = x; | |
if (x > x1) x1 = x; | |
if (y < y0) y0 = y; | |
if (y > y1) y1 = y; | |
} | |
// If there were no (valid) points, inherit the existing extent. | |
if (x1 < x0) x0 = this._x0, x1 = this._x1; | |
if (y1 < y0) y0 = this._y0, y1 = this._y1; | |
// Expand the tree to cover the new points. | |
this.cover(x0, y0).cover(x1, y1); | |
// Add the new points. | |
for (i = 0; i < n; ++i) { | |
add(this, xz[i], yz[i], data[i]); | |
} | |
return this; | |
} | |
function tree_cover(x, y) { | |
if (isNaN(x = +x) || isNaN(y = +y)) return this; // ignore invalid points | |
var x0 = this._x0, | |
y0 = this._y0, | |
x1 = this._x1, | |
y1 = this._y1; | |
// If the quadtree has no extent, initialize them. | |
// Integer extent are necessary so that if we later double the extent, | |
// the existing quadrant boundaries don’t change due to floating point error! | |
if (isNaN(x0)) { | |
x1 = (x0 = Math.floor(x)) + 1; | |
y1 = (y0 = Math.floor(y)) + 1; | |
} | |
// Otherwise, double repeatedly to cover. | |
else if (x0 > x || x > x1 || y0 > y || y > y1) { | |
var z = x1 - x0, | |
node = this._root, | |
parent, | |
i; | |
switch (i = (y < (y0 + y1) / 2) << 1 | (x < (x0 + x1) / 2)) { | |
case 0: { | |
do parent = new Array(4), parent[i] = node, node = parent; | |
while (z *= 2, x1 = x0 + z, y1 = y0 + z, x > x1 || y > y1); | |
break; | |
} | |
case 1: { | |
do parent = new Array(4), parent[i] = node, node = parent; | |
while (z *= 2, x0 = x1 - z, y1 = y0 + z, x0 > x || y > y1); | |
break; | |
} | |
case 2: { | |
do parent = new Array(4), parent[i] = node, node = parent; | |
while (z *= 2, x1 = x0 + z, y0 = y1 - z, x > x1 || y0 > y); | |
break; | |
} | |
case 3: { | |
do parent = new Array(4), parent[i] = node, node = parent; | |
while (z *= 2, x0 = x1 - z, y0 = y1 - z, x0 > x || y0 > y); | |
break; | |
} | |
} | |
if (this._root && this._root.length) this._root = node; | |
} | |
// If the quadtree covers the point already, just return. | |
else return this; | |
this._x0 = x0; | |
this._y0 = y0; | |
this._x1 = x1; | |
this._y1 = y1; | |
return this; | |
} | |
function tree_data() { | |
var data = []; | |
this.visit(function(node) { | |
if (!node.length) do data.push(node.data); while (node = node.next) | |
}); | |
return data; | |
} | |
function tree_extent(_) { | |
return arguments.length | |
? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1]) | |
: isNaN(this._x0) ? undefined : [[this._x0, this._y0], [this._x1, this._y1]]; | |
} | |
function Quad(node, x0, y0, x1, y1) { | |
this.node = node; | |
this.x0 = x0; | |
this.y0 = y0; | |
this.x1 = x1; | |
this.y1 = y1; | |
} | |
function tree_find(x, y, radius) { | |
var data, | |
x0 = this._x0, | |
y0 = this._y0, | |
x1, | |
y1, | |
x2, | |
y2, | |
x3 = this._x1, | |
y3 = this._y1, | |
quads = [], | |
node = this._root, | |
q, | |
i; | |
if (node) quads.push(new Quad(node, x0, y0, x3, y3)); | |
if (radius == null) radius = Infinity; | |
else { | |
x0 = x - radius, y0 = y - radius; | |
x3 = x + radius, y3 = y + radius; | |
radius *= radius; | |
} | |
while (q = quads.pop()) { | |
// Stop searching if this quadrant can’t contain a closer node. | |
if (!(node = q.node) | |
|| (x1 = q.x0) > x3 | |
|| (y1 = q.y0) > y3 | |
|| (x2 = q.x1) < x0 | |
|| (y2 = q.y1) < y0) continue; | |
// Bisect the current quadrant. | |
if (node.length) { | |
var xm = (x1 + x2) / 2, | |
ym = (y1 + y2) / 2; | |
quads.push( | |
new Quad(node[3], xm, ym, x2, y2), | |
new Quad(node[2], x1, ym, xm, y2), | |
new Quad(node[1], xm, y1, x2, ym), | |
new Quad(node[0], x1, y1, xm, ym) | |
); | |
// Visit the closest quadrant first. | |
if (i = (y >= ym) << 1 | (x >= xm)) { | |
q = quads[quads.length - 1]; | |
quads[quads.length - 1] = quads[quads.length - 1 - i]; | |
quads[quads.length - 1 - i] = q; | |
} | |
} | |
// Visit this point. (Visiting coincident points isn’t necessary!) | |
else { | |
var dx = x - +this._x.call(null, node.data), | |
dy = y - +this._y.call(null, node.data), | |
d2 = dx * dx + dy * dy; | |
if (d2 < radius) { | |
var d = Math.sqrt(radius = d2); | |
x0 = x - d, y0 = y - d; | |
x3 = x + d, y3 = y + d; | |
data = node.data; | |
} | |
} | |
} | |
return data; | |
} | |
function tree_remove(d) { | |
if (isNaN(x = +this._x.call(null, d)) || isNaN(y = +this._y.call(null, d))) return this; // ignore invalid points | |
var parent, | |
node = this._root, | |
retainer, | |
previous, | |
next, | |
x0 = this._x0, | |
y0 = this._y0, | |
x1 = this._x1, | |
y1 = this._y1, | |
x, | |
y, | |
xm, | |
ym, | |
right, | |
bottom, | |
i, | |
j; | |
// If the tree is empty, initialize the root as a leaf. | |
if (!node) return this; | |
// Find the leaf node for the point. | |
// While descending, also retain the deepest parent with a non-removed sibling. | |
if (node.length) while (true) { | |
if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; | |
if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; | |
if (!(parent = node, node = node[i = bottom << 1 | right])) return this; | |
if (!node.length) break; | |
if (parent[(i + 1) & 3] || parent[(i + 2) & 3] || parent[(i + 3) & 3]) retainer = parent, j = i; | |
} | |
// Find the point to remove. | |
while (node.data !== d) if (!(previous = node, node = node.next)) return this; | |
if (next = node.next) delete node.next; | |
// If there are multiple coincident points, remove just the point. | |
if (previous) return (next ? previous.next = next : delete previous.next), this; | |
// If this is the root point, remove it. | |
if (!parent) return this._root = next, this; | |
// Remove this leaf. | |
next ? parent[i] = next : delete parent[i]; | |
// If the parent now contains exactly one leaf, collapse superfluous parents. | |
if ((node = parent[0] || parent[1] || parent[2] || parent[3]) | |
&& node === (parent[3] || parent[2] || parent[1] || parent[0]) | |
&& !node.length) { | |
if (retainer) retainer[j] = node; | |
else this._root = node; | |
} | |
return this; | |
} | |
function removeAll(data) { | |
for (var i = 0, n = data.length; i < n; ++i) this.remove(data[i]); | |
return this; | |
} | |
function tree_root() { | |
return this._root; | |
} | |
function tree_size() { | |
var size = 0; | |
this.visit(function(node) { | |
if (!node.length) do ++size; while (node = node.next) | |
}); | |
return size; | |
} | |
function tree_visit(callback) { | |
var quads = [], q, node = this._root, child, x0, y0, x1, y1; | |
if (node) quads.push(new Quad(node, this._x0, this._y0, this._x1, this._y1)); | |
while (q = quads.pop()) { | |
if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) { | |
var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2; | |
if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1)); | |
if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1)); | |
if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym)); | |
if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym)); | |
} | |
} | |
return this; | |
} | |
function tree_visitAfter(callback) { | |
var quads = [], next = [], q; | |
if (this._root) quads.push(new Quad(this._root, this._x0, this._y0, this._x1, this._y1)); | |
while (q = quads.pop()) { | |
var node = q.node; | |
if (node.length) { | |
var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2; | |
if (child = node[0]) quads.push(new Quad(child, x0, y0, xm, ym)); | |
if (child = node[1]) quads.push(new Quad(child, xm, y0, x1, ym)); | |
if (child = node[2]) quads.push(new Quad(child, x0, ym, xm, y1)); | |
if (child = node[3]) quads.push(new Quad(child, xm, ym, x1, y1)); | |
} | |
next.push(q); | |
} | |
while (q = next.pop()) { | |
callback(q.node, q.x0, q.y0, q.x1, q.y1); | |
} | |
return this; | |
} | |
function defaultX(d) { | |
return d[0]; | |
} | |
function tree_x(_) { | |
return arguments.length ? (this._x = _, this) : this._x; | |
} | |
function defaultY(d) { | |
return d[1]; | |
} | |
function tree_y(_) { | |
return arguments.length ? (this._y = _, this) : this._y; | |
} | |
function quadtree(nodes, x, y) { | |
var tree = new Quadtree(x == null ? defaultX : x, y == null ? defaultY : y, NaN, NaN, NaN, NaN); | |
return nodes == null ? tree : tree.addAll(nodes); | |
} | |
function Quadtree(x, y, x0, y0, x1, y1) { | |
this._x = x; | |
this._y = y; | |
this._x0 = x0; | |
this._y0 = y0; | |
this._x1 = x1; | |
this._y1 = y1; | |
this._root = undefined; | |
} | |
function leaf_copy(leaf) { | |
var copy = {data: leaf.data}, next = copy; | |
while (leaf = leaf.next) next = next.next = {data: leaf.data}; | |
return copy; | |
} | |
var treeProto = quadtree.prototype = Quadtree.prototype; | |
treeProto.copy = function() { | |
var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1), | |
node = this._root, | |
nodes, | |
child; | |
if (!node) return copy; | |
if (!node.length) return copy._root = leaf_copy(node), copy; | |
nodes = [{source: node, target: copy._root = new Array(4)}]; | |
while (node = nodes.pop()) { | |
for (var i = 0; i < 4; ++i) { | |
if (child = node.source[i]) { | |
if (child.length) nodes.push({source: child, target: node.target[i] = new Array(4)}); | |
else node.target[i] = leaf_copy(child); | |
} | |
} | |
} | |
return copy; | |
}; | |
treeProto.add = tree_add; | |
treeProto.addAll = addAll; | |
treeProto.cover = tree_cover; | |
treeProto.data = tree_data; | |
treeProto.extent = tree_extent; | |
treeProto.find = tree_find; | |
treeProto.remove = tree_remove; | |
treeProto.removeAll = removeAll; | |
treeProto.root = tree_root; | |
treeProto.size = tree_size; | |
treeProto.visit = tree_visit; | |
treeProto.visitAfter = tree_visitAfter; | |
treeProto.x = tree_x; | |
treeProto.y = tree_y; | |
var slice$1 = [].slice; | |
var noabort = {}; | |
function Queue(size) { | |
if (!(size >= 1)) throw new Error; | |
this._size = size; | |
this._call = | |
this._error = null; | |
this._tasks = []; | |
this._data = []; | |
this._waiting = | |
this._active = | |
this._ended = | |
this._start = 0; // inside a synchronous task callback? | |
} | |
Queue.prototype = queue.prototype = { | |
constructor: Queue, | |
defer: function(callback) { | |
if (typeof callback !== "function" || this._call) throw new Error; | |
if (this._error != null) return this; | |
var t = slice$1.call(arguments, 1); | |
t.push(callback); | |
++this._waiting, this._tasks.push(t); | |
poke(this); | |
return this; | |
}, | |
abort: function() { | |
if (this._error == null) abort(this, new Error("abort")); | |
return this; | |
}, | |
await: function(callback) { | |
if (typeof callback !== "function" || this._call) throw new Error; | |
this._call = function(error, results) { callback.apply(null, [error].concat(results)); }; | |
maybeNotify(this); | |
return this; | |
}, | |
awaitAll: function(callback) { | |
if (typeof callback !== "function" || this._call) throw new Error; | |
this._call = callback; | |
maybeNotify(this); | |
return this; | |
} | |
}; | |
function poke(q) { | |
if (!q._start) { | |
try { start(q); } // let the current task complete | |
catch (e) { | |
if (q._tasks[q._ended + q._active - 1]) abort(q, e); // task errored synchronously | |
else if (!q._data) throw e; // await callback errored synchronously | |
} | |
} | |
} | |
function start(q) { | |
while (q._start = q._waiting && q._active < q._size) { | |
var i = q._ended + q._active, | |
t = q._tasks[i], | |
j = t.length - 1, | |
c = t[j]; | |
t[j] = end(q, i); | |
--q._waiting, ++q._active; | |
t = c.apply(null, t); | |
if (!q._tasks[i]) continue; // task finished synchronously | |
q._tasks[i] = t || noabort; | |
} | |
} | |
function end(q, i) { | |
return function(e, r) { | |
if (!q._tasks[i]) return; // ignore multiple callbacks | |
--q._active, ++q._ended; | |
q._tasks[i] = null; | |
if (q._error != null) return; // ignore secondary errors | |
if (e != null) { | |
abort(q, e); | |
} else { | |
q._data[i] = r; | |
if (q._waiting) poke(q); | |
else maybeNotify(q); | |
} | |
}; | |
} | |
function abort(q, e) { | |
var i = q._tasks.length, t; | |
q._error = e; // ignore active callbacks | |
q._data = undefined; // allow gc | |
q._waiting = NaN; // prevent starting | |
while (--i >= 0) { | |
if (t = q._tasks[i]) { | |
q._tasks[i] = null; | |
if (t.abort) { | |
try { t.abort(); } | |
catch (e) { /* ignore */ } | |
} | |
} | |
} | |
q._active = NaN; // allow notification | |
maybeNotify(q); | |
} | |
function maybeNotify(q) { | |
if (!q._active && q._call) { | |
var d = q._data; | |
q._data = undefined; // allow gc | |
q._call(q._error, d); | |
} | |
} | |
function queue(concurrency) { | |
return new Queue(arguments.length ? +concurrency : Infinity); | |
} | |
function constant$1(x) { | |
return function constant() { | |
return x; | |
}; | |
} | |
var epsilon$1 = 1e-12; | |
var pi$2 = Math.PI; | |
var halfPi$1 = pi$2 / 2; | |
var tau$2 = 2 * pi$2; | |
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 asin(x) { | |
return x >= 1 ? halfPi$1 : x <= -1 ? -halfPi$1 : Math.asin(x); | |
} | |
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) / Math.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) * Math.sqrt(Math.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) | |
}; | |
} | |
function arc() { | |
var innerRadius = arcInnerRadius, | |
outerRadius = arcOuterRadius, | |
cornerRadius = constant$1(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$1, | |
a1 = endAngle.apply(this, arguments) - halfPi$1, | |
da = Math.abs(a1 - a0), | |
cw = a1 > a0; | |
if (!context) context = buffer = 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$1)) context.moveTo(0, 0); | |
// Or is it a circle or annulus? | |
else if (da > tau$2 - epsilon$1) { | |
context.moveTo(r1 * Math.cos(a0), r1 * Math.sin(a0)); | |
context.arc(0, 0, r1, a0, a1, !cw); | |
if (r0 > epsilon$1) { | |
context.moveTo(r0 * Math.cos(a1), r0 * Math.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$1) && (padRadius ? +padRadius.apply(this, arguments) : Math.sqrt(r0 * r0 + r1 * r1)), | |
rc = Math.min(Math.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$1) { | |
var p0 = asin(rp / r0 * Math.sin(ap)), | |
p1 = asin(rp / r1 * Math.sin(ap)); | |
if ((da0 -= p0 * 2) > epsilon$1) p0 *= (cw ? 1 : -1), a00 += p0, a10 -= p0; | |
else da0 = 0, a00 = a10 = (a0 + a1) / 2; | |
if ((da1 -= p1 * 2) > epsilon$1) p1 *= (cw ? 1 : -1), a01 += p1, a11 -= p1; | |
else da1 = 0, a01 = a11 = (a0 + a1) / 2; | |
} | |
var x01 = r1 * Math.cos(a01), | |
y01 = r1 * Math.sin(a01), | |
x10 = r0 * Math.cos(a10), | |
y10 = r0 * Math.sin(a10); | |
// Apply rounded corners? | |
if (rc > epsilon$1) { | |
var x11 = r1 * Math.cos(a11), | |
y11 = r1 * Math.sin(a11), | |
x00 = r0 * Math.cos(a00), | |
y00 = r0 * Math.sin(a00); | |
// Restrict the corner radius according to the sector angle. | |
if (da < pi$2) { | |
var oc = da0 > epsilon$1 ? 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 / Math.sin(Math.acos((ax * bx + ay * by) / (Math.sqrt(ax * ax + ay * ay) * Math.sqrt(bx * bx + by * by))) / 2), | |
lc = Math.sqrt(oc[0] * oc[0] + oc[1] * oc[1]); | |
rc0 = Math.min(rc, (r0 - lc) / (kc - 1)); | |
rc1 = Math.min(rc, (r1 - lc) / (kc + 1)); | |
} | |
} | |
// Is the sector collapsed to a line? | |
if (!(da1 > epsilon$1)) context.moveTo(x01, y01); | |
// Does the sector’s outer ring have rounded corners? | |
else if (rc1 > epsilon$1) { | |
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, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw); | |
// Otherwise, draw the two corners and the ring. | |
else { | |
context.arc(t0.cx, t0.cy, rc1, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw); | |
context.arc(0, 0, r1, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), !cw); | |
context.arc(t1.cx, t1.cy, rc1, Math.atan2(t1.y11, t1.x11), Math.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$1) || !(da0 > epsilon$1)) context.lineTo(x10, y10); | |
// Does the sector’s inner ring (or point) have rounded corners? | |
else if (rc0 > epsilon$1) { | |
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, Math.atan2(t0.y01, t0.x01), Math.atan2(t1.y01, t1.x01), !cw); | |
// Otherwise, draw the two corners and the ring. | |
else { | |
context.arc(t0.cx, t0.cy, rc0, Math.atan2(t0.y01, t0.x01), Math.atan2(t0.y11, t0.x11), !cw); | |
context.arc(0, 0, r0, Math.atan2(t0.cy + t0.y11, t0.cx + t0.x11), Math.atan2(t1.cy + t1.y11, t1.cx + t1.x11), cw); | |
context.arc(t1.cx, t1.cy, rc0, Math.atan2(t1.y11, t1.x11), Math.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 / 2; | |
return [Math.cos(a) * r, Math.sin(a) * r]; | |
}; | |
arc.innerRadius = function(_) { | |
return arguments.length ? (innerRadius = typeof _ === "function" ? _ : constant$1(+_), arc) : innerRadius; | |
}; | |
arc.outerRadius = function(_) { | |
return arguments.length ? (outerRadius = typeof _ === "function" ? _ : constant$1(+_), arc) : outerRadius; | |
}; | |
arc.cornerRadius = function(_) { | |
return arguments.length ? (cornerRadius = typeof _ === "function" ? _ : constant$1(+_), arc) : cornerRadius; | |
}; | |
arc.padRadius = function(_) { | |
return arguments.length ? (padRadius = _ == null ? null : typeof _ === "function" ? _ : constant$1(+_), arc) : padRadius; | |
}; | |
arc.startAngle = function(_) { | |
return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant$1(+_), arc) : startAngle; | |
}; | |
arc.endAngle = function(_) { | |
return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant$1(+_), arc) : endAngle; | |
}; | |
arc.padAngle = function(_) { | |
return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant$1(+_), 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; | |
} | |
} | |
}; | |
function curveLinear(context) { | |
return new Linear(context); | |
} | |
function x(p) { | |
return p[0]; | |
} | |
function y(p) { | |
return p[1]; | |
} | |
function line() { | |
var x$$ = x, | |
y$$ = y, | |
defined = constant$1(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 = 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$$(d, i, data), +y$$(d, i, data)); | |
} | |
if (buffer) return output = null, buffer + "" || null; | |
} | |
line.x = function(_) { | |
return arguments.length ? (x$$ = typeof _ === "function" ? _ : constant$1(+_), line) : x$$; | |
}; | |
line.y = function(_) { | |
return arguments.length ? (y$$ = typeof _ === "function" ? _ : constant$1(+_), line) : y$$; | |
}; | |
line.defined = function(_) { | |
return arguments.length ? (defined = typeof _ === "function" ? _ : constant$1(!!_), 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; | |
} | |
function area$1() { | |
var x0 = x, | |
x1 = null, | |
y0 = constant$1(0), | |
y1 = y, | |
defined = constant$1(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 = 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$1(+_), x1 = null, area) : x0; | |
}; | |
area.x0 = function(_) { | |
return arguments.length ? (x0 = typeof _ === "function" ? _ : constant$1(+_), area) : x0; | |
}; | |
area.x1 = function(_) { | |
return arguments.length ? (x1 = _ == null ? null : typeof _ === "function" ? _ : constant$1(+_), area) : x1; | |
}; | |
area.y = function(_) { | |
return arguments.length ? (y0 = typeof _ === "function" ? _ : constant$1(+_), y1 = null, area) : y0; | |
}; | |
area.y0 = function(_) { | |
return arguments.length ? (y0 = typeof _ === "function" ? _ : constant$1(+_), area) : y0; | |
}; | |
area.y1 = function(_) { | |
return arguments.length ? (y1 = _ == null ? null : typeof _ === "function" ? _ : constant$1(+_), 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$1(!!_), 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; | |
} | |
function descending$1(a, b) { | |
return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; | |
} | |
function identity$1(d) { | |
return d; | |
} | |
function pie() { | |
var value = identity$1, | |
sortValues = descending$1, | |
sort = null, | |
startAngle = constant$1(0), | |
endAngle = constant$1(tau$2), | |
padAngle = constant$1(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$2, Math.max(-tau$2, 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$1(+_), 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$1(+_), pie) : startAngle; | |
}; | |
pie.endAngle = function(_) { | |
return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant$1(+_), pie) : endAngle; | |
}; | |
pie.padAngle = function(_) { | |
return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant$1(+_), 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 radialLine(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; | |
} | |
function radialLine$1() { | |
return radialLine(line().curve(curveRadialLinear)); | |
} | |
function radialArea() { | |
var a = area$1().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 radialLine(x0()); }, delete a.lineX0; | |
a.lineEndAngle = function() { return radialLine(x1()); }, delete a.lineX1; | |
a.lineInnerRadius = function() { return radialLine(y0()); }, delete a.lineY0; | |
a.lineOuterRadius = function() { return radialLine(y1()); }, delete a.lineY1; | |
a.curve = function(_) { | |
return arguments.length ? c(curveRadial(_)) : c()._curve; | |
}; | |
return a; | |
} | |
var circle = { | |
draw: function(context, size) { | |
var r = Math.sqrt(size / pi$2); | |
context.moveTo(r, 0); | |
context.arc(0, 0, r, 0, tau$2); | |
} | |
}; | |
var cross$1 = { | |
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$2 / 10) / Math.sin(7 * pi$2 / 10); | |
var kx = Math.sin(tau$2 / 10) * kr; | |
var ky = -Math.cos(tau$2 / 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$2 * 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$1, | |
diamond, | |
square, | |
star, | |
triangle, | |
wye | |
]; | |
function symbol() { | |
var type = constant$1(circle), | |
size = constant$1(64), | |
context = null; | |
function symbol() { | |
var buffer; | |
if (!context) context = buffer = 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$1(_), symbol) : type; | |
}; | |
symbol.size = function(_) { | |
return arguments.length ? (size = typeof _ === "function" ? _ : constant$1(+_), symbol) : size; | |
}; | |
symbol.context = function(_) { | |
return arguments.length ? (context = _ == null ? null : _, symbol) : context; | |
}; | |
return symbol; | |
} | |
function noop() {} | |
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; | |
} | |
}; | |
function basis(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; | |
} | |
}; | |
function basisClosed(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; | |
} | |
}; | |
function basisOpen(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$1) { | |
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$1) { | |
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, 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); | |
} | |
}; | |
function linearClosed(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]; | |
} | |
function natural(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; | |
} | |
}; | |
function step(context) { | |
return new Step(context, 0.5); | |
} | |
function stepBefore(context) { | |
return new Step(context, 0); | |
} | |
function stepAfter(context) { | |
return new Step(context, 1); | |
} | |
var slice$2 = Array.prototype.slice; | |
function none(series, order) { | |
if (!((n = series.length) > 1)) return; | |
for (var i = 1, s0, s1 = series[order[0]], n, m = s1.length; i < n; ++i) { | |
s0 = s1, s1 = series[order[i]]; | |
for (var j = 0; j < m; ++j) { | |
s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1]; | |
} | |
} | |
} | |
function none$1(series) { | |
var n = series.length, o = new Array(n); | |
while (--n >= 0) o[n] = n; | |
return o; | |
} | |
function stackValue(d, key) { | |
return d[key]; | |
} | |
function stack() { | |
var keys = constant$1([]), | |
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$1(slice$2.call(_)), stack) : keys; | |
}; | |
stack.value = function(_) { | |
return arguments.length ? (value = typeof _ === "function" ? _ : constant$1(+_), stack) : value; | |
}; | |
stack.order = function(_) { | |
return arguments.length ? (order = _ == null ? none$1 : typeof _ === "function" ? _ : constant$1(slice$2.call(_)), stack) : order; | |
}; | |
stack.offset = function(_) { | |
return arguments.length ? (offset = _ == null ? none : _, stack) : offset; | |
}; | |
return stack; | |
} | |
function expand(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); | |
} | |
function silhouette(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); | |
} | |
function wiggle(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); | |
} | |
function ascending$1(series) { | |
var sums = series.map(sum$1); | |
return none$1(series).sort(function(a, b) { return sums[a] - sums[b]; }); | |
} | |
function sum$1(series) { | |
var s = 0, i = -1, n = series.length, v; | |
while (++i < n) if (v = +series[i][1]) s += v; | |
return s; | |
} | |
function descending$2(series) { | |
return ascending$1(series).reverse(); | |
} | |
function insideOut(series) { | |
var n = series.length, | |
i, | |
j, | |
sums = series.map(sum$1), | |
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); | |
} | |
function reverse(series) { | |
return none$1(series).reverse(); | |
} | |
function define(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 reHex3 = /^#([0-9a-f]{3})$/; | |
var reHex6 = /^#([0-9a-f]{6})$/; | |
var reRgbInteger = /^rgb\(\s*([-+]?\d+)\s*,\s*([-+]?\d+)\s*,\s*([-+]?\d+)\s*\)$/; | |
var reRgbPercent = /^rgb\(\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*\)$/; | |
var reRgbaInteger = /^rgba\(\s*([-+]?\d+)\s*,\s*([-+]?\d+)\s*,\s*([-+]?\d+)\s*,\s*([-+]?\d+(?:\.\d+)?)\s*\)$/; | |
var reRgbaPercent = /^rgba\(\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)\s*\)$/; | |
var reHslPercent = /^hsl\(\s*([-+]?\d+(?:\.\d+)?)\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*\)$/; | |
var reHslaPercent = /^hsla\(\s*([-+]?\d+(?:\.\d+)?)\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)%\s*,\s*([-+]?\d+(?:\.\d+)?)\s*\)$/; | |
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: 0xff000 |