BackProjTest.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import Simulation as G\n",
    "import RotRep as R\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from ImageData import SimImage\n",
    "from matplotlib.patches import Polygon, Path, PathPatch\n",
    "from matplotlib.collections import PatchCollection\n",
    "#from matplotlib import path\n",
    "from scipy.optimize import basinhopping\n",
    "import OverlapInfo\n",
    "\n",
    "exp={'energy':71.676}\n",
    "etalimit=81/180.0*np.pi\n",
    "grainpos=np.array([0, 0.0974279, 0])\n",
    "orien=R.EulerZXZ2Mat(np.array([89.5003, 80.7666, 266.397])/180.0*np.pi)\n",
    "\n",
    "reload(G)\n",
    "sample=G.CrystalStr('Ti7')\n",
    "#sample.setPrim([3.61,0,0],[0,3.61,0],[0,0,3.61])\n",
    "#sample.addAtom([0,0,0],29)\n",
    "sample.getRecipVec()\n",
    "sample.getGs(10)\n",
    "\n",
    "\n",
    "Det1=G.Detector()\n",
    "Det1.Move(935.166,1998.96,np.array([4.72573,0,0]),R.EulerZXZ2Mat(np.array([90.6659, 89.4069,359.073])/180.0*np.pi))\n",
    "Det2=G.Detector()\n",
    "Det2.Move(949.46,1996.15,np.array([6.67079,0,0]),R.EulerZXZ2Mat(np.array([89.4765, 90.2675,359.22])/180.0*np.pi))\n",
    "Det3=G.Detector()\n",
    "Det3.Move(966.576,1994.19,np.array([8.63154,0,0]),R.EulerZXZ2Mat(np.array([89.24, 90.545,359.188])/180.0*np.pi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\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",
       "            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",
       "        this.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 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);\n",
       "        canvas.attr('height', height);\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'];\n",
       "    var y0 = fig.canvas.height - msg['y0'];\n",
       "    var x1 = msg['x1'];\n",
       "    var y1 = fig.canvas.height - msg['y1'];\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;\n",
       "    var y = canvas_pos.y;\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 overriden (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",
       "    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 + '\">');\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 dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\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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\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Peaks1,Gs1,PeaksInfo1=G.GetProjectedVertex(Det1,sample,orien,etalimit,grainpos,getPeaksInfo=True,**exp)\n",
    "patches=[]\n",
    "for i in range(len(Peaks1)):\n",
    "    tPeak=Peaks1[i]\n",
    "    tPeakInfo=PeaksInfo1[i]\n",
    "    a1=Det1.BackProj(Det1.Idx2LabCord(tPeak[0],tPeak[1]),tPeak[2]/180.0*np.pi,tPeakInfo['2Theta'],tPeakInfo['eta'])\n",
    "    a2=Det1.BackProj(Det1.Idx2LabCord(tPeak[0]+1,tPeak[1]),tPeak[2]/180.0*np.pi,tPeakInfo['2Theta'],tPeakInfo['eta'])\n",
    "    a3=Det1.BackProj(Det1.Idx2LabCord(tPeak[0]+1,tPeak[1]+1),tPeak[2]/180.0*np.pi,tPeakInfo['2Theta'],tPeakInfo['eta'])\n",
    "    a4=Det1.BackProj(Det1.Idx2LabCord(tPeak[0],tPeak[1]+1),tPeak[2]/180.0*np.pi,tPeakInfo['2Theta'],tPeakInfo['eta'])\n",
    "    a=np.stack((a1,a2,a3,a4))\n",
    "    patches.append(Path([a1,a2,a3,a4]))\n",
    "\n",
    "\n",
    "fig,ax=plt.subplots()\n",
    "\n",
    "for patch in patches: \n",
    "    ax.add_patch(PathPatch(patch,alpha=0.01))\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tp=(np.random.random((100,2))-0.5)*0.0001+[0,0.0974279]\n",
    "b=[]\n",
    "for i in range(len(patches)):\n",
    "    b.append(patches[i].contains_points(tp))\n",
    "b=np.asarray(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\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",
       "            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",
       "        this.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 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);\n",
       "        canvas.attr('height', height);\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'];\n",
       "    var y0 = fig.canvas.height - msg['y0'];\n",
       "    var x1 = msg['x1'];\n",
       "    var y1 = fig.canvas.height - msg['y1'];\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;\n",
       "    var y = canvas_pos.y;\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 overriden (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",
       "    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 + '\">');\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 dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\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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\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(tp[:,0],tp[:,1],c=b.sum(axis=0))\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "reload(G)\n",
    "SimData1=SimImage(720,1)\n",
    "\n",
    "sw=0.001\n",
    "d1=np.array([sw,0,0])\n",
    "d2=np.array([sw,sw,0])\n",
    "d3=np.array([0,sw,0])\n",
    "\n",
    "de=np.array([0.01,0.01,0])/180.0*np.pi\n",
    "\n",
    "gridX,gridY=np.meshgrid(np.arange(-50,50),np.arange(-50,50))\n",
    "for i in range(gridX.shape[0]):\n",
    "    for j in range(gridX.shape[1]):\n",
    "        d=grainpos+gridX[i,j]*d1+gridY[i,j]*d3\n",
    "        dm=R.EulerZXZ2Mat(de*[i,j,0]).dot(orien)\n",
    "        tP0,tG0=G.GetProjectedVertex(Det1,sample,dm,etalimit,d,getPeaksInfo=False,bIdx=False,**exp)\n",
    "        tP1,tG1=G.GetProjectedVertex(Det1,sample,dm,etalimit,d+d1,getPeaksInfo=False,bIdx=False,**exp)\n",
    "        tP2,tG2=G.GetProjectedVertex(Det1,sample,dm,etalimit,d+d2,getPeaksInfo=False,bIdx=False,**exp)\n",
    "        tP3,tG3=G.GetProjectedVertex(Det1,sample,dm,etalimit,d+d3,getPeaksInfo=False,bIdx=False,**exp)\n",
    "\n",
    "        for ii in range(len(tP0)):\n",
    "            xy=np.stack((tP0[ii],tP1[ii],tP2[ii],tP3[ii]))[:,:2]\n",
    "            omega=int((tP0[ii][2]+90)*4)\n",
    "            SimData1.AddHit(G.digitize(xy),omega,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "SimData1.MakeSet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "pickle.dump(SimData1,open('001SimData.pickle','wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\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",
       "            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",
       "        this.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 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);\n",
       "        canvas.attr('height', height);\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'];\n",
       "    var y0 = fig.canvas.height - msg['y0'];\n",
       "    var x1 = msg['x1'];\n",
       "    var y1 = fig.canvas.height - msg['y1'];\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;\n",
       "    var y = canvas_pos.y;\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 overriden (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",
       "    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 + '\">');\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 dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\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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\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ii=16\n",
    "points=np.array(list(SimData1.images[ii][0]))\n",
    "if len(points)>0:\n",
    "    plt.scatter(2047-points[:,0],2047-points[:,1],c='b')\n",
    "    plt.axis('scaled')\n",
    "    plt.xlim((0,2048))\n",
    "    plt.ylim((0,2048))\n",
    "jj=17\n",
    "points=np.array(list(SimData1.images[jj][0]))\n",
    "if len(points)>0:\n",
    "    plt.scatter(2047-points[:,0],2047-points[:,1],c='r')\n",
    "    plt.axis('scaled')\n",
    "    plt.xlim((0,2048))\n",
    "    plt.ylim((0,2048))\n",
    "kk=18\n",
    "points=np.array(list(SimData1.images[kk][0]))\n",
    "if len(points)>0:\n",
    "    plt.scatter(2047-points[:,0],2047-points[:,1],c='y')\n",
    "    plt.axis('scaled')\n",
    "    plt.xlim((0,2048))\n",
    "    plt.ylim((0,2048))\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\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",
       "            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",
       "        this.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 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);\n",
       "        canvas.attr('height', height);\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'];\n",
       "    var y0 = fig.canvas.height - msg['y0'];\n",
       "    var x1 = msg['x1'];\n",
       "    var y1 = fig.canvas.height - msg['y1'];\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;\n",
       "    var y = canvas_pos.y;\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 overriden (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",
       "    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 + '\">');\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 dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\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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\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "ii=27\n",
    "tPeaks=Peaks1\n",
    "b=np.array(list(SimData1.images[int((tPeaks[ii][2]+90)*4)][0]))\n",
    "plt.scatter(2047-b[:,0],2047-b[:,1],c='b')\n",
    "\n",
    "\n",
    "plt.scatter(2047-tPeaks[ii][0],2047-tPeaks[ii][1],c='r')\n",
    "\n",
    "plt.axis('scaled')\n",
    "plt.xlim((0,2048))\n",
    "plt.ylim((0,2048))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def CostWrapper(r):\n",
    "#    strain=np.eye(3)+np.array([[r[0],r[1],r[2]],[r[1],r[3],r[4]],[r[2],r[4],r[5]]])\n",
    "#    strain=np.eye(3)+np.array([[r[0],r[1],r[2]],[r[6],r[3],r[4]],[r[7],r[8],r[5]]])\n",
    "#    oriandstrain=np.eye(3)+np.array([[r[0],r[1],0],[r[1],r[2],0],[0,0,r[3]]])\n",
    "    oriandstrain=R.EulerZXZ2Mat(r)\n",
    "    trans=oriandstrain.dot(orien)\n",
    "#    trans=strain.dot(orien)\n",
    "    Peaks1,Gs1=G.GetProjectedVertex(Det1,sample,trans,etalimit,grainpos,**exp)\n",
    "    newScore1=OverlapInfo.NaiveCostFn(SimData1,Peaks1,0)\n",
    "    Score=newScore1\n",
    "    return -Score   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.8241206030150754"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CostWrapper(de*10+[-0.001,0,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tp=(np.random.random((1000,3))-0.5)*[0.004,0.0004,0.004]\n",
    "b=[]\n",
    "for i in range(len(tp)):\n",
    "    if CostWrapper(de*10+tp[i])<-198/199.0:\n",
    "        b.append(i)\n",
    "tp=tp[b]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.0067816]]\n",
      "[[ 0.01129799]]\n",
      "[[ 0.01360828]]\n",
      "[[ 0.01326859]]\n",
      "[[ 0.00830027]]\n",
      "[[ 0.0027901]]\n",
      "[[ 0.01315352]]\n",
      "[[ 0.0094102]]\n",
      "[[ 0.00734426]]\n",
      "[[ 0.01062994]]\n",
      "[[ 0.0113584]]\n",
      "[[ 0.01361957]]\n",
      "[[ 0.00717605]]\n",
      "[[ 0.00490413]]\n",
      "[[ 0.01346191]]\n",
      "[[ 0.01217032]]\n",
      "[[ 0.01151177]]\n",
      "[[ 0.00942226]]\n",
      "[[ 0.00954544]]\n",
      "[[ 0.00908635]]\n",
      "[[ 0.00806331]]\n",
      "[[ 0.00950863]]\n",
      "[[ 0.00481103]]\n",
      "[[ 0.01133949]]\n",
      "[[ 0.01262922]]\n",
      "[[ 0.00997905]]\n",
      "[[ 0.01275469]]\n",
      "[[ 0.00720357]]\n",
      "[[ 0.0017733]]\n",
      "[[ 0.00944683]]\n",
      "[[ 0.0074015]]\n",
      "[[ 0.0111645]]\n",
      "[[ 0.00961769]]\n",
      "[[ 0.00693194]]\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(tp)):\n",
    "    print R.Misorien2FZ1(R.EulerZXZ2Mat(de*10),R.EulerZXZ2Mat(de*10+tp[i]))[1]/np.pi*180"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.057295779513082325"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.001/np.pi*180"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\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",
       "            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",
       "        this.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 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);\n",
       "        canvas.attr('height', height);\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'];\n",
       "    var y0 = fig.canvas.height - msg['y0'];\n",
       "    var x1 = msg['x1'];\n",
       "    var y1 = fig.canvas.height - msg['y1'];\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;\n",
       "    var y = canvas_pos.y;\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 overriden (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",
       "    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 + '\">');\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 dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\">';\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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\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "ax.scatter(tp[:,0],tp[:,1],tp[:,2])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2.,  0.,  0.],\n",
       "       [ 0.,  2.,  0.],\n",
       "       [ 0.,  0.,  2.]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oriandstrain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "a=np.zeros((2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([ 0.,  0.,  0.]), array([ 0.,  0.,  0.])]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}