diff options
| -rw-r--r-- | Phase measurement Prototype.ipynb | 1777 | ||||
| -rw-r--r-- | ROCOF test data generator.ipynb | 235 | ||||
| -rw-r--r-- | grid_frequency_spectra.ipynb | 4205 |
3 files changed, 6217 insertions, 0 deletions
diff --git a/Phase measurement Prototype.ipynb b/Phase measurement Prototype.ipynb new file mode 100644 index 0000000..498f274 --- /dev/null +++ b/Phase measurement Prototype.ipynb @@ -0,0 +1,1777 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "\n", + "import numpy as np\n", + "from scipy import signal, optimize\n", + "from matplotlib import pyplot as plt\n", + "\n", + "import rocof_test_data" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "fs = 1e3 # Hz\n", + "ff = 50 # Hz\n", + "duration = 60 # seconds\n", + "# test_data = rocof_test_data.sample_waveform(rocof_test_data.test_close_interharmonics_and_flicker(),\n", + "# duration=20,\n", + "# sampling_rate=fs,\n", + "# frequency=ff)[0]\n", + "# test_data = rocof_test_data.sample_waveform(rocof_test_data.gen_noise(fmin=10, amplitude=1),\n", + "# duration=20,\n", + "# sampling_rate=fs,\n", + "# frequency=ff)[0]\n", + "\n", + "\n", + "#gen = rocof_test_data.gen_noise(fmin=10, amplitude=1)\n", + "# gen = rocof_test_data.gen_noise(fmin=60, amplitude=0.2)\n", + "# gen = rocof_test_data.test_harmonics()\n", + "# gen = rocof_test_data.gen_interharmonic(*rocof_test_data.test_interharmonics)\n", + "# gen = rocof_test_data.test_amplitude_steps()\n", + "# gen = rocof_test_data.test_amplitude_and_phase_steps()\n", + "test_data = []\n", + "test_labels = [ fun.__name__.replace('test_', '') for fun in rocof_test_data.all_tests ]\n", + "for gen in rocof_test_data.all_tests:\n", + " test_data.append(rocof_test_data.sample_waveform(gen(),\n", + " duration=duration,\n", + " sampling_rate=fs,\n", + " frequency=ff)[0])\n", + "# d = 10 # seconds\n", + "# test_data = np.sin(2*np.pi * ff * np.linspace(0, d, int(d*fs)))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "analysis_periods = 50\n", + "window_len = fs * analysis_periods/ff\n", + "nfft_factor = 1\n", + "\n", + "ffts = []\n", + "for item in test_data:\n", + " f, t, Zxx = signal.stft(item,\n", + " fs = fs,\n", + " window='blackman',\n", + " nperseg = window_len,\n", + " nfft = window_len * nfft_factor)\n", + " #boundary = 'zeros')\n", + " ffts.append((f, t, Zxx))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "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=\"800\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(len(test_data), figsize=(8, 20), sharex=True)\n", + "fig.tight_layout(pad=2, h_pad=0.1)\n", + "\n", + "for fft, ax, label in zip(ffts, ax.flatten(), test_labels):\n", + " f, t, Zxx = fft\n", + " ax.pcolormesh(t[1:], f[:250], np.abs(Zxx[:250,1:]))\n", + " ax.set_title(label, pad=-20, color='white')\n", + " ax.grid()\n", + " ax.set_ylabel('f [Hz]')\n", + " ax.set_ylim([40, 60]) # Hz\n", + "ax.set_xlabel('simulation time t [s]')\n", + "None" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "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=\"800\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(len(test_data), figsize=(8, 20), sharex=True)\n", + "fig.tight_layout(pad=2.2, h_pad=0, w_pad=1)\n", + "\n", + "for fft, ax, label in zip(ffts, axs.flatten(), test_labels):\n", + " f, f_t, Zxx = fft\n", + " \n", + " n_f, n_t = Zxx.shape\n", + " start, stop = 180, 220\n", + " # start, stop = 90, 110\n", + " # start, stop = 15, 35\n", + " bounds_f = slice(start // 4 * nfft_factor, stop // 4 * nfft_factor)\n", + " \n", + "\n", + " f_mean = np.zeros(Zxx.shape[1])\n", + " for t in range(1, Zxx.shape[1] - 1):\n", + " frame_f = f[bounds_f]\n", + " frame_Z = np.abs(Zxx[bounds_f, t])\n", + " # frame_f = f[180:220]\n", + " # frame_Z = np.abs(Zxx[180:220, 40])\n", + " # frame_f = f[15:35]\n", + " # frame_Z = np.abs(Zxx[15:35, 40])\n", + " # plt.plot(frame_f, frame_Z)\n", + "\n", + " # peak_f = frame_f[np.argmax(frame)]\n", + " # plt.axvline(peak_f, color='red')\n", + "\n", + " def gauss(x, *p):\n", + " A, mu, sigma, o = p\n", + " return A*np.exp(-(x-mu)**2/(2.*sigma**2)) + o\n", + " \n", + " f_start = frame_f[np.argmax(frame_Z)]\n", + " p0 = [.5, f_start, 1., 0]\n", + " coeff, var = optimize.curve_fit(gauss, frame_f, frame_Z, p0=p0)\n", + " # plt.plot(frame_f, gauss(frame_f, *coeff))\n", + " #print(coeff)\n", + " A, mu, sigma, o = coeff\n", + " f_mean[t] = mu\n", + " ax.plot(f_t[1:-1], f_mean[1:-1])\n", + " ax.set_title(label, pad=-20)\n", + " ax.set_ylabel('f [Hz]')\n", + " ax.grid()\n", + " if not label in ['off_frequency', 'sweep_phase_steps']:\n", + " ax.set_ylim([49.90, 50.10])\n", + " ax.text(0.5, 0.1, f'σ²={np.var(f_mean[1:-1]) * 1e3:.3g} mHz', transform=ax.transAxes, ha='center')\n", + " else:\n", + " f_min, f_max = min(f_mean[1:-1]), max(f_mean[1:-1])\n", + " delta = f_max - f_min\n", + " ax.set_ylim(f_min - delta * 0.1, f_max + delta * 0.3)\n", + " \n", + "ax.set_xlabel('simulation time t [s]')\n", + "None" + ] + } + ], + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ROCOF test data generator.ipynb b/ROCOF test data generator.ipynb new file mode 100644 index 0000000..df94a7b --- /dev/null +++ b/ROCOF test data generator.ipynb @@ -0,0 +1,235 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ROCOF test waveform library\n", + "\n", + "This is a re-implementation of the ROCOF test waveforms described in https://zenodo.org/record/3559798\n", + "\n", + "**This file is exported as a python module and loaded from other notebooks here, so please make sure to re-export when changing it.**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import itertools\n", + "\n", + "import numpy as np\n", + "from scipy import signal\n", + "from matplotlib import pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib notebook" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def sample_waveform(generator, duration:\"s\"=10, sampling_rate:\"sp/s\"=10000, frequency:\"Hz\"=50):\n", + " samples = int(duration*sampling_rate)\n", + " phases = np.linspace(0, 2*np.pi, 6, endpoint=False)\n", + " omega_t = np.linspace(phases, phases + 2*np.pi*duration*frequency, samples)\n", + " fundamental = np.sin(omega_t)\n", + " return generator(omega_t, fundamental, sampling_rate=sampling_rate, duration=duration, frequency=frequency).swapaxes(0, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def gen_harmonics(amplitudes, phases=[]):\n", + " return lambda omega_t, fundamental, **_: fundamental + np.sum([\n", + " a*np.sin((p if p else 0) + i*omega_t)\n", + " for i, (a, p) in enumerate(itertools.zip_longest(amplitudes, phases), start=2)\n", + " ], axis=0)\n", + "\n", + "def test_harmonics():\n", + " return gen_harmonics([0.02, 0.05, 0.01, 0.06, 0.005, 0.05, 0.005, 0.015, 0.005, 0.035, 0.005, 0.003])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def gen_interharmonic(amplitudes, ih=[], ih_phase=[]):\n", + " def gen(omega_t, fundamental, **_):\n", + " return fundamental + np.sum([\n", + " a*np.sin(omega_t * ih + (p if p else 0))\n", + " for a, ih, p in itertools.zip_longest(amplitudes, ih, ih_phase)\n", + " ], axis=0)\n", + " return gen\n", + "\n", + "def test_interharmonics():\n", + " return gen_interharmonic([0.1], [15.01401], [np.pi])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def gen_noise(amplitude=0.2, fmax:'Hz'=4.9e3, fmin:'Hz'=100, filter_order=6):\n", + " def gen(omega_t, fundamental, sampling_rate, **_):\n", + " noise = np.random.normal(0, amplitude, fundamental.shape)\n", + " b, a = signal.butter(filter_order,\n", + " [fmin, min(fmax, sampling_rate//2-1)],\n", + " btype='bandpass',\n", + " fs=sampling_rate)\n", + " return fundamental + signal.lfilter(b, a, noise, axis=0)\n", + " return gen\n", + "\n", + "def test_noise():\n", + " return gen_noise()\n", + "\n", + "def test_noise_loud():\n", + " return gen_noise(amplitude=0.5, fmin=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 406, + "metadata": {}, + "outputs": [], + "source": [ + "def gen_steps(size_amplitude=0.1, size_phase=0.1*np.pi, steps_per_sec=1):\n", + " def gen(omega_t, fundamental, duration, **_):\n", + " n = int(steps_per_sec * duration)\n", + " indices = np.random.randint(0, len(omega_t), n)\n", + " amplitudes = np.random.normal(1, size_amplitude, (n, 6))\n", + " phases = np.random.normal(0, size_phase, (n, 6))\n", + " amplitude = np.ones(omega_t.shape)\n", + " for start, end, a, p in zip(indices, indices[1:], amplitudes, phases):\n", + " omega_t[start:end] += p\n", + " amplitude[start:end] = a\n", + " return amplitude*np.sin(omega_t)\n", + " return gen\n", + "\n", + "def test_amplitude_steps():\n", + " return gen_steps(size_amplitude=0.4, size_phase=0)\n", + "\n", + "def test_phase_steps():\n", + " return gen_steps(size_amplitude=0, size_phase=0.1)\n", + "\n", + "def test_amplitude_and_phase_steps():\n", + " return gen_steps(size_amplitude=0.2, size_phase=0.07)" + ] + }, + { + "cell_type": "code", + "execution_count": 418, + "metadata": {}, + "outputs": [], + "source": [ + "def step_gen(shape, stdev, duration, steps_per_sec=1.0, mean=0.0):\n", + " samples, channels = shape\n", + " n = int(steps_per_sec * duration)\n", + " indices = np.random.randint(0, samples, n)\n", + " phases = np.random.normal(mean, stdev, (n, 6))\n", + " amplitude = np.ones((samples, channels))\n", + " out = np.zeros(shape)\n", + " for start, end, a in zip(indices, indices[1:], amplitude):\n", + " out[start:end] = a\n", + " return out\n", + "\n", + "def gen_chirp(fmin, fmax, period, dwell_time=1.0, amplitude=None, phase_steps=None):\n", + " def gen(omega_t, fundamental, sampling_rate, duration, **_):\n", + " samples = int(duration*sampling_rate)\n", + " phases = np.linspace(0, 2*np.pi, 6, endpoint=False)\n", + " \n", + " c = (fmax-fmin)/period\n", + " t = np.linspace(0, duration, samples)\n", + " \n", + " x = np.repeat(np.reshape(2*np.pi*fmin*t, (-1,1)), 6, axis=1)\n", + " data = (phases + x)[:int(sampling_rate*dwell_time)]\n", + " current_phase = 2*np.pi*fmin*dwell_time\n", + " direction = 'up'\n", + " \n", + " for idx in range(int(dwell_time*sampling_rate), samples, int(2*period*sampling_rate)):\n", + " t1 = np.linspace(0, period, int(period*sampling_rate))\n", + " t2 = np.linspace(0, period, int(period*sampling_rate))\n", + " chirp_phase = np.hstack((\n", + " 2*np.pi*(c/2 * t1**2 + fmin * t1),\n", + " 2*np.pi*(-c/2 * t2**2 + fmax * t2 - (c/2 * period**2 + fmin * period))\n", + " ))\n", + " chirp_phase = np.repeat(np.reshape(chirp_phase, (-1, 1)), 6, axis=1)\n", + " new = phases + chirp_phase + current_phase\n", + " current_phase = chirp_phase[-1]\n", + " data = np.vstack((data, new))\n", + " \n", + " data = data[:len(fundamental)]\n", + " \n", + " if phase_steps:\n", + " (step_amplitude, steps_per_sec) = phase_steps\n", + " steps = step_gen(data.shape, step_amplitude, duration, steps_per_sec)\n", + " data += steps\n", + " \n", + " if amplitude is None:\n", + " return np.sin(data)\n", + " else:\n", + " return fundamental + amplitude*np.sin(data)\n", + " return gen\n", + "\n", + "def test_close_interharmonics_and_flicker():\n", + " return gen_chirp(90.0, 150.0, 10, 1, amplitude=0.1)\n", + "\n", + "def test_off_frequency():\n", + "# return gen_chirp(48.0, 52.0, 0.25, 1)\n", + " return gen_chirp(48.0, 52.0, 10, 1)\n", + "\n", + "def test_sweep_phase_steps():\n", + " return gen_chirp(48.0, 52.0, 10, 1, phase_steps=(0.1, 1))\n", + "# return gen_chirp(48.0, 52.0, 0.25, 1, phase_steps=(0.1, 1))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_tests = [test_harmonics, test_interharmonics, test_noise, test_noise_loud, test_amplitude_steps, test_phase_steps, test_amplitude_and_phase_steps, test_close_interharmonics_and_flicker, test_off_frequency, test_sweep_phase_steps]" + ] + } + ], + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/grid_frequency_spectra.ipynb b/grid_frequency_spectra.ipynb new file mode 100644 index 0000000..c861490 --- /dev/null +++ b/grid_frequency_spectra.ipynb @@ -0,0 +1,4205 @@ +{ + "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,iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAgAElEQVR4nOzdeXhU5dk/8LnqBSj8kOuyXi+LbQ9a2SouL1q3ty9URLEVaYu11Grt2yoWW0Ra257IYkR2ZVExAkZkUdlBxUMSCJAFEsKWkATClgRCCGFJIAkJmUlmzvf3x5lzkiEzyUzOzJw5Z76f65o/nPWOPMlzz3me575tICIiIqKoYjM6ACIiIiIKLyaARERERFGGCSARERFRlGECSERERBRlmAASERERRRkmgERERERRhgkgERERUZRhAkhEREQUZZgAEhEREUUZJoBEREREUYYJIBEREVGUYQJIREREFGWYABIRERFFGSaARERERFGGCSARERFRlGECSERERBRlmAASERERRRkmgERERERRhgkgERERUZRhAkhEREQUZZgAEhEREUUZJoBEREREUYYJIBEREVGUYQJIREREFGWYABIRERFFGSaARERERFGGCSARERFRlGECSERERBRlmAASERERRRkmgERERERRhgkgERERUZRhAkhEREQUZZgAEhEREUUZJoBEREREUYYJIBEREVGUYQJIREREFGWYABIRERFFGSaARERERFGGCSARERFRlGECSERERBRlmAASERERRRkmgERERERRhgkgERERUZRhAkhEREQUZZgAEhEREUUZJoBEREREUYYJIBEREVGUYQJIREREFGWYABIRERFFGSaARERERFGGCSARERFRlGECSERERBRlmAASERERRRkmgERERERRhgkgERERUZRhAkhEREQUZZgA6uByuVBaWoqqqipUV1fzxhtvvPHGG28muFVVVaG0tBQul8voVMIwTAB1KC0thc1m44033njjjTfeTHgrLS01OpUwDBNAHaqqqrQBZPS3Gd5444033njjzb+begGnqqrK6FTCMEwAdaiurobNZkN1dbXRoRAREZGfOH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIiMh8OH8zAdSFA4iIyDzySqtw39StWLOvxOhQyGCcv5kA6sIBRERkHjO2FEAQJTy3ONPoUMhgnL+ZAOrCAUREZB4vfpYFQZRwd2wSZFk2OhwyEOdvJoC6cAAREZnHA9OTIYgSBFFC2ZVrRodDBuL8zQRQFw4gIiJzuHTVriV/gihhx9HzRodEBuL8zQRQFw4gIiJz2H3ykkcC+PHOk0aHRAbi/B3iBDA2NhY2m83j1r17d+1xWZYRGxuLnj174sYbb8SQIUNw+PDhNt83Li4OvXv3RqdOnTBo0CCkp6d7PP7qq6/ijjvuwI033ohbb70VI0eOxNGjRz2eU1JSghEjRqBz5874/ve/j9dffx0OhyOgn48DiIjIHOLTizwSwHGrso0OiQzE+TsMCeBdd92F8vJy7Xbx4kXt8dmzZ6Nr167YuHEj8vPzMXr0aPTs2RM1NTU+33PNmjXo0KED4uPjUVBQgDfeeANdunRBSUnTsf4lS5YgLS0Np06dwsGDB/HMM8/ghz/8IZxOJwDA6XRi4MCBeOyxx5CdnY3k5GT06tUL48aNC+jn4wAiIjKHN9cdgiBK+NXHuyGIEobNSzU6JDIQ5+8wJID33nuv18dkWUaPHj0we/Zs7T673Y5u3bph8eLFPt/zwQcfxNixYz3u69+/P2JiYny+Jjc3FzabDYWFhQCAhIQEfO9730NZWZn2nNWrV6NTp04BDQYOICIic3j6o3QIooRlu4shiBLueGsL6hucRodFBuH8HYYEsHPnzujZsyd69+6N0aNHo6ioCABQVFQEm82G7GzPy/AjR47ESy+95PX9HA4HbrjhBmzatMnj/vHjx2Pw4MFeX1NbW4sJEybg9ttv15Z4p0yZgnvuucfjeZcvX4bNZsPOnTt9/jx2ux3V1dXarbS0NOoHEBFRpGt0utBnUgIEUcKpS7W4552tEEQJ+WerjA6NDMIEMMQJYEJCAjZs2IC8vDwkJydjyJAh6N69OyoqKpCRkQGbzeZxFQ4AxowZgyeffNLr+5WVlcFmsyEjI8Pj/hkzZqBv374e98XFxaFLly6w2Wzo37+/dvVP/Ywnnniixft37NgRq1at8vnzeNvTGO0DiIgo0p28UANBlDBgSiJcLhm/W5wJQZSw/kCp0aGRQZgAhvkUcG1tLbp374558+ZpCeC5c+c8nvPKK69g+PDhXl+vJoCZmZ5V3KdPn45+/fp53FdVVYUTJ04gLS0NzzzzDAYNGoT6+noAvpPMDh06YPXq1T7j5xVAIiLz2XyoDIIo4ddxuwEAsd8ehiBKmPbdEYMjI6MwATSgDMywYcMwduzYsC0Bq6/r3LmzdnWvvUvA1+MAIiKKfO8lHYUgSojZmAcAWL23BIIo4YX4LIMjI6Nw/g5zAmi323Hbbbdh6tSp2iGQOXPmaI87HA6/DoG89tprHvcNGDCg1UMgDocDN910E5YtWwag6RBI86uPa9as4SEQIiIL+suyfRBECSsyTwEAcs5cgSBKuH/aNmMDI8Nw/g5xAvjmm28iNTUVxcXFyMrKwogRI9C1a1ecPn0agFIGplu3bti0aRPy8/Px/PPPtygDM3ToUCxcuFD7b7UMzNKlS1FQUIAJEyagS5cu2nsWFRVh5syZOHDgAEpKSpCZmYlf/epXuOWWW3DhwgUATWVgHn/8cWRnZ2P79u34wQ9+wDIwREQW9OisHRBECXuLKwEAdY5G9I5R6gFerLEbHB0ZgfN3iBNAta5fhw4d0KtXL4waNQpHjjTtuVALQffo0QOdOnXC4MGDkZ+f7/EegiAgNjbW4764uDgIgoCOHTti0KBBSEtL0x4rKyvDL37xC/zXf/0XOnTogB/84Af4wx/+gGPHjnm8R0lJCZ5++mncdNNNuOWWWzBu3DjY7YH9IeAAIiKKbFXXGrTiz1XXGrT7f/5+CgRRwq4TlwyMjozC+Zut4HThACIiimz7TlVCECU8OmuHx/1jvzgAQZQQn15kUGRkJM7fTAB14QAiIopsKzNPQRAl/GXZPo/7P0g+AUGU8M+1hwyKjIzE+ZsJoC4cQEREke2tTXkQRAnvJXn2g086XA5BlPDLD9N9vJKsjPM3E0BdOICIiCLbc4uUos/f5Jz1uL+kog6CKKHPxAQ0Ol0GRUdG4fzNBFAXDiAiosimHvbIKqrwuN/lkvGTKYkQRAknztf4eDVZFedvJoC6cAAREUW2gW8nQRAlFF682uKx38TthiBK+PZQmZdXkpVx/mYCqAsHEBFR5KpvcHotAaNS9wfOSTzq5dVkZZy/mQDqwgFERBS5Si837fOTZbnF4+oJ4T9fd0KYrI/zNxNAXTiAiIgil9ry7ZGZ270+rtYI9PU4WRfnbyaAunAAERFFruQj5yGIEp5ZuMvr49X1zbqE1LVcIibr4vzNBFAXDiAiosi1em9Jm0u8ap/g608Jk7Vx/mYCqAsHEBFR5Fq4Q+n28e/1vrt9vLx8HwRRwvKMU+ELjAzH+ZsJoC4cQEREkSv228NtnvJ9P+kYBFFCzMbcMEZGRuP8zQRQFw4gIqLI9bevDkIQJSzdVezzOd/llkEQJfzq491hjIyMxvmbCaAuHEBERJHrd4sz2yz0fPLCVQiihP6TE+FytSwVQ9bE+ZsJoC4cQEREkWvoXKUNXEbhJZ/PaXS60HdSAgRRwqlLtWGMjozE+ZsJoC4cQEREkeued7b61et3xEe7IIgSEvPPhSkyMhrnbyaAunAAERFFJkejS6vxd7nW0epz/7XuEARRwvxtx8MUHRmN8zcTQF04gIiIItO5qmsQRAk/fmtLm3v7PttVDEGU8OrK/WGKjozG+ZsJoC4cQEREkSmvtAqCKOHBGcltPjfj5CUIooTB7+0MQ2QUCTh/MwHUhQOIiCgy7Tx6AYIo4Zcfprf53IqrdgiihN4xEmrtjWGIjozG+ZsJoC4cQEREkWnt/jMQRAkvLd3r1/N/Oj0Zgighu+RyiCOjSMD5mwmgLhxARESRKS7lJARRwj/X+m4D19wfl+6FIEpYtbckxJFRJOD8zQRQFw4gIqLINHXzEQiihJkJBX49f+aWAgiihLe/yQ9xZBQJOH8zAdSFA4iIKDK9viobgighPr3Ir+dvyi6FIEp4bnFmiCOjSMD5mwmgLhxARESR6flP90AQJXydfdav5xecq4YgSrg7NgmyzJZwVsf5mwmgLhxARESR6Yn5qRBECbtO+G4D15yj0YUfv7UFgiih7Mq1EEdHRuP8zQRQFw4gIqLI9N/vboMgSjha7v/f5yfnp0EQJew4ej6EkVEk4PzNBFAXDiAiosjT6HShd4zSBu7SVbvfrxu/Wtk3+PHOkyGMjiIB528mgLpwABERRZ4L1fUQRAm3x0hwttEGrrlPUgohiBLGrcoOYXQUCTh/MwHUhQOIKDwKL17Fnz7fi9zSK0aHQiZwuExpA3f/tLbbwDW385jSPWTYvNQQRUaRgvM3E0BdOICIwiP228MQRAnPf7rH6FDIBFKPX4QgShi+IC2g15VXKVcO73hrC+obnCGKjiIB528mgLpwABGFx+8WZ2q9Ws9V8YQmtW7DAaWm34ufZQX0OlmWce/UrRBECflnq0IUHUUCzt9MAHXhACIKPVmWcc87yqQsiBIWpxYaHRJFuMWpyl6+CWtyAn7t6CXKl431B0pDEBlFCs7fTAB14QAiCr1zVde05K89y3oUfaZLShu46dKRgF+rbjeY9l3gryXz4PzNBFAXDiCi0Nt5VNmY/+isHbhzolKot+Acf+fItwlrciCIEha142rxmn0lEEQJL8QHtnxM5sL5O8QJYGxsLGw2m8ete/fu2uOyLCM2NhY9e/bEjTfeiCFDhuDw4cNtvm9cXBx69+6NTp06YdCgQUhPT9ceq6ysxLhx49C3b1/cdNNN+OEPf4jXX38dVVWe+zmuj8tms2HRokUB/XwcQEShF5dyEoIoYfzqbIxZsR+CKGFmQoHRYVEEe/GzrHYv4x46c8V9gnhbCCKjSMH5OwwJ4F133YXy8nLtdvHiRe3x2bNno2vXrti4cSPy8/MxevRo9OzZEzU1NT7fc82aNejQoQPi4+NRUFCAN954A126dEFJSQkAID8/H6NGjcLmzZtRWFiIHTt2oE+fPnj22Wc93sdms2HZsmUesV27Ftjmcg4gotB7fZVSnPeTlEIk5J2DIEp4aMZ2uAKo70bRZfgCpaNHyrELAb/2msOpFZG+WON/EWkyF87fYUgA7733Xq+PybKMHj16YPbs2dp9drsd3bp1w+LFi32+54MPPoixY8d63Ne/f3/ExMT4fM26devQsWNHNDY2avfZbDZ8/fXX/v4oXnEAEYWe2tN157ELqG9wYmBsEgRRQkahfz1eKfrcPy1Z10nex95PgSBKSD9xse0nkylx/g5DAti5c2f07NkTvXv3xujRo1FUVAQAKCoqgs1mQ3a2Z8X1kSNH4qWXXvL6fg6HAzfccAM2bdrkcf/48eMxePBgn3HEx8fj1ltv9bjPZrPhtttuw/e//3088MADWLRoEVwuV6s/j91uR3V1tXYrLS2N+gFEFEr2RifueEvZ91deVQ8AEDfkQhAl/Gd9rsHRUSRyumTc7r6Cd766vl3v8dqXByCIEn6/ZA9ivz2M2G8PI/U4k0ErYQIY4gQwISEBGzZsQF5eHpKTkzFkyBB0794dFRUVyMjIgM1mQ1lZmcdrxowZgyeffNLr+5WVlcFmsyEjI8Pj/hkzZqBv375eX1NRUYEf/ehHmDRpksf906ZNQ2ZmJnJycjB37lx07twZ06ZNa/Xn8banMdoHEFEoqR0d7p26FbKsLPnuKaqAIEoY+HYSi/VSC2ox59tjJDQ4W/9S74vaEq75rf/kRNTaG9t+MZkCE8AwnwKura1F9+7dMW/ePC0BPHfunMdzXnnlFQwfPtzr69UEMDMz0+P+6dOno1+/fi2eX11djYceeghPPfUUGhoaWo1t7ty5uPnmm1t9Dq8AEoWXWtD3d4ubfuddLhmPzNwOQZSwJe9cK6+maKR2ARk6N6Xd71FT34DFqYV4P+kY3k86hofd421TNmsDWgUTQAPKwAwbNgxjx44N+RJwTU0NHnnkETz++OOor297GWD37t2w2Ww4f/683z8LBxBRaKn13GK/9awOMDvxKARRwisr9hsUGUUqtQj03746GLT3XJB8HIIo4Y9L9wbtPclYnL/DnADa7XbcdtttmDp1qnYIZM6cOdrjDofDr0Mgr732msd9AwYM8DgEUl1djYcffhhDhgxBXV2dX7EtXLgQN954I+x2/099cQARhZZazmP13hKP+4+fr4EgSrhz4hZcrnUYFB1FIrUG4MIdJ4L2nqcu1WrLyhdq2revkCIL5+8QJ4BvvvkmUlNTUVxcjKysLIwYMQJdu3bF6dOnAShlYLp164ZNmzYhPz8fzz//fIsyMEOHDsXChQu1/1bLwCxduhQFBQWYMGECunTpor1nTU0NHnroIdx9990oLCz0KPPidCr7hTZv3oxPP/0U+fn5KCwsRHx8PG6++WaMHz8+oJ+PA4gotNTTnDlnrrR47BcfpEMQJXyx57QBkVGkUkvAJB/xfzXHH7+O2w1BlPDZruKgvi8Zg/N3iBNAta5fhw4d0KtXL4waNQpHjjS111ELQffo0QOdOnXC4MGDkZ+f7/EegiAgNjbW4764uDgIgoCOHTti0KBBSEtrag2VkpLi9aCGzWbDqVOnAACJiYm477778P/+3/9D586dMXDgQHzwwQceZWL8wQFEFDoXa+wQRAm9YyTUOVr+bn6aVgRBlPDsJxleXk3RyNHo0rrFlF72b/XHXysyT0EQJYz4aFdQ35eMwfmbreB04QAiCp1dJy5BECX8/P0Ur4+XV9VrBXtLKoI72ZM5HS2v1k6Iq6fGg6Xiqh0/dpckOnnBd7MCMgfO30wAdeEAIgqd+HTlCt/YLw74fM4f4vdAECV8tD14+73IvL7OPgtBlPDbRaG5KvyXZfsgiBLeTzoWkven8OH8zQRQFw4gotD559pDEEQJHyT7Tu7W7T8DQZTw2NyUoF/xIfOZmVAAQZQw+ev8tp/cDt8eKoMgSvif2TvYitDkOH8zAdSFA4godIbNU1rAJeaX+3xOTX0D+k5KgCBKOFrO38No99LSvRBECV9mheZg0DWHEz+ZkghBlLDvVGVIPoPCg/M3E0BdOICIQkPdy9VnYgKu1LVe5mX0kkwIooT1B1ikN9o9OEM5NX7g9OWQfYZ6ZfqtTXkh+wwKPc7fTAB14QAiCo1ZCUqh5zF+FHqO/fYwBFHCtO+OtPlcsq7KWofWtu1qCFu2qYeT7nlnK+yNbEVoVpy/mQDqwgFEFHwul6y13krwo9Xbmn0lEEQJL8RnhSE6ilQZhUpi9r9zdob0c5wuGT+drlxpTDrse3sCRTbO30wAdeEAIgq+zMIKpZRHbBLqG9q+wnLozBUIooT7p20LQ3QUqZbuKvb7qrFeaovC1770fUKdIhvnbyaAunAAEQXff9bnQhAliBty/Xr+NYdTqwd4scb/Vo5kLf9er+zNm7fteMg/63BZlbJHdVICqq41hPzzKPg4fzMB1IUDiCi46hucGPh2EgRRwp6iCr9f99j7KRBECeknLoYwOopkzyzc5fe2Ab1kWcYT85VT6mv2lbT9Aoo4nL+ZAOrCAUQUXFvyzkEQJTwyc3tAddZe+/IABFHCp2lFIYyOIpXTJWvlgIov1YblM+NSTkIQJYxekhmWz6Pg4vzNBFAXDiCi4BqzYj8EUcLsxKMBve7D7ScgiBL+sTYnRJFRJCu8eBWCKKH/5EQ4w1Sg+eyVa9qp47NXroXlMykwV+2NuFzrwOVaB6rqPJfqOX8zAdSFA4goeK7UOXDnRKXX6vHzgfVaTTpcDkGU8IsP0kMUHRmtwenC0x+l46kP0uFodHk8ttndoWPkwl1hjel3i5UalItTC8P6udHs6+yz+PFbW5CY3/pS/4rMU1qCrt7+s75pXzHnbyaAunAAEQXPl1mn253ElVTUaYWjG52utl9AprPj6HltIt925LzHY+NWZUMQJUzdHN5akGq/6ldXhv7kMSmGL0iDIEr4ddxun8+RZRmD39vZIgH88VtbUHFVOSjG+ZsJoC4cQETB89tFGe3ex+dyyVqLrhMBXj0kc1CTPEGU8LcvD2r3N28HmFt6JawxZZxUag8Ofi+0tQdJUXCu2iOhO+Vjv+fBkssQRAkDpiTiqr0RLpeMER8ph4RWZJ4CwPkbYAKoCwcQUXCcqVSu4PWOkXC+ur5d7/GbuN0QRAnfHioLcnRktOZJnlp+pbpe2dO1/kApBFHCY3NTIMvh2f+nqrhq18ZtbQi7j5Bi5pYCjwRwQbL3kj9TvsmHIEqYsKZpT7B6tVa9csj5mwmgLhxARMGxcIdyiOMP8Xva/R5vbcqDIEqYE+ABEop8WpL3fgqGzVPKr6zddwYA8EJ8FgRRwkfbTxgSm9oVJLskdP2HSTnp/dAMpUPQX1cqp/6HvLezRdLf4HThvqlbIYgSUo83lYW6UF2P22Oarhxy/mYCqAsHEJF+sixj6Fyljt+6/Wfa/T4r3Zu+/7xsXxCjo0jQPMn7eKdSfuX3S/bgfHW9VgS8pKLOkNhe/EyJbdVe1gMMJXW5/e7YJFyudaD/5ESviff2gvPuzkDJLfYDq/9WHySf4PwNJoC6cAAR6ZdXqnRV6DspATX17e+qsO9UpVZDkKzj+iSv9HLTdoF3Nh+GIEp49pMMw+Kb4V6WfPubfMNiiAZqp5eYjXkAgDdWZ3v9//73rw76PBC08aByJfnn76egqqoq6udvJoA6MAEk0m/qZqWv6t+/Otj2k1tRXd+g7Q26vuYXmdenacrerVHNkrzn3OVX1NsXe04bFp+aVDy3mAWhQ6V5h6C9xZUAgJRjFyCIEv773W1ocF/pa75XNK+0qsX71NobtSuHu46URP38zQRQByaARPo0Ol24f5qyh2p7wfm2X9CGR2ftgCBKyAqgjRxFtl98kA5BlLCyWZL3VVaJR2mPy7UOw+I7UlatLU2G+xBKtJBylQ5Bj87aoXUIUv52bIMgSthxVPnbsW7/GQiihKGtHAga775yGLM6K+rnbyaAOjABJNIn9fhFCKKE+6Zu1b7F6/Hy8n0QRAnLM07pD44Md/x8jdckr6quAX0mKld6Xl5ubA0+e6MTP35LKWBexo4gIfHy8v1eD3jFfntYuwr4xPxU3PPO1jYPBO08qlw5/PG/NkT9/M0EUAcmgET6zExQ9k+JG3LbfrIf3k865t4nFJz3I2PNSTzqM8n751plT9jOYxcMiMzTk/PTPK5EUfBU1jq0BPv6Gp9Hyqq1k73NSwSdqfR9IKjB6cKjs3bghxPWRf38zQRQByaARPq8tHQvBFHCl1nB2cP1Xa7SEuxXH/vuEkDm4HLJ2pK+lNuy7Vd9g9NnIeBwU5cVP9550uhQLGflHqVD0C8/9N4hqOjiVWQUXtJurSV/qspaB7blFEf9/M0EUAcmgET6PDhD2f934HRwaqidvHAVgiih/+REba8QmVNWUQUEUcLAt5NQ3+A0OpxWfZJSCEGUMG5VttGhWM6oT5QOQfHpgXcIag3nbyaAunAAEbVfZa1DW7a5GqQuCo1Ol3YKMFKuDlH7xGzMhSBK+Pf6Q0aH0qad7hOpw+alGh2Kpag9vm/X0SHIF87fTAB14QAiar+MQqWw6//OCW4fVbXnZ2J+y2VDMof6BicGxiplPzIKLxkdTpvKq+ohiBLueGtLxF+tNJMPtysdgl78LCvo7835mwmgLhxARO23dFcxBFHCmBXBPcX5r3XK4YD527z3CaXIl5ivlP14eOZ2Uyzly7KMe93tx/LPtqw/R4GTZRmPuTsEbThQGvT35/zNBFAXDiCi9lMr+88LcqL2mTuxfHWlseVBqP1eXamU/Zi5pcDoUPw2eolSnHp9CJKVaJRbegWCKKHf5ISgbRFpjvM3E0BdOICI2u+ZhcpSbUJecJdq1Z6hg98L7tIyhceVOodW46/gnHn+tqo16aZ917IFGQVObfP3eogO1nD+ZgKoCwcQUfs4XbJ2WKM4yIc1Kq7atcMltSG4ckChpXb5GL4gzehQArJmnxL3C/HB368WDS7W2DEzoQCTv87H5K/ztSX1nUdDU+eR8zcTQF04gIjap/BiU7kWZwj2eP10ulJe5mBJcMrLUPioy79mq6mXXXIZgijhoRnbjQ7FlGYlHPUo6CyIEu6fti0oHYK84fzNBFAXDiCi9lF7e44MUcHmP7oLTH+VVRKS96fQUXv/mq2rxplKpWRJ30kJRodiSi9+lgVBlPDXlQcwf9txLEg+jkNnroTs8zh/MwHUhQOIqH3mbT0W1BZw15u5RWkxN+Wb/JC8P4WOuvR3tNxcf1dr6hu0K1fXHCwFE6j7pylX7bPDdNWe8zcTQF04gIja55UVyjLfst3FIXn/TdmlEEQJzy3KDMn7U2jU2hu1JKqmvsHocAIiy7LWs/Zc1TWjwzGViwMuDH4AACAASURBVDXKvt3eMeHbt8v5mwmgLhxARO3zszlKj9c9RRUhef8jZdVKG7HYJMhy5NeRI8WJ8zUQRAl3xyYZHUq73D9tm+lOL0eCXSeUk/tDwnhyn/N3iBPA2NhY2Gw2j1v37t21x2VZRmxsLHr27Ikbb7wRQ4YMweHDh9t837i4OPTu3RudOnXCoEGDkJ7e1CS6srIS48aNQ9++fXHTTTfhhz/8IV5//XVUVXkW5ywpKcGIESPQuXNnfP/738frr78Oh8MR0M/HAUQUuOZLZVfqAvud85e90aldjTl7hVdjzEJtqWa2E8Cqoe7CxWboXhJJ4tOLtP1/4cL5OwwJ4F133YXy8nLtdvHiRe3x2bNno2vXrti4cSPy8/MxevRo9OzZEzU1NT7fc82aNejQoQPi4+NRUFCAN954A126dEFJibLZOz8/H6NGjcLmzZtRWFiIHTt2oE+fPnj22We193A6nRg4cCAee+wxZGdnIzk5Gb169cK4ceMC+vk4gIgCd+B0pdblIZSenJ8GQZSwvcBchwmi2Rd7TkMQJby8fJ/RobTLs59khKS2pdX9c61SFH5Bcvi693D+DkMCeO+993p9TJZl9OjRA7Nnz9bus9vt6NatGxYvXuzzPR988EGMHTvW477+/fsjJibG52vWrVuHjh07orFR2VuQkJCA733veygrK9Oes3r1anTq1CmgwcABRBQ4dZL/v8/3hvRzxq/ONmU5kWg2J1EpBfK2SQ/vvLx8HwRRwqq9PH0eiKc/Snf37y4P22dy/g5DAti5c2f07NkTvXv3xujRo1FUVAQAKCoqgs1mQ3a2Z5XvkSNH4qWXXvL6fg6HAzfccAM2bdrkcf/48eMxePBgn3HEx8fj1ltv1f57ypQpuOeeezyec/nyZdhsNuzc6f8eBA6gttU3OLG94Dy+yy0L6LYl7xwqa0OzPEjhd7S8Wvu3/b/PlRItsxOPhvQzP0kphCBKGBeiTgIUfGrSvji10OhQ2uVNdx/quBR+6fBXo9OFPu6i8KcrglsUvjWcv0OcACYkJGDDhg3Iy8tDcnIyhgwZgu7du6OiogIZGRmw2WweV+EAYMyYMXjyySe9vl9ZWRlsNhsyMjI87p8xYwb69u3r9TUVFRX40Y9+hEmTJnl8xhNPPNHiuR07dsSqVat8/jx2ux3V1dXarbS0NOoHUFsWJB9vUdzT39vvFvMEpxWUV9Vrf+Cb377JORvSz1X3kw2blxrSz6HgUZdQv8sta/vJEWjad0dM18PYaCcvKAd/BkxJhCsEReF9YQIY5lPAtbW16N69O+bNm6clgOfOee6VeOWVVzB8+HCvr1cTwMxMz8Rg+vTp6NevX4vnV1dX46GHHsJTTz2FhoamkgK+kswOHTpg9erVPuP3dqgl2gdQW8a4y308NjcFo5dk+n27PUYK+zdCCo3FqYXuqv7J2r/v+NXZqHOEttxDeVU9BFHCHW9tQX0D67KZwSMzt4e1FlywLdxxAoIo4T/rQ1Pf0oo2HyqDIEr4dVxoisL7wgTQgDIww4YNw9ixY0O+BFxTU4NHHnkEjz/+OOrr6z0ea+8SMK8ABu6XH6a3ayO+2snhg+QTIYqMwmX4gjRD9kXJsqwVFc4/W9X2C8hQDU6X9sXvQnV92y+IQOr+1jEr9hsdimm8l6Ts+4zZmBfWz2UCGOYE0G6347bbbsPUqVO1QyBz5szRHnc4HH4dAnnttdc87hswYIDHIZDq6mo8/PDDGDJkCOrq6lq8h3oIpPnVxzVr1vAQSAjc186q/moh35+/n8I6biZWcE6px9dnYgKq6sJf2Hf0kkwIooT1B0rD/tkUGLWVWp+JCWFdCgym73KVq1nPcfuK3/6yTDk4syLzVFg/l/N3iBPAN998E6mpqSguLkZWVhZGjBiBrl274vTp0wCUMjDdunXDpk2bkJ+fj+eff75FGZihQ4di4cKF2n+rZWCWLl2KgoICTJgwAV26dNHes6amBg899BDuvvtuFBYWepSgcTqVZSC1DMzjjz+O7OxsbN++HT/4wQ9YBibI6hxNVf2rA6zqX2tvRP/JiRBECTkh7AdJoTUzoSDs9b2ai/32MARRwrTvjhjy+eS/rKKKsBcDDja1oPET87nv1F+PzlKKwu8trgzr53L+DnECqNb169ChA3r16oVRo0bhyJGmP8RqIegePXqgU6dOGDx4MPLzPY//C4KA2NhYj/vi4uIgCAI6duyIQYMGIS2tqWhoSkqK1316NpsNp06d0p5XUlKCp59+GjfddBNuueUWjBs3Dna7PaCfjwOoderm3oHtrOqvngiM/bbt4uAUeVwuGQ/N2O4u72BMXbQ1+0ogiBJeiM8y5PPJfxsPKlf9n/90j9GhtFv+2SoIooSfTk82OhRTqLrWVBS+6lp4Vwg4f7MVnC4cQK1L0VnVXz3FOejdbWhwuoIcHYVaRuElra2XUYcwDp254j6Ass2Qzyf/fbRdOUDxr3WHjA6l3Uovu5exJyVw64of9hYrReEfnbUj7J/N+ZsJoC4cQK37MkvZEP2XZe2r6t/odGHQu0pvzZ1HLwQ5Ogq1f68/5N7cbdyJyGsOJ3q7DxZcrAnsCj+FV8zG3LB3gwi2WnvTtpdQn3K3ghWZp3TNEXpw/mYCqAsHUOvU011TdFT1V/dwvc5ivqZS3+DEwLeTIIgSsooqDI3lsfeV/qzpJy62/WQyzIufZUEQJazdf8boUNpNlmXcOVHpQV0WBT2or9obcbHGrt38Obxjb3Rqz1dbwL2XFNqi8N5w/mYCqAsHUOveCEJVf3UJr9/kBFy18xu1WSTmn9OWdow+0fnalwcgiBI+TSsyNA5q3WNzlUQ94+Qlo0PR5f5pyRBECUfKrD0vZJy8hB+/tcWjuPuvPt7d6tJ3Za1D+//T/Lb5UPgLf3P+ZgKoCwdQ6367KEP3L7csy9oVnI0HWcrDLGZsUU7/Tv7a+J6uH7r3lv1jbY7RoZAPsiyj32SlW8ypS+Yu/j5sXqolEtm2vOvueiKIkrbNQhAlHDjtu4j38oxTHq/pHSPhZ3N2GNL2k/M3E0BdOIBapx7vP6izqr86gb/4GU9ymoW6nBfu4s/ebD1cDkGU8IsP0o0OhXyouGrXEgN7o7m7tqhffLfkGXPyPVz+EL/HY8n+H2tz2vzS96uPd0MQJXy+uzhcYfrE+ZsJoC4cQL41Ol24w708cF5nVf+SCuVk3e0x5u0QEG0emJ4cMS29mhcY5mnyyJRbesUy5VNeXq60v/wqy/gvP6EiyzL+231AL69U6bKTfuIiBFHCfVO3wtHY8ves+FKt1poxEg5kcf5mAqgLB5BvZ69cC2pV/1HuJvHx6dzHFekuua/m9I6RUBsB+zZdLhl3uQ+kHD9f0/YLKOzUPaO/+ji8/WBD4V/rlIMNH+88aXQoIXOhpl77Uq6WeHK6ZO2LX/KRlq0/5287DkGU8KfP94Y7XK84fzMB1IUDyDe1vtPgIFX1X+kuF/D0R1zGi3S7T16KuI4O6heIb3LOGh0KeRGfXgRBlPC3rw4aHYpu0yVlb9yMLQVGhxIyaceVq31D56Z43D/NvS/w+n9HWZYx+L2dEfU7yPmbCaAuHEC+qb18f78kOFX9K2sd2omzE7yKE9HUydyo9m/eTNyUB0GUMDsx/OUmqG3vbFbKPc20QNL08c6Tpi9o3ZYlaYVeEz21E0rfSQke7T8PllyGIEoYMCUxYuojcv5mAqgLB5Bv6h/BN4P4R/Dl5fsMqxlF/nvTvQQWSQV9V+5RipL/X4QsP5GnV1cq++aWZ5wyOhTd1AL4r6zYb3QoIfOPNcqBj4U7TnjcL8syHnefgm5ez3HKN/kQRAkT1kTOSXzO30wAdeEA8i1mo3LFZd624CUB3+WWRUxtOfLt6Y/S3f1/y40ORbP/lLIl4eGZ240OhbxQx4y3vWNmI+Uq+xmfW5RpdCgh89QHyr/XNi//XuqXf7Wnc4PThfumboUgSkg9HjnF2Dl/MwHUhQPItz8u3at8C9wXvKr+9Q1ObTP/3uLKoL0vBU+j04U+k5R6bqcrIqeeW3V9U9P5K3XhrzlGrVMThIJz5v9bmuHeAztsXqrRoYREg9OldTs5U1nX4nH11H3vGAmPzU3Bz+bscPfjTkZjBJ3C5/zNBFAXDiDf1GWA3UEuhqqesIvZmBfU96XgOHmhRtvrE2lXadW6lHsMbk1HnuocTf1zq641tP2CCHe4TNkH94AFStp4c6xc+R2/6+0kn10/1AsAzW+RtnWH8zcTQF04gLyTZRn9JydCECUUB7mqv/rt+u7YJNMXjLWizYeUZfpfx0VeOQ91D+myCChCS03ULw0D304yOpSgaF4Cq7W2aGb1Tc5ZCKKEZz/J8Pmcaw4n9p+qxN5i5ZZz5kpEXf0DOH8DTAB14QDyrrLWoX3rU2tEBYvTJeOhGdsjbo8ZKd5LOhqxV2jfTzoGQZQgbsg1OhRqJtVdUmT4gjSjQwmK5lc0I6EOZrDNSlB+xyd9HXm/44Hg/M0EUBcOIO/UUgD3TwvNEshMd5/ZSCozQoq/LFOusq3IPGV0KC2oh4hGWqDYsJV8lVUCQZTw52X7jA4lKGRZRp+Jyj7Ys1euGR1O0P3pc2V594s9p40ORRfO30wAdeEA8i4xvzykE23BuWptiaWqzvx7hqxE3WcXiYd0Tl64CkGU0H9y5O1PjGbqVePWesiajdoRI/9sldGhBJ26AnPgdOT9jgeC8zcTQF04gLxbuqtYKRL6Zeiq+j85Pw2CKGHVXuv22zSbqmtNJ20jMTFvdLrQ131C+VSQ96ZS+01w15RblFpodChB88T80ByCM9rlZtt7auoj73c8EJy/mQDqwgHk3bvudkDTpSMh+4xPUpRK9L9bbN1aW2ajtv97JIJr7Y34aJd7/+g5o0Mht+cWZUIQJXx7qMzoUIJG/ZmkXGuNs8zCCgiihJ/N2WF0KLpx/mYCqAsHkHd/XXkg5Kcty9wn7ay6z8aMVrj7NUfyXi61jND8IBYoJ33UbQMHTl82OpSgeWXFfkvsk7ve57uLLdPlhPM3E0BdOIC8e2bhLp9V4oNp9BLlW3ZcysmQfg755y13v905Edxv9zP39oRXV5p/ArOCRqcLd7h7fJ+vrjc6nKD593rli8bHO631t+k/63OVDk9bjxkdim6cv5kA6sIB1NI1hxMDpig1AI+Wh/b/y5p9JVrFfSvW2zKb38TtjvilPLWO5OD3dhodCqGpZt6dE7dY6mDODHelglBugzHCSPeX+y155l/a5vzNBFAXDqCWvnUXAv6f2TtCnpRVXWvQ2o4dLrPeaTszcblk/MSd+J84X2N0OD5VXLVbukab2aj7Rv93jrUS8rgUpR/um+sOGR1K0DhdMvpNVv7eFl28anQ4unH+ZgKoCwdQS39214GbG6Ylgte+PGDJb9pmU1JRp5XmibSK/9f7qbtEx8ES6+w5M6uvs5WuEr9fssfoUIJKrW348nLrbDUouqiUUeo3OQFOC1yt5fzNBFAXDiBPFVft2n6ekxfC8w1x62Gl5uBPpydb4o+SWSW5/x1++WG60aG0Se1T+lUWSwgZ7eOdypWyf661zpUyANiSdw6CKOG3i3y3SzMb9WcauXCX0aEEBedvJoC6cAB5Wp6hnAJ9Jox/IByNLtw7dSsEUcKuE9aquWUmHySfMM1ErnaSmfKNdQoPm1XMRuXg0DyLncrOKFT2mj4+L9XoUIJm3lalleJ/1lujlSLnbyaAunAAefrVx8ohgKW7Qlf+xRv19KkZkg+rGvuFshQfn15kdCht2pRdCkGU8Nwi1pA02kvuq7Fr950xOpSgOlJWHdJ2mEZQS9t8HsLyXuHE+ZsJoC4cQE2KL9VCECXc8dYWXKyxh/Wz951SNpL/ZEoirjmcYf1sUvz8/RTTXIVVWwkOjE3i6XGDPT4v1TTjJhBqndIfv7XFMmPsZ3OUeo2ZhRVGhxIUnL+ZAOrCAdRk/rbjEEQJLy3dG/bPdrlk/M/sHRFfgsSq6hyN6B2jnKy9dDW8yX97OBpd+LF7ryqLiBtHlmX0n6ycHC+2WGu+aw6ndtr8qgVOm9fUN7V5vFzrMDqcoOD8zQRQl2geQPUNTiQdLsc3OWfxTc5Z7dvh19lnDYnn/aRjEd+Fwqpyzlwx3XLX8AVKL+ntBaEtVk6+Ne8rW99grSv3sixrJapKL9cZHY5uB04rqywPzjDP73hbonn+VjEB1CGaB5CacDW/DZiSiDqHMd92T164qi1Bcxk4vFbvVUpevPhZltGh+G386mxLdmowk/yzVab74hCIB2co5YYOnblidCi6fbHntGErPKESzfO3igmgDtE6gFwuGQ/N2K6UBPh4N16Iz8KLn2Vh/YFSQ+NSl5NOWWw5KdLFfnvYdLUY57m3LMRszDM6lKiVmF+u/Q2xot8tVlpVbjD472IwTPpaOWg3M6HA6FCCJlrn7+aYAOoQrQNILXFwd2xSRC3dqMvQ+09VGh1KVDHjRLd23xkIooQ/WuiKhtksdfdlfu3LA0aHEhJm/GLky7OfZBi6xScUonX+bo4JoA7ROoDURucxGyOrHtSv3b1oE/PN36fSLGRZxj3vbDVdO77d7p7AQ+emGB1K1Hr3uyOWSZC8MePWCG9kWcbAt5PC0t89nKJ1/m6OCaAO0TiA6huc2h+DrKLIKgeg1qlauee00aFEjXNV17S9l/bGyLka3Ba1bFH/yYmWKdNhNn9dqdSOXGaRunLXM+PhKG9KLyttHu+cuAWOxshu8xiIaJy/rxfSBDA2NhY2m83j1r17d+1xWZYRGxuLnj174sYbb8SQIUNw+PDhNt83Li4OvXv3RqdOnTBo0CCkp3u2n1qyZAmGDBmCrl27wmaz4cqVlptwBUFoEZsoigH9fNE4gKRcpR3Qo7N2wBVhrdfUrgLzLdZVIJLtPHoBgijhifnm6nhQ39BUpqPSImUtzOaZhbsgiBK2Hi43OpSQaF4eKdy1UYMp+ch5CKKE4QvSjA4lqKJx/r5eyBPAu+66C+Xl5drt4sWL2uOzZ89G165dsXHjRuTn52P06NHo2bMnampqfL7nmjVr0KFDB8THx6OgoABvvPEGunTpgpKSpr6eCxYswKxZszBr1qxWE8B3333XI7arVwPrXxuNA+jl5cpVtjmJR40OpQW1VdHETdzYHy5xKUov13Grso0OJWAPTFdOaeaVmmfp2koGvbvNdFsHAmWmAum+LNyhtHmcsCbH6FCCKhrn7+uFPAG89957vT4myzJ69OiB2bNna/fZ7XZ069YNixcv9vmeDz74IMaOHetxX//+/RETE9PiuSkpKa0mgAsWLPD3R/Eq2gbQ5VqHVkD3xHnfSbpRVmQqvYhfXbnf6FCixuurzFtOZeTH6p5Ra16BimTNCyVX1TUYHU7ImKlFoi9/++ogBFHC4tRCo0MJqmibv70JeQLYuXNn9OzZE71798bo0aNRVKT8IhQVFcFmsyE72/PKwciRI/HSSy95fT+Hw4EbbrgBmzZt8rh//PjxGDx4cIvnt5UA9ujRA7fccgvuvfdeTJ8+HQ5HYEtB0TCA6hucKK+qR3lVPZakFUIQJfzyw/S2X2iALXnK8vSoTzKMDsU0Kq7atX/fCzX1Ae+He2K+0sprx1HzFVT+25fKxPZZmHtXE1B48arWvtHKezA/SD5hyj7l1fUN2t8F9Spm6vGLbb/QRKJh/m5LSBPAhIQEbNiwAXl5eUhOTsaQIUPQvXt3VFRUICMjAzabDWVlnq27xowZgyeffNLr+5WVlcFmsyEjw3OCnzFjBvr27dvi+a0lgPPnz0dqaipyc3MRHx+PW2+9FS+//HKrP4/dbkd1dbV2Ky0ttfQAqrrWoC3TNL9F6rfZvcVKtfrB7+00OhRT+CSlsMW/bey3be/BVdkbnbjDfUW4zIQt1aZLyinUqZuteQo1kqUcM+fe0UAlHS6P6C/N3uwpqtB+r5vfLlTXGx1aUDEBDPMp4NraWnTv3h3z5s3TEsBz5zxLdrzyyisYPny419erCWBmZqbH/dOnT0e/fv1aPL+1BPB6GzZsgM1mQ0WF75Ot3g61WHkAqfX+1BNgd07cgp+/n4KKCO33WtTsqgK17fdL9mgneNWl/X6TE/zuXXq4rEqrB2nGqzjLdit16P660pp16CLZ5K/zIYgS/rHWWvvKrldSoZyg7TMpAY1Oc5ygfe1LZdn69pimv/svL99vyt/x1jABNKAMzLBhwzB27FjDl4Cvd/bsWdhsNmRl+a7ZFG1XANftP2OqOlbVzRqWsx1c2/53zk4IooS9xZWQZRmPuZd6Nh70r6DzxoOlEEQJzy3ObPvJEWib+3TjiI92GR1KVHE0unDfVKV2ZJrFlhWv53LJ+MkUpUPRyQuRt2/6etX1DVoP4yNl1pzXVEwAw5wA2u123HbbbZg6dap2CGTOnDna4w6Hw69DIK+99prHfQMGDAj4EMj1vvvuO9hsNo/TxG2x+gBS96+IGyKr4LMvzRuwn6k0fwP2UHK5ZNw5Ubnqd9a9fKv+e/ub8M/YUgBBlPD2N/mhDDVk1CuYg97dZnQoUUUtK/LA9GTTXBXT4zfuAvWbD5W1/WSDqR1ynpifarkrftez+vztj5AmgG+++SZSU1NRXFyMrKwsjBgxAl27dsXp00qh3tmzZ6Nbt27YtGkT8vPz8fzzz7coAzN06FAsXLhQ+2+1DMzSpUtRUFCACRMmoEuXLtp7AkB5eTlycnIQHx8Pm82G9PR05OTkoLJSaRGWmZmJ+fPnIycnB8XFxVi7di169eqFkSNHBvTzWX0AqR0/Ptp+wuhQ/PboLKUd3MGSy0aHEtHOV9dry7/qJHy6olZb+vFnv8+Ln2VBECWs2uv/l6ZIUlXHK8ZGUE+VvvtddOy9fGuTUp/0vaTIK511PXVbSFyK+U71B8rq87c/QpoAqnX9OnTogF69emHUqFE4cqTpl14tBN2jRw906tQJgwcPRn6+59UEQRAQGxvrcV9cXBwEQUDHjh0xaNAgpKV5Fqj0tVdv2bJlAICDBw/ioYceQrdu3XDjjTeiX79+iI2NRV1dYFeNrD6A/hC/x3Q9XkdavLhssBwsuawV9G5OvVrhz0EftY5etkmTbVmWcZe7q83JC4HVAKX2qa5vQF/3Vfpoqb+40l2e6i/L9hkdSqvKrlzTClefNeGhrkBZff72B1vB6WD1AaQe/98TYS3fWvOXZfsgiBK+yjLnValw2XyoTNm/t8hz/546WT39UeunFi9dtUMQJfSOkVDr56GRSKSWsbH6XrRIsda9r3jo3BTLLzGq1OoE13/ZijSLUpWqAL8z6Z7eQFl9/vYHE0AdrDyAXC5z7qf7z/pcCKKED020bG0E9Y/9G6s9D2FV+lnse/dJ5YT4EJOX3Pm/z/eaehnbbJ7/VFlVWLgjen4/q641bTWouha5Ra+HL0iDIEpYHSW/C1aev/3FBFAHKw+gCzX12n6wBhNt1H4v6aipDyaEy5Rv8n3uS3p5+b429yzFpxdZooTKpK+V/VnvJx0zOhTLO1fVtMRopi+VwaDuTd5bXGl0KF4VnKtWytVMTIjoJDWYrDx/+4sJoA5WHkA5Z65AECU8PHO70aEE5HN3bbe/fXnQ6FAiWmtL5d/llmlLVi6X92W6N9cpB4QWJB8PdaghpfYy/ofF+pxGosXuq86/XRR9nXrU37cVmaeMDsWrme4T/WO/MPcXukBYef72FxNAHaw8gKRcc7ZV0/a2Rck+lvZSl3tSjl1o8Vh9g1M7HOHrisXTH6Vboo/uNzlnOV7CRB1zX2adbvvJFqOuTMRszDM6lBacLhkPzdgOQZSQFEWH56w8f/uLCaAOVh5Aat/f11dlt/3kCJJZWAFBlPDY3BSjQ4loA2PV06/e9/n9y32Fz9uE1eh0aftDT1fUhjrUkDpw2hwb9M3uaHm11lHoSl1gPdetQP1i+uu43UaH0kKGez/v3bFJsDdGTzkkK8/f/mICqIOVB1Dst4chiBJmJ0Z+7armTl6o0f6YkXfNO6bUObyf4N3dyqSg/j8eMCXR5xKxWZyruqbVQ3Sa/GeJZLMSlCtgY1bsNzoUQ0Ty70xrX/aszMrzt7+YAOpg5QH08vL9EEQJK/eYa7nmSp1DS26i6dtsINQN3/dN3erzOU6XjAdnJHtdForkqxmBcrpk7dRzWRTUPjOCyyXj4ZnKEmNC3rm2X2BBkXrV3J/tHlZl5fnbX0wAdbDyAHrqA2WP186jLfeIRTJZbmpxxgndu+0F5/2q9TfDx8bwSN7P1B7/M1s5obnvVHRNgOGibssYGJuE+obo/VIWiftm/TnwZVVWnr/9xQRQBysPoHveUZq1H2+lFlykUjc055a23QM6Gq1wF3tuaznuSJn30hDqicblGadCHGl4/G5xJgRRwjc5Z40OxZLU2pxm6SkeKpF4ct6fkk9WZeX5219MAHWw6gC6am/UllGvmrDLg/pNe8fR80aHEpFmJihX9t7ZfLjV58myjCfntywOq9Y0yzJRh5jW/GNtDgRRwsc7rd//NNzqG5wY6F5iNFNHoVCItNqZ/hZ9tyqrzt+BYAKog1UH0LFyZcPyPe/43iMWyf7k7u6wdt8Zo0OJSH//6qDf/X4/SfFsD+XR1aDOGgVj5249BkGUMHGTNZa0I8mWPKWc1CMzt0fdEuP1Iq17zso9p/3aCmJVVp2/A8EEUAerDqCdRy9AECX84gNz/mFQl1p4Rce7X8ft9ntDftmVa1rC9+a6QxizYr82oVvF6r0lEEQJf/p8r9GhWM4r7vEyKyH6lhivVxFh/bNHfZLh9xdBK7Lq/B0IJoA6WHUAqd8MX15uzpINasmJtpY4o5V6utffPZJq/9bmt0hZxgqG9BMXIYgShs1LNToUS7lc69AOZB0rj74lRm8emK787mWXXDY0jpKKOq3V54XqekNjMYpV5+9An4qwsAAAIABJREFUMAHUwaoDSE2gYr81ZwKl7rUZZ7Ii1uHgaHRp/Vgrrtr9es3ZK9ewJK0QcSknEZdyEp+mFeFclXVOWBdevApBlPCTKYmQ5ehepgymL9xfJJ8y6UpCKLz4WRYEUcKqvS1bMIbTh9tPQBAlvPhZlqFxGMmq83cgmADqYNUB9PqqbAiihE/TzLk0oLb3+v2SPUaHEnFOV9RCECX0m5zAZMetvsGpXdmMxi4VofLbRcoS45K0QqNDiRhqaaW3v8k3LAZZlvHY+ykQRAkbDpQaFofRrDp/B4IJoA5WHUDq3hAp15xFW9XN1lzSaymj8BJb5Xlx/7RtEEQJ+WerjA7FEs5U1mn73cqronOJ0ZuNB0sN7z196MwV7UugGas8BItV5+9AMAHUwaoDSK2jl3PGnHX01FPMrXW6iFbr9p+J+qUfb55ZuAuCKGHr4cgp0mtmC3coS4x/iOdV+ObU2pp3xyYZdgVebfNptj7vwWbV+TsQTAB1sOIAanA27RG7UGPOb+7qaTtBlNDgdBkdTkRZkHycRXm9GPvFAQiihM93FxsdiunJsoyhc5UlxnX7WYqpOXuj09DWgw1OFwa9u82UXZ6CzYrzd6CYAOpgxQGkLt30mZRg2rpdLpeMO9x/ZM9H6Qk3X/69XimR89H2E0aHElGmfXcEgihh2ndHjA7F9PJKqyCIEvpOSkBNvTVqRQaTWlzdiEL1O48pJb4Gvbst6r8cW3H+DhQTQB2sOIDUvp0/fz/F6FB0UcstcE+Xpz/E74n6zd/eLN1VDEGU8NqX1ilvY5Spm5Vk+u9fHTQ6lIikHrIzok7p+NXZpq7wEExWnL8DxQRQBysOoA0HSi2xd+epD5R2cCnHonuZ43o/d5/+i/a2XNdLOlwOQZQwcuEuo0MxtUanC/dPU758bS9gK0Zv4lJOGlKm6qq9Ef0mJ5h6f3cwWXH+DhQTQB2sOIBmJyo1AP+9/pDRoejyx6VsB3c9l0tGn0nKBHCmss7ocCJK/lll2fL+aduMDsXU9p2q1A5gRfsSoy9qp6Un5oe3SoHalm/IeztZAgrWnL8DxQRQB6sNIFmW8b9zdkIQJWzKNvcSoXrSbbrEPV2qCzX1WvV/Ts6eLtc6tIND9Q1Oo8Mxra+zWYOzLUXuwuMDwlx4fI77y/1b7HkNwHrzd3swAdTBagPoYMll7Q9TncPc9aHU/q4sd9Ikx13/62EL9fENFlmWMWBKIgRRQtHFq0aHY1rswtM2owqP/3nZPgiihJWZp8L2mZHMavN3ezAB1MFqA2jKN/kQRAkT1uQYHYpuarJz/7Rko0OJGFKusgT07CcZRocSkR6flwpBlLDrxCWjQzGtmQkF7MPtByMKjz8yU6nvuu9UZdg+M5JZbf5uDyaAOlhpADU4Xbhv6lYIooTU4xeNDke3OkejVs/wYo1/PW+tbklaIQvAtuIl977RNfuM7dNqZv9ce8iwE65mMtJdeDwpTIXHq+oatKuO1SzNA8Ba83d7MQHUwUoDaHvBee2KWaNF9oepJ155RUeh7oucnXjU6FAi0lub8iCIEuZtPWZ0KKb1Eg9f+SXchcezipTyXo/O2hGWzzMDK83f7cUEUAcrDaC/f3UQgihh6mbrHJpQ/8jGpxcZHUpEeHn5fmUP0J7TRocSkT7eqZTn+Odac5+AN9IvP0w3rMixmYS78PjyjFMQRAkvL98Xls8zAyvN3+3FBFAHqwygmvoG9HWXB8krtU7h5A+ST3BCb0atjRjtLaB8UU+wjl6SaXQopvXgDKUGYG4p68y15vPdSuHxsV+Ep/B4zMZcCKKE95N4dVtllflbDyaAOlhlAK13F38eOjfFUvWh1OK+v/ww3edzZFlGeVU9Si/XofRynaVbx93zjrLH8/j5GqNDiUhqDbufzeEyWXu4XLKhfW7NJNyFx3/18W4IooTvcsvC8nlmYJX5Ww8mgDpYZQC9+FkWBFHCwh3W6g9bUuHuazwxwee+RrVtVfObFfeAXbU3aj/fVbu5S/yEytkr1yCIEu6cuAVOk/bBNlLzWor2RtZSbE04C4+7XDL6T1ZKHJ28wBJHKqvM33owAdTBCgNIlmUMjE2CIEo4Umben8Mbl0vGT9y13U74uOqlFr7uMylB65Lx3xZslH6svAaCKOGed7YaHUrEanS6cIf7ClZ5lXWvBIfKifPKGLs7NsnoUCLelbrwFR4/dakWgiih7yTfX4SjkRXmb72YAOpghQHU/KqHo9F6fxx+E6csfWw+1HLpo/lVscpah0cfU6ttYlfbT/3iA9/L4QQ8OmsHBFHCgdOslRaojMJLEEQJj81NMTqUiBfOwuOJ+Ur9zxEfsc91c1aYv/ViAqiDFQaQWv5l+II0o0MJCbW0x3tJLUufHDitdD55cEZTsWh1SdhqnQxW7jntPgW43+hQItpzizIhiBK+9fKFgVr37aEyCKKE5xbzEI0/hrkLj6efCG3d1fnbjkMQJfxrHQ/DNWeF+VsvJoA6WGEAqaUv3lhtrYRHtTJTKX/wl2Utyx98laW0i3tp6V7tvtzSK9pySY2FCqbOdvcBjf2WHRpaM2FNDgRRwicphUaHYjpLdyknW//25UGjQzGFcBUef3WlUv7ps13hqTloFlaYv/ViAqiDFQaQWv9vUao1Jzz1ZKe3Aqhq67uZCQXafbIs47G5SgHp9QdKwxlqSL2+KhuCKGFJmjX/nYPlvSQlUZ70dZ7RoZjOHPeXjLe/yTc6FFMIV+Hxwe8p+5x3n2RB/OasMH/rFdIEMDY2FjabzePWvXt37XFZlhEbG4uePXvixhtvxJAhQ3D4cNtXKOLi4tC7d2906tQJgwYNQnq6576mJUuWYMiQIejatStsNhuuXGlZk+ry5ct48cUXcfPNN+Pmm2/Giy++6PV5rbHCAFL7n6Ycs2ZtuKprTS2Qqq55XtFTl/u+zj7rcf9H25X6gS/EZ4Uz1JAa9UkGBFGClHvO6FAimnpV+M9erhhT6/69XmkD99F2a1UTCBV19eUfa0PXe7222T7niqtsidmcFeZvvUKeAN51110oLy/XbhcvNu13mD17Nrp27YqNGzciPz8fo0ePRs+ePVFT47tO2Zo1a9ChQwfEx8ejoKAAb7zxBrp06YKSkqbL6AsWLMCsWbMwa9YsnwngU089hYEDByIzMxOZmZkYOHAgRowYEdDPZ/YBVN/gxO3ufrlWrn+nbuzfW9y0sb/56eej5Z7/fmr5mN4x1vn/8rC7EXzOGRbobU3q8YsQRAlPzrfmnthQ+vOyfRBECav2speyP8JRePxgibLP+YHpyW0/OcqYff4OhpAngPfee6/Xx2RZRo8ePTB79mztPrvdjm7dumHx4sU+3/PBBx/E2LFjPe7r378/YmJiWjw3JSXFawJYUFAAm82GrKymKzx79uyBzWbDsWP+X443+wBSa1HdN3WrpQpAX+8v7olpReYp7b62Tj8/675i9mma+dvINThdWqJ/ocYaCW2onLyglDIZ+DZLmQTqmYW7IIgSth2x1gn6UAlH4XH1ivaLn1lnNSNYzD5/B0PIE8DOnTujZ8+e6N27N0aPHo2iImVCLSoqgs1mQ3a25+GDkSNH4qWXXvL6fg6HAzfccAM2bdrkcf/48eMxePDgFs/3lQAuXboU3bp1a/H8bt264fPPP/f589jtdlRXV2u30tJSUw+gdfvPQBAl/H7JHqNDCSl1X1fMxlztvrZOP6unZq1QNuVMZZ1W69DFAsetqnM0LZldv2WAWqdeac8uuWx0KKZQ5v4S+uO3glt4fNLXeXh01g48OmuHtsoxY0tB2y+MMkwAQ5wAJiQkYMOGDcjLy0NycjKGDBmC7t27o6KiAhkZGbDZbCgr8yy3MGbMGDz55JNe36+srAw2mw0ZGRke98+YMQN9+/Zt8XxfCeCMGTPQp0+fFs/v06cPZs6c6fPn8ban0cwD6F13Q/J3Nlv7ZOhWd9ulR2Zu1xIgdf/NhDXe999UXLVriUC1yU8D7ymqgCBK+Pn7KUaHYgpqLUgmMv6TZVkrpH6mss7ocEwhFIXHK5t1Y2l+s+oebz2YAIb5FHBtbS26d++OefPmaQnguXOem9JfeeUVDB8+3Ovr1QQwM9Nzz8T06dPRr1+/Fs9vLQH0ljDeeeedmDVrls/4rXYF8A/xeyCIEtbuO2N0KCFV3+DUvgnvKaoA0HT6eXErp58fce+b23fK3EWBN7h7Pf8h3tpXeoNFbY24mnvZ/FZd33TYKtSdLawk2IXH1WLcj87agUNnruDQmSs4XVEblPe2GiaABpSBGTZsGMaOHWvKJeDrmXkAybKM/353GwRRQm6p9Q8G/Gd9LgRRgrhBWQb25/Szuql9ZbO9g2b0oftU87/XsxCsP6ZLR1gzMUBFF69CECXcxb2TAXlucXALj6u1GF9dyYLvbTHz/B0sYU0A7XY7brvtNkydOlU7BDJnzhztcYfD4dchkNdee83jvgEDBrTrEMjevU0FgLOysqLqEMiFmnoIooTbYyRcc1j/G3tmobIMOjA2CVXXGvw6/azWNXtrk7lrwokblOT3g2SW5/CHesX0d+xo4be9xcqBhiHv7TQ6FFMJduFxtRTP/G3Hg/J+Vmbm+TtYQpoAvvnmm0hNTUVxcTGysrIwYsQIdO3aFadPnwaglIHp1q0bNm3ahPz8fDz//PMtysAMHToUCxcu1P5bLQOzdOlSFBQUYMKECejSpYv2ngBQXl6OnJwcxMfHw2azIT09HTk5OaisbLrM/tRTT+Gee+7Bnj17sGfPHtx9991RVQYmzV3uIlr6drpcslYK5f2kY36dflZbW/0mbncYIw0+dUlz3X5rL/UHy+Ey5XT8Pe9Y+3R8MG3JU/rNPvtJRttPJo36tyhYhcfVk9iJ+az32RYzz9/BEtIEUK3r16FDB/Tq1QujRo3CkSNHtMfVQtA9evRAp06dMHjwYOTne1aRFwQBsbGxHvfFxcVBEAR07NgRgwYNQlqa50lOX4c1li1bpj2nsrISL7zwArp27YquXbvihRdeiKpC0EvSCqOubdOsBOWKXr/JCX6dfj5xXikJ8pMpiaY+Pat2NskoZCcAf9gbndrm/HNV14wOxxRWuFsu/nXlAaNDMZVVe4NXeNzpktHXfRDn1CXu+2uLmefvYGErOB3MPID+4V56iKaq/cfKazxOxrV1+rnR6UKficof1JIKc55slGVZS3i5Gdx/w9x7RHce5elJf8zbGtwrWdEimIXHC937MPtPNvcX1nAx8/wdLEwAdTDzAHrqg/SoLNo6fEGalgD6c/r5lx8q/5+SDpeHIbrgu+QuZ9M7RvJa8Jq8G+funRyXctLoUEwhZqPS13ZBMveeBeLkhabDM3q3G0i5yjL8yI/NvWUlXMw8fwcLE0AdzDqAGpwu3DlxS1TW7FqcWqglgP6cfv7n2kPtPkBRcdWOmQkFOHvFuGXE3NIrEEQJD85gK6hAqHUiX1+V3faTCa+s2A9BlPDFntNtP5k0wSw8Ptd9FVatdECtM+v8HUxMAHUw6wBSl0KD8a3TbM5VXcOdE7fgrreT/Dr9HJ9eBEGUMPaLwPc2xWzMNXxfVIJ7c/6vTX6QJdx2HFU6xTwxP9XoUEzh13G73YcPzHml3EgPTFcKj+86oW+P7svLlSR82e7iIEVmbWadv4OJCaAOZh1A3+ScjeoTewdLLuPQGf8O/Ow6caldXTSaF5/uMzEBVXXGdBNRE9i/fxU9h32CoXmbLnuj9csk6fWzOcEtaBxN3tqkLJ+/uU5fnc7/mb3Do9g9tc6s83cwMQHUwawDSD0Nyw3bbWu+h67O0ej36xLzz3kcOFllUFeJdzYfhiBKmJnAXqCBkGUZd7sT+CNl5vr9NkL/yYk8aNRO+05Vaisy7e2i0rwTy5U6R5AjtCazzt/BxARQB7MOoD99vpf7dQKg9obN8fOqIQD8deUBCKKE+6cp3VaeM6io8Bj33qwVJu9mYgS1S8PGg6VGhxLRau1N+9hq7f5/SSKFyyVrV+++y21fR5D97iTy4ZnbgxyddZl1/g4mJoA6mHUAPTRjO5drAhBob9iqugatfMzOoxfQ2911xIjDIOop5u0F0XXaOxje/iYfgihhxhZePW3N6YparfwItY9aEPrl5e2rB7hyz2kIooT/+3xv208mAOadv4OJCaAO6gC6cqXK6FD8drnWoX1br6k3Zl+a2QTaG1Yt7jp8gVLb6/dL9hhWUuS+qVshiBIKzkXvH7n2Uv8dX/wsy+hQItqB08rVp5/N2WF0KKZ18kKNtue0sjbwJdyJ7n2EsxOPhiA6a2ICyARQF3UAFZaap1is2hP3f2bzj7W/Au0Nqy4dLkpV+nuu3XcGgihh2LzUsJ66bl5ioprJfsCySy5DECU8MJ0ldFqTmF/Ok+ZBMOIjpY3bynZs1xj1SQYEUcI3OWeDH5hFMQFkAqiLOoDSDptnL92y3cXupYb9RodiGoH0hi29XKcdGilzL/lW1zegj7tF0+Gy8F0tVq8qDIxNCttnWkmtvVFbvr901W50OBHrC/fy4ysr+DdFj892Fber97jLJeOut5UDS8fP14QoOuthAsgEUBd1AK3ZfczoUPwmblBq083dap6YjRZIb1i1gPD1fYb/9uVBCKKE6dIRH68MvpRjFzyWoilwQ97bCUGUsPsk+yj7siD5OARRQsxGVhXQ40JNPW53f+EI5DT1mco6rdxUg5PdfvzFBJAJoC7qAFqwJcfoUPw28mOlYKuUe87oUEzliflKb9iEPN//32RZxuPuHrLXt5nbdkQpLPzorPAtvX+ZpVyZ+UsQGs1HK/U0d3x6kdGhRKxJXyv7z+bxS6Vu6oGzQDoPfXuoDIIo4akP0kMYmfUwAWQCqIs6gP6zak/bT44ATpes1esqvHjV6HBMRT0I8tqXvrt65J9Vlor7TEposeeuplmdrsvt2OTdHu8lKfUep3yTH5bPsyL16pbeIr1W9udl+wytdWklGw+WaoXn/d0vrLbhm5XAAyCBYALIBFAXdQD9cdFOo0PxS/ElpVxD30kJcLqiqwWcXuo+QG/JnWrad0qS+LcvvXfdULslZBaGp1L/G6uzPQ6jUODUAw5Pf8SrK748OT8Ngigh9fhFo0MxvVp7o/Yl3Z+6o1fqHFpfd+7/CwwTQCaAuqgD6PFZCUaH4he1L+wzC3cZHYrpyLKsLQNfv7wLKFdX1Z6e2454r7n3/9u797io6vx/4CcIUFyl1AAv66GLqWlSbrG2/ZT1nmW12bfMzbXdSrMirdx21ExS06i0rUytyEpN0UQq94goKN7Aa5MyiDdAERFFRUCE4Tav3x/DOTAwAzOeueG8no/H+YOZw5kzHz9yXufyeX/kM3VnzdX5f0uNIwM3HLq+4rJUV+Ou+7vxqOLzVWb1qR2AcPIC7yrYw+TaEzdryk7Jj3mM5O1fmzEAMgCqInegXtPWu3pXrLJwi/F21jvreDvreixONj/AAwB2niiAqJEQOnszKqrMB4UFm43FXjWxhx29qwCAv3xovOL4W06hUz7vRlRTY0Cv9zbVBhxeYWmoqKzu0QZbpkoky7bVDt7qN2dLs4M65JO8b3bwGVVbMQAyAKoid6A/vvlTi6izJk8LtmyXc65A3WjOXilrVOJF9vbaQxA1EmbEWR4JKR02XoF94kvH10urqq5RRi6fLy53+OfdyP62eDevpFqQca4YokbC/XO2uHpXbhhV1TXoN8c4heS2Y5ZrzMqjf0Om8f/49WAAZABUpX4APJrv/p1owEfGkhYpmSxpcb2ebVDkGQDKKqpxT+1VogOnLE+vl1lwVZkyy9HPYMr1CO+asRE1fN5TlWnrjaNcP07gQ/YNJdaObh/1BR8rsafIX9MhaiRMjtFaXGfR1hMQNRL+Ht0yBiG6GwZABkBV6gdAd59r9Wq9CduvZ6ohMoppMM0bUFeG4eGorU2O3KuuMeDu2oLQ2Retr/N1PfZlG6fnGvBRyxig5M6Wp55iOR0Lfkgxts3EFSwCbU+HzlyBqJHQY2Y8ruob31o3GAwYvCAZokbCTwcaP5NMzWMAZABUpX4AvJ7pe5zp4GnjtFZh8zitlRpFZZXoPsMY4nYcL8DpS6VK7S5rims/vmhXs/UE7SFOm2vxeUWyjRymnVnDsaWYvzEDokbC7A3OK3DuCQwGAwZ9kqw8snP6UqnJsu3oBaWiA+d0vz4MgAyAqtQPgPPjM1y9O02SR4uNX7bP1bvS4k1aeVC5mlp/sWYU5DvrjM8KLtxy3KH7KN8eYv069eoPdCgq48G2vtdWGWe4+ZbPFdvd50knzP6dqb+8vsp8ySlqHgMgA6Aq9QOgu/9HlM/UrSktQE07eLoQYfMS0XtWgrK8vda6oLWsdr7PCQ6eN1V+bs3RQdNTyCOq92VbfsbTEz1ZO7PQJh1nFrK388XlGLQg2eTvTP3lz/OSrKoVSOYxADIAqlI/ANo6gbezvV57ps4prVwrJfOiU57N+8eyfRZrFpLtXqyd7WK5mz/q4WwP1ta+TMstcvWuENmEAZABUJX6AdDdn62TS1k4+tkzatrl0grl9o25h7vtRZ6TePdJjvi2h482GafVm95EmR9Po6+qVvrypat6V+8OkU0YABkAVakfAEOmSRYLALsD+Uz9cC5vGbha2Dzjv8XB044p0Gww1M357OjRxp5CHunt7lf6nUmeJaXHzHir560lchcMgAyAqsgd6M5/x0LUSMi5dM3Vu2RW/TP1izxTd7nxtbdnf9x72iHbr3+Vsbyy2iGf4WlOnC+BqJFwz3ubWFexVspJ4+MMgxcku3pXiGzGAMgAqIrcgQbMldy6wDLP1N3L/HjjgJyZP+scsn3d2SKIGgl/muvejyW0JFXVNUr5H3c90XO2tQfOQNRIGPftXlfvCpHNGAAZAFWRO9Czi7a6dUFO+Ux9EM/U3cLP2rMQNRL+b2mKQ7a/SZfvtCnnPMmjn++EqJGQkJ7v6l1xC/9NNM4tPm29c+a2JrInBkAGQFXkDjRluXFC7s8ST7h6l8z6iWfqbuVovnH+1D6zEhxyRfbb2lIzr/3o3qWJWhp5vmd3/X/ubP/+ydgei7ayPajlYQBkAFRF7kAf/aqFqJHwzjr3LLorn6lrYnmm7g4qqmpw14yNEDUScgutv52YcvIiRn2xq9mBPLM3HIGokfCBxNkZ7Cl6ZxZEjYRJKw9a/TsGgwHvrDuEt9b+3uSzg9U1BkxaeRB/npdk1TJtvetHI4/9Zg9EjYT1v+W6eleIbMYAyACoityBVmw3PtP1fLR7XmGTZ5/4PIln6u5ixH93QNRISDxi/RzST9WW8nnph6aLSMvbZg1A+9p1wvgoxV8/Sbb6d+QpGEWNhL1Zlyyut7v2MQ1bluPnS+zwra5f+Mfbmv1eRO6KAZABUBW5AyX+fsrmA4Mz/T3aeKYee5Bn6u5iSozWpttn8kAeUSPhzukbcbm0wux6GeeMt5e7z4hH0TVOW2ZPF6/qIWokhEyTcK3CuhqOM3/WKf9uTT0rN7X2duobq7XQnS1qcpHnnv5o01F7fTWb1dQYlEExZy5zUAy1PAyADICqyB3oyCnjQ/fd3413yxIR8pn6Hp6pu42l2zONz+lZOYXgZ4mm84Ku2GO+hIw8wnjiCsdONeep/jTXWMPRmim4KqpqcN/szcq/WZ/IBLNlecoqqtF7VgJEjYT9p5qfak46fA6iRsJfPtzqsr83F0rKIWok3D5NQmW1+9Y/JbKEAZABUBW5A10qvIKQacY/8gUl7lVnr6bGgO7v8kzd3SQfu2B1DTWDwYC/fpIMUSPh8UW7IGokPL2k8QjimhoD+s9P4tysDiRffYvZl9PsuolHzivleJr6d9lQW2T64SjrAl15ZV1gdNXcxNoc463th+YnueTzidRiAGQAVKV+B/rzvCSrrww4E8/U3dP54rp/l+aKNf9+5gpEjYSeMzchq+Aqbq892WhYjy418xJEjYR7LVxpIvU+kIwDbCJ/TW923ddq59+e878jTV6ZlecZ/iThmNX7IY/AddVgkP8dzrN4IkLUEjAAOjgARkZGQhAEkyUoKEh532AwIDIyEp06dUKrVq0QHh6O9PTm/7AuXrwYISEh8PPzQ79+/bBz506T9/V6PSIiItChQwf4+/vj8ccfR26u6fNvDfdLEAQsXbrUpu9XvwONXmIsBSMddq8rL/KZen+eqbsVg8Gg3B7UnS1qct3IX9MhaiRMjtECAJ6PNl6F+qLBoJ7/rDvMumwOFnswF6JGwrNfpTa5Xkl5Je6uvfKuO1uklP7pPiMeV67VPb956aoed043jgg/ecH6QR1ybc97IxOgr3J+2P96R6ZJnyRqaRgAnRAAe/fujfz8fGUpKChQ3o+KikLbtm2xfv166HQ6jBkzBp06dUJJieU/hGvWrIGPjw+io6ORkZGBKVOmoE2bNsjJqbslM2nSJHTp0gWJiYnQarUYNGgQQkNDUV1d94dSEAR8//33JvtWVlZm0/er34EiVhsf6v9mR5ZN23A0+Xmh0TxTdzvPfb2n2QLildU16DdnC0SNhG3HLgAA1tWGkEELkpU6guWV1ehTe1uQozIdJz3POMtK3/c3N1nDUa69Objev5E8OnvV3rq/VctTjQPIRn2xy6b9qK4xKHcdNumcX5h61i86lw9EIVKDAdAJATA0NNTsewaDAcHBwYiKilJe0+v1CAgIwFdffWVxm2FhYZg0aZLJaz179sS0adMAAEVFRfDx8cGaNWuU9/Py8uDl5YWEhATlNUEQ8PPPP1/X95LV70Afxh+1+taQM8ln6m+s5pm6u3l/Q7pyi9CSbUeNzwr2m7MFVbW38EvKK9FjpvHqklwTcGOa6wcGeAJ9VTXuqL1id67I8gmjPPK+/ijvr2oH/jyztO7q4d9qS/t8uyvb5n2Zv9F4W/mVFdbXJbSXl34w3rZeaWEwEpG7YwCFUswaAAAgAElEQVR0QgD09/dHp06dEBISgjFjxiAry3iFLCsrC4IgQKs1DSZPPPEExo8fb3Z7FRUV8Pb2RlxcnMnrkydPxsCBAwEAW7duhSAIKCwsNFmnb9++mDVrlvKzIAjo0qULOnTogAceeABLly5FTU3Tz8jp9XoUFxcrS25urtKBVuw5bVWNNmeTz9SjeKbudtbuN14l+nv0HovrvFF7ZbnhiYV8xfnRz3dicowWg2oHifCKjOMN+3S78Yrs0Qtm388vKlcGhdUfeHWuqEx5PWK1Fq/XPiN4+zQJF0rKbd6P+iV/JsdozS4b0+zzSEpNjQGfJBxTtis/viBflSZqaRgAHRwA4+PjERsbi7S0NCQmJiI8PBxBQUG4dOkSUlJSIAgC8vLyTH5nwoQJGD58uNnt5eXlQRAEpKSY3s6cN28e7r77bgDAqlWr4Ovr2+h3hw0bhokTJyo/z507F6mpqfj999+xYMEC+Pv7Y+7cuU1+H3PPNModaOtR44i/kZ/tbHIbzvbSDweaLBtCrnM41zi44/45W8zeTryqr1Ku9DUcXCSPIq6/hEyTcMLFxYE9gRzKFyefNPu+HOyfWtx4LmZ5FHH95YXv9l33voz8bGeTxaJ7vbcJ1Xa4ImypUDUrC1BLxQDo5FHApaWlCAoKwsKFC5UAeO6c6Rnqyy+/jBEjRpj9fTkApqaaPoD9wQcfoEePHgAsB8ChQ4filVdesbhvCxYsQLt27Zrc/6auAB7LL1GeDXInj9QeICxdrSDXKauoVkb0mrsCtP63XKXAeMOAaDAYIB0+h+idWcqy/XhBo22Q/S1OPtnkYxXyoJ25Zm7tny8ux/e7s5V/sx9STuFCse1X/2Q5l65h2a5sk34gL/IglKyCq9e9fdk3O7KUMkTy9pN59Y9aMAZAF5SBGTp0KCZNmuTyW8AN7d69G4Ig4Px566fmqt+BSsorlbPiq3rrZglwhr7vG2/VHMvnlSF3NGiB8dbtDjPhTb5a9Fkip/BzJ/JzmcM+3W72/TFfp0LUSFjn4pl35JqR9rgN/Nba3yFqOJ0k3TgYAJ0cAPV6Pbp06YLZs2crg0A++ugj5f2KigqrBoG8+uqrJq/16tWr0SCQtWvXKu+fO3eu0SCQhhYtWoRWrVpBr7e+kHPDDnRvpHEUpqvn6JRd1Ve5ZSilOq/9aHwO7OsdmSavXyguV64Onr5U6qK9I3POFZVB1Ei4Y/rGRiVYDAYDQq0s7+No8hzgC7ccV70t+Vbz5nTnjzgmcgQGQAcHwKlTp2L79u3Izs7G3r17MWrUKLRt2xanTxufR4uKikJAQADi4uKg0+kwduzYRmVgBg8ejEWLFik/y2Vgli1bhoyMDLz55pto06aNsk3AWAama9euSEpKglarxeDBg03KwGzYsAHffPMNdDodMjMzER0djXbt2mHy5Mk2fb+GHcjdbre6621pqvNFknGKt7fW/G7yevTOLIvPkZFrGQwG5cp6ep5pyMsvKlfCoauLcS/blQ1RI2HCcnUD0yqrazjvL91wGAAdHADlun4+Pj7o3LkzRo8ejSNH6p6LkQtBBwcHw8/PDwMHDoROpzPZhiiKiIyMNHlt8eLFEEURvr6+6NevH3bs2GHyfnl5OSIiItC+fXu0bt0ao0aNwpkzdbXWNm3ahPvuuw9/+MMf4O/vjz59+uCzzz5DVZVtV8kadiB3G3Ah36p6xM0GplCdLbXThTX8N3rsC+PJxIrUU67ZMWrSs18Zb/Ou/830Nu+22sE5Qxeavz3sTCmZxoEbAz7apmo7x88bTyR7z0pgiSG6YTAAcio4VRp2IHcrueKupWmozpnL1yBqJNw1Y6MyVd+J2gPundM34nJpRTNbIFeQB3rM25hh8vqS5EylzIurXS6tsMsjIL/8fpbF5OmGwwDIAKhKww7kbkWX3bU4NdUxGAzoXTuDhzxQ5+OEo7XBfb+L944sWb0vB6JGwrhv95q8PjnGWCLmy23mS8Q4W9i8RIgaCQdPFza/sgVRm4z9cUaca+YdJnIEBkAGQFUadiB52jV3mSBdrlfWcIABuRd5HukZcWlYtTcH/ecbp/j63+G85n+ZXEKeY/uBDxJNXh/+qXG6t6QM66sJONL4ZfsgaiT8uPf6H0v553f73OrRFiJ7YABkAFSlYQeSDwr95ye5eM+M5EEp0mH7zAZAjjHzZ12jAru9ZyW4fBABWXatokqZ1SO30DgwoqKqBnfWThN39opt84o7yvx443RxM3/WNb+yBfIJyYFTl+24Z0SuxQDIAKhKww50oaRcmdpJfp7LVTILriqjES9dtb60DTnfqYulmBKjxcvLD+Dl5QcwYfkBhvYWQK73tyTZeIVdnpqtT2SC2ZldXOFnrfH5vf9ben13Ja5cq3uOsLi80s57R+Q6DIAMgKo07EA1NQa3KZewcPMxiBoJ//qez5EROcKa/TlKQWiDwYA4rXHmlmeWpjb/y05yNL82lM66vlC6J+sSRI2Eh6O2OmDviFyHAZABUBVzHSj8420QNRL2ZF1y2X4ZDAb8v4+2QtRI+PUQnyMjcoSiskp0r51u7UheMeZvNN5ufe+X67/dam8VVTW4a8ZGk1vVtvh+dzYHJNENiQGQAVAVcx3o79F7IGokxLpwGqiDpy9D1Ei4571NKKvgc2REjvLqjweVcjD/qB1wsWpvjqt3y8SI/xoHpiQesX1giib2MESNhE8Sjjlgz4hchwGQAVAVcx3o3z8Zp1/6woVzZr77cxpEjYS31x5y2T4QeYLN6fkQNRLC5iXiT3ONJVd+y7n+kiuO8OYa4zy+i7ba/jfpiS93c0Q63ZAYABkAVTHXgf6beByiRoIm9rBL9qmiqkaZi3TniQKX7AORp6ioqlGmhZOXUjebd/ur7cb6pK+t+s2m36uuMaDnzE0QNRJOXrjqoL0jcg0GQAZAVcx1oJ8OnDFbINZZ5KnFHvggEdWctonI4abHpSnhb+DH6qZdc4TtxwsgaiQMXpBs0+9lXyyFqJFw97vxqHJxVQMie2MAZABUxVwHSjlpnH9zkI1/bNW4UFKOzIKryCy4qsxHPPd/R5r/RSJSbf+py0oAnLjC/aZdvFBcV57qWH6J8reiuWVF6imIGgmjvtjl6q9AZHcMgAyAqpjrQKcvGc+ae8yMd0otsG1HLzQqIixqJOjOFjn8s4nIWP7p4SjjqPtPtxx39e40YjAYcP+cLWb/Tliz/PsnPktMNx4GQAZAVcx1IH1VtTJDwEUnFGD+1/f7IWok9Jy5CfdGJuDeyARErNa6TSFaIk/w66E8jPjvDmRfLHX1rpj1WeIJhM7erPyNsHbpPz8JKZkXXb37RHbHAMgAqIqlDvTgB8bRgIdzrzj08y9d1eOO2qmn+JA2ERGRdRgAGQBVsdSB/rbYWDohPs2x03n9kMJndIiIiGzFAMgAqIqlDvT6qt8gaiRE78xy6Oc/WVuj69td2Q79HCIiohsJAyADoCqWOpA8JdT7G9Id9tmnaks03D5NwoWScod9DhER0Y2GAZABUBVLHWh5bfmECcsdVxJCLjj9j2X7HPYZRERENyIGQAZAVSx1oKQMYzHmx77Y6ZDPNRgMCP94G0SNhDit6+YcJiIiaokYABkAVbHUgTLOFUPUSLhv9maHfK42p1Ap/eJu004RERG5OwZABkBVLHWg4vJKh84LOusXHUSNhCkxWrtvm4iI6EbHAMgAqEpTHShsnrEW4JYj5+36mZXVNUpV/+RjF+y6bSIiIk/AAMgAqEpTHWjO/45A1Eh47cff7PqZW48any/809wtnKCdiIjoOjAAMgCq0lQH0p0tgqiR0P3deBSXV9rtMyNWax1eYoaIiOhGxgDIAKhKUx3IYDBgyMLtEDUS1u4/Y5fPKymvxN3vxkPUSDh0xrHTzBEREd2oGAAZAFVprgN9ue0kRI2E577eY5fPW3cwF6JGwqBPkmEwGOyyTSIiIk/DAMgAqEpzHejM5WsQNRJCpknIu1Km+vOej94LUSPh86QTqrdFRETkqRgAGQBVsaYDPbM0FaJGwtLtmao+63xxOW6fZiwtk3PpmqptEREReTIGQAZAVazpQKv25kDUSBjx3x2qPit6ZxZEjYTRS1JUbYeIiMjTMQAyAKpiTQcqulaJ7jOMAzcyzlnf0UrKKzHzZx1eW/UbXlv1m1JXcMWe0/bYdSIiIo/FAMgAqIq1HWjiigMQNRLmx2dYve2Ve04rs4nIy93vxuNyaYXa3SYiIvJoDIAMgKpY24E26c5B1Ej487wk1NRYN3p3elwaRI2Ef363D9/vzsb3u7OhzSm0x24TERF5NAZABkBVrO1A5ZXVuDcyAaJGQkrmRau2/dTi3RA1En49lGePXSUiIqJaDIAMgKrY0oGmrT8MUSPhnXWHml23psaAe97bBFEj4cT5EnvsKhEREdViAGQAVMWWDrQ36xJEjYQ+sxJQXlnd5Lo5l4z1A7vPiOd8v0RERHbGAOjgABgZGQlBEEyWoKAg5X2DwYDIyEh06tQJrVq1Qnh4ONLTm5/jdvHixQgJCYGfnx/69euHnTt3mryv1+sRERGBDh06wN/fH48//jhyc3NN1snJycGoUaPg7++PDh064I033kBFhW0DLGzpQDU1Bvzlw60QNRKkw+eaXDchPR+iRsKjn+9scj0iIiKyHQOgEwJg7969kZ+frywFBQXK+1FRUWjbti3Wr18PnU6HMWPGoFOnTigpsXzbc82aNfDx8UF0dDQyMjIwZcoUtGnTBjk5Oco6kyZNQpcuXZCYmAitVotBgwYhNDQU1dXGK2/V1dXo06cPBg0aBK1Wi8TERHTu3BkRERE2fT9bO9BHm45C1Eh46YcDTa73WeIJiBoJb69t/nYxERER2YYB0AkBMDQ01Ox7BoMBwcHBiIqKUl7T6/UICAjAV199ZXGbYWFhmDRpkslrPXv2xLRp0wAARUVF8PHxwZo1a5T38/Ly4OXlhYSEBABAfHw8vLy8kJdXN8AiJiYGfn5+NnUGWzvQ8fMlEDUS7py+sclyLpNWHoSokRC9M8vqfSEiIiLrMAA6IQD6+/ujU6dOCAkJwZgxY5CVZQw1WVlZEAQBWq3W5HeeeOIJjB8/3uz2Kioq4O3tjbi4OJPXJ0+ejIEDBwIAtm7dCkEQUFhoWjKlb9++mDVrFgDgvffeQ9++fU3eLywshCAI2LZtm9Xf73o60MjPdjZb0PmvnyRD1EjYdcK6EcNERERkPQZABwfA+Ph4xMbGIi0tDYmJiQgPD0dQUBAuXbqElJQUCIJgchUOACZMmIDhw4eb3V5eXh4EQUBKiul0aPPmzcPdd98NAFi1ahV8fX0b/e6wYcMwceJE5TOGDRvWaB1fX1+sXr3a4vfR6/UoLi5WltzcXJs70Dc7mp7S7VpFFUJq5/y9eFVv9XaJiIjIOgyATh4FXFpaiqCgICxcuFAJgOfOmQ6IePnllzFixAizvy8HwNTUVJPXP/jgA/To0QOA5QA4dOhQvPLKKwAsh0wfHx/ExMRY3H9zg1ps7UDni8uVgJdz6Vqj938/cwWiRsKf5iZavU0iIiKyHgOgC8rADB06FJMmTWqRt4DtcQUQAJ6P3gtRI+HzpBON3ovZlwNRI2Hct3tt2iYRERFZhwHQyQFQr9ejS5cumD17tjII5KOPPlLer6iosGoQyKuvvmryWq9evRoNAlm7dq3y/rlz58wOAql/9XHNmjUOHwQiW3cwF6JGwqAFyTAYTKeGi/w1HaJGwgfSEZu2SURERNZhAHRwAJw6dSq2b9+O7Oxs7N27F6NGjULbtm1x+rRxAERUVBQCAgIQFxcHnU6HsWPHNioDM3jwYCxatEj5WS4Ds2zZMmRkZODNN99EmzZtlG0CxjIwXbt2RVJSErRaLQYPHmy2DMyQIUOg1WqRlJSErl27OrwMjKykvBI9ZsZD1Eg4nHvF5L1nv0qFqJEQezDXwm8TERGRGgyADg6Acl0/Hx8fdO7cGaNHj8aRI3VXtuRC0MHBwfDz88PAgQOh0+lMtiGKIiIjI01eW7x4MURRhK+vL/r164cdO3aYvF9eXo6IiAi0b98erVu3xqhRo3DmzBmTdXJycvDYY4+hdevWaN++PSIiIqDX2zboQk0HilithaiR8P6GusLXBoMBobM3Q9RISM8rsnmbRERE1DwGQE4Fp4qaDrT16PnawR5blOne8ovKIWok3DF9I/RVTU8XR0RERNeHAZABUBU1Haiyugb3z9kCUSMh+dgFAMC2YxcgaiQM+3S7vXeViIiIajEAMgCqorYDzfpFB1EjYeKKAzh+vgTzNmZA1Eh4Y7W2+V8mIiKi68IAyACoitoOpM0phKiRGi2Lk0/aeU+JiIhIxgDIAKiK2g5kMBjw+qrfcP+cLcoyaEEysi+W2nlPiYiISMYAyACoCjsQERFRy8PjNwOgKuxARERELQ+P3wyAqrADERERtTw8fjMAqsIORERE1PLw+M0AqAo7EBERUcvD4zcDoCrsQERERC0Pj98MgKqwAxEREbU8PH4zAKrCDkRERNTy8PjNAKgKOxAREVHLw+M3A6Aq7EBEREQtD4/fDICqsAMRERG1PDx+MwCqwg5ERETU8vD4zQCoCjsQERFRy8PjNwOgKuxARERELQ+P3wyAqrADERERtTw8fjMAqsIORERE1PLw+M0AqAo7EBERUcvD4zcDoCrsQERERC0Pj98MgKqwAxEREbU8PH4zAKrCDkRERNTy8PjNAKgKOxAREVHLw+M3A6Aq7EBEREQtD4/fDICqsAMRERG1PDx+MwCqwg5ERETU8vD4zQCoCjsQERFRy8PjNwOgKuxARERELQ+P3wyAqrADERERtTw8fjMAqsIORERE1PLw+M0AqAo7EBERUcvD4zcDoCrsQERERC0Pj98MgKqwAxEREbU8PH47MQDOnz8fgiBgypQpymuZmZn429/+ho4dO6Jt27Z45plncP78+Sa3U1JSgilTpqBbt25o1aoVHnroIezfv99knfPnz+OFF15Ap06d0Lp1a4wYMQInTpwwWSc8PByCIJgsY8aMsek7sQMRERG1PDx+OykA7t+/HyEhIejbt68SAEtLS3HHHXfgqaeeQlpaGtLS0vDkk0/iwQcfRE1NjcVtPfvss7jnnnuwY8cOnDx5EpGRkWjXrh3Onj0LADAYDOjfvz8GDBiA/fv349ixY5g4cSK6deuG0tJSZTvh4eGYMGEC8vPzlaWoqMim78UORERE1PLw+O2EAHj16lV0794diYmJCA8PVwLg5s2b4eXlZdL4hYWFEAQBiYmJZrdVVlYGb29vSJJk8npoaCjeffddAMDx48chCALS09OV96urq9G+fXtER0crr9Xfl+vFDkRERNTy8PjthAA4fvx4vPnmmwBMQ9eGDRvg7e0NvV6vrFtWVgYvLy9ERkaa3VZJSQkEQUBSUpLJ6/3790d4eDgAIC0tDYIgIDMz02Sd4OBgvPDCC8rP4eHh6NixIzp06IB77rkHU6dORUlJiU3fjR2IiIio5eHx28EBMCYmBn369EF5eTkA0wBYUFCAdu3aYcqUKbh27RpKS0vx+uuvQxAETJw40eI2H3roIYSHhyMvLw/V1dVYuXIlbrrpJtx9990AgMrKSoiiiGeeeQaFhYWoqKjAhx9+CEEQMHz4cGU733zzDRITE6HT6RATE4OQkBAMHTq0ye+j1+tRXFysLGfOnIEgCMjNzTV5nQsXLly4cOHivktubi4EQbD50a8bicMC4JkzZxAYGIhDhw4przW87bp582bccccduOmmm+Dt7Y1x48ahX79+ePXVVy1uNzMzEwMHDoQgCPD29saDDz6I559/Hr169VLWOXjwIEJDQ5V1RowYgZEjR2LkyJEWt3vw4EEIgoDffvvN4jqRkZGNBo5w4cKFCxcuXFrmkpuba22sueE4LAD+/PPPEARjAJMXQRCUsFddXa2se/HiRVy5cgUAEBQUhI8//rjZ7ZeWluLcuXMAjANDHn300UbrFBUVoaCgAAAQFhaG1157zeL2DAYDfHx8sGbNGovrNLwCeOXKFWRlZaGoqMgtzmQ8/Uok24HtwLZgO7At2A7WLEVFRcjNzW1y0OmNzmEBsKSkBDqdzmR54IEHMG7cOOh0OrO/s3XrVtx00004duyY1Z9TWFiIgIAAfP311xbXOXHiBLy8vLB582aL6+h0OgiCgB07dlj92e6iuJjPMgBsBxnboQ7bwojtUIdtYcR2IKcWgm54C/i7777Dnj17kJmZiZUrV6J9+/Z4++23TX5n8ODBWLRokfJzQkICNm3ahOzsbGzZsgWhoaEICwtDZWWlss5PP/2E5ORkZGVl4ZdffoEoihg9erTyfmZmJmbPno0DBw7g1KlT2LhxI3r27In777/f5MpkS8H/yEZsByO2Qx22hRHboQ7bwojtQC4NgBqNBkFBQfDx8UH37t2xcOFCGAwGk98RRdFkVPDatWtxxx13wNfXF8HBwXj99dcbPcT5+eefo2vXrvDx8UG3bt0wc+ZMVFRUKO+fOXMGAwcORPv27eHr64s777wTkydPxuXLlx3zxR2M/5GN2A5GbIc6bAsjtkMdtoUR24E4FdwNQK/XIzIy0qSkjidiOxixHeqwLYzYDnXYFkZsB2IAJCIiIvIwDIBEREREHoYBkIiIiMjDMAASEREReRgGQCIiIiIPwwDoAkuWLMG9996Ltm3bom3btujfvz/i4+OV9/Pz8zFu3DgEBQXB398f999/P9atW9doO5IkISwsDK1atUKHDh3w1FNPmbyfk5ODUaNGwd/fHx06dMAbb7xhUg4HALZv345+/frBz88Pt99+O5YuXeqYL22GM9rh0KFDeO6559C1a1e0atUKPXv2xGeffdZoGzd6O9R36dIldOnSBYIgKDPwyFzZDoBz2+L777/HvffeCz8/PwQFBeH11183eT8tLQ0DBw5Eq1at0LlzZ8yePbtRmSpHcVY77N+/H4MHD0ZAQABuueUWDBs2DL///rvJOq5sB0B9WyQnJ1ucBmz//v02fc/Y2Fj06tULvr6+6NWrF+Li4hzfALWc0Q7Jycl44oknEBwcDH9/f4SGhuLHH39stC+ubAeyHwZAF9iwYQM2btyI48eP4/jx45gxYwZ8fHyQnp4OABg6dCgefPBB7Nu3D1lZWZg7dy68vLyg1WqVbcTGxuLWW2/F0qVLcfz4cRw7dszkP3t1dTX69OmDQYMGQavVIjExEZ07d0ZERISyTnZ2Nvz9/TFlyhRkZGQgOjoaPj4+iI2NvWHaYdmyZXjjjTewfft2ZGVlYeXKlWjdurVJcXFPaIf6nnzySYwcObJRAHR1OwDOa4uFCxeic+fOWLVqFTIzM5Geno4NGzYo7xcXFyMoKAjPPfccdDod1q9fj7Zt22LBggU3TDuUlJTg1ltvxT//+U8cO3YM6enpePrppxEYGKgU1nd1O9ijLSoqKpCfn2+yvPzyywgJCVECnjXfMzU1Fd7e3pg/fz6OHj2K+fPn4+abb8bevXtvmHaYN28eZs6ciZSUFGRmZuLzzz+Hl5eXyf8NV7cD2Q8DoJu49dZb8e233wIA2rRpgxUrVpi83759e+X9qqoqdOnSRfnZnPj4eHh5eSEvL095LSYmBn5+fkrhz//85z/o2bOnye+98sor6N+/v12+0/WwdzuY89prr2HQoEHKz57UDkuWLEF4eDi2bt3aKAC6YzsA9m+LwsJCtG7dGklJSRbXWbJkCQICAkxqpH344Yfo3LmzU69+1Wfvdjhw4AAEQcCZM2eU19LS0iAIAjIzMwG4ZzsAtrVFQ5WVlQgMDMScOXOU16z5ns8++yweeeQRk22NGDECzz33nF2+0/WwdzuY8+ijj+Jf//qX8rM7tgNdHwZAF6uurkZMTAx8fX1x5MgRAMb/TI899hguX76MmpoaxMTEoE2bNsof5X379kEQBHz33Xe47777EBwcjEceeUQ5EwSA9957D3379jX5rMLCQgiCgG3btgEABgwYgMmTJ5usExcXh5tvvtlkaj1ncFQ7mPP888/j6aefVn72lHY4cuQIgoODkZOTo9wOqh8A3akdAMe1xdq1a+Hn54fly5ejZ8+e6NKlC5555hmTIPSPf/wDTzzxhMn+aLVaCIKA7OxsJ3z7Oo5qh5KSEnTs2BGRkZGoqKhAWVkZpkyZgt69e6OqqgqAe7UDcH1t0VBsbCy8vLxs/vf+4x//iE8//dRknU8//RTdunWz51e0iqPawZyHH34YU6dOVX52p3YgdRgAXSQtLQ1t2rSBt7c3AgICsHHjRuW9oqIijBgxAoIg4Oabb0a7du2wZcsW5f2YmBgIgoBu3bohNjYWBw8exNixY9GhQwdlOrsJEyZg2LBhjT7X19cXq1evBgB0794d8+bNM3k/JSUFgiDg3LlzjvjajTi6HRpKTU2Fj4+PyXY8oR30ej369u2LlStXAoDZAOgO7QA4vi0+/PBD+Pj4oEePHkhISMCePXswZMgQ9OjRQ3lGdtiwYZgwYYLJfuXl5UEQBKSmpjqhFZzzfyM9PR133nknvLy84OXlhZ49eyInJ0d53x3aAVDXFg2NHDkSI0eONHnNmu/p4+ODVatWmayzatUq+Pr6qv16VnN0OzS0bt06+Pr6mpw4uEM7kH0wALpIRUUFTp48iQMHDmDatGno2LGjciYXERGBsLAwJCUl4dChQ3j//fcREBCAtLQ0AMb/bIIg4Ouvv1a2p9fr0bFjR3z11VcAjAFw+PDhjT7Xx8cHMTExAIwH/Pnz55u8v3v3bgiCgPz8fId874Yc3Q71paen47bbbsPcuXNNXveEdnjrrbcwZswY5X1LAdDV7QA4vi3mzZsHQRCwefNmZZ2CggJ4eXkhISEBgDEQTJw40WS/zp49C0EQsGfPHod+f5mj26GsrAxhYWEYP3489u/fjz179uDpp/io/ckAAAUNSURBVJ9G7969UVZWBsA92gFQ1xb15ebmwsvLq9FzrdZ8Tx8fH+XkWfbjjz/Cz8/Pnl+1SY5uh/qSk5PRpk0bLF++3OR1d2gHsg8GQDcxZMgQTJw4EZmZmRAEodHtuyFDhuCVV14BAGzbtg2CIGDXrl0m64SFhWHGjBkAWt4tYJm920F25MgRBAYGNnod8Ix2CA0NhZeXF7y9veHt7Q0vLy8IggBvb2/MmjULgHu2A2D/tvjuu+8gCAJyc3NN1gkMDMQ333wDwP1ufQL2b4dvv/0WgYGBqKmpUd6vqKiAv7+/cpLoju0A2NYW9c2ZMwe33XZbo/7c0m4By+zdDrLt27fjD3/4g8kJhMwd24GuDwOgmxg8eDBeeOEF5SHsjIwMk/eHDx+u3KIoLi6Gn5+fycO98gO98n9YeRBI/Vt3a9asaTQIpFevXiafM2nSJJc+9G/vdgCMV/4CAwPxzjvvmP1MT2iHzMxM6HQ6ZZFDUGpqKi5cuADAPdsBsH9bHD9+HIIgmAwCuXz5Mry8vJSrgkuWLMEtt9xiUjYpKirKpYMf7N0OX3zxBYKDg02+T1VVFdq0aaPc4nPHdgBsawuZwWDA7bffbvI8m8ya7/nss882umX6yCOPuHTwg73bAai78vfll1+afd8d24GuDwOgC0yfPh07d+7EqVOnkJaWhhkzZsDLywtbtmxBZWUl7rrrLgwYMAD79u1DZmYmFixYgJtuusnkeY8pU6agS5cu2Lx5M44dO4aXXnoJgYGBKCwsBFBXBmbIkCHQarVISkpC165dzZaBeeutt5CRkYFly5Y5teyHM9pBvu37/PPPm5Q/KCgo8Kh2aMjcLWBXtwPgvLZ48skn0bt3b6SkpECn02HUqFG45557lCsiRUVFCAoKwtixY6HT6RAXF4d27do5rfyJM9rh6NGj8PPzw6uvvoqMjAykp6dj3LhxCAgIUE4cXd0O9moLAEhKSjIbkgDrvmdKSgq8vb0RFRWFo0ePIioqyqnlT5zRDsnJyfD398f06dNN/l7Wf27U1e1A9sMA6AIvvvgiRFGEr68vbrvtNgwZMsTkYd0TJ05g9OjRCAwMhL+/P/r27dtoeH9lZSWmTp2KwMBAtG3bFkOHDm10+T8nJwePPfYYWrdujfbt2yMiIsKkzAFgvNR///33w9fXFyEhIU4t/OuMdoiMjDRb+FQURZPt3Ojt0JC5AAi4th0A57VFcXExXnzxRdxyyy1o3749nnrqqUajIdPS0jBgwAD4+fkhODgY77//vtOuejmrHbZs2YKHH34YAQEBuPXWWzF48OBGz/a5sh0A+7QFAIwdOxZ/+ctfLH6ONd9z3bp16NGjB3x8fNCzZ0+sX7/efl+0Gc5ohxdeeMHs38vw8HCT9VzZDmQ/DIBEREREHoYBkIiIiMjDMAASEREReRgGQCIiIiIPwwBIRERE5GEYAImIiIg8DAMgERERkYdhACQiIiLyMAyARERERB6GAZCIiIjIwzAAEhEREXkYBkAiIiIiD8MASERERORhGACJiIiIPAwDIBEREZGHYQAkIiIi8jAMgEREREQehgGQiIiIyMMwABIRERF5GAZAIiIiIg/DAEhERETkYRgAiYiIiDwMAyARERGRh2EAJCIiIvIwDIBEREREHoYBkIiIiMjDMAASEREReRgGQCIiIiIPwwBIRERE5GEYAImIiIg8DAMgERERkYdhACQiIiLyMP8fHjmcPhqZSdUAAAAASUVORK5CYII=\" width=\"640\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "[<matplotlib.lines.Line2D at 0x79510ce19a90>]" + ] + }, + "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=\"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 = 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()\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": 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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} |