diff options
Diffstat (limited to 'Phase measurement Prototype.ipynb')
| -rw-r--r-- | Phase measurement Prototype.ipynb | 1777 |
1 files changed, 1777 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 +} |