Playing with images & filters.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Playing with images & filters\n",
      "\n",
      "This is a small demo of how to use numpy and mahotas to manipulate images."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import mahotas as mh\n",
      "import numpy as np\n",
      "from matplotlib import pyplot as plt\n",
      "%matplotlib inline"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We will use IPython *interactive features*!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from IPython.html.widgets import interact, fixed"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "It is slightly nicer if images are larger:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "plt.rcParams['figure.figsize'] = (10.0, 8.0) # 10 x 8 inches"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "First, let's just load an image and look at it:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "im = mh.imread('jordan.jpeg')\n",
      "plt.imshow(im)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A simple transformation that's built-in to mahotas is to convert to sepia:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "sepia = mh.colors.rgb2sepia(im)\n",
      "plt.imshow(sepia)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You can also play with the pixels directly. Let's try the following transformation:\n",
      "\n",
      "$$ p' = p^2 $$"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "im2 = im ** 2.\n",
      "plt.imshow(im2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Ok, that didn't work out exactly as planned.\n",
      "\n",
      "The reason is that although we transformed the image correctly, when we tried to display it, `matplotlib` saw a floating point image and did not handle it correctly.\n",
      "\n",
      "The solution is to convert the image back to 8-bit pixels. Mahotas has a simple utility function, `mh.stretch_rgb` which will do this for use (it will stretch an RGB image to 0..255, handling each channel separately).\n",
      "\n",
      "This function is also very useful when you want to save your results. Many image formats only support integer images or other pieces of software only support 8-bit images."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "im2 = im**2.\n",
      "print(\"First pixel is {}.\".format(im2[0,0]))\n",
      "im2 = mh.stretch_rgb(im2)\n",
      "print(\"After stretching, first pixel is {}.\".format(im2[0,0]))\n",
      "plt.imshow(im2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Question**: If you try `im2 = im ** 2`, the result will not be as expected. Why?"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Stretching each channel separately\n",
      "\n",
      "We can use different exponents on different colour channels to get different effects.\n",
      "\n",
      "The first thing we need to do is separate the channels, using `ndarray.transpose`.\n",
      "\n",
      "**Tip**: In Ipython, you can type `np.transpose?` (yes, that's a question mark), followed by ENTER, to obtain the docstring for `np.transpose` (naturally, it works for all functions and methods)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "r,g,b = im.transpose((2,0,1))\n",
      "plt.imshow(mh.as_rgb(r**2., g**2.4, b**4.))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Interactive exploration!\n",
      "\n",
      "For the final flourish, we are going to use `interact` to build a small widget for exploring different options."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "@interact(im=fixed(im),\n",
      "          r_exp=(.1, 4.),\n",
      "          g_exp=(.1, 4.),\n",
      "          b_exp=(.1, 4.),\n",
      "          extra=['option A', 'option B'])\n",
      "def do_plot(im, r_exp, g_exp, b_exp, extra):\n",
      "    '''\n",
      "    Generate a plot with the image being\n",
      "    stretched by different amounts in each channel.\n",
      "    '''\n",
      "    r,g,b = im.transpose((2,0,1))\n",
      "    plt.imshow(mh.as_rgb(r**r_exp, g**g_exp, b**b_exp))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}