localization.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num good sets: 6942\n"
     ]
    }
   ],
   "source": [
    "# our libraries\n",
    "import src.dataread;\n",
    "import src.model as ce240;\n",
    "\n",
    "# external libraries\n",
    "import numpy as np;\n",
    "import pymap3d as pm;\n",
    "from mpl_toolkits import mplot3d\n",
    "%matplotlib notebook\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "DATASET = \"../mammoth_localization\";\n",
    "REF_J   = 0;\n",
    "\n",
    "# read in the data from the csvs\n",
    "sensor_data = src.dataread.get_sensor_list(dataset=DATASET);\n",
    "\n",
    "# TODO move this to dataread.py\n",
    "nodes = ce240.get_nodes(); # hardcoded node positions (ECEF)\n",
    "xn,yn,zn = np.hsplit(nodes,3); # legacy to get the x,y,z vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the time series xls output\n",
    "output_vector_list = ce240.get_series_out(sensor_data, REF_J);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    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 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",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"639.8333333333334\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "    \n",
    "\"\"\"\n",
    "Plots nodes on a 3D coordinate system.\n",
    "Anchor nodes are in black.\n",
    "Mobile node is in green.\n",
    "\"\"\"\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = plt.axes(projection='3d')\n",
    "\n",
    "# XYZ location of quadcopter (node 9)\n",
    "#x = -2455200.7931187\n",
    "#y = -4425468.23573119\n",
    "#z = 3873216.13338933\n",
    "\n",
    "x, y, z = list(zip(*output_vector_list));\n",
    "x = np.asarray(x);\n",
    "y = np.asarray(y);\n",
    "z = np.asarray(z);\n",
    "\n",
    "\n",
    "# color gradient\n",
    "cm = plt.get_cmap(\"RdYlGn\");\n",
    "grad = [cm(float(i)/(len(x))) for i in range(len(x))];\n",
    "\n",
    "# Print locations of nodes. Node 9 is in a different color\n",
    "ax.scatter(xn, yn, zn, c='Black', s=10, depthshade=False);\n",
    "ax.scatter(x, y, z, s=1, c=grad, depthshade=False); # c='Green',\n",
    "\n",
    "ax.set_xlim3d(float(-40),float(40))\n",
    "ax.set_ylim3d(float(-40),float(40))\n",
    "ax.set_zlim3d(float(-40),float(40))\n",
    "\n",
    "\"\"\"\"ax.set_xlabel('X axis')\n",
    "ax.set_ylabel('Y axis')\n",
    "ax.set_zlabel('Z axis')\"\"\"\n",
    "\n",
    "\n",
    "# Placement 0, 0 would be the bottom left, 1, 1 would be the top right.\n",
    "ax.text2D(0.05, 0.95, \"ECEF Coordinates of Anchor and Mobile Nodes\", transform=ax.transAxes)\n",
    "\n",
    "plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min(xn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min(yn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min(zn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}