StructureTensor3D_Examples.ipynb

       "\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": [
    "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",