Advanced-Lane-Lines-Dectection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Self-Driving Car Engineer Nanodegree\n",
    "\n",
    "\n",
    "## Project: **Advanced Lane Finding** \n",
    "***\n",
    "The goals / steps of this project are the following:\n",
    "\n",
    "* Compute the camera calibration matrix and distortion coefficients given a set of chessboard images.\n",
    "* Apply a distortion correction to raw images.\n",
    "* Use color transforms, gradients, etc., to create a thresholded binary image.\n",
    "* Apply a perspective transform to rectify binary image (\"birds-eye view\").\n",
    "* Detect lane pixels and fit to find the lane boundary.\n",
    "* Determine the curvature of the lane and vehicle position with respect to center.\n",
    "* Warp the detected lane boundaries back onto the original image.\n",
    "* Output visual display of the lane boundaries and numerical estimation of lane curvature and vehicle position.   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "import glob\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "import pickle\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calibrata_camera(cal_images,nx=9,ny=6):\n",
    "    objp = np.zeros((nx*ny, 3),np.float32)\n",
    "    objp[:,:2] = np.mgrid[0:nx, 0:ny].T.reshape(-1, 2)\n",
    "    objpoints = [] # 3d points in real world space\n",
    "    imgpoints = [] # 2d points in image plane\n",
    "\n",
    "    for index, image in enumerate(cal_images):\n",
    "        image = cv2.imread(image)\n",
    "        img_size=image.shape[1::-1]\n",
    "        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "        ret, corners = cv2.findChessboardCorners(gray,(9,6),None)\n",
    "        if ret==True:\n",
    "            objpoints.append(objp)\n",
    "            imgpoints.append(corners)\n",
    "            cv2.drawChessboardCorners(image, (nx,ny), corners, ret)\n",
    "            write_name = 'corners_found/'+ str(index)+ '.jpg'\n",
    "            cv2.imwrite(write_name,image)\n",
    "    ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, img_size, None, None)\n",
    "    dist_pickle = {}\n",
    "    dist_pickle[\"mtx\"] = mtx\n",
    "    dist_pickle[\"dist\"] = dist\n",
    "    dist_pickle[\"objpoints\"]=objpoints\n",
    "    dist_pickle[\"imgpoints\"]=imgpoints\n",
    "    pickle.dump( dist_pickle, open( \"camera_cal/dist_pickle.p\", \"wb\" ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cal_undistort(image,cal_file='camera_cal/dist_pickle.p'):\n",
    "    dist_pickle = pickle.load( open( cal_file, \"rb\" ) )\n",
    "    mtx = dist_pickle[\"mtx\"]\n",
    "    dist = dist_pickle[\"dist\"]\n",
    "    undist = cv2.undistort(image,mtx,dist,None,mtx)  \n",
    "    return undist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def abs_sobel_thresh(image, orient='x', sobel_kernel=3, thresh=(0,255)):\n",
    "    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) \n",
    "    sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=sobel_kernel)\n",
    "    sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=sobel_kernel)\n",
    "    abs_sobelx=np.absolute(sobelx)\n",
    "    abs_sobely=np.absolute(sobely)\n",
    "    scaled_sobelx=np.uint8(255*abs_sobelx/np.max(abs_sobelx))\n",
    "    scaled_sobely=np.uint8(255*abs_sobely/np.max(abs_sobely))\n",
    "    if orient=='x':\n",
    "        grad_binary=np.zeros_like(scaled_sobelx)\n",
    "        grad_binary[(scaled_sobelx>=thresh[0])&(scaled_sobelx<=thresh[1])]=1\n",
    "    \n",
    "    elif orient=='y':\n",
    "        grad_binary=np.zeros_like(scaled_sobely)\n",
    "        grad_binary[(scaled_sobely>=thresh[0])&(scaled_sobely<=thresh[1])]=1\n",
    "    return grad_binary\n",
    "\n",
    "def mag_thresh(image, sobel_kernel=3, mag_thresh=(0,255)):\n",
    "    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) \n",
    "    sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=sobel_kernel)\n",
    "    sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=sobel_kernel)\n",
    "    mag=np.sqrt(sobelx**2+sobely**2)\n",
    "    scaled_sobel=np.uint8(255*mag/np.max(mag))\n",
    "    mag_binary=np.zeros_like(scaled_sobel)\n",
    "    mag_binary[(scaled_sobel>=mag_thresh[0])&(scaled_sobel<=mag_thresh[1])]=1\n",
    "    return mag_binary\n",
    "\n",
    "def dir_threshold (image,sobel_kernel=3, thresh=(0, np.pi/2)):\n",
    "    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) \n",
    "    sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=sobel_kernel)\n",
    "    sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=sobel_kernel)\n",
    "    dir_sobel=np.arctan2(np.absolute(sobely),np.absolute(sobelx))\n",
    "    dir_binary=np.zeros_like(dir_sobel)\n",
    "    dir_binary[(dir_sobel>=thresh[0])&(dir_sobel<=thresh[1])]=1\n",
    "    return dir_binary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def combined_gradient(image):\n",
    "    gradx = abs_sobel_thresh(image, orient='x', sobel_kernel=3, thresh=(20, 100)) \n",
    "    grady = abs_sobel_thresh(image, orient='y', sobel_kernel=3, thresh=(20, 100)) \n",
    "    mag_binary = mag_thresh(image, sobel_kernel=3, mag_thresh=(30, 100))\n",
    "    dir_binary = dir_threshold(image, sobel_kernel=15, thresh=(0.6, 1.0))\n",
    "    combined_binary = np.zeros_like(dir_binary)\n",
    "    combined_binary[((gradx == 1) & (grady == 1)) | ((mag_binary == 1) & (dir_binary == 1))] = 1\n",
    "    return combined_binary\n",
    "\n",
    "def hls_hsv_select(img, sthresh=(0, 255), vthresh=(0,255)):\n",
    "    hls = cv2.cvtColor(img, cv2.COLOR_RGB2HLS)\n",
    "    s_channel = hls[:,:,2]\n",
    "    sbinary_output = np.zeros_like(s_channel)\n",
    "    sbinary_output[(s_channel >= sthresh[0]) & (s_channel <= sthresh[1])] = 1\n",
    "    hsv=cv2.cvtColor(img, cv2.COLOR_RGB2HSV)\n",
    "    v_channel=hsv[:,:,2]\n",
    "    vbinary_output = np.zeros_like(v_channel)\n",
    "    vbinary_output[(v_channel >= vthresh[0]) & (v_channel <= vthresh[1])] = 1\n",
    "    output = np.zeros_like(s_channel)\n",
    "    output[(sbinary_output == 1) & (vbinary_output == 1)] = 1\n",
    "    return output\n",
    "\n",
    "\n",
    "def threshold(image):\n",
    "    gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)\n",
    "    gradient_binary = combined_gradient(image)\n",
    "    s_binary=hls_hsv_select(image, sthresh=(100, 255), vthresh=(200,255))\n",
    "    color_binary = np.dstack(( np.zeros_like(gradient_binary), gradient_binary, s_binary)) * 255\n",
    "    combined_binary = np.zeros_like(gradient_binary)\n",
    "    combined_binary[(s_binary == 1) | (gradient_binary == 1)] = 1\n",
    "    return combined_binary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def corners_unwarp(img):\n",
    "    img_size=img.shape[1::-1]\n",
    "    #src=np.float32([[537.6,  475.2], [742.4,  475.2], [1126.4,  673.2], [153.6,  673.2]]) \n",
    "    #dst=np.float32([[422.4,   0.], [857.6,   0.],[857.6, 720.], [422.4, 720.]])\n",
    "    src=np.float32([[200,715],[1150,715],[620,450],[725,450]]) \n",
    "    dst=np.float32([[280,715], [950,715],[280,0], [950,0]])\n",
    "    M=cv2.getPerspectiveTransform(src,dst)\n",
    "    Minv = cv2.getPerspectiveTransform(dst, src)\n",
    "    warped=cv2.warpPerspective(img,M,img_size, flags=cv2.INTER_LINEAR)\n",
    "    \n",
    "    return  warped, Minv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_lanelines(binary_warped):\n",
    "\n",
    "    histogram = np.sum(binary_warped[binary_warped.shape[0]//2:,:], axis=0)\n",
    "    out_img = np.dstack((binary_warped, binary_warped, binary_warped))*255\n",
    "    midpoint = np.int(histogram.shape[0]//2)\n",
    "    leftx_base = np.argmax(histogram[:midpoint])\n",
    "    rightx_base = np.argmax(histogram[midpoint:]) + midpoint\n",
    "    \n",
    "    nwindows = 9\n",
    "    window_height = np.int(binary_warped.shape[0]//nwindows)\n",
    "    nonzero = binary_warped.nonzero()\n",
    "    nonzeroy = np.array(nonzero[0])\n",
    "    nonzerox = np.array(nonzero[1])\n",
    "    \n",
    "    leftx_current = leftx_base\n",
    "    rightx_current = rightx_base\n",
    "    \n",
    "    margin = 100\n",
    "    minpix = 50\n",
    "    \n",
    "    left_lane_inds = []\n",
    "    right_lane_inds = []\n",
    "    \n",
    "    for window in range(nwindows):\n",
    "        win_y_low = binary_warped.shape[0] - (window+1)*window_height\n",
    "        win_y_high = binary_warped.shape[0] - window*window_height\n",
    "        win_xleft_low = leftx_current - margin\n",
    "        win_xleft_high = leftx_current + margin\n",
    "        win_xright_low = rightx_current - margin\n",
    "        win_xright_high = rightx_current + margin\n",
    "        cv2.rectangle(out_img,(win_xleft_low,win_y_low),(win_xleft_high,win_y_high),(0,255,0), 2) \n",
    "        cv2.rectangle(out_img,(win_xright_low,win_y_low),(win_xright_high,win_y_high),(0,255,0), 2) \n",
    "        \n",
    "        good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & \n",
    "                          (nonzerox >= win_xleft_low) &  (nonzerox < win_xleft_high)).nonzero()[0]\n",
    "        good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & \n",
    "                           (nonzerox >= win_xright_low) &  (nonzerox < win_xright_high)).nonzero()[0]\n",
    "        # Append these indices to the lists\n",
    "        left_lane_inds.append(good_left_inds)\n",
    "        right_lane_inds.append(good_right_inds)\n",
    "        # If you found > minpix pixels, recenter next window on their mean position\n",
    "        if len(good_left_inds) > minpix:\n",
    "            leftx_current = np.int(np.mean(nonzerox[good_left_inds]))\n",
    "        if len(good_right_inds) > minpix:        \n",
    "            rightx_current = np.int(np.mean(nonzerox[good_right_inds]))\n",
    "\n",
    "    # Concatenate the arrays of indices\n",
    "    left_lane_inds = np.concatenate(left_lane_inds)\n",
    "    right_lane_inds = np.concatenate(right_lane_inds)\n",
    "\n",
    "    # Extract left and right line pixel positions\n",
    "    leftx = nonzerox[left_lane_inds]\n",
    "    lefty = nonzeroy[left_lane_inds] \n",
    "    rightx = nonzerox[right_lane_inds]\n",
    "    righty = nonzeroy[right_lane_inds] \n",
    "\n",
    "    # Fit a second order polynomial to each\n",
    "    left_fit = np.polyfit(lefty, leftx, 2)\n",
    "    right_fit = np.polyfit(righty, rightx, 2)\n",
    "\n",
    "    # Generate x and y values for plotting\n",
    "    ploty = np.linspace(0, binary_warped.shape[0]-1, binary_warped.shape[0] )\n",
    "    left_fitx = left_fit[0]*ploty**2 + left_fit[1]*ploty + left_fit[2]\n",
    "    right_fitx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]\n",
    "    return ploty, left_fitx, right_fitx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_curvature(binary_warped):\n",
    "\n",
    "    ploty, left_fitx, right_fitx=find_lanelines(binary_warped)\n",
    "    \n",
    "    \n",
    "    # Define conversions in x and y from pixels space to meters\n",
    "    ym_per_pix = 30/720 # meters per pixel in y dimension\n",
    "    xm_per_pix = 3.7/700 # meters per pixel in x dimension\n",
    "\n",
    "    y_eval = np.max(ploty)\n",
    "    # Fit new polynomials to x,y in world space\n",
    "    left_fit_cr = np.polyfit(ploty*ym_per_pix, left_fitx*xm_per_pix, 2)\n",
    "    right_fit_cr = np.polyfit(ploty*ym_per_pix, right_fitx*xm_per_pix, 2)\n",
    "    # Calculate the new radii of curvature\n",
    "    left_curverad = ((1 + (2*left_fit_cr[0]*y_eval*ym_per_pix + left_fit_cr[1])**2)**1.5) / np.absolute(2*left_fit_cr[0])\n",
    "    right_curverad = ((1 + (2*right_fit_cr[0]*y_eval*ym_per_pix + right_fit_cr[1])**2)**1.5) / np.absolute(2*right_fit_cr[0])\n",
    "    # Now our radius of curvature is in meters\n",
    "    #print(left_curverad, 'm', right_curverad, 'm')\n",
    "    # Example values: 632.1 m    626.2 m\n",
    "\n",
    "    img_middle = (left_fitx[-1] + right_fitx[-1])//2\n",
    "    veh_pos = binary_warped.shape[1]//2\n",
    "    dx = (veh_pos - img_middle)*xm_per_pix # Positive if on right, Negative on left\n",
    "\n",
    "    return left_curverad, right_curverad, dx\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vis(undist,warped,Minv):\n",
    "    ploty, left_fitx, right_fitx=find_lanelines(warped)\n",
    "    warp_zero = np.zeros_like(warped).astype(np.uint8)\n",
    "    color_warp = np.dstack((warp_zero, warp_zero, warp_zero))\n",
    "    pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])\n",
    "    pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])\n",
    "    pts = np.hstack((pts_left, pts_right))\n",
    "    cv2.fillPoly(color_warp, np.int_([pts]), (0,255, 0))\n",
    "    newwarp = cv2.warpPerspective(color_warp, Minv, (undist.shape[1], undist.shape[0])) \n",
    "    result = cv2.addWeighted(undist, 1, newwarp, 0.3, 0)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def put_text(image, left_curverad,right_curverad, dx):\n",
    "    font = cv2.FONT_HERSHEY_SIMPLEX\n",
    "    cv2.putText(image,'Left radius of curvature  = %.2f m'%(left_curverad),(50,50), font, 1,(255,255,255),2,cv2.LINE_AA)\n",
    "    cv2.putText(image,'Right radius of curvature = %.2f m'%(right_curverad),(50,80), font, 1,(255,255,255),2,cv2.LINE_AA)\n",
    "    cv2.putText(image,'Vehicle position : %.2f m %s of center'%(abs(dx), 'left' if dx < 0 else 'right'),(50,110),\n",
    "                        font, 1,(255,255,255),2,cv2.LINE_AA)\n",
    "    cv2.putText(image,'sparc-II',(1110,50), font, 1,(255,255,255),2,cv2.LINE_AA)\n",
    "    return image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calibrate Camera"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "cal_images=glob.glob('camera_cal//calibration*.jpg')\n",
    "cal_camera=calibrata_camera(cal_images,nx=9,ny=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Project pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pipeline Steps:**  \n",
    "Camera calibration → Distortion correction → Color/gradient threshold → Perspective transform → Detect lane lines → Determine the lane curvature  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pipeline(image):\n",
    "    undistorted = cal_undistort(image) #undistored image\n",
    "    combined_image = threshold(undistorted) #get binary image\n",
    "    binary_warped, Minv = corners_unwarp(combined_image) #get transformed image\n",
    "    left_curverad,right_curverad, dx= find_curvature(binary_warped) #get curvature\n",
    "    result=vis(undistorted,binary_warped,Minv) #visulize detected lane lines result in image\n",
    "    output=put_text(result,left_curverad,right_curverad, dx) #Add text on image\n",
    "    return output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test with test images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_imgs = glob.glob('test_images//test*.jpg')\n",
    "\n",
    "for index, image in enumerate(test_imgs):\n",
    "    image=cv2.imread(image)\n",
    "    result=pipeline(image)\n",
    "    #result=cv2.cvtColor(result,cv2.COLOR_RGB2BRG)\n",
    "    write_name = 'output_images/'+ 'test'+str(index+1)+ '.jpg'\n",
    "    cv2.imwrite(write_name,result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test with Video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import everything needed to edit/save/watch video clips\n",
    "from moviepy.editor import VideoFileClip\n",
    "from IPython.display import HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "t:   0%|                                                                            | 0/1260 [00:00<?, ?it/s, now=None]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video test_videos_output/project_video.mp4.\n",
      "Moviepy - Writing video test_videos_output/project_video.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                       \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready test_videos_output/project_video.mp4\n",
      "Wall time: 10min 39s\n"
     ]
    }
   ],
   "source": [
    "white_output = 'test_videos_output/project_video.mp4'\n",
    "## To speed up the testing process you may want to try your pipeline on a shorter subclip of the video\n",
    "## To do so add .subclip(start_second,end_second) to the end of the line below\n",
    "## Where start_second and end_second are integer values representing the start and end of the subclip\n",
    "## You may also uncomment the following line for a subclip of the first 5 seconds\n",
    "clip1 = VideoFileClip(\"project_video.mp4\")\n",
    "white_clip = clip1.fl_image(pipeline) #NOTE: this function expects color images!!\n",
    "%time white_clip.write_videofile(white_output, audio=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<video width=\"960\" height=\"540\" controls>\n",
       "  <source src=\"test_videos_output/challenge_video.mp4\">\n",
       "</video>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML(\"\"\"\n",
    "<video width=\"960\" height=\"540\" controls>\n",
    "  <source src=\"{0}\">\n",
    "</video>\n",
    "\"\"\".format(white_output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "t:   0%|                                                                             | 0/485 [00:00<?, ?it/s, now=None]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video test_videos_output/challenge_video.mp4.\n",
      "Moviepy - Writing video test_videos_output/challenge_video.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                       \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready test_videos_output/challenge_video.mp4\n",
      "Wall time: 3min 20s\n"
     ]
    }
   ],
   "source": [
    "white_output = 'test_videos_output/challenge_video.mp4'\n",
    "## To speed up the testing process you may want to try your pipeline on a shorter subclip of the video\n",
    "## To do so add .subclip(start_second,end_second) to the end of the line below\n",
    "## Where start_second and end_second are integer values representing the start and end of the subclip\n",
    "## You may also uncomment the following line for a subclip of the first 5 seconds\n",
    "clip1 = VideoFileClip(\"challenge_video.mp4\")\n",
    "white_clip = clip1.fl_image(pipeline) #NOTE: this function expects color images!!\n",
    "%time white_clip.write_videofile(white_output, audio=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<video width=\"960\" height=\"540\" controls>\n",
       "  <source src=\"test_videos_output/challenge_video.mp4\">\n",
       "</video>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML(\"\"\"\n",
    "<video width=\"960\" height=\"540\" controls>\n",
    "  <source src=\"{0}\">\n",
    "</video>\n",
    "\"\"\".format(white_output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "t:   0%|                                                                            | 0/1199 [00:00<?, ?it/s, now=None]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video test_videos_output/harder_challenge_video.mp4.\n",
      "Moviepy - Writing video test_videos_output/harder_challenge_video.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                       \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready test_videos_output/harder_challenge_video.mp4\n",
      "Wall time: 14min 56s\n"
     ]
    }
   ],
   "source": [
    "white_output = 'test_videos_output/harder_challenge_video.mp4'\n",
    "## To speed up the testing process you may want to try your pipeline on a shorter subclip of the video\n",
    "## To do so add .subclip(start_second,end_second) to the end of the line below\n",
    "## Where start_second and end_second are integer values representing the start and end of the subclip\n",
    "## You may also uncomment the following line for a subclip of the first 5 seconds\n",
    "clip1 = VideoFileClip(\"harder_challenge_video.mp4\")\n",
    "white_clip = clip1.fl_image(pipeline) #NOTE: this function expects color images!!\n",
    "%time white_clip.write_videofile(white_output, audio=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<video width=\"960\" height=\"540\" controls>\n",
       "  <source src=\"test_videos_output/harder_challenge_video.mp4\">\n",
       "</video>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML(\"\"\"\n",
    "<video width=\"960\" height=\"540\" controls>\n",
    "  <source src=\"{0}\">\n",
    "</video>\n",
    "\"\"\".format(white_output))"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}