| license: mit |
| node_modules/ |
This started as experiment to look at using the playpool chart idea in different ways.
This was inspired by Luke Mastin's vertical timeline of Western philosophers and the names and dates are taken from the historical section of Mastin's The Basics of Philosophy website.
I wrote about developing this and the problems I encountered in my blog post called "Problems in the philosophers' playpool".
| (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ | |
| var d3 = require("d3") | |
| var dickiedates = require("dickie-dates") | |
| var m = [20, 15, 50, 20] //top right bottom left | |
| var f = 20 | |
| var w = 960 - m[1] - m[3] | |
| var h = 500 - m[0] - m[2] | |
| var miniHeight = h / 6 | |
| var mainHeight = h - miniHeight | |
| timeBegin = new Date("0000") | |
| timeEnd = new Date("2000") | |
| var x = d3.time.scale() | |
| .range([0, w]) | |
| var t = d3.time.scale() | |
| .range([0, w]) | |
| var y1 = d3.scale.linear() | |
| .range([0, mainHeight]) | |
| var y2 = d3.scale.linear() | |
| .range([0, miniHeight]) | |
| var xAxis = d3.svg.axis() | |
| .scale(x) | |
| .orient("bottom") | |
| .tickSize(5) | |
| .tickPadding(1) | |
| var tAxis = d3.svg.axis() | |
| .scale(t) | |
| .orient("bottom") | |
| .tickSize(5) | |
| .tickPadding(1) | |
| var getMainItemHeight = d => .8 * y1(1) | |
| var getMiniItemHeight = d => .8 * y2(1) | |
| var chart = d3.select("body") | |
| .append("svg") | |
| .attr("width", w + m[1] + m[3]) | |
| .attr("height", h + m[0] + m[2]) | |
| .attr("class", `chart`) | |
| chart.append("defs").append("clipPath") | |
| .attr("id", "clip") | |
| .append("rect") | |
| .attr("width", w) | |
| .attr("height", mainHeight) | |
| var main = chart.append("g") | |
| .attr("transform", `translate(${m[3]}, ${m[0]})`) | |
| .attr("width", w) | |
| .attr("height", mainHeight) | |
| .attr("class", "main") | |
| var mini = chart.append("g") | |
| .attr("transform", `translate(${m[3]}, ${mainHeight + m[0]})`) | |
| .attr("width", w) | |
| .attr("height", miniHeight) | |
| .attr("class", "mini") | |
| var focus = main.append("g") | |
| .attr("class", "focus") | |
| focus.append("g") | |
| .attr("class", "t axis") | |
| .call(tAxis) | |
| var dataOptions = { | |
| "start": "Born", | |
| "end": "Died", | |
| "id": "Philosopher", | |
| "dateformat": { | |
| parse: dateTimeValue => { | |
| var isoDateFormat = dateTimeValue.replace(/(-?)(\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)/, "$100$2-$3-$4 $5:$6:$7") | |
| var dateObject = new Date(isoDateFormat) | |
| var yearWithoutSign = dateTimeValue.match(/^00\d{2}/) | |
| var correctedDateObject = yearWithoutSign ? dateObject.setUTCFullYear(yearWithoutSign) : dateObject | |
| return correctedDateObject | |
| } | |
| } | |
| } | |
| var laneKeys = {} | |
| var lanes = [] | |
| var laneLength = 0 | |
| var laneArrays = [] | |
| var processData = (options => { | |
| var dataOptions = { | |
| "start": options.start || "start", | |
| "end": options.end || "end", | |
| "lane": options.lane || "", | |
| "id": options.id || "id", | |
| "dateformat": options.dateformat || { parse: x => x } | |
| } | |
| return v => { | |
| if (v[dataOptions.start]) { | |
| if (v[dataOptions.start]) { | |
| var dates = dickiedates.parseDate({ | |
| startDate: v[dataOptions.start], | |
| endDate: v[dataOptions.end] || v[dataOptions.start] | |
| }) | |
| } else { | |
| var dates = { | |
| startDate: "", | |
| endDate: "" | |
| } | |
| } | |
| v.start = dataOptions.dateformat.parse(dates.startDate) | |
| v.end = dataOptions.dateformat.parse(dates.endDate) | |
| var assignLanes = function (laneArrays, i) { | |
| var updateValue = (v, i) => { | |
| v.lanelabel = `Lane ${i}` | |
| v.lane = i | |
| return v | |
| } | |
| var checkConflict = (v, e) => ( | |
| (v.start >= e.start && v.start <= e.end) || | |
| (v.end >= e.start && v.end <= e.end) || | |
| (e.start >= v.start && e.start <= v.end) || | |
| (e.end >= v.start && e.end <= v.end) | |
| ) | |
| var isConflict = false | |
| var j | |
| if (laneArrays[i]) { | |
| for (j = 0; (j < laneArrays[i].length) && !isConflict; j += 1) { | |
| isConflict = checkConflict(v, laneArrays[i][j]) | |
| } | |
| if (isConflict) { | |
| assignLanes(laneArrays, i + 1) | |
| } else { | |
| laneArrays[i][j] = updateValue(v, i) | |
| } | |
| } else { | |
| laneArrays[i] = [updateValue(v, i)] | |
| lanes.push(`Lane ${i}`) | |
| laneLength += 1 | |
| } | |
| } | |
| if (dataOptions.lane) { | |
| if (!laneKeys.hasOwnProperty(v[dataOptions.lane])) { | |
| lanes.push(v[dataOptions.lane]) | |
| laneKeys[v[dataOptions.lane]] = laneLength | |
| laneLength += 1 | |
| } | |
| v.lanelabel = v[dataOptions.lane] | |
| v.lane = laneKeys[v[dataOptions.lane]] | |
| } else { | |
| assignLanes(laneArrays, 0) | |
| } | |
| v.id = v[dataOptions.id] | |
| if (!v.start || !v.end) { | |
| v = null | |
| } | |
| } else { | |
| v = null | |
| } | |
| return v | |
| } | |
| })(dataOptions) | |
| d3.tsv("data.tsv", processData, function (error, items) { | |
| if (error) throw error | |
| var timeBegin = d3.min(items, d => d.start) | |
| var timeEnd = d3.max(items, d => d.end) | |
| x.domain([timeBegin, timeEnd]) | |
| t.domain([timeBegin, timeEnd]) | |
| y1.domain([0, laneLength]) | |
| y2.domain([0, laneLength]) | |
| var itemRects = main.append("g") | |
| .attr("clip-path", "url(#clip)") | |
| //mini item rects | |
| mini.append("g").selectAll("miniItems") | |
| .data(items) | |
| .enter().append("rect") | |
| .attr("x", d => x(d.start)) | |
| .attr("y", d => y2(d.lane + .5) + f - (getMiniItemHeight() / 2)) | |
| .attr("width", d => x(d.end) - x(d.start)) | |
| .attr("height", getMiniItemHeight) | |
| .attr("class", d => `mini-line q${d.lane}-${laneLength} mini-line-${d.id.replace(/\W/g, "-")}`) | |
| var brush = d3.svg.brush() | |
| .x(x) | |
| .on("brush", display) | |
| mini.append("g") | |
| .attr("class", "x brush") | |
| .call(brush) | |
| .selectAll("rect") | |
| .attr("y", 1 + f) | |
| .attr("height", miniHeight) | |
| mini.append("g") | |
| .attr("class", "x axis") | |
| .attr("transform", `translate(0, ${miniHeight + f})`) | |
| .call(xAxis) | |
| display() | |
| function display() { | |
| var rects | |
| var labels | |
| var minExtent = brush.empty() ? t.domain()[0] : brush.extent()[0] | |
| var maxExtent = brush.empty() ? t.domain()[1] : brush.extent()[1] | |
| var visItems = items.filter(d => d.start < maxExtent && d.end > minExtent) | |
| if (!brush.empty()) { | |
| mini.select(".brush") | |
| .call(brush.extent([minExtent, maxExtent])) | |
| } | |
| t.domain([minExtent, maxExtent]) | |
| focus.select(".t.axis").call(tAxis) | |
| // add lines | |
| lines = itemRects.selectAll("line") | |
| .data(visItems, d => d.id) | |
| .attr("x1", d => t(d.start)) | |
| .attr("x2", d => t(d.end)) | |
| //.attr("width", d => t(d.end) - t(d.start)) | |
| lines.enter().append("line") | |
| .attr("class", d => `line q${d.lane}-${laneLength} major-line-${d.id.replace(/\W/g, "-")}`) | |
| .attr("x1", d => t(d.start)) | |
| .attr("x2", d => t(d.end)) | |
| .attr("y1", d => y1(d.lane + 0.5) + f) | |
| .attr("y2", d => y1(d.lane + 0.5) + f) | |
| .on("mouseover", d => { | |
| d3.select(`.major-line-${d.id.replace(/\W/g, "-")}`) | |
| .classed("selected", true) | |
| d3.select(`.mini-line-${d.id.replace(/\W/g, "-")}`) | |
| .classed("selected", true) | |
| chart.selectAll(`.major-text-${d.id.replace(/\W/g, "-")}`) | |
| .style("display", "block") | |
| }) | |
| .on("mouseout", d => { | |
| chart.selectAll(".selected") | |
| .classed("selected", false) | |
| chart.selectAll(`.major-text-${d.id.replace(/\W/g, "-")}`) | |
| .style("display", "none") | |
| }) | |
| lines.exit().remove() | |
| labels = itemRects.selectAll("text") | |
| .data(visItems, d => d.id) | |
| .attr("x", d => t(Math.max(d.start, minExtent))) | |
| labels.enter().append("text") | |
| .text(d => d.id) | |
| .attr("x", d => t(Math.max(d.start, minExtent))) | |
| .attr("y", d => y1(d.lane + .5) + f - 6) | |
| .attr("text-anchor", "start") | |
| .style("display", "none") | |
| .attr("class", d => `label major-text-${d.id.replace(/\W/g, "-")}`) | |
| labels.exit().remove() | |
| } | |
| }) | |
| },{"d3":2,"dickie-dates":3}],2:[function(require,module,exports){ | |
| !function() { | |
| var d3 = { | |
| version: "3.5.17" | |
| }; | |
| var d3_arraySlice = [].slice, d3_array = function(list) { | |
| return d3_arraySlice.call(list); | |
| }; | |
| var d3_document = this.document; | |
| function d3_documentElement(node) { | |
| return node && (node.ownerDocument || node.document || node).documentElement; | |
| } | |
| function d3_window(node) { | |
| return node && (node.ownerDocument && node.ownerDocument.defaultView || node.document && node || node.defaultView); | |
| } | |
| if (d3_document) { | |
| try { | |
| d3_array(d3_document.documentElement.childNodes)[0].nodeType; | |
| } catch (e) { | |
| d3_array = function(list) { | |
| var i = list.length, array = new Array(i); | |
| while (i--) array[i] = list[i]; | |
| return array; | |
| }; | |
| } | |
| } | |
| if (!Date.now) Date.now = function() { | |
| return +new Date(); | |
| }; | |
| if (d3_document) { | |
| try { | |
| d3_document.createElement("DIV").style.setProperty("opacity", 0, ""); | |
| } catch (error) { | |
| var d3_element_prototype = this.Element.prototype, d3_element_setAttribute = d3_element_prototype.setAttribute, d3_element_setAttributeNS = d3_element_prototype.setAttributeNS, d3_style_prototype = this.CSSStyleDeclaration.prototype, d3_style_setProperty = d3_style_prototype.setProperty; | |
| d3_element_prototype.setAttribute = function(name, value) { | |
| d3_element_setAttribute.call(this, name, value + ""); | |
| }; | |
| d3_element_prototype.setAttributeNS = function(space, local, value) { | |
| d3_element_setAttributeNS.call(this, space, local, value + ""); | |
| }; | |
| d3_style_prototype.setProperty = function(name, value, priority) { | |
| d3_style_setProperty.call(this, name, value + "", priority); | |
| }; | |
| } | |
| } | |
| d3.ascending = d3_ascending; | |
| function d3_ascending(a, b) { | |
| return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; | |
| } | |
| d3.descending = function(a, b) { | |
| return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; | |
| }; | |
| d3.min = function(array, f) { | |
| var i = -1, n = array.length, a, b; | |
| if (arguments.length === 1) { | |
| 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.call(array, array[i], i)) != null && b >= b) { | |
| a = b; | |
| break; | |
| } | |
| while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b; | |
| } | |
| return a; | |
| }; | |
| d3.max = function(array, f) { | |
| var i = -1, n = array.length, a, b; | |
| if (arguments.length === 1) { | |
| 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.call(array, array[i], i)) != null && b >= b) { | |
| a = b; | |
| break; | |
| } | |
| while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b; | |
| } | |
| return a; | |
| }; | |
| d3.extent = function(array, f) { | |
| var i = -1, n = array.length, a, b, c; | |
| if (arguments.length === 1) { | |
| 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.call(array, array[i], i)) != null && b >= b) { | |
| a = c = b; | |
| break; | |
| } | |
| while (++i < n) if ((b = f.call(array, array[i], i)) != null) { | |
| if (a > b) a = b; | |
| if (c < b) c = b; | |
| } | |
| } | |
| return [ a, c ]; | |
| }; | |
| function d3_number(x) { | |
| return x === null ? NaN : +x; | |
| } | |
| function d3_numeric(x) { | |
| return !isNaN(x); | |
| } | |
| d3.sum = function(array, f) { | |
| var s = 0, n = array.length, a, i = -1; | |
| if (arguments.length === 1) { | |
| while (++i < n) if (d3_numeric(a = +array[i])) s += a; | |
| } else { | |
| while (++i < n) if (d3_numeric(a = +f.call(array, array[i], i))) s += a; | |
| } | |
| return s; | |
| }; | |
| d3.mean = function(array, f) { | |
| var s = 0, n = array.length, a, i = -1, j = n; | |
| if (arguments.length === 1) { | |
| while (++i < n) if (d3_numeric(a = d3_number(array[i]))) s += a; else --j; | |
| } else { | |
| while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) s += a; else --j; | |
| } | |
| if (j) return s / j; | |
| }; | |
| d3.quantile = function(values, p) { | |
| var H = (values.length - 1) * p + 1, h = Math.floor(H), v = +values[h - 1], e = H - h; | |
| return e ? v + e * (values[h] - v) : v; | |
| }; | |
| d3.median = function(array, f) { | |
| var numbers = [], n = array.length, a, i = -1; | |
| if (arguments.length === 1) { | |
| while (++i < n) if (d3_numeric(a = d3_number(array[i]))) numbers.push(a); | |
| } else { | |
| while (++i < n) if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) numbers.push(a); | |
| } | |
| if (numbers.length) return d3.quantile(numbers.sort(d3_ascending), .5); | |
| }; | |
| d3.variance = function(array, f) { | |
| var n = array.length, m = 0, a, d, s = 0, i = -1, j = 0; | |
| if (arguments.length === 1) { | |
| while (++i < n) { | |
| if (d3_numeric(a = d3_number(array[i]))) { | |
| d = a - m; | |
| m += d / ++j; | |
| s += d * (a - m); | |
| } | |
| } | |
| } else { | |
| while (++i < n) { | |
| if (d3_numeric(a = d3_number(f.call(array, array[i], i)))) { | |
| d = a - m; | |
| m += d / ++j; | |
| s += d * (a - m); | |
| } | |
| } | |
| } | |
| if (j > 1) return s / (j - 1); | |
| }; | |
| d3.deviation = function() { | |
| var v = d3.variance.apply(this, arguments); | |
| return v ? Math.sqrt(v) : v; | |
| }; | |
| function d3_bisector(compare) { | |
| return { | |
| left: function(a, x, lo, hi) { | |
| if (arguments.length < 3) lo = 0; | |
| if (arguments.length < 4) 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 (arguments.length < 3) lo = 0; | |
| if (arguments.length < 4) 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; | |
| } | |
| }; | |
| } | |
| var d3_bisect = d3_bisector(d3_ascending); | |
| d3.bisectLeft = d3_bisect.left; | |
| d3.bisect = d3.bisectRight = d3_bisect.right; | |
| d3.bisector = function(f) { | |
| return d3_bisector(f.length === 1 ? function(d, x) { | |
| return d3_ascending(f(d), x); | |
| } : f); | |
| }; | |
| d3.shuffle = function(array, i0, i1) { | |
| if ((m = arguments.length) < 3) { | |
| i1 = array.length; | |
| if (m < 2) i0 = 0; | |
| } | |
| var m = i1 - 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; | |
| }; | |
| d3.permute = function(array, indexes) { | |
| var i = indexes.length, permutes = new Array(i); | |
| while (i--) permutes[i] = array[indexes[i]]; | |
| return permutes; | |
| }; | |
| d3.pairs = function(array) { | |
| var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n); | |
| while (i < n) pairs[i] = [ p0 = p1, p1 = array[++i] ]; | |
| return pairs; | |
| }; | |
| d3.transpose = function(matrix) { | |
| if (!(n = matrix.length)) return []; | |
| for (var i = -1, m = d3.min(matrix, d3_transposeLength), 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 d3_transposeLength(d) { | |
| return d.length; | |
| } | |
| d3.zip = function() { | |
| return d3.transpose(arguments); | |
| }; | |
| d3.keys = function(map) { | |
| var keys = []; | |
| for (var key in map) keys.push(key); | |
| return keys; | |
| }; | |
| d3.values = function(map) { | |
| var values = []; | |
| for (var key in map) values.push(map[key]); | |
| return values; | |
| }; | |
| d3.entries = function(map) { | |
| var entries = []; | |
| for (var key in map) entries.push({ | |
| key: key, | |
| value: map[key] | |
| }); | |
| return entries; | |
| }; | |
| d3.merge = function(arrays) { | |
| var n = arrays.length, m, i = -1, j = 0, merged, array; | |
| while (++i < n) j += arrays[i].length; | |
| merged = new Array(j); | |
| while (--n >= 0) { | |
| array = arrays[n]; | |
| m = array.length; | |
| while (--m >= 0) { | |
| merged[--j] = array[m]; | |
| } | |
| } | |
| return merged; | |
| }; | |
| var abs = Math.abs; | |
| d3.range = function(start, stop, step) { | |
| if (arguments.length < 3) { | |
| step = 1; | |
| if (arguments.length < 2) { | |
| stop = start; | |
| start = 0; | |
| } | |
| } | |
| if ((stop - start) / step === Infinity) throw new Error("infinite range"); | |
| var range = [], k = d3_range_integerScale(abs(step)), i = -1, j; | |
| start *= k, stop *= k, step *= k; | |
| if (step < 0) while ((j = start + step * ++i) > stop) range.push(j / k); else while ((j = start + step * ++i) < stop) range.push(j / k); | |
| return range; | |
| }; | |
| function d3_range_integerScale(x) { | |
| var k = 1; | |
| while (x * k % 1) k *= 10; | |
| return k; | |
| } | |
| function d3_class(ctor, properties) { | |
| for (var key in properties) { | |
| Object.defineProperty(ctor.prototype, key, { | |
| value: properties[key], | |
| enumerable: false | |
| }); | |
| } | |
| } | |
| d3.map = function(object, f) { | |
| var map = new d3_Map(); | |
| if (object instanceof d3_Map) { | |
| object.forEach(function(key, value) { | |
| map.set(key, value); | |
| }); | |
| } else if (Array.isArray(object)) { | |
| var i = -1, n = object.length, o; | |
| if (arguments.length === 1) while (++i < n) map.set(i, object[i]); else while (++i < n) map.set(f.call(object, o = object[i], i), o); | |
| } else { | |
| for (var key in object) map.set(key, object[key]); | |
| } | |
| return map; | |
| }; | |
| function d3_Map() { | |
| this._ = Object.create(null); | |
| } | |
| var d3_map_proto = "__proto__", d3_map_zero = "\x00"; | |
| d3_class(d3_Map, { | |
| has: d3_map_has, | |
| get: function(key) { | |
| return this._[d3_map_escape(key)]; | |
| }, | |
| set: function(key, value) { | |
| return this._[d3_map_escape(key)] = value; | |
| }, | |
| remove: d3_map_remove, | |
| keys: d3_map_keys, | |
| values: function() { | |
| var values = []; | |
| for (var key in this._) values.push(this._[key]); | |
| return values; | |
| }, | |
| entries: function() { | |
| var entries = []; | |
| for (var key in this._) entries.push({ | |
| key: d3_map_unescape(key), | |
| value: this._[key] | |
| }); | |
| return entries; | |
| }, | |
| size: d3_map_size, | |
| empty: d3_map_empty, | |
| forEach: function(f) { | |
| for (var key in this._) f.call(this, d3_map_unescape(key), this._[key]); | |
| } | |
| }); | |
| function d3_map_escape(key) { | |
| return (key += "") === d3_map_proto || key[0] === d3_map_zero ? d3_map_zero + key : key; | |
| } | |
| function d3_map_unescape(key) { | |
| return (key += "")[0] === d3_map_zero ? key.slice(1) : key; | |
| } | |
| function d3_map_has(key) { | |
| return d3_map_escape(key) in this._; | |
| } | |
| function d3_map_remove(key) { | |
| return (key = d3_map_escape(key)) in this._ && delete this._[key]; | |
| } | |
| function d3_map_keys() { | |
| var keys = []; | |
| for (var key in this._) keys.push(d3_map_unescape(key)); | |
| return keys; | |
| } | |
| function d3_map_size() { | |
| var size = 0; | |
| for (var key in this._) ++size; | |
| return size; | |
| } | |
| function d3_map_empty() { | |
| for (var key in this._) return false; | |
| return true; | |
| } | |
| d3.nest = function() { | |
| var nest = {}, keys = [], sortKeys = [], sortValues, rollup; | |
| function map(mapType, array, depth) { | |
| if (depth >= keys.length) return rollup ? rollup.call(nest, array) : sortValues ? array.sort(sortValues) : array; | |
| var i = -1, n = array.length, key = keys[depth++], keyValue, object, setter, valuesByKey = new d3_Map(), values; | |
| while (++i < n) { | |
| if (values = valuesByKey.get(keyValue = key(object = array[i]))) { | |
| values.push(object); | |
| } else { | |
| valuesByKey.set(keyValue, [ object ]); | |
| } | |
| } | |
| if (mapType) { | |
| object = mapType(); | |
| setter = function(keyValue, values) { | |
| object.set(keyValue, map(mapType, values, depth)); | |
| }; | |
| } else { | |
| object = {}; | |
| setter = function(keyValue, values) { | |
| object[keyValue] = map(mapType, values, depth); | |
| }; | |
| } | |
| valuesByKey.forEach(setter); | |
| return object; | |
| } | |
| function entries(map, depth) { | |
| if (depth >= keys.length) return map; | |
| var array = [], sortKey = sortKeys[depth++]; | |
| map.forEach(function(key, keyMap) { | |
| array.push({ | |
| key: key, | |
| values: entries(keyMap, depth) | |
| }); | |
| }); | |
| return sortKey ? array.sort(function(a, b) { | |
| return sortKey(a.key, b.key); | |
| }) : array; | |
| } | |
| nest.map = function(array, mapType) { | |
| return map(mapType, array, 0); | |
| }; | |
| nest.entries = function(array) { | |
| return entries(map(d3.map, array, 0), 0); | |
| }; | |
| nest.key = function(d) { | |
| keys.push(d); | |
| return nest; | |
| }; | |
| nest.sortKeys = function(order) { | |
| sortKeys[keys.length - 1] = order; | |
| return nest; | |
| }; | |
| nest.sortValues = function(order) { | |
| sortValues = order; | |
| return nest; | |
| }; | |
| nest.rollup = function(f) { | |
| rollup = f; | |
| return nest; | |
| }; | |
| return nest; | |
| }; | |
| d3.set = function(array) { | |
| var set = new d3_Set(); | |
| if (array) for (var i = 0, n = array.length; i < n; ++i) set.add(array[i]); | |
| return set; | |
| }; | |
| function d3_Set() { | |
| this._ = Object.create(null); | |
| } | |
| d3_class(d3_Set, { | |
| has: d3_map_has, | |
| add: function(key) { | |
| this._[d3_map_escape(key += "")] = true; | |
| return key; | |
| }, | |
| remove: d3_map_remove, | |
| values: d3_map_keys, | |
| size: d3_map_size, | |
| empty: d3_map_empty, | |
| forEach: function(f) { | |
| for (var key in this._) f.call(this, d3_map_unescape(key)); | |
| } | |
| }); | |
| d3.behavior = {}; | |
| function d3_identity(d) { | |
| return d; | |
| } | |
| d3.rebind = function(target, source) { | |
| var i = 1, n = arguments.length, method; | |
| while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]); | |
| return target; | |
| }; | |
| function d3_rebind(target, source, method) { | |
| return function() { | |
| var value = method.apply(source, arguments); | |
| return value === source ? target : value; | |
| }; | |
| } | |
| function d3_vendorSymbol(object, name) { | |
| if (name in object) return name; | |
| name = name.charAt(0).toUpperCase() + name.slice(1); | |
| for (var i = 0, n = d3_vendorPrefixes.length; i < n; ++i) { | |
| var prefixName = d3_vendorPrefixes[i] + name; | |
| if (prefixName in object) return prefixName; | |
| } | |
| } | |
| var d3_vendorPrefixes = [ "webkit", "ms", "moz", "Moz", "o", "O" ]; | |
| function d3_noop() {} | |
| d3.dispatch = function() { | |
| var dispatch = new d3_dispatch(), i = -1, n = arguments.length; | |
| while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch); | |
| return dispatch; | |
| }; | |
| function d3_dispatch() {} | |
| d3_dispatch.prototype.on = function(type, listener) { | |
| var i = type.indexOf("."), name = ""; | |
| if (i >= 0) { | |
| name = type.slice(i + 1); | |
| type = type.slice(0, i); | |
| } | |
| if (type) return arguments.length < 2 ? this[type].on(name) : this[type].on(name, listener); | |
| if (arguments.length === 2) { | |
| if (listener == null) for (type in this) { | |
| if (this.hasOwnProperty(type)) this[type].on(name, null); | |
| } | |
| return this; | |
| } | |
| }; | |
| function d3_dispatch_event(dispatch) { | |
| var listeners = [], listenerByName = new d3_Map(); | |
| function event() { | |
| var z = listeners, i = -1, n = z.length, l; | |
| while (++i < n) if (l = z[i].on) l.apply(this, arguments); | |
| return dispatch; | |
| } | |
| event.on = function(name, listener) { | |
| var l = listenerByName.get(name), i; | |
| if (arguments.length < 2) return l && l.on; | |
| if (l) { | |
| l.on = null; | |
| listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1)); | |
| listenerByName.remove(name); | |
| } | |
| if (listener) listeners.push(listenerByName.set(name, { | |
| on: listener | |
| })); | |
| return dispatch; | |
| }; | |
| return event; | |
| } | |
| d3.event = null; | |
| function d3_eventPreventDefault() { | |
| d3.event.preventDefault(); | |
| } | |
| function d3_eventSource() { | |
| var e = d3.event, s; | |
| while (s = e.sourceEvent) e = s; | |
| return e; | |
| } | |
| function d3_eventDispatch(target) { | |
| var dispatch = new d3_dispatch(), i = 0, n = arguments.length; | |
| while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(dispatch); | |
| dispatch.of = function(thiz, argumentz) { | |
| return function(e1) { | |
| try { | |
| var e0 = e1.sourceEvent = d3.event; | |
| e1.target = target; | |
| d3.event = e1; | |
| dispatch[e1.type].apply(thiz, argumentz); | |
| } finally { | |
| d3.event = e0; | |
| } | |
| }; | |
| }; | |
| return dispatch; | |
| } | |
| d3.requote = function(s) { | |
| return s.replace(d3_requote_re, "\\$&"); | |
| }; | |
| var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g; | |
| var d3_subclass = {}.__proto__ ? function(object, prototype) { | |
| object.__proto__ = prototype; | |
| } : function(object, prototype) { | |
| for (var property in prototype) object[property] = prototype[property]; | |
| }; | |
| function d3_selection(groups) { | |
| d3_subclass(groups, d3_selectionPrototype); | |
| return groups; | |
| } | |
| var d3_select = function(s, n) { | |
| return n.querySelector(s); | |
| }, d3_selectAll = function(s, n) { | |
| return n.querySelectorAll(s); | |
| }, d3_selectMatches = function(n, s) { | |
| var d3_selectMatcher = n.matches || n[d3_vendorSymbol(n, "matchesSelector")]; | |
| d3_selectMatches = function(n, s) { | |
| return d3_selectMatcher.call(n, s); | |
| }; | |
| return d3_selectMatches(n, s); | |
| }; | |
| if (typeof Sizzle === "function") { | |
| d3_select = function(s, n) { | |
| return Sizzle(s, n)[0] || null; | |
| }; | |
| d3_selectAll = Sizzle; | |
| d3_selectMatches = Sizzle.matchesSelector; | |
| } | |
| d3.selection = function() { | |
| return d3.select(d3_document.documentElement); | |
| }; | |
| var d3_selectionPrototype = d3.selection.prototype = []; | |
| d3_selectionPrototype.select = function(selector) { | |
| var subgroups = [], subgroup, subnode, group, node; | |
| selector = d3_selection_selector(selector); | |
| for (var j = -1, m = this.length; ++j < m; ) { | |
| subgroups.push(subgroup = []); | |
| subgroup.parentNode = (group = this[j]).parentNode; | |
| for (var i = -1, n = group.length; ++i < n; ) { | |
| if (node = group[i]) { | |
| subgroup.push(subnode = selector.call(node, node.__data__, i, j)); | |
| if (subnode && "__data__" in node) subnode.__data__ = node.__data__; | |
| } else { | |
| subgroup.push(null); | |
| } | |
| } | |
| } | |
| return d3_selection(subgroups); | |
| }; | |
| function d3_selection_selector(selector) { | |
| return typeof selector === "function" ? selector : function() { | |
| return d3_select(selector, this); | |
| }; | |
| } | |
| d3_selectionPrototype.selectAll = function(selector) { | |
| var subgroups = [], subgroup, node; | |
| selector = d3_selection_selectorAll(selector); | |
| for (var j = -1, m = this.length; ++j < m; ) { | |
| for (var group = this[j], i = -1, n = group.length; ++i < n; ) { | |
| if (node = group[i]) { | |
| subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i, j))); | |
| subgroup.parentNode = node; | |
| } | |
| } | |
| } | |
| return d3_selection(subgroups); | |
| }; | |
| function d3_selection_selectorAll(selector) { | |
| return typeof selector === "function" ? selector : function() { | |
| return d3_selectAll(selector, this); | |
| }; | |
| } | |
| var d3_nsXhtml = "http://www.w3.org/1999/xhtml"; | |
| var d3_nsPrefix = { | |
| svg: "http://www.w3.org/2000/svg", | |
| xhtml: d3_nsXhtml, | |
| xlink: "http://www.w3.org/1999/xlink", | |
| xml: "http://www.w3.org/XML/1998/namespace", | |
| xmlns: "http://www.w3.org/2000/xmlns/" | |
| }; | |
| d3.ns = { | |
| prefix: d3_nsPrefix, | |
| qualify: function(name) { | |
| var i = name.indexOf(":"), prefix = name; | |
| if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1); | |
| return d3_nsPrefix.hasOwnProperty(prefix) ? { | |
| space: d3_nsPrefix[prefix], | |
| local: name | |
| } : name; | |
| } | |
| }; | |
| d3_selectionPrototype.attr = function(name, value) { | |
| if (arguments.length < 2) { | |
| if (typeof name === "string") { | |
| var node = this.node(); | |
| name = d3.ns.qualify(name); | |
| return name.local ? node.getAttributeNS(name.space, name.local) : node.getAttribute(name); | |
| } | |
| for (value in name) this.each(d3_selection_attr(value, name[value])); | |
| return this; | |
| } | |
| return this.each(d3_selection_attr(name, value)); | |
| }; | |
| function d3_selection_attr(name, value) { | |
| name = d3.ns.qualify(name); | |
| function attrNull() { | |
| this.removeAttribute(name); | |
| } | |
| function attrNullNS() { | |
| this.removeAttributeNS(name.space, name.local); | |
| } | |
| function attrConstant() { | |
| this.setAttribute(name, value); | |
| } | |
| function attrConstantNS() { | |
| this.setAttributeNS(name.space, name.local, value); | |
| } | |
| function attrFunction() { | |
| var x = value.apply(this, arguments); | |
| if (x == null) this.removeAttribute(name); else this.setAttribute(name, x); | |
| } | |
| function attrFunctionNS() { | |
| var x = value.apply(this, arguments); | |
| if (x == null) this.removeAttributeNS(name.space, name.local); else this.setAttributeNS(name.space, name.local, x); | |
| } | |
| return value == null ? name.local ? attrNullNS : attrNull : typeof value === "function" ? name.local ? attrFunctionNS : attrFunction : name.local ? attrConstantNS : attrConstant; | |
| } | |
| function d3_collapse(s) { | |
| return s.trim().replace(/\s+/g, " "); | |
| } | |
| d3_selectionPrototype.classed = function(name, value) { | |
| if (arguments.length < 2) { | |
| if (typeof name === "string") { | |
| var node = this.node(), n = (name = d3_selection_classes(name)).length, i = -1; | |
| if (value = node.classList) { | |
| while (++i < n) if (!value.contains(name[i])) return false; | |
| } else { | |
| value = node.getAttribute("class"); | |
| while (++i < n) if (!d3_selection_classedRe(name[i]).test(value)) return false; | |
| } | |
| return true; | |
| } | |
| for (value in name) this.each(d3_selection_classed(value, name[value])); | |
| return this; | |
| } | |
| return this.each(d3_selection_classed(name, value)); | |
| }; | |
| function d3_selection_classedRe(name) { | |
| return new RegExp("(?:^|\\s+)" + d3.requote(name) + "(?:\\s+|$)", "g"); | |
| } | |
| function d3_selection_classes(name) { | |
| return (name + "").trim().split(/^|\s+/); | |
| } | |
| function d3_selection_classed(name, value) { | |
| name = d3_selection_classes(name).map(d3_selection_classedName); | |
| var n = name.length; | |
| function classedConstant() { | |
| var i = -1; | |
| while (++i < n) name[i](this, value); | |
| } | |
| function classedFunction() { | |
| var i = -1, x = value.apply(this, arguments); | |
| while (++i < n) name[i](this, x); | |
| } | |
| return typeof value === "function" ? classedFunction : classedConstant; | |
| } | |
| function d3_selection_classedName(name) { | |
| var re = d3_selection_classedRe(name); | |
| return function(node, value) { | |
| if (c = node.classList) return value ? c.add(name) : c.remove(name); | |
| var c = node.getAttribute("class") || ""; | |
| if (value) { | |
| re.lastIndex = 0; | |
| if (!re.test(c)) node.setAttribute("class", d3_collapse(c + " " + name)); | |
| } else { | |
| node.setAttribute("class", d3_collapse(c.replace(re, " "))); | |
| } | |
| }; | |
| } | |
| d3_selectionPrototype.style = function(name, value, priority) { | |
| var n = arguments.length; | |
| if (n < 3) { | |
| if (typeof name !== "string") { | |
| if (n < 2) value = ""; | |
| for (priority in name) this.each(d3_selection_style(priority, name[priority], value)); | |
| return this; | |
| } | |
| if (n < 2) { | |
| var node = this.node(); | |
| return d3_window(node).getComputedStyle(node, null).getPropertyValue(name); | |
| } | |
| priority = ""; | |
| } | |
| return this.each(d3_selection_style(name, value, priority)); | |
| }; | |
| function d3_selection_style(name, value, priority) { | |
| function styleNull() { | |
| this.style.removeProperty(name); | |
| } | |
| function styleConstant() { | |
| this.style.setProperty(name, value, priority); | |
| } | |
| function styleFunction() { | |
| var x = value.apply(this, arguments); | |
| if (x == null) this.style.removeProperty(name); else this.style.setProperty(name, x, priority); | |
| } | |
| return value == null ? styleNull : typeof value === "function" ? styleFunction : styleConstant; | |
| } | |
| d3_selectionPrototype.property = function(name, value) { | |
| if (arguments.length < 2) { | |
| if (typeof name === "string") return this.node()[name]; | |
| for (value in name) this.each(d3_selection_property(value, name[value])); | |
| return this; | |
| } | |
| return this.each(d3_selection_property(name, value)); | |
| }; | |
| function d3_selection_property(name, value) { | |
| function propertyNull() { | |
| delete this[name]; | |
| } | |
| function propertyConstant() { | |
| this[name] = value; | |
| } | |
| function propertyFunction() { | |
| var x = value.apply(this, arguments); | |
| if (x == null) delete this[name]; else this[name] = x; | |
| } | |
| return value == null ? propertyNull : typeof value === "function" ? propertyFunction : propertyConstant; | |
| } | |
| d3_selectionPrototype.text = function(value) { | |
| return arguments.length ? this.each(typeof value === "function" ? function() { | |
| var v = value.apply(this, arguments); | |
| this.textContent = v == null ? "" : v; | |
| } : value == null ? function() { | |
| this.textContent = ""; | |
| } : function() { | |
| this.textContent = value; | |
| }) : this.node().textContent; | |
| }; | |
| d3_selectionPrototype.html = function(value) { | |
| return arguments.length ? this.each(typeof value === "function" ? function() { | |
| var v = value.apply(this, arguments); | |
| this.innerHTML = v == null ? "" : v; | |
| } : value == null ? function() { | |
| this.innerHTML = ""; | |
| } : function() { | |
| this.innerHTML = value; | |
| }) : this.node().innerHTML; | |
| }; | |
| d3_selectionPrototype.append = function(name) { | |
| name = d3_selection_creator(name); | |
| return this.select(function() { | |
| return this.appendChild(name.apply(this, arguments)); | |
| }); | |
| }; | |
| function d3_selection_creator(name) { | |
| function create() { | |
| var document = this.ownerDocument, namespace = this.namespaceURI; | |
| return namespace === d3_nsXhtml && document.documentElement.namespaceURI === d3_nsXhtml ? document.createElement(name) : document.createElementNS(namespace, name); | |
| } | |
| function createNS() { | |
| return this.ownerDocument.createElementNS(name.space, name.local); | |
| } | |
| return typeof name === "function" ? name : (name = d3.ns.qualify(name)).local ? createNS : create; | |
| } | |
| d3_selectionPrototype.insert = function(name, before) { | |
| name = d3_selection_creator(name); | |
| before = d3_selection_selector(before); | |
| return this.select(function() { | |
| return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments) || null); | |
| }); | |
| }; | |
| d3_selectionPrototype.remove = function() { | |
| return this.each(d3_selectionRemove); | |
| }; | |
| function d3_selectionRemove() { | |
| var parent = this.parentNode; | |
| if (parent) parent.removeChild(this); | |
| } | |
| d3_selectionPrototype.data = function(value, key) { | |
| var i = -1, n = this.length, group, node; | |
| if (!arguments.length) { | |
| value = new Array(n = (group = this[0]).length); | |
| while (++i < n) { | |
| if (node = group[i]) { | |
| value[i] = node.__data__; | |
| } | |
| } | |
| return value; | |
| } | |
| function bind(group, groupData) { | |
| var i, n = group.length, m = groupData.length, n0 = Math.min(n, m), updateNodes = new Array(m), enterNodes = new Array(m), exitNodes = new Array(n), node, nodeData; | |
| if (key) { | |
| var nodeByKeyValue = new d3_Map(), keyValues = new Array(n), keyValue; | |
| for (i = -1; ++i < n; ) { | |
| if (node = group[i]) { | |
| if (nodeByKeyValue.has(keyValue = key.call(node, node.__data__, i))) { | |
| exitNodes[i] = node; | |
| } else { | |
| nodeByKeyValue.set(keyValue, node); | |
| } | |
| keyValues[i] = keyValue; | |
| } | |
| } | |
| for (i = -1; ++i < m; ) { | |
| if (!(node = nodeByKeyValue.get(keyValue = key.call(groupData, nodeData = groupData[i], i)))) { | |
| enterNodes[i] = d3_selection_dataNode(nodeData); | |
| } else if (node !== true) { | |
| updateNodes[i] = node; | |
| node.__data__ = nodeData; | |
| } | |
| nodeByKeyValue.set(keyValue, true); | |
| } | |
| for (i = -1; ++i < n; ) { | |
| if (i in keyValues && nodeByKeyValue.get(keyValues[i]) !== true) { | |
| exitNodes[i] = group[i]; | |
| } | |
| } | |
| } else { | |
| for (i = -1; ++i < n0; ) { | |
| node = group[i]; | |
| nodeData = groupData[i]; | |
| if (node) { | |
| node.__data__ = nodeData; | |
| updateNodes[i] = node; | |
| } else { | |
| enterNodes[i] = d3_selection_dataNode(nodeData); | |
| } | |
| } | |
| for (;i < m; ++i) { | |
| enterNodes[i] = d3_selection_dataNode(groupData[i]); | |
| } | |
| for (;i < n; ++i) { | |
| exitNodes[i] = group[i]; | |
| } | |
| } | |
| enterNodes.update = updateNodes; | |
| enterNodes.parentNode = updateNodes.parentNode = exitNodes.parentNode = group.parentNode; | |
| enter.push(enterNodes); | |
| update.push(updateNodes); | |
| exit.push(exitNodes); | |
| } | |
| var enter = d3_selection_enter([]), update = d3_selection([]), exit = d3_selection([]); | |
| if (typeof value === "function") { | |
| while (++i < n) { | |
| bind(group = this[i], value.call(group, group.parentNode.__data__, i)); | |
| } | |
| } else { | |
| while (++i < n) { | |
| bind(group = this[i], value); | |
| } | |
| } | |
| update.enter = function() { | |
| return enter; | |
| }; | |
| update.exit = function() { | |
| return exit; | |
| }; | |
| return update; | |
| }; | |
| function d3_selection_dataNode(data) { | |
| return { | |
| __data__: data | |
| }; | |
| } | |
| d3_selectionPrototype.datum = function(value) { | |
| return arguments.length ? this.property("__data__", value) : this.property("__data__"); | |
| }; | |
| d3_selectionPrototype.filter = function(filter) { | |
| var subgroups = [], subgroup, group, node; | |
| if (typeof filter !== "function") filter = d3_selection_filter(filter); | |
| for (var j = 0, m = this.length; j < m; j++) { | |
| subgroups.push(subgroup = []); | |
| subgroup.parentNode = (group = this[j]).parentNode; | |
| for (var i = 0, n = group.length; i < n; i++) { | |
| if ((node = group[i]) && filter.call(node, node.__data__, i, j)) { | |
| subgroup.push(node); | |
| } | |
| } | |
| } | |
| return d3_selection(subgroups); | |
| }; | |
| function d3_selection_filter(selector) { | |
| return function() { | |
| return d3_selectMatches(this, selector); | |
| }; | |
| } | |
| d3_selectionPrototype.order = function() { | |
| for (var j = -1, m = this.length; ++j < m; ) { | |
| for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0; ) { | |
| if (node = group[i]) { | |
| if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next); | |
| next = node; | |
| } | |
| } | |
| } | |
| return this; | |
| }; | |
| d3_selectionPrototype.sort = function(comparator) { | |
| comparator = d3_selection_sortComparator.apply(this, arguments); | |
| for (var j = -1, m = this.length; ++j < m; ) this[j].sort(comparator); | |
| return this.order(); | |
| }; | |
| function d3_selection_sortComparator(comparator) { | |
| if (!arguments.length) comparator = d3_ascending; | |
| return function(a, b) { | |
| return a && b ? comparator(a.__data__, b.__data__) : !a - !b; | |
| }; | |
| } | |
| d3_selectionPrototype.each = function(callback) { | |
| return d3_selection_each(this, function(node, i, j) { | |
| callback.call(node, node.__data__, i, j); | |
| }); | |
| }; | |
| function d3_selection_each(groups, callback) { | |
| for (var j = 0, m = groups.length; j < m; j++) { | |
| for (var group = groups[j], i = 0, n = group.length, node; i < n; i++) { | |
| if (node = group[i]) callback(node, i, j); | |
| } | |
| } | |
| return groups; | |
| } | |
| d3_selectionPrototype.call = function(callback) { | |
| var args = d3_array(arguments); | |
| callback.apply(args[0] = this, args); | |
| return this; | |
| }; | |
| d3_selectionPrototype.empty = function() { | |
| return !this.node(); | |
| }; | |
| d3_selectionPrototype.node = function() { | |
| for (var j = 0, m = this.length; j < m; j++) { | |
| for (var group = this[j], i = 0, n = group.length; i < n; i++) { | |
| var node = group[i]; | |
| if (node) return node; | |
| } | |
| } | |
| return null; | |
| }; | |
| d3_selectionPrototype.size = function() { | |
| var n = 0; | |
| d3_selection_each(this, function() { | |
| ++n; | |
| }); | |
| return n; | |
| }; | |
| function d3_selection_enter(selection) { | |
| d3_subclass(selection, d3_selection_enterPrototype); | |
| return selection; | |
| } | |
| var d3_selection_enterPrototype = []; | |
| d3.selection.enter = d3_selection_enter; | |
| d3.selection.enter.prototype = d3_selection_enterPrototype; | |
| d3_selection_enterPrototype.append = d3_selectionPrototype.append; | |
| d3_selection_enterPrototype.empty = d3_selectionPrototype.empty; | |
| d3_selection_enterPrototype.node = d3_selectionPrototype.node; | |
| d3_selection_enterPrototype.call = d3_selectionPrototype.call; | |
| d3_selection_enterPrototype.size = d3_selectionPrototype.size; | |
| d3_selection_enterPrototype.select = function(selector) { | |
| var subgroups = [], subgroup, subnode, upgroup, group, node; | |
| for (var j = -1, m = this.length; ++j < m; ) { | |
| upgroup = (group = this[j]).update; | |
| subgroups.push(subgroup = []); | |
| subgroup.parentNode = group.parentNode; | |
| for (var i = -1, n = group.length; ++i < n; ) { | |
| if (node = group[i]) { | |
| subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i, j)); | |
| subnode.__data__ = node.__data__; | |
| } else { | |
| subgroup.push(null); | |
| } | |
| } | |
| } | |
| return d3_selection(subgroups); | |
| }; | |
| d3_selection_enterPrototype.insert = function(name, before) { | |
| if (arguments.length < 2) before = d3_selection_enterInsertBefore(this); | |
| return d3_selectionPrototype.insert.call(this, name, before); | |
| }; | |
| function d3_selection_enterInsertBefore(enter) { | |
| var i0, j0; | |
| return function(d, i, j) { | |
| var group = enter[j].update, n = group.length, node; | |
| if (j != j0) j0 = j, i0 = 0; | |
| if (i >= i0) i0 = i + 1; | |
| while (!(node = group[i0]) && ++i0 < n) ; | |
| return node; | |
| }; | |
| } | |
| d3.select = function(node) { | |
| var group; | |
| if (typeof node === "string") { | |
| group = [ d3_select(node, d3_document) ]; | |
| group.parentNode = d3_document.documentElement; | |
| } else { | |
| group = [ node ]; | |
| group.parentNode = d3_documentElement(node); | |
| } | |
| return d3_selection([ group ]); | |
| }; | |
| d3.selectAll = function(nodes) { | |
| var group; | |
| if (typeof nodes === "string") { | |
| group = d3_array(d3_selectAll(nodes, d3_document)); | |
| group.parentNode = d3_document.documentElement; | |
| } else { | |
| group = d3_array(nodes); | |
| group.parentNode = null; | |
| } | |
| return d3_selection([ group ]); | |
| }; | |
| d3_selectionPrototype.on = function(type, listener, capture) { | |
| var n = arguments.length; | |
| if (n < 3) { | |
| if (typeof type !== "string") { | |
| if (n < 2) listener = false; | |
| for (capture in type) this.each(d3_selection_on(capture, type[capture], listener)); | |
| return this; | |
| } | |
| if (n < 2) return (n = this.node()["__on" + type]) && n._; | |
| capture = false; | |
| } | |
| return this.each(d3_selection_on(type, listener, capture)); | |
| }; | |
| function d3_selection_on(type, listener, capture) { | |
| var name = "__on" + type, i = type.indexOf("."), wrap = d3_selection_onListener; | |
| if (i > 0) type = type.slice(0, i); | |
| var filter = d3_selection_onFilters.get(type); | |
| if (filter) type = filter, wrap = d3_selection_onFilter; | |
| function onRemove() { | |
| var l = this[name]; | |
| if (l) { | |
| this.removeEventListener(type, l, l.$); | |
| delete this[name]; | |
| } | |
| } | |
| function onAdd() { | |
| var l = wrap(listener, d3_array(arguments)); | |
| onRemove.call(this); | |
| this.addEventListener(type, this[name] = l, l.$ = capture); | |
| l._ = listener; | |
| } | |
| function removeAll() { | |
| var re = new RegExp("^__on([^.]+)" + d3.requote(type) + "$"), match; | |
| for (var name in this) { | |
| if (match = name.match(re)) { | |
| var l = this[name]; | |
| this.removeEventListener(match[1], l, l.$); | |
| delete this[name]; | |
| } | |
| } | |
| } | |
| return i ? listener ? onAdd : onRemove : listener ? d3_noop : removeAll; | |
| } | |
| var d3_selection_onFilters = d3.map({ | |
| mouseenter: "mouseover", | |
| mouseleave: "mouseout" | |
| }); | |
| if (d3_document) { | |
| d3_selection_onFilters.forEach(function(k) { | |
| if ("on" + k in d3_document) d3_selection_onFilters.remove(k); | |
| }); | |
| } | |
| function d3_selection_onListener(listener, argumentz) { | |
| return function(e) { | |
| var o = d3.event; | |
| d3.event = e; | |
| argumentz[0] = this.__data__; | |
| try { | |
| listener.apply(this, argumentz); | |
| } finally { | |
| d3.event = o; | |
| } | |
| }; | |
| } | |
| function d3_selection_onFilter(listener, argumentz) { | |
| var l = d3_selection_onListener(listener, argumentz); | |
| return function(e) { | |
| var target = this, related = e.relatedTarget; | |
| if (!related || related !== target && !(related.compareDocumentPosition(target) & 8)) { | |
| l.call(target, e); | |
| } | |
| }; | |
| } | |
| var d3_event_dragSelect, d3_event_dragId = 0; | |
| function d3_event_dragSuppress(node) { | |
| var name = ".dragsuppress-" + ++d3_event_dragId, click = "click" + name, w = d3.select(d3_window(node)).on("touchmove" + name, d3_eventPreventDefault).on("dragstart" + name, d3_eventPreventDefault).on("selectstart" + name, d3_eventPreventDefault); | |
| if (d3_event_dragSelect == null) { | |
| d3_event_dragSelect = "onselectstart" in node ? false : d3_vendorSymbol(node.style, "userSelect"); | |
| } | |
| if (d3_event_dragSelect) { | |
| var style = d3_documentElement(node).style, select = style[d3_event_dragSelect]; | |
| style[d3_event_dragSelect] = "none"; | |
| } | |
| return function(suppressClick) { | |
| w.on(name, null); | |
| if (d3_event_dragSelect) style[d3_event_dragSelect] = select; | |
| if (suppressClick) { | |
| var off = function() { | |
| w.on(click, null); | |
| }; | |
| w.on(click, function() { | |
| d3_eventPreventDefault(); | |
| off(); | |
| }, true); | |
| setTimeout(off, 0); | |
| } | |
| }; | |
| } | |
| d3.mouse = function(container) { | |
| return d3_mousePoint(container, d3_eventSource()); | |
| }; | |
| var d3_mouse_bug44083 = this.navigator && /WebKit/.test(this.navigator.userAgent) ? -1 : 0; | |
| function d3_mousePoint(container, e) { | |
| if (e.changedTouches) e = e.changedTouches[0]; | |
| var svg = container.ownerSVGElement || container; | |
| if (svg.createSVGPoint) { | |
| var point = svg.createSVGPoint(); | |
| if (d3_mouse_bug44083 < 0) { | |
| var window = d3_window(container); | |
| if (window.scrollX || window.scrollY) { | |
| svg = d3.select("body").append("svg").style({ | |
| position: "absolute", | |
| top: 0, | |
| left: 0, | |
| margin: 0, | |
| padding: 0, | |
| border: "none" | |
| }, "important"); | |
| var ctm = svg[0][0].getScreenCTM(); | |
| d3_mouse_bug44083 = !(ctm.f || ctm.e); | |
| svg.remove(); | |
| } | |
| } | |
| if (d3_mouse_bug44083) point.x = e.pageX, point.y = e.pageY; else point.x = e.clientX, | |
| point.y = e.clientY; | |
| point = point.matrixTransform(container.getScreenCTM().inverse()); | |
| return [ point.x, point.y ]; | |
| } | |
| var rect = container.getBoundingClientRect(); | |
| return [ e.clientX - rect.left - container.clientLeft, e.clientY - rect.top - container.clientTop ]; | |
| } | |
| d3.touch = function(container, touches, identifier) { | |
| if (arguments.length < 3) identifier = touches, touches = d3_eventSource().changedTouches; | |
| if (touches) for (var i = 0, n = touches.length, touch; i < n; ++i) { | |
| if ((touch = touches[i]).identifier === identifier) { | |
| return d3_mousePoint(container, touch); | |
| } | |
| } | |
| }; | |
| d3.behavior.drag = function() { | |
| var event = d3_eventDispatch(drag, "drag", "dragstart", "dragend"), origin = null, mousedown = dragstart(d3_noop, d3.mouse, d3_window, "mousemove", "mouseup"), touchstart = dragstart(d3_behavior_dragTouchId, d3.touch, d3_identity, "touchmove", "touchend"); | |
| function drag() { | |
| this.on("mousedown.drag", mousedown).on("touchstart.drag", touchstart); | |
| } | |
| function dragstart(id, position, subject, move, end) { | |
| return function() { | |
| var that = this, target = d3.event.target.correspondingElement || d3.event.target, parent = that.parentNode, dispatch = event.of(that, arguments), dragged = 0, dragId = id(), dragName = ".drag" + (dragId == null ? "" : "-" + dragId), dragOffset, dragSubject = d3.select(subject(target)).on(move + dragName, moved).on(end + dragName, ended), dragRestore = d3_event_dragSuppress(target), position0 = position(parent, dragId); | |
| if (origin) { | |
| dragOffset = origin.apply(that, arguments); | |
| dragOffset = [ dragOffset.x - position0[0], dragOffset.y - position0[1] ]; | |
| } else { | |
| dragOffset = [ 0, 0 ]; | |
| } | |
| dispatch({ | |
| type: "dragstart" | |
| }); | |
| function moved() { | |
| var position1 = position(parent, dragId), dx, dy; | |
| if (!position1) return; | |
| dx = position1[0] - position0[0]; | |
| dy = position1[1] - position0[1]; | |
| dragged |= dx | dy; | |
| position0 = position1; | |
| dispatch({ | |
| type: "drag", | |
| x: position1[0] + dragOffset[0], | |
| y: position1[1] + dragOffset[1], | |
| dx: dx, | |
| dy: dy | |
| }); | |
| } | |
| function ended() { | |
| if (!position(parent, dragId)) return; | |
| dragSubject.on(move + dragName, null).on(end + dragName, null); | |
| dragRestore(dragged); | |
| dispatch({ | |
| type: "dragend" | |
| }); | |
| } | |
| }; | |
| } | |
| drag.origin = function(x) { | |
| if (!arguments.length) return origin; | |
| origin = x; | |
| return drag; | |
| }; | |
| return d3.rebind(drag, event, "on"); | |
| }; | |
| function d3_behavior_dragTouchId() { | |
| return d3.event.changedTouches[0].identifier; | |
| } | |
| d3.touches = function(container, touches) { | |
| if (arguments.length < 2) touches = d3_eventSource().touches; | |
| return touches ? d3_array(touches).map(function(touch) { | |
| var point = d3_mousePoint(container, touch); | |
| point.identifier = touch.identifier; | |
| return point; | |
| }) : []; | |
| }; | |
| var ε = 1e-6, ε2 = ε * ε, π = Math.PI, τ = 2 * π, τε = τ - ε, halfπ = π / 2, d3_radians = π / 180, d3_degrees = 180 / π; | |
| function d3_sgn(x) { | |
| return x > 0 ? 1 : x < 0 ? -1 : 0; | |
| } | |
| function d3_cross2d(a, b, c) { | |
| return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]); | |
| } | |
| function d3_acos(x) { | |
| return x > 1 ? 0 : x < -1 ? π : Math.acos(x); | |
| } | |
| function d3_asin(x) { | |
| return x > 1 ? halfπ : x < -1 ? -halfπ : Math.asin(x); | |
| } | |
| function d3_sinh(x) { | |
| return ((x = Math.exp(x)) - 1 / x) / 2; | |
| } | |
| function d3_cosh(x) { | |
| return ((x = Math.exp(x)) + 1 / x) / 2; | |
| } | |
| function d3_tanh(x) { | |
| return ((x = Math.exp(2 * x)) - 1) / (x + 1); | |
| } | |
| function d3_haversin(x) { | |
| return (x = Math.sin(x / 2)) * x; | |
| } | |
| var ρ = Math.SQRT2, ρ2 = 2, ρ4 = 4; | |
| d3.interpolateZoom = function(p0, p1) { | |
| var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], ux1 = p1[0], uy1 = p1[1], w1 = p1[2], dx = ux1 - ux0, dy = uy1 - uy0, d2 = dx * dx + dy * dy, i, S; | |
| if (d2 < ε2) { | |
| S = Math.log(w1 / w0) / ρ; | |
| i = function(t) { | |
| return [ ux0 + t * dx, uy0 + t * dy, w0 * Math.exp(ρ * t * S) ]; | |
| }; | |
| } else { | |
| var d1 = Math.sqrt(d2), b0 = (w1 * w1 - w0 * w0 + ρ4 * d2) / (2 * w0 * ρ2 * d1), b1 = (w1 * w1 - w0 * w0 - ρ4 * d2) / (2 * w1 * ρ2 * d1), r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1); | |
| S = (r1 - r0) / ρ; | |
| i = function(t) { | |
| var s = t * S, coshr0 = d3_cosh(r0), u = w0 / (ρ2 * d1) * (coshr0 * d3_tanh(ρ * s + r0) - d3_sinh(r0)); | |
| return [ ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / d3_cosh(ρ * s + r0) ]; | |
| }; | |
| } | |
| i.duration = S * 1e3; | |
| return i; | |
| }; | |
| d3.behavior.zoom = function() { | |
| var view = { | |
| x: 0, | |
| y: 0, | |
| k: 1 | |
| }, translate0, center0, center, size = [ 960, 500 ], scaleExtent = d3_behavior_zoomInfinity, duration = 250, zooming = 0, mousedown = "mousedown.zoom", mousemove = "mousemove.zoom", mouseup = "mouseup.zoom", mousewheelTimer, touchstart = "touchstart.zoom", touchtime, event = d3_eventDispatch(zoom, "zoomstart", "zoom", "zoomend"), x0, x1, y0, y1; | |
| if (!d3_behavior_zoomWheel) { | |
| d3_behavior_zoomWheel = "onwheel" in d3_document ? (d3_behavior_zoomDelta = function() { | |
| return -d3.event.deltaY * (d3.event.deltaMode ? 120 : 1); | |
| }, "wheel") : "onmousewheel" in d3_document ? (d3_behavior_zoomDelta = function() { | |
| return d3.event.wheelDelta; | |
| }, "mousewheel") : (d3_behavior_zoomDelta = function() { | |
| return -d3.event.detail; | |
| }, "MozMousePixelScroll"); | |
| } | |
| function zoom(g) { | |
| g.on(mousedown, mousedowned).on(d3_behavior_zoomWheel + ".zoom", mousewheeled).on("dblclick.zoom", dblclicked).on(touchstart, touchstarted); | |
| } | |
| zoom.event = function(g) { | |
| g.each(function() { | |
| var dispatch = event.of(this, arguments), view1 = view; | |
| if (d3_transitionInheritId) { | |
| d3.select(this).transition().each("start.zoom", function() { | |
| view = this.__chart__ || { | |
| x: 0, | |
| y: 0, | |
| k: 1 | |
| }; | |
| zoomstarted(dispatch); | |
| }).tween("zoom:zoom", function() { | |
| var dx = size[0], dy = size[1], cx = center0 ? center0[0] : dx / 2, cy = center0 ? center0[1] : dy / 2, i = d3.interpolateZoom([ (cx - view.x) / view.k, (cy - view.y) / view.k, dx / view.k ], [ (cx - view1.x) / view1.k, (cy - view1.y) / view1.k, dx / view1.k ]); | |
| return function(t) { | |
| var l = i(t), k = dx / l[2]; | |
| this.__chart__ = view = { | |
| x: cx - l[0] * k, | |
| y: cy - l[1] * k, | |
| k: k | |
| }; | |
| zoomed(dispatch); | |
| }; | |
| }).each("interrupt.zoom", function() { | |
| zoomended(dispatch); | |
| }).each("end.zoom", function() { | |
| zoomended(dispatch); | |
| }); | |
| } else { | |
| this.__chart__ = view; | |
| zoomstarted(dispatch); | |
| zoomed(dispatch); | |
| zoomended(dispatch); | |
| } | |
| }); | |
| }; | |
| zoom.translate = function(_) { | |
| if (!arguments.length) return [ view.x, view.y ]; | |
| view = { | |
| x: +_[0], | |
| y: +_[1], | |
| k: view.k | |
| }; | |
| rescale(); | |
| return zoom; | |
| }; | |
| zoom.scale = function(_) { | |
| if (!arguments.length) return view.k; | |
| view = { | |
| x: view.x, | |
| y: view.y, | |
| k: null | |
| }; | |
| scaleTo(+_); | |
| rescale(); | |
| return zoom; | |
| }; | |
| zoom.scaleExtent = function(_) { | |
| if (!arguments.length) return scaleExtent; | |
| scaleExtent = _ == null ? d3_behavior_zoomInfinity : [ +_[0], +_[1] ]; | |
| return zoom; | |
| }; | |
| zoom.center = function(_) { | |
| if (!arguments.length) return center; | |
| center = _ && [ +_[0], +_[1] ]; | |
| return zoom; | |
| }; | |
| zoom.size = function(_) { | |
| if (!arguments.length) return size; | |
| size = _ && [ +_[0], +_[1] ]; | |
| return zoom; | |
| }; | |
| zoom.duration = function(_) { | |
| if (!arguments.length) return duration; | |
| duration = +_; | |
| return zoom; | |
| }; | |
| zoom.x = function(z) { | |
| if (!arguments.length) return x1; | |
| x1 = z; | |
| x0 = z.copy(); | |
| view = { | |
| x: 0, | |
| y: 0, | |
| k: 1 | |
| }; | |
| return zoom; | |
| }; | |
| zoom.y = function(z) { | |
| if (!arguments.length) return y1; | |
| y1 = z; | |
| y0 = z.copy(); | |
| view = { | |
| x: 0, | |
| y: 0, | |
| k: 1 | |
| }; | |
| return zoom; | |
| }; | |
| function location(p) { | |
| return [ (p[0] - view.x) / view.k, (p[1] - view.y) / view.k ]; | |
| } | |
| function point(l) { | |
| return [ l[0] * view.k + view.x, l[1] * view.k + view.y ]; | |
| } | |
| function scaleTo(s) { | |
| view.k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s)); | |
| } | |
| function translateTo(p, l) { | |
| l = point(l); | |
| view.x += p[0] - l[0]; | |
| view.y += p[1] - l[1]; | |
| } | |
| function zoomTo(that, p, l, k) { | |
| that.__chart__ = { | |
| x: view.x, | |
| y: view.y, | |
| k: view.k | |
| }; | |
| scaleTo(Math.pow(2, k)); | |
| translateTo(center0 = p, l); | |
| that = d3.select(that); | |
| if (duration > 0) that = that.transition().duration(duration); | |
| that.call(zoom.event); | |
| } | |
| function rescale() { | |
| if (x1) x1.domain(x0.range().map(function(x) { | |
| return (x - view.x) / view.k; | |
| }).map(x0.invert)); | |
| if (y1) y1.domain(y0.range().map(function(y) { | |
| return (y - view.y) / view.k; | |
| }).map(y0.invert)); | |
| } | |
| function zoomstarted(dispatch) { | |
| if (!zooming++) dispatch({ | |
| type: "zoomstart" | |
| }); | |
| } | |
| function zoomed(dispatch) { | |
| rescale(); | |
| dispatch({ | |
| type: "zoom", | |
| scale: view.k, | |
| translate: [ view.x, view.y ] | |
| }); | |
| } | |
| function zoomended(dispatch) { | |
| if (!--zooming) dispatch({ | |
| type: "zoomend" | |
| }), center0 = null; | |
| } | |
| function mousedowned() { | |
| var that = this, dispatch = event.of(that, arguments), dragged = 0, subject = d3.select(d3_window(that)).on(mousemove, moved).on(mouseup, ended), location0 = location(d3.mouse(that)), dragRestore = d3_event_dragSuppress(that); | |
| d3_selection_interrupt.call(that); | |
| zoomstarted(dispatch); | |
| function moved() { | |
| dragged = 1; | |
| translateTo(d3.mouse(that), location0); | |
| zoomed(dispatch); | |
| } | |
| function ended() { | |
| subject.on(mousemove, null).on(mouseup, null); | |
| dragRestore(dragged); | |
| zoomended(dispatch); | |
| } | |
| } | |
| function touchstarted() { | |
| var that = this, dispatch = event.of(that, arguments), locations0 = {}, distance0 = 0, scale0, zoomName = ".zoom-" + d3.event.changedTouches[0].identifier, touchmove = "touchmove" + zoomName, touchend = "touchend" + zoomName, targets = [], subject = d3.select(that), dragRestore = d3_event_dragSuppress(that); | |
| started(); | |
| zoomstarted(dispatch); | |
| subject.on(mousedown, null).on(touchstart, started); | |
| function relocate() { | |
| var touches = d3.touches(that); | |
| scale0 = view.k; | |
| touches.forEach(function(t) { | |
| if (t.identifier in locations0) locations0[t.identifier] = location(t); | |
| }); | |
| return touches; | |
| } | |
| function started() { | |
| var target = d3.event.target; | |
| d3.select(target).on(touchmove, moved).on(touchend, ended); | |
| targets.push(target); | |
| var changed = d3.event.changedTouches; | |
| for (var i = 0, n = changed.length; i < n; ++i) { | |
| locations0[changed[i].identifier] = null; | |
| } | |
| var touches = relocate(), now = Date.now(); | |
| if (touches.length === 1) { | |
| if (now - touchtime < 500) { | |
| var p = touches[0]; | |
| zoomTo(that, p, locations0[p.identifier], Math.floor(Math.log(view.k) / Math.LN2) + 1); | |
| d3_eventPreventDefault(); | |
| } | |
| touchtime = now; | |
| } else if (touches.length > 1) { | |
| var p = touches[0], q = touches[1], dx = p[0] - q[0], dy = p[1] - q[1]; | |
| distance0 = dx * dx + dy * dy; | |
| } | |
| } | |
| function moved() { | |
| var touches = d3.touches(that), p0, l0, p1, l1; | |
| d3_selection_interrupt.call(that); | |
| for (var i = 0, n = touches.length; i < n; ++i, l1 = null) { | |
| p1 = touches[i]; | |
| if (l1 = locations0[p1.identifier]) { | |
| if (l0) break; | |
| p0 = p1, l0 = l1; | |
| } | |
| } | |
| if (l1) { | |
| var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1, scale1 = distance0 && Math.sqrt(distance1 / distance0); | |
| p0 = [ (p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2 ]; | |
| l0 = [ (l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2 ]; | |
| scaleTo(scale1 * scale0); | |
| } | |
| touchtime = null; | |
| translateTo(p0, l0); | |
| zoomed(dispatch); | |
| } | |
| function ended() { | |
| if (d3.event.touches.length) { | |
| var changed = d3.event.changedTouches; | |
| for (var i = 0, n = changed.length; i < n; ++i) { | |
| delete locations0[changed[i].identifier]; | |
| } | |
| for (var identifier in locations0) { | |
| return void relocate(); | |
| } | |
| } | |
| d3.selectAll(targets).on(zoomName, null); | |
| subject.on(mousedown, mousedowned).on(touchstart, touchstarted); | |
| dragRestore(); | |
| zoomended(dispatch); | |
| } | |
| } | |
| function mousewheeled() { | |
| var dispatch = event.of(this, arguments); | |
| if (mousewheelTimer) clearTimeout(mousewheelTimer); else d3_selection_interrupt.call(this), | |
| translate0 = location(center0 = center || d3.mouse(this)), zoomstarted(dispatch); | |
| mousewheelTimer = setTimeout(function() { | |
| mousewheelTimer = null; | |
| zoomended(dispatch); | |
| }, 50); | |
| d3_eventPreventDefault(); | |
| scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * view.k); | |
| translateTo(center0, translate0); | |
| zoomed(dispatch); | |
| } | |
| function dblclicked() { | |
| var p = d3.mouse(this), k = Math.log(view.k) / Math.LN2; | |
| zoomTo(this, p, location(p), d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1); | |
| } | |
| return d3.rebind(zoom, event, "on"); | |
| }; | |
| var d3_behavior_zoomInfinity = [ 0, Infinity ], d3_behavior_zoomDelta, d3_behavior_zoomWheel; | |
| d3.color = d3_color; | |
| function d3_color() {} | |
| d3_color.prototype.toString = function() { | |
| return this.rgb() + ""; | |
| }; | |
| d3.hsl = d3_hsl; | |
| function d3_hsl(h, s, l) { | |
| return this instanceof d3_hsl ? void (this.h = +h, this.s = +s, this.l = +l) : arguments.length < 2 ? h instanceof d3_hsl ? new d3_hsl(h.h, h.s, h.l) : d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl) : new d3_hsl(h, s, l); | |
| } | |
| var d3_hslPrototype = d3_hsl.prototype = new d3_color(); | |
| d3_hslPrototype.brighter = function(k) { | |
| k = Math.pow(.7, arguments.length ? k : 1); | |
| return new d3_hsl(this.h, this.s, this.l / k); | |
| }; | |
| d3_hslPrototype.darker = function(k) { | |
| k = Math.pow(.7, arguments.length ? k : 1); | |
| return new d3_hsl(this.h, this.s, k * this.l); | |
| }; | |
| d3_hslPrototype.rgb = function() { | |
| return d3_hsl_rgb(this.h, this.s, this.l); | |
| }; | |
| function d3_hsl_rgb(h, s, l) { | |
| var m1, m2; | |
| h = isNaN(h) ? 0 : (h %= 360) < 0 ? h + 360 : h; | |
| s = isNaN(s) ? 0 : s < 0 ? 0 : s > 1 ? 1 : s; | |
| l = l < 0 ? 0 : l > 1 ? 1 : l; | |
| m2 = l <= .5 ? l * (1 + s) : l + s - l * s; | |
| m1 = 2 * l - m2; | |
| function v(h) { | |
| if (h > 360) h -= 360; else if (h < 0) h += 360; | |
| if (h < 60) return m1 + (m2 - m1) * h / 60; | |
| if (h < 180) return m2; | |
| if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60; | |
| return m1; | |
| } | |
| function vv(h) { | |
| return Math.round(v(h) * 255); | |
| } | |
| return new d3_rgb(vv(h + 120), vv(h), vv(h - 120)); | |
| } | |
| d3.hcl = d3_hcl; | |
| function d3_hcl(h, c, l) { | |
| return this instanceof d3_hcl ? void (this.h = +h, this.c = +c, this.l = +l) : arguments.length < 2 ? h instanceof d3_hcl ? new d3_hcl(h.h, h.c, h.l) : h instanceof d3_lab ? d3_lab_hcl(h.l, h.a, h.b) : d3_lab_hcl((h = d3_rgb_lab((h = d3.rgb(h)).r, h.g, h.b)).l, h.a, h.b) : new d3_hcl(h, c, l); | |
| } | |
| var d3_hclPrototype = d3_hcl.prototype = new d3_color(); | |
| d3_hclPrototype.brighter = function(k) { | |
| return new d3_hcl(this.h, this.c, Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1))); | |
| }; | |
| d3_hclPrototype.darker = function(k) { | |
| return new d3_hcl(this.h, this.c, Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1))); | |
| }; | |
| d3_hclPrototype.rgb = function() { | |
| return d3_hcl_lab(this.h, this.c, this.l).rgb(); | |
| }; | |
| function d3_hcl_lab(h, c, l) { | |
| if (isNaN(h)) h = 0; | |
| if (isNaN(c)) c = 0; | |
| return new d3_lab(l, Math |
