1_1_Python_for_Visual_Computing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MoDL 2020\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",
    "plt.figure(figsize=[15,5])\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": [
    "### Containers\n",
    "\n",
    "Source: cs231n.github.io"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "xs = [3, 1, 2]    # Create a list\n",
    "print(xs, xs[2])  \n",
    "print(xs[-1])     # Negative indices count from the end of the list; prints \"2\"\n",
    "xs[2] = 'foo'     # Lists can contain elements of different types\n",
    "print(xs)         \n",
    "xs.append('bar')  # Add a new element to the end of the list\n",
    "print(xs)         \n",
    "x = xs.pop()      # Remove and return the last element of the list\n",
    "print(x, xs)      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = list(range(5))     # range is a built-in function that creates a list of integers\n",
    "print(nums)               \n",
    "print(nums[2:4])          \n",
    "print(nums[2:])           \n",
    "print(nums[:2])           \n",
    "print(nums[:])            \n",
    "print(nums[:-1])          \n",
    "nums[2:4] = [8, 9]        # Assign a new sublist to a slice\n",
    "print(nums)               "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for animal in animals:\n",
    "    print(animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'cat': 'cute', 'dog': 'furry'}  # Create a new dictionary with some data\n",
    "print(d['cat'])      \n",
    "\n",
    "d['fish'] = 'wet'     # Set an entry in a dictionary\n",
    "print(d['fish'])      # Prints \"wet\"\n",
    "# print(d['monkey'])  # KeyError: 'monkey' not a key of d\n",
    "print(d.get('monkey', 'N/A'))  # Get an element with a default; prints \"N/A\"\n",
    "print(d.get('fish', 'N/A'))    # Get an element with a default; prints \"wet\"\n",
    "del d['fish']         # Remove an element from a dictionary\n",
    "print(d.get('fish', 'N/A')) # \"fish\" is no longer a key; prints \"N/A\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'person': 2, 'cat': 4, 'spider': 8}\n",
    "for animal in d:\n",
    "    legs = d[animal]\n",
    "    print('A %s has %d legs' % (animal, legs))\n",
    "# Prints \"A person has 2 legs\", \"A cat has 4 legs\", \"A spider has 8 legs\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {(x, x + 1): x for x in range(10)}  # Create a dictionary with tuple keys\n",
    "t = (5, 6)        # Create a tuple\n",
    "print(type(t))    # Prints \"<class 'tuple'>\"\n",
    "print(d[t])       # Prints \"5\"\n",
    "print(d[(1, 2)])  # Prints \"1\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sign(x):\n",
    "    if x > 0:\n",
    "        return 'positive'\n",
    "    elif x < 0:\n",
    "        return 'negative'\n",
    "    else:\n",
    "        return 'zero'\n",
    "\n",
    "for x in [-1, 0, 1]:\n",
    "    print(sign(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Greeter(object):\n",
    "\n",
    "    # Constructor\n",
    "    def __init__(self, name):\n",
    "        self.name = name  # Create an instance variable\n",
    "\n",
    "    # Instance method\n",
    "    def greet(self, loud=False):\n",
    "        if loud:\n",
    "            print('HELLO, %s!' % self.name.upper())\n",
    "        else:\n",
    "            print('Hello, %s' % self.name)\n",
    "\n",
    "g = Greeter('Fred')  # Construct an instance of the Greeter class\n",
    "g.greet()            # Call an instance method; prints \"Hello, Fred\"\n",
    "g.greet(loud=True)   # Call an instance method; prints \"HELLO, FRED!\""
   ]
  },
  {
   "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,cmap='gray')\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.figure(figsize=[15,10])\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.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.figure(figsize=[15,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.figure(figsize=[15,10])\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')"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}