dobler_111014_part2.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:a1273790c24e79e6ff314c272fbda173d2e156f1b147a2504df3ca751367d825"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "(always be aware of your imports and <b><u><i>preserve namespaces</i></u></b>!!!)"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import os\n",
      "import sys\n",
      "import time\n",
      "import numpy as np\n",
      "import scipy.ndimage as nd\n",
      "import matplotlib.pyplot as plt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "# Reading images into python\n",
      "\n",
      "There are many ways to read images into a usable data structure in python.  Lots of good modules exist, some of the most popular being:<br>\n",
      ". scipy.ndimage<br>\n",
      ". PIL (python imaging library)<br>\n",
      ". scikit-image<br>\n",
      ". opencv<br>\n",
      "<br>\n",
      "Each of these has its pros and cons, we'll almost exclusively be using scipy.ndimage since we can load the data directly into a numpy array and it lets us stay \"close\" to the data.<br>\n",
      "<br>\n",
      "This notebook is running in a directory with a subdirectory called \"images\" where the Mona Lisa image is stored.  To load it into a numpy array,"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import os\n",
      "import sys\n",
      "import time\n",
      "import numpy as np\n",
      "import scipy.ndimage as nd\n",
      "import matplotlib.pyplot as plt\n",
      "\n",
      "dpath = 'images'\n",
      "fname = 'ml.jpg'\n",
      "infile = os.path.join(dpath,fname)\n",
      "img_ml = nd.imread(infile)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print infile"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "images/ml.jpg\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We now have the image ready to use as a numpy array (with all of its associated methods).  Some important things to note about this array though are its shape and type,"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(\"shape : {0}\\ntype  : {1}\".format(img_ml.shape,img_ml.dtype))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "shape : (954, 640, 3)\n",
        "type  : uint8\n"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "---\n",
      "\n",
      "# 3D arrays, data types, and heatmaps\n",
      "\n",
      "While grayscale images are 2D arrays, color images are 3D (... and sometimes 4D) data <i>cubes</i>.  Typically, these are stored as 8-bit unsigned integers meaning that the value a given pixel can take is between $0$ and $255 = 2^8 - 1$.<br>\n",
      "<br>\n",
      "Fortunately, when matplotlib sees a 3D data cube it knows what to do:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "ysize = 10.\n",
      "xsize = ysize*float(img_ml.shape[1])/float(img_ml.shape[0])\n",
      "\n",
      "fig5, ax5 = plt.subplots(num=5,figsize=[xsize,ysize])\n",
      "fig5.subplots_adjust(0,0,1,1)\n",
      "ax5.axis('off')\n",
      "im5 = ax5.imshow(img_ml)\n",
      "fig5.canvas.draw()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "CAUTION: matplotlib always \"interprets\" 3D data cubes as being unsigned 8-bit integers.  If your 3D data cube is <i>not</i> an unsigned 8-bit integer, the color matching will fail,"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "im5.set_data(1.0*img_ml)\n",
      "fig5.canvas.draw()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 8
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Let's say, for example, that you wanted to make the whole image fainter by a factor of $4$.  You can multiply by $0.25$ but be careful to change the type back to a uint8:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "fig6, ax6 = plt.subplots(1,3,num=6,figsize=[3*xsize,ysize])\n",
      "fig6.subplots_adjust(0,0,1,1,0,0)\n",
      "[i.axis('off') for i in ax6]\n",
      "im6a = ax6[0].imshow(img_ml)\n",
      "im6b = ax6[1].imshow(0.25*img_ml)\n",
      "im6c = ax6[2].imshow((0.25*img_ml).astype(np.uint8))\n",
      "fig6.canvas.draw()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Whenever processing an image, always use the highest precision you can and only go back to 8-bit integers for visualizations.<br>\n",
      "<br>\n",
      "Notice though what matplotlib does when the input array is <i>not</i> a 3D data cube:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "img_ml_L = img_ml.mean(2) # convert to gray scale by taking the mean across the color axis\n",
      "print(\"img_ml_L\\n  shape : {0}\\n  type  : {1}\".format(img_ml_L.shape,img_ml_L.dtype))\n",
      "\n",
      "fig7, ax7 = plt.subplots(num=7,figsize=[xsize,ysize])\n",
      "fig7.subplots_adjust(0,0,1,1)\n",
      "ax7.axis('off')\n",
      "im7 = ax7.imshow(img_ml_L)\n",
      "fig7.canvas.draw()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "img_ml_L\n",
        "  shape : (954, 640)\n",
        "  type  : float64\n"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Here the data is a 2D 64-bit float.  In this case matplotlib creates a heatmap and intensity is preserved regardless of amplitude.\n",
      "\n",
      "---"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Cropping, negative, and overplotting"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "1. Find a jpg from the internet and download it\n",
      "2. Load it into python using scipy.ndimage\n",
      "3. Display the full image\n",
      "4. Display only the upper left corner\n",
      "5. Display only the lower right corner\n",
      "6. Display only the central half of the image\n",
      "7. Diplay a negative of the full image\n",
      "8. Reset the right half of the image as the negative of itself\n",
      "9. Plot a step function with a transition at ncol/2 and height nrow\n",
      "10. Overshow the result of step 8"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}