wiki 0.0.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (72) hide show
  1. checksums.yaml +7 -0
  2. data/.gitignore +17 -0
  3. data/Gemfile +4 -0
  4. data/LICENSE.txt +22 -0
  5. data/README.md +29 -0
  6. data/Rakefile +1 -0
  7. data/lib/wiki.rb +2 -0
  8. data/lib/wiki/ReadMe.md +89 -0
  9. data/lib/wiki/config.ru +2 -0
  10. data/lib/wiki/favicon.rb +31 -0
  11. data/lib/wiki/page.rb +74 -0
  12. data/lib/wiki/random_id.rb +5 -0
  13. data/lib/wiki/server.rb +336 -0
  14. data/lib/wiki/server_helpers.rb +66 -0
  15. data/lib/wiki/stores/ReadMe.md +26 -0
  16. data/lib/wiki/stores/all.rb +3 -0
  17. data/lib/wiki/stores/couch.rb +121 -0
  18. data/lib/wiki/stores/file.rb +53 -0
  19. data/lib/wiki/stores/store.rb +38 -0
  20. data/lib/wiki/version.rb +3 -0
  21. data/lib/wiki/views/client/Gruntfile.js +50 -0
  22. data/lib/wiki/views/client/ReadMe.md +67 -0
  23. data/lib/wiki/views/client/build-test.bat +10 -0
  24. data/lib/wiki/views/client/build.bat +8 -0
  25. data/lib/wiki/views/client/builder.pl +41 -0
  26. data/lib/wiki/views/client/client.coffee +3 -0
  27. data/lib/wiki/views/client/client.js +3607 -0
  28. data/lib/wiki/views/client/crosses.png +0 -0
  29. data/lib/wiki/views/client/images/external-link-ltr-icon.png +0 -0
  30. data/lib/wiki/views/client/images/noise.png +0 -0
  31. data/lib/wiki/views/client/images/oops.jpg +0 -0
  32. data/lib/wiki/views/client/js/d3/d3.behavior.js +198 -0
  33. data/lib/wiki/views/client/js/d3/d3.chart.js +984 -0
  34. data/lib/wiki/views/client/js/d3/d3.csv.js +92 -0
  35. data/lib/wiki/views/client/js/d3/d3.geo.js +566 -0
  36. data/lib/wiki/views/client/js/d3/d3.geom.js +825 -0
  37. data/lib/wiki/views/client/js/d3/d3.js +3597 -0
  38. data/lib/wiki/views/client/js/d3/d3.layout.js +1923 -0
  39. data/lib/wiki/views/client/js/d3/d3.time.js +660 -0
  40. data/lib/wiki/views/client/js/images/ui-bg_glass_65_ffffff_1x400.png +0 -0
  41. data/lib/wiki/views/client/js/images/ui-icons_222222_256x240.png +0 -0
  42. data/lib/wiki/views/client/js/jquery-1.6.2.min.js +18 -0
  43. data/lib/wiki/views/client/js/jquery-1.7.1.min.js +4 -0
  44. data/lib/wiki/views/client/js/jquery-1.9.1.min.js +5 -0
  45. data/lib/wiki/views/client/js/jquery-migrate-1.1.1.min.js +3 -0
  46. data/lib/wiki/views/client/js/jquery-ui-1.10.1.custom.min.css +5 -0
  47. data/lib/wiki/views/client/js/jquery-ui-1.10.1.custom.min.js +6 -0
  48. data/lib/wiki/views/client/js/jquery-ui-1.8.16.custom.css +339 -0
  49. data/lib/wiki/views/client/js/jquery-ui-1.8.16.custom.min.js +315 -0
  50. data/lib/wiki/views/client/js/jquery.ie.cors.js +310 -0
  51. data/lib/wiki/views/client/js/jquery.ui.touch-punch.min.js +11 -0
  52. data/lib/wiki/views/client/js/modernizr.custom.63710.js +824 -0
  53. data/lib/wiki/views/client/js/sockjs-0.3.min.js +27 -0
  54. data/lib/wiki/views/client/js/underscore-min.js +30 -0
  55. data/lib/wiki/views/client/mkplugin.sh +97 -0
  56. data/lib/wiki/views/client/package.json +36 -0
  57. data/lib/wiki/views/client/runtests.html +26 -0
  58. data/lib/wiki/views/client/style.css +339 -0
  59. data/lib/wiki/views/client/test/mocha.css +231 -0
  60. data/lib/wiki/views/client/test/mocha.js +5340 -0
  61. data/lib/wiki/views/client/test/testclient.js +17133 -0
  62. data/lib/wiki/views/client/testclient.coffee +18 -0
  63. data/lib/wiki/views/client/theme/granite.css +59 -0
  64. data/lib/wiki/views/client/theme/stoneSeamless.jpg +0 -0
  65. data/lib/wiki/views/client/twitter-maintainance.jpg +0 -0
  66. data/lib/wiki/views/layout.haml +56 -0
  67. data/lib/wiki/views/oops.haml +5 -0
  68. data/lib/wiki/views/page.haml +20 -0
  69. data/lib/wiki/views/static.html +30 -0
  70. data/lib/wiki/views/view.haml +2 -0
  71. data/wiki.gemspec +28 -0
  72. metadata +121 -0
@@ -0,0 +1,3597 @@
1
+ (function(){d3 = {version: "1.29.4"}; // semver
2
+ if (!Date.now) Date.now = function() {
3
+ return +new Date;
4
+ };
5
+ if (!Object.create) Object.create = function(o) {
6
+ /** @constructor */ function f() {}
7
+ f.prototype = o;
8
+ return new f;
9
+ };
10
+ var d3_array = d3_arraySlice; // conversion for NodeLists
11
+
12
+ function d3_arrayCopy(psuedoarray) {
13
+ var i = -1, n = psuedoarray.length, array = [];
14
+ while (++i < n) array.push(psuedoarray[i]);
15
+ return array;
16
+ }
17
+
18
+ function d3_arraySlice(psuedoarray) {
19
+ return Array.prototype.slice.call(psuedoarray);
20
+ }
21
+
22
+ try {
23
+ d3_array(document.documentElement.childNodes)[0].nodeType;
24
+ } catch(e) {
25
+ d3_array = d3_arrayCopy;
26
+ }
27
+ d3.functor = function(v) {
28
+ return typeof v === "function" ? v : function() { return v; };
29
+ };
30
+ // A getter-setter method that preserves the appropriate `this` context.
31
+ d3.rebind = function(object, method) {
32
+ return function() {
33
+ var x = method.apply(object, arguments);
34
+ return arguments.length ? object : x;
35
+ };
36
+ };
37
+ d3.ascending = function(a, b) {
38
+ return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
39
+ };
40
+ d3.descending = function(a, b) {
41
+ return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
42
+ };
43
+ d3.min = function(array, f) {
44
+ var i = -1,
45
+ n = array.length,
46
+ a,
47
+ b;
48
+ if (arguments.length === 1) {
49
+ while (++i < n && ((a = array[i]) == null || a != a)) a = undefined;
50
+ while (++i < n) if ((b = array[i]) != null && a > b) a = b;
51
+ } else {
52
+ while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined;
53
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b;
54
+ }
55
+ return a;
56
+ };
57
+ d3.max = function(array, f) {
58
+ var i = -1,
59
+ n = array.length,
60
+ a,
61
+ b;
62
+ if (arguments.length === 1) {
63
+ while (++i < n && ((a = array[i]) == null || a != a)) a = undefined;
64
+ while (++i < n) if ((b = array[i]) != null && b > a) a = b;
65
+ } else {
66
+ while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined;
67
+ while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b;
68
+ }
69
+ return a;
70
+ };
71
+ d3.sum = function(array, f) {
72
+ var s = 0,
73
+ n = array.length,
74
+ a,
75
+ i = -1;
76
+
77
+ if (arguments.length === 1) {
78
+ while (++i < n) if (!isNaN(a = +array[i])) s += a;
79
+ } else {
80
+ while (++i < n) if (!isNaN(a = +f.call(array, array[i], i))) s += a;
81
+ }
82
+
83
+ return s;
84
+ };
85
+ // R-7 per <http://en.wikipedia.org/wiki/Quantile>
86
+ d3.quantile = function(values, p) {
87
+ var H = (values.length - 1) * p + 1,
88
+ h = Math.floor(H),
89
+ v = values[h - 1],
90
+ e = H - h;
91
+ return e ? v + e * (values[h] - v) : v;
92
+ };
93
+ d3.zip = function() {
94
+ if (!(n = arguments.length)) return [];
95
+ for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m;) {
96
+ for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n;) {
97
+ zip[j] = arguments[j][i];
98
+ }
99
+ }
100
+ return zips;
101
+ };
102
+
103
+ function d3_zipLength(d) {
104
+ return d.length;
105
+ }
106
+ // Locate the insertion point for x in a to maintain sorted order. The
107
+ // arguments lo and hi may be used to specify a subset of the array which should
108
+ // be considered; by default the entire array is used. If x is already present
109
+ // in a, the insertion point will be before (to the left of) any existing
110
+ // entries. The return value is suitable for use as the first argument to
111
+ // `array.splice` assuming that a is already sorted.
112
+ //
113
+ // The returned insertion point i partitions the array a into two halves so that
114
+ // all v < x for v in a[lo:i] for the left side and all v >= x for v in a[i:hi]
115
+ // for the right side.
116
+ d3.bisectLeft = function(a, x, lo, hi) {
117
+ if (arguments.length < 3) lo = 0;
118
+ if (arguments.length < 4) hi = a.length;
119
+ while (lo < hi) {
120
+ var mid = (lo + hi) >> 1;
121
+ if (a[mid] < x) lo = mid + 1;
122
+ else hi = mid;
123
+ }
124
+ return lo;
125
+ };
126
+
127
+ // Similar to bisectLeft, but returns an insertion point which comes after (to
128
+ // the right of) any existing entries of x in a.
129
+ //
130
+ // The returned insertion point i partitions the array into two halves so that
131
+ // all v <= x for v in a[lo:i] for the left side and all v > x for v in a[i:hi]
132
+ // for the right side.
133
+ d3.bisect =
134
+ d3.bisectRight = function(a, x, lo, hi) {
135
+ if (arguments.length < 3) lo = 0;
136
+ if (arguments.length < 4) hi = a.length;
137
+ while (lo < hi) {
138
+ var mid = (lo + hi) >> 1;
139
+ if (x < a[mid]) hi = mid;
140
+ else lo = mid + 1;
141
+ }
142
+ return lo;
143
+ };
144
+ d3.first = function(array, f) {
145
+ var i = 0,
146
+ n = array.length,
147
+ a = array[0],
148
+ b;
149
+ if (arguments.length === 1) f = d3.ascending;
150
+ while (++i < n) {
151
+ if (f.call(array, a, b = array[i]) > 0) {
152
+ a = b;
153
+ }
154
+ }
155
+ return a;
156
+ };
157
+ d3.last = function(array, f) {
158
+ var i = 0,
159
+ n = array.length,
160
+ a = array[0],
161
+ b;
162
+ if (arguments.length === 1) f = d3.ascending;
163
+ while (++i < n) {
164
+ if (f.call(array, a, b = array[i]) <= 0) {
165
+ a = b;
166
+ }
167
+ }
168
+ return a;
169
+ };
170
+ d3.nest = function() {
171
+ var nest = {},
172
+ keys = [],
173
+ sortKeys = [],
174
+ sortValues,
175
+ rollup;
176
+
177
+ function map(array, depth) {
178
+ if (depth >= keys.length) return rollup
179
+ ? rollup.call(nest, array) : (sortValues
180
+ ? array.sort(sortValues)
181
+ : array);
182
+
183
+ var i = -1,
184
+ n = array.length,
185
+ key = keys[depth++],
186
+ keyValue,
187
+ object,
188
+ o = {};
189
+
190
+ while (++i < n) {
191
+ if ((keyValue = key(object = array[i])) in o) {
192
+ o[keyValue].push(object);
193
+ } else {
194
+ o[keyValue] = [object];
195
+ }
196
+ }
197
+
198
+ for (keyValue in o) {
199
+ o[keyValue] = map(o[keyValue], depth);
200
+ }
201
+
202
+ return o;
203
+ }
204
+
205
+ function entries(map, depth) {
206
+ if (depth >= keys.length) return map;
207
+
208
+ var a = [],
209
+ sortKey = sortKeys[depth++],
210
+ key;
211
+
212
+ for (key in map) {
213
+ a.push({key: key, values: entries(map[key], depth)});
214
+ }
215
+
216
+ if (sortKey) a.sort(function(a, b) {
217
+ return sortKey(a.key, b.key);
218
+ });
219
+
220
+ return a;
221
+ }
222
+
223
+ nest.map = function(array) {
224
+ return map(array, 0);
225
+ };
226
+
227
+ nest.entries = function(array) {
228
+ return entries(map(array, 0), 0);
229
+ };
230
+
231
+ nest.key = function(d) {
232
+ keys.push(d);
233
+ return nest;
234
+ };
235
+
236
+ // Specifies the order for the most-recently specified key.
237
+ // Note: only applies to entries. Map keys are unordered!
238
+ nest.sortKeys = function(order) {
239
+ sortKeys[keys.length - 1] = order;
240
+ return nest;
241
+ };
242
+
243
+ // Specifies the order for leaf values.
244
+ // Applies to both maps and entries array.
245
+ nest.sortValues = function(order) {
246
+ sortValues = order;
247
+ return nest;
248
+ };
249
+
250
+ nest.rollup = function(f) {
251
+ rollup = f;
252
+ return nest;
253
+ };
254
+
255
+ return nest;
256
+ };
257
+ d3.keys = function(map) {
258
+ var keys = [];
259
+ for (var key in map) keys.push(key);
260
+ return keys;
261
+ };
262
+ d3.values = function(map) {
263
+ var values = [];
264
+ for (var key in map) values.push(map[key]);
265
+ return values;
266
+ };
267
+ d3.entries = function(map) {
268
+ var entries = [];
269
+ for (var key in map) entries.push({key: key, value: map[key]});
270
+ return entries;
271
+ };
272
+ d3.permute = function(array, indexes) {
273
+ var permutes = [],
274
+ i = -1,
275
+ n = indexes.length;
276
+ while (++i < n) permutes[i] = array[indexes[i]];
277
+ return permutes;
278
+ };
279
+ d3.merge = function(arrays) {
280
+ return Array.prototype.concat.apply([], arrays);
281
+ };
282
+ d3.split = function(array, f) {
283
+ var arrays = [],
284
+ values = [],
285
+ value,
286
+ i = -1,
287
+ n = array.length;
288
+ if (arguments.length < 2) f = d3_splitter;
289
+ while (++i < n) {
290
+ if (f.call(values, value = array[i], i)) {
291
+ values = [];
292
+ } else {
293
+ if (!values.length) arrays.push(values);
294
+ values.push(value);
295
+ }
296
+ }
297
+ return arrays;
298
+ };
299
+
300
+ function d3_splitter(d) {
301
+ return d == null;
302
+ }
303
+ function d3_collapse(s) {
304
+ return s.replace(/(^\s+)|(\s+$)/g, "").replace(/\s+/g, " ");
305
+ }
306
+ //
307
+ // Note: assigning to the arguments array simultaneously changes the value of
308
+ // the corresponding argument!
309
+ //
310
+ // TODO The `this` argument probably shouldn't be the first argument to the
311
+ // callback, anyway, since it's redundant. However, that will require a major
312
+ // version bump due to backwards compatibility, so I'm not changing it right
313
+ // away.
314
+ //
315
+ function d3_call(callback) {
316
+ callback.apply(this, (arguments[0] = this, arguments));
317
+ return this;
318
+ }
319
+ /**
320
+ * @param {number} start
321
+ * @param {number=} stop
322
+ * @param {number=} step
323
+ */
324
+ d3.range = function(start, stop, step) {
325
+ if (arguments.length < 3) {
326
+ step = 1;
327
+ if (arguments.length < 2) {
328
+ stop = start;
329
+ start = 0;
330
+ }
331
+ }
332
+ if ((stop - start) / step == Infinity) throw new Error("infinite range");
333
+ var range = [],
334
+ i = -1,
335
+ j;
336
+ if (step < 0) while ((j = start + step * ++i) > stop) range.push(j);
337
+ else while ((j = start + step * ++i) < stop) range.push(j);
338
+ return range;
339
+ };
340
+ d3.requote = function(s) {
341
+ return s.replace(d3_requote_re, "\\$&");
342
+ };
343
+
344
+ var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;
345
+ d3.round = function(x, n) {
346
+ return n
347
+ ? Math.round(x * Math.pow(10, n)) * Math.pow(10, -n)
348
+ : Math.round(x);
349
+ };
350
+ d3.xhr = function(url, mime, callback) {
351
+ var req = new XMLHttpRequest;
352
+ if (arguments.length < 3) callback = mime;
353
+ else if (mime && req.overrideMimeType) req.overrideMimeType(mime);
354
+ req.open("GET", url, true);
355
+ req.onreadystatechange = function() {
356
+ if (req.readyState === 4) callback(req.status < 300 ? req : null);
357
+ };
358
+ req.send(null);
359
+ };
360
+ d3.text = function(url, mime, callback) {
361
+ function ready(req) {
362
+ callback(req && req.responseText);
363
+ }
364
+ if (arguments.length < 3) {
365
+ callback = mime;
366
+ mime = null;
367
+ }
368
+ d3.xhr(url, mime, ready);
369
+ };
370
+ d3.json = function(url, callback) {
371
+ d3.text(url, "application/json", function(text) {
372
+ callback(text ? JSON.parse(text) : null);
373
+ });
374
+ };
375
+ d3.html = function(url, callback) {
376
+ d3.text(url, "text/html", function(text) {
377
+ if (text != null) { // Treat empty string as valid HTML.
378
+ var range = document.createRange();
379
+ range.selectNode(document.body);
380
+ text = range.createContextualFragment(text);
381
+ }
382
+ callback(text);
383
+ });
384
+ };
385
+ d3.xml = function(url, mime, callback) {
386
+ function ready(req) {
387
+ callback(req && req.responseXML);
388
+ }
389
+ if (arguments.length < 3) {
390
+ callback = mime;
391
+ mime = null;
392
+ }
393
+ d3.xhr(url, mime, ready);
394
+ };
395
+ d3.ns = {
396
+
397
+ prefix: {
398
+ svg: "http://www.w3.org/2000/svg",
399
+ xhtml: "http://www.w3.org/1999/xhtml",
400
+ xlink: "http://www.w3.org/1999/xlink",
401
+ xml: "http://www.w3.org/XML/1998/namespace",
402
+ xmlns: "http://www.w3.org/2000/xmlns/"
403
+ },
404
+
405
+ qualify: function(name) {
406
+ var i = name.indexOf(":");
407
+ return i < 0 ? name : {
408
+ space: d3.ns.prefix[name.substring(0, i)],
409
+ local: name.substring(i + 1)
410
+ };
411
+ }
412
+
413
+ };
414
+ /** @param {...string} types */
415
+ d3.dispatch = function(types) {
416
+ var dispatch = {},
417
+ type;
418
+ for (var i = 0, n = arguments.length; i < n; i++) {
419
+ type = arguments[i];
420
+ dispatch[type] = d3_dispatch(type);
421
+ }
422
+ return dispatch;
423
+ };
424
+
425
+ function d3_dispatch(type) {
426
+ var dispatch = {},
427
+ listeners = [];
428
+
429
+ dispatch.add = function(listener) {
430
+ for (var i = 0; i < listeners.length; i++) {
431
+ if (listeners[i].listener == listener) return dispatch; // already registered
432
+ }
433
+ listeners.push({listener: listener, on: true});
434
+ return dispatch;
435
+ };
436
+
437
+ dispatch.remove = function(listener) {
438
+ for (var i = 0; i < listeners.length; i++) {
439
+ var l = listeners[i];
440
+ if (l.listener == listener) {
441
+ l.on = false;
442
+ listeners = listeners.slice(0, i).concat(listeners.slice(i + 1));
443
+ break;
444
+ }
445
+ }
446
+ return dispatch;
447
+ };
448
+
449
+ dispatch.dispatch = function() {
450
+ var ls = listeners; // defensive reference
451
+ for (var i = 0, n = ls.length; i < n; i++) {
452
+ var l = ls[i];
453
+ if (l.on) l.listener.apply(this, arguments);
454
+ }
455
+ };
456
+
457
+ return dispatch;
458
+ };
459
+ // TODO align
460
+ d3.format = function(specifier) {
461
+ var match = d3_format_re.exec(specifier),
462
+ fill = match[1] || " ",
463
+ sign = match[3] || "",
464
+ zfill = match[5],
465
+ width = +match[6],
466
+ comma = match[7],
467
+ precision = match[8],
468
+ type = match[9],
469
+ percentage = false,
470
+ integer = false;
471
+
472
+ if (precision) precision = precision.substring(1);
473
+
474
+ if (zfill) {
475
+ fill = "0"; // TODO align = "=";
476
+ if (comma) width -= Math.floor((width - 1) / 4);
477
+ }
478
+
479
+ switch (type) {
480
+ case "n": comma = true; type = "g"; break;
481
+ case "%": percentage = true; type = "f"; break;
482
+ case "p": percentage = true; type = "r"; break;
483
+ case "d": integer = true; precision = "0"; break;
484
+ }
485
+
486
+ type = d3_format_types[type] || d3_format_typeDefault;
487
+
488
+ return function(value) {
489
+ var number = percentage ? value * 100 : +value,
490
+ negative = (number < 0) && (number = -number) ? "\u2212" : sign;
491
+
492
+ // Return the empty string for floats formatted as ints.
493
+ if (integer && (number % 1)) return "";
494
+
495
+ // Convert the input value to the desired precision.
496
+ value = type(number, precision);
497
+
498
+ // If the fill character is 0, the sign and group is applied after the fill.
499
+ if (zfill) {
500
+ var length = value.length + negative.length;
501
+ if (length < width) value = new Array(width - length + 1).join(fill) + value;
502
+ if (comma) value = d3_format_group(value);
503
+ value = negative + value;
504
+ }
505
+
506
+ // Otherwise (e.g., space-filling), the sign and group is applied before.
507
+ else {
508
+ if (comma) value = d3_format_group(value);
509
+ value = negative + value;
510
+ var length = value.length;
511
+ if (length < width) value = new Array(width - length + 1).join(fill) + value;
512
+ }
513
+ if (percentage) value += "%";
514
+
515
+ return value;
516
+ };
517
+ };
518
+
519
+ // [[fill]align][sign][#][0][width][,][.precision][type]
520
+ var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?(#)?(0)?([0-9]+)?(,)?(\.[0-9]+)?([a-zA-Z%])?/;
521
+
522
+ var d3_format_types = {
523
+ g: function(x, p) { return x.toPrecision(p); },
524
+ e: function(x, p) { return x.toExponential(p); },
525
+ f: function(x, p) { return x.toFixed(p); },
526
+ r: function(x, p) {
527
+ var n = 1 + Math.floor(1e-15 + Math.log(x) / Math.LN10);
528
+ return d3.round(x, p - n).toFixed(Math.max(0, p - n));
529
+ }
530
+ };
531
+
532
+ function d3_format_typeDefault(x) {
533
+ return x + "";
534
+ }
535
+
536
+ // Apply comma grouping for thousands.
537
+ function d3_format_group(value) {
538
+ var i = value.lastIndexOf("."),
539
+ f = i >= 0 ? value.substring(i) : (i = value.length, ""),
540
+ t = [];
541
+ while (i > 0) t.push(value.substring(i -= 3, i + 3));
542
+ return t.reverse().join(",") + f;
543
+ }
544
+ /*
545
+ * TERMS OF USE - EASING EQUATIONS
546
+ *
547
+ * Open source under the BSD License.
548
+ *
549
+ * Copyright 2001 Robert Penner
550
+ * All rights reserved.
551
+ *
552
+ * Redistribution and use in source and binary forms, with or without
553
+ * modification, are permitted provided that the following conditions are met:
554
+ *
555
+ * - Redistributions of source code must retain the above copyright notice, this
556
+ * list of conditions and the following disclaimer.
557
+ *
558
+ * - Redistributions in binary form must reproduce the above copyright notice,
559
+ * this list of conditions and the following disclaimer in the documentation
560
+ * and/or other materials provided with the distribution.
561
+ *
562
+ * - Neither the name of the author nor the names of contributors may be used to
563
+ * endorse or promote products derived from this software without specific
564
+ * prior written permission.
565
+ *
566
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
567
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
568
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
569
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
570
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
571
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
572
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
573
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
574
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
575
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
576
+ * POSSIBILITY OF SUCH DAMAGE.
577
+ */
578
+
579
+ var d3_ease_quad = d3_ease_poly(2),
580
+ d3_ease_cubic = d3_ease_poly(3);
581
+
582
+ var d3_ease = {
583
+ linear: function() { return d3_ease_linear; },
584
+ poly: d3_ease_poly,
585
+ quad: function() { return d3_ease_quad; },
586
+ cubic: function() { return d3_ease_cubic; },
587
+ sin: function() { return d3_ease_sin; },
588
+ exp: function() { return d3_ease_exp; },
589
+ circle: function() { return d3_ease_circle; },
590
+ elastic: d3_ease_elastic,
591
+ back: d3_ease_back,
592
+ bounce: function() { return d3_ease_bounce; }
593
+ };
594
+
595
+ var d3_ease_mode = {
596
+ "in": function(f) { return f; },
597
+ "out": d3_ease_reverse,
598
+ "in-out": d3_ease_reflect,
599
+ "out-in": function(f) { return d3_ease_reflect(d3_ease_reverse(f)); }
600
+ };
601
+
602
+ d3.ease = function(name) {
603
+ var i = name.indexOf("-"),
604
+ t = i >= 0 ? name.substring(0, i) : name,
605
+ m = i >= 0 ? name.substring(i + 1) : "in";
606
+ return d3_ease_mode[m](d3_ease[t].apply(null, Array.prototype.slice.call(arguments, 1)));
607
+ };
608
+
609
+ function d3_ease_reverse(f) {
610
+ return function(t) {
611
+ return 1 - f(1 - t);
612
+ };
613
+ }
614
+
615
+ function d3_ease_reflect(f) {
616
+ return function(t) {
617
+ return .5 * (t < .5 ? f(2 * t) : (2 - f(2 - 2 * t)));
618
+ };
619
+ }
620
+
621
+ function d3_ease_linear(t) {
622
+ return t;
623
+ }
624
+
625
+ function d3_ease_poly(e) {
626
+ return function(t) {
627
+ return Math.pow(t, e);
628
+ }
629
+ }
630
+
631
+ function d3_ease_sin(t) {
632
+ return 1 - Math.cos(t * Math.PI / 2);
633
+ }
634
+
635
+ function d3_ease_exp(t) {
636
+ return Math.pow(2, 10 * (t - 1));
637
+ }
638
+
639
+ function d3_ease_circle(t) {
640
+ return 1 - Math.sqrt(1 - t * t);
641
+ }
642
+
643
+ function d3_ease_elastic(a, p) {
644
+ var s;
645
+ if (arguments.length < 2) p = 0.45;
646
+ if (arguments.length < 1) { a = 1; s = p / 4; }
647
+ else s = p / (2 * Math.PI) * Math.asin(1 / a);
648
+ return function(t) {
649
+ return 1 + a * Math.pow(2, 10 * -t) * Math.sin((t - s) * 2 * Math.PI / p);
650
+ };
651
+ }
652
+
653
+ function d3_ease_back(s) {
654
+ if (!s) s = 1.70158;
655
+ return function(t) {
656
+ return t * t * ((s + 1) * t - s);
657
+ };
658
+ }
659
+
660
+ function d3_ease_bounce(t) {
661
+ return t < 1 / 2.75 ? 7.5625 * t * t
662
+ : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75
663
+ : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375
664
+ : 7.5625 * (t -= 2.625 / 2.75) * t + .984375;
665
+ }
666
+ d3.event = null;
667
+ d3.interpolate = function(a, b) {
668
+ var i = d3.interpolators.length, f;
669
+ while (--i >= 0 && !(f = d3.interpolators[i](a, b)));
670
+ return f;
671
+ };
672
+
673
+ d3.interpolateNumber = function(a, b) {
674
+ b -= a;
675
+ return function(t) { return a + b * t; };
676
+ };
677
+
678
+ d3.interpolateRound = function(a, b) {
679
+ b -= a;
680
+ return function(t) { return Math.round(a + b * t); };
681
+ };
682
+
683
+ d3.interpolateString = function(a, b) {
684
+ var m, // current match
685
+ i, // current index
686
+ j, // current index (for coallescing)
687
+ s0 = 0, // start index of current string prefix
688
+ s1 = 0, // end index of current string prefix
689
+ s = [], // string constants and placeholders
690
+ q = [], // number interpolators
691
+ n, // q.length
692
+ o;
693
+
694
+ // Reset our regular expression!
695
+ d3_interpolate_number.lastIndex = 0;
696
+
697
+ // Find all numbers in b.
698
+ for (i = 0; m = d3_interpolate_number.exec(b); ++i) {
699
+ if (m.index) s.push(b.substring(s0, s1 = m.index));
700
+ q.push({i: s.length, x: m[0]});
701
+ s.push(null);
702
+ s0 = d3_interpolate_number.lastIndex;
703
+ }
704
+ if (s0 < b.length) s.push(b.substring(s0));
705
+
706
+ // Find all numbers in a.
707
+ for (i = 0, n = q.length; (m = d3_interpolate_number.exec(a)) && i < n; ++i) {
708
+ o = q[i];
709
+ if (o.x == m[0]) { // The numbers match, so coallesce.
710
+ if (o.i) {
711
+ if (s[o.i + 1] == null) { // This match is followed by another number.
712
+ s[o.i - 1] += o.x;
713
+ s.splice(o.i, 1);
714
+ for (j = i + 1; j < n; ++j) q[j].i--;
715
+ } else { // This match is followed by a string, so coallesce twice.
716
+ s[o.i - 1] += o.x + s[o.i + 1];
717
+ s.splice(o.i, 2);
718
+ for (j = i + 1; j < n; ++j) q[j].i -= 2;
719
+ }
720
+ } else {
721
+ if (s[o.i + 1] == null) { // This match is followed by another number.
722
+ s[o.i] = o.x;
723
+ } else { // This match is followed by a string, so coallesce twice.
724
+ s[o.i] = o.x + s[o.i + 1];
725
+ s.splice(o.i + 1, 1);
726
+ for (j = i + 1; j < n; ++j) q[j].i--;
727
+ }
728
+ }
729
+ q.splice(i, 1);
730
+ n--;
731
+ i--;
732
+ } else {
733
+ o.x = d3.interpolateNumber(parseFloat(m[0]), parseFloat(o.x));
734
+ }
735
+ }
736
+
737
+ // Remove any numbers in b not found in a.
738
+ while (i < n) {
739
+ o = q.pop();
740
+ if (s[o.i + 1] == null) { // This match is followed by another number.
741
+ s[o.i] = o.x;
742
+ } else { // This match is followed by a string, so coallesce twice.
743
+ s[o.i] = o.x + s[o.i + 1];
744
+ s.splice(o.i + 1, 1);
745
+ }
746
+ n--;
747
+ }
748
+
749
+ // Special optimization for only a single match.
750
+ if (s.length === 1) {
751
+ return s[0] == null ? q[0].x : function() { return b; };
752
+ }
753
+
754
+ // Otherwise, interpolate each of the numbers and rejoin the string.
755
+ return function(t) {
756
+ for (i = 0; i < n; ++i) s[(o = q[i]).i] = o.x(t);
757
+ return s.join("");
758
+ };
759
+ };
760
+
761
+ d3.interpolateRgb = function(a, b) {
762
+ a = d3.rgb(a);
763
+ b = d3.rgb(b);
764
+ var ar = a.r,
765
+ ag = a.g,
766
+ ab = a.b,
767
+ br = b.r - ar,
768
+ bg = b.g - ag,
769
+ bb = b.b - ab;
770
+ return function(t) {
771
+ return "rgb(" + Math.round(ar + br * t)
772
+ + "," + Math.round(ag + bg * t)
773
+ + "," + Math.round(ab + bb * t)
774
+ + ")";
775
+ };
776
+ };
777
+
778
+ // interpolates HSL space, but outputs RGB string (for compatibility)
779
+ d3.interpolateHsl = function(a, b) {
780
+ a = d3.hsl(a);
781
+ b = d3.hsl(b);
782
+ var h0 = a.h,
783
+ s0 = a.s,
784
+ l0 = a.l,
785
+ h1 = b.h - h0,
786
+ s1 = b.s - s0,
787
+ l1 = b.l - l0;
788
+ return function(t) {
789
+ return d3_hsl_rgb(h0 + h1 * t, s0 + s1 * t, l0 + l1 * t).toString();
790
+ };
791
+ };
792
+
793
+ d3.interpolateArray = function(a, b) {
794
+ var x = [],
795
+ c = [],
796
+ na = a.length,
797
+ nb = b.length,
798
+ n0 = Math.min(a.length, b.length),
799
+ i;
800
+ for (i = 0; i < n0; ++i) x.push(d3.interpolate(a[i], b[i]));
801
+ for (; i < na; ++i) c[i] = a[i];
802
+ for (; i < nb; ++i) c[i] = b[i];
803
+ return function(t) {
804
+ for (i = 0; i < n0; ++i) c[i] = x[i](t);
805
+ return c;
806
+ };
807
+ };
808
+
809
+ d3.interpolateObject = function(a, b) {
810
+ var i = {},
811
+ c = {},
812
+ k;
813
+ for (k in a) {
814
+ if (k in b) {
815
+ i[k] = d3_interpolateByName(k)(a[k], b[k]);
816
+ } else {
817
+ c[k] = a[k];
818
+ }
819
+ }
820
+ for (k in b) {
821
+ if (!(k in a)) {
822
+ c[k] = b[k];
823
+ }
824
+ }
825
+ return function(t) {
826
+ for (k in i) c[k] = i[k](t);
827
+ return c;
828
+ };
829
+ }
830
+
831
+ var d3_interpolate_number = /[-+]?(?:\d+\.\d+|\d+\.|\.\d+|\d+)(?:[eE][-]?\d+)?/g,
832
+ d3_interpolate_rgb = {background: 1, fill: 1, stroke: 1};
833
+
834
+ function d3_interpolateByName(n) {
835
+ return n in d3_interpolate_rgb || /\bcolor\b/.test(n)
836
+ ? d3.interpolateRgb
837
+ : d3.interpolate;
838
+ }
839
+
840
+ d3.interpolators = [
841
+ d3.interpolateObject,
842
+ function(a, b) { return (b instanceof Array) && d3.interpolateArray(a, b); },
843
+ function(a, b) { return (typeof b === "string") && d3.interpolateString(String(a), b); },
844
+ function(a, b) { return (typeof b === "string" ? b in d3_rgb_names || /^(#|rgb\(|hsl\()/.test(b) : b instanceof d3_Rgb || b instanceof d3_Hsl) && d3.interpolateRgb(String(a), b); },
845
+ function(a, b) { return (typeof b === "number") && d3.interpolateNumber(+a, b); }
846
+ ];
847
+ function d3_uninterpolateNumber(a, b) {
848
+ b = 1 / (b - (a = +a));
849
+ return function(x) { return (x - a) * b; };
850
+ }
851
+
852
+ function d3_uninterpolateClamp(a, b) {
853
+ b = 1 / (b - (a = +a));
854
+ return function(x) { return Math.max(0, Math.min(1, (x - a) * b)); };
855
+ }
856
+ d3.rgb = function(r, g, b) {
857
+ return arguments.length === 1
858
+ ? d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb)
859
+ : d3_rgb(~~r, ~~g, ~~b);
860
+ };
861
+
862
+ function d3_rgb(r, g, b) {
863
+ return new d3_Rgb(r, g, b);
864
+ }
865
+
866
+ function d3_Rgb(r, g, b) {
867
+ this.r = r;
868
+ this.g = g;
869
+ this.b = b;
870
+ }
871
+
872
+ d3_Rgb.prototype.brighter = function(k) {
873
+ k = Math.pow(0.7, arguments.length ? k : 1);
874
+ var r = this.r,
875
+ g = this.g,
876
+ b = this.b,
877
+ i = 30;
878
+ if (!r && !g && !b) return d3_rgb(i, i, i);
879
+ if (r && r < i) r = i;
880
+ if (g && g < i) g = i;
881
+ if (b && b < i) b = i;
882
+ return d3_rgb(
883
+ Math.min(255, Math.floor(r / k)),
884
+ Math.min(255, Math.floor(g / k)),
885
+ Math.min(255, Math.floor(b / k)));
886
+ };
887
+
888
+ d3_Rgb.prototype.darker = function(k) {
889
+ k = Math.pow(0.7, arguments.length ? k : 1);
890
+ return d3_rgb(
891
+ Math.max(0, Math.floor(k * this.r)),
892
+ Math.max(0, Math.floor(k * this.g)),
893
+ Math.max(0, Math.floor(k * this.b)));
894
+ };
895
+
896
+ d3_Rgb.prototype.hsl = function() {
897
+ return d3_rgb_hsl(this.r, this.g, this.b);
898
+ };
899
+
900
+ d3_Rgb.prototype.toString = function() {
901
+ return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b);
902
+ };
903
+
904
+ function d3_rgb_hex(v) {
905
+ return v < 0x10 ? "0" + v.toString(16) : v.toString(16);
906
+ }
907
+
908
+ function d3_rgb_parse(format, rgb, hsl) {
909
+ var r = 0, // red channel; int in [0, 255]
910
+ g = 0, // green channel; int in [0, 255]
911
+ b = 0, // blue channel; int in [0, 255]
912
+ m1, // CSS color specification match
913
+ m2, // CSS color specification type (e.g., rgb)
914
+ name;
915
+
916
+ /* Handle hsl, rgb. */
917
+ m1 = /([a-z]+)\((.*)\)/i.exec(format);
918
+ if (m1) {
919
+ m2 = m1[2].split(",");
920
+ switch (m1[1]) {
921
+ case "hsl": {
922
+ return hsl(
923
+ parseFloat(m2[0]), // degrees
924
+ parseFloat(m2[1]) / 100, // percentage
925
+ parseFloat(m2[2]) / 100 // percentage
926
+ );
927
+ }
928
+ case "rgb": {
929
+ return rgb(
930
+ d3_rgb_parseNumber(m2[0]),
931
+ d3_rgb_parseNumber(m2[1]),
932
+ d3_rgb_parseNumber(m2[2])
933
+ );
934
+ }
935
+ }
936
+ }
937
+
938
+ /* Named colors. */
939
+ if (name = d3_rgb_names[format]) return rgb(name.r, name.g, name.b);
940
+
941
+ /* Hexadecimal colors: #rgb and #rrggbb. */
942
+ if (format != null && format.charAt(0) === "#") {
943
+ if (format.length === 4) {
944
+ r = format.charAt(1); r += r;
945
+ g = format.charAt(2); g += g;
946
+ b = format.charAt(3); b += b;
947
+ } else if (format.length === 7) {
948
+ r = format.substring(1, 3);
949
+ g = format.substring(3, 5);
950
+ b = format.substring(5, 7);
951
+ }
952
+ r = parseInt(r, 16);
953
+ g = parseInt(g, 16);
954
+ b = parseInt(b, 16);
955
+ }
956
+
957
+ return rgb(r, g, b);
958
+ }
959
+
960
+ function d3_rgb_hsl(r, g, b) {
961
+ var min = Math.min(r /= 255, g /= 255, b /= 255),
962
+ max = Math.max(r, g, b),
963
+ d = max - min,
964
+ h,
965
+ s,
966
+ l = (max + min) / 2;
967
+ if (d) {
968
+ s = l < .5 ? d / (max + min) : d / (2 - max - min);
969
+ if (r == max) h = (g - b) / d + (g < b ? 6 : 0);
970
+ else if (g == max) h = (b - r) / d + 2;
971
+ else h = (r - g) / d + 4;
972
+ h *= 60;
973
+ } else {
974
+ s = h = 0;
975
+ }
976
+ return d3_hsl(h, s, l);
977
+ }
978
+
979
+ function d3_rgb_parseNumber(c) { // either integer or percentage
980
+ var f = parseFloat(c);
981
+ return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f;
982
+ }
983
+
984
+ var d3_rgb_names = {
985
+ aliceblue: "#f0f8ff",
986
+ antiquewhite: "#faebd7",
987
+ aqua: "#00ffff",
988
+ aquamarine: "#7fffd4",
989
+ azure: "#f0ffff",
990
+ beige: "#f5f5dc",
991
+ bisque: "#ffe4c4",
992
+ black: "#000000",
993
+ blanchedalmond: "#ffebcd",
994
+ blue: "#0000ff",
995
+ blueviolet: "#8a2be2",
996
+ brown: "#a52a2a",
997
+ burlywood: "#deb887",
998
+ cadetblue: "#5f9ea0",
999
+ chartreuse: "#7fff00",
1000
+ chocolate: "#d2691e",
1001
+ coral: "#ff7f50",
1002
+ cornflowerblue: "#6495ed",
1003
+ cornsilk: "#fff8dc",
1004
+ crimson: "#dc143c",
1005
+ cyan: "#00ffff",
1006
+ darkblue: "#00008b",
1007
+ darkcyan: "#008b8b",
1008
+ darkgoldenrod: "#b8860b",
1009
+ darkgray: "#a9a9a9",
1010
+ darkgreen: "#006400",
1011
+ darkgrey: "#a9a9a9",
1012
+ darkkhaki: "#bdb76b",
1013
+ darkmagenta: "#8b008b",
1014
+ darkolivegreen: "#556b2f",
1015
+ darkorange: "#ff8c00",
1016
+ darkorchid: "#9932cc",
1017
+ darkred: "#8b0000",
1018
+ darksalmon: "#e9967a",
1019
+ darkseagreen: "#8fbc8f",
1020
+ darkslateblue: "#483d8b",
1021
+ darkslategray: "#2f4f4f",
1022
+ darkslategrey: "#2f4f4f",
1023
+ darkturquoise: "#00ced1",
1024
+ darkviolet: "#9400d3",
1025
+ deeppink: "#ff1493",
1026
+ deepskyblue: "#00bfff",
1027
+ dimgray: "#696969",
1028
+ dimgrey: "#696969",
1029
+ dodgerblue: "#1e90ff",
1030
+ firebrick: "#b22222",
1031
+ floralwhite: "#fffaf0",
1032
+ forestgreen: "#228b22",
1033
+ fuchsia: "#ff00ff",
1034
+ gainsboro: "#dcdcdc",
1035
+ ghostwhite: "#f8f8ff",
1036
+ gold: "#ffd700",
1037
+ goldenrod: "#daa520",
1038
+ gray: "#808080",
1039
+ green: "#008000",
1040
+ greenyellow: "#adff2f",
1041
+ grey: "#808080",
1042
+ honeydew: "#f0fff0",
1043
+ hotpink: "#ff69b4",
1044
+ indianred: "#cd5c5c",
1045
+ indigo: "#4b0082",
1046
+ ivory: "#fffff0",
1047
+ khaki: "#f0e68c",
1048
+ lavender: "#e6e6fa",
1049
+ lavenderblush: "#fff0f5",
1050
+ lawngreen: "#7cfc00",
1051
+ lemonchiffon: "#fffacd",
1052
+ lightblue: "#add8e6",
1053
+ lightcoral: "#f08080",
1054
+ lightcyan: "#e0ffff",
1055
+ lightgoldenrodyellow: "#fafad2",
1056
+ lightgray: "#d3d3d3",
1057
+ lightgreen: "#90ee90",
1058
+ lightgrey: "#d3d3d3",
1059
+ lightpink: "#ffb6c1",
1060
+ lightsalmon: "#ffa07a",
1061
+ lightseagreen: "#20b2aa",
1062
+ lightskyblue: "#87cefa",
1063
+ lightslategray: "#778899",
1064
+ lightslategrey: "#778899",
1065
+ lightsteelblue: "#b0c4de",
1066
+ lightyellow: "#ffffe0",
1067
+ lime: "#00ff00",
1068
+ limegreen: "#32cd32",
1069
+ linen: "#faf0e6",
1070
+ magenta: "#ff00ff",
1071
+ maroon: "#800000",
1072
+ mediumaquamarine: "#66cdaa",
1073
+ mediumblue: "#0000cd",
1074
+ mediumorchid: "#ba55d3",
1075
+ mediumpurple: "#9370db",
1076
+ mediumseagreen: "#3cb371",
1077
+ mediumslateblue: "#7b68ee",
1078
+ mediumspringgreen: "#00fa9a",
1079
+ mediumturquoise: "#48d1cc",
1080
+ mediumvioletred: "#c71585",
1081
+ midnightblue: "#191970",
1082
+ mintcream: "#f5fffa",
1083
+ mistyrose: "#ffe4e1",
1084
+ moccasin: "#ffe4b5",
1085
+ navajowhite: "#ffdead",
1086
+ navy: "#000080",
1087
+ oldlace: "#fdf5e6",
1088
+ olive: "#808000",
1089
+ olivedrab: "#6b8e23",
1090
+ orange: "#ffa500",
1091
+ orangered: "#ff4500",
1092
+ orchid: "#da70d6",
1093
+ palegoldenrod: "#eee8aa",
1094
+ palegreen: "#98fb98",
1095
+ paleturquoise: "#afeeee",
1096
+ palevioletred: "#db7093",
1097
+ papayawhip: "#ffefd5",
1098
+ peachpuff: "#ffdab9",
1099
+ peru: "#cd853f",
1100
+ pink: "#ffc0cb",
1101
+ plum: "#dda0dd",
1102
+ powderblue: "#b0e0e6",
1103
+ purple: "#800080",
1104
+ red: "#ff0000",
1105
+ rosybrown: "#bc8f8f",
1106
+ royalblue: "#4169e1",
1107
+ saddlebrown: "#8b4513",
1108
+ salmon: "#fa8072",
1109
+ sandybrown: "#f4a460",
1110
+ seagreen: "#2e8b57",
1111
+ seashell: "#fff5ee",
1112
+ sienna: "#a0522d",
1113
+ silver: "#c0c0c0",
1114
+ skyblue: "#87ceeb",
1115
+ slateblue: "#6a5acd",
1116
+ slategray: "#708090",
1117
+ slategrey: "#708090",
1118
+ snow: "#fffafa",
1119
+ springgreen: "#00ff7f",
1120
+ steelblue: "#4682b4",
1121
+ tan: "#d2b48c",
1122
+ teal: "#008080",
1123
+ thistle: "#d8bfd8",
1124
+ tomato: "#ff6347",
1125
+ turquoise: "#40e0d0",
1126
+ violet: "#ee82ee",
1127
+ wheat: "#f5deb3",
1128
+ white: "#ffffff",
1129
+ whitesmoke: "#f5f5f5",
1130
+ yellow: "#ffff00",
1131
+ yellowgreen: "#9acd32"
1132
+ };
1133
+
1134
+ for (var d3_rgb_name in d3_rgb_names) {
1135
+ d3_rgb_names[d3_rgb_name] = d3_rgb_parse(
1136
+ d3_rgb_names[d3_rgb_name],
1137
+ d3_rgb,
1138
+ d3_hsl_rgb);
1139
+ }
1140
+ d3.hsl = function(h, s, l) {
1141
+ return arguments.length === 1
1142
+ ? d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl)
1143
+ : d3_hsl(+h, +s, +l);
1144
+ };
1145
+
1146
+ function d3_hsl(h, s, l) {
1147
+ return new d3_Hsl(h, s, l);
1148
+ }
1149
+
1150
+ function d3_Hsl(h, s, l) {
1151
+ this.h = h;
1152
+ this.s = s;
1153
+ this.l = l;
1154
+ }
1155
+
1156
+ d3_Hsl.prototype.brighter = function(k) {
1157
+ k = Math.pow(0.7, arguments.length ? k : 1);
1158
+ return d3_hsl(this.h, this.s, this.l / k);
1159
+ };
1160
+
1161
+ d3_Hsl.prototype.darker = function(k) {
1162
+ k = Math.pow(0.7, arguments.length ? k : 1);
1163
+ return d3_hsl(this.h, this.s, k * this.l);
1164
+ };
1165
+
1166
+ d3_Hsl.prototype.rgb = function() {
1167
+ return d3_hsl_rgb(this.h, this.s, this.l);
1168
+ };
1169
+
1170
+ d3_Hsl.prototype.toString = function() {
1171
+ return "hsl(" + this.h + "," + this.s * 100 + "%," + this.l * 100 + "%)";
1172
+ };
1173
+
1174
+ function d3_hsl_rgb(h, s, l) {
1175
+ var m1,
1176
+ m2;
1177
+
1178
+ /* Some simple corrections for h, s and l. */
1179
+ h = h % 360; if (h < 0) h += 360;
1180
+ s = s < 0 ? 0 : s > 1 ? 1 : s;
1181
+ l = l < 0 ? 0 : l > 1 ? 1 : l;
1182
+
1183
+ /* From FvD 13.37, CSS Color Module Level 3 */
1184
+ m2 = l <= .5 ? l * (1 + s) : l + s - l * s;
1185
+ m1 = 2 * l - m2;
1186
+
1187
+ function v(h) {
1188
+ if (h > 360) h -= 360;
1189
+ else if (h < 0) h += 360;
1190
+ if (h < 60) return m1 + (m2 - m1) * h / 60;
1191
+ if (h < 180) return m2;
1192
+ if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60;
1193
+ return m1;
1194
+ }
1195
+
1196
+ function vv(h) {
1197
+ return Math.round(v(h) * 255);
1198
+ }
1199
+
1200
+ return d3_rgb(vv(h + 120), vv(h), vv(h - 120));
1201
+ }
1202
+ var d3_select = function(s, n) { return n.querySelector(s); },
1203
+ d3_selectAll = function(s, n) { return d3_array(n.querySelectorAll(s)); };
1204
+
1205
+ // Use Sizzle, if available.
1206
+ if (typeof Sizzle === "function") {
1207
+ d3_select = function(s, n) { return Sizzle(s, n)[0]; };
1208
+ d3_selectAll = function(s, n) { return Sizzle.uniqueSort(Sizzle(s, n)); };
1209
+ }
1210
+
1211
+ var d3_root = d3_selection([[document]]);
1212
+ d3_root[0].parentNode = document.documentElement;
1213
+
1214
+ // TODO fast singleton implementation!
1215
+ d3.select = function(selector) {
1216
+ return typeof selector === "string"
1217
+ ? d3_root.select(selector)
1218
+ : d3_selection([[selector]]); // assume node
1219
+ };
1220
+
1221
+ d3.selectAll = function(selector) {
1222
+ return typeof selector === "string"
1223
+ ? d3_root.selectAll(selector)
1224
+ : d3_selection([d3_array(selector)]); // assume node[]
1225
+ };
1226
+
1227
+ function d3_selection(groups) {
1228
+
1229
+ function select(select) {
1230
+ var subgroups = [],
1231
+ subgroup,
1232
+ subnode,
1233
+ group,
1234
+ node;
1235
+ for (var j = 0, m = groups.length; j < m; j++) {
1236
+ group = groups[j];
1237
+ subgroups.push(subgroup = []);
1238
+ subgroup.parentNode = group.parentNode;
1239
+ for (var i = 0, n = group.length; i < n; i++) {
1240
+ if (node = group[i]) {
1241
+ subgroup.push(subnode = select(node));
1242
+ if (subnode && "__data__" in node) subnode.__data__ = node.__data__;
1243
+ } else {
1244
+ subgroup.push(null);
1245
+ }
1246
+ }
1247
+ }
1248
+ return d3_selection(subgroups);
1249
+ }
1250
+
1251
+ function selectAll(selectAll) {
1252
+ var subgroups = [],
1253
+ subgroup,
1254
+ group,
1255
+ node;
1256
+ for (var j = 0, m = groups.length; j < m; j++) {
1257
+ group = groups[j];
1258
+ for (var i = 0, n = group.length; i < n; i++) {
1259
+ if (node = group[i]) {
1260
+ subgroups.push(subgroup = selectAll(node));
1261
+ subgroup.parentNode = node;
1262
+ }
1263
+ }
1264
+ }
1265
+ return d3_selection(subgroups);
1266
+ }
1267
+
1268
+ // TODO select(function)?
1269
+ groups.select = function(selector) {
1270
+ return select(function(node) {
1271
+ return d3_select(selector, node);
1272
+ });
1273
+ };
1274
+
1275
+ // TODO selectAll(function)?
1276
+ groups.selectAll = function(selector) {
1277
+ return selectAll(function(node) {
1278
+ return d3_selectAll(selector, node);
1279
+ });
1280
+ };
1281
+
1282
+ // TODO preserve null elements to maintain index?
1283
+ groups.filter = function(filter) {
1284
+ var subgroups = [],
1285
+ subgroup,
1286
+ group,
1287
+ node;
1288
+ for (var j = 0, m = groups.length; j < m; j++) {
1289
+ group = groups[j];
1290
+ subgroups.push(subgroup = []);
1291
+ subgroup.parentNode = group.parentNode;
1292
+ for (var i = 0, n = group.length; i < n; i++) {
1293
+ if ((node = group[i]) && filter.call(node, node.__data__, i)) {
1294
+ subgroup.push(node);
1295
+ }
1296
+ }
1297
+ }
1298
+ return d3_selection(subgroups);
1299
+ };
1300
+
1301
+ groups.map = function(map) {
1302
+ var group,
1303
+ node;
1304
+ for (var j = 0, m = groups.length; j < m; j++) {
1305
+ group = groups[j];
1306
+ for (var i = 0, n = group.length; i < n; i++) {
1307
+ if (node = group[i]) node.__data__ = map.call(node, node.__data__, i);
1308
+ }
1309
+ }
1310
+ return groups;
1311
+ };
1312
+
1313
+ // TODO data(null) for clearing data?
1314
+ groups.data = function(data, join) {
1315
+ var enter = [],
1316
+ update = [],
1317
+ exit = [];
1318
+
1319
+ function bind(group, groupData) {
1320
+ var i = 0,
1321
+ n = group.length,
1322
+ m = groupData.length,
1323
+ n0 = Math.min(n, m),
1324
+ n1 = Math.max(n, m),
1325
+ updateNodes = [],
1326
+ enterNodes = [],
1327
+ exitNodes = [],
1328
+ node,
1329
+ nodeData;
1330
+
1331
+ if (join) {
1332
+ var nodeByKey = {},
1333
+ keys = [],
1334
+ key,
1335
+ j = groupData.length;
1336
+
1337
+ for (i = 0; i < n; i++) {
1338
+ key = join.call(node = group[i], node.__data__, i);
1339
+ if (key in nodeByKey) {
1340
+ exitNodes[j++] = node; // duplicate key
1341
+ } else {
1342
+ nodeByKey[key] = node;
1343
+ }
1344
+ keys.push(key);
1345
+ }
1346
+
1347
+ for (i = 0; i < m; i++) {
1348
+ node = nodeByKey[key = join.call(groupData, nodeData = groupData[i], i)];
1349
+ if (node) {
1350
+ node.__data__ = nodeData;
1351
+ updateNodes[i] = node;
1352
+ enterNodes[i] = exitNodes[i] = null;
1353
+ } else {
1354
+ enterNodes[i] = d3_selection_enterNode(nodeData);
1355
+ updateNodes[i] = exitNodes[i] = null;
1356
+ }
1357
+ delete nodeByKey[key];
1358
+ }
1359
+
1360
+ for (i = 0; i < n; i++) {
1361
+ if (keys[i] in nodeByKey) {
1362
+ exitNodes[i] = group[i];
1363
+ }
1364
+ }
1365
+ } else {
1366
+ for (; i < n0; i++) {
1367
+ node = group[i];
1368
+ nodeData = groupData[i];
1369
+ if (node) {
1370
+ node.__data__ = nodeData;
1371
+ updateNodes[i] = node;
1372
+ enterNodes[i] = exitNodes[i] = null;
1373
+ } else {
1374
+ enterNodes[i] = d3_selection_enterNode(nodeData);
1375
+ updateNodes[i] = exitNodes[i] = null;
1376
+ }
1377
+ }
1378
+ for (; i < m; i++) {
1379
+ enterNodes[i] = d3_selection_enterNode(groupData[i]);
1380
+ updateNodes[i] = exitNodes[i] = null;
1381
+ }
1382
+ for (; i < n1; i++) {
1383
+ exitNodes[i] = group[i];
1384
+ enterNodes[i] = updateNodes[i] = null;
1385
+ }
1386
+ }
1387
+
1388
+ enterNodes.parentNode
1389
+ = updateNodes.parentNode
1390
+ = exitNodes.parentNode
1391
+ = group.parentNode;
1392
+
1393
+ enter.push(enterNodes);
1394
+ update.push(updateNodes);
1395
+ exit.push(exitNodes);
1396
+ }
1397
+
1398
+ var i = -1,
1399
+ n = groups.length,
1400
+ group;
1401
+ if (typeof data === "function") {
1402
+ while (++i < n) {
1403
+ bind(group = groups[i], data.call(group, group.parentNode.__data__, i));
1404
+ }
1405
+ } else {
1406
+ while (++i < n) {
1407
+ bind(group = groups[i], data);
1408
+ }
1409
+ }
1410
+
1411
+ var selection = d3_selection(update);
1412
+ selection.enter = function() {
1413
+ return d3_selectionEnter(enter);
1414
+ };
1415
+ selection.exit = function() {
1416
+ return d3_selection(exit);
1417
+ };
1418
+ return selection;
1419
+ };
1420
+
1421
+ // TODO mask forEach? or rename for eachData?
1422
+ // TODO offer the same semantics for map, reduce, etc.?
1423
+ groups.each = function(callback) {
1424
+ for (var j = 0, m = groups.length; j < m; j++) {
1425
+ var group = groups[j];
1426
+ for (var i = 0, n = group.length; i < n; i++) {
1427
+ var node = group[i];
1428
+ if (node) callback.call(node, node.__data__, i);
1429
+ }
1430
+ }
1431
+ return groups;
1432
+ };
1433
+
1434
+ function first(callback) {
1435
+ for (var j = 0, m = groups.length; j < m; j++) {
1436
+ var group = groups[j];
1437
+ for (var i = 0, n = group.length; i < n; i++) {
1438
+ var node = group[i];
1439
+ if (node) return callback.call(node, node.__data__, i);
1440
+ }
1441
+ }
1442
+ return null;
1443
+ }
1444
+
1445
+ groups.empty = function() {
1446
+ return !first(function() { return true; });
1447
+ };
1448
+
1449
+ groups.node = function() {
1450
+ return first(function() { return this; });
1451
+ };
1452
+
1453
+ groups.attr = function(name, value) {
1454
+ name = d3.ns.qualify(name);
1455
+
1456
+ // If no value is specified, return the first value.
1457
+ if (arguments.length < 2) {
1458
+ return first(name.local
1459
+ ? function() { return this.getAttributeNS(name.space, name.local); }
1460
+ : function() { return this.getAttribute(name); });
1461
+ }
1462
+
1463
+ /** @this {Element} */
1464
+ function attrNull() {
1465
+ this.removeAttribute(name);
1466
+ }
1467
+
1468
+ /** @this {Element} */
1469
+ function attrNullNS() {
1470
+ this.removeAttributeNS(name.space, name.local);
1471
+ }
1472
+
1473
+ /** @this {Element} */
1474
+ function attrConstant() {
1475
+ this.setAttribute(name, value);
1476
+ }
1477
+
1478
+ /** @this {Element} */
1479
+ function attrConstantNS() {
1480
+ this.setAttributeNS(name.space, name.local, value);
1481
+ }
1482
+
1483
+ /** @this {Element} */
1484
+ function attrFunction() {
1485
+ var x = value.apply(this, arguments);
1486
+ if (x == null) this.removeAttribute(name);
1487
+ else this.setAttribute(name, x);
1488
+ }
1489
+
1490
+ /** @this {Element} */
1491
+ function attrFunctionNS() {
1492
+ var x = value.apply(this, arguments);
1493
+ if (x == null) this.removeAttributeNS(name.space, name.local);
1494
+ else this.setAttributeNS(name.space, name.local, x);
1495
+ }
1496
+
1497
+ return groups.each(value == null
1498
+ ? (name.local ? attrNullNS : attrNull) : (typeof value === "function"
1499
+ ? (name.local ? attrFunctionNS : attrFunction)
1500
+ : (name.local ? attrConstantNS : attrConstant)));
1501
+ };
1502
+
1503
+ groups.classed = function(name, value) {
1504
+ var re = new RegExp("(^|\\s+)" + d3.requote(name) + "(\\s+|$)", "g");
1505
+
1506
+ // If no value is specified, return the first value.
1507
+ if (arguments.length < 2) {
1508
+ return first(function() {
1509
+ if (c = this.classList) return c.contains(name);
1510
+ var c = this.className;
1511
+ re.lastIndex = 0;
1512
+ return re.test(c.baseVal != null ? c.baseVal : c);
1513
+ });
1514
+ }
1515
+
1516
+ /** @this {Element} */
1517
+ function classedAdd() {
1518
+ if (c = this.classList) return c.add(name);
1519
+ var c = this.className,
1520
+ cb = c.baseVal != null,
1521
+ cv = cb ? c.baseVal : c;
1522
+ re.lastIndex = 0;
1523
+ if (!re.test(cv)) {
1524
+ cv = d3_collapse(cv + " " + name);
1525
+ if (cb) c.baseVal = cv;
1526
+ else this.className = cv;
1527
+ }
1528
+ }
1529
+
1530
+ /** @this {Element} */
1531
+ function classedRemove() {
1532
+ if (c = this.classList) return c.remove(name);
1533
+ var c = this.className,
1534
+ cb = c.baseVal != null,
1535
+ cv = cb ? c.baseVal : c;
1536
+ cv = d3_collapse(cv.replace(re, " "));
1537
+ if (cb) c.baseVal = cv;
1538
+ else this.className = cv;
1539
+ }
1540
+
1541
+ /** @this {Element} */
1542
+ function classedFunction() {
1543
+ (value.apply(this, arguments)
1544
+ ? classedAdd
1545
+ : classedRemove).call(this);
1546
+ }
1547
+
1548
+ return groups.each(typeof value === "function"
1549
+ ? classedFunction : value
1550
+ ? classedAdd
1551
+ : classedRemove);
1552
+ };
1553
+
1554
+ groups.style = function(name, value, priority) {
1555
+ if (arguments.length < 3) priority = "";
1556
+
1557
+ // If no value is specified, return the first value.
1558
+ if (arguments.length < 2) {
1559
+ return first(function() {
1560
+ return window.getComputedStyle(this, null).getPropertyValue(name);
1561
+ });
1562
+ }
1563
+
1564
+ /** @this {Element} */
1565
+ function styleNull() {
1566
+ this.style.removeProperty(name);
1567
+ }
1568
+
1569
+ /** @this {Element} */
1570
+ function styleConstant() {
1571
+ this.style.setProperty(name, value, priority);
1572
+ }
1573
+
1574
+ /** @this {Element} */
1575
+ function styleFunction() {
1576
+ var x = value.apply(this, arguments);
1577
+ if (x == null) this.style.removeProperty(name);
1578
+ else this.style.setProperty(name, x, priority);
1579
+ }
1580
+
1581
+ return groups.each(value == null
1582
+ ? styleNull : (typeof value === "function"
1583
+ ? styleFunction : styleConstant));
1584
+ };
1585
+
1586
+ groups.property = function(name, value) {
1587
+ name = d3.ns.qualify(name);
1588
+
1589
+ // If no value is specified, return the first value.
1590
+ if (arguments.length < 2) {
1591
+ return first(function() {
1592
+ return this[name];
1593
+ });
1594
+ }
1595
+
1596
+ /** @this {Element} */
1597
+ function propertyNull() {
1598
+ delete this[name];
1599
+ }
1600
+
1601
+ /** @this {Element} */
1602
+ function propertyConstant() {
1603
+ this[name] = value;
1604
+ }
1605
+
1606
+ /** @this {Element} */
1607
+ function propertyFunction() {
1608
+ var x = value.apply(this, arguments);
1609
+ if (x == null) delete this[name];
1610
+ else this[name] = x;
1611
+ }
1612
+
1613
+ return groups.each(value == null
1614
+ ? propertyNull : (typeof value === "function"
1615
+ ? propertyFunction : propertyConstant));
1616
+ };
1617
+
1618
+ groups.text = function(value) {
1619
+
1620
+ // If no value is specified, return the first value.
1621
+ if (arguments.length < 1) {
1622
+ return first(function() {
1623
+ return this.textContent;
1624
+ });
1625
+ }
1626
+
1627
+ /** @this {Element} */
1628
+ function textConstant() {
1629
+ this.textContent = value;
1630
+ }
1631
+
1632
+ /** @this {Element} */
1633
+ function textFunction() {
1634
+ this.textContent = value.apply(this, arguments);
1635
+ }
1636
+
1637
+ return groups.each(typeof value === "function"
1638
+ ? textFunction : textConstant);
1639
+ };
1640
+
1641
+ groups.html = function(value) {
1642
+
1643
+ // If no value is specified, return the first value.
1644
+ if (arguments.length < 1) {
1645
+ return first(function() {
1646
+ return this.innerHTML;
1647
+ });
1648
+ }
1649
+
1650
+ /** @this {Element} */
1651
+ function htmlConstant() {
1652
+ this.innerHTML = value;
1653
+ }
1654
+
1655
+ /** @this {Element} */
1656
+ function htmlFunction() {
1657
+ this.innerHTML = value.apply(this, arguments);
1658
+ }
1659
+
1660
+ return groups.each(typeof value === "function"
1661
+ ? htmlFunction : htmlConstant);
1662
+ };
1663
+
1664
+ // TODO append(node)?
1665
+ // TODO append(function)?
1666
+ groups.append = function(name) {
1667
+ name = d3.ns.qualify(name);
1668
+
1669
+ function append(node) {
1670
+ return node.appendChild(document.createElement(name));
1671
+ }
1672
+
1673
+ function appendNS(node) {
1674
+ return node.appendChild(document.createElementNS(name.space, name.local));
1675
+ }
1676
+
1677
+ return select(name.local ? appendNS : append);
1678
+ };
1679
+
1680
+ // TODO insert(node, function)?
1681
+ // TODO insert(function, string)?
1682
+ // TODO insert(function, function)?
1683
+ groups.insert = function(name, before) {
1684
+ name = d3.ns.qualify(name);
1685
+
1686
+ function insert(node) {
1687
+ return node.insertBefore(
1688
+ document.createElement(name),
1689
+ d3_select(before, node));
1690
+ }
1691
+
1692
+ function insertNS(node) {
1693
+ return node.insertBefore(
1694
+ document.createElementNS(name.space, name.local),
1695
+ d3_select(before, node));
1696
+ }
1697
+
1698
+ return select(name.local ? insertNS : insert);
1699
+ };
1700
+
1701
+ // TODO remove(selector)?
1702
+ // TODO remove(node)?
1703
+ // TODO remove(function)?
1704
+ groups.remove = function() {
1705
+ return groups.each(function() {
1706
+ var parent = this.parentNode;
1707
+ if (parent) parent.removeChild(this);
1708
+ });
1709
+ };
1710
+
1711
+ groups.sort = function(comparator) {
1712
+ comparator = d3_selection_comparator.apply(this, arguments);
1713
+ for (var j = 0, m = groups.length; j < m; j++) {
1714
+ var group = groups[j];
1715
+ group.sort(comparator);
1716
+ for (var i = 1, n = group.length, prev = group[0]; i < n; i++) {
1717
+ var node = group[i];
1718
+ if (node) {
1719
+ if (prev) prev.parentNode.insertBefore(node, prev.nextSibling);
1720
+ prev = node;
1721
+ }
1722
+ }
1723
+ }
1724
+ return groups;
1725
+ };
1726
+
1727
+ // type can be namespaced, e.g., "click.foo"
1728
+ // listener can be null for removal
1729
+ groups.on = function(type, listener, capture) {
1730
+ if (arguments.length < 3) capture = false;
1731
+
1732
+ // parse the type specifier
1733
+ var i = type.indexOf("."),
1734
+ typo = i === -1 ? type : type.substring(0, i),
1735
+ name = "__on" + type;
1736
+
1737
+ // remove the old event listener, and add the new event listener
1738
+ return groups.each(function(d, i) {
1739
+ if (this[name]) this.removeEventListener(typo, this[name], capture);
1740
+ if (listener) this.addEventListener(typo, this[name] = l, capture);
1741
+
1742
+ // wrapped event listener that preserves i
1743
+ var node = this;
1744
+ function l(e) {
1745
+ var o = d3.event; // Events can be reentrant (e.g., focus).
1746
+ d3.event = e;
1747
+ try {
1748
+ listener.call(this, node.__data__, i);
1749
+ } finally {
1750
+ d3.event = o;
1751
+ }
1752
+ }
1753
+ });
1754
+ };
1755
+
1756
+ // TODO slice?
1757
+
1758
+ groups.transition = function() {
1759
+ return d3_transition(groups);
1760
+ };
1761
+
1762
+ groups.call = d3_call;
1763
+
1764
+ return groups;
1765
+ }
1766
+
1767
+ function d3_selectionEnter(groups) {
1768
+
1769
+ function select(select) {
1770
+ var subgroups = [],
1771
+ subgroup,
1772
+ subnode,
1773
+ group,
1774
+ node;
1775
+ for (var j = 0, m = groups.length; j < m; j++) {
1776
+ group = groups[j];
1777
+ subgroups.push(subgroup = []);
1778
+ subgroup.parentNode = group.parentNode;
1779
+ for (var i = 0, n = group.length; i < n; i++) {
1780
+ if (node = group[i]) {
1781
+ subgroup.push(subnode = select(group.parentNode));
1782
+ subnode.__data__ = node.__data__;
1783
+ } else {
1784
+ subgroup.push(null);
1785
+ }
1786
+ }
1787
+ }
1788
+ return d3_selection(subgroups);
1789
+ }
1790
+
1791
+ // TODO append(node)?
1792
+ // TODO append(function)?
1793
+ groups.append = function(name) {
1794
+ name = d3.ns.qualify(name);
1795
+
1796
+ function append(node) {
1797
+ return node.appendChild(document.createElement(name));
1798
+ }
1799
+
1800
+ function appendNS(node) {
1801
+ return node.appendChild(document.createElementNS(name.space, name.local));
1802
+ }
1803
+
1804
+ return select(name.local ? appendNS : append);
1805
+ };
1806
+
1807
+ // TODO insert(node, function)?
1808
+ // TODO insert(function, string)?
1809
+ // TODO insert(function, function)?
1810
+ groups.insert = function(name, before) {
1811
+ name = d3.ns.qualify(name);
1812
+
1813
+ function insert(node) {
1814
+ return node.insertBefore(
1815
+ document.createElement(name),
1816
+ d3_select(before, node));
1817
+ }
1818
+
1819
+ function insertNS(node) {
1820
+ return node.insertBefore(
1821
+ document.createElementNS(name.space, name.local),
1822
+ d3_select(before, node));
1823
+ }
1824
+
1825
+ return select(name.local ? insertNS : insert);
1826
+ };
1827
+
1828
+ return groups;
1829
+ }
1830
+
1831
+ function d3_selection_comparator(comparator) {
1832
+ if (!arguments.length) comparator = d3.ascending;
1833
+ return function(a, b) {
1834
+ return comparator(a && a.__data__, b && b.__data__);
1835
+ };
1836
+ }
1837
+
1838
+ function d3_selection_enterNode(data) {
1839
+ return {__data__: data};
1840
+ }
1841
+ d3.transition = d3_root.transition;
1842
+
1843
+ var d3_transitionId = 0,
1844
+ d3_transitionInheritId = 0;
1845
+
1846
+ function d3_transition(groups) {
1847
+ var transition = {},
1848
+ transitionId = d3_transitionInheritId || ++d3_transitionId,
1849
+ tweens = {},
1850
+ interpolators = [],
1851
+ remove = false,
1852
+ event = d3.dispatch("start", "end"),
1853
+ stage = [],
1854
+ delay = [],
1855
+ duration = [],
1856
+ durationMax,
1857
+ ease = d3.ease("cubic-in-out");
1858
+
1859
+ //
1860
+ // Be careful with concurrent transitions!
1861
+ //
1862
+ // Say transition A causes an exit. Before A finishes, a transition B is
1863
+ // created, and believes it only needs to do an update, because the elements
1864
+ // haven't been removed yet (which happens at the very end of the exit
1865
+ // transition).
1866
+ //
1867
+ // Even worse, what if either transition A or B has a staggered delay? Then,
1868
+ // some elements may be removed, while others remain. Transition B does not
1869
+ // know to enter the elements because they were still present at the time
1870
+ // the transition B was created (but not yet started).
1871
+ //
1872
+ // To prevent such confusion, we only trigger end events for transitions if
1873
+ // the transition ending is the only one scheduled for the given element.
1874
+ // Similarly, we only allow one transition to be active for any given
1875
+ // element, so that concurrent transitions do not overwrite each other's
1876
+ // properties.
1877
+ //
1878
+ // TODO Support transition namespaces, so that transitions can proceed
1879
+ // concurrently on the same element if needed. Hopefully, this is rare!
1880
+ //
1881
+
1882
+ groups.each(function() {
1883
+ (this.__transition__ || (this.__transition__ = {})).owner = transitionId;
1884
+ });
1885
+
1886
+ function step(elapsed) {
1887
+ var clear = true,
1888
+ k = -1;
1889
+ groups.each(function() {
1890
+ if (stage[++k] === 2) return; // ended
1891
+ var t = (elapsed - delay[k]) / duration[k],
1892
+ tx = this.__transition__,
1893
+ te, // ease(t)
1894
+ tk, // tween key
1895
+ ik = interpolators[k];
1896
+
1897
+ // Check if the (un-eased) time is outside the range [0,1].
1898
+ if (t < 1) {
1899
+ clear = false;
1900
+ if (t < 0) return;
1901
+ } else {
1902
+ t = 1;
1903
+ }
1904
+
1905
+ // Determine the stage of this transition.
1906
+ // 0 - Not yet started.
1907
+ // 1 - In progress.
1908
+ // 2 - Ended.
1909
+ if (stage[k]) {
1910
+ if (!tx || tx.active !== transitionId) {
1911
+ stage[k] = 2;
1912
+ return;
1913
+ }
1914
+ } else if (!tx || tx.active > transitionId) {
1915
+ stage[k] = 2;
1916
+ return;
1917
+ } else {
1918
+ stage[k] = 1;
1919
+ event.start.dispatch.apply(this, arguments);
1920
+ ik = interpolators[k] = {};
1921
+ tx.active = transitionId;
1922
+ for (tk in tweens) {
1923
+ if (te = tweens[tk].apply(this, arguments)) {
1924
+ ik[tk] = te;
1925
+ }
1926
+ }
1927
+ }
1928
+
1929
+ // Apply the interpolators!
1930
+ te = ease(t);
1931
+ for (tk in ik) ik[tk].call(this, te);
1932
+
1933
+ // Handle ending transitions.
1934
+ if (t === 1) {
1935
+ stage[k] = 2;
1936
+ if (tx.active === transitionId) {
1937
+ var owner = tx.owner;
1938
+ if (owner === transitionId) {
1939
+ delete this.__transition__;
1940
+ if (remove && this.parentNode) this.parentNode.removeChild(this);
1941
+ }
1942
+ d3_transitionInheritId = transitionId;
1943
+ event.end.dispatch.apply(this, arguments);
1944
+ d3_transitionInheritId = 0;
1945
+ tx.owner = owner;
1946
+ }
1947
+ }
1948
+ });
1949
+ return clear;
1950
+ }
1951
+
1952
+ transition.delay = function(value) {
1953
+ var delayMin = Infinity,
1954
+ k = -1;
1955
+ if (typeof value === "function") {
1956
+ groups.each(function(d, i) {
1957
+ var x = delay[++k] = +value.apply(this, arguments);
1958
+ if (x < delayMin) delayMin = x;
1959
+ });
1960
+ } else {
1961
+ delayMin = +value;
1962
+ groups.each(function(d, i) {
1963
+ delay[++k] = delayMin;
1964
+ });
1965
+ }
1966
+ d3_timer(step, delayMin);
1967
+ return transition;
1968
+ };
1969
+
1970
+ transition.duration = function(value) {
1971
+ var k = -1;
1972
+ if (typeof value === "function") {
1973
+ durationMax = 0;
1974
+ groups.each(function(d, i) {
1975
+ var x = duration[++k] = +value.apply(this, arguments);
1976
+ if (x > durationMax) durationMax = x;
1977
+ });
1978
+ } else {
1979
+ durationMax = +value;
1980
+ groups.each(function(d, i) {
1981
+ duration[++k] = durationMax;
1982
+ });
1983
+ }
1984
+ return transition;
1985
+ };
1986
+
1987
+ transition.ease = function(value) {
1988
+ ease = typeof value === "function" ? value : d3.ease.apply(d3, arguments);
1989
+ return transition;
1990
+ };
1991
+
1992
+ transition.attrTween = function(name, tween) {
1993
+
1994
+ /** @this {Element} */
1995
+ function attrTween(d, i) {
1996
+ var f = tween.call(this, d, i, this.getAttribute(name));
1997
+ return f && function(t) {
1998
+ this.setAttribute(name, f(t));
1999
+ };
2000
+ }
2001
+
2002
+ /** @this {Element} */
2003
+ function attrTweenNS(d, i) {
2004
+ var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local));
2005
+ return f && function(t) {
2006
+ this.setAttributeNS(name.space, name.local, f(t));
2007
+ };
2008
+ }
2009
+
2010
+ tweens["attr." + name] = name.local ? attrTweenNS : attrTween;
2011
+ return transition;
2012
+ };
2013
+
2014
+ transition.attr = function(name, value) {
2015
+ return transition.attrTween(name, d3_transitionTween(value));
2016
+ };
2017
+
2018
+ transition.styleTween = function(name, tween, priority) {
2019
+ if (arguments.length < 3) priority = null;
2020
+
2021
+ /** @this {Element} */
2022
+ function styleTween(d, i) {
2023
+ var f = tween.call(this, d, i, window.getComputedStyle(this, null).getPropertyValue(name));
2024
+ return f && function(t) {
2025
+ this.style.setProperty(name, f(t), priority);
2026
+ };
2027
+ }
2028
+
2029
+ tweens["style." + name] = styleTween;
2030
+ return transition;
2031
+ };
2032
+
2033
+ transition.style = function(name, value, priority) {
2034
+ if (arguments.length < 3) priority = null;
2035
+ return transition.styleTween(name, d3_transitionTween(value), priority);
2036
+ };
2037
+
2038
+ transition.text = function(value) {
2039
+ tweens.text = function(d, i) {
2040
+ this.textContent = typeof value === "function"
2041
+ ? value.call(this, d, i)
2042
+ : value;
2043
+ };
2044
+ return transition;
2045
+ };
2046
+
2047
+ transition.select = function(query) {
2048
+ var k, t = d3_transition(groups.select(query)).ease(ease);
2049
+ k = -1; t.delay(function(d, i) { return delay[++k]; });
2050
+ k = -1; t.duration(function(d, i) { return duration[++k]; });
2051
+ return t;
2052
+ };
2053
+
2054
+ transition.selectAll = function(query) {
2055
+ var k, t = d3_transition(groups.selectAll(query)).ease(ease);
2056
+ k = -1; t.delay(function(d, i) { return delay[i ? k : ++k]; })
2057
+ k = -1; t.duration(function(d, i) { return duration[i ? k : ++k]; });
2058
+ return t;
2059
+ };
2060
+
2061
+ transition.remove = function() {
2062
+ remove = true;
2063
+ return transition;
2064
+ };
2065
+
2066
+ transition.each = function(type, listener) {
2067
+ event[type].add(listener);
2068
+ return transition;
2069
+ };
2070
+
2071
+ transition.call = d3_call;
2072
+
2073
+ return transition.delay(0).duration(250);
2074
+ }
2075
+
2076
+ function d3_transitionTween(b) {
2077
+ return typeof b === "function"
2078
+ ? function(d, i, a) { var v = b.call(this, d, i) + ""; return a != v && d3.interpolate(a, v); }
2079
+ : (b = b + "", function(d, i, a) { return a != b && d3.interpolate(a, b); });
2080
+ }
2081
+ var d3_timer_queue = null,
2082
+ d3_timer_interval, // is an interval (or frame) active?
2083
+ d3_timer_timeout; // is a timeout active?
2084
+
2085
+ // The timer will continue to fire until callback returns true.
2086
+ d3.timer = function(callback) {
2087
+ d3_timer(callback, 0);
2088
+ };
2089
+
2090
+ function d3_timer(callback, delay) {
2091
+ var now = Date.now(),
2092
+ found = false,
2093
+ t0,
2094
+ t1 = d3_timer_queue;
2095
+
2096
+ if (!isFinite(delay)) return;
2097
+
2098
+ // See if the callback's already in the queue.
2099
+ while (t1) {
2100
+ if (t1.callback === callback) {
2101
+ t1.then = now;
2102
+ t1.delay = delay;
2103
+ found = true;
2104
+ break;
2105
+ }
2106
+ t0 = t1;
2107
+ t1 = t1.next;
2108
+ }
2109
+
2110
+ // Otherwise, add the callback to the queue.
2111
+ if (!found) d3_timer_queue = {
2112
+ callback: callback,
2113
+ then: now,
2114
+ delay: delay,
2115
+ next: d3_timer_queue
2116
+ };
2117
+
2118
+ // Start animatin'!
2119
+ if (!d3_timer_interval) {
2120
+ d3_timer_timeout = clearTimeout(d3_timer_timeout);
2121
+ d3_timer_interval = 1;
2122
+ d3_timer_frame(d3_timer_step);
2123
+ }
2124
+ }
2125
+
2126
+ function d3_timer_step() {
2127
+ var elapsed,
2128
+ now = Date.now(),
2129
+ t1 = d3_timer_queue;
2130
+
2131
+ while (t1) {
2132
+ elapsed = now - t1.then;
2133
+ if (elapsed > t1.delay) t1.flush = t1.callback(elapsed);
2134
+ t1 = t1.next;
2135
+ }
2136
+
2137
+ var delay = d3_timer_flush() - now;
2138
+ if (delay > 24) {
2139
+ if (isFinite(delay)) {
2140
+ clearTimeout(d3_timer_timeout);
2141
+ d3_timer_timeout = setTimeout(d3_timer_step, delay);
2142
+ }
2143
+ d3_timer_interval = 0;
2144
+ } else {
2145
+ d3_timer_interval = 1;
2146
+ d3_timer_frame(d3_timer_step);
2147
+ }
2148
+ }
2149
+
2150
+ d3.timer.flush = function() {
2151
+ var elapsed,
2152
+ now = Date.now(),
2153
+ t1 = d3_timer_queue;
2154
+
2155
+ while (t1) {
2156
+ elapsed = now - t1.then;
2157
+ if (!t1.delay) t1.flush = t1.callback(elapsed);
2158
+ t1 = t1.next;
2159
+ }
2160
+
2161
+ d3_timer_flush();
2162
+ };
2163
+
2164
+ // Flush after callbacks, to avoid concurrent queue modification.
2165
+ function d3_timer_flush() {
2166
+ var t0 = null,
2167
+ t1 = d3_timer_queue,
2168
+ then = Infinity;
2169
+ while (t1) {
2170
+ if (t1.flush) {
2171
+ t1 = t0 ? t0.next = t1.next : d3_timer_queue = t1.next;
2172
+ } else {
2173
+ then = Math.min(then, t1.then + t1.delay);
2174
+ t1 = (t0 = t1).next;
2175
+ }
2176
+ }
2177
+ return then;
2178
+ }
2179
+
2180
+ var d3_timer_frame = window.requestAnimationFrame
2181
+ || window.webkitRequestAnimationFrame
2182
+ || window.mozRequestAnimationFrame
2183
+ || window.oRequestAnimationFrame
2184
+ || window.msRequestAnimationFrame
2185
+ || function(callback) { setTimeout(callback, 17); };
2186
+ function d3_noop() {}
2187
+ d3.scale = {};
2188
+
2189
+ function d3_scaleExtent(domain) {
2190
+ var start = domain[0], stop = domain[domain.length - 1];
2191
+ return start < stop ? [start, stop] : [stop, start];
2192
+ }
2193
+ function d3_scale_nice(domain, nice) {
2194
+ var i0 = 0,
2195
+ i1 = domain.length - 1,
2196
+ x0 = domain[i0],
2197
+ x1 = domain[i1],
2198
+ dx;
2199
+
2200
+ if (x1 < x0) {
2201
+ dx = i0; i0 = i1; i1 = dx;
2202
+ dx = x0; x0 = x1; x1 = dx;
2203
+ }
2204
+
2205
+ nice = nice(x1 - x0);
2206
+ domain[i0] = nice.floor(x0);
2207
+ domain[i1] = nice.ceil(x1);
2208
+ return domain;
2209
+ }
2210
+
2211
+ function d3_scale_niceDefault() {
2212
+ return Math;
2213
+ }
2214
+ d3.scale.linear = function() {
2215
+ var domain = [0, 1],
2216
+ range = [0, 1],
2217
+ interpolate = d3.interpolate,
2218
+ clamp = false,
2219
+ output,
2220
+ input;
2221
+
2222
+ function rescale() {
2223
+ var linear = domain.length == 2 ? d3_scale_bilinear : d3_scale_polylinear,
2224
+ uninterpolate = clamp ? d3_uninterpolateClamp : d3_uninterpolateNumber;
2225
+ output = linear(domain, range, uninterpolate, interpolate);
2226
+ input = linear(range, domain, uninterpolate, d3.interpolate);
2227
+ return scale;
2228
+ }
2229
+
2230
+ function scale(x) {
2231
+ return output(x);
2232
+ }
2233
+
2234
+ // Note: requires range is coercible to number!
2235
+ scale.invert = function(y) {
2236
+ return input(y);
2237
+ };
2238
+
2239
+ scale.domain = function(x) {
2240
+ if (!arguments.length) return domain;
2241
+ domain = x.map(Number);
2242
+ return rescale();
2243
+ };
2244
+
2245
+ scale.range = function(x) {
2246
+ if (!arguments.length) return range;
2247
+ range = x;
2248
+ return rescale();
2249
+ };
2250
+
2251
+ scale.rangeRound = function(x) {
2252
+ return scale.range(x).interpolate(d3.interpolateRound);
2253
+ };
2254
+
2255
+ scale.clamp = function(x) {
2256
+ if (!arguments.length) return clamp;
2257
+ clamp = x;
2258
+ return rescale();
2259
+ };
2260
+
2261
+ scale.interpolate = function(x) {
2262
+ if (!arguments.length) return interpolate;
2263
+ interpolate = x;
2264
+ return rescale();
2265
+ };
2266
+
2267
+ scale.ticks = function(m) {
2268
+ return d3_scale_linearTicks(domain, m);
2269
+ };
2270
+
2271
+ scale.tickFormat = function(m) {
2272
+ return d3_scale_linearTickFormat(domain, m);
2273
+ };
2274
+
2275
+ scale.nice = function() {
2276
+ d3_scale_nice(domain, d3_scale_linearNice);
2277
+ return rescale();
2278
+ };
2279
+
2280
+ return rescale();
2281
+ };
2282
+
2283
+ function d3_scale_linearRebind(scale, linear) {
2284
+ scale.range = d3.rebind(scale, linear.range);
2285
+ scale.rangeRound = d3.rebind(scale, linear.rangeRound);
2286
+ scale.interpolate = d3.rebind(scale, linear.interpolate);
2287
+ scale.clamp = d3.rebind(scale, linear.clamp);
2288
+ return scale;
2289
+ }
2290
+
2291
+ function d3_scale_linearNice(dx) {
2292
+ dx = Math.pow(10, Math.round(Math.log(dx) / Math.LN10) - 1);
2293
+ return {
2294
+ floor: function(x) { return Math.floor(x / dx) * dx; },
2295
+ ceil: function(x) { return Math.ceil(x / dx) * dx; }
2296
+ };
2297
+ }
2298
+
2299
+ // TODO Dates? Ugh.
2300
+ function d3_scale_linearTickRange(domain, m) {
2301
+ var extent = d3_scaleExtent(domain),
2302
+ span = extent[1] - extent[0],
2303
+ step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)),
2304
+ err = m / span * step;
2305
+
2306
+ // Filter ticks to get closer to the desired count.
2307
+ if (err <= .15) step *= 10;
2308
+ else if (err <= .35) step *= 5;
2309
+ else if (err <= .75) step *= 2;
2310
+
2311
+ // Round start and stop values to step interval.
2312
+ extent[0] = Math.ceil(extent[0] / step) * step;
2313
+ extent[1] = Math.floor(extent[1] / step) * step + step * .5; // inclusive
2314
+ extent[2] = step;
2315
+ return extent;
2316
+ }
2317
+
2318
+ function d3_scale_linearTicks(domain, m) {
2319
+ return d3.range.apply(d3, d3_scale_linearTickRange(domain, m));
2320
+ }
2321
+
2322
+ function d3_scale_linearTickFormat(domain, m) {
2323
+ return d3.format(",." + Math.max(0, -Math.floor(Math.log(d3_scale_linearTickRange(domain, m)[2]) / Math.LN10 + .01)) + "f");
2324
+ }
2325
+ function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
2326
+ var u = uninterpolate(domain[0], domain[1]),
2327
+ i = interpolate(range[0], range[1]);
2328
+ return function(x) {
2329
+ return i(u(x));
2330
+ };
2331
+ }
2332
+ function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
2333
+ var u = [],
2334
+ i = [],
2335
+ j = 0,
2336
+ n = domain.length;
2337
+
2338
+ while (++j < n) {
2339
+ u.push(uninterpolate(domain[j - 1], domain[j]));
2340
+ i.push(interpolate(range[j - 1], range[j]));
2341
+ }
2342
+
2343
+ return function(x) {
2344
+ var j = d3.bisect(domain, x, 1, domain.length - 1) - 1;
2345
+ return i[j](u[j](x));
2346
+ };
2347
+ }
2348
+ d3.scale.log = function() {
2349
+ var linear = d3.scale.linear(),
2350
+ log = d3_scale_log,
2351
+ pow = log.pow;
2352
+
2353
+ function scale(x) {
2354
+ return linear(log(x));
2355
+ }
2356
+
2357
+ scale.invert = function(x) {
2358
+ return pow(linear.invert(x));
2359
+ };
2360
+
2361
+ scale.domain = function(x) {
2362
+ if (!arguments.length) return linear.domain().map(pow);
2363
+ log = x[0] < 0 ? d3_scale_logn : d3_scale_log;
2364
+ pow = log.pow;
2365
+ linear.domain(x.map(log));
2366
+ return scale;
2367
+ };
2368
+
2369
+ scale.nice = function() {
2370
+ linear.domain(d3_scale_nice(linear.domain(), d3_scale_niceDefault));
2371
+ return scale;
2372
+ };
2373
+
2374
+ scale.ticks = function() {
2375
+ var extent = d3_scaleExtent(linear.domain()),
2376
+ ticks = [];
2377
+ if (extent.every(isFinite)) {
2378
+ var i = Math.floor(extent[0]),
2379
+ j = Math.ceil(extent[1]),
2380
+ u = pow(extent[0]),
2381
+ v = pow(extent[1]);
2382
+ if (log === d3_scale_logn) {
2383
+ ticks.push(pow(i));
2384
+ for (; i++ < j;) for (var k = 9; k > 0; k--) ticks.push(pow(i) * k);
2385
+ } else {
2386
+ for (; i < j; i++) for (var k = 1; k < 10; k++) ticks.push(pow(i) * k);
2387
+ ticks.push(pow(i));
2388
+ }
2389
+ for (i = 0; ticks[i] < u; i++) {} // strip small values
2390
+ for (j = ticks.length; ticks[j - 1] > v; j--) {} // strip big values
2391
+ ticks = ticks.slice(i, j);
2392
+ }
2393
+ return ticks;
2394
+ };
2395
+
2396
+ scale.tickFormat = function() {
2397
+ return d3_scale_logTickFormat;
2398
+ };
2399
+
2400
+ return d3_scale_linearRebind(scale, linear);
2401
+ };
2402
+
2403
+ function d3_scale_log(x) {
2404
+ return Math.log(x) / Math.LN10;
2405
+ }
2406
+
2407
+ function d3_scale_logn(x) {
2408
+ return -Math.log(-x) / Math.LN10;
2409
+ }
2410
+
2411
+ d3_scale_log.pow = function(x) {
2412
+ return Math.pow(10, x);
2413
+ };
2414
+
2415
+ d3_scale_logn.pow = function(x) {
2416
+ return -Math.pow(10, -x);
2417
+ };
2418
+
2419
+ function d3_scale_logTickFormat(d) {
2420
+ return d.toPrecision(1);
2421
+ }
2422
+ d3.scale.pow = function() {
2423
+ var linear = d3.scale.linear(),
2424
+ exponent = 1,
2425
+ powp = Number,
2426
+ powb = powp;
2427
+
2428
+ function scale(x) {
2429
+ return linear(powp(x));
2430
+ }
2431
+
2432
+ scale.invert = function(x) {
2433
+ return powb(linear.invert(x));
2434
+ };
2435
+
2436
+ scale.domain = function(x) {
2437
+ if (!arguments.length) return linear.domain().map(powb);
2438
+ powp = d3_scale_powPow(exponent);
2439
+ powb = d3_scale_powPow(1 / exponent);
2440
+ linear.domain(x.map(powp));
2441
+ return scale;
2442
+ };
2443
+
2444
+ scale.ticks = function(m) {
2445
+ return d3_scale_linearTicks(scale.domain(), m);
2446
+ };
2447
+
2448
+ scale.tickFormat = function(m) {
2449
+ return d3_scale_linearTickFormat(scale.domain(), m);
2450
+ };
2451
+
2452
+ scale.nice = function() {
2453
+ return scale.domain(d3_scale_nice(scale.domain(), d3_scale_linearNice));
2454
+ };
2455
+
2456
+ scale.exponent = function(x) {
2457
+ if (!arguments.length) return exponent;
2458
+ var domain = scale.domain();
2459
+ exponent = x;
2460
+ return scale.domain(domain);
2461
+ };
2462
+
2463
+ return d3_scale_linearRebind(scale, linear);
2464
+ };
2465
+
2466
+ function d3_scale_powPow(e) {
2467
+ return function(x) {
2468
+ return x < 0 ? -Math.pow(-x, e) : Math.pow(x, e);
2469
+ };
2470
+ }
2471
+ d3.scale.sqrt = function() {
2472
+ return d3.scale.pow().exponent(.5);
2473
+ };
2474
+ d3.scale.ordinal = function() {
2475
+ var domain = [],
2476
+ index = {},
2477
+ range = [],
2478
+ rangeBand = 0,
2479
+ rerange = d3_noop;
2480
+
2481
+ function scale(x) {
2482
+ var i = x in index ? index[x] : (index[x] = domain.push(x) - 1);
2483
+ return range[i % range.length];
2484
+ }
2485
+
2486
+ scale.domain = function(x) {
2487
+ if (!arguments.length) return domain;
2488
+ domain = x;
2489
+ index = {};
2490
+ var i = -1, j = -1, n = domain.length; while (++i < n) {
2491
+ x = domain[i];
2492
+ if (!(x in index)) index[x] = ++j;
2493
+ }
2494
+ rerange();
2495
+ return scale;
2496
+ };
2497
+
2498
+ scale.range = function(x) {
2499
+ if (!arguments.length) return range;
2500
+ range = x;
2501
+ rerange = d3_noop;
2502
+ return scale;
2503
+ };
2504
+
2505
+ scale.rangePoints = function(x, padding) {
2506
+ if (arguments.length < 2) padding = 0;
2507
+ (rerange = function() {
2508
+ var start = x[0],
2509
+ stop = x[1],
2510
+ step = (stop - start) / (domain.length - 1 + padding);
2511
+ range = domain.length == 1
2512
+ ? [(start + stop) / 2]
2513
+ : d3.range(start + step * padding / 2, stop + step / 2, step);
2514
+ rangeBand = 0;
2515
+ })();
2516
+ return scale;
2517
+ };
2518
+
2519
+ scale.rangeBands = function(x, padding) {
2520
+ if (arguments.length < 2) padding = 0;
2521
+ (rerange = function() {
2522
+ var start = x[0],
2523
+ stop = x[1],
2524
+ step = (stop - start) / (domain.length + padding);
2525
+ range = d3.range(start + step * padding, stop, step);
2526
+ rangeBand = step * (1 - padding);
2527
+ })();
2528
+ return scale;
2529
+ };
2530
+
2531
+ scale.rangeRoundBands = function(x, padding) {
2532
+ if (arguments.length < 2) padding = 0;
2533
+ (rerange = function() {
2534
+ var start = x[0],
2535
+ stop = x[1],
2536
+ diff = stop - start,
2537
+ step = Math.floor(diff / (domain.length + padding)),
2538
+ err = diff - (domain.length - padding) * step;
2539
+ range = d3.range(start + Math.round(err / 2), stop, step);
2540
+ rangeBand = Math.round(step * (1 - padding));
2541
+ })();
2542
+ return scale;
2543
+ };
2544
+
2545
+ scale.rangeBand = function() {
2546
+ return rangeBand;
2547
+ };
2548
+
2549
+ return scale;
2550
+ };
2551
+ /*
2552
+ * This product includes color specifications and designs developed by Cynthia
2553
+ * Brewer (http://colorbrewer.org/). See lib/colorbrewer for more information.
2554
+ */
2555
+
2556
+ d3.scale.category10 = function() {
2557
+ return d3.scale.ordinal().range(d3_category10);
2558
+ };
2559
+
2560
+ d3.scale.category20 = function() {
2561
+ return d3.scale.ordinal().range(d3_category20);
2562
+ };
2563
+
2564
+ d3.scale.category20b = function() {
2565
+ return d3.scale.ordinal().range(d3_category20b);
2566
+ };
2567
+
2568
+ d3.scale.category20c = function() {
2569
+ return d3.scale.ordinal().range(d3_category20c);
2570
+ };
2571
+
2572
+ var d3_category10 = [
2573
+ "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
2574
+ "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"
2575
+ ];
2576
+
2577
+ var d3_category20 = [
2578
+ "#1f77b4", "#aec7e8",
2579
+ "#ff7f0e", "#ffbb78",
2580
+ "#2ca02c", "#98df8a",
2581
+ "#d62728", "#ff9896",
2582
+ "#9467bd", "#c5b0d5",
2583
+ "#8c564b", "#c49c94",
2584
+ "#e377c2", "#f7b6d2",
2585
+ "#7f7f7f", "#c7c7c7",
2586
+ "#bcbd22", "#dbdb8d",
2587
+ "#17becf", "#9edae5"
2588
+ ];
2589
+
2590
+ var d3_category20b = [
2591
+ "#393b79", "#5254a3", "#6b6ecf", "#9c9ede",
2592
+ "#637939", "#8ca252", "#b5cf6b", "#cedb9c",
2593
+ "#8c6d31", "#bd9e39", "#e7ba52", "#e7cb94",
2594
+ "#843c39", "#ad494a", "#d6616b", "#e7969c",
2595
+ "#7b4173", "#a55194", "#ce6dbd", "#de9ed6"
2596
+ ];
2597
+
2598
+ var d3_category20c = [
2599
+ "#3182bd", "#6baed6", "#9ecae1", "#c6dbef",
2600
+ "#e6550d", "#fd8d3c", "#fdae6b", "#fdd0a2",
2601
+ "#31a354", "#74c476", "#a1d99b", "#c7e9c0",
2602
+ "#756bb1", "#9e9ac8", "#bcbddc", "#dadaeb",
2603
+ "#636363", "#969696", "#bdbdbd", "#d9d9d9"
2604
+ ];
2605
+ d3.scale.quantile = function() {
2606
+ var domain = [],
2607
+ range = [],
2608
+ thresholds = [];
2609
+
2610
+ function rescale() {
2611
+ var k = 0,
2612
+ n = domain.length,
2613
+ q = range.length;
2614
+ thresholds.length = Math.max(0, q - 1);
2615
+ while (++k < q) thresholds[k - 1] = d3.quantile(domain, k / q);
2616
+ }
2617
+
2618
+ function scale(x) {
2619
+ if (isNaN(x = +x)) return NaN;
2620
+ return range[d3.bisect(thresholds, x)];
2621
+ }
2622
+
2623
+ scale.domain = function(x) {
2624
+ if (!arguments.length) return domain;
2625
+ domain = x.filter(function(d) { return !isNaN(d); }).sort(d3.ascending);
2626
+ rescale();
2627
+ return scale;
2628
+ };
2629
+
2630
+ scale.range = function(x) {
2631
+ if (!arguments.length) return range;
2632
+ range = x;
2633
+ rescale();
2634
+ return scale;
2635
+ };
2636
+
2637
+ scale.quantiles = function() {
2638
+ return thresholds;
2639
+ };
2640
+
2641
+ return scale;
2642
+ };
2643
+ d3.scale.quantize = function() {
2644
+ var x0 = 0,
2645
+ x1 = 1,
2646
+ kx = 2,
2647
+ i = 1,
2648
+ range = [0, 1];
2649
+
2650
+ function scale(x) {
2651
+ return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))];
2652
+ }
2653
+
2654
+ scale.domain = function(x) {
2655
+ if (!arguments.length) return [x0, x1];
2656
+ x0 = x[0];
2657
+ x1 = x[1];
2658
+ kx = range.length / (x1 - x0);
2659
+ return scale;
2660
+ };
2661
+
2662
+ scale.range = function(x) {
2663
+ if (!arguments.length) return range;
2664
+ range = x;
2665
+ kx = range.length / (x1 - x0);
2666
+ i = range.length - 1;
2667
+ return scale;
2668
+ };
2669
+
2670
+ return scale;
2671
+ };
2672
+ d3.svg = {};
2673
+ d3.svg.arc = function() {
2674
+ var innerRadius = d3_svg_arcInnerRadius,
2675
+ outerRadius = d3_svg_arcOuterRadius,
2676
+ startAngle = d3_svg_arcStartAngle,
2677
+ endAngle = d3_svg_arcEndAngle;
2678
+
2679
+ function arc() {
2680
+ var r0 = innerRadius.apply(this, arguments),
2681
+ r1 = outerRadius.apply(this, arguments),
2682
+ a0 = startAngle.apply(this, arguments) + d3_svg_arcOffset,
2683
+ a1 = endAngle.apply(this, arguments) + d3_svg_arcOffset,
2684
+ da = a1 - a0,
2685
+ df = da < Math.PI ? "0" : "1",
2686
+ c0 = Math.cos(a0),
2687
+ s0 = Math.sin(a0),
2688
+ c1 = Math.cos(a1),
2689
+ s1 = Math.sin(a1);
2690
+ return da >= d3_svg_arcMax
2691
+ ? (r0
2692
+ ? "M0," + r1
2693
+ + "A" + r1 + "," + r1 + " 0 1,1 0," + (-r1)
2694
+ + "A" + r1 + "," + r1 + " 0 1,1 0," + r1
2695
+ + "M0," + r0
2696
+ + "A" + r0 + "," + r0 + " 0 1,1 0," + (-r0)
2697
+ + "A" + r0 + "," + r0 + " 0 1,1 0," + r0
2698
+ + "Z"
2699
+ : "M0," + r1
2700
+ + "A" + r1 + "," + r1 + " 0 1,1 0," + (-r1)
2701
+ + "A" + r1 + "," + r1 + " 0 1,1 0," + r1
2702
+ + "Z")
2703
+ : (r0
2704
+ ? "M" + r1 * c0 + "," + r1 * s0
2705
+ + "A" + r1 + "," + r1 + " 0 " + df + ",1 " + r1 * c1 + "," + r1 * s1
2706
+ + "L" + r0 * c1 + "," + r0 * s1
2707
+ + "A" + r0 + "," + r0 + " 0 " + df + ",0 " + r0 * c0 + "," + r0 * s0
2708
+ + "Z"
2709
+ : "M" + r1 * c0 + "," + r1 * s0
2710
+ + "A" + r1 + "," + r1 + " 0 " + df + ",1 " + r1 * c1 + "," + r1 * s1
2711
+ + "L0,0"
2712
+ + "Z");
2713
+ }
2714
+
2715
+ arc.innerRadius = function(v) {
2716
+ if (!arguments.length) return innerRadius;
2717
+ innerRadius = d3.functor(v);
2718
+ return arc;
2719
+ };
2720
+
2721
+ arc.outerRadius = function(v) {
2722
+ if (!arguments.length) return outerRadius;
2723
+ outerRadius = d3.functor(v);
2724
+ return arc;
2725
+ };
2726
+
2727
+ arc.startAngle = function(v) {
2728
+ if (!arguments.length) return startAngle;
2729
+ startAngle = d3.functor(v);
2730
+ return arc;
2731
+ };
2732
+
2733
+ arc.endAngle = function(v) {
2734
+ if (!arguments.length) return endAngle;
2735
+ endAngle = d3.functor(v);
2736
+ return arc;
2737
+ };
2738
+
2739
+ arc.centroid = function() {
2740
+ var r = (innerRadius.apply(this, arguments)
2741
+ + outerRadius.apply(this, arguments)) / 2,
2742
+ a = (startAngle.apply(this, arguments)
2743
+ + endAngle.apply(this, arguments)) / 2 + d3_svg_arcOffset;
2744
+ return [Math.cos(a) * r, Math.sin(a) * r];
2745
+ };
2746
+
2747
+ return arc;
2748
+ };
2749
+
2750
+ var d3_svg_arcOffset = -Math.PI / 2,
2751
+ d3_svg_arcMax = 2 * Math.PI - 1e-6;
2752
+
2753
+ function d3_svg_arcInnerRadius(d) {
2754
+ return d.innerRadius;
2755
+ }
2756
+
2757
+ function d3_svg_arcOuterRadius(d) {
2758
+ return d.outerRadius;
2759
+ }
2760
+
2761
+ function d3_svg_arcStartAngle(d) {
2762
+ return d.startAngle;
2763
+ }
2764
+
2765
+ function d3_svg_arcEndAngle(d) {
2766
+ return d.endAngle;
2767
+ }
2768
+ function d3_svg_line(projection) {
2769
+ var x = d3_svg_lineX,
2770
+ y = d3_svg_lineY,
2771
+ interpolate = "linear",
2772
+ interpolator = d3_svg_lineInterpolators[interpolate],
2773
+ tension = .7;
2774
+
2775
+ function line(d) {
2776
+ return d.length < 1 ? null : "M" + interpolator(projection(d3_svg_linePoints(this, d, x, y)), tension);
2777
+ }
2778
+
2779
+ line.x = function(v) {
2780
+ if (!arguments.length) return x;
2781
+ x = v;
2782
+ return line;
2783
+ };
2784
+
2785
+ line.y = function(v) {
2786
+ if (!arguments.length) return y;
2787
+ y = v;
2788
+ return line;
2789
+ };
2790
+
2791
+ line.interpolate = function(v) {
2792
+ if (!arguments.length) return interpolate;
2793
+ interpolator = d3_svg_lineInterpolators[interpolate = v];
2794
+ return line;
2795
+ };
2796
+
2797
+ line.tension = function(v) {
2798
+ if (!arguments.length) return tension;
2799
+ tension = v;
2800
+ return line;
2801
+ };
2802
+
2803
+ return line;
2804
+ }
2805
+
2806
+ d3.svg.line = function() {
2807
+ return d3_svg_line(Object);
2808
+ };
2809
+
2810
+ // Converts the specified array of data into an array of points
2811
+ // (x-y tuples), by evaluating the specified `x` and `y` functions on each
2812
+ // data point. The `this` context of the evaluated functions is the specified
2813
+ // "self" object; each function is passed the current datum and index.
2814
+ function d3_svg_linePoints(self, d, x, y) {
2815
+ var points = [],
2816
+ i = -1,
2817
+ n = d.length,
2818
+ fx = typeof x === "function",
2819
+ fy = typeof y === "function",
2820
+ value;
2821
+ if (fx && fy) {
2822
+ while (++i < n) points.push([
2823
+ x.call(self, value = d[i], i),
2824
+ y.call(self, value, i)
2825
+ ]);
2826
+ } else if (fx) {
2827
+ while (++i < n) points.push([x.call(self, d[i], i), y]);
2828
+ } else if (fy) {
2829
+ while (++i < n) points.push([x, y.call(self, d[i], i)]);
2830
+ } else {
2831
+ while (++i < n) points.push([x, y]);
2832
+ }
2833
+ return points;
2834
+ }
2835
+
2836
+ // The default `x` property, which references d[0].
2837
+ function d3_svg_lineX(d) {
2838
+ return d[0];
2839
+ }
2840
+
2841
+ // The default `y` property, which references d[1].
2842
+ function d3_svg_lineY(d) {
2843
+ return d[1];
2844
+ }
2845
+
2846
+ // The various interpolators supported by the `line` class.
2847
+ var d3_svg_lineInterpolators = {
2848
+ "linear": d3_svg_lineLinear,
2849
+ "step-before": d3_svg_lineStepBefore,
2850
+ "step-after": d3_svg_lineStepAfter,
2851
+ "basis": d3_svg_lineBasis,
2852
+ "basis-open": d3_svg_lineBasisOpen,
2853
+ "basis-closed": d3_svg_lineBasisClosed,
2854
+ "bundle": d3_svg_lineBundle,
2855
+ "cardinal": d3_svg_lineCardinal,
2856
+ "cardinal-open": d3_svg_lineCardinalOpen,
2857
+ "cardinal-closed": d3_svg_lineCardinalClosed,
2858
+ "monotone": d3_svg_lineMonotone
2859
+ };
2860
+
2861
+ // Linear interpolation; generates "L" commands.
2862
+ function d3_svg_lineLinear(points) {
2863
+ var path = [],
2864
+ i = 0,
2865
+ n = points.length,
2866
+ p = points[0];
2867
+ path.push(p[0], ",", p[1]);
2868
+ while (++i < n) path.push("L", (p = points[i])[0], ",", p[1]);
2869
+ return path.join("");
2870
+ }
2871
+
2872
+ // Step interpolation; generates "H" and "V" commands.
2873
+ function d3_svg_lineStepBefore(points) {
2874
+ var path = [],
2875
+ i = 0,
2876
+ n = points.length,
2877
+ p = points[0];
2878
+ path.push(p[0], ",", p[1]);
2879
+ while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]);
2880
+ return path.join("");
2881
+ }
2882
+
2883
+ // Step interpolation; generates "H" and "V" commands.
2884
+ function d3_svg_lineStepAfter(points) {
2885
+ var path = [],
2886
+ i = 0,
2887
+ n = points.length,
2888
+ p = points[0];
2889
+ path.push(p[0], ",", p[1]);
2890
+ while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]);
2891
+ return path.join("");
2892
+ }
2893
+
2894
+ // Open cardinal spline interpolation; generates "C" commands.
2895
+ function d3_svg_lineCardinalOpen(points, tension) {
2896
+ return points.length < 4
2897
+ ? d3_svg_lineLinear(points)
2898
+ : points[1] + d3_svg_lineHermite(points.slice(1, points.length - 1),
2899
+ d3_svg_lineCardinalTangents(points, tension));
2900
+ }
2901
+
2902
+ // Closed cardinal spline interpolation; generates "C" commands.
2903
+ function d3_svg_lineCardinalClosed(points, tension) {
2904
+ return points.length < 3
2905
+ ? d3_svg_lineLinear(points)
2906
+ : points[0] + d3_svg_lineHermite((points.push(points[0]), points),
2907
+ d3_svg_lineCardinalTangents([points[points.length - 2]]
2908
+ .concat(points, [points[1]]), tension));
2909
+ }
2910
+
2911
+ // Cardinal spline interpolation; generates "C" commands.
2912
+ function d3_svg_lineCardinal(points, tension, closed) {
2913
+ return points.length < 3
2914
+ ? d3_svg_lineLinear(points)
2915
+ : points[0] + d3_svg_lineHermite(points,
2916
+ d3_svg_lineCardinalTangents(points, tension));
2917
+ }
2918
+
2919
+ // Hermite spline construction; generates "C" commands.
2920
+ function d3_svg_lineHermite(points, tangents) {
2921
+ if (tangents.length < 1
2922
+ || (points.length != tangents.length
2923
+ && points.length != tangents.length + 2)) {
2924
+ return d3_svg_lineLinear(points);
2925
+ }
2926
+
2927
+ var quad = points.length != tangents.length,
2928
+ path = "",
2929
+ p0 = points[0],
2930
+ p = points[1],
2931
+ t0 = tangents[0],
2932
+ t = t0,
2933
+ pi = 1;
2934
+
2935
+ if (quad) {
2936
+ path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3)
2937
+ + "," + p[0] + "," + p[1];
2938
+ p0 = points[1];
2939
+ pi = 2;
2940
+ }
2941
+
2942
+ if (tangents.length > 1) {
2943
+ t = tangents[1];
2944
+ p = points[pi];
2945
+ pi++;
2946
+ path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1])
2947
+ + "," + (p[0] - t[0]) + "," + (p[1] - t[1])
2948
+ + "," + p[0] + "," + p[1];
2949
+ for (var i = 2; i < tangents.length; i++, pi++) {
2950
+ p = points[pi];
2951
+ t = tangents[i];
2952
+ path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1])
2953
+ + "," + p[0] + "," + p[1];
2954
+ }
2955
+ }
2956
+
2957
+ if (quad) {
2958
+ var lp = points[pi];
2959
+ path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3)
2960
+ + "," + lp[0] + "," + lp[1];
2961
+ }
2962
+
2963
+ return path;
2964
+ }
2965
+
2966
+ // Generates tangents for a cardinal spline.
2967
+ function d3_svg_lineCardinalTangents(points, tension) {
2968
+ var tangents = [],
2969
+ a = (1 - tension) / 2,
2970
+ p0,
2971
+ p1 = points[0],
2972
+ p2 = points[1],
2973
+ i = 1,
2974
+ n = points.length;
2975
+ while (++i < n) {
2976
+ p0 = p1;
2977
+ p1 = p2;
2978
+ p2 = points[i];
2979
+ tangents.push([a * (p2[0] - p0[0]), a * (p2[1] - p0[1])]);
2980
+ }
2981
+ return tangents;
2982
+ }
2983
+
2984
+ // B-spline interpolation; generates "C" commands.
2985
+ function d3_svg_lineBasis(points) {
2986
+ if (points.length < 3) return d3_svg_lineLinear(points);
2987
+ var path = [],
2988
+ i = 1,
2989
+ n = points.length,
2990
+ pi = points[0],
2991
+ x0 = pi[0],
2992
+ y0 = pi[1],
2993
+ px = [x0, x0, x0, (pi = points[1])[0]],
2994
+ py = [y0, y0, y0, pi[1]];
2995
+ path.push(x0, ",", y0);
2996
+ d3_svg_lineBasisBezier(path, px, py);
2997
+ while (++i < n) {
2998
+ pi = points[i];
2999
+ px.shift(); px.push(pi[0]);
3000
+ py.shift(); py.push(pi[1]);
3001
+ d3_svg_lineBasisBezier(path, px, py);
3002
+ }
3003
+ i = -1;
3004
+ while (++i < 2) {
3005
+ px.shift(); px.push(pi[0]);
3006
+ py.shift(); py.push(pi[1]);
3007
+ d3_svg_lineBasisBezier(path, px, py);
3008
+ }
3009
+ return path.join("");
3010
+ }
3011
+
3012
+ // Open B-spline interpolation; generates "C" commands.
3013
+ function d3_svg_lineBasisOpen(points) {
3014
+ if (points.length < 4) return d3_svg_lineLinear(points);
3015
+ var path = [],
3016
+ i = -1,
3017
+ n = points.length,
3018
+ pi,
3019
+ px = [0],
3020
+ py = [0];
3021
+ while (++i < 3) {
3022
+ pi = points[i];
3023
+ px.push(pi[0]);
3024
+ py.push(pi[1]);
3025
+ }
3026
+ path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px)
3027
+ + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, py));
3028
+ --i; while (++i < n) {
3029
+ pi = points[i];
3030
+ px.shift(); px.push(pi[0]);
3031
+ py.shift(); py.push(pi[1]);
3032
+ d3_svg_lineBasisBezier(path, px, py);
3033
+ }
3034
+ return path.join("");
3035
+ }
3036
+
3037
+ // Closed B-spline interpolation; generates "C" commands.
3038
+ function d3_svg_lineBasisClosed(points) {
3039
+ var path,
3040
+ i = -1,
3041
+ n = points.length,
3042
+ m = n + 4,
3043
+ pi,
3044
+ px = [],
3045
+ py = [];
3046
+ while (++i < 4) {
3047
+ pi = points[i % n];
3048
+ px.push(pi[0]);
3049
+ py.push(pi[1]);
3050
+ }
3051
+ path = [
3052
+ d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",",
3053
+ d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)
3054
+ ];
3055
+ --i; while (++i < m) {
3056
+ pi = points[i % n];
3057
+ px.shift(); px.push(pi[0]);
3058
+ py.shift(); py.push(pi[1]);
3059
+ d3_svg_lineBasisBezier(path, px, py);
3060
+ }
3061
+ return path.join("");
3062
+ }
3063
+
3064
+ function d3_svg_lineBundle(points, tension) {
3065
+ var n = points.length - 1,
3066
+ x0 = points[0][0],
3067
+ y0 = points[0][1],
3068
+ dx = points[n][0] - x0,
3069
+ dy = points[n][1] - y0,
3070
+ i = -1,
3071
+ p,
3072
+ t;
3073
+ while (++i <= n) {
3074
+ p = points[i];
3075
+ t = i / n;
3076
+ p[0] = tension * p[0] + (1 - tension) * (x0 + t * dx);
3077
+ p[1] = tension * p[1] + (1 - tension) * (y0 + t * dy);
3078
+ }
3079
+ return d3_svg_lineBasis(points);
3080
+ }
3081
+
3082
+ // Returns the dot product of the given four-element vectors.
3083
+ function d3_svg_lineDot4(a, b) {
3084
+ return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
3085
+ }
3086
+
3087
+ // Matrix to transform basis (b-spline) control points to bezier
3088
+ // control points. Derived from FvD 11.2.8.
3089
+ var d3_svg_lineBasisBezier1 = [0, 2/3, 1/3, 0],
3090
+ d3_svg_lineBasisBezier2 = [0, 1/3, 2/3, 0],
3091
+ d3_svg_lineBasisBezier3 = [0, 1/6, 2/3, 1/6];
3092
+
3093
+ // Pushes a "C" Bézier curve onto the specified path array, given the
3094
+ // two specified four-element arrays which define the control points.
3095
+ function d3_svg_lineBasisBezier(path, x, y) {
3096
+ path.push(
3097
+ "C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x),
3098
+ ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1, y),
3099
+ ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, x),
3100
+ ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, y),
3101
+ ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, x),
3102
+ ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, y));
3103
+ }
3104
+
3105
+ // Computes the slope from points p0 to p1.
3106
+ function d3_svg_lineSlope(p0, p1) {
3107
+ return (p1[1] - p0[1]) / (p1[0] - p0[0]);
3108
+ }
3109
+
3110
+ // Compute three-point differences for the given points.
3111
+ // http://en.wikipedia.org/wiki/Cubic_Hermite_spline#Finite_difference
3112
+ function d3_svg_lineFiniteDifferences(points) {
3113
+ var i = 0,
3114
+ j = points.length - 1,
3115
+ m = [],
3116
+ p0 = points[0],
3117
+ p1 = points[1],
3118
+ d = m[0] = d3_svg_lineSlope(p0, p1);
3119
+ while (++i < j) {
3120
+ m[i] = d + (d = d3_svg_lineSlope(p0 = p1, p1 = points[i + 1]));
3121
+ }
3122
+ m[i] = d;
3123
+ return m;
3124
+ }
3125
+
3126
+ // Interpolates the given points using Fritsch-Carlson Monotone cubic Hermite
3127
+ // interpolation. Returns an array of tangent vectors. For details, see
3128
+ // http://en.wikipedia.org/wiki/Monotone_cubic_interpolation
3129
+ function d3_svg_lineMonotoneTangents(points) {
3130
+ var tangents = [],
3131
+ d,
3132
+ a,
3133
+ b,
3134
+ s,
3135
+ m = d3_svg_lineFiniteDifferences(points),
3136
+ i = -1,
3137
+ j = points.length - 1;
3138
+
3139
+ // The first two steps are done by computing finite-differences:
3140
+ // 1. Compute the slopes of the secant lines between successive points.
3141
+ // 2. Initialize the tangents at every point as the average of the secants.
3142
+
3143
+ // Then, for each segment…
3144
+ while (++i < j) {
3145
+ d = d3_svg_lineSlope(points[i], points[i + 1]);
3146
+
3147
+ // 3. If two successive yk = y{k + 1} are equal (i.e., d is zero), then set
3148
+ // mk = m{k + 1} = 0 as the spline connecting these points must be flat to
3149
+ // preserve monotonicity. Ignore step 4 and 5 for those k.
3150
+
3151
+ if (Math.abs(d) < 1e-6) {
3152
+ m[i] = m[i + 1] = 0;
3153
+ } else {
3154
+ // 4. Let ak = mk / dk and bk = m{k + 1} / dk.
3155
+ a = m[i] / d;
3156
+ b = m[i + 1] / d;
3157
+
3158
+ // 5. Prevent overshoot and ensure monotonicity by restricting the
3159
+ // magnitude of vector <ak, bk> to a circle of radius 3.
3160
+ s = a * a + b * b;
3161
+ if (s > 9) {
3162
+ s = d * 3 / Math.sqrt(s);
3163
+ m[i] = s * a;
3164
+ m[i + 1] = s * b;
3165
+ }
3166
+ }
3167
+ }
3168
+
3169
+ // Compute the normalized tangent vector from the slopes. Note that if x is
3170
+ // not monotonic, it's possible that the slope will be infinite, so we protect
3171
+ // against NaN by setting the coordinate to zero.
3172
+ i = -1; while (++i <= j) {
3173
+ s = (points[Math.min(j, i + 1)][0] - points[Math.max(0, i - 1)][0])
3174
+ / (6 * (1 + m[i] * m[i]));
3175
+ tangents.push([s || 0, m[i] * s || 0]);
3176
+ }
3177
+
3178
+ return tangents;
3179
+ }
3180
+
3181
+ function d3_svg_lineMonotone(points) {
3182
+ return points.length < 3
3183
+ ? d3_svg_lineLinear(points)
3184
+ : points[0] +
3185
+ d3_svg_lineHermite(points, d3_svg_lineMonotoneTangents(points));
3186
+ }
3187
+ d3.svg.line.radial = function() {
3188
+ var line = d3_svg_line(d3_svg_lineRadial);
3189
+ line.radius = line.x, delete line.x;
3190
+ line.angle = line.y, delete line.y;
3191
+ return line;
3192
+ };
3193
+
3194
+ function d3_svg_lineRadial(points) {
3195
+ var point,
3196
+ i = -1,
3197
+ n = points.length,
3198
+ r,
3199
+ a;
3200
+ while (++i < n) {
3201
+ point = points[i];
3202
+ r = point[0];
3203
+ a = point[1] + d3_svg_arcOffset;
3204
+ point[0] = r * Math.cos(a);
3205
+ point[1] = r * Math.sin(a);
3206
+ }
3207
+ return points;
3208
+ }
3209
+ function d3_svg_area(projection) {
3210
+ var x0 = d3_svg_lineX,
3211
+ x1 = d3_svg_lineX,
3212
+ y0 = 0,
3213
+ y1 = d3_svg_lineY,
3214
+ interpolate = "linear",
3215
+ interpolator = d3_svg_lineInterpolators[interpolate],
3216
+ tension = .7;
3217
+
3218
+ function area(d) {
3219
+ if (d.length < 1) return null;
3220
+ var points0 = d3_svg_linePoints(this, d, x0, y0),
3221
+ points1 = d3_svg_linePoints(this, d, x0 === x1 ? d3_svg_areaX(points0) : x1, y0 === y1 ? d3_svg_areaY(points0) : y1);
3222
+ return "M" + interpolator(projection(points1), tension)
3223
+ + "L" + interpolator(projection(points0.reverse()), tension)
3224
+ + "Z";
3225
+ }
3226
+
3227
+ area.x = function(x) {
3228
+ if (!arguments.length) return x1;
3229
+ x0 = x1 = x;
3230
+ return area;
3231
+ };
3232
+
3233
+ area.x0 = function(x) {
3234
+ if (!arguments.length) return x0;
3235
+ x0 = x;
3236
+ return area;
3237
+ };
3238
+
3239
+ area.x1 = function(x) {
3240
+ if (!arguments.length) return x1;
3241
+ x1 = x;
3242
+ return area;
3243
+ };
3244
+
3245
+ area.y = function(y) {
3246
+ if (!arguments.length) return y1;
3247
+ y0 = y1 = y;
3248
+ return area;
3249
+ };
3250
+
3251
+ area.y0 = function(y) {
3252
+ if (!arguments.length) return y0;
3253
+ y0 = y;
3254
+ return area;
3255
+ };
3256
+
3257
+ area.y1 = function(y) {
3258
+ if (!arguments.length) return y1;
3259
+ y1 = y;
3260
+ return area;
3261
+ };
3262
+
3263
+ area.interpolate = function(x) {
3264
+ if (!arguments.length) return interpolate;
3265
+ interpolator = d3_svg_lineInterpolators[interpolate = x];
3266
+ return area;
3267
+ };
3268
+
3269
+ area.tension = function(x) {
3270
+ if (!arguments.length) return tension;
3271
+ tension = x;
3272
+ return area;
3273
+ };
3274
+
3275
+ return area;
3276
+ }
3277
+
3278
+ d3.svg.area = function() {
3279
+ return d3_svg_area(Object);
3280
+ };
3281
+
3282
+ function d3_svg_areaX(points) {
3283
+ return function(d, i) {
3284
+ return points[i][0];
3285
+ };
3286
+ }
3287
+
3288
+ function d3_svg_areaY(points) {
3289
+ return function(d, i) {
3290
+ return points[i][1];
3291
+ };
3292
+ }
3293
+ d3.svg.area.radial = function() {
3294
+ var area = d3_svg_area(d3_svg_lineRadial);
3295
+ area.radius = area.x, delete area.x;
3296
+ area.innerRadius = area.x0, delete area.x0;
3297
+ area.outerRadius = area.x1, delete area.x1;
3298
+ area.angle = area.y, delete area.y;
3299
+ area.startAngle = area.y0, delete area.y0;
3300
+ area.endAngle = area.y1, delete area.y1;
3301
+ return area;
3302
+ };
3303
+ d3.svg.chord = function() {
3304
+ var source = d3_svg_chordSource,
3305
+ target = d3_svg_chordTarget,
3306
+ radius = d3_svg_chordRadius,
3307
+ startAngle = d3_svg_arcStartAngle,
3308
+ endAngle = d3_svg_arcEndAngle;
3309
+
3310
+ // TODO Allow control point to be customized.
3311
+
3312
+ function chord(d, i) {
3313
+ var s = subgroup(this, source, d, i),
3314
+ t = subgroup(this, target, d, i);
3315
+ return "M" + s.p0
3316
+ + arc(s.r, s.p1) + (equals(s, t)
3317
+ ? curve(s.r, s.p1, s.r, s.p0)
3318
+ : curve(s.r, s.p1, t.r, t.p0)
3319
+ + arc(t.r, t.p1)
3320
+ + curve(t.r, t.p1, s.r, s.p0))
3321
+ + "Z";
3322
+ }
3323
+
3324
+ function subgroup(self, f, d, i) {
3325
+ var subgroup = f.call(self, d, i),
3326
+ r = radius.call(self, subgroup, i),
3327
+ a0 = startAngle.call(self, subgroup, i) + d3_svg_arcOffset,
3328
+ a1 = endAngle.call(self, subgroup, i) + d3_svg_arcOffset;
3329
+ return {
3330
+ r: r,
3331
+ a0: a0,
3332
+ a1: a1,
3333
+ p0: [r * Math.cos(a0), r * Math.sin(a0)],
3334
+ p1: [r * Math.cos(a1), r * Math.sin(a1)]
3335
+ };
3336
+ }
3337
+
3338
+ function equals(a, b) {
3339
+ return a.a0 == b.a0 && a.a1 == b.a1;
3340
+ }
3341
+
3342
+ function arc(r, p) {
3343
+ return "A" + r + "," + r + " 0 0,1 " + p;
3344
+ }
3345
+
3346
+ function curve(r0, p0, r1, p1) {
3347
+ return "Q 0,0 " + p1;
3348
+ }
3349
+
3350
+ chord.radius = function(v) {
3351
+ if (!arguments.length) return radius;
3352
+ radius = d3.functor(v);
3353
+ return chord;
3354
+ };
3355
+
3356
+ chord.source = function(v) {
3357
+ if (!arguments.length) return source;
3358
+ source = d3.functor(v);
3359
+ return chord;
3360
+ };
3361
+
3362
+ chord.target = function(v) {
3363
+ if (!arguments.length) return target;
3364
+ target = d3.functor(v);
3365
+ return chord;
3366
+ };
3367
+
3368
+ chord.startAngle = function(v) {
3369
+ if (!arguments.length) return startAngle;
3370
+ startAngle = d3.functor(v);
3371
+ return chord;
3372
+ };
3373
+
3374
+ chord.endAngle = function(v) {
3375
+ if (!arguments.length) return endAngle;
3376
+ endAngle = d3.functor(v);
3377
+ return chord;
3378
+ };
3379
+
3380
+ return chord;
3381
+ };
3382
+
3383
+ function d3_svg_chordSource(d) {
3384
+ return d.source;
3385
+ }
3386
+
3387
+ function d3_svg_chordTarget(d) {
3388
+ return d.target;
3389
+ }
3390
+
3391
+ function d3_svg_chordRadius(d) {
3392
+ return d.radius;
3393
+ }
3394
+
3395
+ function d3_svg_chordStartAngle(d) {
3396
+ return d.startAngle;
3397
+ }
3398
+
3399
+ function d3_svg_chordEndAngle(d) {
3400
+ return d.endAngle;
3401
+ }
3402
+ d3.svg.diagonal = function() {
3403
+ var source = d3_svg_chordSource,
3404
+ target = d3_svg_chordTarget,
3405
+ projection = d3_svg_diagonalProjection;
3406
+
3407
+ function diagonal(d, i) {
3408
+ var p0 = source.call(this, d, i),
3409
+ p3 = target.call(this, d, i),
3410
+ m = (p0.y + p3.y) / 2,
3411
+ p = [p0, {x: p0.x, y: m}, {x: p3.x, y: m}, p3];
3412
+ p = p.map(projection);
3413
+ return "M" + p[0] + "C" + p[1] + " " + p[2] + " " + p[3];
3414
+ }
3415
+
3416
+ diagonal.source = function(x) {
3417
+ if (!arguments.length) return source;
3418
+ source = d3.functor(x);
3419
+ return diagonal;
3420
+ };
3421
+
3422
+ diagonal.target = function(x) {
3423
+ if (!arguments.length) return target;
3424
+ target = d3.functor(x);
3425
+ return diagonal;
3426
+ };
3427
+
3428
+ diagonal.projection = function(x) {
3429
+ if (!arguments.length) return projection;
3430
+ projection = x;
3431
+ return diagonal;
3432
+ };
3433
+
3434
+ return diagonal;
3435
+ };
3436
+
3437
+ function d3_svg_diagonalProjection(d) {
3438
+ return [d.x, d.y];
3439
+ }
3440
+ d3.svg.diagonal.radial = function() {
3441
+ var diagonal = d3.svg.diagonal(),
3442
+ projection = d3_svg_diagonalProjection,
3443
+ projection_ = diagonal.projection;
3444
+
3445
+ diagonal.projection = function(x) {
3446
+ return arguments.length
3447
+ ? projection_(d3_svg_diagonalRadialProjection(projection = x))
3448
+ : projection;
3449
+ };
3450
+
3451
+ return diagonal;
3452
+ };
3453
+
3454
+ function d3_svg_diagonalRadialProjection(projection) {
3455
+ return function() {
3456
+ var d = projection.apply(this, arguments),
3457
+ r = d[0],
3458
+ a = d[1] + d3_svg_arcOffset;
3459
+ return [r * Math.cos(a), r * Math.sin(a)];
3460
+ };
3461
+ }
3462
+ d3.svg.mouse = function(container) {
3463
+ return d3_svg_mousePoint(container, d3.event);
3464
+ };
3465
+
3466
+ // https://bugs.webkit.org/show_bug.cgi?id=44083
3467
+ var d3_mouse_bug44083 = /WebKit/.test(navigator.userAgent) ? -1 : 0;
3468
+
3469
+ function d3_svg_mousePoint(container, e) {
3470
+ var point = (container.ownerSVGElement || container).createSVGPoint();
3471
+ if ((d3_mouse_bug44083 < 0) && (window.scrollX || window.scrollY)) {
3472
+ var svg = d3.select(document.body)
3473
+ .append("svg:svg")
3474
+ .style("position", "absolute")
3475
+ .style("top", 0)
3476
+ .style("left", 0);
3477
+ var ctm = svg[0][0].getScreenCTM();
3478
+ d3_mouse_bug44083 = !(ctm.f || ctm.e);
3479
+ svg.remove();
3480
+ }
3481
+ if (d3_mouse_bug44083) {
3482
+ point.x = e.pageX;
3483
+ point.y = e.pageY;
3484
+ } else {
3485
+ point.x = e.clientX;
3486
+ point.y = e.clientY;
3487
+ }
3488
+ point = point.matrixTransform(container.getScreenCTM().inverse());
3489
+ return [point.x, point.y];
3490
+ };
3491
+ d3.svg.touches = function(container) {
3492
+ var touches = d3.event.touches;
3493
+ return touches ? d3_array(touches).map(function(touch) {
3494
+ var point = d3_svg_mousePoint(container, touch);
3495
+ point.identifier = touch.identifier;
3496
+ return point;
3497
+ }) : [];
3498
+ };
3499
+ d3.svg.symbol = function() {
3500
+ var type = d3_svg_symbolType,
3501
+ size = d3_svg_symbolSize;
3502
+
3503
+ function symbol(d, i) {
3504
+ return (d3_svg_symbols[type.call(this, d, i)]
3505
+ || d3_svg_symbols.circle)
3506
+ (size.call(this, d, i));
3507
+ }
3508
+
3509
+ symbol.type = function(x) {
3510
+ if (!arguments.length) return type;
3511
+ type = d3.functor(x);
3512
+ return symbol;
3513
+ };
3514
+
3515
+ // size of symbol in square pixels
3516
+ symbol.size = function(x) {
3517
+ if (!arguments.length) return size;
3518
+ size = d3.functor(x);
3519
+ return symbol;
3520
+ };
3521
+
3522
+ return symbol;
3523
+ };
3524
+
3525
+ function d3_svg_symbolSize() {
3526
+ return 64;
3527
+ }
3528
+
3529
+ function d3_svg_symbolType() {
3530
+ return "circle";
3531
+ }
3532
+
3533
+ // TODO cross-diagonal?
3534
+ var d3_svg_symbols = {
3535
+ "circle": function(size) {
3536
+ var r = Math.sqrt(size / Math.PI);
3537
+ return "M0," + r
3538
+ + "A" + r + "," + r + " 0 1,1 0," + (-r)
3539
+ + "A" + r + "," + r + " 0 1,1 0," + r
3540
+ + "Z";
3541
+ },
3542
+ "cross": function(size) {
3543
+ var r = Math.sqrt(size / 5) / 2;
3544
+ return "M" + -3 * r + "," + -r
3545
+ + "H" + -r
3546
+ + "V" + -3 * r
3547
+ + "H" + r
3548
+ + "V" + -r
3549
+ + "H" + 3 * r
3550
+ + "V" + r
3551
+ + "H" + r
3552
+ + "V" + 3 * r
3553
+ + "H" + -r
3554
+ + "V" + r
3555
+ + "H" + -3 * r
3556
+ + "Z";
3557
+ },
3558
+ "diamond": function(size) {
3559
+ var ry = Math.sqrt(size / (2 * d3_svg_symbolTan30)),
3560
+ rx = ry * d3_svg_symbolTan30;
3561
+ return "M0," + -ry
3562
+ + "L" + rx + ",0"
3563
+ + " 0," + ry
3564
+ + " " + -rx + ",0"
3565
+ + "Z";
3566
+ },
3567
+ "square": function(size) {
3568
+ var r = Math.sqrt(size) / 2;
3569
+ return "M" + -r + "," + -r
3570
+ + "L" + r + "," + -r
3571
+ + " " + r + "," + r
3572
+ + " " + -r + "," + r
3573
+ + "Z";
3574
+ },
3575
+ "triangle-down": function(size) {
3576
+ var rx = Math.sqrt(size / d3_svg_symbolSqrt3),
3577
+ ry = rx * d3_svg_symbolSqrt3 / 2;
3578
+ return "M0," + ry
3579
+ + "L" + rx +"," + -ry
3580
+ + " " + -rx + "," + -ry
3581
+ + "Z";
3582
+ },
3583
+ "triangle-up": function(size) {
3584
+ var rx = Math.sqrt(size / d3_svg_symbolSqrt3),
3585
+ ry = rx * d3_svg_symbolSqrt3 / 2;
3586
+ return "M0," + -ry
3587
+ + "L" + rx +"," + ry
3588
+ + " " + -rx + "," + ry
3589
+ + "Z";
3590
+ }
3591
+ };
3592
+
3593
+ d3.svg.symbolTypes = d3.keys(d3_svg_symbols);
3594
+
3595
+ var d3_svg_symbolSqrt3 = Math.sqrt(3),
3596
+ d3_svg_symbolTan30 = Math.tan(30 * Math.PI / 180);
3597
+ })();