How to extract peaks from digitizer traces.ipynb

       "\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=\"600\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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",