StructureTensor3D_Examples.ipynb

       "\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": [
    "u = np.array([0,0,1])\n",
    "dist = st3d.tensor_vector_distance(S,u)\n",
    "st3d.show_vol(dist.reshape(volume.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## K-means like clustering of structure tensor using tensor-vector distance\n",
    "Tensor-vector distance allows clustering tensors using an approach similar to k-means. Here, every cluster is characterized by an orientation vector, and consists of the tensors which have a small distance to this orientation. The advantage of the approach is that it operates on tensors, and does not require their eigendecomposition. Only computation of cluster orientation requires eigendecomposition. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter 0: moved cluster centers for for 3.4611420322311117\n",
      "Iter 0: moved 39247 voxels\n",
      "Iter 1: moved cluster centers for for 0.004271292625400079\n",
      "Iter 1: moved 1943 voxels\n",
      "Iter 2: moved cluster centers for for 0.0002994716482208428\n",
      "Iter 2: moved 147 voxels\n",
      "Iter 3: moved cluster centers for for 2.5064554745549023e-05\n",
      "Iter 3: moved 12 voxels\n",
      "Iter 4: moved cluster centers for for 2.299743582546306e-06\n",
      "Iter 4: moved 0 voxels\n",
      "Iter 5: moved cluster centers for for 0.0\n",
      "Iter 5: moved 0 voxels\n",
      "Iter 6: moved cluster centers for for 0.0\n",
      "Iter 6: moved 0 voxels\n",
      "Iter 7: moved cluster centers for for 0.0\n",
      "Iter 7: moved 0 voxels\n",
      "Iter 8: moved cluster centers for for 0.0\n",
      "Iter 8: moved 0 voxels\n",
      "Iter 9: moved cluster centers for for 0.0\n",
      "Iter 9: moved 0 voxels\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support. ' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option);\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",