sums_line_object_detector.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Detectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Line detectors, face detector... How does these detectors work?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter  shortcuts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "up/down arrow keys to move, enter to edit\n",
    "\n",
    "Esc to exit edit mode\n",
    "\n",
    "Shift + enter to run code\n",
    "\n",
    "a/b to add cell above/below\n",
    "\n",
    "dd to delete cell\n",
    "\n",
    "1/2/3... to add comment\n",
    "\n",
    "press h for more shortcuts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to do detection?  Part 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use threshold mask as a tool to detec object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy as sp\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "a = np.zeros((100, 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l_mat = np.zeros((5, 5))\n",
    "l_map = [(1, 2), (2, 2), (3, 2), (3, 3)]\n",
    "for (i,j) in l_map :\n",
    "    l_mat[i][j]=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.matshow(l_mat, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(30) :\n",
    "    x = int(np.random.random()*94)\n",
    "    y = int(np.random.random()*94)\n",
    "    for p in range(l_mat.shape[0]) :\n",
    "        for q in range(l_mat.shape[1]) :\n",
    "            if(l_mat[p][q]!=0):\n",
    "                a[x+p][y+q]=l_mat[p][q]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.matshow(a, cmap=plt.cm.gray)\n",
    "#plt.matshow(a)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "threshold = np.zeros((100, 100))\n",
    "for i in range(a.shape[0]) :\n",
    "    for j in range(a.shape[1]) :\n",
    "        if a[i][j] > 95 :\n",
    "            threshold[i][j]=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.matshow(threshold, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to detec? Part 2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convolution is a commonly use method in signal processing. Let's see how it work!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from scipy import signal\n",
    "conv = signal.convolve2d(a, l_mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.matshow(conv, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get into a real world "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " It seem that adding convoluton is not that good than pure threshold method. \n",
    " However, in the real world, there are noise every where."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  3.40454335  43.19144172  50.81241807 ...,  37.69693548  47.89459809\n",
      "   39.67663531]\n",
      " [ 50.64750583  36.43109817   9.75849106 ...,  34.84880417  98.91880204\n",
      "   57.24627865]\n",
      " [ 55.52434748  73.70038771  26.93357007 ...,  54.52029052  62.24351063\n",
      "   45.50102651]\n",
      " ..., \n",
      " [ 11.31887205  76.79437237  45.06395074 ...,  93.85727358  72.88323556\n",
      "   41.09442711]\n",
      " [ 21.30828867  57.69871918   7.18787274 ...,  86.60690569  95.26056843\n",
      "   12.59150791]\n",
      " [ 50.22413505  81.77251915  84.0266466  ...,  16.66383012  60.97471444\n",
      "   55.81863844]]\n"
     ]
    }
   ],
   "source": [
    "noise = np.random.random(10000).reshape(100,100)\n",
    "noise *=100\n",
    "print noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.matshow(noise, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "noise_a = np.add(noise,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.matshow(noise_a, vmax=100, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If we use pure threshold to detec the shape in a noise environment. How it goes?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "threshold = np.zeros((100, 100))\n",
    "for i in range(noise_a.shape[0]) :\n",
    "    for j in range(noise_a.shape[1]) :\n",
    "        if noise_a[i][j] > 98 :\n",
    "            threshold[i][j]=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.matshow(threshold, vmax=100, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How about adding convolution for help?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "conv = signal.convolve2d(noise_a, l_mat)\n",
    "conv /= conv.max()\n",
    "threshold = np.zeros((100, 100))\n",
    "for i in range(100) :\n",
    "    for j in range(100) :\n",
    "        if conv[i][j] > 0.65 :\n",
    "            threshold[i][j]=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.matshow(conv, cmap=plt.cm.gray)\n",
    "plt.matshow(threshold, cmap=plt.cm.gray)\n",
    "plt.matshow(a, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cool stuff : Gaussian filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from scipy.ndimage.filters import gaussian_filter\n",
    "gauss = np.zeros((100,100))\n",
    "gaussian_filter(a, 2, output = gauss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.matshow(gauss, cmap=plt.cm.gray)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some commonly used line detectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sobel Detector "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "img = cv2.imread('images/sudoku.jpg',0)\n",
    "\n",
    "laplacian = cv2.Laplacian(img,cv2.CV_64F)\n",
    "sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=5)\n",
    "sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=5)\n",
    " \n",
    "plt.subplot(2,2,1),plt.imshow(img,cmap = 'gray')\n",
    "plt.title('Original'), plt.xticks([]), plt.yticks([])\n",
    "plt.subplot(2,2,2),plt.imshow(laplacian,cmap = 'gray')\n",
    "plt.title('Laplacian'), plt.xticks([]), plt.yticks([])\n",
    "plt.subplot(2,2,3),plt.imshow(sobelx,cmap = 'gray')\n",
    "plt.title('Sobel X'), plt.xticks([]), plt.yticks([])\n",
    "plt.subplot(2,2,4),plt.imshow(sobely,cmap = 'gray')\n",
    "plt.title('Sobel Y'), plt.xticks([]), plt.yticks([])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Canny Edge Detector "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "img = cv2.imread('images/duckietown.jpg',0)\n",
    "edges = cv2.Canny(img,100,200)\n",
    "\n",
    "#img1 = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "plt.subplot(121),plt.imshow(img, cmap = 'gray')\n",
    "plt.title('Original Image'), plt.xticks([]), plt.yticks([])\n",
    "plt.subplot(122),plt.imshow(edges,cmap = 'gray')\n",
    "plt.title('Edge Image'), plt.xticks([]), plt.yticks([])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = cv2.imread('./images/line.jpg',0)\n",
    "edges = cv2.Canny(img,30, 60)\n",
    "\n",
    "plt.subplot(121),plt.imshow(img, cmap = 'gray')\n",
    "plt.title('Original Image'), plt.xticks([]), plt.yticks([])\n",
    "plt.subplot(122),plt.imshow(edges,cmap = 'gray')\n",
    "plt.title('Edge Image'), plt.xticks([]), plt.yticks([])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = cv2.imread('./images/lena.bmp',0)\n",
    "edges = cv2.Canny(img,100, 200)\n",
    "\n",
    "plt.subplot(121),plt.imshow(img, cmap = 'gray')\n",
    "plt.title('Original Image'), plt.xticks([]), plt.yticks([])\n",
    "plt.subplot(122),plt.imshow(edges,cmap = 'gray')\n",
    "plt.title('Edge Image'), plt.xticks([]), plt.yticks([])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#  Check Point!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use your Duckiebot to take a picture of the Road.\n",
    "\n",
    "## Send Picture to your laptop\n",
    "\n",
    "## Use Jupyter Notebook & Canny Edge Detector to draw out the edges of the lines.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hint : \n",
    "### Command for taking picture on Rpi : duckiebot@ raspistill -t 1 -o out.jpg\n",
    "### Command for coping picture from Rpi to laptop : laptop@ scp ubuntu@\"duckiebot\".local:~/out.jpg out.jpg\n",
    "### You can modify the code in this file if you have no clue on drawing the edges on the lines.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}