diff options
| -rw-r--r-- | Phase Measurement Prototype.ipynb | 1803 | ||||
| -rw-r--r-- | Phase measurement Prototype.ipynb | 1777 | ||||
| -rw-r--r-- | rocof_test_data.py | 180 |
3 files changed, 1983 insertions, 1777 deletions
diff --git a/Phase Measurement Prototype.ipynb b/Phase Measurement Prototype.ipynb new file mode 100644 index 0000000..df68f94 --- /dev/null +++ b/Phase Measurement Prototype.ipynb @@ -0,0 +1,1803 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 224, + "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": 225, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 255, + "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": 256, + "metadata": {}, + "outputs": [], + "source": [ + "analysis_periods = 10\n", + "window_len = fs * analysis_periods/ff\n", + "nfft_factor = 1\n", + "sigma = window_len/8 # samples\n", + "\n", + "ffts = []\n", + "for item in test_data:\n", + " f, t, Zxx = signal.stft(item,\n", + " fs = fs,\n", + " window=('gaussian', sigma),\n", + " nperseg = window_len,\n", + " nfft = window_len * nfft_factor)\n", + " #boundary = 'zeros')\n", + " ffts.append((f, t, Zxx))" + ] + }, + { + "cell_type": "code", + "execution_count": 257, + "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([30, 75]) # Hz\n", + "ax.set_xlabel('simulation time t [s]')\n", + "None" + ] + }, + { + "cell_type": "code", + "execution_count": 259, + "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", + " f_min, f_max = 30, 70 # Hz\n", + " bounds_f = slice(np.argmax(f > f_min), np.argmin(f < f_max))\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_step = frame_f[1] - frame_f[0]\n", + " time_step = f_t[1] - f_t[0]\n", + " #if t == 10:\n", + " # axs[-1].plot(frame_f, frame_Z)\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", + " def gauss(x, *p):\n", + " A, mu, sigma = p\n", + " return A*np.exp(-(x-mu)**2/(2.*sigma**2))\n", + " \n", + " f_start = frame_f[np.argmax(frame_Z)]\n", + " A_start = np.max(frame_Z)\n", + " p0 = [A_start, f_start, 1.]\n", + " try:\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, *_ = coeff\n", + " f_mean[t] = mu\n", + " except RuntimeError:\n", + " f_mean[t] = np.nan\n", + " ax.plot(f_t[1:-1], f_mean[1:-1])\n", + " \n", + "# b, a = signal.butter(3,\n", + "# 1/5, # Hz\n", + "# btype='lowpass',\n", + "# fs=1/time_step)\n", + "# filtered = signal.lfilter(b, a, f_mean[1:-1], axis=0)\n", + "# ax.plot(f_t[1:-1], filtered)\n", + " \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", + " var = np.var(f_mean[1:-1])\n", + " ax.text(0.5, 0.1, f'σ²={var * 1e3:.3g} mHz²', transform=ax.transAxes, ha='center')\n", + " ax.text(0.5, 0.25, f'σ={np.sqrt(var) * 1e3:.3g} mHz', transform=ax.transAxes, ha='center')\n", + "# ax.text(0.5, 0.2, f'filt. σ²={np.var(filtered) * 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/Phase measurement Prototype.ipynb b/Phase measurement Prototype.ipynb deleted file mode 100644 index 498f274..0000000 --- a/Phase measurement Prototype.ipynb +++ /dev/null @@ -1,1777 +0,0 @@ -{ - "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.py b/rocof_test_data.py new file mode 100644 index 0000000..91bee95 --- /dev/null +++ b/rocof_test_data.py @@ -0,0 +1,180 @@ +#!/usr/bin/env python +# coding: utf-8 + +# # ROCOF test waveform library +# +# This is a re-implementation of the ROCOF test waveforms described in https://zenodo.org/record/3559798 +# +# **This file is exported as a python module and loaded from other notebooks here, so please make sure to re-export when changing it.** + +# In[ ]: + + +import math +import itertools + +import numpy as np +from scipy import signal +from matplotlib import pyplot as plt + + +# In[ ]: + + +get_ipython().run_line_magic('matplotlib', 'notebook') + + +# In[ ]: + + +def sample_waveform(generator, duration:"s"=10, sampling_rate:"sp/s"=10000, frequency:"Hz"=50): + samples = int(duration*sampling_rate) + phases = np.linspace(0, 2*np.pi, 6, endpoint=False) + omega_t = np.linspace(phases, phases + 2*np.pi*duration*frequency, samples) + fundamental = np.sin(omega_t) + return generator(omega_t, fundamental, sampling_rate=sampling_rate, duration=duration, frequency=frequency).swapaxes(0, 1) + + +# In[ ]: + + +def gen_harmonics(amplitudes, phases=[]): + return lambda omega_t, fundamental, **_: fundamental + np.sum([ + a*np.sin((p if p else 0) + i*omega_t) + for i, (a, p) in enumerate(itertools.zip_longest(amplitudes, phases), start=2) + ], axis=0) + +def test_harmonics(): + 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]) + + +# In[ ]: + + +def gen_interharmonic(amplitudes, ih=[], ih_phase=[]): + def gen(omega_t, fundamental, **_): + return fundamental + np.sum([ + a*np.sin(omega_t * ih + (p if p else 0)) + for a, ih, p in itertools.zip_longest(amplitudes, ih, ih_phase) + ], axis=0) + return gen + +def test_interharmonics(): + return gen_interharmonic([0.1], [15.01401], [np.pi]) + + +# In[ ]: + + +def gen_noise(amplitude=0.2, fmax:'Hz'=4.9e3, fmin:'Hz'=100, filter_order=6): + def gen(omega_t, fundamental, sampling_rate, **_): + noise = np.random.normal(0, amplitude, fundamental.shape) + b, a = signal.butter(filter_order, + [fmin, min(fmax, sampling_rate//2-1)], + btype='bandpass', + fs=sampling_rate) + return fundamental + signal.lfilter(b, a, noise, axis=0) + return gen + +def test_noise(): + return gen_noise() + +def test_noise_loud(): + return gen_noise(amplitude=0.5, fmin=10) + + +# In[406]: + + +def gen_steps(size_amplitude=0.1, size_phase=0.1*np.pi, steps_per_sec=1): + def gen(omega_t, fundamental, duration, **_): + n = int(steps_per_sec * duration) + indices = np.random.randint(0, len(omega_t), n) + amplitudes = np.random.normal(1, size_amplitude, (n, 6)) + phases = np.random.normal(0, size_phase, (n, 6)) + amplitude = np.ones(omega_t.shape) + for start, end, a, p in zip(indices, indices[1:], amplitudes, phases): + omega_t[start:end] += p + amplitude[start:end] = a + return amplitude*np.sin(omega_t) + return gen + +def test_amplitude_steps(): + return gen_steps(size_amplitude=0.4, size_phase=0) + +def test_phase_steps(): + return gen_steps(size_amplitude=0, size_phase=0.1) + +def test_amplitude_and_phase_steps(): + return gen_steps(size_amplitude=0.2, size_phase=0.07) + + +# In[418]: + + +def step_gen(shape, stdev, duration, steps_per_sec=1.0, mean=0.0): + samples, channels = shape + n = int(steps_per_sec * duration) + indices = np.random.randint(0, samples, n) + phases = np.random.normal(mean, stdev, (n, 6)) + amplitude = np.ones((samples, channels)) + out = np.zeros(shape) + for start, end, a in zip(indices, indices[1:], amplitude): + out[start:end] = a + return out + +def gen_chirp(fmin, fmax, period, dwell_time=1.0, amplitude=None, phase_steps=None): + def gen(omega_t, fundamental, sampling_rate, duration, **_): + samples = int(duration*sampling_rate) + phases = np.linspace(0, 2*np.pi, 6, endpoint=False) + + c = (fmax-fmin)/period + t = np.linspace(0, duration, samples) + + x = np.repeat(np.reshape(2*np.pi*fmin*t, (-1,1)), 6, axis=1) + data = (phases + x)[:int(sampling_rate*dwell_time)] + current_phase = 2*np.pi*fmin*dwell_time + direction = 'up' + + for idx in range(int(dwell_time*sampling_rate), samples, int(2*period*sampling_rate)): + t1 = np.linspace(0, period, int(period*sampling_rate)) + t2 = np.linspace(0, period, int(period*sampling_rate)) + chirp_phase = np.hstack(( + 2*np.pi*(c/2 * t1**2 + fmin * t1), + 2*np.pi*(-c/2 * t2**2 + fmax * t2 - (c/2 * period**2 + fmin * period)) + )) + chirp_phase = np.repeat(np.reshape(chirp_phase, (-1, 1)), 6, axis=1) + new = phases + chirp_phase + current_phase + current_phase = chirp_phase[-1] + data = np.vstack((data, new)) + + data = data[:len(fundamental)] + + if phase_steps: + (step_amplitude, steps_per_sec) = phase_steps + steps = step_gen(data.shape, step_amplitude, duration, steps_per_sec) + data += steps + + if amplitude is None: + return np.sin(data) + else: + return fundamental + amplitude*np.sin(data) + return gen + +def test_close_interharmonics_and_flicker(): + return gen_chirp(90.0, 150.0, 10, 1, amplitude=0.1) + +def test_off_frequency(): +# return gen_chirp(48.0, 52.0, 0.25, 1) + return gen_chirp(48.0, 52.0, 10, 1) + +def test_sweep_phase_steps(): + return gen_chirp(48.0, 52.0, 10, 1, phase_steps=(0.1, 1)) +# return gen_chirp(48.0, 52.0, 0.25, 1, phase_steps=(0.1, 1)) + + +# In[ ]: + + +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] + |