diff options
Diffstat (limited to 'tools/grid_frequency_spectra.ipynb')
| -rw-r--r-- | tools/grid_frequency_spectra.ipynb | 4206 |
1 files changed, 4206 insertions, 0 deletions
diff --git a/tools/grid_frequency_spectra.ipynb b/tools/grid_frequency_spectra.ipynb new file mode 100644 index 0000000..ba7c48d --- /dev/null +++ b/tools/grid_frequency_spectra.ipynb @@ -0,0 +1,4206 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import csv\n", + "\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "import scipy.fftpack" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "data = np.genfromtxt('Netzfrequenz_Sekundenwerte_2012_KW37.csv', delimiter=',')[1:,1:]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'] / mpl.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", + " var x1 = msg['x1'] / mpl.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys (original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object')\n", + " obj[key] = original[key]\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * mpl.ratio;\n", + " var y = canvas_pos.y * mpl.ratio;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event)});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value,\n", + " guiEvent: simpleKeys(event)});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " var width = fig.canvas.width/mpl.ratio\n", + " fig.root.unbind('remove')\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", + " fig.close_ws(fig, msg);\n", + "}\n", + "\n", + "mpl.figure.prototype.close_ws = function(fig, msg){\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width/mpl.ratio\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\" width=\"640\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "[<matplotlib.lines.Line2D at 0x7608496bfed0>]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt.plot(data[:3600*24, 0])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.02051102806199375" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.std(data[:,0])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/lib/python3.7/site-packages/ipykernel_launcher.py:7: DeprecationWarning: object of type <class 'float'> cannot be safely interpreted as an integer.\n", + " import sys\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'] / mpl.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", + " var x1 = msg['x1'] / mpl.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys (original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object')\n", + " obj[key] = original[key]\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * mpl.ratio;\n", + " var y = canvas_pos.y * mpl.ratio;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event)});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value,\n", + " guiEvent: simpleKeys(event)});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " var width = fig.canvas.width/mpl.ratio\n", + " fig.root.unbind('remove')\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", + " fig.close_ws(fig, msg);\n", + "}\n", + "\n", + "mpl.figure.prototype.close_ws = function(fig, msg){\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width/mpl.ratio\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\" width=\"640\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ys = scipy.fftpack.fft(data[:,0])\n", + "ys = 2.0/len(data) * np.abs(ys[:len(data)//2])\n", + "s = 60\n", + "\n", + "ys = np.convolve(ys, np.ones((s,))/s, mode='valid')\n", + "\n", + "xs = np.linspace(0, 1.0/2.0, len(data)/2)\n", + "#xs = np.linspace(len(data)/2, 1, len(data)/2)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.loglog(xs[s//2:-s//2+1], ys)\n", + "ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, _pos: 1/x))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/lib/python3.7/site-packages/ipykernel_launcher.py:7: DeprecationWarning: object of type <class 'float'> cannot be safely interpreted as an integer.\n", + " import sys\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'] / mpl.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", + " var x1 = msg['x1'] / mpl.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys (original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object')\n", + " obj[key] = original[key]\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * mpl.ratio;\n", + " var y = canvas_pos.y * mpl.ratio;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event)});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value,\n", + " guiEvent: simpleKeys(event)});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " var width = fig.canvas.width/mpl.ratio\n", + " fig.root.unbind('remove')\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", + " fig.close_ws(fig, msg);\n", + "}\n", + "\n", + "mpl.figure.prototype.close_ws = function(fig, msg){\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width/mpl.ratio\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\" width=\"640\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ys = scipy.fftpack.fft(data[:,0])\n", + "ys = 2.0/len(data) * np.abs(ys[:len(data)//2])\n", + "s = 1\n", + "\n", + "ys = np.convolve(ys, np.ones((s,))/s, mode='valid')\n", + "\n", + "xs = np.linspace(0, 1.0/2.0, len(data)/2)\n", + "#xs = np.linspace(len(data)/2, 1, len(data)/2)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.loglog(xs[s//2:-s//2+1 if s > 1 else None], ys)\n", + "ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, _pos: 1/x))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/lib/python3.7/site-packages/ipykernel_launcher.py:7: DeprecationWarning: object of type <class 'float'> cannot be safely interpreted as an integer.\n", + " import sys\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'] / mpl.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", + " var x1 = msg['x1'] / mpl.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys (original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object')\n", + " obj[key] = original[key]\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * mpl.ratio;\n", + " var y = canvas_pos.y * mpl.ratio;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event)});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value,\n", + " guiEvent: simpleKeys(event)});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " var width = fig.canvas.width/mpl.ratio\n", + " fig.root.unbind('remove')\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", + " fig.close_ws(fig, msg);\n", + "}\n", + "\n", + "mpl.figure.prototype.close_ws = function(fig, msg){\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width/mpl.ratio\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\" width=\"640\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ys = scipy.fftpack.fft(data[:,0])\n", + "ys = 2.0/len(data) * np.abs(ys[:len(data)//2])\n", + "s = 1\n", + "\n", + "ys = np.convolve(ys, np.ones((s,))/s, mode='valid')\n", + "\n", + "xs = np.linspace(0, 1.0/2.0, len(data)/2)\n", + "\n", + "ys *= 2*np.pi*xs\n", + "#xs = np.linspace(len(data)/2, 1, len(data)/2)\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.loglog(xs[s//2:-s//2+1 if s > 1 else None], ys)\n", + "ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, _pos: 1/x))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/lib/python3.7/site-packages/ipykernel_launcher.py:7: DeprecationWarning: object of type <class 'float'> cannot be safely interpreted as an integer.\n", + " import sys\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('<div/>');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", + " 'ui-helper-clearfix\"/>');\n", + " var titletext = $(\n", + " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", + " 'text-align: center; padding: 3px;\"/>');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('<div/>');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('<canvas/>');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('<canvas/>');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('<button/>');\n", + " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", + " 'ui-button-icon-only');\n", + " button.attr('role', 'button');\n", + " button.attr('aria-disabled', 'false');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + "\n", + " var icon_img = $('<span/>');\n", + " icon_img.addClass('ui-button-icon-primary ui-icon');\n", + " icon_img.addClass(image);\n", + " icon_img.addClass('ui-corner-all');\n", + "\n", + " var tooltip_span = $('<span/>');\n", + " tooltip_span.addClass('ui-button-text');\n", + " tooltip_span.html(tooltip);\n", + "\n", + " button.append(icon_img);\n", + " button.append(tooltip_span);\n", + "\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " var fmt_picker_span = $('<span/>');\n", + "\n", + " var fmt_picker = $('<select/>');\n", + " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", + " fmt_picker_span.append(fmt_picker);\n", + " nav_element.append(fmt_picker_span);\n", + " this.format_dropdown = fmt_picker[0];\n", + "\n", + " for (var ind in mpl.extensions) {\n", + " var fmt = mpl.extensions[ind];\n", + " var option = $(\n", + " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", + " fmt_picker.append(option)\n", + " }\n", + "\n", + " // Add hover states to the ui-buttons\n", + " $( \".ui-button\" ).hover(\n", + " function() { $(this).addClass(\"ui-state-hover\");},\n", + " function() { $(this).removeClass(\"ui-state-hover\");}\n", + " );\n", + "\n", + " var status_bar = $('<span class=\"mpl-message\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "}\n", + "\n", + "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", + " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", + " // which will in turn request a refresh of the image.\n", + " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", + "}\n", + "\n", + "mpl.figure.prototype.send_message = function(type, properties) {\n", + " properties['type'] = type;\n", + " properties['figure_id'] = this.id;\n", + " this.ws.send(JSON.stringify(properties));\n", + "}\n", + "\n", + "mpl.figure.prototype.send_draw_message = function() {\n", + " if (!this.waiting) {\n", + " this.waiting = true;\n", + " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", + " }\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " var format_dropdown = fig.format_dropdown;\n", + " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", + " fig.ondownload(fig, format);\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", + " var size = msg['size'];\n", + " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", + " fig._resize_canvas(size[0], size[1]);\n", + " fig.send_message(\"refresh\", {});\n", + " };\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", + " var x0 = msg['x0'] / mpl.ratio;\n", + " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", + " var x1 = msg['x1'] / mpl.ratio;\n", + " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", + " x0 = Math.floor(x0) + 0.5;\n", + " y0 = Math.floor(y0) + 0.5;\n", + " x1 = Math.floor(x1) + 0.5;\n", + " y1 = Math.floor(y1) + 0.5;\n", + " var min_x = Math.min(x0, x1);\n", + " var min_y = Math.min(y0, y1);\n", + " var width = Math.abs(x1 - x0);\n", + " var height = Math.abs(y1 - y0);\n", + "\n", + " fig.rubberband_context.clearRect(\n", + " 0, 0, fig.canvas.width, fig.canvas.height);\n", + "\n", + " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", + " // Updates the figure title.\n", + " fig.header.textContent = msg['label'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", + " var cursor = msg['cursor'];\n", + " switch(cursor)\n", + " {\n", + " case 0:\n", + " cursor = 'pointer';\n", + " break;\n", + " case 1:\n", + " cursor = 'default';\n", + " break;\n", + " case 2:\n", + " cursor = 'crosshair';\n", + " break;\n", + " case 3:\n", + " cursor = 'move';\n", + " break;\n", + " }\n", + " fig.rubberband_canvas.style.cursor = cursor;\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_message = function(fig, msg) {\n", + " fig.message.textContent = msg['message'];\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", + " // Request the server to send over a new figure.\n", + " fig.send_draw_message();\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", + " fig.image_mode = msg['mode'];\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Called whenever the canvas gets updated.\n", + " this.send_message(\"ack\", {});\n", + "}\n", + "\n", + "// A function to construct a web socket function for onmessage handling.\n", + "// Called in the figure constructor.\n", + "mpl.figure.prototype._make_on_message_function = function(fig) {\n", + " return function socket_on_message(evt) {\n", + " if (evt.data instanceof Blob) {\n", + " /* FIXME: We get \"Resource interpreted as Image but\n", + " * transferred with MIME type text/plain:\" errors on\n", + " * Chrome. But how to set the MIME type? It doesn't seem\n", + " * to be part of the websocket stream */\n", + " evt.data.type = \"image/png\";\n", + "\n", + " /* Free the memory for the previous frames */\n", + " if (fig.imageObj.src) {\n", + " (window.URL || window.webkitURL).revokeObjectURL(\n", + " fig.imageObj.src);\n", + " }\n", + "\n", + " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", + " evt.data);\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", + " fig.imageObj.src = evt.data;\n", + " fig.updated_canvas_event();\n", + " fig.waiting = false;\n", + " return;\n", + " }\n", + "\n", + " var msg = JSON.parse(evt.data);\n", + " var msg_type = msg['type'];\n", + "\n", + " // Call the \"handle_{type}\" callback, which takes\n", + " // the figure and JSON message as its only arguments.\n", + " try {\n", + " var callback = fig[\"handle_\" + msg_type];\n", + " } catch (e) {\n", + " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", + " return;\n", + " }\n", + "\n", + " if (callback) {\n", + " try {\n", + " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", + " callback(fig, msg);\n", + " } catch (e) {\n", + " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", + " }\n", + " }\n", + " };\n", + "}\n", + "\n", + "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", + "mpl.findpos = function(e) {\n", + " //this section is from http://www.quirksmode.org/js/events_properties.html\n", + " var targ;\n", + " if (!e)\n", + " e = window.event;\n", + " if (e.target)\n", + " targ = e.target;\n", + " else if (e.srcElement)\n", + " targ = e.srcElement;\n", + " if (targ.nodeType == 3) // defeat Safari bug\n", + " targ = targ.parentNode;\n", + "\n", + " // jQuery normalizes the pageX and pageY\n", + " // pageX,Y are the mouse positions relative to the document\n", + " // offset() returns the position of the element relative to the document\n", + " var x = e.pageX - $(targ).offset().left;\n", + " var y = e.pageY - $(targ).offset().top;\n", + "\n", + " return {\"x\": x, \"y\": y};\n", + "};\n", + "\n", + "/*\n", + " * return a copy of an object with only non-object keys\n", + " * we need this to avoid circular references\n", + " * http://stackoverflow.com/a/24161582/3208463\n", + " */\n", + "function simpleKeys (original) {\n", + " return Object.keys(original).reduce(function (obj, key) {\n", + " if (typeof original[key] !== 'object')\n", + " obj[key] = original[key]\n", + " return obj;\n", + " }, {});\n", + "}\n", + "\n", + "mpl.figure.prototype.mouse_event = function(event, name) {\n", + " var canvas_pos = mpl.findpos(event)\n", + "\n", + " if (name === 'button_press')\n", + " {\n", + " this.canvas.focus();\n", + " this.canvas_div.focus();\n", + " }\n", + "\n", + " var x = canvas_pos.x * mpl.ratio;\n", + " var y = canvas_pos.y * mpl.ratio;\n", + "\n", + " this.send_message(name, {x: x, y: y, button: event.button,\n", + " step: event.step,\n", + " guiEvent: simpleKeys(event)});\n", + "\n", + " /* This prevents the web browser from automatically changing to\n", + " * the text insertion cursor when the button is pressed. We want\n", + " * to control all of the cursor setting manually through the\n", + " * 'cursor' event from matplotlib */\n", + " event.preventDefault();\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " // Handle any extra behaviour associated with a key event\n", + "}\n", + "\n", + "mpl.figure.prototype.key_event = function(event, name) {\n", + "\n", + " // Prevent repeat events\n", + " if (name == 'key_press')\n", + " {\n", + " if (event.which === this._key)\n", + " return;\n", + " else\n", + " this._key = event.which;\n", + " }\n", + " if (name == 'key_release')\n", + " this._key = null;\n", + "\n", + " var value = '';\n", + " if (event.ctrlKey && event.which != 17)\n", + " value += \"ctrl+\";\n", + " if (event.altKey && event.which != 18)\n", + " value += \"alt+\";\n", + " if (event.shiftKey && event.which != 16)\n", + " value += \"shift+\";\n", + "\n", + " value += 'k';\n", + " value += event.which.toString();\n", + "\n", + " this._key_event_extra(event, name);\n", + "\n", + " this.send_message(name, {key: value,\n", + " guiEvent: simpleKeys(event)});\n", + " return false;\n", + "}\n", + "\n", + "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", + " if (name == 'download') {\n", + " this.handle_save(this, null);\n", + " } else {\n", + " this.send_message(\"toolbar_button\", {name: name});\n", + " }\n", + "};\n", + "\n", + "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", + " this.message.textContent = tooltip;\n", + "};\n", + "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", + "\n", + "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", + "\n", + "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", + " // Create a \"websocket\"-like object which calls the given IPython comm\n", + " // object with the appropriate methods. Currently this is a non binary\n", + " // socket, so there is still some room for performance tuning.\n", + " var ws = {};\n", + "\n", + " ws.close = function() {\n", + " comm.close()\n", + " };\n", + " ws.send = function(m) {\n", + " //console.log('sending', m);\n", + " comm.send(m);\n", + " };\n", + " // Register the callback with on_msg.\n", + " comm.on_msg(function(msg) {\n", + " //console.log('receiving', msg['content']['data'], msg);\n", + " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", + " ws.onmessage(msg['content']['data'])\n", + " });\n", + " return ws;\n", + "}\n", + "\n", + "mpl.mpl_figure_comm = function(comm, msg) {\n", + " // This is the function which gets called when the mpl process\n", + " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", + "\n", + " var id = msg.content.data.id;\n", + " // Get hold of the div created by the display call when the Comm\n", + " // socket was opened in Python.\n", + " var element = $(\"#\" + id);\n", + " var ws_proxy = comm_websocket_adapter(comm)\n", + "\n", + " function ondownload(figure, format) {\n", + " window.open(figure.imageObj.src);\n", + " }\n", + "\n", + " var fig = new mpl.figure(id, ws_proxy,\n", + " ondownload,\n", + " element.get(0));\n", + "\n", + " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", + " // web socket which is closed, not our websocket->open comm proxy.\n", + " ws_proxy.onopen();\n", + "\n", + " fig.parent_element = element.get(0);\n", + " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", + " if (!fig.cell_info) {\n", + " console.error(\"Failed to find cell for figure\", id, fig);\n", + " return;\n", + " }\n", + "\n", + " var output_index = fig.cell_info[2]\n", + " var cell = fig.cell_info[0];\n", + "\n", + "};\n", + "\n", + "mpl.figure.prototype.handle_close = function(fig, msg) {\n", + " var width = fig.canvas.width/mpl.ratio\n", + " fig.root.unbind('remove')\n", + "\n", + " // Update the output cell to use the data from the current canvas.\n", + " fig.push_to_output();\n", + " var dataURL = fig.canvas.toDataURL();\n", + " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", + " // the notebook keyboard shortcuts fail.\n", + " IPython.keyboard_manager.enable()\n", + " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", + " fig.close_ws(fig, msg);\n", + "}\n", + "\n", + "mpl.figure.prototype.close_ws = function(fig, msg){\n", + " fig.send_message('closing', msg);\n", + " // fig.ws.close()\n", + "}\n", + "\n", + "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", + " // Turn the data on the canvas into data in the output cell.\n", + " var width = this.canvas.width/mpl.ratio\n", + " var dataURL = this.canvas.toDataURL();\n", + " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", + "}\n", + "\n", + "mpl.figure.prototype.updated_canvas_event = function() {\n", + " // Tell IPython that the notebook contents must change.\n", + " IPython.notebook.set_dirty(true);\n", + " this.send_message(\"ack\", {});\n", + " var fig = this;\n", + " // Wait a second, then push the new image to the DOM so\n", + " // that it is saved nicely (might be nice to debounce this).\n", + " setTimeout(function () { fig.push_to_output() }, 1000);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('<div/>')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items){\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) { continue; };\n", + "\n", + " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", + " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i<ncells; i++) {\n", + " var cell = cells[i];\n", + " if (cell.cell_type === 'code'){\n", + " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", + " var data = cell.output_area.outputs[j];\n", + " if (data.data) {\n", + " // IPython >= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "<IPython.core.display.Javascript object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<img src=\"data:image/png;base64,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\" width=\"900\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ys = scipy.fftpack.fft(data[:,0])\n", + "ys = 2.0/len(data) * np.abs(ys[:len(data)//2])\n", + "s = 30\n", + "\n", + "ys = np.convolve(ys, np.ones((s,))/s, mode='valid')\n", + "\n", + "xs = np.linspace(0, 1.0/2.0, len(data)/2)\n", + "\n", + "ys *= 2*np.pi*xs[s//2:-s//2+1]\n", + "\n", + "#xs = np.linspace(len(data)/2, 1, len(data)/2)\n", + "\n", + "fig, ax = plt.subplots(figsize=(9,5))\n", + "ax.loglog(xs[s//2:-s//2+1], ys)\n", + "ax.xaxis.set_major_formatter(plt.FuncFormatter(lambda x, _pos: 1/x))\n", + "ax.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15.923566878980893" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1/0.0628" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} |