amg8833_playground.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importiere `pyboard` und andere Module. Wichtig ist, dass sich die Datei [`pyboard.py`](https://github.com/micropython/micropython/blob/master/tools/pyboard.py) im selben Verzeichnis wie dieses Notebook befinden. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyboard\n",
    "import time\n",
    "import json\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.patches import Circle\n",
    "from matplotlib.animation import FuncAnimation\n",
    "\n",
    "pb = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Öffne eine serielle Verbindung zum Microcontroller-Board. Wenn hier das Board nicht gefunden wird, kann man folgendes probieren:\n",
    "- USB-Kabel ab- und wieder anstecken  \n",
    "- Überprüfen, ob die richtige Schnittstelle angegeben ist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "if pb is None:\n",
    "    try:\n",
    "        pb = pyboard.Pyboard(\"COM3\")\n",
    "    except pyboard.PyboardError as e:\n",
    "        print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Öffne Zugang zum REPL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "pb.enter_raw_repl()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definiere eine einfache Funktion, um ein Skript auf dem Board auszuführen. Die Funktion geht davon aus, dass das Board über `pb` anzusprechen ist."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_on_board(code, wait_s=0, no_print=False):\n",
    "    for ln in code:\n",
    "        res = pb.exec(ln)\n",
    "        if len(res) > 0 and not no_print:\n",
    "            res = res[:-2].decode()\n",
    "            print(res)\n",
    "    if wait_s > 0:\n",
    "        time.sleep(wait_s)        \n",
    "    return res    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rufe das Skript auf, dass den Wärmebildsensor AMG8833 auf dem I2C-Bus detektiert und initialisiert. Der Sensor braucht etwas Zeit, daher die kurze Wartezeit nach der Initialisierung."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning: I2C(-1, ...) is deprecated, use SoftI2C(...) instead\r\n",
      "Software I2C bus frequency is 400.0 kHz\r\n",
      "Scanning I2C bus ...\r\n",
      "... 2 device(s) found ([96, 105])\n",
      "[     amg88xx] GRID-Eye IR 8x8 thermal camera      (0.1.0.0): ok\n"
     ]
    }
   ],
   "source": [
    "script = [\n",
    "    'from amg88xx import AMG88XX',\n",
    "    'import helper.busio as busio',\n",
    "    'import helper.dio as dio',\n",
    "    'power5V = dio.DigitalOut(16, value=True)',\n",
    "    'i2c = busio.I2CBus(400000, 22, 23)',\n",
    "    'amg = AMG88XX(i2c)',\n",
    "]\n",
    "_ = run_on_board(script, wait_s=0.4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definiert die Hilfsfunktion `get_image()`, die ein neues Bild zurückliefert.\n",
    "\n",
    "Die Funktion ruft erst das Skript auf, dass Daten vom Wärmebildsensor liest. Die Daten werden als 1D-Vektor mit 64 Temperaturwerten (in °Celsius) geliefert. Da die `pyboard`-Funktion einen String zurückgibt, wird dieser mittels einer `json`-Funktion in eine Liste umgewandelt. Anschließend wird der Vektor in ein 8x8 Pixel-Bild umgeformt, dann rotiert und geflippt, damit es richig herum angezeigt wird."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[21 23 25 22 20 20 20 20]\n",
      " [21 26 28 25 21 20 20 19]\n",
      " [22 27 28 26 20 20 20 20]\n",
      " [22 25 29 27 22 21 20 20]\n",
      " [22 25 27 27 26 25 21 20]\n",
      " [23 25 26 26 25 26 23 20]\n",
      " [24 25 26 26 26 25 23 21]\n",
      " [25 26 26 26 26 25 23 21]]\n"
     ]
    }
   ],
   "source": [
    "def get_image():\n",
    "    script = [\n",
    "        'img_raw = list(amg.pixels_64x1)',\n",
    "        'print(img_raw)'\n",
    "    ]\n",
    "    raw = json.loads(run_on_board(script, no_print=True))\n",
    "    return np.flip(np.transpose(np.reshape(raw, (8, 8))))\n",
    "\n",
    "img = get_image()\n",
    "print(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das aktuelle Wärmebild im Original (links) und geglättet (rechts):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x2029193db88>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Erstelle eine Abbildung mit zwei Unterfenstern\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(9,3))\n",
    "\n",
    "# Stelle das Wärmebild in den jeweiligen Unterfenstern dar\n",
    "im1 = ax1.imshow(img, cmap='inferno', vmin=18, vmax=32)\n",
    "im2 = ax2.imshow(img, cmap='inferno', vmin=18, vmax=32, interpolation=\"bilinear\")\n",
    "\n",
    "# Füge eine Farbskala hinzu\n",
    "plt.colorbar(im1, format=\"%.0f°C\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Das folgende Skript liest den Sensor `nrepeats` Mal aus, skaliert die Werte auf den Bereich von `tmin` bis `tmax` °Celsius und zeigt es kontinuierlich an (wenn `smooth == True`, dann wird das Bild geglättet. Zum Anhalten der Animation auf den blauen Knopf drücken."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "/* global mpl */\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(\n",
       "            '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",
       "\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 = document.createElement('div');\n",
       "    this.root.setAttribute('style', 'display: inline-block');\n",
       "    this._root_extra_style(this.root);\n",
       "\n",
       "    parent_element.appendChild(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 = document.createElement('div');\n",
       "    titlebar.classList =\n",
       "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
       "    var titletext = document.createElement('div');\n",
       "    titletext.classList = 'ui-dialog-title';\n",
       "    titletext.setAttribute(\n",
       "        'style',\n",
       "        'width: 100%; text-align: center; padding: 3px;'\n",
       "    );\n",
       "    titlebar.appendChild(titletext);\n",
       "    this.root.appendChild(titlebar);\n",
       "    this.header = titletext;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
       "    canvas_div.setAttribute(\n",
       "        'style',\n",
       "        'border: 1px solid #ddd;' +\n",
       "            'box-sizing: content-box;' +\n",
       "            'clear: both;' +\n",
       "            'min-height: 1px;' +\n",
       "            'min-width: 1px;' +\n",
       "            'outline: 0;' +\n",
       "            'overflow: hidden;' +\n",
       "            'position: relative;' +\n",
       "            'resize: both;'\n",
       "    );\n",
       "\n",
       "    function on_keyboard_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.key_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    canvas_div.addEventListener(\n",
       "        'keydown',\n",
       "        on_keyboard_event_closure('key_press')\n",
       "    );\n",
       "    canvas_div.addEventListener(\n",
       "        'keyup',\n",
       "        on_keyboard_event_closure('key_release')\n",
       "    );\n",
       "\n",
       "    this._canvas_extra_style(canvas_div);\n",
       "    this.root.appendChild(canvas_div);\n",
       "\n",
       "    var canvas = (this.canvas = document.createElement('canvas'));\n",
       "    canvas.classList.add('mpl-canvas');\n",
       "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
       "\n",
       "    this.context = canvas.getContext('2d');\n",
       "\n",
       "    var backingStore =\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        this.context.webkitBackingStorePixelRatio ||\n",
       "        this.context.mozBackingStorePixelRatio ||\n",
       "        this.context.msBackingStorePixelRatio ||\n",
       "        this.context.oBackingStorePixelRatio ||\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
       "        'canvas'\n",
       "    ));\n",
       "    rubberband_canvas.setAttribute(\n",
       "        'style',\n",
       "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
       "    );\n",
       "\n",
       "    var resizeObserver = new ResizeObserver(function (entries) {\n",
       "        var nentries = entries.length;\n",
       "        for (var i = 0; i < nentries; i++) {\n",
       "            var entry = entries[i];\n",
       "            var width, height;\n",
       "            if (entry.contentBoxSize) {\n",
       "                if (entry.contentBoxSize instanceof Array) {\n",
       "                    // Chrome 84 implements new version of spec.\n",
       "                    width = entry.contentBoxSize[0].inlineSize;\n",
       "                    height = entry.contentBoxSize[0].blockSize;\n",
       "                } else {\n",
       "                    // Firefox implements old version of spec.\n",
       "                    width = entry.contentBoxSize.inlineSize;\n",
       "                    height = entry.contentBoxSize.blockSize;\n",
       "                }\n",
       "            } else {\n",
       "                // Chrome <84 implements even older version of spec.\n",
       "                width = entry.contentRect.width;\n",
       "                height = entry.contentRect.height;\n",
       "            }\n",
       "\n",
       "            // Keep the size of the canvas and rubber band canvas in sync with\n",
       "            // the canvas container.\n",
       "            if (entry.devicePixelContentBoxSize) {\n",
       "                // Chrome 84 implements new version of spec.\n",
       "                canvas.setAttribute(\n",
       "                    'width',\n",
       "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
       "                );\n",
       "                canvas.setAttribute(\n",
       "                    'height',\n",
       "                    entry.devicePixelContentBoxSize[0].blockSize\n",
       "                );\n",
       "            } else {\n",
       "                canvas.setAttribute('width', width * mpl.ratio);\n",
       "                canvas.setAttribute('height', height * mpl.ratio);\n",
       "            }\n",
       "            canvas.setAttribute(\n",
       "                'style',\n",
       "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
       "            );\n",
       "\n",
       "            rubberband_canvas.setAttribute('width', width);\n",
       "            rubberband_canvas.setAttribute('height', height);\n",
       "\n",
       "            // And update the size in Python. We ignore the initial 0/0 size\n",
       "            // that occurs as the element is placed into the DOM, which should\n",
       "            // otherwise not happen due to the minimum size styling.\n",
       "            if (width != 0 && height != 0) {\n",
       "                fig.request_resize(width, height);\n",
       "            }\n",
       "        }\n",
       "    });\n",
       "    resizeObserver.observe(canvas_div);\n",
       "\n",
       "    function on_mouse_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.mouse_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousedown',\n",
       "        on_mouse_event_closure('button_press')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseup',\n",
       "        on_mouse_event_closure('button_release')\n",
       "    );\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousemove',\n",
       "        on_mouse_event_closure('motion_notify')\n",
       "    );\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseenter',\n",
       "        on_mouse_event_closure('figure_enter')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseleave',\n",
       "        on_mouse_event_closure('figure_leave')\n",
       "    );\n",
       "\n",
       "    canvas_div.addEventListener('wheel', function (event) {\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        on_mouse_event_closure('scroll')(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.appendChild(canvas);\n",
       "    canvas_div.appendChild(rubberband_canvas);\n",
       "\n",
       "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
       "    this.rubberband_context.strokeStyle = '#000000';\n",
       "\n",
       "    this._resize_canvas = function (width, height, forward) {\n",
       "        if (forward) {\n",
       "            canvas_div.style.width = width + 'px';\n",
       "            canvas_div.style.height = height + 'px';\n",
       "        }\n",
       "    };\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
       "        event.preventDefault();\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 toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'mpl-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'mpl-button-group';\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",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'mpl-button-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        var button = (fig.buttons[name] = document.createElement('button'));\n",
       "        button.classList = 'mpl-widget';\n",
       "        button.setAttribute('role', 'button');\n",
       "        button.setAttribute('aria-disabled', 'false');\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "\n",
       "        var icon_img = document.createElement('img');\n",
       "        icon_img.src = '_images/' + image + '.png';\n",
       "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
       "        icon_img.alt = tooltip;\n",
       "        button.appendChild(icon_img);\n",
       "\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    var fmt_picker = document.createElement('select');\n",
       "    fmt_picker.classList = 'mpl-widget';\n",
       "    toolbar.appendChild(fmt_picker);\n",
       "    this.format_dropdown = fmt_picker;\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = document.createElement('option');\n",
       "        option.selected = fmt === mpl.default_extension;\n",
       "        option.innerHTML = fmt;\n",
       "        fmt_picker.appendChild(option);\n",
       "    }\n",
       "\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\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",
       "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",
       "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], msg['forward']);\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,\n",
       "        0,\n",
       "        fig.canvas.width / mpl.ratio,\n",
       "        fig.canvas.height / mpl.ratio\n",
       "    );\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",
       "        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.handle_history_buttons = function (fig, msg) {\n",
       "    for (var key in msg) {\n",
       "        if (!(key in fig.buttons)) {\n",
       "            continue;\n",
       "        }\n",
       "        fig.buttons[key].disabled = !msg[key];\n",
       "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
       "    if (msg['mode'] === 'PAN') {\n",
       "        fig.buttons['Pan'].classList.add('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    } else if (msg['mode'] === 'ZOOM') {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.add('active');\n",
       "    } else {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    }\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",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data\n",
       "            );\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        } else if (\n",
       "            typeof evt.data === 'string' &&\n",
       "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
       "        ) {\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(\n",
       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
       "                msg\n",
       "            );\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(\n",
       "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
       "                    e,\n",
       "                    e.stack,\n",
       "                    msg\n",
       "                );\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",
       "    }\n",
       "    if (e.target) {\n",
       "        targ = e.target;\n",
       "    } else if (e.srcElement) {\n",
       "        targ = e.srcElement;\n",
       "    }\n",
       "    if (targ.nodeType === 3) {\n",
       "        // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "    }\n",
       "\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    var boundingRect = targ.getBoundingClientRect();\n",
       "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
       "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\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",
       "        }\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",
       "        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, {\n",
       "        x: x,\n",
       "        y: y,\n",
       "        button: event.button,\n",
       "        step: event.step,\n",
       "        guiEvent: simpleKeys(event),\n",
       "    });\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",
       "    // Prevent repeat events\n",
       "    if (name === 'key_press') {\n",
       "        if (event.which === this._key) {\n",
       "            return;\n",
       "        } else {\n",
       "            this._key = event.which;\n",
       "        }\n",
       "    }\n",
       "    if (name === 'key_release') {\n",
       "        this._key = null;\n",
       "    }\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which !== 17) {\n",
       "        value += 'ctrl+';\n",
       "    }\n",
       "    if (event.altKey && event.which !== 18) {\n",
       "        value += 'alt+';\n",
       "    }\n",
       "    if (event.shiftKey && event.which !== 16) {\n",
       "        value += 'shift+';\n",
       "    }\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, 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\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"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\";/* global mpl */\n",
       "\n",
       "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 = document.getElementById(id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm);\n",
       "\n",
       "    function ondownload(figure, _format) {\n",
       "        window.open(figure.canvas.toDataURL());\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\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;\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",
       "\n",
       "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
       "    var width = fig.canvas.width / mpl.ratio;\n",
       "    fig.root.removeEventListener('remove', this._remove_fig_handler);\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.innerHTML =\n",
       "        '<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'] =\n",
       "        '<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 () {\n",
       "        fig.push_to_output();\n",
       "    }, 1000);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'btn-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'btn-group';\n",
       "    var button;\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",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'btn-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        button = fig.buttons[name] = document.createElement('button');\n",
       "        button.classList = 'btn btn-default';\n",
       "        button.href = '#';\n",
       "        button.title = name;\n",
       "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message pull-right';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = document.createElement('div');\n",
       "    buttongrp.classList = 'btn-group inline pull-right';\n",
       "    button = document.createElement('button');\n",
       "    button.classList = 'btn btn-mini btn-primary';\n",
       "    button.href = '#';\n",
       "    button.title = 'Stop Interaction';\n",
       "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
       "    button.addEventListener('click', function (_evt) {\n",
       "        fig.handle_close(fig, {});\n",
       "    });\n",
       "    button.addEventListener(\n",
       "        'mouseover',\n",
       "        on_mouseover_closure('Stop Interaction')\n",
       "    );\n",
       "    buttongrp.appendChild(button);\n",
       "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
       "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._remove_fig_handler = function () {\n",
       "    this.close_ws(this, {});\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (el) {\n",
       "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
       "    el.addEventListener('remove', this._remove_fig_handler);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
       "    // this is important to make the div 'focusable\n",
       "    el.setAttribute('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",
       "    } else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\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",
       "\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",
       "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(\n",
       "        'matplotlib',\n",
       "        mpl.mpl_figure_comm\n",
       "    );\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:,\" width=\"0\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "\n",
    "# Darstellungsparameter\n",
    "nrepeats = 50\n",
    "interpol = \"bilinear\"\n",
    "tmin = 20\n",
    "tmax = 34\n",
    "cmap = \"inferno\" \n",
    "\n",
    "# Erstelle eine Abbildung mit einem Unterfenster\n",
    "fig, (ax1) = plt.subplots(1, 1, figsize=(3,3))\n",
    "\n",
    "# Erzeuge ein leeres Bild und zeige es zusammen mit der Farbskala an\n",
    "img = np.zeros((8,8))\n",
    "im = plt.imshow(img, cmap=cmap, vmin=tmin, vmax=tmax, interpolation=interpol)\n",
    "plt.colorbar(format=\"%.0f°C\")\n",
    "\n",
    "# Die folgende Funktion lädt ein Bild vom Sensor und kopiert es in die Abbildung\n",
    "def update1(i):\n",
    "    img = get_image()\n",
    "    im.set_array(img)\n",
    "    return im, \n",
    "\n",
    "# Zeige die Abbildung als Animation\n",
    "ani1 = FuncAnimation(plt.gcf(), update1, frames=range(nrepeats), interval=1, blit=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "_ = run_on_board(['import blob as blob'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definiert eine Hilfsfunktion, die ein Wärmebild liest und mit Hilfe der Funktion `find_blobs`, die auf dem Board läuft, \"Blobs\" im Bild detektiert. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_image_blobs():\n",
    "    script = [\n",
    "        'img_raw = list(amg.pixels_64x1)',\n",
    "        'print(img_raw)'\n",
    "    ]\n",
    "    raw = json.loads(run_on_board(script, no_print=True))\n",
    "    img = np.flip(np.transpose(np.reshape(raw, (8, 8))))\n",
    "    script = [\n",
    "        'blob_list = blob.find_blobs_timed(img_raw, (8, 8))',\n",
    "        'print(blob_list)'\n",
    "    ]\n",
    "    blobs = json.loads(run_on_board(script, no_print=True))\n",
    "    return img, blobs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Liest ein Bild und die dazughörigen Blobs ein. In `blob.py` kann man auch auf die Masken zugreifen, die zeigen, welche Pixel über dem Temperaturschwellenwert lagen (`msk1`) und welche Pixel zu welchem Blob gehören (`msk2`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "img, blobs = get_image_blobs()   \n",
    "msk1 = json.loads(run_on_board([\"print(list(blob.pMskSave1))\"], no_print=True).decode())\n",
    "msk1 = np.flip(np.transpose(np.reshape(msk1, (8, 8))))\n",
    "msk2 = json.loads(run_on_board([\"print(list(blob.pMskSave2))\"], no_print=True).decode())\n",
    "msk2 = np.flip(np.transpose(np.reshape(msk2, (8, 8))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Erstelle eine Abbildung mit dem Wärmebild (\"heatmap\") und den beiden Masken (siehe oben)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x2029a5674c8>"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18,4))\n",
    "im1 = ax1.imshow(img, cmap='inferno', vmin=18, vmax=32)\n",
    "im2 = ax2.imshow(msk1, cmap='Greys', vmin=250, vmax=255)\n",
    "im3 = ax3.imshow(msk2, cmap='Greys', vmin=0, vmax=2)\n",
    "\n",
    "circs = []\n",
    "cs = [(0.5, 1, 0.2), (1, 0.5, 0.2), (0.2, 0.5, 1)]\n",
    "for i, b in enumerate(blobs):\n",
    "    r = np.sqrt(b[0]/np.pi)\n",
    "    c = (1,1,1) if i >= len(cs) else cs[i]\n",
    "    circs.append(Circle((8-b[3]-1, 8-b[4]-1), radius=r, fill=False, ec=c, lw=2))\n",
    "    ax3.add_patch(circs[i])\n",
    "    \n",
    "for i in range(8):\n",
    "    for j in range(8):\n",
    "        c = \"w\" if img[i, j] < 26 else \"black\"\n",
    "        text = ax1.text(j, i, img[i, j], ha=\"center\", va=\"center\", color=c)\n",
    "for i in range(8):\n",
    "    for j in range(8):\n",
    "        text = ax2.text(j, i, msk1[i, j], ha=\"center\", va=\"center\", color=\"w\")\n",
    "for i in range(8):\n",
    "    for j in range(8):\n",
    "        c = \"w\" if msk2[i, j] > 200 else \"black\"\n",
    "        text = ax3.text(j, i, msk2[i, j], ha=\"center\", va=\"center\", color=c)\n",
    "\n",
    "plt.colorbar(im1, format=\"%.0f°C\")"
   ]
  },
  {
   "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.7.6"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}