PCA_illustration.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support. ' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option);\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width / mpl.ratio, fig.canvas.height / mpl.ratio);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"1000\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.widgets import Slider, Button\n",
    "from ipywidgets import interact\n",
    "%matplotlib notebook\n",
    "\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "import pandas as pd\n",
    "\n",
    "\n",
    "\n",
    "def f(sigma_1, sigma_2, sigma_cross, n_samples=300):\n",
    "    ### f(sigma_1, sigma_2, sigma_cross, n_samples=300)\n",
    "    ### sigma_1 : cov(X1, X1), sigma_2 : cov(X2, X2), sigma_cross=cov(X1, X2)=cov(X2, X1), n_samples: number of samples to draw\n",
    "    #### a bivariate gaussian distribution sampling function\n",
    "\n",
    "    # number of dimensions\n",
    "    d = 2\n",
    "    # covoriance matrix\n",
    "    K = np.array([[sigma_1, sigma_cross], \\\n",
    "                  [sigma_cross, sigma_2]])\n",
    "    # zero mean (=> simpler for the \"game\" to find the projection angle bellow)\n",
    "    mu = np.array([0.0, 0.0])\n",
    "    # sampling from a bivariate (d=2) gaussian distribution\n",
    "    # by applying the lower-triangular matrix L to make x follow the distribution implied by the covariance matrix\n",
    "    L = np.linalg.cholesky(K + 1e-6*np.eye(d))\n",
    "    u = np.random.normal(size=(d, n_samples))\n",
    "    x = np.dot(L, u)\n",
    "    # unused because of zero mean\n",
    "    # x[0, :] = mu[0] + x[0, :]\n",
    "    # x[1, :] = mu[1] + x[1, :]\n",
    "\n",
    "    return x, K\n",
    "\n",
    "\n",
    "\n",
    "# The projection function to plot the projected points on the principal direction\n",
    "def project_method2(data, angle):\n",
    "    a = np.tan(angle  * np.pi / 180) # the line has equation y = a * x\n",
    "    e = np.array([[1, a]]) # vector e is along the principal direction\n",
    "    data_p = (np.dot(data.T, e.T)/np.dot(e, e.T))*e # projection by scalar product amplitude along direction of vector e.\n",
    "    return data_p.T\n",
    "\n",
    "def get_line(t, angle):\n",
    "    a = np.tan(angle  * np.pi / 180)\n",
    "    y = a * t\n",
    "    return y\n",
    "\n",
    "# Define initial parameters\n",
    "init_X1_cov = 25\n",
    "init_X2_cov = 25\n",
    "init_cross_cov = 12\n",
    "init_angle = 0\n",
    "\n",
    "# Create the figure\n",
    "fig, ax = plt.subplots(figsize=(10,10))\n",
    "plt.xlim(-20,20)\n",
    "plt.ylim(-20,20)\n",
    "# create and scatter bivariate gaussian distributed data (also retrieve the covariance matrix)\n",
    "data, K = f(init_X1_cov, init_X2_cov, init_cross_cov)\n",
    "sc = ax.scatter(data[0, :], data[1, :])\n",
    "# display the covariance matrix on the figure\n",
    "t1 = ax.text(12, -12,  str(np.round(K, 1)))\n",
    "# display the projection line\n",
    "t = np.linspace(-30, 30, 1000)\n",
    "line, = ax.plot(t, get_line(t, init_angle), lw=2)\n",
    "# set axis\n",
    "ax.set_xlabel('X1')\n",
    "ax.set_ylabel('X2')\n",
    "ax.axis('equal')\n",
    "# draw\n",
    "plt.draw()\n",
    "\n",
    "axcolor = 'lightgoldenrodyellow'\n",
    "ax.margins(x=0)\n",
    "\n",
    "# adjust the main plot to make room for the sliders\n",
    "plt.subplots_adjust(left=0.20, bottom=0.20)\n",
    "\n",
    "# Make a bottom horizontal slider to control the X1 correlation.\n",
    "ax_X1_cov = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor)\n",
    "X1_cov_slider = Slider(\n",
    "    ax=ax_X1_cov,\n",
    "    label='X1 covariance',\n",
    "    valmin=0.1,\n",
    "    valmax=30,\n",
    "    valinit=init_X1_cov,\n",
    ")\n",
    "\n",
    "# Make a vertically oriented slider to control the X2 correlation\n",
    "ax_X2_cov = plt.axes([0.1, 0.25, 0.0225, 0.63], facecolor=axcolor)\n",
    "X2_cov_slider = Slider(\n",
    "    ax=ax_X2_cov,\n",
    "    label=\"X2 covariance\",\n",
    "    valmin=0.1,\n",
    "    valmax=30,\n",
    "    valinit=init_X2_cov,\n",
    "    orientation=\"vertical\"\n",
    ")\n",
    "\n",
    "# Make a top horizontal slider to control the cross correlation.\n",
    "ax_cross_cov = plt.axes([0.25, 0.95, 0.65, 0.03], facecolor=axcolor)\n",
    "cross_cov_slider = Slider(\n",
    "    ax=ax_cross_cov,\n",
    "    label='cov(X1,X2)',\n",
    "    valmin=-30,\n",
    "    valmax=30,\n",
    "    valinit=init_cross_cov,\n",
    ")\n",
    "\n",
    "\n",
    "# Make a top vertical slider to control the projection angle\n",
    "ax_angle = plt.axes([0.92, 0.25, 0.03, 0.65], facecolor=axcolor)\n",
    "angle_slider = Slider(\n",
    "    ax=ax_angle,\n",
    "    label='angle',\n",
    "    valmin=-89,\n",
    "    valmax=89,\n",
    "    valinit=init_angle,\n",
    "    orientation=\"vertical\"\n",
    ")\n",
    "\n",
    "\n",
    "# The function to be called anytime a slider's value changes\n",
    "def update(val):\n",
    "    global fig, data, K, t1, data2, t, line, init_flag_pca, init_flag_projection, sc_update_projection, sc_update_pca, ax, sc\n",
    "    data, K = f(X1_cov_slider.val, X2_cov_slider.val, cross_cov_slider.val)\n",
    "    data2 = data\n",
    "\n",
    "    sc.set_offsets(data.T)\n",
    "    data_p_2 = project_method2(data, angle_slider.val)\n",
    "    line.set_ydata(get_line(t, angle_slider.val))\n",
    "    t1.set_text(str(np.round(K, 1)))\n",
    "\n",
    "    if init_flag_projection == 0:\n",
    "        sc_update_projection.set_offsets(data_p_2.T)\n",
    "\n",
    "    if init_flag_pca==0:\n",
    "        X=data2.T\n",
    "        pca.fit(X)\n",
    "        X_pca_1d = pca.transform(X)\n",
    "        X_new = pca.inverse_transform(X_pca_1d)\n",
    "        sc_update_pca.set_offsets(X_new)\n",
    "    fig.canvas.draw_idle()\n",
    "\n",
    "\n",
    "\n",
    "# The function to be called anytime a slider's value changes\n",
    "def update_no_new_sampling(val):\n",
    "    global fig, data, K, t1, data2, t, line, init_flag_pca, init_flag_projection, sc_update_projection, sc_update_pca, ax\n",
    "\n",
    "    line.set_ydata(get_line(t, angle_slider.val))\n",
    "    data_p_2 = project_method2(data, angle_slider.val)\n",
    "    if init_flag_projection:\n",
    "        sc_update_projection = ax.scatter(data_p_2[0, :], data_p_2[1, :], alpha=0.9,color='orange')\n",
    "        init_flag_projection=0\n",
    "    else:\n",
    "        sc_update_projection.set_offsets(data_p_2.T)\n",
    "        sc_update_projection.set_visible(True)\n",
    "\n",
    "    fig.canvas.draw_idle()\n",
    "\n",
    "\n",
    "# register the update function with each slider\n",
    "cross_cov_slider.on_changed(update)\n",
    "X2_cov_slider.on_changed(update)\n",
    "X1_cov_slider.on_changed(update)\n",
    "angle_slider.on_changed(update_no_new_sampling)\n",
    "\n",
    "# Create a `matplotlib.widgets.Button` to reset the sliders to initial values.\n",
    "resetax = plt.axes([0.8, 0.025, 0.1, 0.04])\n",
    "button_reset = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975')\n",
    "pca_btn_ax = plt.axes([0.6, 0.025, 0.1, 0.04])\n",
    "button_PCA = Button(pca_btn_ax, 'compute PCA', color=axcolor, hovercolor='0.975')\n",
    "\n",
    "\n",
    "pca = PCA(n_components=1)\n",
    "init_flag_pca = 1\n",
    "init_flag_projection = 1\n",
    "\n",
    "def button_PCA_callback(event):\n",
    "    global data, data2, t, line, init_flag_pca, init_flag_projection, sc_update_projection, sc_update_pca, sc\n",
    "\n",
    "\n",
    "    data2 = data\n",
    "    X=data2.T\n",
    "    pca.fit(X)\n",
    "    X_pca_1d = pca.transform(X)\n",
    "    X_new = pca.inverse_transform(X_pca_1d)\n",
    "\n",
    "    data_p_2 = project_method2(data, angle_slider.val)\n",
    "\n",
    "    if init_flag_pca:\n",
    "        sc_update_pca = ax.scatter(X_new[:, 0], X_new[:, 1], alpha=0.9,color='y')\n",
    "        init_flag_pca = 0\n",
    "    else:\n",
    "        sc_update_pca.set_offsets(X_new)\n",
    "        sc_update_pca.set_visible(True)\n",
    "\n",
    "    if init_flag_projection:\n",
    "        sc_update_projection = ax.scatter(data_p_2[:, 0], data_p_2[:, 1], alpha=0.9,color='orange')\n",
    "        line.set_ydata(get_line(t, angle_slider.val))\n",
    "        init_flag_projection = 0\n",
    "    else:\n",
    "        sc_update_projection.set_offsets(data_p_2.T)\n",
    "        sc_update_projection.set_visible(True)\n",
    "        line.set_ydata(get_line(t, angle_slider.val))\n",
    "    fig.canvas.draw_idle()\n",
    "\n",
    "\n",
    "\n",
    "def button_reset_callback(event):\n",
    "    global fig, data, K, t1, data2, t, line, init_flag_pca, init_flag_projection, sc_update_projection, sc_update_pca, ax\n",
    "    # ax.clear()\n",
    "\n",
    "    X1_cov_slider.reset()\n",
    "    X2_cov_slider.reset()\n",
    "    cross_cov_slider.reset()\n",
    "    angle_slider.reset()\n",
    "\n",
    "    # fill the figure again\n",
    "    # create and scatter bivariate gaussian distributed data (also retrieve the covariance matrix)\n",
    "    data, K = f(X1_cov_slider.val, X2_cov_slider.val, cross_cov_slider.val)\n",
    "    sc.set_offsets(data.T)\n",
    "    sc_update_projection.set_visible(False)\n",
    "    sc_update_pca.set_visible(False)\n",
    "    # display the projection line\n",
    "    line.set_ydata(get_line(t, angle_slider.val))\n",
    "    # display the covariance matrix on the figure\n",
    "    t1.set_text(str(np.round(K, 1)))\n",
    "\n",
    "    ax.axis('equal')\n",
    "    # draw\n",
    "    fig.canvas.draw_idle()\n",
    "\n",
    "\n",
    "button_reset.on_clicked(button_reset_callback)\n",
    "button_PCA.on_clicked(button_PCA_callback)\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "covid",
   "language": "python",
   "name": "covid"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}