1_Python for Visual Computing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DLVC 2017\n",
    "# Tutorial 1 : Python for Visual Computing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Reference: Programming Computer Vision with Python by Jan Erik Solem*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1: Basic Image Handling and Processing\n",
    "\n",
    "### Python Image Library (PIL) [http://www.pythonware.com/products/pil/]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import numpy as np\n",
    "\n",
    "if not os.path.exists('tut01-results'):\n",
    "    os.makedirs('tut01-results')\n",
    "\n",
    "#Loading an image\n",
    "img = Image.open('data/iitkgp.jpg')\n",
    "plt.imshow(img) # display the image\n",
    "print('Image size: '+str(img.size)) # image dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Converting an image to grayscale\n",
    "img_gray = img.convert('L') \n",
    "plt.imshow(np.asarray(img_gray),cmap='gray')\n",
    "\n",
    "#Saving an image\n",
    "img_gray.save('tut01-results/iitkgp_gray.png') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Cropping an image\n",
    "box = (250,10,450,250) # top-left and bottom right co-ordinates of the region to be cropped\n",
    "img_crop = img.crop(box)\n",
    "plt.imshow(img_crop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Resizing an image\n",
    "img_resz = img.resize((200,200))\n",
    "plt.figure()\n",
    "plt.imshow(np.asarray(img))\n",
    "plt.figure()\n",
    "plt.imshow(np.asarray(img_resz))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Rotating an image\n",
    "img_rot = img_resz.rotate(45) # anti-clockwise rotation\n",
    "plt.subplot(1,2,1)\n",
    "plt.imshow(img_resz)\n",
    "plt.subplot(1,2,2)\n",
    "plt.imshow(img_rot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Read all the images from a folder\n",
    "import os\n",
    "    # Function that returns a list containing the names of image files in a folder\n",
    "def get_imlist(path):\n",
    "    return [os.path.join(path,f) for f in os.listdir(path) if f.endswith('.jpg')]\n",
    "\n",
    "img_list = get_imlist('data/images') # list containing filenames\n",
    "print(img_list)\n",
    "    # Displaying the images\n",
    "for fileNum in range(len(img_list)):\n",
    "    im = Image.open(img_list[fileNum])\n",
    "    plt.subplot(1,len(img_list),fileNum+1)\n",
    "    plt.imshow(im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.pyplot import bar\n",
    "#Histogram of images\n",
    "img_hist = img_gray.histogram()\n",
    "bar(range(256),img_hist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For more examples on matplotlib visit https://matplotlib.org/2.0.2/examples/index.html\n",
    "\n",
    "\n",
    "### NumPy [doc: http://docs.scipy.org/doc/numpy/]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "# Converting to numpy array and properties\n",
    "img_arr = np.array(img)\n",
    "print img_arr.shape, img_arr.dtype\n",
    "img_grayarr = np.array(img.convert('L'),'f') # 'f' => floating point\n",
    "print img_grayarr.shape, img_grayarr.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Acessing an element in an array\n",
    "px1 = img_arr[100,100,2]\n",
    "print('px1: '+ str(px1))\n",
    "\n",
    "# Accessing multiple elements by slicing\n",
    "px2 = img_grayarr[100,:] # all the elemts in a row\n",
    "print('px2: '+ str(px2))\n",
    "\n",
    "px3 = img_grayarr[100,30:40] # range of elements in a row\n",
    "print('px3: '+ str(px3))\n",
    "\n",
    "px4 = img_grayarr[:,-1] # last column\n",
    "print('px4: '+ str(px4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Graylevel transformations\n",
    "img_grayinv = 255-img_grayarr\n",
    "plt.figure()\n",
    "plt.subplot(121)\n",
    "plt.imshow(img_grayarr,'gray')\n",
    "plt.subplot(122)\n",
    "plt.imshow(img_grayinv,'gray')\n",
    "\n",
    "img_clamp = (100.0/255) * img_grayarr + 100 #clamp to interval 100...200\n",
    "plt.figure()\n",
    "plt.imshow(img_clamp)\n",
    "plt.colorbar()\n",
    "\n",
    "# Minimum and maximum values\n",
    "print(img_grayarr.min(),img_grayarr.max())\n",
    "print(img_clamp.min(),img_clamp.max())\n",
    "\n",
    "img_clamp_hist,_ = np.histogram(img_clamp, range=(0,255), bins=256)\n",
    "plt.figure()\n",
    "bar(range(256),img_clamp_hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Array to image\n",
    "pil_img = Image.fromarray(np.uint8(img_clamp))\n",
    "plt.imshow(np.asarray(pil_img),'gray')\n",
    "# pil_img.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Histogram equivalization\n",
    "img_clamp_hist,bins = np.histogram(img_clamp.flatten(),range=(0,255),bins=256)\n",
    "cdf = img_clamp_hist.cumsum() # cumulative distribution function\n",
    "cdf = 255 * cdf / cdf[-1] # normalize\n",
    "# use linear interpolation of cdf to find new pixel values\n",
    "img_clampeq = np.interp(img_clamp.flatten(),bins[:-1],cdf).reshape(img_grayarr.shape)\n",
    "img_clampeq_hist,_ = np.histogram(img_clampeq.flatten(),range=(0,255),bins=256)\n",
    "plt.subplot(2,2,1)\n",
    "plt.imshow(np.uint8(img_clamp),'gray')\n",
    "plt.subplot(2,2,2)\n",
    "plt.imshow(np.uint8(img_clampeq),'gray')\n",
    "plt.figure()\n",
    "plt.subplot(2,2,3)\n",
    "bar(range(256),img_clamp_hist)\n",
    "plt.subplot(2,2,4)\n",
    "bar(range(256),img_clampeq_hist)\n",
    "\n",
    "Image.fromarray(np.uint8(img_clamp)).save('tut01-results/iitkgp_clamp.png') \n",
    "Image.fromarray(np.uint8(img_clampeq)).save('tut01-results/iitkgp_clampEq.png') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Using pickle module for saving data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "# Saving data\n",
    "with open('tut01-results/image_array.pkl','wb') as f:  # 'with' automatically handles opening and closing of files\n",
    "    pickle.dump(img_grayarr,f)    \n",
    "\n",
    "# Loading data\n",
    "with open('tut01-results/image_array.pkl','rb') as f:\n",
    "    img_ar = pickle.load(f)\n",
    "\n",
    "plt.imshow(img_ar,'gray')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SciPy [doc: https://docs.scipy.org/doc/scipy/reference/]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Blurring images\n",
    "from scipy.ndimage import filters\n",
    "\n",
    "img_blur1 = filters.gaussian_filter(img_gray,2) # sigma(sd) = 2\n",
    "img_blur2 = filters.gaussian_filter(img_gray,5) # sigma = 5\n",
    "img_blur3 = filters.gaussian_filter(img_gray,10) # sigma = 10\n",
    "plt.subplot(2,2,1)\n",
    "plt.imshow(np.array(img_gray),'gray')\n",
    "plt.subplot(2,2,2)\n",
    "plt.imshow(img_blur1,'gray')\n",
    "plt.subplot(2,2,3)\n",
    "plt.imshow(img_blur2,'gray')\n",
    "plt.subplot(2,2,4)\n",
    "plt.imshow(img_blur3,'gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Image gradients\n",
    "\n",
    "#Sobel derivative filters\n",
    "imx = np.zeros(img_grayarr.shape) \n",
    "filters.sobel(img_grayarr,1,imx) # operates on arrays!\n",
    "imy = np.zeros(img_grayarr.shape)\n",
    "filters.sobel(img_grayarr,0,imy)\n",
    "img_grad = np.sqrt(imx**2+imy**2) # ** ==> squaring\n",
    "\n",
    "plt.subplot(2,2,1)\n",
    "plt.imshow(np.array(img_gray),'gray')\n",
    "plt.subplot(2,2,2)\n",
    "plt.imshow(imx,'gray')\n",
    "plt.subplot(2,2,3)\n",
    "plt.imshow(imy,'gray')\n",
    "plt.subplot(2,2,4)\n",
    "plt.imshow(img_grad,'gray')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Excercise 2: Feature Extraction\n",
    "#### Using skimgae [doc: http://scikit-image.org/docs/stable/]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from skimage import feature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Co-ocurance matrix\n",
    "coMatFeat = feature.greycomatrix(np.uint8(img_grayarr), [1], [np.pi/4],normed=True,levels=256) \n",
    "print(coMatFeat.shape)\n",
    "\n",
    "# Properties of GLCM\n",
    "coPropFeat = feature.greycoprops(coMatFeat, prop= 'homogeneity')\n",
    "print(coPropFeat)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Histogram of Oriented Gradients\n",
    "hogFeat = feature.hog(img_grayarr, orientations=4, pixels_per_cell=(50,50),block_norm='L2-Hys')\n",
    "print(hogFeat.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Local binary pattern\n",
    "lbpFeat = feature.local_binary_pattern(img_grayarr, 35, 15)\n",
    "plt.imshow(lbpFeat,'gray')\n",
    "print(lbpFeat.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}