StructureTensor3D_Examples.ipynb

       "    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": [
    "volume = np.transpose(volume, (1, 0, 2))\n",
    "S = st3d.structure_tensor(volume, sigma, rho)\n",
    "val,vec = st3d.eig_special(S)\n",
    "coloring_z = lambda v : st3d.fan_coloring(v[[2, 0, 1]]) # rotating the coloring function\n",
    "st3d.show_vol_orientation(volume, vec, coloring = coloring_z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Investigating tensor-vector distance\n",
    "A tensor-vector distance can be computed for every voxel. Here I compute the distance from the z-direction. In the rotated volume, a 90 deg. bundle (the middle layer) is aligned with z-direction, and has the smallest distance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "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",