diff --git a/js/lib/d3.v3.js b/js/lib/d3.v3.js index 23697d206..641e86be2 100644 --- a/js/lib/d3.v3.js +++ b/js/lib/d3.v3.js @@ -1,5 +1,5 @@ d3 = (function(){ - var d3 = {version: "3.2.7"}; // semver + var d3 = {version: "3.3.8"}; // semver d3.ascending = function(a, b) { return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; }; @@ -137,12 +137,15 @@ d3.shuffle = function(array) { return array; }; d3.permute = function(array, indexes) { - var permutes = [], - i = -1, - n = indexes.length; - while (++i < n) permutes[i] = array[indexes[i]]; + var i = indexes.length, permutes = new Array(i); + while (i--) permutes[i] = array[indexes[i]]; return permutes; }; +d3.pairs = function(array) { + var i = 0, n = array.length - 1, p0, p1 = array[0], pairs = new Array(n < 0 ? 0 : n); + while (i < n) pairs[i] = [p0 = p1, p1 = array[++i]]; + return pairs; +}; d3.zip = function() { if (!(n = arguments.length)) return []; @@ -177,8 +180,28 @@ d3.entries = function(map) { return entries; }; d3.merge = function(arrays) { - return Array.prototype.concat.apply([], arrays); + var n = arrays.length, + m, + i = -1, + j = 0, + merged, + array; + + while (++i < n) j += arrays[i].length; + merged = new Array(j); + + while (--n >= 0) { + array = arrays[n]; + m = array.length; + while (--m >= 0) { + merged[--j] = array[m]; + } + } + + return merged; }; +var abs = Math.abs; + d3.range = function(start, stop, step) { if (arguments.length < 3) { step = 1; @@ -189,7 +212,7 @@ d3.range = function(start, stop, step) { } if ((stop - start) / step === Infinity) throw new Error("infinite range"); var range = [], - k = d3_range_integerScale(Math.abs(step)), + k = d3_range_integerScale(abs(step)), i = -1, j; start *= k, stop *= k, step *= k; @@ -218,7 +241,8 @@ function d3_class(ctor, properties) { d3.map = function(object) { var map = new d3_Map; - for (var key in object) map.set(key, object[key]); + if (object instanceof d3_Map) object.forEach(function(key, value) { map.set(key, value); }); + else for (var key in object) map.set(key, object[key]); return map; }; @@ -362,8 +386,8 @@ d3.nest = function() { }; d3.set = function(array) { - var set = new d3_Set(); - if (array) for (var i = 0; i < array.length; i++) set.add(array[i]); + var set = new d3_Set; + if (array) for (var i = 0, n = array.length; i < n; ++i) set.add(array[i]); return set; }; @@ -397,9 +421,23 @@ d3_class(d3_Set, { } }); d3.behavior = {}; +var d3_arraySlice = [].slice, + d3_array = function(list) { return d3_arraySlice.call(list); }; // conversion for NodeLists + var d3_document = document, d3_documentElement = d3_document.documentElement, d3_window = window; + +// Redefine d3_array if the browser doesn’t support slice-based conversion. +try { + d3_array(d3_documentElement.childNodes)[0].nodeType; +} catch(e) { + d3_array = function(list) { + var i = list.length, array = new Array(i); + while (i--) array[i] = list[i]; + return array; + }; +} // Copies a variable number of methods from source to target. d3.rebind = function(target, source) { var i = 1, n = arguments.length, method; @@ -427,24 +465,6 @@ function d3_vendorSymbol(object, name) { } var d3_vendorPrefixes = ["webkit", "ms", "moz", "Moz", "o", "O"]; - -var d3_array = d3_arraySlice; // conversion for NodeLists - -function d3_arrayCopy(pseudoarray) { - var i = -1, n = pseudoarray.length, array = []; - while (++i < n) array.push(pseudoarray[i]); - return array; -} - -function d3_arraySlice(pseudoarray) { - return Array.prototype.slice.call(pseudoarray); -} - -try { - d3_array(d3_documentElement.childNodes)[0].nodeType; -} catch(e) { - d3_array = d3_arrayCopy; -} function d3_noop() {} d3.dispatch = function() { @@ -942,15 +962,15 @@ d3_selectionPrototype.append = function(name) { function d3_selection_creator(name) { return typeof name === "function" ? name - : (name = d3.ns.qualify(name)).local ? function() { return d3_document.createElementNS(name.space, name.local); } - : function() { return d3_document.createElementNS(this.namespaceURI, name); }; + : (name = d3.ns.qualify(name)).local ? function() { return this.ownerDocument.createElementNS(name.space, name.local); } + : function() { return this.ownerDocument.createElementNS(this.namespaceURI, name); }; } d3_selectionPrototype.insert = function(name, before) { name = d3_selection_creator(name); before = d3_selection_selector(before); return this.select(function() { - return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments)); + return this.insertBefore(name.apply(this, arguments), before.apply(this, arguments) || null); }); }; @@ -1134,7 +1154,7 @@ d3_selectionPrototype.sort = function(comparator) { function d3_selection_sortComparator(comparator) { if (!arguments.length) comparator = d3.ascending; return function(a, b) { - return (!a - !b) || comparator(a.__data__, b.__data__); + return a && b ? comparator(a.__data__, b.__data__) : !a - !b; }; } @@ -1239,6 +1259,8 @@ function d3_selection_enterInsertBefore(enter) { }; } +// import "../transition/transition"; + d3_selectionPrototype.transition = function() { var id = d3_transitionInheritId || ++d3_transitionId, subgroups = [], @@ -1256,6 +1278,16 @@ d3_selectionPrototype.transition = function() { return d3_transition(subgroups, id); }; +// import "../transition/transition"; + +d3_selectionPrototype.interrupt = function() { + return this.each(d3_selection_interrupt); +}; + +function d3_selection_interrupt() { + var lock = this.__transition__; + if (lock) ++lock.active; +} // TODO fast singleton implementation? d3.select = function(node) { @@ -1402,6 +1434,7 @@ d3.mouse = function(container) { var d3_mouse_bug44083 = /WebKit/.test(d3_window.navigator.userAgent) ? -1 : 0; function d3_mousePoint(container, e) { + if (e.changedTouches) e = e.changedTouches[0]; var svg = container.ownerSVGElement || container; if (svg.createSVGPoint) { var point = svg.createSVGPoint(); @@ -1418,13 +1451,8 @@ function d3_mousePoint(container, e) { d3_mouse_bug44083 = !(ctm.f || ctm.e); svg.remove(); } - if (d3_mouse_bug44083) { - point.x = e.pageX; - point.y = e.pageY; - } else { - point.x = e.clientX; - point.y = e.clientY; - } + if (d3_mouse_bug44083) point.x = e.pageX, point.y = e.pageY; + else point.x = e.clientX, point.y = e.clientY; point = point.matrixTransform(container.getScreenCTM().inverse()); return [point.x, point.y]; } @@ -1440,47 +1468,180 @@ d3.touches = function(container, touches) { return point; }) : []; }; +var π = Math.PI, + τ = 2 * π, + halfπ = π / 2, + ε = 1e-6, + ε2 = ε * ε, + d3_radians = π / 180, + d3_degrees = 180 / π; + +function d3_sgn(x) { + return x > 0 ? 1 : x < 0 ? -1 : 0; +} + +function d3_acos(x) { + return x > 1 ? 0 : x < -1 ? π : Math.acos(x); +} + +function d3_asin(x) { + return x > 1 ? halfπ : x < -1 ? -halfπ : Math.asin(x); +} + +function d3_sinh(x) { + return ((x = Math.exp(x)) - 1 / x) / 2; +} + +function d3_cosh(x) { + return ((x = Math.exp(x)) + 1 / x) / 2; +} + +function d3_tanh(x) { + return ((x = Math.exp(2 * x)) - 1) / (x + 1); +} + +function d3_haversin(x) { + return (x = Math.sin(x / 2)) * x; +} + +var ρ = Math.SQRT2, + ρ2 = 2, + ρ4 = 4; + +// p0 = [ux0, uy0, w0] +// p1 = [ux1, uy1, w1] +d3.interpolateZoom = function(p0, p1) { + var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], + ux1 = p1[0], uy1 = p1[1], w1 = p1[2]; + + var dx = ux1 - ux0, + dy = uy1 - uy0, + d2 = dx * dx + dy * dy, + d1 = Math.sqrt(d2), + b0 = (w1 * w1 - w0 * w0 + ρ4 * d2) / (2 * w0 * ρ2 * d1), + b1 = (w1 * w1 - w0 * w0 - ρ4 * d2) / (2 * w1 * ρ2 * d1), + r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), + r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1), + dr = r1 - r0, + S = (dr || Math.log(w1 / w0)) / ρ; + + function interpolate(t) { + var s = t * S; + if (dr) { + // General case. + var coshr0 = d3_cosh(r0), + u = w0 / (ρ2 * d1) * (coshr0 * d3_tanh(ρ * s + r0) - d3_sinh(r0)); + return [ + ux0 + u * dx, + uy0 + u * dy, + w0 * coshr0 / d3_cosh(ρ * s + r0) + ]; + } + // Special case for u0 ~= u1. + return [ + ux0 + t * dx, + uy0 + t * dy, + w0 * Math.exp(ρ * s) + ]; + } + + interpolate.duration = S * 1000; + + return interpolate; +}; d3.behavior.zoom = function() { - var translate = [0, 0], + var view = {x: 0, y: 0, k: 1}, translate0, // translate when we started zooming (to avoid drift) - scale = 1, + center, // desired position of translate0 after zooming + size = [960, 500], // viewport size; required for zoom interpolation scaleExtent = d3_behavior_zoomInfinity, mousedown = "mousedown.zoom", mousemove = "mousemove.zoom", mouseup = "mouseup.zoom", - event = d3_eventDispatch(zoom, "zoom"), + mousewheelTimer, + touchstart = "touchstart.zoom", + touchtime, // time of last touchstart (to detect double-tap) + event = d3_eventDispatch(zoom, "zoomstart", "zoom", "zoomend"), x0, x1, y0, - y1, - touchtime; // time of last touchstart (to detect double-tap) + y1; - function zoom() { - this.on(mousedown, mousedowned) + function zoom(g) { + g .on(mousedown, mousedowned) .on(d3_behavior_zoomWheel + ".zoom", mousewheeled) .on(mousemove, mousewheelreset) .on("dblclick.zoom", dblclicked) - .on("touchstart.zoom", touchstarted); + .on(touchstart, touchstarted); } - zoom.translate = function(x) { - if (!arguments.length) return translate; - translate = x.map(Number); + zoom.event = function(g) { + g.each(function() { + var event_ = event.of(this, arguments), + view1 = view; + if (d3_transitionInheritId) { + d3.select(this).transition() + .each("start.zoom", function() { + view = this.__chart__ || {x: 0, y: 0, k: 1}; // pre-transition state + zoomstarted(event_); + }) + .tween("zoom:zoom", function() { + var dx = size[0], + dy = size[1], + cx = dx / 2, + cy = dy / 2, + i = d3.interpolateZoom( + [(cx - view.x) / view.k, (cy - view.y) / view.k, dx / view.k], + [(cx - view1.x) / view1.k, (cy - view1.y) / view1.k, dx / view1.k] + ); + return function(t) { + var l = i(t), k = dx / l[2]; + this.__chart__ = view = {x: cx - l[0] * k, y: cy - l[1] * k, k: k}; + zoomed(event_); + }; + }) + .each("end.zoom", function() { + zoomended(event_); + }); + } else { + this.__chart__ = view; + zoomstarted(event_); + zoomed(event_); + zoomended(event_); + } + }); + } + + zoom.translate = function(_) { + if (!arguments.length) return [view.x, view.y]; + view = {x: +_[0], y: +_[1], k: view.k}; // copy-on-write rescale(); return zoom; }; - zoom.scale = function(x) { - if (!arguments.length) return scale; - scale = +x; + zoom.scale = function(_) { + if (!arguments.length) return view.k; + view = {x: view.x, y: view.y, k: +_}; // copy-on-write rescale(); return zoom; }; - zoom.scaleExtent = function(x) { + zoom.scaleExtent = function(_) { if (!arguments.length) return scaleExtent; - scaleExtent = x == null ? d3_behavior_zoomInfinity : x.map(Number); + scaleExtent = _ == null ? d3_behavior_zoomInfinity : [+_[0], +_[1]]; + return zoom; + }; + + zoom.center = function(_) { + if (!arguments.length) return center; + center = _ && [+_[0], +_[1]]; + return zoom; + }; + + zoom.size = function(_) { + if (!arguments.length) return size; + size = _ && [+_[0], +_[1]]; return zoom; }; @@ -1488,8 +1649,7 @@ d3.behavior.zoom = function() { if (!arguments.length) return x1; x1 = z; x0 = z.copy(); - translate = [0, 0]; - scale = 1; + view = {x: 0, y: 0, k: 1}; // copy-on-write return zoom; }; @@ -1497,37 +1657,44 @@ d3.behavior.zoom = function() { if (!arguments.length) return y1; y1 = z; y0 = z.copy(); - translate = [0, 0]; - scale = 1; + view = {x: 0, y: 0, k: 1}; // copy-on-write return zoom; }; function location(p) { - return [(p[0] - translate[0]) / scale, (p[1] - translate[1]) / scale]; + return [(p[0] - view.x) / view.k, (p[1] - view.y) / view.k]; } function point(l) { - return [l[0] * scale + translate[0], l[1] * scale + translate[1]]; + return [l[0] * view.k + view.x, l[1] * view.k + view.y]; } function scaleTo(s) { - scale = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s)); + view.k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], s)); } function translateTo(p, l) { l = point(l); - translate[0] += p[0] - l[0]; - translate[1] += p[1] - l[1]; + view.x += p[0] - l[0]; + view.y += p[1] - l[1]; } function rescale() { - if (x1) x1.domain(x0.range().map(function(x) { return (x - translate[0]) / scale; }).map(x0.invert)); - if (y1) y1.domain(y0.range().map(function(y) { return (y - translate[1]) / scale; }).map(y0.invert)); + if (x1) x1.domain(x0.range().map(function(x) { return (x - view.x) / view.k; }).map(x0.invert)); + if (y1) y1.domain(y0.range().map(function(y) { return (y - view.y) / view.k; }).map(y0.invert)); } - function dispatch(event) { + function zoomstarted(event) { + event({type: "zoomstart"}); + } + + function zoomed(event) { rescale(); - event({type: "zoom", scale: scale, translate: translate}); + event({type: "zoom", scale: view.k, translate: [view.x, view.y]}); + } + + function zoomended(event) { + event({type: "zoomend"}); } function mousedowned() { @@ -1539,62 +1706,92 @@ d3.behavior.zoom = function() { l = location(d3.mouse(target)), dragRestore = d3_event_dragSuppress(); + d3_selection_interrupt.call(target); + zoomstarted(event_); + function moved() { dragged = 1; translateTo(d3.mouse(target), l); - dispatch(event_); + zoomed(event_); } function ended() { w.on(mousemove, d3_window === target ? mousewheelreset : null).on(mouseup, null); dragRestore(dragged && d3.event.target === eventTarget); + zoomended(event_); } } + // These closures persist for as long as at least one touch is active. function touchstarted() { var target = this, event_ = event.of(target, arguments), - touches = d3.touches(target), - locations = {}, + locations0 = {}, // touchstart locations distance0 = 0, // distance² between initial touches - scale0 = scale, // scale when we started touching - now = Date.now(), - name = "zoom-" + d3.event.changedTouches[0].identifier, - touchmove = "touchmove." + name, - touchend = "touchend." + name, + scale0, // scale when we started touching + eventId = d3.event.changedTouches[0].identifier, + touchmove = "touchmove.zoom-" + eventId, + touchend = "touchend.zoom-" + eventId, w = d3.select(d3_window).on(touchmove, moved).on(touchend, ended), - t = d3.select(target).on(mousedown, null), // prevent duplicate events + t = d3.select(target).on(mousedown, null).on(touchstart, started), // prevent duplicate events dragRestore = d3_event_dragSuppress(); - touches.forEach(function(t) { locations[t.identifier] = location(t); }); + d3_selection_interrupt.call(target); + started(); + zoomstarted(event_); - if (touches.length === 1) { - if (now - touchtime < 500) { // dbltap - var p = touches[0], l = location(touches[0]); - scaleTo(scale * 2); - translateTo(p, l); - d3_eventPreventDefault(); - dispatch(event_); + // Updates locations of any touches in locations0. + function relocate() { + var touches = d3.touches(target); + scale0 = view.k; + touches.forEach(function(t) { + if (t.identifier in locations0) locations0[t.identifier] = location(t); + }); + return touches; + } + + // Temporarily override touchstart while gesture is active. + function started() { + // Only track touches started on the target element. + var changed = d3.event.changedTouches; + for (var i = 0, n = changed.length; i < n; ++i) { + locations0[changed[i].identifier] = null; + } + + var touches = relocate(), + now = Date.now(); + + if (touches.length === 1) { + if (now - touchtime < 500) { // dbltap + var p = touches[0], l = locations0[p.identifier]; + scaleTo(view.k * 2); + translateTo(p, l); + d3_eventPreventDefault(); + zoomed(event_); + } + touchtime = now; + } else if (touches.length > 1) { + var p = touches[0], q = touches[1], + dx = p[0] - q[0], dy = p[1] - q[1]; + distance0 = dx * dx + dy * dy; } - touchtime = now; - } else if (touches.length > 1) { - var p = touches[0], q = touches[1], - dx = p[0] - q[0], dy = p[1] - q[1]; - distance0 = dx * dx + dy * dy; } function moved() { var touches = d3.touches(target), - p0 = touches[0], - l0 = locations[p0.identifier]; - - if (p1 = touches[1]) { - var p1, l1 = locations[p1.identifier], - scale1 = d3.event.scale; - if (scale1 == null) { - var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1; - scale1 = distance0 && Math.sqrt(distance1 / distance0); + p0, l0, + p1, l1; + for (var i = 0, n = touches.length; i < n; ++i, l1 = null) { + p1 = touches[i]; + if (l1 = locations0[p1.identifier]) { + if (l0) break; + p0 = p1, l0 = l1; } + } + + if (l1) { + var distance1 = (distance1 = p1[0] - p0[0]) * distance1 + (distance1 = p1[1] - p0[1]) * distance1, + scale1 = distance0 && Math.sqrt(distance1 / distance0); p0 = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2]; l0 = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2]; scaleTo(scale1 * scale0); @@ -1602,22 +1799,42 @@ d3.behavior.zoom = function() { touchtime = null; translateTo(p0, l0); - dispatch(event_); + zoomed(event_); } function ended() { + // If there are any globally-active touches remaining, remove the ended + // touches from locations0. + if (d3.event.touches.length) { + var changed = d3.event.changedTouches; + for (var i = 0, n = changed.length; i < n; ++i) { + delete locations0[changed[i].identifier]; + } + // If locations0 is not empty, then relocate and continue listening for + // touchmove and touchend. + for (var identifier in locations0) { + return void relocate(); // locations may have detached due to rotation + } + } + // Otherwise, remove touchmove and touchend listeners. w.on(touchmove, null).on(touchend, null); - t.on(mousedown, mousedowned); + t.on(mousedown, mousedowned).on(touchstart, touchstarted); dragRestore(); + zoomended(event_); } } function mousewheeled() { + var event_ = event.of(this, arguments); + if (mousewheelTimer) clearTimeout(mousewheelTimer); + else d3_selection_interrupt.call(this), zoomstarted(event_); + mousewheelTimer = setTimeout(function() { mousewheelTimer = null; zoomended(event_); }, 50); d3_eventPreventDefault(); - if (!translate0) translate0 = location(d3.mouse(this)); - scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * scale); - translateTo(d3.mouse(this), translate0); - dispatch(event.of(this, arguments)); + var point = center || d3.mouse(this); + if (!translate0) translate0 = location(point); + scaleTo(Math.pow(2, d3_behavior_zoomDelta() * .002) * view.k); + translateTo(point, translate0); + zoomed(event_); } function mousewheelreset() { @@ -1625,10 +1842,15 @@ d3.behavior.zoom = function() { } function dblclicked() { - var p = d3.mouse(this), l = location(p), k = Math.log(scale) / Math.LN2; + var event_ = event.of(this, arguments), + p = d3.mouse(this), + l = location(p), + k = Math.log(view.k) / Math.LN2; + zoomstarted(event_); scaleTo(Math.pow(2, d3.event.shiftKey ? Math.ceil(k) - 1 : Math.floor(k) + 1)); translateTo(p, l); - dispatch(event.of(this, arguments)); + zoomed(event_); + zoomended(event_); } return d3.rebind(zoom, event, "on"); @@ -1661,8 +1883,8 @@ d3.timer = function(callback, delay, then) { if (n < 3) then = Date.now(); // Add the callback to the tail of the queue. - var time = then + delay, timer = {callback: callback, time: time, next: null}; - if (d3_timer_queueTail) d3_timer_queueTail.next = timer; + var time = then + delay, timer = {c: callback, t: time, f: false, n: null}; + if (d3_timer_queueTail) d3_timer_queueTail.n = timer; else d3_timer_queueHead = timer; d3_timer_queueTail = timer; @@ -1694,20 +1916,12 @@ d3.timer.flush = function() { d3_timer_sweep(); }; -function d3_timer_replace(callback, delay, then) { - var n = arguments.length; - if (n < 2) delay = 0; - if (n < 3) then = Date.now(); - d3_timer_active.callback = callback; - d3_timer_active.time = then + delay; -} - function d3_timer_mark() { var now = Date.now(); d3_timer_active = d3_timer_queueHead; while (d3_timer_active) { - if (now >= d3_timer_active.time) d3_timer_active.flush = d3_timer_active.callback(now - d3_timer_active.time); - d3_timer_active = d3_timer_active.next; + if (now >= d3_timer_active.t) d3_timer_active.f = d3_timer_active.c(now - d3_timer_active.t); + d3_timer_active = d3_timer_active.n; } return now; } @@ -1719,45 +1933,16 @@ function d3_timer_sweep() { t1 = d3_timer_queueHead, time = Infinity; while (t1) { - if (t1.flush) { - t1 = t0 ? t0.next = t1.next : d3_timer_queueHead = t1.next; + if (t1.f) { + t1 = t0 ? t0.n = t1.n : d3_timer_queueHead = t1.n; } else { - if (t1.time < time) time = t1.time; - t1 = (t0 = t1).next; + if (t1.t < time) time = t1.t; + t1 = (t0 = t1).n; } } d3_timer_queueTail = t0; return time; } -var π = Math.PI, - ε = 1e-6, - ε2 = ε * ε, - d3_radians = π / 180, - d3_degrees = 180 / π; - -function d3_sgn(x) { - return x > 0 ? 1 : x < 0 ? -1 : 0; -} - -function d3_acos(x) { - return x > 1 ? 0 : x < -1 ? π : Math.acos(x); -} - -function d3_asin(x) { - return x > 1 ? π / 2 : x < -1 ? -π / 2 : Math.asin(x); -} - -function d3_sinh(x) { - return (Math.exp(x) - Math.exp(-x)) / 2; -} - -function d3_cosh(x) { - return (Math.exp(x) + Math.exp(-x)) / 2; -} - -function d3_haversin(x) { - return (x = Math.sin(x / 2)) * x; -} d3.geo = {}; function d3_identity(d) { return d; @@ -1774,13 +1959,13 @@ function d3_geo_spherical(cartesian) { } function d3_geo_sphericalEqual(a, b) { - return Math.abs(a[0] - b[0]) < ε && Math.abs(a[1] - b[1]) < ε; + return abs(a[0] - b[0]) < ε && abs(a[1] - b[1]) < ε; } // General spherical polygon clipping algorithm: takes a polygon, cuts it into // visible line segments and rejoins the segments by interpolating along the // clip edge. -function d3_geo_clipPolygon(segments, compare, inside, interpolate, listener) { +function d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener) { var subject = [], clip = []; @@ -1799,14 +1984,14 @@ function d3_geo_clipPolygon(segments, compare, inside, interpolate, listener) { return; } - var a = {point: p0, points: segment, other: null, visited: false, entry: true, subject: true}, - b = {point: p0, points: [p0], other: a, visited: false, entry: false, subject: false}; - a.other = b; + var a = new d3_geo_clipPolygonIntersection(p0, segment, null, true), + b = new d3_geo_clipPolygonIntersection(p0, null, a, false); + a.o = b; subject.push(a); clip.push(b); - a = {point: p1, points: [p1], other: null, visited: false, entry: false, subject: true}; - b = {point: p1, points: [p1], other: a, visited: false, entry: true, subject: false}; - a.other = b; + a = new d3_geo_clipPolygonIntersection(p1, segment, null, false); + b = new d3_geo_clipPolygonIntersection(p1, null, a, true); + a.o = b; subject.push(a); clip.push(b); }); @@ -1815,41 +2000,42 @@ function d3_geo_clipPolygon(segments, compare, inside, interpolate, listener) { d3_geo_clipPolygonLinkCircular(clip); if (!subject.length) return; - if (inside) for (var i = 1, e = !inside(clip[0].point), n = clip.length; i < n; ++i) { - clip[i].entry = (e = !e); + for (var i = 0, entry = clipStartInside, n = clip.length; i < n; ++i) { + clip[i].e = entry = !entry; } var start = subject[0], - current, points, point; while (1) { // Find first unvisited intersection. - current = start; - while (current.visited) if ((current = current.next) === start) return; - points = current.points; + var current = start, + isSubject = true; + while (current.v) if ((current = current.n) === start) return; + points = current.z; listener.lineStart(); do { - current.visited = current.other.visited = true; - if (current.entry) { - if (current.subject) { - for (var i = 0; i < points.length; i++) listener.point((point = points[i])[0], point[1]); + current.v = current.o.v = true; + if (current.e) { + if (isSubject) { + for (var i = 0, n = points.length; i < n; ++i) listener.point((point = points[i])[0], point[1]); } else { - interpolate(current.point, current.next.point, 1, listener); + interpolate(current.x, current.n.x, 1, listener); } - current = current.next; + current = current.n; } else { - if (current.subject) { - points = current.prev.points; - for (var i = points.length; --i >= 0;) listener.point((point = points[i])[0], point[1]); + if (isSubject) { + points = current.p.z; + for (var i = points.length - 1; i >= 0; --i) listener.point((point = points[i])[0], point[1]); } else { - interpolate(current.point, current.prev.point, -1, listener); + interpolate(current.x, current.p.x, -1, listener); } - current = current.prev; + current = current.p; } - current = current.other; - points = current.points; - } while (!current.visited); + current = current.o; + points = current.z; + isSubject = !isSubject; + } while (!current.v); listener.lineEnd(); } } @@ -1861,17 +2047,27 @@ function d3_geo_clipPolygonLinkCircular(array) { a = array[0], b; while (++i < n) { - a.next = b = array[i]; - b.prev = a; + a.n = b = array[i]; + b.p = a; a = b; } - a.next = b = array[0]; - b.prev = a; + a.n = b = array[0]; + b.p = a; } -function d3_geo_clip(pointVisible, clipLine, interpolate, polygonContains) { - return function(listener) { - var line = clipLine(listener); +function d3_geo_clipPolygonIntersection(point, points, other, entry) { + this.x = point; + this.z = points; + this.o = other; // another intersection + this.e = entry; // is an entry? + this.v = false; // visited + this.n = this.p = null; // next & previous +} + +function d3_geo_clip(pointVisible, clipLine, interpolate, clipStart) { + return function(rotate, listener) { + var line = clipLine(listener), + rotatedClipStart = rotate.invert(clipStart[0], clipStart[1]); var clip = { point: point, @@ -1891,9 +2087,10 @@ function d3_geo_clip(pointVisible, clipLine, interpolate, polygonContains) { clip.lineEnd = lineEnd; segments = d3.merge(segments); + var clipStartInside = d3_geo_pointInPolygon(rotatedClipStart, polygon); if (segments.length) { - d3_geo_clipPolygon(segments, d3_geo_clipSort, null, interpolate, listener); - } else if (polygonContains(polygon)) { + d3_geo_clipPolygon(segments, d3_geo_clipSort, clipStartInside, interpolate, listener); + } else if (clipStartInside) { listener.lineStart(); interpolate(null, null, 1, listener); listener.lineEnd(); @@ -1910,8 +2107,14 @@ function d3_geo_clip(pointVisible, clipLine, interpolate, polygonContains) { } }; - function point(λ, φ) { if (pointVisible(λ, φ)) listener.point(λ, φ); } - function pointLine(λ, φ) { line.point(λ, φ); } + function point(λ, φ) { + var point = rotate(λ, φ); + if (pointVisible(λ = point[0], φ = point[1])) listener.point(λ, φ); + } + function pointLine(λ, φ) { + var point = rotate(λ, φ); + line.point(point[0], point[1]); + } function lineStart() { clip.point = pointLine; line.lineStart(); } function lineEnd() { clip.point = point; line.lineEnd(); } @@ -1923,8 +2126,9 @@ function d3_geo_clip(pointVisible, clipLine, interpolate, polygonContains) { ring; function pointRing(λ, φ) { - ringListener.point(λ, φ); ring.push([λ, φ]); + var point = rotate(λ, φ); + ringListener.point(point[0], point[1]); } function ringStart() { @@ -1996,8 +2200,8 @@ function d3_geo_clipBufferListener() { // Intersection points are sorted along the clip edge. For both antimeridian // cutting and circle clipping, the same comparison is used. function d3_geo_clipSort(a, b) { - return ((a = a.point)[0] < 0 ? a[1] - π / 2 - ε : π / 2 - a[1]) - - ((b = b.point)[0] < 0 ? b[1] - π / 2 - ε : π / 2 - b[1]); + return ((a = a.x)[0] < 0 ? a[1] - halfπ - ε : halfπ - a[1]) + - ((b = b.x)[0] < 0 ? b[1] - halfπ - ε : halfπ - b[1]); } // Adds floating point numbers with twice the normal precision. // Reference: J. R. Shewchuk, Adaptive Precision Floating-Point Arithmetic and @@ -2063,12 +2267,12 @@ var d3_geo_streamGeometryType = { listener.sphere(); }, Point: function(object, listener) { - var coordinate = object.coordinates; - listener.point(coordinate[0], coordinate[1]); + object = object.coordinates; + listener.point(object[0], object[1], object[2]); }, MultiPoint: function(object, listener) { - var coordinates = object.coordinates, i = -1, n = coordinates.length, coordinate; - while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1]); + var coordinates = object.coordinates, i = -1, n = coordinates.length; + while (++i < n) object = coordinates[i], listener.point(object[0], object[1], object[2]); }, LineString: function(object, listener) { d3_geo_streamLine(object.coordinates, listener, 0); @@ -2093,7 +2297,7 @@ var d3_geo_streamGeometryType = { function d3_geo_streamLine(coordinates, listener, closed) { var i = -1, n = coordinates.length - closed, coordinate; listener.lineStart(); - while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1]); + while (++i < n) coordinate = coordinates[i], listener.point(coordinate[0], coordinate[1], coordinate[2]); listener.lineEnd(); } @@ -2218,8 +2422,6 @@ function d3_geo_pointInPolygon(point, polygon) { parallel = point[1], meridianNormal = [Math.sin(meridian), -Math.cos(meridian), 0], polarAngle = 0, - polar = false, - southPole = false, winding = 0; d3_geo_areaRingSum.reset(); @@ -2242,12 +2444,11 @@ function d3_geo_pointInPolygon(point, polygon) { sinφ = Math.sin(φ), cosφ = Math.cos(φ), dλ = λ - λ0, - antimeridian = Math.abs(dλ) > π, + antimeridian = abs(dλ) > π, k = sinφ0 * sinφ; d3_geo_areaRingSum.add(Math.atan2(k * Math.sin(dλ), cosφ0 * cosφ + k * Math.cos(dλ))); - if (Math.abs(φ) < ε) southPole = true; - polarAngle += antimeridian ? dλ + (dλ >= 0 ? 2 : -2) * π : dλ; + polarAngle += antimeridian ? dλ + (dλ >= 0 ? τ : -τ): dλ; // Are the longitudes either side of the point's meridian, and are the // latitudes smaller than the parallel? @@ -2257,34 +2458,34 @@ function d3_geo_pointInPolygon(point, polygon) { var intersection = d3_geo_cartesianCross(meridianNormal, arc); d3_geo_cartesianNormalize(intersection); var φarc = (antimeridian ^ dλ >= 0 ? -1 : 1) * d3_asin(intersection[2]); - if (parallel > φarc) { + if (parallel > φarc || parallel === φarc && (arc[0] || arc[1])) { winding += antimeridian ^ dλ >= 0 ? 1 : -1; } } if (!j++) break; λ0 = λ, sinφ0 = sinφ, cosφ0 = cosφ, point0 = point; } - if (Math.abs(polarAngle) > ε) polar = true; } // First, determine whether the South pole is inside or outside: // // It is inside if: - // * the polygon doesn't wind around it, and its area is negative (counter-clockwise). - // * otherwise, if the polygon winds around it in a clockwise direction. + // * the polygon winds around it in a clockwise direction. + // * the polygon does not (cumulatively) wind around it, but has a negative + // (counter-clockwise) area. // // Second, count the (signed) number of times a segment crosses a meridian // from the point to the South pole. If it is zero, then the point is the // same side as the South pole. - return (!southPole && !polar && d3_geo_areaRingSum < 0 || polarAngle < -ε) ^ (winding & 1); + return (polarAngle < -ε || polarAngle < ε && d3_geo_areaRingSum < 0) ^ (winding & 1); } var d3_geo_clipAntimeridian = d3_geo_clip( d3_true, d3_geo_clipAntimeridianLine, d3_geo_clipAntimeridianInterpolate, - d3_geo_clipAntimeridianPolygonContains); + [-π, -π / 2]); // Takes a line and cuts into visible segments. Return values: // 0: there were intersections or the line was empty. @@ -2304,9 +2505,9 @@ function d3_geo_clipAntimeridianLine(listener) { }, point: function(λ1, φ1) { var sλ1 = λ1 > 0 ? π : -π, - dλ = Math.abs(λ1 - λ0); - if (Math.abs(dλ - π) < ε) { // line crosses a pole - listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? π / 2 : -π / 2); + dλ = abs(λ1 - λ0); + if (abs(dλ - π) < ε) { // line crosses a pole + listener.point(λ0, φ0 = (φ0 + φ1) / 2 > 0 ? halfπ : -halfπ); listener.point(sλ0, φ0); listener.lineEnd(); listener.lineStart(); @@ -2315,8 +2516,8 @@ function d3_geo_clipAntimeridianLine(listener) { clean = 0; } else if (sλ0 !== sλ1 && dλ >= π) { // line crosses antimeridian // handle degeneracies - if (Math.abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε; - if (Math.abs(λ1 - sλ1) < ε) λ1 -= sλ1 * ε; + if (abs(λ0 - sλ0) < ε) λ0 -= sλ0 * ε; + if (abs(λ1 - sλ1) < ε) λ1 -= sλ1 * ε; φ0 = d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1); listener.point(sλ0, φ0); listener.lineEnd(); @@ -2340,7 +2541,7 @@ function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) { var cosφ0, cosφ1, sinλ0_λ1 = Math.sin(λ0 - λ1); - return Math.abs(sinλ0_λ1) > ε + return abs(sinλ0_λ1) > ε ? Math.atan((Math.sin(φ0) * (cosφ1 = Math.cos(φ1)) * Math.sin(λ1) - Math.sin(φ1) * (cosφ0 = Math.cos(φ0)) * Math.sin(λ0)) / (cosφ0 * cosφ1 * sinλ0_λ1)) @@ -2350,7 +2551,7 @@ function d3_geo_clipAntimeridianIntersect(λ0, φ0, λ1, φ1) { function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) { var φ; if (from == null) { - φ = direction * π / 2; + φ = direction * halfπ; listener.point(-π, φ); listener.point( 0, φ); listener.point( π, φ); @@ -2360,8 +2561,8 @@ function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) { listener.point(-π, -φ); listener.point(-π, 0); listener.point(-π, φ); - } else if (Math.abs(from[0] - to[0]) > ε) { - var s = (from[0] < to[0] ? 1 : -1) * π; + } else if (abs(from[0] - to[0]) > ε) { + var s = from[0] < to[0] ? π : -π; φ = direction * s / 2; listener.point(-s, φ); listener.point( 0, φ); @@ -2371,12 +2572,6 @@ function d3_geo_clipAntimeridianInterpolate(from, to, direction, listener) { } } -var d3_geo_clipAntimeridianPoint = [-π, 0]; - -function d3_geo_clipAntimeridianPolygonContains(polygon) { - return d3_geo_pointInPolygon(d3_geo_clipAntimeridianPoint, polygon); -} - function d3_geo_equirectangular(λ, φ) { return [λ, φ]; } @@ -2401,17 +2596,23 @@ d3.geo.rotation = function(rotate) { return forward; }; +function d3_geo_identityRotation(λ, φ) { + return [λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ]; +} + +d3_geo_identityRotation.invert = d3_geo_equirectangular; + // Note: |δλ| must be < 2π function d3_geo_rotation(δλ, δφ, δγ) { return δλ ? (δφ || δγ ? d3_geo_compose(d3_geo_rotationλ(δλ), d3_geo_rotationφγ(δφ, δγ)) : d3_geo_rotationλ(δλ)) : (δφ || δγ ? d3_geo_rotationφγ(δφ, δγ) - : d3_geo_equirectangular); + : d3_geo_identityRotation); } function d3_geo_forwardRotationλ(δλ) { return function(λ, φ) { - return λ += δλ, [λ > π ? λ - 2 * π : λ < -π ? λ + 2 * π : λ, φ]; + return λ += δλ, [λ > π ? λ - τ : λ < -π ? λ + τ : λ, φ]; }; } @@ -2502,16 +2703,16 @@ function d3_geo_circleInterpolate(radius, precision) { var cr = Math.cos(radius), sr = Math.sin(radius); return function(from, to, direction, listener) { + var step = direction * precision; if (from != null) { from = d3_geo_circleAngle(cr, from); to = d3_geo_circleAngle(cr, to); - if (direction > 0 ? from < to: from > to) from += direction * 2 * π; + if (direction > 0 ? from < to: from > to) from += direction * τ; } else { - from = radius + direction * 2 * π; - to = radius; + from = radius + direction * τ; + to = radius - .5 * step; } - var point; - for (var step = direction * precision, t = from; direction > 0 ? t > to : t < to; t -= step) { + for (var point, t = from; direction > 0 ? t > to : t < to; t -= step) { listener.point((point = d3_geo_spherical([ cr, -sr * Math.cos(t), @@ -2534,11 +2735,10 @@ function d3_geo_circleAngle(cr, point) { function d3_geo_clipCircle(radius) { var cr = Math.cos(radius), smallRadius = cr > 0, - point = [radius, 0], - notHemisphere = Math.abs(cr) > ε, // TODO optimise for this common case + notHemisphere = abs(cr) > ε, // TODO optimise for this common case interpolate = d3_geo_circleInterpolate(radius, 6 * d3_radians); - return d3_geo_clip(visible, clipLine, interpolate, polygonContains); + return d3_geo_clip(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-π, radius - π]); function visible(λ, φ) { return Math.cos(λ) * Math.cos(φ) > cr; @@ -2672,7 +2872,7 @@ function d3_geo_clipCircle(radius) { z; if (λ1 < λ0) z = λ0, λ0 = λ1, λ1 = z; var δλ = λ1 - λ0, - polar = Math.abs(δλ - π) < ε, + polar = abs(δλ - π) < ε, meridian = polar || δλ < ε; if (!polar && φ1 < φ0) z = φ0, φ0 = φ1, φ1 = z; @@ -2680,7 +2880,7 @@ function d3_geo_clipCircle(radius) { // Check that the first point is between a and b. if (meridian ? polar - ? φ0 + φ1 > 0 ^ q[1] < (Math.abs(q[0] - λ0) < ε ? φ0 : φ1) + ? φ0 + φ1 > 0 ^ q[1] < (abs(q[0] - λ0) < ε ? φ0 : φ1) : φ0 <= q[1] && q[1] <= φ1 : δλ > π ^ (λ0 <= q[0] && q[0] <= λ1)) { var q1 = d3_geo_cartesianScale(u, (-w + t) / uu); @@ -2700,18 +2900,101 @@ function d3_geo_clipCircle(radius) { else if (φ > r) code |= 8; // above return code; } - - function polygonContains(polygon) { - return d3_geo_pointInPolygon(point, polygon); - } } -var d3_geo_clipViewMAX = 1e9; +// Liang–Barsky line clipping. +function d3_geom_clipLine(x0, y0, x1, y1) { + return function(line) { + var a = line.a, + b = line.b, + ax = a.x, + ay = a.y, + bx = b.x, + by = b.y, + t0 = 0, + t1 = 1, + dx = bx - ax, + dy = by - ay, + r; -function d3_geo_clipView(x0, y0, x1, y1) { + r = x0 - ax; + if (!dx && r > 0) return; + r /= dx; + if (dx < 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } else if (dx > 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } + + r = x1 - ax; + if (!dx && r < 0) return; + r /= dx; + if (dx < 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } else if (dx > 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } + + r = y0 - ay; + if (!dy && r > 0) return; + r /= dy; + if (dy < 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } else if (dy > 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } + + r = y1 - ay; + if (!dy && r < 0) return; + r /= dy; + if (dy < 0) { + if (r > t1) return; + if (r > t0) t0 = r; + } else if (dy > 0) { + if (r < t0) return; + if (r < t1) t1 = r; + } + + if (t0 > 0) line.a = {x: ax + t0 * dx, y: ay + t0 * dy}; + if (t1 < 1) line.b = {x: ax + t1 * dx, y: ay + t1 * dy}; + return line; + }; +} + +var d3_geo_clipExtentMAX = 1e9; + +d3.geo.clipExtent = function() { + var x0, y0, x1, y1, + stream, + clip, + clipExtent = { + stream: function(output) { + if (stream) stream.valid = false; + stream = clip(output); + stream.valid = true; // allow caching by d3.geo.path + return stream; + }, + extent: function(_) { + if (!arguments.length) return [[x0, y0], [x1, y1]]; + clip = d3_geo_clipExtent(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]); + if (stream) stream.valid = false, stream = null; + return clipExtent; + } + }; + return clipExtent.extent([[0, 0], [960, 500]]); +}; + +function d3_geo_clipExtent(x0, y0, x1, y1) { return function(listener) { var listener_ = listener, bufferListener = d3_geo_clipBufferListener(), + clipLine = d3_geom_clipLine(x0, y0, x1, y1), segments, polygon, ring; @@ -2724,28 +3007,30 @@ function d3_geo_clipView(x0, y0, x1, y1) { listener = bufferListener; segments = []; polygon = []; + clean = true; }, polygonEnd: function() { listener = listener_; - if ((segments = d3.merge(segments)).length) { + segments = d3.merge(segments); + var clipStartInside = insidePolygon([x0, y1]), + inside = clean && clipStartInside, + visible = segments.length; + if (inside || visible) { listener.polygonStart(); - d3_geo_clipPolygon(segments, compare, inside, interpolate, listener); + if (inside) { + listener.lineStart(); + interpolate(null, null, 1, listener); + listener.lineEnd(); + } + if (visible) { + d3_geo_clipPolygon(segments, compare, clipStartInside, interpolate, listener); + } listener.polygonEnd(); - } else if (insidePolygon([x0, y0])) { - listener.polygonStart(), listener.lineStart(); - interpolate(null, null, 1, listener); - listener.lineEnd(), listener.polygonEnd(); } segments = polygon = ring = null; } }; - function inside(point) { - var a = corner(point, -1), - i = insidePolygon([a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0]); - return i; - } - function insidePolygon(p) { var wn = 0, // the winding number counter n = polygon.length, @@ -2782,17 +3067,18 @@ function d3_geo_clipView(x0, y0, x1, y1) { } } - function visible(x, y) { + function pointVisible(x, y) { return x0 <= x && x <= x1 && y0 <= y && y <= y1; } function point(x, y) { - if (visible(x, y)) listener.point(x, y); + if (pointVisible(x, y)) listener.point(x, y); } var x__, y__, v__, // first point x_, y_, v_, // previous point - first; + first, + clean; function lineStart() { clip.point = linePoint; @@ -2816,9 +3102,9 @@ function d3_geo_clipView(x0, y0, x1, y1) { } function linePoint(x, y) { - x = Math.max(-d3_geo_clipViewMAX, Math.min(d3_geo_clipViewMAX, x)); - y = Math.max(-d3_geo_clipViewMAX, Math.min(d3_geo_clipViewMAX, y)); - var v = visible(x, y); + x = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, x)); + y = Math.max(-d3_geo_clipExtentMAX, Math.min(d3_geo_clipExtentMAX, y)); + var v = pointVisible(x, y); if (polygon) ring.push([x, y]); if (first) { x__ = x, y__ = y, v__ = v; @@ -2830,18 +3116,19 @@ function d3_geo_clipView(x0, y0, x1, y1) { } else { if (v && v_) listener.point(x, y); else { - var a = [x_, y_], - b = [x, y]; - if (clipLine(a, b)) { + var l = {a: {x: x_, y: y_}, b: {x: x, y: y}}; + if (clipLine(l)) { if (!v_) { listener.lineStart(); - listener.point(a[0], a[1]); + listener.point(l.a.x, l.a.y); } - listener.point(b[0], b[1]); + listener.point(l.b.x, l.b.y); if (!v) listener.lineEnd(); + clean = false; } else if (v) { listener.lineStart(); listener.point(x, y); + clean = false; } } } @@ -2852,14 +3139,14 @@ function d3_geo_clipView(x0, y0, x1, y1) { }; function corner(p, direction) { - return Math.abs(p[0] - x0) < ε ? direction > 0 ? 0 : 3 - : Math.abs(p[0] - x1) < ε ? direction > 0 ? 2 : 1 - : Math.abs(p[1] - y0) < ε ? direction > 0 ? 1 : 0 - : direction > 0 ? 3 : 2; // Math.abs(p[1] - y1) < ε + return abs(p[0] - x0) < ε ? direction > 0 ? 0 : 3 + : abs(p[0] - x1) < ε ? direction > 0 ? 2 : 1 + : abs(p[1] - y0) < ε ? direction > 0 ? 1 : 0 + : direction > 0 ? 3 : 2; // abs(p[1] - y1) < ε } function compare(a, b) { - return comparePoints(a.point, b.point); + return comparePoints(a.x, b.x); } function comparePoints(a, b) { @@ -2871,47 +3158,6 @@ function d3_geo_clipView(x0, y0, x1, y1) { : ca === 2 ? a[1] - b[1] : b[0] - a[0]; } - - // Liang–Barsky line clipping. - function clipLine(a, b) { - var dx = b[0] - a[0], - dy = b[1] - a[1], - t = [0, 1]; - - if (Math.abs(dx) < ε && Math.abs(dy) < ε) return x0 <= a[0] && a[0] <= x1 && y0 <= a[1] && a[1] <= y1; - - if (d3_geo_clipViewT(x0 - a[0], dx, t) && - d3_geo_clipViewT(a[0] - x1, -dx, t) && - d3_geo_clipViewT(y0 - a[1], dy, t) && - d3_geo_clipViewT(a[1] - y1, -dy, t)) { - if (t[1] < 1) { - b[0] = a[0] + t[1] * dx; - b[1] = a[1] + t[1] * dy; - } - if (t[0] > 0) { - a[0] += t[0] * dx; - a[1] += t[0] * dy; - } - return true; - } - - return false; - } -} - -function d3_geo_clipViewT(num, denominator, t) { - if (Math.abs(denominator) < ε) return num <= 0; - - var u = num / denominator; - - if (denominator > 0) { - if (u > t[1]) return false; - if (u > t[0]) t[0] = u; - } else { - if (u < t[0]) return false; - if (u < t[1]) t[1] = u; - } - return true; } function d3_geo_compose(a, b) { @@ -3154,7 +3400,7 @@ d3.geo.bounds = (function() { var dλ = λ - λ_, s = dλ > 0 ? 1 : -1, λi = inflection[0] * d3_degrees * s, - antimeridian = Math.abs(dλ) > 180; + antimeridian = abs(dλ) > 180; if (antimeridian ^ (s * λ_ < λi && λi < s * λ)) { var φi = inflection[1] * d3_degrees; if (φi > φ1) φ1 = φi; @@ -3199,7 +3445,7 @@ d3.geo.bounds = (function() { function ringPoint(λ, φ) { if (p0) { var dλ = λ - λ_; - dλSum += Math.abs(dλ) > 180 ? dλ + (dλ > 0 ? 360 : -360) : dλ; + dλSum += abs(dλ) > 180 ? dλ + (dλ > 0 ? 360 : -360) : dλ; } else λ__ = λ, φ__ = φ; d3_geo_area.point(λ, φ); linePoint(λ, φ); @@ -3212,7 +3458,7 @@ d3.geo.bounds = (function() { function ringEnd() { ringPoint(λ__, φ__); d3_geo_area.lineEnd(); - if (Math.abs(dλSum) > ε) λ0 = -(λ1 = 180); + if (abs(dλSum) > ε) λ0 = -(λ1 = 180); range[0] = λ0, range[1] = λ1; p0 = null; } @@ -3425,7 +3671,7 @@ var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = { }, polygonEnd: function() { d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop; - d3_geo_pathAreaSum += Math.abs(d3_geo_pathAreaPolygon / 2); + d3_geo_pathAreaSum += abs(d3_geo_pathAreaPolygon / 2); } }; @@ -3630,7 +3876,7 @@ function d3_geo_pathContext(context) { function point(x, y) { context.moveTo(x, y); - context.arc(x, y, pointRadius, 0, 2 * π); + context.arc(x, y, pointRadius, 0, τ); } function pointLineStart(x, y) { @@ -3722,7 +3968,7 @@ function d3_geo_resample(project) { c = c0 + c1, m = Math.sqrt(a * a + b * b + c * c), φ2 = Math.asin(c /= m), - λ2 = Math.abs(Math.abs(c) - 1) < ε ? (λ0 + λ1) / 2 : Math.atan2(b, a), + λ2 = abs(abs(c) - 1) < ε ? (λ0 + λ1) / 2 : Math.atan2(b, a), p = project(λ2, φ2), x2 = p[0], y2 = p[1], @@ -3730,7 +3976,7 @@ function d3_geo_resample(project) { dy2 = y2 - y0, dz = dy * dx2 - dx * dy2; if (dz * dz / d2 > δ2 // perpendicular projected distance - || Math.abs((dx * dx2 + dy * dy2) / d2 - .5) > .3 // midpoint close to an end + || abs((dx * dx2 + dy * dy2) / d2 - .5) > .3 // midpoint close to an end || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { // angular distance resampleLineTo(x0, y0, λ0, a0, b0, c0, x2, y2, λ2, a /= m, b /= m, c, depth, stream); stream.point(x2, y2); @@ -3748,6 +3994,29 @@ function d3_geo_resample(project) { return resample; } +d3.geo.transform = function(methods) { + return { + stream: function(stream) { + var transform = new d3_geo_transform(stream); + for (var k in methods) transform[k] = methods[k]; + return transform; + } + }; +}; + +function d3_geo_transform(stream) { + this.stream = stream; +} + +d3_geo_transform.prototype = { + point: function(x, y) { this.stream.point(x, y); }, + sphere: function() { this.stream.sphere(); }, + lineStart: function() { this.stream.lineStart(); }, + lineEnd: function() { this.stream.lineEnd(); }, + polygonStart: function() { this.stream.polygonStart(); }, + polygonEnd: function() { this.stream.polygonEnd(); } +}; + d3.geo.path = function() { var pointRadius = 4.5, projection, @@ -3816,17 +4085,11 @@ d3.geo.path = function() { }; function d3_geo_pathProjectStream(project) { - var resample = d3_geo_resample(function(λ, φ) { return project([λ * d3_degrees, φ * d3_degrees]); }); + var resample = d3_geo_resample(function(x, y) { return project([x * d3_degrees, y * d3_degrees]); }); return function(stream) { - stream = resample(stream); - return { - point: function(λ, φ) { stream.point(λ * d3_radians, φ * d3_radians); }, - sphere: function() { stream.sphere(); }, - lineStart: function() { stream.lineStart(); }, - lineEnd: function() { stream.lineEnd(); }, - polygonStart: function() { stream.polygonStart(); }, - polygonEnd: function() { stream.polygonEnd(); } - }; + var transform = new d3_geo_transform(stream = resample(stream)); + transform.point = function(x, y) { stream.point(x * d3_radians, y * d3_radians); }; + return transform; }; } @@ -3865,7 +4128,7 @@ function d3_geo_projectionMutator(projectAt) { projection.stream = function(output) { if (stream) stream.valid = false; - stream = d3_geo_projectionRadiansRotate(rotate, preclip(projectResample(postclip(output)))); + stream = d3_geo_projectionRadians(preclip(rotate, projectResample(postclip(output)))); stream.valid = true; // allow caching by d3.geo.path return stream; }; @@ -3879,7 +4142,7 @@ function d3_geo_projectionMutator(projectAt) { projection.clipExtent = function(_) { if (!arguments.length) return clipExtent; clipExtent = _; - postclip = _ == null ? d3_identity : d3_geo_clipView(_[0][0], _[0][1], _[1][0], _[1][1]); + postclip = _ ? d3_geo_clipExtent(_[0][0], _[0][1], _[1][0], _[1][1]) : d3_identity; return invalidate(); }; @@ -3922,10 +4185,7 @@ function d3_geo_projectionMutator(projectAt) { } function invalidate() { - if (stream) { - stream.valid = false; - stream = null; - } + if (stream) stream.valid = false, stream = null; return projection; } @@ -3936,18 +4196,12 @@ function d3_geo_projectionMutator(projectAt) { }; } -function d3_geo_projectionRadiansRotate(rotate, stream) { - return { - point: function(x, y) { - y = rotate(x * d3_radians, y * d3_radians), x = y[0]; - stream.point(x > π ? x - 2 * π : x < -π ? x + 2 * π : x, y[1]); - }, - sphere: function() { stream.sphere(); }, - lineStart: function() { stream.lineStart(); }, - lineEnd: function() { stream.lineEnd(); }, - polygonStart: function() { stream.polygonStart(); }, - polygonEnd: function() { stream.polygonEnd(); } +function d3_geo_projectionRadians(stream) { + var transform = new d3_geo_transform(stream); + transform.point = function(λ, φ) { + stream.point(λ * d3_radians, φ * d3_radians); }; + return transform; } function d3_geo_mercator(λ, φ) { @@ -3955,7 +4209,7 @@ function d3_geo_mercator(λ, φ) { } d3_geo_mercator.invert = function(x, y) { - return [x, 2 * Math.atan(Math.exp(y)) - π / 2]; + return [x, 2 * Math.atan(Math.exp(y)) - halfπ]; }; function d3_geo_mercatorProjection(project) { @@ -4127,7 +4381,7 @@ d3.ease = function(name) { m = i >= 0 ? name.substring(i + 1) : "in"; t = d3_ease.get(t) || d3_ease_default; m = d3_ease_mode.get(m) || d3_identity; - return d3_ease_clamp(m(t.apply(null, Array.prototype.slice.call(arguments, 1)))); + return d3_ease_clamp(m(t.apply(null, d3_arraySlice.call(arguments, 1)))); }; function d3_ease_clamp(f) { @@ -4171,7 +4425,7 @@ function d3_ease_poly(e) { } function d3_ease_sin(t) { - return 1 - Math.cos(t * π / 2); + return 1 - Math.cos(t * halfπ); } function d3_ease_exp(t) { @@ -4185,10 +4439,10 @@ function d3_ease_circle(t) { function d3_ease_elastic(a, p) { var s; if (arguments.length < 2) p = 0.45; - if (arguments.length) s = p / (2 * π) * Math.asin(1 / a); + if (arguments.length) s = p / τ * Math.asin(1 / a); else a = 1, s = p / 4; return function(t) { - return 1 + a * Math.pow(2, 10 * -t) * Math.sin((t - s) * 2 * π / p); + return 1 + a * Math.pow(2, -10 * t) * Math.sin((t - s) * τ / p); }; } @@ -5203,7 +5457,7 @@ function d3_transition_text(b) { d3_transitionPrototype.remove = function() { return this.each("end.transition", function() { var p; - if (!this.__transition__ && (p = this.parentNode)) p.removeChild(this); + if (this.__transition__.count < 2 && (p = this.parentNode)) p.removeChild(this); }); }; @@ -5217,15 +5471,15 @@ d3_transitionPrototype.ease = function(value) { d3_transitionPrototype.delay = function(value) { var id = this.id; return d3_selection_each(this, typeof value === "function" - ? function(node, i, j) { node.__transition__[id].delay = value.call(node, node.__data__, i, j) | 0; } - : (value |= 0, function(node) { node.__transition__[id].delay = value; })); + ? function(node, i, j) { node.__transition__[id].delay = +value.call(node, node.__data__, i, j); } + : (value = +value, function(node) { node.__transition__[id].delay = value; })); }; d3_transitionPrototype.duration = function(value) { var id = this.id; return d3_selection_each(this, typeof value === "function" - ? function(node, i, j) { node.__transition__[id].duration = Math.max(1, value.call(node, node.__data__, i, j) | 0); } - : (value = Math.max(1, value | 0), function(node) { node.__transition__[id].duration = value; })); + ? function(node, i, j) { node.__transition__[id].duration = Math.max(1, value.call(node, node.__data__, i, j)); } + : (value = Math.max(1, value), function(node) { node.__transition__[id].duration = value; })); }; d3_transitionPrototype.each = function(type, listener) { @@ -5295,10 +5549,12 @@ function d3_transitionNode(node, i, id, inherit) { ease = transition.ease, delay = transition.delay, duration = transition.duration, + timer = d3_timer_active, tweened = []; - if (delay <= elapsed) return start(elapsed); - d3_timer_replace(start, delay, time); + timer.t = delay + time; + if (delay <= elapsed) return start(elapsed - delay); + timer.c = start; function start(elapsed) { if (lock.active > id) return stop(); @@ -5311,14 +5567,16 @@ function d3_transitionNode(node, i, id, inherit) { } }); - if (tick(elapsed)) return 1; - d3_timer_replace(tick, 0, time); + d3.timer(function() { // defer to end of current frame + timer.c = tick(elapsed || 1) ? d3_true : tick; + return 1; + }, 0, time); } function tick(elapsed) { if (lock.active !== id) return stop(); - var t = (elapsed - delay) / duration, + var t = elapsed / duration, e = ease(t), n = tweened.length; @@ -5327,9 +5585,8 @@ function d3_transitionNode(node, i, id, inherit) { } if (t >= 1) { - stop(); transition.event && transition.event.end.call(node, d, i); - return 1; + return stop(); } } @@ -5353,7 +5610,7 @@ function d3_xhrType(response) { function d3_xhr(url, mimeType, response, callback) { var xhr = {}, - dispatch = d3.dispatch("progress", "load", "error"), + dispatch = d3.dispatch("beforesend", "progress", "load", "error"), headers = {}, request = new XMLHttpRequest, responseType = null; @@ -5435,6 +5692,7 @@ function d3_xhr(url, mimeType, response, callback) { if (mimeType != null && request.overrideMimeType) request.overrideMimeType(mimeType); if (responseType != null) request.responseType = responseType; if (callback != null) xhr.on("error", callback).on("load", function(request) { callback(null, request); }); + dispatch.beforesend.call(xhr, request); request.send(data == null ? null : data); return xhr; }; diff --git a/package.json b/package.json index 7eabf77fb..de4116c4e 100644 --- a/package.json +++ b/package.json @@ -20,7 +20,7 @@ ], "license": "WTFPL", "devDependencies": { - "d3": "3", + "d3": "3.3.8", "smash": "0.0", "uglify-js": "~2.2.5", "maki": "0.1",