Trials.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Libraries\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "import matplotlib.image as mpimg\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from skimage.feature import hog\n",
    "%pylab inline\n",
    "pylab.rcParams['figure.figsize'] = (10, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0. Directories and Util Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "VEHICLE_DATA = 'Data/vehicles/vehicles/GTI_Far'\n",
    "NON_VEHICLE_DATA = 'Data/non-vehicles/non-vehicles/GTI'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "''' Function to load images handling different extensions.\n",
    "    It can load images in grayscale. '''\n",
    "\n",
    "def load_image(path, gray = False):\n",
    "    extension = path.split('/')[-1].split('.')[-1]\n",
    "    \n",
    "    if extension == 'png':\n",
    "        if gray:\n",
    "            image = cv2.cvtColor(cv2.imread(path), cv2.COLOR_BGR2GRAY)\n",
    "        else:\n",
    "            image = cv2.cvtColor(cv2.imread(path), cv2.COLOR_BGR2RGB)\n",
    "    elif extension == 'jpg':\n",
    "        image = mpimg.imread(path)\n",
    "        if gray:\n",
    "            image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)\n",
    "        \n",
    "    return image\n",
    "\n",
    "\n",
    "''' Function to print images side by side to facilitade comparinson'''\n",
    "\n",
    "def plot_images(list_images, list_labels, list_cmap = None):\n",
    "    if(not list_cmap):\n",
    "        list_cmap = [None] * len(list_images)\n",
    "    \n",
    "    assert len(list_images) == len(list_labels) == len(list_cmap)\n",
    "    \n",
    "    plot_id = 121\n",
    "    ids = []\n",
    "    fig = plt.figure()\n",
    "    for i, image in enumerate(list_images):\n",
    "        plt.subplot(plot_id)\n",
    "        ids.append(plot_id)\n",
    "        plot_id += 1\n",
    "        plt.imshow(image, cmap=list_cmap[i])\n",
    "        plt.title(list_labels[i])\n",
    "    return ids\n",
    "\n",
    "\n",
    "''' Plot a 3D graph '''\n",
    "\n",
    "def plot3d(pixels, colors_rgb,\n",
    "        axis_labels=list(\"RGB\"), axis_limits=[(0, 255), (0, 255), (0, 255)]):\n",
    "    \"\"\"Plot pixels in 3D.\"\"\"\n",
    "\n",
    "    # Create figure and 3D axes\n",
    "    fig = plt.figure(figsize=(8, 8))\n",
    "    ax = Axes3D(fig)\n",
    "\n",
    "    # Set axis limits\n",
    "    ax.set_xlim(*axis_limits[0])\n",
    "    ax.set_ylim(*axis_limits[1])\n",
    "    ax.set_zlim(*axis_limits[2])\n",
    "\n",
    "    # Set axis labels and sizes\n",
    "    ax.tick_params(axis='both', which='major', labelsize=14, pad=8)\n",
    "    ax.set_xlabel(axis_labels[0], fontsize=16, labelpad=16)\n",
    "    ax.set_ylabel(axis_labels[1], fontsize=16, labelpad=16)\n",
    "    ax.set_zlabel(axis_labels[2], fontsize=16, labelpad=16)\n",
    "\n",
    "    # Plot pixel values with colors given in colors_rgb\n",
    "    ax.scatter(\n",
    "        pixels[:, :, 0].ravel(),\n",
    "        pixels[:, :, 1].ravel(),\n",
    "        pixels[:, :, 2].ravel(),\n",
    "        c=colors_rgb.reshape((-1, 3)), edgecolors='none')\n",
    "\n",
    "    return ax  # return Axes3D object for further manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "'''Define a function to return HOG features and visualization'''\n",
    "\n",
    "def get_hog_features(img, orient, pix_per_cell, cell_per_block, \n",
    "                        vis=False, feature_vec=True):\n",
    "    # Call with two outputs if vis==True\n",
    "    if vis == True:\n",
    "        features, hog_image = hog(img, orientations=orient, \n",
    "                                  pixels_per_cell=(pix_per_cell, pix_per_cell),\n",
    "                                  cells_per_block=(cell_per_block, cell_per_block), \n",
    "                                  transform_sqrt=True, \n",
    "                                  visualise=vis, feature_vector=feature_vec)\n",
    "        return features, hog_image\n",
    "    # Otherwise call with one output\n",
    "    else:      \n",
    "        features = hog(img, orientations=orient, \n",
    "                       pixels_per_cell=(pix_per_cell, pix_per_cell),\n",
    "                       cells_per_block=(cell_per_block, cell_per_block), \n",
    "                       transform_sqrt=True, \n",
    "                       visualise=vis, feature_vector=feature_vec)\n",
    "        return features\n",
    "\n",
    "    \n",
    "''' Define a function to compute binned color features '''\n",
    "\n",
    "def bin_spatial(img, size=(32, 32)):\n",
    "    # Use cv2.resize().ravel() to create the feature vector\n",
    "    features = cv2.resize(img, size).ravel() \n",
    "    # Return the feature vector\n",
    "    return features\n",
    "\n",
    "\n",
    "''' Define a function to compute color histogram features '''\n",
    "\n",
    "# NEED TO CHANGE bins_range if reading .png files with mpimg!\n",
    "def color_hist(img, nbins=32, bins_range=(0, 256)):\n",
    "    # Compute the histogram of the color channels separately\n",
    "    channel1_hist = np.histogram(img[:,:,0], bins=nbins, range=bins_range)\n",
    "    channel2_hist = np.histogram(img[:,:,1], bins=nbins, range=bins_range)\n",
    "    channel3_hist = np.histogram(img[:,:,2], bins=nbins, range=bins_range)\n",
    "    # Concatenate the histograms into a single feature vector\n",
    "    hist_features = np.concatenate((channel1_hist[0], channel2_hist[0], channel3_hist[0]))\n",
    "    # Return the individual histograms, bin_centers and feature vector\n",
    "    return hist_features\n",
    "\n",
    "\n",
    "# Define a function to extract features from a list of images\n",
    "# Have this function call bin_spatial() and color_hist()\n",
    "def extract_features(imgs, color_space='RGB', spatial_size=(32, 32),\n",
    "                        hist_bins=32, orient=9, \n",
    "                        pix_per_cell=8, cell_per_block=2, hog_channel=0,\n",
    "                        spatial_feat=True, hist_feat=True, hog_feat=True):\n",
    "    # Create a list to append feature vectors to\n",
    "    features = []\n",
    "    # Iterate through the list of images\n",
    "    for file in imgs:\n",
    "        file_features = []\n",
    "        # Read in each one by one\n",
    "#         image = mpimg.imread(file)\n",
    "        image = load_image(file)\n",
    "        # apply color conversion if other than 'RGB'\n",
    "        if color_space != 'RGB':\n",
    "            if color_space == 'HSV':\n",
    "                feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)\n",
    "            elif color_space == 'LUV':\n",
    "                feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2LUV)\n",
    "            elif color_space == 'HLS':\n",
    "                feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2HLS)\n",
    "            elif color_space == 'YUV':\n",
    "                feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2YUV)\n",
    "            elif color_space == 'YCrCb':\n",
    "                feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2YCrCb)\n",
    "        else: feature_image = np.copy(image)      \n",
    "\n",
    "        if spatial_feat == True:\n",
    "            spatial_features = bin_spatial(feature_image, size=spatial_size)\n",
    "            file_features.append(spatial_features)\n",
    "        if hist_feat == True:\n",
    "            # Apply color_hist()\n",
    "            hist_features = color_hist(feature_image, nbins=hist_bins)\n",
    "            file_features.append(hist_features)\n",
    "        if hog_feat == True:\n",
    "        # Call get_hog_features() with vis=False, feature_vec=True\n",
    "            if hog_channel == 'ALL':\n",
    "                hog_features = []\n",
    "                for channel in range(feature_image.shape[2]):\n",
    "                    hog_features.append(get_hog_features(feature_image[:,:,channel], \n",
    "                                        orient, pix_per_cell, cell_per_block, \n",
    "                                        vis=False, feature_vec=True))\n",
    "                hog_features = np.ravel(hog_features)        \n",
    "            else:\n",
    "                hog_features = get_hog_features(feature_image[:,:,hog_channel], orient, \n",
    "                            pix_per_cell, cell_per_block, vis=False, feature_vec=True)\n",
    "            # Append the new feature vector to the features list\n",
    "            file_features.append(hog_features)\n",
    "        features.append(np.concatenate(file_features))\n",
    "    # Return list of feature vectors\n",
    "    return features\n",
    "    \n",
    "# Define a function that takes an image,\n",
    "# start and stop positions in both x and y, \n",
    "# window size (x and y dimensions),  \n",
    "# and overlap fraction (for both x and y)\n",
    "def slide_window(img, x_start_stop=[None, None], y_start_stop=[None, None], \n",
    "                    xy_window=(64, 64), xy_overlap=(0.5, 0.5)):\n",
    "    # If x and/or y start/stop positions not defined, set to image size\n",
    "    if x_start_stop[0] == None:\n",
    "        x_start_stop[0] = 0\n",
    "    if x_start_stop[1] == None:\n",
    "        x_start_stop[1] = img.shape[1]\n",
    "    if y_start_stop[0] == None:\n",
    "        y_start_stop[0] = 0\n",
    "    if y_start_stop[1] == None:\n",
    "        y_start_stop[1] = img.shape[0]\n",
    "    # Compute the span of the region to be searched    \n",
    "    xspan = x_start_stop[1] - x_start_stop[0]\n",
    "    yspan = y_start_stop[1] - y_start_stop[0]\n",
    "    # Compute the number of pixels per step in x/y\n",
    "    nx_pix_per_step = np.int(xy_window[0]*(1 - xy_overlap[0]))\n",
    "    ny_pix_per_step = np.int(xy_window[1]*(1 - xy_overlap[1]))\n",
    "    # Compute the number of windows in x/y\n",
    "    nx_buffer = np.int(xy_window[0]*(xy_overlap[0]))\n",
    "    ny_buffer = np.int(xy_window[1]*(xy_overlap[1]))\n",
    "    nx_windows = np.int((xspan-nx_buffer)/nx_pix_per_step) \n",
    "    ny_windows = np.int((yspan-ny_buffer)/ny_pix_per_step) \n",
    "    # Initialize a list to append window positions to\n",
    "    window_list = []\n",
    "    # Loop through finding x and y window positions\n",
    "    # Note: you could vectorize this step, but in practice\n",
    "    # you'll be considering windows one by one with your\n",
    "    # classifier, so looping makes sense\n",
    "    for ys in range(ny_windows):\n",
    "        for xs in range(nx_windows):\n",
    "            # Calculate window position\n",
    "            startx = xs*nx_pix_per_step + x_start_stop[0]\n",
    "            endx = startx + xy_window[0]\n",
    "            starty = ys*ny_pix_per_step + y_start_stop[0]\n",
    "            endy = starty + xy_window[1]\n",
    "            \n",
    "            # Append window position to list\n",
    "            window_list.append(((startx, starty), (endx, endy)))\n",
    "    # Return the list of windows\n",
    "    return window_list\n",
    "\n",
    "# Define a function to draw bounding boxes\n",
    "def draw_boxes(img, bboxes, color=(0, 0, 255), thick=6):\n",
    "    # Make a copy of the image\n",
    "    imcopy = np.copy(img)\n",
    "    # Iterate through the bounding boxes\n",
    "    for bbox in bboxes:\n",
    "        # Draw a rectangle given bbox coordinates\n",
    "        cv2.rectangle(imcopy, bbox[0], bbox[1], color, thick)\n",
    "    # Return the image copy with boxes drawn\n",
    "    return imcopy\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Extract Image Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([156, 168, 163, ..., 161, 161, 142], dtype=uint8)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img = load_image(VEHICLE_DATA + '/image0000.png')\n",
    "\n",
    "# plt.imshow(img)\n",
    "\n",
    "bin_spatial(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/asgalioth/tensorflow/lib/python3.5/site-packages/skimage/feature/_hog.py:119: skimage_deprecation: Default value of `block_norm`==`L1` is deprecated and will be changed to `L2-Hys` in v0.15\n",
      "  'be changed to `L2-Hys` in v0.15', skimage_deprecation)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[121, 122]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlMAAAEtCAYAAAAsgeXEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f260c183400>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "img = load_image(VEHICLE_DATA + '/image0000.png', gray=True)\n",
    "img.shape\n",
    "\n",
    "orient = 9\n",
    "pix_per_cell = 8\n",
    "cell_per_block = 2\n",
    "\n",
    "# get_hog_features(img, orient, pix_per_cell, cell_per_block, vis=False, feature_vec=True)\n",
    "\n",
    "features, imgHOG = get_hog_features(img, orient, pix_per_cell, cell_per_block, vis=True, feature_vec=False)\n",
    "\n",
    "plot_images([img, imgHOG], ['Normal', 'HOG'], ['gray', 'gray'])"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tensorflow",
   "language": "python",
   "name": "tensorflow"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}