object_detection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "returning-thursday",
   "metadata": {},
   "source": [
    "# Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "deluxe-hearing",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.image as mpimg\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import cv2\n",
    "import os\n",
    "import time\n",
    "import pickle\n",
    "from sklearn.svm import LinearSVC\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from skimage.feature import hog\n",
    "from sklearn.model_selection import train_test_split\n",
    "from scipy.ndimage.measurements import label\n",
    "from moviepy.editor import VideoFileClip\n",
    "from IPython.display import HTML\n",
    "from skimage.feature import hog\n",
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "given-columbus",
   "metadata": {},
   "source": [
    "# Loading in Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "color-socket",
   "metadata": {},
   "outputs": [],
   "source": [
    "def grab_files(root):\n",
    "    dataset = []\n",
    "    for path, dirs, files in os.walk(root):\n",
    "        for file in files:\n",
    "            if '.DS_Store' not in file:\n",
    "                dataset.append(os.path.join(path, file))\n",
    "    return dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "smoking-chemistry",
   "metadata": {},
   "outputs": [],
   "source": [
    "cars = grab_files(\"./vehicles\")\n",
    "notcars = grab_files(\"./non-vehicles\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "architectural-grenada",
   "metadata": {},
   "outputs": [],
   "source": [
    "color_space = 'YCrCb' \n",
    "orient = 8\n",
    "pix_per_cell = 8 \n",
    "cell_per_block = 2 \n",
    "hog_channel = 'ALL'\n",
    "spatial_size = (16, 16) \n",
    "hist_bins = 32\n",
    "spatial_feat = True\n",
    "hist_feat = True\n",
    "hog_feat = True \n",
    "y_start_stop = [400,700]\n",
    "scale = 1.5\n",
    "xy_window = (64,64)\n",
    "xy_overlap = (0.85,0.85)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "palestinian-mercury",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bin_spatial(img, size=(32, 32)):\n",
    "    color1 = cv2.resize(img[:,:,0], size).ravel()\n",
    "    color2 = cv2.resize(img[:,:,1], size).ravel()\n",
    "    color3 = cv2.resize(img[:,:,2], size).ravel()\n",
    "    return np.hstack((color1, color2, color3))\n",
    "\n",
    "def color_hist(img, nbins=32, bins_range=(0, 256)):\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",
    "    hist_features = np.concatenate((channel1_hist[0], channel2_hist[0], channel3_hist[0]))\n",
    "    return hist_features\n",
    "\n",
    "def convert_image(image, cspace):\n",
    "\n",
    "    if cspace != 'RGB':\n",
    "        if cspace == 'HSV':\n",
    "            feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)\n",
    "        elif cspace == 'LUV':\n",
    "            feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2LUV)\n",
    "        elif cspace == 'HLS':\n",
    "            feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2HLS)\n",
    "        elif cspace == 'YUV':\n",
    "            feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2YUV)\n",
    "        elif cspace == 'YCrCb':\n",
    "            feature_image = cv2.cvtColor(image, cv2.COLOR_RGB2YCrCb)\n",
    "    else: \n",
    "        feature_image = np.copy(image) \n",
    "        \n",
    "    return feature_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "designing-tragedy",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_hog_features(img, orient, pix_per_cell, cell_per_block, \n",
    "                        vis=False, feature_vec=True):\n",
    "    if vis == True:\n",
    "        features, hog_image = hog(img, orientations=orient, \n",
    "                                  pixels_per_cell=(pix_per_cell, pix_per_cell),\n",
    "                                  block_norm= 'L2-Hys',\n",
    "                                  cells_per_block=(cell_per_block, cell_per_block), \n",
    "                                  transform_sqrt=True, \n",
    "                                  visualize=vis, feature_vector=feature_vec)\n",
    "        return features, hog_image\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",
    "                       block_norm= 'L2-Hys',\n",
    "                       transform_sqrt=True, \n",
    "                       visualize=vis, feature_vector=feature_vec)\n",
    "        return features\n",
    "\n",
    "def single_img_features(img, color_space='YCrCb', spatial_size=(16, 16),\n",
    "                        hist_bins=32, orient=8, \n",
    "                        pix_per_cell=8, cell_per_block=2, hog_channel=\"ALL\",\n",
    "                        spatial_feat=True, hist_feat=True, hog_feat=True):    \n",
    "    img_features = []\n",
    "    feature_image = convert_image(img,color_space)    \n",
    "        \n",
    "    if spatial_feat == True:\n",
    "        spatial_features = bin_spatial(feature_image, size=spatial_size)\n",
    "        img_features.append(spatial_features)\n",
    "    if hist_feat == True:\n",
    "        hist_features = color_hist(feature_image, nbins=hist_bins)\n",
    "        img_features.append(hist_features)\n",
    "    if hog_feat == True:\n",
    "        if hog_channel == 'ALL':\n",
    "            hog_features = []\n",
    "            for channel in range(feature_image.shape[2]):\n",
    "                hog_features.extend(get_hog_features(feature_image[:,:,channel], \n",
    "                                    orient, pix_per_cell, cell_per_block, \n",
    "                                    vis=False, feature_vec=True))      \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",
    "        img_features.append(hog_features)\n",
    "\n",
    "    return np.concatenate(img_features)\n",
    "\n",
    "def extract_features(imgs, color_space='YCrCb', spatial_size=(16,16),\n",
    "                        hist_bins=32, orient=8, \n",
    "                        pix_per_cell=8, cell_per_block=2, hog_channel=\"ALL\",\n",
    "                        spatial_feat=True, hist_feat=True, hog_feat=True):\n",
    "    features = []\n",
    "    for file in imgs:\n",
    "        file_features = []\n",
    "        # Read in each one by one\n",
    "        image = cv2.imread(file)\n",
    "        feature_image = convert_image(image,color_space)    \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",
    "            hist_features = color_hist(feature_image, nbins=hist_bins)\n",
    "            file_features.append(hist_features)\n",
    "        if hog_feat == 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",
    "            file_features.append(hog_features)\n",
    "        features.append(np.concatenate(file_features))\n",
    "    return features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "solid-russia",
   "metadata": {},
   "outputs": [],
   "source": [
    "car_features = extract_features(cars, color_space=color_space, \n",
    "                        spatial_size=spatial_size, hist_bins=hist_bins, \n",
    "                        orient=orient, pix_per_cell=pix_per_cell, \n",
    "                        cell_per_block=cell_per_block, \n",
    "                        hog_channel=hog_channel, spatial_feat=spatial_feat, \n",
    "                        hist_feat=hist_feat, hog_feat=hog_feat)\n",
    "notcar_features = extract_features(notcars, color_space=color_space, \n",
    "                        spatial_size=spatial_size, hist_bins=hist_bins, \n",
    "                        orient=orient, pix_per_cell=pix_per_cell, \n",
    "                        cell_per_block=cell_per_block, \n",
    "                        hog_channel=hog_channel, spatial_feat=spatial_feat, \n",
    "                        hist_feat=hist_feat, hog_feat=hog_feat)\n",
    "\n",
    "X = np.vstack((car_features, notcar_features)).astype(np.float64)\n",
    "y = np.hstack((np.ones(len(car_features)), np.zeros(len(notcar_features))))\n",
    "\n",
    "rand_state = np.random.randint(0, 100)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=rand_state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dependent-gentleman",
   "metadata": {},
   "outputs": [],
   "source": [
    "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 9))\n",
    "\n",
    "i = cv2.cvtColor(cv2.imread(random.choice(cars)),cv2.COLOR_BGR2RGB)\n",
    "j = cv2.cvtColor(cv2.imread(random.choice(notcars)),cv2.COLOR_BGR2RGB)\n",
    "\n",
    "car_feat = single_img_features(img=i, color_space=color_space, spatial_size=spatial_size,\n",
    "                        hist_bins=hist_bins, orient=orient, \n",
    "                        pix_per_cell=pix_per_cell, cell_per_block=cell_per_block, hog_channel=hog_channel,\n",
    "                        spatial_feat=spatial_feat, hist_feat=hist_feat, hog_feat=hog_feat)\n",
    "notcar_feat = single_img_features(img=j, color_space=color_space, spatial_size=spatial_size,\n",
    "                        hist_bins=hist_bins, orient=orient, \n",
    "                        pix_per_cell=pix_per_cell, cell_per_block=cell_per_block, hog_channel=hog_channel,\n",
    "                        spatial_feat=spatial_feat, hist_feat=hist_feat, hog_feat=hog_feat)\n",
    "ax1.plot(car_feat)\n",
    "ax1.set_title(\"Car Spatial features\")\n",
    "ax2.plot(notcar_feat)\n",
    "ax2.set_title(\"Non-car Spatial features\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "detailed-appreciation",
   "metadata": {},
   "outputs": [],
   "source": [
    "car1 = cv2.cvtColor(cv2.imread(cars[0]),cv2.COLOR_BGR2RGB)\n",
    "not_car1 = cv2.cvtColor(cv2.imread(notcars[0]),cv2.COLOR_BGR2RGB)\n",
    "\n",
    "_, hog1 = get_hog_features(car1, orient, pix_per_cell, cell_per_block, vis=True, feature_vec=True)\n",
    "_, hog2 = get_hog_features(not_car1, orient, pix_per_cell, cell_per_block, vis=True, feature_vec=True)\n",
    "\n",
    "f, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, figsize=(20,10))\n",
    "ax1.set_title('Vehicle')\n",
    "ax1.imshow(car1, cmap='gray')\n",
    "ax2.set_title('Vehicle hog')\n",
    "ax2.imshow(hog1, cmap='gray')\n",
    "ax3.set_title('Non-vehicle')\n",
    "ax3.imshow(not_car1, cmap='gray')\n",
    "ax4.set_title('Non-vehicle hog')\n",
    "ax4.imshow(hog2, cmap='gray')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "existing-brick",
   "metadata": {},
   "source": [
    "# SVM Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ambient-nicholas",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_scaler = StandardScaler().fit(X_train)\n",
    "X_train = X_scaler.transform(X_train)\n",
    "X_test = X_scaler.transform(X_test)\n",
    "\n",
    "print('Using:',orient,'orientations',pix_per_cell,\n",
    "    'pixels per cell and', cell_per_block,'cells per block')\n",
    "print('Feature vector length:', len(X_train[0]))\n",
    "\n",
    "svc = LinearSVC()\n",
    "\n",
    "t=time.time()\n",
    "\n",
    "svc.fit(X_train, y_train)\n",
    "\n",
    "t2 = time.time()\n",
    "\n",
    "print(round(t2-t, 2), 'Seconds to train SVC...')\n",
    "\n",
    "print('Test Accuracy of SVC = ', round(svc.score(X_test, y_test), 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "atlantic-entertainment",
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_boxes(img, bboxes, color=(0, 0, 255), thick=6):\n",
    "    imcopy = np.copy(img)\n",
    "    for bbox in bboxes:\n",
    "        cv2.rectangle(imcopy, bbox[0], bbox[1], color, thick)\n",
    "    return imcopy\n",
    "\n",
    "def slide_window(img, x_start_stop=[None, None], y_start_stop=[400,700], \n",
    "                    xy_window=(64, 64), xy_overlap=(0.85, 0.85)):\n",
    "    \n",
    "    \n",
    "    x_start_stop = [0,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",
    "    xspan = x_start_stop[1] - x_start_stop[0]\n",
    "    yspan = y_start_stop[1] - y_start_stop[0]\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",
    "    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",
    "\n",
    "    window_list = []\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",
    "            window_list.append(((startx, starty), (endx, endy)))\n",
    "    return window_list \n",
    "\n",
    "def find_cars(img, clf, scaler, color_space='YCrCb', \n",
    "                    spatial_size=(16, 16), hist_bins=32, \n",
    "                    hist_range=(0, 256), orient=8, \n",
    "                    pix_per_cell=8, cell_per_block=2, \n",
    "                    hog_channel=\"ALL\", spatial_feat=True, \n",
    "                    hist_feat=True, hog_feat=True):\n",
    "\n",
    "    windows = slide_window(img, y_start_stop=y_start_stop, xy_window=xy_window, xy_overlap=xy_overlap)\n",
    "    on_windows = []\n",
    "    for window in windows:\n",
    "        test_img = cv2.resize(img[window[0][1]:window[1][1], window[0][0]:window[1][0]], (64,64))      \n",
    "        features = single_img_features(test_img, color_space=color_space, \n",
    "                            spatial_size=spatial_size, hist_bins=hist_bins, \n",
    "                            orient=orient, pix_per_cell=pix_per_cell, \n",
    "                            cell_per_block=cell_per_block, \n",
    "                            hog_channel=hog_channel, spatial_feat=spatial_feat, \n",
    "                            hist_feat=hist_feat, hog_feat=hog_feat)\n",
    "        test_features = scaler.transform(np.array(features).reshape(1, -1))\n",
    "        prediction = clf.predict(test_features)\n",
    "        if prediction == 1:\n",
    "            on_windows.append(window)\n",
    "    return on_windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fewer-relative",
   "metadata": {},
   "outputs": [],
   "source": [
    "img = cv2.cvtColor(cv2.imread('test_img/test1.jpg'),cv2.COLOR_BGR2RGB)\n",
    "car_loc = find_cars(img, svc, X_scaler, color_space=color_space, \n",
    "                        spatial_size=spatial_size, hist_bins=hist_bins, \n",
    "                        orient=orient, pix_per_cell=pix_per_cell, \n",
    "                        cell_per_block=cell_per_block, \n",
    "                        hog_channel=hog_channel, spatial_feat=spatial_feat, \n",
    "                        hist_feat=hist_feat, hog_feat=hog_feat) \n",
    "out_img = draw_boxes(image, car_loc)\n",
    "plt.imshow(out_img)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "civil-exception",
   "metadata": {},
   "source": [
    "# Heat Pipeline + False Positives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "registered-delivery",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_heat(heatmap, bbox_list):\n",
    "    for box in bbox_list:\n",
    "        heatmap[box[0][1]:box[1][1], box[0][0]:box[1][0]] += 1\n",
    "    return heatmap\n",
    "    \n",
    "def apply_threshold(heatmap, threshold):\n",
    "    heatmap[heatmap <= threshold] = 0\n",
    "    return heatmap\n",
    "\n",
    "def draw_labeled_bboxes(img, labels):\n",
    "    for car_number in range(1, labels[1]+1):\n",
    "        nonzero = (labels[0] == car_number).nonzero()\n",
    "        nonzeroy = np.array(nonzero[0])\n",
    "        nonzerox = np.array(nonzero[1])\n",
    "        bbox = ((np.min(nonzerox), np.min(nonzeroy)), (np.max(nonzerox), np.max(nonzeroy)))\n",
    "        cv2.rectangle(img, bbox[0], bbox[1], (0,0,255), 6)\n",
    "    return img\n",
    "\n",
    "def heat_pipeline(img,car_loc):\n",
    "    heat = np.zeros_like(img[:,:,0]).astype(np.float)\n",
    "    heat = add_heat(heat,car_loc)\n",
    "    heat = apply_threshold(heat,1)\n",
    "    heatmap = np.clip(heat, 0, 255)\n",
    "    labels = label(heatmap)\n",
    "    \n",
    "    return heatmap, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adolescent-mortality",
   "metadata": {},
   "outputs": [],
   "source": [
    "def vis_img(img):\n",
    "    \n",
    "    car_loc = find_cars(img, svc, X_scaler, color_space=color_space, \n",
    "                            spatial_size=spatial_size, hist_bins=hist_bins, \n",
    "                            orient=orient, pix_per_cell=pix_per_cell, \n",
    "                            cell_per_block=cell_per_block, \n",
    "                            hog_channel=hog_channel, spatial_feat=spatial_feat, \n",
    "                            hist_feat=hist_feat, hog_feat=hog_feat)    \n",
    "    heatmap, labels = heat_pipeline(img,car_loc)\n",
    "    draw_img = draw_labeled_bboxes(np.copy(img), labels)\n",
    "    \n",
    "    f, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 9))\n",
    "    ax1.imshow(draw_img)\n",
    "    ax2.imshow(heatmap, cmap='hot')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "square-hours",
   "metadata": {},
   "outputs": [],
   "source": [
    "img = cv2.cvtColor(cv2.imread('test_img/test1.jpg'),cv2.COLOR_BGR2RGB)\n",
    "vis_img(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fantastic-montana",
   "metadata": {},
   "source": [
    "# HOG Subsampling Window Search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "loving-edward",
   "metadata": {},
   "outputs": [],
   "source": [
    "def hog_sub_find_cars(img, color_space, ystart, ystop, scale, svc, X_scaler, orient, pix_per_cell, cell_per_block, spatial_size, hist_bins, window):\n",
    "    \n",
    "    draw_img = np.copy(img)\n",
    "    \n",
    "    img_tosearch = img[ystart:ystop,:,:]\n",
    "    \n",
    "    if color_space != 'RGB':\n",
    "        ctrans_tosearch = convert_image(img_tosearch,color_space)\n",
    "    else: \n",
    "        ctrans_tosearch = np.copy(img_tosearch)  \n",
    "        \n",
    "    if scale != 1:\n",
    "        imshape = ctrans_tosearch.shape\n",
    "        ctrans_tosearch = cv2.resize(ctrans_tosearch, (np.int(imshape[1]/scale), np.int(imshape[0]/scale)))\n",
    "        \n",
    "    ch1 = ctrans_tosearch[:,:,0]\n",
    "    ch2 = ctrans_tosearch[:,:,1]\n",
    "    ch3 = ctrans_tosearch[:,:,2]\n",
    "\n",
    "    nxblocks = (ch1.shape[1] // pix_per_cell) - cell_per_block + 1\n",
    "    nyblocks = (ch1.shape[0] // pix_per_cell) - cell_per_block + 1 \n",
    "    nfeat_per_block = orient*cell_per_block**2\n",
    "\n",
    "    window = 64\n",
    "    nblocks_per_window = (window // pix_per_cell) - cell_per_block + 1\n",
    "    cells_per_step = 1  # Instead of overlap, define how many cells to step\n",
    "    nxsteps = (nxblocks - nblocks_per_window) // cells_per_step \n",
    "    nysteps = (nyblocks - nblocks_per_window) // cells_per_step \n",
    "\n",
    "    hog1 = get_hog_features(ch1, orient, pix_per_cell, cell_per_block, feature_vec=False)\n",
    "    hog2 = get_hog_features(ch2, orient, pix_per_cell, cell_per_block, feature_vec=False)\n",
    "    hog3 = get_hog_features(ch3, orient, pix_per_cell, cell_per_block, feature_vec=False)\n",
    "    \n",
    "    car_windows=[]\n",
    "    for xb in range(nxsteps):\n",
    "        for yb in range(nysteps):\n",
    "            ypos = yb*cells_per_step\n",
    "            xpos = xb*cells_per_step\n",
    "\n",
    "            hog_feat1 = hog1[ypos:ypos+nblocks_per_window, xpos:xpos+nblocks_per_window].ravel() \n",
    "            hog_feat2 = hog2[ypos:ypos+nblocks_per_window, xpos:xpos+nblocks_per_window].ravel() \n",
    "            hog_feat3 = hog3[ypos:ypos+nblocks_per_window, xpos:xpos+nblocks_per_window].ravel() \n",
    "            hog_features = np.hstack((hog_feat1, hog_feat2, hog_feat3))\n",
    "\n",
    "            xleft = xpos*pix_per_cell\n",
    "            ytop = ypos*pix_per_cell\n",
    "\n",
    "            subimg = cv2.resize(ctrans_tosearch[ytop:ytop+window, xleft:xleft+window], (64,64))\n",
    "\n",
    "            spatial_features = bin_spatial(subimg, size=spatial_size)\n",
    "            hist_features = color_hist(subimg, nbins=hist_bins)\n",
    "\n",
    "            test_features = X_scaler.transform(np.hstack((spatial_features, hist_features, hog_features)).reshape(1, -1))    \n",
    "            test_prediction = svc.predict(test_features)\n",
    "            \n",
    "            if test_prediction == 1:\n",
    "                xbox_left = np.int(xleft*scale)\n",
    "                ytop_draw = np.int(ytop*scale)\n",
    "                win_draw = np.int(window*scale)\n",
    "                cv2.rectangle(draw_img,(xbox_left, ytop_draw+ystart),(xbox_left+win_draw,ytop_draw+win_draw+ystart),(0,0,255),6) \n",
    "                car_windows.append(((xbox_left, ytop_draw+ystart),(xbox_left+win_draw,ytop_draw+win_draw+ystart)))\n",
    "                \n",
    "    return car_windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "alternative-tribute",
   "metadata": {},
   "outputs": [],
   "source": [
    "read_img = mpimg.imread('test_img/test1.jpg')\n",
    "car_loc = hog_sub_find_cars(img=read_img, color_space=color_space, ystart=400, ystop=550, scale=scale, svc=svc, X_scaler=X_scaler, \n",
    "                    orient=orient, pix_per_cell=pix_per_cell, cell_per_block=cell_per_block, spatial_size=spatial_size, hist_bins=hist_bins, window=64)    \n",
    "\n",
    "heatmap, labels = heat_pipeline(read_img,car_loc)\n",
    "draw_img = draw_labeled_bboxes(np.copy(read_img), labels)\n",
    "\n",
    "f, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 9))\n",
    "ax1.imshow(draw_img)\n",
    "ax2.imshow(heatmap, cmap='hot')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "widespread-plasma",
   "metadata": {},
   "source": [
    "# Writing out video "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "standard-subcommittee",
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_img(image):\n",
    "    car_loc = find_cars(image, svc, X_scaler, color_space=color_space, \n",
    "                                spatial_size=spatial_size, hist_bins=hist_bins, \n",
    "                                orient=orient, pix_per_cell=pix_per_cell, \n",
    "                                cell_per_block=cell_per_block, \n",
    "                                hog_channel=hog_channel, spatial_feat=spatial_feat, \n",
    "                                hist_feat=hist_feat, hog_feat=hog_feat)    \n",
    "    heatmap, labels = heat_pipeline(image,car_loc)\n",
    "    draw_img = draw_labeled_bboxes(np.copy(image), labels)\n",
    "    return draw_img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "victorian-console",
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_img(img):\n",
    "    \n",
    "    car_loc = hog_sub_find_cars(img=img, color_space=color_space, ystart=y_start_stop[0], ystop=y_start_stop[1], scale=scale, svc=svc, X_scaler=X_scaler, \n",
    "                    orient=orient, pix_per_cell=pix_per_cell, cell_per_block=cell_per_block, spatial_size=spatial_size, hist_bins=hist_bins, window=xy_window[0])    \n",
    "    heatmap, labels = heat_pipeline(img,car_loc)\n",
    "    draw_img = draw_labeled_bboxes(np.copy(img), labels)      \n",
    "    return draw_img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "beautiful-surge",
   "metadata": {},
   "outputs": [],
   "source": [
    "output_vid = 'final_tracker4.mp4'\n",
    "input_vid = 'project_video.mp4'\n",
    "# input_vid = 'lane_tracker.mp4'\n",
    "\n",
    "clip1 = VideoFileClip(input_vid)\n",
    "video_clip = clip1.fl_image(process_img)\n",
    "video_clip.write_videofile(output_vid, audio=False, fps=30, threads=12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "iraqi-schedule",
   "metadata": {},
   "outputs": [],
   "source": [
    "HTML(\"\"\"\n",
    "<video width=\"1280\" height=\"720\" controls>\n",
    "  <source src=\"{0}\">\n",
    "</video>\n",
    "\"\"\".format(output_vid))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "crude-advance",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}