Circle Animation with FuncAnimation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Based on Basic animation with FuncAnimation\n",
    "https://riptutorial.com/matplotlib/example/23558/basic-animation-with-funcanimation\n",
    "\n",
    "Let's animate a dot moving around a circle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "# import matplotlib.animation as animation\n",
    "from matplotlib.animation import FuncAnimation, FFMpegWriter\n",
    "%matplotlib notebook\n",
    "# set up figure size and DPI for screen demo\n",
    "plt.rcParams['figure.figsize'] = (7, 7)\n",
    "plt.rcParams['figure.dpi'] = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support. ' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option);\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width / mpl.ratio, fig.canvas.height / mpl.ratio);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>');\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        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=\"700\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving frame 1 of 63\n",
      "Saving frame 2 of 63\n",
      "Saving frame 3 of 63\n",
      "Saving frame 4 of 63\n",
      "Saving frame 5 of 63\n",
      "Saving frame 6 of 63\n",
      "Saving frame 7 of 63\n",
      "Saving frame 8 of 63\n",
      "Saving frame 9 of 63\n",
      "Saving frame 10 of 63\n",
      "Saving frame 11 of 63\n",
      "Saving frame 12 of 63\n",
      "Saving frame 13 of 63\n",
      "Saving frame 14 of 63\n",
      "Saving frame 15 of 63\n",
      "Saving frame 16 of 63\n",
      "Saving frame 17 of 63\n",
      "Saving frame 18 of 63\n",
      "Saving frame 19 of 63\n",
      "Saving frame 20 of 63\n",
      "Saving frame 21 of 63\n",
      "Saving frame 22 of 63\n",
      "Saving frame 23 of 63\n",
      "Saving frame 24 of 63\n",
      "Saving frame 25 of 63\n",
      "Saving frame 26 of 63\n",
      "Saving frame 27 of 63\n",
      "Saving frame 28 of 63\n",
      "Saving frame 29 of 63\n",
      "Saving frame 30 of 63\n",
      "Saving frame 31 of 63\n",
      "Saving frame 32 of 63\n",
      "Saving frame 33 of 63\n",
      "Saving frame 34 of 63\n",
      "Saving frame 35 of 63\n",
      "Saving frame 36 of 63\n",
      "Saving frame 37 of 63\n",
      "Saving frame 38 of 63\n",
      "Saving frame 39 of 63\n",
      "Saving frame 40 of 63\n",
      "Saving frame 41 of 63\n",
      "Saving frame 42 of 63\n",
      "Saving frame 43 of 63\n",
      "Saving frame 44 of 63\n",
      "Saving frame 45 of 63\n",
      "Saving frame 46 of 63\n",
      "Saving frame 47 of 63\n",
      "Saving frame 48 of 63\n",
      "Saving frame 49 of 63\n",
      "Saving frame 50 of 63\n",
      "Saving frame 51 of 63\n",
      "Saving frame 52 of 63\n",
      "Saving frame 53 of 63\n",
      "Saving frame 54 of 63\n",
      "Saving frame 55 of 63\n",
      "Saving frame 56 of 63\n",
      "Saving frame 57 of 63\n",
      "Saving frame 58 of 63\n",
      "Saving frame 59 of 63\n",
      "Saving frame 60 of 63\n",
      "Saving frame 61 of 63\n",
      "Saving frame 62 of 63\n",
      "Saving frame 63 of 63\n"
     ]
    }
   ],
   "source": [
    "TWOPI = 2*np.pi # numpy doesn't have tau (2π)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "theta = np.arange(0.0, TWOPI, 0.001) # ø values from 0 to π in increments of 0.001\n",
    "x = np.cos(theta)                    # x values from -1 to 1\n",
    "y = np.sin(theta)                    # y values from -1 to 1\n",
    "l = plt.plot(x, y)                   # x,y plot of t,s values\n",
    "ax = plt.axis([-1.1,1.1,-1.1,1.1]) # plt.axis([xmin, xmax, ymin, ymax]) equivalent to ax.set(xlim=(xmin, xmax), ylim=(ymin, ymax))\n",
    "\n",
    "redDot, = plt.plot([np.cos(0)], [np.sin(0)], 'ro')\n",
    "\n",
    "# plt.plot\n",
    "\n",
    "def animate(i):\n",
    "    redDot.set_data(np.cos(i), np.sin(i))\n",
    "    plt.title('radians: {:^2.1f}'.format(i))\n",
    "    return redDot,\n",
    "\n",
    "# create animation using the animate() function\n",
    "progress_callback = lambda i, n: print(f'Saving frame {i+1} of {n}')\n",
    "animation = FuncAnimation(fig, animate, frames=np.arange(0.0, TWOPI, 0.1), interval=50, blit=True, repeat=False)\n",
    "\n",
    "# animation = FuncAnimation(plt.gcf(), #get current figure or gcf\n",
    "#                           update, #the function to update\n",
    "#                           frames=frames, #overrides the default frames behavior of counting up i in integers from 0\n",
    "#                           interval=interval,\n",
    "#                           #repeat = False, #option to stop animation after one iteration\n",
    "#                           repeat_delay = 2e3, #optional delay in ms; 1e3 = 1000 ms = 1 s\n",
    "#                           #progress_callback=progress_callback\n",
    "#                           )\n",
    "\n",
    "\n",
    "# from matplotlib.animation import FFMpegWriter\n",
    "writer = FFMpegWriter(fps=15, metadata=dict(artist='Stephen Shadle'), bitrate=1800)\n",
    "#ani.save(\"/home/pi/Documents/Thonny/dynamic_image.mp4\", writer=writer) #explicit directory\n",
    "animation.save(\"animate_circle2.mp4\", writer=writer, progress_callback=progress_callback) #current directory\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "?FuncAnimation"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}