part4_lab1_solution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part IV Lab 1 Solution\n",
    "\n",
    "Written by Charlie Watson (dch.watson@gmail.com) for University of Victoria MATH/PHYS 248 Winter 2018.\n",
    "\n",
    "## Relevant Notes\n",
    "\n",
    "The task is to create an animated analogue clock. The necessary material is covered in [Part IV Lecture 1](../Part.IV/Dynamic.plots.1.ipynb). In particular, I can start with [Ryan's code to animate a pendulum](../Part.IV/Dynamic.plots.1.ipynb#Pendulum-plots), since it involves drawing a circle and animating a radial line. \n",
    "\n",
    "## Outline\n",
    "\n",
    "I will start by animating only the second hand, so I can see it working. After that's working it will be easy to add the hour and minute hands. Finally, I will make the clock look nice.\n",
    "\n",
    "After the first code cell with all of the necessary imports, *every code cell is completely self-contained*. That makes this notebook quite long, but even though I change my code incrementally, nothing is obscured along the way. Think of this notebook as capturing my progress at every step while I write the code in front of you. **This is not how you should write your assignments**. Your submissions should reflect your final understanding, while this notebook shows my incremental refinement process.\n",
    "\n",
    "## Table of Contents\n",
    "\n",
    "* [Setting Up](#Setting-Up)\n",
    "* [Important Note](#Important-Note)\n",
    "* [Stripping Down Ryan's Code](#Stripping-Down-Ryan's-Code)\n",
    "* [Getting the Current Time](#Getting-the-Current-Time)\n",
    "* [Adding Hour and Minute Hands](#Adding-Hour-and-Minute-Hands)\n",
    "* [Making It Look Nicer](#Making-It-Look-Nicer)\n",
    "* [Improving the Hands](#Improving-the-Hands)\n",
    "\n",
    "## Important Note\n",
    "\n",
    "The code cell that I copy from Ryan's notes will not run properly on its own. `odeint` is imported from `scipy.integrate` in an earlier code cell, and both `a` and `b` are defined in an earlier code cell. However, you will not get an error message, since `matplotlib.animation.FuncAnimation` silently absorbs errors. To get around this, if `FuncAnimation` isn't doing what you expect then test your `animate` and `init` functions on their own, in a separate code cell.\n",
    "\n",
    "## Setting Up\n",
    "\n",
    "As always, I begin by importing the modules I'll need.\n",
    "\n",
    "* Ryan has instructed us to use the `time` module to get the current time.\n",
    "* As in the lecture, I will use `matplotlib.animation` to create an animation.\n",
    "* The magic commands `%pylab nbagg` or `%matplotlib nbagg` are required to embed animations in the notebook. I will use `%matplotlib` to avoid polluting the global namespace.\n",
    "\n",
    "Note: If you're having trouble with embedded animations (such as running out of memory), try using just `%matplotlib` instead. Animations will open in a new window."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import matplotlib.animation as animation\n",
    "%matplotlib nbagg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stripping Down Ryan's Code\n",
    "\n",
    "I'll look at Ryan's code in chunks and figure out which parts I should keep.\n",
    "\n",
    "```python\n",
    "## let's now do an animated plot, to \"see\" the pendulum in action\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "## initial plot. bearing, initial arm, circle of radius 1.\n",
    "\n",
    "circ = plt.Circle( (0.0, 0.0), 1.0, color='y', fill=False)\n",
    "cent = plt.plot([0.0], [0.0], 'ro')\n",
    "ax.add_artist(circ)\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "```\n",
    "\n",
    "I'll keep the circle as the outside of the clock. I don't need to mark the centre, so I'll remove it. The x and y limits are still sensible. So, my code will start like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ryan then sets up the arm of the pendulum.\n",
    "\n",
    "```python\n",
    "## set up arm\n",
    "TH = [0.0]\n",
    "TP = [14.0]\n",
    "\n",
    "arm, = plt.plot([0.0, np.sin(TH[-1])], [0.0, -np.cos(TH[-1])], 'b')\n",
    "\n",
    "dt = 0.002\n",
    "```\n",
    "\n",
    "`TH` and `TP` are lists of the all previous $\\theta$ and $\\theta'$ values. They are necessary for solving the ODE and tracing the previous path of the pendulum, so I don't need them here. Similarly, I don't need `dt`.\n",
    "\n",
    "Notice the comma after `arm`! `plt.plot` returns a *list* of plots (even if we only ask for one), and I only want the first one! The other way to handle this is to get the element at index `0`, like\n",
    "\n",
    "```python\n",
    "arm = plt.plot([0.0, np.sin(TH[-1])], [0.0, -np.cos(TH[-1])], 'b')[0]\n",
    "```\n",
    "\n",
    "All I need is a plot object for the second hand that I can update each frame. I'll name that `second_hand`. The initial state of the arm doesn't matter, because my `init` function will set it up properly before the first frame of the animation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "# Create second hand\n",
    "second_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next part of Ryan's code is a function that sets up the animation.\n",
    "\n",
    "```python\n",
    "def init():\n",
    "    arm.set_xdata( [0.0, np.sin(TH[-1])] )\n",
    "    arm.set_ydata( [0.0, -np.cos(TH[-1])] )\n",
    "    return arm, \n",
    "```\n",
    "\n",
    "Notice the comma in the `return` statement! The `init` and `animate` functions *must* return lists of objects! The other way to do this is to wrap the value in brackets, like\n",
    "\n",
    "```python\n",
    "return [arm]\n",
    "```\n",
    "\n",
    "Eventually I'll add some code to set the hands to the current time, but for now I'll just set the second hand to the x-axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "# Create second hand\n",
    "second_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "\n",
    "def init():\n",
    "    \"\"\"Set up the clock animation.\"\"\"\n",
    "    second_hand.set_xdata([0, 1])\n",
    "    second_hand.set_ydata([0, 0])\n",
    "    \n",
    "    return [second_hand]\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ryan then defines a function which updates the figure for each frame of the animation.\n",
    "\n",
    "```python\n",
    "def animate(i):\n",
    "    ## asking the ODE code to do just one step\n",
    "    SOL = odeint(lambda th, t, a, b: [th[1], -a*th[1]-b*np.sin(th[0])], [TH[-1], TP[-1]], \\\n",
    "                [0.0, dt], args=(a,b))\n",
    "    TH.append(SOL[-1][0])\n",
    "    TP.append(SOL[-1][1])\n",
    "    arm.set_xdata( [0.0, np.sin(TH[-1])] )\n",
    "    arm.set_ydata( [0.0, -np.cos(TH[-1])] )\n",
    "    return arm,\n",
    "```\n",
    "\n",
    "I don't need most of this, since I'm not solving an ODE. All I need to do is update the second hand.\n",
    "\n",
    "Notice that the animate function *must* to take an argument specifying the frame number. In my final code I won't use the frame number, but I'm not going to use the proper time, yet. For now I'll simply make the clock advance by one degree per frame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "# Create second hand\n",
    "second_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "\n",
    "def init():\n",
    "    \"\"\"Set up the clock animation.\"\"\"\n",
    "    second_hand.set_xdata([0, 1])\n",
    "    second_hand.set_ydata([0, 0])\n",
    "    \n",
    "    return [second_hand]\n",
    "\n",
    "def animate(i):\n",
    "    \"\"\"Update the clock hands to current time.\"\"\"\n",
    "    # Map frame i to i degrees around the circle.\n",
    "    angle = 2*np.pi * i/360\n",
    "    \n",
    "    second_hand.set_xdata([0, np.cos(angle)])\n",
    "    second_hand.set_ydata([0, np.sin(angle)])\n",
    "    \n",
    "    return [second_hand]\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, Ryan bundles this all together and creates the animation.\n",
    "\n",
    "```python    \n",
    "## interval is ms delay between frames\n",
    "ani = animation.FuncAnimation( fig, animate, init_func=init, interval=1,\\\n",
    "                               blit=True )\n",
    "\n",
    "plt.show()\n",
    "```\n",
    "\n",
    "The `interval` argument specifies the delay between frames of the animation, in milliseconds. I don't need clock to update one thousand times per second, so I'll use `interval=200` instead. This is actually the default, so I could simply leave the argument out if I wanted.\n",
    "\n",
    "The `blit` argument is important. By default, matplotlib will create the animation by separately rendering each frame, even if very little changes between frames. For simple animations (like this one) this might not be a big problem, but for larger, or more detailed, animations this can take a *long* time. Alternatively, if a class of students are all repeatedly rendering simple animations at the same time, it could crash the server. Blitting is a rendering method where only the parts of the image which change are calculated, often decreasing rendering time *enormously*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "# Create second hand\n",
    "second_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "\n",
    "def init():\n",
    "    \"\"\"Set up the clock animation.\"\"\"\n",
    "    second_hand.set_xdata([0, 1])\n",
    "    second_hand.set_ydata([0, 0])\n",
    "    \n",
    "    return [second_hand]\n",
    "\n",
    "def animate(i):\n",
    "    \"\"\"Update the clock hands to current time.\"\"\"\n",
    "    # Map frame i to i degrees around the circle.\n",
    "    angle = 2*np.pi * i/360\n",
    "    \n",
    "    second_hand.set_xdata([0, np.cos(angle)])\n",
    "    second_hand.set_ydata([0, np.sin(angle)])\n",
    "    \n",
    "    return [second_hand]\n",
    "\n",
    "ani = animation.FuncAnimation(fig, animate, init_func=init, interval=200, blit=True)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Excellent! First I will make the animation use the proper time, then I will make the clock look nicer.\n",
    "\n",
    "## Getting the Current Time\n",
    "\n",
    "The `time` module provides the `localtime()` function which returns a dictionary containing everything about the current time you could want. However, all four servers are set to UTC (Universal Coordinated Time, identical to Greenwich Mean Time) instead of the Pacific Standard Time you might expect. We'll have to account for that eventually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time.tzname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "now = time.localtime()\n",
    "now"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the hour or minute, use the appropriate name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "now.tm_hour, now.tm_min"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I have to map a second to an angle on the circle. Notice that each second maps to one-sixtieth of a rotation clockwise from vertical ($\\frac{\\pi}{2}$ radians). Clockwise is a negative rotation, so second 1 maps to $\\frac{\\pi}{2} - 1 \\cdot \\frac{2\\pi}{60}$. In general, second $s$ maps to $\\frac{\\pi}{2} - s \\cdot \\frac{2\\pi}{60}$.\n",
    "\n",
    "My `init` and `animate` functions will now simply get the current time and set the second hand to the right angle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "# Create second hand\n",
    "second_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "\n",
    "def init():\n",
    "    \"\"\"Set up the clock animation.\"\"\"\n",
    "    # Get the current time and set the hand angles.\n",
    "    now = time.localtime()\n",
    "    second_angle = np.pi/2 - now.tm_sec * (2*np.pi / 60)\n",
    "    \n",
    "    second_hand.set_xdata([0, np.cos(second_angle)])\n",
    "    second_hand.set_ydata([0, np.sin(second_angle)])\n",
    "    \n",
    "    return [second_hand]\n",
    "\n",
    "def animate(i):\n",
    "    \"\"\"Update the clock hands to current time.\"\"\"\n",
    "    # Get the current time and set the hand angles.\n",
    "    now = time.localtime()\n",
    "    second_angle = np.pi/2 - now.tm_sec * (2*np.pi / 60)\n",
    "    \n",
    "    second_hand.set_xdata([0, np.cos(second_angle)])\n",
    "    second_hand.set_ydata([0, np.sin(second_angle)])\n",
    "    \n",
    "    return [second_hand]\n",
    "\n",
    "ani = animation.FuncAnimation(fig, animate, init_func=init, interval=200, blit=True)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beautiful! I'm almost ready to make the clock look a bit nicer. However, before that I can clean up my code a bit. I've repeated myself in the bodies of `init` and `animate`. I can refactor that code into a function like `update_hand()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "# Create second hand\n",
    "second_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "\n",
    "# Update the second for the current time.\n",
    "def update_hand():\n",
    "    \"\"\"Set the second hand to current time.\"\"\"\n",
    "    now = time.localtime()\n",
    "    \n",
    "    second_angle = np.pi/2 - now.tm_sec * (2*np.pi / 60)\n",
    "    second_hand.set_xdata([0, np.cos(second_angle)])\n",
    "    second_hand.set_ydata([0, np.sin(second_angle)])\n",
    "    \n",
    "    return [second_hand]\n",
    "\n",
    "def init():\n",
    "    \"\"\"Set up the clock animation.\"\"\"\n",
    "    return [update_hand()]\n",
    "\n",
    "def animate(i):\n",
    "    \"\"\"Update the clock hands to current time.\"\"\"\n",
    "    return [update_hand()]\n",
    "\n",
    "ani = animation.FuncAnimation(fig, animate, init_func=init, interval=200, blit=True)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding Hour and Minute Hands\n",
    "\n",
    "Adding the minute and hour hands is mostly copy-and-paste. I'll also change the name of `update_hand()` to `update_hands()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "# Create clock hands\n",
    "second_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "minute_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "hour_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "\n",
    "# Update all three hands for the current time.\n",
    "def update_hands():\n",
    "    \"\"\"Set each hand to the current time.\"\"\"\n",
    "    now = time.localtime()\n",
    "    \n",
    "    second_angle = np.pi/2 - now.tm_sec * (2*np.pi / 60)\n",
    "    second_hand.set_xdata([0, np.cos(second_angle)])\n",
    "    second_hand.set_ydata([0, np.sin(second_angle)])\n",
    "    \n",
    "    minute_angle = np.pi/2 - now.tm_min * (2*np.pi / 60)\n",
    "    minute_hand.set_xdata([0, np.cos(minute_angle)])\n",
    "    minute_hand.set_ydata([0, np.sin(minute_angle)])\n",
    "    \n",
    "    hour_angle = np.pi/2 - now.tm_hour * (2*np.pi / 12)\n",
    "    hour_hand.set_xdata([0, np.cos(hour_angle)])\n",
    "    hour_hand.set_ydata([0, np.sin(hour_angle)])\n",
    "    \n",
    "    return [second_hand, minute_hand, hour_hand]\n",
    "\n",
    "def init():\n",
    "    \"\"\"Set up the clock animation.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "def animate(i):\n",
    "    \"\"\"Update the clock hands to current time.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "ani = animation.FuncAnimation(fig, animate, init_func=init, interval=200, blit=True)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is starting to look pretty good, but I'm repeating myself in my code again. I'll refactor `update_hands()` and create a function `update_hand(hand, position, steps)` which takes one of the hand plot objects, the relevant time value, and the number of steps around for that time value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "# Create clock hands\n",
    "second_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "minute_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "hour_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "\n",
    "# Update one hand to a given value.\n",
    "def update_hand(hand, position, steps):\n",
    "    \"\"\"Move a hand to a position.\n",
    "    \n",
    "    Arugments:\n",
    "        hand:     A plot object for the hand.\n",
    "        position: The numeric position, like 55 or 3.\n",
    "        steps:    The number of steps the hand takes, like 12, 24, or 60.\n",
    "    \"\"\"\n",
    "    angle = np.pi/2 - position * (2*np.pi / steps)\n",
    "    \n",
    "    hand.set_xdata([0, np.cos(angle)])\n",
    "    hand.set_ydata([0, np.sin(angle)])\n",
    "\n",
    "# Update all three hands for the current time.\n",
    "def update_hands():\n",
    "    \"\"\"Set each hand to the current time.\"\"\"\n",
    "    now = time.localtime()\n",
    "    \n",
    "    update_hand(second_hand, now.tm_sec, 60)\n",
    "    update_hand(minute_hand, now.tm_min, 60)\n",
    "    update_hand(hour_hand, now.tm_hour, 12)\n",
    "    \n",
    "    return [second_hand, minute_hand, hour_hand]\n",
    "\n",
    "def init():\n",
    "    \"\"\"Set up the clock animation.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "def animate(i):\n",
    "    \"\"\"Update the clock hands to current time.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "ani = animation.FuncAnimation(fig, animate, init_func=init, interval=200, blit=True)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making It Look Nicer\n",
    "\n",
    "Firstly I can correct the aspect ratio so the clock is a circle, and remove the axis ticks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "ax.set_aspect('equal')\n",
    "ax.set_xticks([])\n",
    "ax.set_yticks([])\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "# Create clock hands\n",
    "second_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "minute_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "hour_hand = plt.plot([0, 1], [0, 0])[0]\n",
    "\n",
    "# Update one hand to a given value.\n",
    "def update_hand(hand, position, steps):\n",
    "    \"\"\"Move a hand to a position.\n",
    "    \n",
    "    Arugments:\n",
    "        hand:     A plot object for the hand.\n",
    "        position: The numeric position, like 55 or 3.\n",
    "        steps:    The number of steps the hand takes, like 12, 24, or 60.\n",
    "    \"\"\"\n",
    "    angle = np.pi/2 - position * (2*np.pi / steps)\n",
    "    \n",
    "    hand.set_xdata([0, np.cos(angle)])\n",
    "    hand.set_ydata([0, np.sin(angle)])\n",
    "\n",
    "# Update all three hands for the current time.\n",
    "def update_hands():\n",
    "    \"\"\"Set each hand to the current time.\"\"\"\n",
    "    now = time.localtime()\n",
    "    \n",
    "    update_hand(second_hand, now.tm_sec, 60)\n",
    "    update_hand(minute_hand, now.tm_min, 60)\n",
    "    update_hand(hour_hand, now.tm_hour, 12)\n",
    "    \n",
    "    return [second_hand, minute_hand, hour_hand]\n",
    "\n",
    "def init():\n",
    "    \"\"\"Set up the clock animation.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "def animate(i):\n",
    "    \"\"\"Update the clock hands to current time.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "ani = animation.FuncAnimation(fig, animate, init_func=init, interval=200, blit=True)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next I can make the hands look different. The second hand on a clock is long and thin. The minute hand is medium-length and thick. The hour hand is short and thick. I will define three new variables for the hand lengths. I will also have to modify `update_hand` to take a hand length. I'll also change the hand colours as Ryan asked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "ax.set_aspect('equal')\n",
    "ax.set_xticks([])\n",
    "ax.set_yticks([])\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "# Create clock hands\n",
    "second_length = 1\n",
    "minute_length = 0.8\n",
    "hour_length = 0.6\n",
    "\n",
    "second_hand = plt.plot([0, 1], [0, 0], color='red')[0]\n",
    "minute_hand = plt.plot([0, 1], [0, 0], color='black', linewidth=5)[0]\n",
    "hour_hand = plt.plot([0, 1], [0, 0], color='black', linewidth=5)[0]\n",
    "\n",
    "# Update one hand to a given value.\n",
    "def update_hand(hand, position, steps, length):\n",
    "    \"\"\"Move a hand to a position.\n",
    "    \n",
    "    Arugments:\n",
    "        hand:     A plot object for the hand.\n",
    "        position: The numeric position, like 55 or 3.\n",
    "        steps:    The number of steps the hand takes, like 12, 24, or 60.\n",
    "        length:   The length of the hand.\n",
    "    \"\"\"\n",
    "    angle = np.pi/2 - position * (2*np.pi / steps)\n",
    "    \n",
    "    hand.set_xdata([0, length * np.cos(angle)])\n",
    "    hand.set_ydata([0, length * np.sin(angle)])\n",
    "\n",
    "# Update all three hands for the current time.\n",
    "def update_hands():\n",
    "    \"\"\"Set each hand to the current time.\"\"\"\n",
    "    now = time.localtime()\n",
    "    \n",
    "    update_hand(second_hand, now.tm_sec, 60, second_length)\n",
    "    update_hand(minute_hand, now.tm_min, 60, minute_length)\n",
    "    update_hand(hour_hand, now.tm_hour, 12, hour_length)\n",
    "    \n",
    "    return [second_hand, minute_hand, hour_hand]\n",
    "\n",
    "def init():\n",
    "    \"\"\"Set up the clock animation.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "def animate(i):\n",
    "    \"\"\"Update the clock hands to current time.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "ani = animation.FuncAnimation(fig, animate, init_func=init, interval=200, blit=True)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, I can add numbers around the face."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "ax.set_aspect('equal')\n",
    "ax.set_xticks([])\n",
    "ax.set_yticks([])\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "# Add numbers around the clock\n",
    "for i in range(1, 13):\n",
    "    angle = np.pi/2 - i * (2*np.pi / 12)\n",
    "    plt.text(np.cos(angle), np.sin(angle), i)\n",
    "\n",
    "# Create clock hands\n",
    "second_length = 1\n",
    "minute_length = 0.8\n",
    "hour_length = 0.6\n",
    "\n",
    "second_hand = plt.plot([0, 1], [0, 0], color='red')[0]\n",
    "minute_hand = plt.plot([0, 1], [0, 0], color='black', linewidth=5)[0]\n",
    "hour_hand = plt.plot([0, 1], [0, 0], color='black', linewidth=5)[0]\n",
    "\n",
    "# Update one hand to a given value.\n",
    "def update_hand(hand, position, steps, length):\n",
    "    \"\"\"Move a hand to a position.\n",
    "    \n",
    "    Arugments:\n",
    "        hand:     A plot object for the hand.\n",
    "        position: The numeric position, like 55 or 3.\n",
    "        steps:    The number of steps the hand takes, like 12, 24, or 60.\n",
    "        length:   The length of the hand.\n",
    "    \"\"\"\n",
    "    angle = np.pi/2 - position * (2*np.pi / steps)\n",
    "    \n",
    "    hand.set_xdata([0, length * np.cos(angle)])\n",
    "    hand.set_ydata([0, length * np.sin(angle)])\n",
    "\n",
    "# Update all three hands for the current time.\n",
    "def update_hands():\n",
    "    \"\"\"Set each hand to the current time.\"\"\"\n",
    "    now = time.localtime()\n",
    "    \n",
    "    update_hand(second_hand, now.tm_sec, 60, second_length)\n",
    "    update_hand(minute_hand, now.tm_min, 60, minute_length)\n",
    "    update_hand(hour_hand, now.tm_hour, 12, hour_length)\n",
    "    \n",
    "    return [second_hand, minute_hand, hour_hand]\n",
    "\n",
    "def init():\n",
    "    \"\"\"Set up the clock animation.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "def animate(i):\n",
    "    \"\"\"Update the clock hands to current time.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "ani = animation.FuncAnimation(fig, animate, init_func=init, interval=200, blit=True)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's pretty good, but I can clearly improve it. I'll centre the numbers and move them inside the circle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "ax.set_aspect('equal')\n",
    "ax.set_xticks([])\n",
    "ax.set_yticks([])\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "# Add numbers around the clock\n",
    "for i in range(1, 13):\n",
    "    angle = np.pi/2 - i * (2*np.pi / 12)\n",
    "    plt.text(0.9 * np.cos(angle), 0.9 * np.sin(angle), i,\n",
    "             horizontalalignment='center', verticalalignment='center')\n",
    "\n",
    "# Create clock hands\n",
    "second_length = 1\n",
    "minute_length = 0.8\n",
    "hour_length = 0.6\n",
    "\n",
    "second_hand = plt.plot([0, 1], [0, 0], color='red')[0]\n",
    "minute_hand = plt.plot([0, 1], [0, 0], color='black', linewidth=5)[0]\n",
    "hour_hand = plt.plot([0, 1], [0, 0], color='black', linewidth=5)[0]\n",
    "\n",
    "# Update one hand to a given value.\n",
    "def update_hand(hand, position, steps, length):\n",
    "    \"\"\"Move a hand to a position.\n",
    "    \n",
    "    Arugments:\n",
    "        hand:     A plot object for the hand.\n",
    "        position: The numeric position, like 55 or 3.\n",
    "        steps:    The number of steps the hand takes, like 12, 24, or 60.\n",
    "        length:   The length of the hand.\n",
    "    \"\"\"\n",
    "    angle = np.pi/2 - position * (2*np.pi / steps)\n",
    "    \n",
    "    hand.set_xdata([0, length * np.cos(angle)])\n",
    "    hand.set_ydata([0, length * np.sin(angle)])\n",
    "\n",
    "# Update all three hands for the current time.\n",
    "def update_hands():\n",
    "    \"\"\"Set each hand to the current time.\"\"\"\n",
    "    now = time.localtime()\n",
    "    \n",
    "    update_hand(second_hand, now.tm_sec, 60, second_length)\n",
    "    update_hand(minute_hand, now.tm_min, 60, minute_length)\n",
    "    update_hand(hour_hand, now.tm_hour, 12, hour_length)\n",
    "    \n",
    "    return [second_hand, minute_hand, hour_hand]\n",
    "\n",
    "def init():\n",
    "    \"\"\"Set up the clock animation.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "def animate(i):\n",
    "    \"\"\"Update the clock hands to current time.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "ani = animation.FuncAnimation(fig, animate, init_func=init, interval=200, blit=True)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Improving the Hands\n",
    "\n",
    "A real clock's hour hand doesn't make a big jump every hour. Instead, it moves gradually every moment. I can change the way I calculate the hour to include the portion of the way through the current hour."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Configure axes\n",
    "ax.set_xlim(-1.05, 1.05)\n",
    "ax.set_ylim(-1.05, 1.05)\n",
    "ax.set_aspect('equal')\n",
    "ax.set_xticks([])\n",
    "ax.set_yticks([])\n",
    "\n",
    "# Create clock boundary\n",
    "circle = plt.Circle((0, 0), 1, color='black', fill=False)\n",
    "ax.add_artist(circle)\n",
    "\n",
    "# Add numbers around the clock\n",
    "for i in range(1, 13):\n",
    "    angle = np.pi/2 - i * (2*np.pi / 12)\n",
    "    plt.text(0.9 * np.cos(angle), 0.9 * np.sin(angle), i,\n",
    "             horizontalalignment='center', verticalalignment='center')\n",
    "\n",
    "# Create clock hands\n",
    "second_length = 1\n",
    "minute_length = 0.8\n",
    "hour_length = 0.6\n",
    "\n",
    "second_hand = plt.plot([0, 1], [0, 0], color='red')[0]\n",
    "minute_hand = plt.plot([0, 1], [0, 0], color='black', linewidth=5)[0]\n",
    "hour_hand = plt.plot([0, 1], [0, 0], color='black', linewidth=5)[0]\n",
    "\n",
    "# Update one hand to a given value.\n",
    "def update_hand(hand, position, steps, length):\n",
    "    \"\"\"Move a hand to a position.\n",
    "    \n",
    "    Arugments:\n",
    "        hand:     A plot object for the hand.\n",
    "        position: The numeric position, like 55 or 3.\n",
    "        steps:    The number of steps the hand takes, like 12, 24, or 60.\n",
    "        length:   The length of the hand.\n",
    "    \"\"\"\n",
    "    angle = np.pi/2 - position * (2*np.pi / steps)\n",
    "    \n",
    "    hand.set_xdata([0, length * np.cos(angle)])\n",
    "    hand.set_ydata([0, length * np.sin(angle)])\n",
    "\n",
    "# Update all three hands for the current time.\n",
    "def update_hands():\n",
    "    \"\"\"Set each hand to the current time.\"\"\"\n",
    "    now = time.localtime()\n",
    "    \n",
    "    # Compute time values including fractions.\n",
    "    hour = now.tm_hour + now.tm_min/60 + now.tm_sec/3600\n",
    "    minute = now.tm_min + now.tm_sec/60\n",
    "    \n",
    "    update_hand(second_hand, now.tm_sec, 60, second_length)\n",
    "    update_hand(minute_hand, minute, 60, minute_length)\n",
    "    update_hand(hour_hand, hour, 12, hour_length)\n",
    "    \n",
    "    return [second_hand, minute_hand, hour_hand]\n",
    "\n",
    "def init():\n",
    "    \"\"\"Set up the clock animation.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "def animate(i):\n",
    "    \"\"\"Update the clock hands to current time.\"\"\"\n",
    "    return [update_hands()]\n",
    "\n",
    "ani = animation.FuncAnimation(fig, animate, init_func=init, interval=200, blit=True)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's a nice looking clock."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Things to Improve\n",
    "\n",
    "* Ideally my `update_hand` function wouldn't take a `length` argument. Instead, I would to set each hand's length once at the start.\n",
    "* The calculation for `angle` inside the `update_hand` function could be its own function. Then I could use it to put numbers around the clock face."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}