matplotlib_animation.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The following is based on the tutorial at [Pythonic Perambulations](http://jakevdp.github.io/blog/2012/08/18/matplotlib-animation-tutorial/). Note that animations don't appear to work in IPython Notebook, and that saving an animation to a file is also apparently broken."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Animated Sine Wave"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"\"\"\n",
      "Matplotlib Animation Example\n",
      "\n",
      "author: Jake Vanderplas\n",
      "email: vanderplas@astro.washington.edu\n",
      "website: http://jakevdp.github.com\n",
      "license: BSD\n",
      "Please feel free to use and modify this, but keep the above information. Thanks!\n",
      "\"\"\"\n",
      "import numpy as np\n",
      "from matplotlib import pyplot as plt\n",
      "from matplotlib import animation\n",
      "\n",
      "# First set up the figure, the axis and the plot element we want to animate.\n",
      "fig = plt.figure()\n",
      "ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))\n",
      "line, = ax.plot([], [], lw=2)\n",
      "\n",
      "# Initialisation function: plot the background of each frame.\n",
      "def init():\n",
      "    line.set_data([], [])\n",
      "    return line,\n",
      "\n",
      "# Animation function. This gets called sequentially.\n",
      "def animate(i):\n",
      "    x = np.linspace(0, 2, 1000)\n",
      "    y = np.sin(2 * np.pi * (x - 0.01 * i))\n",
      "    line.set_data(x, y)\n",
      "    return line,\n",
      "\n",
      "# Call the animator. blit=True is used to only re-draw the changed parts.\n",
      "anim = animation.FuncAnimation(fig, animate, init_func=init,\n",
      "                               frames=200, interval=20, blit=True)\n",
      "\n",
      "# anim.save(\"basic_animation.mp4\", fps=30, extra_args=[\"-vcodec\", \"libx264\"])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "NameError",
       "evalue": "name 'display_animation' is not defined",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
        "\u001b[1;32m<ipython-input-10-cb1b0ebf1bbb>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     35\u001b[0m \u001b[1;31m# anim.save(\"basic_animation.mp4\", fps=30, extra_args=[\"-vcodec\", \"libx264\"])\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     36\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 37\u001b[1;33m \u001b[0mdisplay_animation\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[1;31mNameError\u001b[0m: name 'display_animation' is not defined"
       ]
      },
      {
       "metadata": {},
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEACAYAAAC08h1NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngg==\n",
       "text": [
        "<matplotlib.figure.Figure at 0x7f9e6c72c8d0>"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To begin with, `numpy` and `matplotlib` are imported. Then a plot is set up:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fig = plt.figure()\n",
      "ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))\n",
      "line, = ax.plot([], [], lw=2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEACAYAAAC08h1NAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngg==\n",
       "text": [
        "<matplotlib.figure.Figure at 0x7f44094f2c50>"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "When setting up the axes, note that the limits can be defined; so far we have been be automatically set by `matplotlib`. Not also that the plot is provided with empty lists for $x$ and $y$ values, but that the plot is allocated to the variable `line`. This will be used later to add data.\n",
      "\n",
      "Next, functions are created to actually do the animation."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def init():\n",
      "    line.set_data([], [])\n",
      "    return line,"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "All this does is set the data in the `line` object to nothing. This empty object is returned so that the animator knows which objects on the plot need to be updated for each frame.\n",
      "\n",
      "The next function is the `animate` function."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def animate(i):\n",
      "    x = np.linspace(0, 2, 1000)\n",
      "    y = np.sin(2 * np.pi * (x - 0.01*i))\n",
      "    line.set_data(x, y)\n",
      "    return line,"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This contains the function to be animated and is dependent on the frame number `i`. Again, the modified plot object, `line`, is returned to tell the animator what part of the plot to change.\n",
      "\n",
      "The actual animation is carried out by this function:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "anim = animation.FuncAnimation(fig, animate, init_func=init, \n",
      "                               frames=100, interval=20, blit=True)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The object is assigned to the `anim` variable so that it persists. 100 frames are set and the `interval` keyword determines the delay in ms between each frame. \n",
      "\n",
      "The `blit` keyword tells the animator to only re-draw the changed elements of the plot.\n",
      "\n",
      "Finally, the plot can be saved as a video, although this isn't currently working on my installation."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "anim.save(\"basic_animation.mp4\", fps=30, extra_args=[\"-vcodec\", \"libx264\"]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Double Pendulum"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python is actually fast enough to compute and animate the dynamics of a double pendulum in real time."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"\"\"\n",
      "General Numerical Solver for the 1D Time-Dependent Schrodinger's equation.\n",
      "\n",
      "adapted from code at http://matplotlib.sourceforge.net/examples/animation/double_pendulum_animated.py\n",
      "\n",
      "Double pendulum formula translated from the C code at\n",
      "http://www.physics.usyd.edu.au/~wheat/dpend_html/solve_dpend.c\n",
      "\n",
      "author: Jake Vanderplas\n",
      "email: vanderplas@astro.washington.edu\n",
      "website: http://jakevdp.github.com\n",
      "license: BSD\n",
      "Please feel free to use and modify this, but keep the above information. Thanks!\n",
      "\"\"\"\n",
      "\n",
      "from numpy import sin, cos\n",
      "import numpy as np\n",
      "import matplotlib.pyplot as plt\n",
      "import scipy.integrate as integrate\n",
      "import matplotlib.animation as animation\n",
      "\n",
      "class DoublePendulum:\n",
      "    \"\"\"Double Pendulum Class\n",
      "\n",
      "    init_state is [theta1, omega1, theta2, omega2] in degrees,\n",
      "    where theta1, omega1 is the angular position and velocity of the first\n",
      "    pendulum arm, and theta2, omega2 is that of the second pendulum arm\n",
      "    \"\"\"\n",
      "    def __init__(self,\n",
      "                 init_state = [120, 0, -20, 0],\n",
      "                 L1=1.0,  # length of pendulum 1 in m\n",
      "                 L2=1.0,  # length of pendulum 2 in m\n",
      "                 M1=1.0,  # mass of pendulum 1 in kg\n",
      "                 M2=1.0,  # mass of pendulum 2 in kg\n",
      "                 G=9.8,  # acceleration due to gravity, in m/s^2\n",
      "                 origin=(0, 0)): \n",
      "        self.init_state = np.asarray(init_state, dtype='float')\n",
      "        self.params = (L1, L2, M1, M2, G)\n",
      "        self.origin = origin\n",
      "        self.time_elapsed = 0\n",
      "\n",
      "        self.state = self.init_state * np.pi / 180.\n",
      "    \n",
      "    def position(self):\n",
      "        \"\"\"compute the current x,y positions of the pendulum arms\"\"\"\n",
      "        (L1, L2, M1, M2, G) = self.params\n",
      "\n",
      "        x = np.cumsum([self.origin[0],\n",
      "                       L1 * sin(self.state[0]),\n",
      "                       L2 * sin(self.state[2])])\n",
      "        y = np.cumsum([self.origin[1],\n",
      "                       -L1 * cos(self.state[0]),\n",
      "                       -L2 * cos(self.state[2])])\n",
      "        return (x, y)\n",
      "\n",
      "    def energy(self):\n",
      "        \"\"\"compute the energy of the current state\"\"\"\n",
      "        (L1, L2, M1, M2, G) = self.params\n",
      "\n",
      "        x = np.cumsum([L1 * sin(self.state[0]),\n",
      "                       L2 * sin(self.state[2])])\n",
      "        y = np.cumsum([-L1 * cos(self.state[0]),\n",
      "                       -L2 * cos(self.state[2])])\n",
      "        vx = np.cumsum([L1 * self.state[1] * cos(self.state[0]),\n",
      "                        L2 * self.state[3] * cos(self.state[2])])\n",
      "        vy = np.cumsum([L1 * self.state[1] * sin(self.state[0]),\n",
      "                        L2 * self.state[3] * sin(self.state[2])])\n",
      "\n",
      "        U = G * (M1 * y[0] + M2 * y[1])\n",
      "        K = 0.5 * (M1 * np.dot(vx, vx) + M2 * np.dot(vy, vy))\n",
      "\n",
      "        return U + K\n",
      "\n",
      "    def dstate_dt(self, state, t):\n",
      "        \"\"\"compute the derivative of the given state\"\"\"\n",
      "        (M1, M2, L1, L2, G) = self.params\n",
      "\n",
      "        dydx = np.zeros_like(state)\n",
      "        dydx[0] = state[1]\n",
      "        dydx[2] = state[3]\n",
      "\n",
      "        cos_delta = cos(state[2] - state[0])\n",
      "        sin_delta = sin(state[2] - state[0])\n",
      "\n",
      "        den1 = (M1 + M2) * L1 - M2 * L1 * cos_delta * cos_delta\n",
      "        dydx[1] = (M2 * L1 * state[1] * state[1] * sin_delta * cos_delta\n",
      "                   + M2 * G * sin(state[2]) * cos_delta\n",
      "                   + M2 * L2 * state[3] * state[3] * sin_delta\n",
      "                   - (M1 + M2) * G * sin(state[0])) / den1\n",
      "\n",
      "        den2 = (L2 / L1) * den1\n",
      "        dydx[3] = (-M2 * L2 * state[3] * state[3] * sin_delta * cos_delta\n",
      "                   + (M1 + M2) * G * sin(state[0]) * cos_delta\n",
      "                   - (M1 + M2) * L1 * state[1] * state[1] * sin_delta\n",
      "                   - (M1 + M2) * G * sin(state[2])) / den2\n",
      "        \n",
      "        return dydx\n",
      "\n",
      "    def step(self, dt):\n",
      "        \"\"\"execute one time step of length dt and update state\"\"\"\n",
      "        self.state = integrate.odeint(self.dstate_dt, self.state, [0, dt])[1]\n",
      "        self.time_elapsed += dt\n",
      "\n",
      "#------------------------------------------------------------\n",
      "# set up initial state and global variables\n",
      "pendulum = DoublePendulum([180., 0.0, -20., 0.0])\n",
      "dt = 1./30 # 30 fps\n",
      "\n",
      "#------------------------------------------------------------\n",
      "# set up figure and animation\n",
      "fig = plt.figure()\n",
      "ax = fig.add_subplot(111, aspect='equal', autoscale_on=False,\n",
      "                     xlim=(-2, 2), ylim=(-2, 2))\n",
      "ax.grid()\n",
      "\n",
      "line, = ax.plot([], [], 'o-', lw=2)\n",
      "time_text = ax.text(0.02, 0.95, '', transform=ax.transAxes)\n",
      "energy_text = ax.text(0.02, 0.90, '', transform=ax.transAxes)\n",
      "\n",
      "def init():\n",
      "    \"\"\"initialize animation\"\"\"\n",
      "    line.set_data([], [])\n",
      "    time_text.set_text('')\n",
      "    energy_text.set_text('')\n",
      "    return line, time_text, energy_text\n",
      "\n",
      "def animate(i):\n",
      "    \"\"\"perform animation step\"\"\"\n",
      "    global pendulum, dt\n",
      "    pendulum.step(dt)\n",
      "    \n",
      "    line.set_data(*pendulum.position())\n",
      "    time_text.set_text('time = %.1f' % pendulum.time_elapsed)\n",
      "    energy_text.set_text('energy = %.3f J' % pendulum.energy())\n",
      "    return line, time_text, energy_text\n",
      "\n",
      "# choose the interval based on dt and the time to animate one step\n",
      "from time import time\n",
      "t0 = time()\n",
      "animate(0)\n",
      "t1 = time()\n",
      "interval = 1000 * dt - (t1 - t0)\n",
      "\n",
      "ani = animation.FuncAnimation(fig, animate, frames=300,\n",
      "                              interval=interval, blit=True, init_func=init)\n",
      "\n",
      "# save the animation as an mp4.  This requires ffmpeg or mencoder to be\n",
      "# installed.  The extra_args ensure that the x264 codec is used, so that\n",
      "# the video can be embedded in html5.  You may need to adjust this for\n",
      "# your system: for more information, see\n",
      "# http://matplotlib.sourceforge.net/api/animation_api.html\n",
      "#ani.save('double_pendulum.mp4', fps=30, extra_args=['-vcodec', 'libx264'])\n",
      "\n",
      "plt.show()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "This example uses a class to store the state of the double pendulum as well as containing methods to compute its dynamics."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Particles in a Box"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The example below animates a box of particles. The particles collide elastically and are subject to gravity."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "\"\"\"\n",
      "Animation of Elastic collisions with Gravity\n",
      "\n",
      "author: Jake Vanderplas\n",
      "email: vanderplas@astro.washington.edu\n",
      "website: http://jakevdp.github.com\n",
      "license: BSD\n",
      "Please feel free to use and modify this, but keep the above information. Thanks!\n",
      "\"\"\"\n",
      "import numpy as np\n",
      "from scipy.spatial.distance import pdist, squareform\n",
      "\n",
      "import matplotlib.pyplot as plt\n",
      "import scipy.integrate as integrate\n",
      "import matplotlib.animation as animation\n",
      "\n",
      "class ParticleBox:\n",
      "    \"\"\"Orbits class\n",
      "    \n",
      "    init_state is an [N x 4] array, where N is the number of particles:\n",
      "       [[x1, y1, vx1, vy1],\n",
      "        [x2, y2, vx2, vy2],\n",
      "        ...               ]\n",
      "\n",
      "    bounds is the size of the box: [xmin, xmax, ymin, ymax]\n",
      "    \"\"\"\n",
      "    def __init__(self,\n",
      "                 init_state = [[1, 0, 0, -1],\n",
      "                               [-0.5, 0.5, 0.5, 0.5],\n",
      "                               [-0.5, -0.5, -0.5, 0.5]],\n",
      "                 bounds = [-2, 2, -2, 2],\n",
      "                 size = 0.04,\n",
      "                 M = 0.05,\n",
      "                 G = 9.8):\n",
      "        self.init_state = np.asarray(init_state, dtype=float)\n",
      "        self.M = M * np.ones(self.init_state.shape[0])\n",
      "        self.size = size\n",
      "        self.state = self.init_state.copy()\n",
      "        self.time_elapsed = 0\n",
      "        self.bounds = bounds\n",
      "        self.G = G\n",
      "\n",
      "    def step(self, dt):\n",
      "        \"\"\"step once by dt seconds\"\"\"\n",
      "        self.time_elapsed += dt\n",
      "        \n",
      "        # update positions\n",
      "        self.state[:, :2] += dt * self.state[:, 2:]\n",
      "\n",
      "        # find pairs of particles undergoing a collision\n",
      "        D = squareform(pdist(self.state[:, :2]))\n",
      "        ind1, ind2 = np.where(D < 2 * self.size)\n",
      "        unique = (ind1 < ind2)\n",
      "        ind1 = ind1[unique]\n",
      "        ind2 = ind2[unique]\n",
      "\n",
      "        # update velocities of colliding pairs\n",
      "        for i1, i2 in zip(ind1, ind2):\n",
      "            # mass\n",
      "            m1 = self.M[i1]\n",
      "            m2 = self.M[i2]\n",
      "\n",
      "            # location vector\n",
      "            r1 = self.state[i1, :2]\n",
      "            r2 = self.state[i2, :2]\n",
      "\n",
      "            # velocity vector\n",
      "            v1 = self.state[i1, 2:]\n",
      "            v2 = self.state[i2, 2:]\n",
      "\n",
      "            # relative location & velocity vectors\n",
      "            r_rel = r1 - r2\n",
      "            v_rel = v1 - v2\n",
      "\n",
      "            # momentum vector of the center of mass\n",
      "            v_cm = (m1 * v1 + m2 * v2) / (m1 + m2)\n",
      "\n",
      "            # collisions of spheres reflect v_rel over r_rel\n",
      "            rr_rel = np.dot(r_rel, r_rel)\n",
      "            vr_rel = np.dot(v_rel, r_rel)\n",
      "            v_rel = 2 * r_rel * vr_rel / rr_rel - v_rel\n",
      "\n",
      "            # assign new velocities\n",
      "            self.state[i1, 2:] = v_cm + v_rel * m2 / (m1 + m2)\n",
      "            self.state[i2, 2:] = v_cm - v_rel * m1 / (m1 + m2) \n",
      "\n",
      "        # check for crossing boundary\n",
      "        crossed_x1 = (self.state[:, 0] < self.bounds[0] + self.size)\n",
      "        crossed_x2 = (self.state[:, 0] > self.bounds[1] - self.size)\n",
      "        crossed_y1 = (self.state[:, 1] < self.bounds[2] + self.size)\n",
      "        crossed_y2 = (self.state[:, 1] > self.bounds[3] - self.size)\n",
      "\n",
      "        self.state[crossed_x1, 0] = self.bounds[0] + self.size\n",
      "        self.state[crossed_x2, 0] = self.bounds[1] - self.size\n",
      "\n",
      "        self.state[crossed_y1, 1] = self.bounds[2] + self.size\n",
      "        self.state[crossed_y2, 1] = self.bounds[3] - self.size\n",
      "\n",
      "        self.state[crossed_x1 | crossed_x2, 2] *= -1\n",
      "        self.state[crossed_y1 | crossed_y2, 3] *= -1\n",
      "\n",
      "        # add gravity\n",
      "        self.state[:, 3] -= self.M * self.G * dt\n",
      "\n",
      "\n",
      "#------------------------------------------------------------\n",
      "# set up initial state\n",
      "np.random.seed(0)\n",
      "init_state = -0.5 + np.random.random((50, 4))\n",
      "init_state[:, :2] *= 3.9\n",
      "\n",
      "box = ParticleBox(init_state, size=0.04)\n",
      "dt = 1. / 30 # 30fps\n",
      "\n",
      "\n",
      "#------------------------------------------------------------\n",
      "# set up figure and animation\n",
      "fig = plt.figure()\n",
      "fig.subplots_adjust(left=0, right=1, bottom=0, top=1)\n",
      "ax = fig.add_subplot(111, aspect='equal', autoscale_on=False,\n",
      "                     xlim=(-3.2, 3.2), ylim=(-2.4, 2.4))\n",
      "\n",
      "# particles holds the locations of the particles\n",
      "particles, = ax.plot([], [], 'bo', ms=6)\n",
      "\n",
      "# rect is the box edge\n",
      "rect = plt.Rectangle(box.bounds[::2],\n",
      "                     box.bounds[1] - box.bounds[0],\n",
      "                     box.bounds[3] - box.bounds[2],\n",
      "                     ec='none', lw=2, fc='none')\n",
      "ax.add_patch(rect)\n",
      "\n",
      "def init():\n",
      "    \"\"\"initialize animation\"\"\"\n",
      "    global box, rect\n",
      "    particles.set_data([], [])\n",
      "    rect.set_edgecolor('none')\n",
      "    return particles, rect\n",
      "\n",
      "def animate(i):\n",
      "    \"\"\"perform animation step\"\"\"\n",
      "    global box, rect, dt, ax, fig\n",
      "    box.step(dt)\n",
      "\n",
      "    ms = int(fig.dpi * 2 * box.size * fig.get_figwidth()\n",
      "             / np.diff(ax.get_xbound())[0])\n",
      "    \n",
      "    # update pieces of the animation\n",
      "    rect.set_edgecolor('k')\n",
      "    particles.set_data(box.state[:, 0], box.state[:, 1])\n",
      "    particles.set_markersize(ms)\n",
      "    return particles, rect\n",
      "\n",
      "ani = animation.FuncAnimation(fig, animate, frames=600,\n",
      "                              interval=10, blit=True, init_func=init)\n",
      "\n",
      "\n",
      "# save the animation as an mp4.  This requires ffmpeg or mencoder to be\n",
      "# installed.  The extra_args ensure that the x264 codec is used, so that\n",
      "# the video can be embedded in html5.  You may need to adjust this for\n",
      "# your system: for more information, see\n",
      "# http://matplotlib.sourceforge.net/api/animation_api.html\n",
      "#ani.save('particle_box.mp4', fps=30, extra_args=['-vcodec', 'libx264'])\n",
      "\n",
      "plt.show()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "There are a few interesting aspects of this code. In particular, the method used to find colliding pairs:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "D = squareform(pdist(self.state[:, :2]))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The documentation for `pdist` is shown below:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from scipy.spatial.distance import pdist, squareform\n",
      "help(pdist)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Help on function pdist in module scipy.spatial.distance:\n",
        "\n",
        "pdist(X, metric='euclidean', p=2, w=None, V=None, VI=None)\n",
        "    Pairwise distances between observations in n-dimensional space.\n",
        "    \n",
        "    The following are common calling conventions.\n",
        "    \n",
        "    1. ``Y = pdist(X, 'euclidean')``\n",
        "    \n",
        "       Computes the distance between m points using Euclidean distance\n",
        "       (2-norm) as the distance metric between the points. The points\n",
        "       are arranged as m n-dimensional row vectors in the matrix X.\n",
        "    \n",
        "    2. ``Y = pdist(X, 'minkowski', p)``\n",
        "    \n",
        "       Computes the distances using the Minkowski distance\n",
        "       :math:`||u-v||_p` (p-norm) where :math:`p \\geq 1`.\n",
        "    \n",
        "    3. ``Y = pdist(X, 'cityblock')``\n",
        "    \n",
        "       Computes the city block or Manhattan distance between the\n",
        "       points.\n",
        "    \n",
        "    4. ``Y = pdist(X, 'seuclidean', V=None)``\n",
        "    \n",
        "       Computes the standardized Euclidean distance. The standardized\n",
        "       Euclidean distance between two n-vectors ``u`` and ``v`` is\n",
        "    \n",
        "       .. math::\n",
        "    \n",
        "          \\sqrt{\\sum {(u_i-v_i)^2 / V[x_i]}}\n",
        "    \n",
        "    \n",
        "       V is the variance vector; V[i] is the variance computed over all\n",
        "       the i'th components of the points.  If not passed, it is\n",
        "       automatically computed.\n",
        "    \n",
        "    5. ``Y = pdist(X, 'sqeuclidean')``\n",
        "    \n",
        "       Computes the squared Euclidean distance :math:`||u-v||_2^2` between\n",
        "       the vectors.\n",
        "    \n",
        "    6. ``Y = pdist(X, 'cosine')``\n",
        "    \n",
        "       Computes the cosine distance between vectors u and v,\n",
        "    \n",
        "       .. math::\n",
        "    \n",
        "          1 - \\frac{u \\cdot v}\n",
        "                   {{||u||}_2 {||v||}_2}\n",
        "    \n",
        "       where :math:`||*||_2` is the 2-norm of its argument ``*``, and\n",
        "       :math:`u \\cdot v` is the dot product of ``u`` and ``v``.\n",
        "    \n",
        "    7. ``Y = pdist(X, 'correlation')``\n",
        "    \n",
        "       Computes the correlation distance between vectors u and v. This is\n",
        "    \n",
        "       .. math::\n",
        "    \n",
        "          1 - \\frac{(u - \\bar{u}) \\cdot (v - \\bar{v})}\n",
        "                   {{||(u - \\bar{u})||}_2 {||(v - \\bar{v})||}_2}\n",
        "    \n",
        "       where :math:`\\bar{v}` is the mean of the elements of vector v,\n",
        "       and :math:`x \\cdot y` is the dot product of :math:`x` and :math:`y`.\n",
        "    \n",
        "    8. ``Y = pdist(X, 'hamming')``\n",
        "    \n",
        "       Computes the normalized Hamming distance, or the proportion of\n",
        "       those vector elements between two n-vectors ``u`` and ``v``\n",
        "       which disagree. To save memory, the matrix ``X`` can be of type\n",
        "       boolean.\n",
        "    \n",
        "    9. ``Y = pdist(X, 'jaccard')``\n",
        "    \n",
        "       Computes the Jaccard distance between the points. Given two\n",
        "       vectors, ``u`` and ``v``, the Jaccard distance is the\n",
        "       proportion of those elements ``u[i]`` and ``v[i]`` that\n",
        "       disagree where at least one of them is non-zero.\n",
        "    \n",
        "    10. ``Y = pdist(X, 'chebyshev')``\n",
        "    \n",
        "       Computes the Chebyshev distance between the points. The\n",
        "       Chebyshev distance between two n-vectors ``u`` and ``v`` is the\n",
        "       maximum norm-1 distance between their respective elements. More\n",
        "       precisely, the distance is given by\n",
        "    \n",
        "       .. math::\n",
        "    \n",
        "          d(u,v) = \\max_i {|u_i-v_i|}\n",
        "    \n",
        "    11. ``Y = pdist(X, 'canberra')``\n",
        "    \n",
        "       Computes the Canberra distance between the points. The\n",
        "       Canberra distance between two points ``u`` and ``v`` is\n",
        "    \n",
        "       .. math::\n",
        "    \n",
        "         d(u,v) = \\sum_i \\frac{|u_i-v_i|}\n",
        "                              {|u_i|+|v_i|}\n",
        "    \n",
        "    \n",
        "    12. ``Y = pdist(X, 'braycurtis')``\n",
        "    \n",
        "       Computes the Bray-Curtis distance between the points. The\n",
        "       Bray-Curtis distance between two points ``u`` and ``v`` is\n",
        "    \n",
        "    \n",
        "       .. math::\n",
        "    \n",
        "            d(u,v) = \\frac{\\sum_i {u_i-v_i}}\n",
        "                          {\\sum_i {u_i+v_i}}\n",
        "    \n",
        "    13. ``Y = pdist(X, 'mahalanobis', VI=None)``\n",
        "    \n",
        "       Computes the Mahalanobis distance between the points. The\n",
        "       Mahalanobis distance between two points ``u`` and ``v`` is\n",
        "       :math:`(u-v)(1/V)(u-v)^T` where :math:`(1/V)` (the ``VI``\n",
        "       variable) is the inverse covariance. If ``VI`` is not None,\n",
        "       ``VI`` will be used as the inverse covariance matrix.\n",
        "    \n",
        "    14. ``Y = pdist(X, 'yule')``\n",
        "    \n",
        "       Computes the Yule distance between each pair of boolean\n",
        "       vectors. (see yule function documentation)\n",
        "    \n",
        "    15. ``Y = pdist(X, 'matching')``\n",
        "    \n",
        "       Computes the matching distance between each pair of boolean\n",
        "       vectors. (see matching function documentation)\n",
        "    \n",
        "    16. ``Y = pdist(X, 'dice')``\n",
        "    \n",
        "       Computes the Dice distance between each pair of boolean\n",
        "       vectors. (see dice function documentation)\n",
        "    \n",
        "    17. ``Y = pdist(X, 'kulsinski')``\n",
        "    \n",
        "       Computes the Kulsinski distance between each pair of\n",
        "       boolean vectors. (see kulsinski function documentation)\n",
        "    \n",
        "    18. ``Y = pdist(X, 'rogerstanimoto')``\n",
        "    \n",
        "       Computes the Rogers-Tanimoto distance between each pair of\n",
        "       boolean vectors. (see rogerstanimoto function documentation)\n",
        "    \n",
        "    19. ``Y = pdist(X, 'russellrao')``\n",
        "    \n",
        "       Computes the Russell-Rao distance between each pair of\n",
        "       boolean vectors. (see russellrao function documentation)\n",
        "    \n",
        "    20. ``Y = pdist(X, 'sokalmichener')``\n",
        "    \n",
        "       Computes the Sokal-Michener distance between each pair of\n",
        "       boolean vectors. (see sokalmichener function documentation)\n",
        "    \n",
        "    21. ``Y = pdist(X, 'sokalsneath')``\n",
        "    \n",
        "       Computes the Sokal-Sneath distance between each pair of\n",
        "       boolean vectors. (see sokalsneath function documentation)\n",
        "    \n",
        "    22. ``Y = pdist(X, 'wminkowski')``\n",
        "    \n",
        "       Computes the weighted Minkowski distance between each pair of\n",
        "       vectors. (see wminkowski function documentation)\n",
        "    \n",
        "    23. ``Y = pdist(X, f)``\n",
        "    \n",
        "       Computes the distance between all pairs of vectors in X\n",
        "       using the user supplied 2-arity function f. For example,\n",
        "       Euclidean distance between the vectors could be computed\n",
        "       as follows::\n",
        "    \n",
        "         dm = pdist(X, lambda u, v: np.sqrt(((u-v)**2).sum()))\n",
        "    \n",
        "       Note that you should avoid passing a reference to one of\n",
        "       the distance functions defined in this library. For example,::\n",
        "    \n",
        "         dm = pdist(X, sokalsneath)\n",
        "    \n",
        "       would calculate the pair-wise distances between the vectors in\n",
        "       X using the Python function sokalsneath. This would result in\n",
        "       sokalsneath being called :math:`{n \\choose 2}` times, which\n",
        "       is inefficient. Instead, the optimized C version is more\n",
        "       efficient, and we call it using the following syntax.::\n",
        "    \n",
        "         dm = pdist(X, 'sokalsneath')\n",
        "    \n",
        "    Parameters\n",
        "    ----------\n",
        "    X : ndarray\n",
        "        An m by n array of m original observations in an\n",
        "        n-dimensional space.\n",
        "    metric : string or function\n",
        "        The distance metric to use. The distance function can\n",
        "        be 'braycurtis', 'canberra', 'chebyshev', 'cityblock',\n",
        "        'correlation', 'cosine', 'dice', 'euclidean', 'hamming',\n",
        "        'jaccard', 'kulsinski', 'mahalanobis', 'matching',\n",
        "        'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean',\n",
        "        'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule'.\n",
        "    w : ndarray\n",
        "        The weight vector (for weighted Minkowski).\n",
        "    p : double\n",
        "        The p-norm to apply (for Minkowski, weighted and unweighted)\n",
        "    V : ndarray\n",
        "            The variance vector (for standardized Euclidean).\n",
        "    VI : ndarray\n",
        "        The inverse of the covariance matrix (for Mahalanobis).\n",
        "    \n",
        "    Returns\n",
        "    -------\n",
        "    Y : ndarray\n",
        "        Returns a condensed distance matrix Y.  For\n",
        "        each :math:`i` and :math:`j` (where :math:`i<j<n`), the\n",
        "        metric ``dist(u=X[i], v=X[j])`` is computed and stored in entry ``ij``.\n",
        "    \n",
        "    See Also\n",
        "    --------\n",
        "    squareform : converts between condensed distance matrices and\n",
        "                 square distance matrices.\n",
        "    \n",
        "    Notes\n",
        "    -----\n",
        "    See ``squareform`` for information on how to calculate the index of\n",
        "    this entry or to convert the condensed distance matrix to a\n",
        "    redundant square matrix.\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It is useful to know that there is a capability within `scipy` specifically dealing with spatial distance calculations. There are other problems that this could be applied to.\n",
      "\n",
      "`squareform` is documented below:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "help(squareform)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Help on function squareform in module scipy.spatial.distance:\n",
        "\n",
        "squareform(X, force='no', checks=True)\n",
        "    Converts a vector-form distance vector to a square-form distance\n",
        "    matrix, and vice-versa.\n",
        "    \n",
        "    Parameters\n",
        "    ----------\n",
        "    X : ndarray\n",
        "        Either a condensed or redundant distance matrix.\n",
        "    force : str, optional\n",
        "        As with MATLAB(TM), if force is equal to 'tovector' or 'tomatrix',\n",
        "        the input will be treated as a distance matrix or distance vector\n",
        "        respectively.\n",
        "    checks : bool, optional\n",
        "        If `checks` is set to False, no checks will be made for matrix\n",
        "        symmetry nor zero diagonals. This is useful if it is known that\n",
        "        ``X - X.T1`` is small and ``diag(X)`` is close to zero.\n",
        "        These values are ignored any way so they do not disrupt the\n",
        "        squareform transformation.\n",
        "    \n",
        "    Returns\n",
        "    -------\n",
        "    Y : ndarray\n",
        "        If a condensed distance matrix is passed, a redundant one is\n",
        "        returned, or if a redundant one is passed, a condensed distance\n",
        "        matrix is returned.\n",
        "    \n",
        "    Notes\n",
        "    -----\n",
        "    \n",
        "    1. v = squareform(X)\n",
        "    \n",
        "       Given a square d-by-d symmetric distance matrix X,\n",
        "       ``v=squareform(X)`` returns a ``d * (d-1) / 2`` (or\n",
        "       `${n \\choose 2}$`) sized vector v.\n",
        "    \n",
        "      v[{n \\choose 2}-{n-i \\choose 2} + (j-i-1)] is the distance\n",
        "      between points i and j. If X is non-square or asymmetric, an error\n",
        "      is returned.\n",
        "    \n",
        "    2. X = squareform(v)\n",
        "    \n",
        "      Given a d*d(-1)/2 sized v for some integer d>=2 encoding distances\n",
        "      as described, X=squareform(v) returns a d by d distance matrix X. The\n",
        "      X[i, j] and X[j, i] values are set to\n",
        "      v[{n \\choose 2}-{n-i \\choose 2} + (j-u-1)] and all\n",
        "      diagonal elements are zero.\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It would be worth inspecting the rest of this code carefully to pick up some useful techniques for collison detection."
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "Embedded Animations"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Further reading led me to [this post](http://jakevdp.github.io/blog/2013/05/12/embedding-matplotlib-animations/) that described embedded matplotlib animations in IPython. Let's give it a go."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from tempfile import NamedTemporaryFile\n",
      "\n",
      "VIDEO_TAG = \"\"\"<video controls>\n",
      " <source src=\"data:video/x-m4v;base64,{0}\" type=\"video/mp4\">\n",
      " Your browser does not support the video tag.\n",
      "</video>\"\"\"\n",
      "\n",
      "def anim_to_html(anim):\n",
      "    if not hasattr(anim, '_encoded_video'):\n",
      "        with NamedTemporaryFile(suffix='.mp4') as f:\n",
      "            anim.save(f.name, fps=20, extra_args=['-vcodec', 'libx264'])\n",
      "            video = open(f.name, \"rb\").read()\n",
      "        anim._encoded_video = video.encode(\"base64\")\n",
      "    \n",
      "    return VIDEO_TAG.format(anim._encoded_video)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 11
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Immediately I become concerned that this will not work, because it required the video to be saved, something that does not work on this machine. Let's continue anyway."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from IPython.display import HTML\n",
      "\n",
      "def display_animation(anim):\n",
      "    plt.close(anim._fig)\n",
      "    return HTML(anim_to_html(anim))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Using the earlier animated sine wave code, we call the new `display_animation` function at the end."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from matplotlib import animation\n",
      "\n",
      "# First set up the figure, the axis, and the plot element we want to animate\n",
      "fig = plt.figure()\n",
      "ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))\n",
      "line, = ax.plot([], [], lw=2)\n",
      "\n",
      "# initialization function: plot the background of each frame\n",
      "def init():\n",
      "    line.set_data([], [])\n",
      "    return line,\n",
      "\n",
      "# animation function.  This is called sequentially\n",
      "def animate(i):\n",
      "    x = np.linspace(0, 2, 1000)\n",
      "    y = np.sin(2 * np.pi * (x - 0.01 * i))\n",
      "    line.set_data(x, y)\n",
      "    return line,\n",
      "\n",
      "# call the animator.  blit=True means only re-draw the parts that have changed.\n",
      "anim = animation.FuncAnimation(fig, animate, init_func=init,\n",
      "                               frames=100, interval=20, blit=True)\n",
      "\n",
      "# call our new function to display the animation\n",
      "display_animation(anim)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "UnicodeDecodeError",
       "evalue": "'utf-8' codec can't decode byte 0xff in position 0: invalid start byte",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mUnicodeDecodeError\u001b[0m                        Traceback (most recent call last)",
        "\u001b[1;32m<ipython-input-13-b51bfc0123f6>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     23\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     24\u001b[0m \u001b[1;31m# call our new function to display the animation\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 25\u001b[1;33m \u001b[0mdisplay_animation\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0manim\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[1;32m<ipython-input-12-63a8cd04f4be>\u001b[0m in \u001b[0;36mdisplay_animation\u001b[1;34m(anim)\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mdisplay_animation\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0manim\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0manim\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_fig\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0mHTML\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0manim_to_html\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0manim\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
        "\u001b[1;32m<ipython-input-11-e4c246e992b2>\u001b[0m in \u001b[0;36manim_to_html\u001b[1;34m(anim)\u001b[0m\n\u001b[0;32m      9\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0manim\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'_encoded_video'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0mNamedTemporaryFile\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msuffix\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'.mp4'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m             \u001b[0manim\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msave\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfps\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m20\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mextra_args\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'-vcodec'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'libx264'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     12\u001b[0m             \u001b[0mvideo\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"rb\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m         \u001b[0manim\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_encoded_video\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mvideo\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mencode\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"base64\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
        "\u001b[1;32m/home/paul/.virtualenvs/notebook/lib/python3.3/site-packages/matplotlib/animation.py\u001b[0m in \u001b[0;36msave\u001b[1;34m(self, filename, writer, fps, dpi, codec, bitrate, extra_args, metadata, extra_anim, savefig_kwargs)\u001b[0m\n\u001b[0;32m    717\u001b[0m                     \u001b[1;31m#TODO: Need to see if turning off blit is really necessary\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    718\u001b[0m                     \u001b[0manim\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_draw_next_frame\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mblit\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 719\u001b[1;33m                 \u001b[0mwriter\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mgrab_frame\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0msavefig_kwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    720\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    721\u001b[0m         \u001b[1;31m# Reconnect signal for first draw if necessary\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
        "\u001b[1;32m/home/paul/.virtualenvs/notebook/lib/python3.3/site-packages/matplotlib/animation.py\u001b[0m in \u001b[0;36mgrab_frame\u001b[1;34m(self, **savefig_kwargs)\u001b[0m\n\u001b[0;32m    203\u001b[0m             \u001b[1;31m# frame format and dpi.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    204\u001b[0m             self.fig.savefig(self._frame_sink(), format=self.frame_format,\n\u001b[1;32m--> 205\u001b[1;33m                              dpi=self.dpi, **savefig_kwargs)\n\u001b[0m\u001b[0;32m    206\u001b[0m         \u001b[1;32mexcept\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    207\u001b[0m             \u001b[0mout\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0merr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_proc\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcommunicate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
        "\u001b[1;32m/home/paul/.virtualenvs/notebook/lib/python3.3/site-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36msavefig\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1420\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_frameon\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mframeon\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1421\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1422\u001b[1;33m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1423\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1424\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mframeon\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
        "\u001b[1;32m/home/paul/.virtualenvs/notebook/lib/python3.3/site-packages/matplotlib/backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[1;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, **kwargs)\u001b[0m\n\u001b[0;32m   2223\u001b[0m                 \u001b[0mrestore_bbox\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2224\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2225\u001b[1;33m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdpi\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0morigDPI\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2226\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_facecolor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0morigfacecolor\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2227\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_edgecolor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0morigedgecolor\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
        "\u001b[1;32m/home/paul/.virtualenvs/notebook/lib/python3.3/site-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36m_set_dpi\u001b[1;34m(self, dpi)\u001b[0m\n\u001b[0;32m    383\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m_set_dpi\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdpi\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    384\u001b[0m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_dpi\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdpi\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 385\u001b[1;33m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdpi_scale_trans\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mclear\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mscale\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdpi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdpi\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    386\u001b[0m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcallbacks\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mprocess\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'dpi_changed'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    387\u001b[0m     \u001b[0mdpi\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mproperty\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_get_dpi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0m_set_dpi\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
        "\u001b[1;32m/home/paul/.virtualenvs/notebook/lib/python3.3/site-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36mclear\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m   1784\u001b[0m         \u001b[0mReset\u001b[0m \u001b[0mthe\u001b[0m \u001b[0munderlying\u001b[0m \u001b[0mmatrix\u001b[0m \u001b[0mto\u001b[0m \u001b[0mthe\u001b[0m \u001b[0midentity\u001b[0m \u001b[0mtransform\u001b[0m\u001b[1;33m.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1785\u001b[0m         \"\"\"\n\u001b[1;32m-> 1786\u001b[1;33m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_mtx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0midentity\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1787\u001b[0m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minvalidate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1788\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
        "\u001b[1;32m/home/paul/.virtualenvs/notebook/lib/python3.3/site-packages/numpy/core/numeric.py\u001b[0m in \u001b[0;36midentity\u001b[1;34m(n, dtype)\u001b[0m\n\u001b[0;32m   2051\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2052\u001b[0m     \"\"\"\n\u001b[1;32m-> 2053\u001b[1;33m     \u001b[1;32mfrom\u001b[0m \u001b[0mnumpy\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0meye\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2054\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0meye\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2055\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
        "\u001b[1;32m/home/paul/.virtualenvs/notebook/lib/python3.3/importlib/_bootstrap.py\u001b[0m in \u001b[0;36m_handle_fromlist\u001b[1;34m(module, fromlist, import_)\u001b[0m\n",
        "\u001b[1;31mUnicodeDecodeError\u001b[0m: 'utf-8' codec can't decode byte 0xff in position 0: invalid start byte"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "There is that lingering error again. That's a shame."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}