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