diff options
Diffstat (limited to 'gm_platform/fw/grid_scope.ipynb')
| -rw-r--r-- | gm_platform/fw/grid_scope.ipynb | 3649 |
1 files changed, 3649 insertions, 0 deletions
diff --git a/gm_platform/fw/grid_scope.ipynb b/gm_platform/fw/grid_scope.ipynb new file mode 100644 index 0000000..ea641f0 --- /dev/null +++ b/gm_platform/fw/grid_scope.ipynb @@ -0,0 +1,3649 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import sqlite3\n", + "import struct\n", + "import datetime\n", + "\n", + "import matplotlib\n", + "from matplotlib import pyplot as plt\n", + "from matplotlib import patches\n", + "import numpy as np\n", + "from scipy import signal, optimize\n", + "from tqdm.notebook import tnrange, tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "db = sqlite3.connect('waveform.sqlite3')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Run 000: 2020-01-30 14:24:25 - 2020-01-30 14:24:33 ( 0:00:07.571, 6880sp)\n", + "Run 001: 2020-01-30 14:24:56 - 2020-01-30 14:25:25 ( 0:00:28.305, 8992sp)\n", + "Run 002: 2020-01-30 14:25:33 - 2020-01-30 14:30:37 ( 0:05:04.016, 290112sp)\n", + "Run 003: 2020-01-30 14:31:31 - 2020-01-30 14:37:59 ( 0:06:27.900, 384192sp)\n", + "Run 004: 2020-01-30 14:38:30 - 2020-01-30 14:45:27 ( 0:06:56.604, 417216sp)\n", + "Run 005: 2020-01-30 15:18:50 - 2020-01-30 15:19:01 ( 0:00:10.690, 10240sp)\n", + "Run 006: 2020-01-30 16:37:15 - 2020-01-30 16:37:17 ( 0:00:02.527, 2560sp)\n", + "Run 007: 2020-01-30 16:44:23 - 2020-01-30 16:58:48 ( 0:14:24.293, 665600sp)\n", + "Run 008: 2020-01-30 17:06:35 - 2020-01-30 17:46:16 ( 0:39:41.608, 2163168sp)\n", + "Run 009: 2020-01-30 17:46:20 - 2020-01-30 18:11:16 ( 0:24:55.928, 1492480sp)\n", + "Run 010: 2020-01-30 18:11:39 - 2020-01-30 18:22:29 ( 0:10:50.025, 642560sp)\n", + "Run 011: 2020-01-30 18:22:32 - 2020-01-30 19:33:52 ( 1:11:20.495, 4280320sp)\n", + "Run 012: 2020-01-31 13:16:53 - 2020-01-31 13:18:12 ( 0:01:19.317, 79360sp)\n", + "Run 013: 2020-01-31 13:30:54 - 2020-01-31 13:31:35 ( 0:00:40.762, 40960sp)\n", + "Run 014: 2020-01-31 13:45:37 - 2020-01-31 13:45:42 ( 0:00:05.090, 5120sp)\n", + "Run 015: 2020-01-31 13:53:56 - 2020-01-31 13:54:01 ( 0:00:05.089, 5120sp)\n", + "Run 016: 2020-01-31 13:54:21 - 2020-01-31 13:54:26 ( 0:00:05.088, 5120sp)\n", + "Run 017: 2020-01-31 13:55:41 - 2020-01-31 13:55:46 ( 0:00:05.087, 5120sp)\n", + "Run 018: 2020-01-31 13:56:13 - 2020-01-31 13:56:19 ( 0:00:05.091, 5120sp)\n", + "Run 019: 2020-01-31 13:56:27 - 2020-01-31 13:56:30 ( 0:00:02.527, 2560sp)\n", + "Run 020: 2020-01-31 13:56:40 - 2020-01-31 13:56:48 ( 0:00:07.649, 7680sp)\n", + "Run 021: 2020-01-31 13:57:10 - 2020-01-31 13:58:34 ( 0:01:24.342, 84416sp)\n", + "Run 022: 2020-01-31 14:05:08 - 2020-01-31 14:05:24 ( 0:00:15.242, 15360sp)\n", + "Run 023: 2020-01-31 14:05:33 - 2020-01-31 14:12:50 ( 0:07:17.092, 435200sp)\n", + "Run 024: 2020-01-31 14:13:21 - 2020-01-31 14:15:39 ( 0:02:18.190, 138240sp)\n", + "Run 025: 2020-01-31 14:18:16 - 2020-01-31 18:58:25 ( 4:40:09.251, 16611840sp)\n" + ] + } + ], + "source": [ + "for run_id, start, end, count in db.execute('SELECT run_id, MIN(rx_ts), MAX(rx_ts), COUNT(*) FROM measurements GROUP BY run_id'):\n", + " foo = lambda x: datetime.datetime.fromtimestamp(x/1000)\n", + " start, end = foo(start), foo(end)\n", + " print(f'Run {run_id:03d}: {start:%Y-%m-%d %H:%M:%S} - {end:%Y-%m-%d %H:%M:%S} ({str(end-start)[:-3]:>13}, {count*32:>9d}sp)')\n", + "last_run, n_records = run_id, count\n", + "sampling_rate = 1000.0" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "par = lambda *rs: 1/sum(1/r for r in rs) # resistor parallel calculation\n", + "\n", + "# FIXME: These are for the first prototype only!\n", + "vmeas_source_impedance = 330e3\n", + "vmeas_source_scale = 0.5\n", + "\n", + "vcc = 15.0\n", + "vmeas_div_high = 27e3\n", + "vmeas_div_low = par(4.7e3, 10e3)\n", + "vmeas_div_voltage = vcc * vmeas_div_low / (vmeas_div_high + vmeas_div_low)\n", + "vmeas_div_impedance = par(vmeas_div_high, vmeas_div_low)\n", + "\n", + "#vmeas_overall_factor = vmeas_div_impedance / (vmeas_source_impedance + vmeas_div_impedance)\n", + "v0 = 1.5746\n", + "v100 = 2.004\n", + "vn100 = 1.1452\n", + "\n", + "adc_vcc = 3.3 # V\n", + "adc_fullscale = 4095\n", + "\n", + "adc_val_to_voltage_factor = 1/adc_fullscale * adc_vcc\n", + "\n", + "adc_count_to_vmeas = lambda x: (x*adc_val_to_voltage_factor - v0) / (v100-v0) * 100" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e5ad4355e2a540f9a4c56bccad434a09", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=519120), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "limit = n_records\n", + "record_size = 32\n", + "skip_dropped_sections = False\n", + "\n", + "data = np.zeros(limit*record_size)\n", + "data[:] = np.nan\n", + "\n", + "last_seq = None\n", + "write_index = 0\n", + "for i, (seq, chunk) in tqdm(enumerate(db.execute(\n", + " 'SELECT seq, data FROM measurements WHERE run_id = ? ORDER BY rx_ts LIMIT ? OFFSET ?',\n", + " (last_run, limit, n_records-limit))), total=n_records):\n", + " \n", + " if last_seq is None or seq == (last_seq + 1)%0xffff:\n", + " last_seq = seq\n", + " idx = write_index if skip_dropped_sections else i\n", + " data[idx*record_size:(idx+1)*record_size] = np.frombuffer(chunk, dtype='<H')\n", + " write_index += 1\n", + " \n", + " elif seq > last_seq:\n", + " last_seq = seq\n", + " # nans = np.empty((record_size,))\n", + " # nans[:] = np.nan\n", + " # data = np.append(data, nans) FIXME\n", + " \n", + "data = (data * adc_val_to_voltage_factor - v0) / (v100-v0) * 100" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "227.138252895397" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_not_nan = data[~np.isnan(data)]\n", + "np.sqrt(np.mean(np.square(data_not_nan)))" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "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=\"900\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (top, bottom) = plt.subplots(2, figsize=(9,6), sharex=True)\n", + "fig.tight_layout()\n", + "\n", + "range_start, range_len = -300, 60 # [s]\n", + "\n", + "data_slice = data[ int(range_start * sampling_rate) : int((range_start + range_len) * sampling_rate) ]\n", + "\n", + "top.grid()\n", + "top.plot(np.linspace(0, range_len, int(range_len*sampling_rate)), data_slice, lw=0.5)\n", + "mean = np.mean(data_not_nan)\n", + "rms = np.sqrt(np.mean(np.square(data_not_nan - mean)))\n", + "peak = np.max(np.abs(data_not_nan - mean))\n", + "top.axhline(mean, color='red')\n", + "bbox = {'facecolor': 'black', 'alpha': 0.8, 'pad': 2}\n", + "top.text(0, mean, f'mean: {mean:.3f}', color='white', bbox=bbox)\n", + "top.text(0.98, 0.2, f'V_RMS: {rms:.3f}', transform=top.transAxes, color='white', bbox=bbox, ha='right')\n", + "top.text(0.98, 0.1, f'V_Pk: {peak:.3f}', transform=top.transAxes, color='white', bbox=bbox, ha='right')\n", + "\n", + "bottom.grid()\n", + "bottom.specgram(data_slice, Fs=sampling_rate)\n", + "bottom.yaxis.set_label('F [Hz]')\n", + "bottom.xaxis.set_label('t [s]')\n", + "None" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "fs = sampling_rate # Hz\n", + "ff = 50 # Hz\n", + "\n", + "analysis_periods = 10\n", + "window_len = fs * analysis_periods/ff\n", + "nfft_factor = 4\n", + "sigma = window_len/8 # samples\n", + "\n", + "f, t, Zxx = signal.stft(data,\n", + " fs = fs,\n", + " window=('gaussian', sigma),\n", + " nperseg = window_len,\n", + " nfft = window_len * nfft_factor)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "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=\"900\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(9, 3))\n", + "fig.tight_layout(pad=2, h_pad=0.1)\n", + "\n", + "ax.pcolormesh(t[-200:-100], f[:250], np.abs(Zxx[:250,-200:-100]))\n", + "ax.set_title(f\"Run {last_run}\", 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": 12, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bb14b5b4747148898f1d8f046318bb55", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=166118), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "f_t = t\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 le_t in tnrange(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, le_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[le_t] = mu\n", + " except Exception:\n", + " f_mean[le_t] = np.nan" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "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=\"900\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(9, 5), sharex=True)\n", + "fig.tight_layout(pad=2.2, h_pad=0, w_pad=1)\n", + "\n", + "label = f'Run {last_run}'\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[~np.isnan(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.15, 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", + "for i in np.where(np.isnan(f_mean))[0]:\n", + " ax.axvspan(f_t[i], f_t[i+1], color='lightblue')\n", + "\n", + "ax.set_xlabel('recording time t [s]')\n", + "None" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "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=\"900\">" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f_copy = np.copy(f_mean[1:-1])\n", + "f_copy[np.isnan(f_copy)] = np.mean(f_copy[~np.isnan(f_copy)])\n", + "b, a = signal.cheby2(7, 86, 100, 'low', output='ba', fs=1000)\n", + "filtered = signal.lfilter(b, a, f_copy)\n", + "\n", + "b2, a2 = signal.cheby2(3, 30, 1, 'high', output='ba', fs=1000)\n", + "filtered2 = signal.lfilter(b2, a2, filtered)\n", + "\n", + "fig, (ax2, ax1) = plt.subplots(2, figsize=(9,7))\n", + "ax1.plot(f_t[1:-1], f_copy, color='lightgray')\n", + "ax1.set_ylim([49.90, 50.10])\n", + "ax1.grid()\n", + "formatter = matplotlib.ticker.FuncFormatter(lambda s, x: str(datetime.timedelta(seconds=s)))\n", + "ax1.xaxis.set_major_formatter(formatter)\n", + "zoom_offx = 7000 # s\n", + "zoom_len = 300 # s\n", + "ax1.set_xlim([zoom_offx, zoom_offx + zoom_len])\n", + "\n", + "ax1.plot(f_t[1:-1], filtered, color='orange')\n", + "ax1r = ax1.twinx()\n", + "ax1r.plot(f_t[1:-1], filtered2, color='red')\n", + "ax1r.set_ylim([-0.015, 0.015])\n", + "ax1.set_title(f'Zoomed trace ({datetime.timedelta(seconds=zoom_len)})', pad=-20)\n", + "\n", + "\n", + "ax2.set_title(f'Run {last_run}')\n", + "ax2.plot(f_t[1:-1], f_copy, color='orange')\n", + "\n", + "ax2r = ax2.twinx()\n", + "ax2r.set_ylim([-0.1, 0.1])\n", + "ax2r.plot(f_t[1:-1], filtered2, color='red')\n", + "#ax2.plot(f_t[1:-1], filtered, color='orange', zorder=1)\n", + "ax2.set_ylim([49.90, 50.10])\n", + "ax2.set_xlim([0, f_t[-2]])\n", + "ax2.grid()\n", + "formatter = matplotlib.ticker.FuncFormatter(lambda s, x: str(datetime.timedelta(seconds=s)))\n", + "ax2.xaxis.set_major_formatter(formatter)\n", + "\n", + "ax2.legend(handles=[\n", + " patches.Patch(color='lightgray', label='Raw frequency'),\n", + " patches.Patch(color='orange', label='low-pass filtered'),\n", + " patches.Patch(color='red', label='band-pass filtered')])\n", + "\n", + "ax1.set_ylabel('f [Hz]')\n", + "ax1r.set_ylabel('band-pass Δf [Hz]')\n", + "ax2.set_ylabel('f [Hz]')\n", + "ax2r.set_ylabel('band-pass Δf [Hz]')\n", + "\n", + "# Cut out first 10min of filtered data to give filters time to settle\n", + "rms_slice = filtered2[np.where(f_t[1:] > 10*60)[0][0]:]\n", + "rms = np.sqrt(np.mean(np.square(rms_slice)))\n", + "ax1.text(0.5, 0.1, f'RMS (filtered): {rms*1e3:.3f}mHz', transform=ax1.transAxes, color='white', bbox=bbox, ha='center')\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 +} |