StructureTensor3D_Examples-checkpoint.ipynb

       "\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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\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",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\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=\"639.999990463257\">"
      ],
      "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": 8,
   "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 / mpl.ratio, fig.canvas.height / mpl.ratio);\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\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\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",