|
(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, 120] //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") |
|
//.ticks(d3.time.years, 100) |
|
//.tickFormat(d3.time.format("%Y")) |
|
.tickSize(5) |
|
.tickPadding(1) |
|
|
|
var tAxis = d3.svg.axis() |
|
.scale(t) |
|
.orient("bottom") |
|
//.ticks(d3.time.years, 100) |
|
//.tickFormat(d3.time.format("%Y")) |
|
.tickSize(5) |
|
.tickPadding(1) |
|
|
|
var getMainItemHeight = d => .8 * y1(1) |
|
var getMiniItemHeight = d => .8 * y2(1) |
|
var brewedColorClass = "Spectral" |
|
|
|
var chart = d3.select("body") |
|
.append("svg") |
|
.attr("width", w + m[1] + m[3]) |
|
.attr("height", h + m[0] + m[2]) |
|
.attr("class", `chart ${brewedColorClass}`) |
|
|
|
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": "Start Date", |
|
"end": "End Date", |
|
"id": "Page", |
|
"dateformat": d3.time.format("%Y%m%d%H%M%S") |
|
} |
|
|
|
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("sample-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]) |
|
|
|
//main lanes and texts |
|
main.append("g").selectAll(".laneLines") |
|
.data(items) |
|
.enter().append("line") |
|
.attr("t", m[1]) |
|
.attr("y1", d => y1(d.lane) + f) |
|
.attr("x2", w) |
|
.attr("y2", d => y1(d.lane) + f) |
|
.attr("stroke", "lightgray") |
|
|
|
main.append("g").selectAll(".laneText") |
|
.data(lanes) |
|
.enter().append("text") |
|
.text(d => d) |
|
.attr("x", -m[1]) |
|
.attr("y", (d, i) => y1(i + .5) + f) |
|
.attr("dy", ".5ex") |
|
.attr("text-anchor", "end") |
|
.attr("class", "laneText") |
|
|
|
//mini lanes and texts |
|
mini.append("g").selectAll(".laneLines") |
|
.data(items) |
|
.enter().append("line") |
|
.attr("t", m[1]) |
|
.attr("y1", d => y2(d.lane) + f) |
|
.attr("x2", w) |
|
.attr("y2", d => y2(d.lane) + f) |
|
.attr("stroke", "lightgray") |
|
|
|
mini.append("g").selectAll(".laneText") |
|
.data(lanes) |
|
.enter().append("text") |
|
.text(d => d) |
|
.attr("x", -m[1]) |
|
.attr("y", (d, i) => y2(i + .5) + f) |
|
.attr("dy", ".5ex") |
|
.attr("text-anchor", "end") |
|
.attr("class", "laneText") |
|
|
|
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) |
|
.style("fill", d => "") |
|
.attr("class", d => `q${d.lane}-${laneLength}`) |
|
|
|
//mini labels |
|
mini.append("g").selectAll(".miniLabels") |
|
.data(items) |
|
.enter().append("text") |
|
.text(d => d.id) |
|
.attr("x", d => x(d.start)) |
|
.attr("y", d => y2(d.lane + .5) + f) |
|
.attr("dy", ".5ex") |
|
|
|
//brush |
|
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}`) |
|
.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) |
|
//.attr("width", d => t(d.end) - t(d.start)) |
|
//.attr("height", getMainItemHeight) |
|
|
|
lines.exit().remove() |
|
|
|
endmarker = itemRects.selectAll(".endmarker") |
|
.data(visItems, d => d.id) |
|
.attr("transform", d => `translate(${t(d.end)}, ${y1(d.lane + 0.5) + f}) rotate(45)`) |
|
|
|
endmarker.enter().append("path") |
|
.attr("d", d3.svg.symbol().type("cross").size(200)) |
|
.attr("transform", d => `translate(${t(d.end)}, ${y1(d.lane + 0.5) + f}) rotate(45)`) |
|
.attr("class", d => `endmarker shape q${d.lane}-${laneLength}`) |
|
|
|
endmarker.exit().remove() |
|
|
|
startmarker = itemRects.selectAll(".startmarker") |
|
.data(visItems, d => d.id) |
|
.attr("transform", d => `translate(${t(d.start)}, ${y1(d.lane + 0.5) + f}) rotate(45)`) |
|
|
|
startmarker.enter().append("path") |
|
.attr("d", d3.svg.symbol().type("cross").size(200)) |
|
.attr("transform", d => `translate(${t(d.start)}, ${y1(d.lane + 0.5) + f}) rotate(45)`) |
|
.attr("class", d => `startmarker shape q${d.lane}-${laneLength}`) |
|
|
|
startmarker.exit().remove() |
|
|
|
//update the item labels |
|
labels = itemRects.selectAll("text") |
|
.data(visItems, d => d.id) |
|
.attr("x", d => t(Math.max(d.start, minExtent)) + 10) |
|
|
|
labels.enter().append("text") |
|
.text(d => d.id) |
|
.attr("x", d => t(Math.max(d.start, minExtent)) + 10) |
|
.attr("y", d => y1(d.lane + .5) + f - 10) |
|
.attr("text-anchor", "start") |
|
|
|
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.cos(h *= d3_radians) * c, Math.sin(h) * c); |
|
} |
|
d3.lab = d3_lab; |
|
function d3_lab(l, a, b) { |
|
return this instanceof d3_lab ? void (this.l = +l, this.a = +a, this.b = +b) : arguments.length < 2 ? l instanceof d3_lab ? new d3_lab(l.l, l.a, l.b) : l instanceof d3_hcl ? d3_hcl_lab(l.h, l.c, l.l) : d3_rgb_lab((l = d3_rgb(l)).r, l.g, l.b) : new d3_lab(l, a, b); |
|
} |
|
var d3_lab_K = 18; |
|
var d3_lab_X = .95047, d3_lab_Y = 1, d3_lab_Z = 1.08883; |
|
var d3_labPrototype = d3_lab.prototype = new d3_color(); |
|
d3_labPrototype.brighter = function(k) { |
|
return new d3_lab(Math.min(100, this.l + d3_lab_K * (arguments.length ? k : 1)), this.a, this.b); |
|
}; |
|
d3_labPrototype.darker = function(k) { |
|
return new d3_lab(Math.max(0, this.l - d3_lab_K * (arguments.length ? k : 1)), this.a, this.b); |
|
}; |
|
d3_labPrototype.rgb = function() { |
|
return d3_lab_rgb(this.l, this.a, this.b); |
|
}; |
|
function d3_lab_rgb(l, a, b) { |
|
var y = (l + 16) / 116, x = y + a / 500, z = y - b / 200; |
|
x = d3_lab_xyz(x) * d3_lab_X; |
|
y = d3_lab_xyz(y) * d3_lab_Y; |
|
z = d3_lab_xyz(z) * d3_lab_Z; |
|
return new d3_rgb(d3_xyz_rgb(3.2404542 * x - 1.5371385 * y - .4985314 * z), d3_xyz_rgb(-.969266 * x + 1.8760108 * y + .041556 * z), d3_xyz_rgb(.0556434 * x - .2040259 * y + 1.0572252 * z)); |
|
} |
|
function d3_lab_hcl(l, a, b) { |
|
return l > 0 ? new d3_hcl(Math.atan2(b, a) * d3_degrees, Math.sqrt(a * a + b * b), l) : new d3_hcl(NaN, NaN, l); |
|
} |
|
function d3_lab_xyz(x) { |
|
return x > .206893034 ? x * x * x : (x - 4 / 29) / 7.787037; |
|
} |
|
function d3_xyz_lab(x) { |
|
return x > .008856 ? Math.pow(x, 1 / 3) : 7.787037 * x + 4 / 29; |
|
} |
|
function d3_xyz_rgb(r) { |
|
return Math.round(255 * (r <= .00304 ? 12.92 * r : 1.055 * Math.pow(r, 1 / 2.4) - .055)); |
|
} |
|
d3.rgb = d3_rgb; |
|
function d3_rgb(r, g, b) { |
|
return this instanceof d3_rgb ? void (this.r = ~~r, this.g = ~~g, this.b = ~~b) : arguments.length < 2 ? r instanceof d3_rgb ? new d3_rgb(r.r, r.g, r.b) : d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb) : new d3_rgb(r, g, b); |
|
} |
|
function d3_rgbNumber(value) { |
|
return new d3_rgb(value >> 16, value >> 8 & 255, value & 255); |
|
} |
|
function d3_rgbString(value) { |
|
return d3_rgbNumber(value) + ""; |
|
} |
|
var d3_rgbPrototype = d3_rgb.prototype = new d3_color(); |
|
d3_rgbPrototype.brighter = function(k) { |
|
k = Math.pow(.7, arguments.length ? k : 1); |
|
var r = this.r, g = this.g, b = this.b, i = 30; |
|
if (!r && !g && !b) return new d3_rgb(i, i, i); |
|
if (r && r < i) r = i; |
|
if (g && g < i) g = i; |
|
if (b && b < i) b = i; |
|
return new d3_rgb(Math.min(255, r / k), Math.min(255, g / k), Math.min(255, b / k)); |
|
}; |
|
d3_rgbPrototype.darker = function(k) { |
|
k = Math.pow(.7, arguments.length ? k : 1); |
|
return new d3_rgb(k * this.r, k * this.g, k * this.b); |
|
}; |
|
d3_rgbPrototype.hsl = function() { |
|
return d3_rgb_hsl(this.r, this.g, this.b); |
|
}; |
|
d3_rgbPrototype.toString = function() { |
|
return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b); |
|
}; |
|
function d3_rgb_hex(v) { |
|
return v < 16 ? "0" + Math.max(0, v).toString(16) : Math.min(255, v).toString(16); |
|
} |
|
function d3_rgb_parse(format, rgb, hsl) { |
|
var r = 0, g = 0, b = 0, m1, m2, color; |
|
m1 = /([a-z]+)\((.*)\)/.exec(format = format.toLowerCase()); |
|
if (m1) { |
|
m2 = m1[2].split(","); |
|
switch (m1[1]) { |
|
case "hsl": |
|
{ |
|
return hsl(parseFloat(m2[0]), parseFloat(m2[1]) / 100, parseFloat(m2[2]) / 100); |
|
} |
|
|
|
case "rgb": |
|
{ |
|
return rgb(d3_rgb_parseNumber(m2[0]), d3_rgb_parseNumber(m2[1]), d3_rgb_parseNumber(m2[2])); |
|
} |
|
} |
|
} |
|
if (color = d3_rgb_names.get(format)) { |
|
return rgb(color.r, color.g, color.b); |
|
} |
|
if (format != null && format.charAt(0) === "#" && !isNaN(color = parseInt(format.slice(1), 16))) { |
|
if (format.length === 4) { |
|
r = (color & 3840) >> 4; |
|
r = r >> 4 | r; |
|
g = color & 240; |
|
g = g >> 4 | g; |
|
b = color & 15; |
|
b = b << 4 | b; |
|
} else if (format.length === 7) { |
|
r = (color & 16711680) >> 16; |
|
g = (color & 65280) >> 8; |
|
b = color & 255; |
|
} |
|
} |
|
return rgb(r, g, b); |
|
} |
|
function d3_rgb_hsl(r, g, b) { |
|
var min = Math.min(r /= 255, g /= 255, b /= 255), max = Math.max(r, g, b), d = max - min, h, s, l = (max + min) / 2; |
|
if (d) { |
|
s = l < .5 ? d / (max + min) : d / (2 - max - min); |
|
if (r == max) h = (g - b) / d + (g < b ? 6 : 0); else if (g == max) h = (b - r) / d + 2; else h = (r - g) / d + 4; |
|
h *= 60; |
|
} else { |
|
h = NaN; |
|
s = l > 0 && l < 1 ? 0 : h; |
|
} |
|
return new d3_hsl(h, s, l); |
|
} |
|
function d3_rgb_lab(r, g, b) { |
|
r = d3_rgb_xyz(r); |
|
g = d3_rgb_xyz(g); |
|
b = d3_rgb_xyz(b); |
|
var x = d3_xyz_lab((.4124564 * r + .3575761 * g + .1804375 * b) / d3_lab_X), y = d3_xyz_lab((.2126729 * r + .7151522 * g + .072175 * b) / d3_lab_Y), z = d3_xyz_lab((.0193339 * r + .119192 * g + .9503041 * b) / d3_lab_Z); |
|
return d3_lab(116 * y - 16, 500 * (x - y), 200 * (y - z)); |
|
} |
|
function d3_rgb_xyz(r) { |
|
return (r /= 255) <= .04045 ? r / 12.92 : Math.pow((r + .055) / 1.055, 2.4); |
|
} |
|
function d3_rgb_parseNumber(c) { |
|
var f = parseFloat(c); |
|
return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f; |
|
} |
|
var d3_rgb_names = d3.map({ |
|
aliceblue: 15792383, |
|
antiquewhite: 16444375, |
|
aqua: 65535, |
|
aquamarine: 8388564, |
|
azure: 15794175, |
|
beige: 16119260, |
|
bisque: 16770244, |
|
black: 0, |
|
blanchedalmond: 16772045, |
|
blue: 255, |
|
blueviolet: 9055202, |
|
brown: 10824234, |
|
burlywood: 14596231, |
|
cadetblue: 6266528, |
|
chartreuse: 8388352, |
|
chocolate: 13789470, |
|
coral: 16744272, |
|
cornflowerblue: 6591981, |
|
cornsilk: 16775388, |
|
crimson: 14423100, |
|
cyan: 65535, |
|
darkblue: 139, |
|
darkcyan: 35723, |
|
darkgoldenrod: 12092939, |
|
darkgray: 11119017, |
|
darkgreen: 25600, |
|
darkgrey: 11119017, |
|
darkkhaki: 12433259, |
|
darkmagenta: 9109643, |
|
darkolivegreen: 5597999, |
|
darkorange: 16747520, |
|
darkorchid: 10040012, |
|
darkred: 9109504, |
|
darksalmon: 15308410, |
|
darkseagreen: 9419919, |
|
darkslateblue: 4734347, |
|
darkslategray: 3100495, |
|
darkslategrey: 3100495, |
|
darkturquoise: 52945, |
|
darkviolet: 9699539, |
|
deeppink: 16716947, |
|
deepskyblue: 49151, |
|
dimgray: 6908265, |
|
dimgrey: 6908265, |
|
dodgerblue: 2003199, |
|
firebrick: 11674146, |
|
floralwhite: 16775920, |
|
forestgreen: 2263842, |
|
fuchsia: 16711935, |
|
gainsboro: 14474460, |
|
ghostwhite: 16316671, |
|
gold: 16766720, |
|
goldenrod: 14329120, |
