Lec08_interactive.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Interactive Graphics\n",
    "## Example setup up and test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis of two backends\n",
    "The two cells below use either qt5agg backend (cell 1) or what ever\n",
    "is native the the system (macosx in ny case).  Once either of these \n",
    "cells is run, the kernel needs to be restarted to have the other one\n",
    "run.  \n",
    "* In the cell 1, removing the %matplotlib magic line and a kernel restart \n",
    "still generates\n",
    "the figure and allows points to be selected but the figure goes into \n",
    "spin-dump when ginput completes.\n",
    "* In cell 2, removing the %matplotlib line genearates an error saying\n",
    "in-line backend does not allow interative features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %matplotlib with no arguments seems to be needed for the figure\n",
    "# not to spin-dump after ginput ends.  Once this cell is run, \n",
    "# the next cell will generate errors.  The figure created here is \n",
    "# different to that in the seconcd cell.\n",
    "%matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "\n",
    "print('Use qt5agg')\n",
    "matplotlib.use('qt5agg')\n",
    "\n",
    "fig = plt.figure(figsize=(6,6))\n",
    "plt.clf()\n",
    "# plt.ion()  # This does seem to be needd\n",
    "plt.ylim((-100,100))\n",
    "plt.xlim((-100,100))\n",
    "plt.grid(True)\n",
    "#plt.plot([1.6, 2.7])\n",
    "plt.title(\"Interactive test with \"+plt.get_backend())\n",
    "plt.xlabel(\"X-axis\")\n",
    "plt.ylabel(\"Y-axis\")\n",
    "\n",
    "# Back space deletes, returns stops for single button mouse (settihgs below which\n",
    "# has right-click as stop do not affect this)\n",
    "print('Select points')\n",
    "#pts = plt.ginput(n=5, timeout=30, show_clicks=True, mouse_add=1, mouse_pop=2, mouse_stop=3)\n",
    "# Figures goes into spin dump (messages below are printed but figure not usable)\n",
    "pts = plt.ginput(n=5, show_clicks=True)\n",
    "print('Selected point ',pts)\n",
    "selpts = np.array(pts)\n",
    "# Now draw the points\n",
    "plt.plot(selpts[:,0],selpts[:,1])\n",
    "print('Backend',plt.get_backend())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This next method is one of the more common peferred methods \n",
    "# using a separate namespace for the modules.\n",
    "# After re-start of kernal; code below works only if the\n",
    "# %matplotlib magic command with no arguments is used. \n",
    "# FIgure looks differenent to cell above with the qt5agg \n",
    "%matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "fig = plt.figure;\n",
    "\n",
    "fig(figsize=(6,6))\n",
    "# plt.plot([1, 2, 3, 4], [1, 4, 2, 3])\n",
    "plt.clf()\n",
    "# plt.ion()  # This does seem to be needd\n",
    "plt.ylim((-100,100))\n",
    "plt.xlim((-100,100))\n",
    "plt.grid(True)\n",
    "plt.title(\"Interactive test with \"+plt.get_backend())\n",
    "plt.xlabel(\"X-axis\")\n",
    "plt.ylabel(\"Y-axis\")\n",
    "pts = plt.ginput(n=5, show_clicks=True)\n",
    "selpts = np.array(pts)\n",
    "# Now draw the points\n",
    "plt.plot(selpts[:,0],selpts[:,1])\n",
    "plt.show()\n",
    "print('Backend',plt.get_backend())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Issues with interactive plots and versioning\n",
    "Packages below wotk \n",
    "TAHMac[1514] jupyter --version\n",
    "<br>jupyter core     : 4.5.0\n",
    "<br>jupyter-notebook : 6.0.1\n",
    "<br>qtconsole        : 4.5.5\n",
    "<br>ipython          : 7.8.0\n",
    "<br>ipykernel        : 5.1.2\n",
    "<br>jupyter client   : 5.3.3\n",
    "<br>jupyter lab      : 1.1.4\n",
    "<br>nbconvert        : 5.6.0\n",
    "<br>ipywidgets       : 7.5.1\n",
    "<br>nbformat         : 4.4.0\n",
    "<br>traitlets        : 4.3.3\n",
    "Update to anaconda 2.1.0 from 2.0.4 (touched all packages)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jupyter version\n",
      "jupyter core     : 4.7.1\n",
      "jupyter-notebook : 6.3.0\n",
      "qtconsole        : 5.0.3\n",
      "ipython          : 7.22.0\n",
      "ipykernel        : 5.3.4\n",
      "jupyter client   : 6.1.12\n",
      "jupyter lab      : 3.0.14\n",
      "nbconvert        : 6.0.7\n",
      "ipywidgets       : 7.6.3\n",
      "nbformat         : 5.1.3\n",
      "traitlets        : 5.0.5\n"
     ]
    }
   ],
   "source": [
    "print('jupyter version')\n",
    "!jupyter --version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slider and reset test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This code runs when either cell 1 or 2 is run but the look is\n",
    "# different as to where the fogure control line is.\n",
    "# If the kernel is restarted and neither cell above is run, the \n",
    "# code generates an inline figure that can not be interacted with.\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "\n",
    "from matplotlib.widgets import Slider, Button\n",
    "\n",
    "#matplotlib.use('qt5agg')\n",
    "#plt.ion()\n",
    "\n",
    "# The parametrized function to be plotted\n",
    "def f(t, amplitude, frequency):\n",
    "    return amplitude * np.sin(2 * np.pi * frequency * t)\n",
    "\n",
    "t = np.linspace(0, 1, 1000)\n",
    "\n",
    "# Define initial parameters\n",
    "init_amplitude = 5\n",
    "init_frequency = 3\n",
    "\n",
    "# Create the figure and the line that we will manipulate\n",
    "fig, ax = plt.subplots()\n",
    "line, = plt.plot(t, f(t, init_amplitude, init_frequency), lw=2)\n",
    "ax.set_xlabel('Time [s]')\n",
    "\n",
    "axcolor = 'lightgoldenrodyellow'\n",
    "ax.margins(x=0)\n",
    "\n",
    "# adjust the main plot to make room for the sliders\n",
    "plt.subplots_adjust(left=0.25, bottom=0.25)\n",
    "\n",
    "# Make a horizontal slider to control the frequency.\n",
    "axfreq = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor)\n",
    "freq_slider = Slider(\n",
    "    ax=axfreq,\n",
    "    label='Frequency [Hz]',\n",
    "    valmin=0.1,\n",
    "    valmax=30,\n",
    "    valinit=init_frequency,\n",
    ")\n",
    "\n",
    "# Make a vertically oriented slider to control the amplitude\n",
    "axamp = plt.axes([0.1, 0.25, 0.0225, 0.63], facecolor=axcolor)\n",
    "amp_slider = Slider(\n",
    "    ax=axamp,\n",
    "    label=\"Amplitude\",\n",
    "    valmin=0,\n",
    "    valmax=10,\n",
    "    valinit=init_amplitude,\n",
    "    orientation=\"vertical\"\n",
    ")\n",
    "\n",
    "\n",
    "# The function to be called anytime a slider's value changes\n",
    "def update(val):\n",
    "    line.set_ydata(f(t, amp_slider.val, freq_slider.val))\n",
    "    fig.canvas.draw_idle()\n",
    "\n",
    "\n",
    "# register the update function with each slider\n",
    "freq_slider.on_changed(update)\n",
    "amp_slider.on_changed(update)\n",
    "\n",
    "# Create a `matplotlib.widgets.Button` to reset the sliders to initial values.\n",
    "resetax = plt.axes([0.8, 0.025, 0.1, 0.04])\n",
    "button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.8')\n",
    "\n",
    "# Create 2nd  `matplotlib.widgets.Button` to see what happens.\n",
    "resetax = plt.axes([0.6, 0.025, 0.1, 0.04])\n",
    "button2 = Button(resetax, 'Test', color=axcolor, hovercolor='0.9')\n",
    "\n",
    "def reset(event):\n",
    "    print('Sliders Reset',event)\n",
    "    freq_slider.reset()\n",
    "    amp_slider.reset()\n",
    "    \n",
    "def test(event):\n",
    "    print('Test event',event)\n",
    "    \n",
    "button.on_clicked(reset)\n",
    "button2.on_clicked(test)\n",
    "plt.draw()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Radio button example\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.widgets import RadioButtons\n",
    "\n",
    "t = np.arange(0.0, 2.0, 0.01)\n",
    "s0 = np.sin(2*np.pi*t)\n",
    "s1 = np.sin(4*np.pi*t)\n",
    "s2 = np.sin(8*np.pi*t)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "l, = ax.plot(t, s0, lw=2, color='red')\n",
    "plt.subplots_adjust(left=0.3)\n",
    "\n",
    "axcolor = 'lightgoldenrodyellow'\n",
    "rax = plt.axes([0.05, 0.7, 0.15, 0.15], facecolor=axcolor)\n",
    "radio = RadioButtons(rax, ('2 Hz', '4 Hz', '8 Hz'))\n",
    "\n",
    "\n",
    "def hzfunc(label):\n",
    "    hzdict = {'2 Hz': s0, '4 Hz': s1, '8 Hz': s2}\n",
    "    ydata = hzdict[label]\n",
    "    l.set_ydata(ydata)\n",
    "    plt.draw()\n",
    "radio.on_clicked(hzfunc)\n",
    "\n",
    "rax = plt.axes([0.05, 0.4, 0.15, 0.15], facecolor=axcolor)\n",
    "radio2 = RadioButtons(rax, ('red', 'blue', 'green'))\n",
    "\n",
    "\n",
    "def colorfunc(label):\n",
    "    l.set_color(label)\n",
    "    plt.draw()\n",
    "radio2.on_clicked(colorfunc)\n",
    "\n",
    "rax = plt.axes([0.05, 0.1, 0.15, 0.15], facecolor=axcolor)\n",
    "# steps has been depreciated so does not work). \n",
    "radio3 = RadioButtons(rax, ('-', '--', '-.', 'steps', ':'))\n",
    "\n",
    "# For some reason line style change needs two clicks\n",
    "def stylefunc(label):\n",
    "    l.set_linestyle(label)\n",
    "    plt.draw()\n",
    "radio3.on_clicked(stylefunc)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l.set_linestyle?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Text Box that show how to have input text and have a plot\n",
    "# generated.\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.widgets import TextBox\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "fig.subplots_adjust(bottom=0.2)\n",
    "\n",
    "t = np.arange(-2.0, 2.0, 0.001)\n",
    "l, = ax.plot(t, np.zeros_like(t), lw=2)\n",
    "print('1st output from ax.plot',l)\n",
    "\n",
    "def submit(expression):\n",
    "    \"\"\"\n",
    "    Update the plotted function to the new math *expression*.\n",
    "\n",
    "    *expression* is a string using \"t\" as its independent variable, e.g.\n",
    "    \"t ** 3\".\n",
    "    np.<function name> can be used for math functions. e.g., np.sin(t)\n",
    "    \"\"\"\n",
    "    ydata = eval(expression)\n",
    "    l.set_ydata(ydata)\n",
    "    ax.relim()\n",
    "    ax.autoscale_view()\n",
    "    plt.draw()\n",
    "\n",
    "\n",
    "axbox = fig.add_axes([0.1, 0.05, 0.8, 0.075])\n",
    "text_box = TextBox(axbox, \"Evaluate\")\n",
    "text_box.on_submit(submit)\n",
    "text_box.set_val(\"t ** 2\")  # Trigger `submit` with the initial string.\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ellipse selector.  Keyboard usage seems to be depreciated.\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.widgets import EllipseSelector\n",
    "\n",
    "def onselect(eclick, erelease):\n",
    "    \"eclick and erelease are matplotlib events at press and release.\"\n",
    "    print('startposition: (%f, %f)' % (eclick.xdata, eclick.ydata))\n",
    "    print('endposition  : (%f, %f)' % (erelease.xdata, erelease.ydata))\n",
    "    print('used button  : ', eclick.button)\n",
    "\n",
    "def toggle_selector(event):\n",
    "    print(' Key pressed.',event.key)\n",
    "    if event.key in ['Q', 'q'] and toggle_selector.ES.active:\n",
    "        print('EllipseSelector deactivated.')\n",
    "        toggle_selector.RS.set_active(False)\n",
    "    if event.key in ['A', 'a'] and not toggle_selector.ES.active:\n",
    "        print('EllipseSelector activated.')\n",
    "        toggle_selector.ES.set_active(True)\n",
    "\n",
    "x = np.arange(100.) / 99\n",
    "y = np.sin(x)\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(x, y)\n",
    "\n",
    "toggle_selector.ES = EllipseSelector(ax, onselect, drawtype='line')\n",
    "fig.canvas.mpl_connect('key_press_event', toggle_selector)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# animation\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import matplotlib.animation as animation\n",
    "\n",
    "pause = False\n",
    "def simData():\n",
    "    t_max = 10.0\n",
    "    dt = 0.05\n",
    "    x = 0.0\n",
    "    t = 0.0\n",
    "    while t < t_max:\n",
    "        if not pause:\n",
    "            x = np.sin(np.pi*t)\n",
    "            t = t + dt\n",
    "        yield x, t\n",
    "\n",
    "def onClick(event):\n",
    "    global pause\n",
    "    pause ^= True\n",
    "\n",
    "def simPoints(simData):\n",
    "    x, t = simData[0], simData[1]\n",
    "    time_text.set_text(time_template%(t))\n",
    "    line.set_data(t, x)\n",
    "    return line, time_text\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "line, = ax.plot([], [], 'bo', ms=10)\n",
    "ax.set_ylim(-1, 1)\n",
    "ax.set_xlim(0, 10)\n",
    "\n",
    "time_template = 'Time = %.1f s'\n",
    "time_text = ax.text(0.05, 0.9, '', transform=ax.transAxes)\n",
    "fig.canvas.mpl_connect('button_press_event', onClick)\n",
    "ani = animation.FuncAnimation(fig, simPoints, simData, blit=False, interval=10,\n",
    "    repeat=True)\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# New concept used in code above\n",
    "# Code snipets and example from: https://stackoverflow.com/questions/231767/what-does-the-yield-keyword-do\n",
    "#\n",
    "# Iterables: lists, tuples are iterables \n",
    "print('Iterable')\n",
    "myiter = [x**2 for x in range(3)]\n",
    "for i in myiter:\n",
    "    print(i)\n",
    "    \n",
    "print(myiter)\n",
    "print('Generator')\n",
    "# Generators: Simialr except can only be called once and don't use\n",
    "# a lot of space\n",
    "mygen = (x**2 for x in range(3))\n",
    "for i in mygen:\n",
    "    print(i)\n",
    "    \n",
    "print(mygen)\n",
    "print('Try generator a second time')\n",
    "for i in mygen:\n",
    "    print(i)\n",
    "print('Notice nothing is printed')\n",
    "\n",
    "def create_gen():\n",
    "    mylist = range(3)\n",
    "    for i in mylist:\n",
    "        yield i**2  # Simply use return here; would need to create list to be returned.\n",
    "        \n",
    "myfungen = create_gen()\n",
    "print('Create generator with yield keyword in function')\n",
    "for i in myfungen:\n",
    "    print(i)\n",
    "\n",
    "print(myfungen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chained: Animation works but controls are not present.\n",
    "No error messages but seems to need later version of matplotlib\n",
    "that can't be installed in anaconda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation\n",
    "\n",
    "# Fixing random state for reproducibility\n",
    "np.random.seed(19680801)\n",
    "\n",
    "\n",
    "# Create new Figure with black background\n",
    "fig = plt.figure(figsize=(8, 8), facecolor='black')\n",
    "\n",
    "# Add a subplot with no frame\n",
    "ax = plt.subplot(frameon=False)\n",
    "\n",
    "# Generate random data\n",
    "data = np.random.uniform(0, 1, (64, 75))\n",
    "X = np.linspace(-1, 1, data.shape[-1])\n",
    "G = 1.5 * np.exp(-4 * X ** 2)\n",
    "\n",
    "# Generate line plots\n",
    "lines = []\n",
    "for i in range(len(data)):\n",
    "    # Small reduction of the X extents to get a cheap perspective effect\n",
    "    xscale = 1 - i / 200.\n",
    "    # Same for linewidth (thicker strokes on bottom)\n",
    "    lw = 1.5 - i / 100.0\n",
    "    line, = ax.plot(xscale * X, i + G * data[i], color=\"w\", lw=lw)\n",
    "    lines.append(line)\n",
    "\n",
    "# Set y limit (or first line is cropped because of thickness)\n",
    "ax.set_ylim(-1, 70)\n",
    "\n",
    "# No ticks\n",
    "ax.set_xticks([])\n",
    "ax.set_yticks([])\n",
    "\n",
    "# 2 part titles to get different font weights\n",
    "ax.text(0.5, 1.0, \"MATPLOTLIB \", transform=ax.transAxes,\n",
    "        ha=\"right\", va=\"bottom\", color=\"w\",\n",
    "        family=\"sans-serif\", fontweight=\"light\", fontsize=16)\n",
    "ax.text(0.5, 1.0, \"UNCHAINED\", transform=ax.transAxes,\n",
    "        ha=\"left\", va=\"bottom\", color=\"w\",\n",
    "        family=\"sans-serif\", fontweight=\"bold\", fontsize=16)\n",
    "\n",
    "\n",
    "def update(*args):\n",
    "    # Shift all data to the right\n",
    "    data[:, 1:] = data[:, :-1]\n",
    "\n",
    "    # Fill-in new values\n",
    "    data[:, 0] = np.random.uniform(0, 1, len(data))\n",
    "\n",
    "    # Update data\n",
    "    for i in range(len(data)):\n",
    "        lines[i].set_ydata(i + G * data[i])\n",
    "\n",
    "    # Return modified artists\n",
    "    return lines\n",
    "\n",
    "# Construct the animation, using the update function as the animation director.\n",
    "anim = animation.FuncAnimation(fig, update, interval=10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of using Tkinter but we will not cover here.\n",
    "# conda intall -c anaconda tk needed for this to run (not done)\n",
    "import Tkinter\n",
    "parent_widget = Tkinter.Tk()\n",
    "button_widget = Tkinter.Button(parent_widget,\n",
    "    text=\"A Button\")\n",
    "button_widget.pack()\n",
    "Tkinter.mainloop()"
   ]
  },
  {
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}