image_gen-final.py.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## importing jupyter notebook as a module: https://stackoverflow.com/questions/20186344/ipynb-import-another-ipynb-file\n",
    "%run tracker.py.ipynb\n",
    "import numpy as np\n",
    "import cv2\n",
    "import pickle\n",
    "import glob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# https://wayhome25.github.io/cs/2017/04/04/cs-04/\n",
    "# https://stackoverflow.com/questions/13906623/using-pickle-dump-typeerror-must-be-str-not-bytes\n",
    "'''\n",
    "def pickle_dump(dict_name,file_name):\n",
    "    f = open(file_name,'wb')\n",
    "    pickle.dump(dict_name,f)\n",
    "    f.close()\n",
    "\n",
    "import pickle\n",
    "mailbox = {'sarah':'lee','seok':'lee'}\n",
    "pickle_dump(mailbox,'dict.txt')    \n",
    "    \n",
    "'''\n",
    "\n",
    "dist_pickle = pickle.load(open('calibration_pickle.p','rb'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'dist': array([[-0.24688775, -0.02373133, -0.00109842,  0.00035108, -0.00258571]]), 'mtx': array([[  1.15777930e+03,   0.00000000e+00,   6.67111054e+02],\n",
      "       [  0.00000000e+00,   1.15282291e+03,   3.86128938e+02],\n",
      "       [  0.00000000e+00,   0.00000000e+00,   1.00000000e+00]])}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# checking data type and the contents of data\n",
    "print(dist_pickle)\n",
    "type(dist_pickle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# how to extract data from dict data type in python:\n",
    "# https://stackoverflow.com/questions/5404665/accessing-elements-of-python-dictionary-by-index\n",
    "mtx = dist_pickle['mtx']\n",
    "dist = dist_pickle['dist']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# play list number 14:27\n",
    "# https://www.youtube.com/watch?v=vWY8YUayf9Q&feature=youtu.be\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# https://classroom.udacity.com/nanodegrees/nd013-ent/parts/f114da49-70ce-4ebe-b88c-e0ab576aed25/modules/37588c52-f496-4568-898e-651cbd0e8fc1/lessons/4883b3e6-1679-48d3-8fa3-b5893659d657/concepts/e6115672-155d-4c10-b640-fe20a4f4b0a6\n",
    "# sobel extraction:\n",
    "'''\n",
    "https://blog.naver.com/roboholic84/220482877717\n",
    "https://iskim3068.tistory.com/49 # sobel,kenny, prewitt, robert, etc. \n",
    "https://076923.github.io/posts/Python-opencv-14/\n",
    "\n",
    "\n",
    "sobel = cv2.Sobel(gray, cv2.CV_8U, 1, 0, 3)\n",
    "cv2.Sobel(grayscale image, accuracy, x direction derivative, y direction derivative, kernel size) \n",
    "cv2.Sobel(그레이스케일 이미지, 정밀도, x방향 미분, y방향 미분, 커널, 배율, 델타, 픽셀 외삽법)를 이용하여 가장자리 검출을 적용합니다.\n",
    "\n",
    "정밀도는 결과 이미지의 이미지 정밀도를 의미합니다. 정밀도에 따라 결과물이 달라질 수 있습니다.\n",
    "\n",
    "x 방향 미분은 이미지에서 x 방향으로 미분할 값을 설정합니다.\n",
    "\n",
    "y 방향 미분은 이미지에서 y 방향으로 미분할 값을 설정합니다.\n",
    "\n",
    "커널은 소벨 커널의 크기를 설정합니다. 1, 3, 5, 7의 값을 사용합니다.\n",
    "\n",
    "배율은 계산된 미분 값에 대한 배율값입니다.\n",
    "\n",
    "'''\n",
    "def abs_sobel_thresh(img,orient='x',sobel_kernel=3,thresh=(0,255)):\n",
    "    # calculate directional gradient\n",
    "    gray = cv2.cvtColor(img,cv2.COLOR_RGB2GRAY)\n",
    "    if orient =='x':\n",
    "        abs_sobel = np.absolute(cv2.Sobel(gray,cv2.CV_64F,1,0,ksize = sobel_kernel))\n",
    "    if orient == 'y':\n",
    "        abs_sobel = np.absolute(cv2.Sobel(gray,cv2.CV_64F,0,1,ksize = sobel_kernel))\n",
    "# normalization     \n",
    "    scaled_sobel = np.uint8(255*abs_sobel/np.max(abs_sobel))\n",
    "# numpy.zeros_like is the same as zeros in matlab: https://www.geeksforgeeks.org/numpy-zeros_like-python/\n",
    "    binary_output = np.zeros_like(scaled_sobel)\n",
    "# if scaled_sobel>=0 and scaled_sobel<=255, then set to 1    \n",
    "    binary_output[(scaled_sobel>=thresh[0])&(scaled_sobel<=thresh[1])] = 1\n",
    "    return binary_output\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# maginitude based gradient check\n",
    "# https://classroom.udacity.com/nanodegrees/nd013-ent/parts/f114da49-70ce-4ebe-b88c-e0ab576aed25/modules/37588c52-f496-4568-898e-651cbd0e8fc1/lessons/4883b3e6-1679-48d3-8fa3-b5893659d657/concepts/78be8208-1af0-4cb4-8a60-2d904b696449\n",
    "    \n",
    "def mag_thresh(image,sobel_kernel = 3,mag_thresh =(0,255)):\n",
    "    gray = cv2.cvtColor(img,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",
    "    gradmag = np.sqrt(sobelx**2,sobely**2)\n",
    "    scale_factor = np.max(gradmag)/255\n",
    "    gradmag = (gradmag/scale_factor).astype(np.uint8)\n",
    "    binary_output = np.zeros_like(gradmag)\n",
    "    binary_output[(gradmag >= mag_thresh[0]) & (gradmag <= mag_thresh[1])] = 1\n",
    "    return binary_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# directional gradient check:\n",
    "# https://classroom.udacity.com/nanodegrees/nd013-ent/parts/f114da49-70ce-4ebe-b88c-e0ab576aed25/modules/37588c52-f496-4568-898e-651cbd0e8fc1/lessons/4883b3e6-1679-48d3-8fa3-b5893659d657/concepts/d9ad4008-6744-4dc1-803d-e43a67cc050f\n",
    "\n",
    "def dir_threshold(image, sobel_kernel = 3, thresh = (0,np.pi/2)):\n",
    "    # calculate gradient direction\n",
    "    gray = cv2.cvtColor(img,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",
    "    with np.errstate(divide='ignore',invalid='ignore'):\n",
    "        absgraddir = np.absolute(np.arctan(sobely/sobelx))\n",
    "        binary_output = np.zeros_like(absgraddir)\n",
    "        #apply threshold\n",
    "        binary_output[(absgraddir >= thresh[0])&(absgraddir <= thresh[1])]=1\n",
    "    return binary_output\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## colar threshold:\n",
    "## https://classroom.udacity.com/nanodegrees/nd013-ent/parts/f114da49-70ce-4ebe-b88c-e0ab576aed25/modules/37588c52-f496-4568-898e-651cbd0e8fc1/lessons/4883b3e6-1679-48d3-8fa3-b5893659d657/concepts/d7542ed8-36ce-4407-bd0a-4a38d17d2325\n",
    "    \n",
    "def color_threshold(image,sthresh = (0,255),vthresh = (0,255)):\n",
    "    hls = cv2.cvtColor(image,cv2.COLOR_RGB2HLS)\n",
    "    s_channel = hls[:,:,2]\n",
    "    s_binary = np.zeros_like(s_channel)\n",
    "    s_binary[(s_channel >= sthresh[0])&(s_channel <= sthresh[1])] = 1\n",
    "    \n",
    "    hsv = cv2.cvtColor(image,cv2.COLOR_RGB2HSV)\n",
    "    v_channel = hsv[:,:,2]\n",
    "    v_binary = np.zeros_like(v_channel)\n",
    "    v_binary[(v_channel >=vthresh[0])&(v_channel <= vthresh[1])] = 1\n",
    "    \n",
    "    output = np.zeros_like(s_channel)\n",
    "    output[(s_binary ==1)&(v_binary ==1)] = 1\n",
    "    return output\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def window_mask(width,height,img_ref,center,level):\n",
    "    output = np.zeros_like(img_ref)\n",
    "    output[int(img_ref.shape[0]-(level+1)*height):int(img_ref.shape[0]-level*height),max(0,int(center-width)):min(int(center+width),img_ref.shape[1])] = 1\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## make a list of test images\n",
    "## https://wikidocs.net/83\n",
    "'''\n",
    "import glob\n",
    "glob.glob('*.*')\n",
    "['INSTALL.LOG', 'LICENSE.txt', 'NEWS.txt', 'py.ico', 'pyc.ico',\n",
    "'pycon.ico', 'python.exe', 'pythonw.exe', 'readme.txt',\n",
    "'UNWISE.EXE', 'w9xpopen.exe']\n",
    "glob.glob('*.txt')\n",
    "['LICENSE.txt', 'NEWS.txt', 'readme.txt']\n",
    "\n",
    "'''\n",
    "\n",
    "images = glob.glob('test_images/test*.jpg')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for idx,fname in enumerate(images):\n",
    "    # read in image\n",
    "    img = cv2.imread(fname)\n",
    "    ksize = 3\n",
    "    # undistort the image\n",
    "    img = cv2.undistort(img,mtx,dist,None,mtx)\n",
    "    \n",
    "    \n",
    "    preprocessImage = np.zeros_like(img[:,:,0])\n",
    "    gradx = abs_sobel_thresh(img, orient = 'x', thresh =(12,255)) \n",
    "    grady = abs_sobel_thresh(img, orient = 'y', thresh =(25,255))\n",
    "    c_binary = color_threshold(img, sthresh = (100,255), vthresh = (50,255))\n",
    "    preprocessImage[((gradx == 1)&(grady == 1)|(c_binary == 1))] = 255\n",
    "    \n",
    "    mag_binary = mag_thresh(img, sobel_kernel=ksize, mag_thresh=(0, 255))\n",
    "    dir_binary = dir_threshold(img, sobel_kernel=ksize, thresh=(0, np.pi/2))\n",
    "    \n",
    "    #preprocessImage[((gradx == 1)&(grady == 1)|(mag_binary == 1) & (dir_binary == 1)|(c_binary == 1))] = 255\n",
    "    \n",
    "    img_size =(img.shape[1],img.shape[0])\n",
    "    bot_width = .76\n",
    "    mid_width = .08\n",
    "    height_pct= .62\n",
    "    bottom_trim= .935\n",
    "    \n",
    " \n",
    "    offset = img_size[0]*.25\n",
    "    src = np.float32([[img.shape[1]*(.5-mid_width/2),img.shape[0]*height_pct],[img.shape[1]*(.5+mid_width/2),img.shape[0]*height_pct],[img.shape[1]*(.5+bot_width/2),img.shape[0]*bottom_trim],[img.shape[1]*(.5-bot_width/2),img.shape[0]*bottom_trim]])\n",
    "    dst = np.float32([[offset, 0], [img_size[0]-offset, 0],[img_size[0]-offset, img_size[1]],[offset, img_size[1]]])\n",
    "    \n",
    "    M = cv2.getPerspectiveTransform(src, dst)\n",
    "    Minv = cv2.getPerspectiveTransform(dst, src)                 \n",
    "    warped = cv2.warpPerspective(preprocessImage, M, img_size, flags=cv2.INTER_LINEAR)\n",
    "    \n",
    "    window_width = 25\n",
    "    window_height = 80\n",
    "    \n",
    "    #set up the overall class to do all the tracking \n",
    "    '''\n",
    "    https://classroom.udacity.com/nanodegrees/nd013-ent/parts/f114da49-70ce-4ebe-b88c-e0ab576aed25/modules/37588c52-f496-4568-898e-651cbd0e8fc1/lessons/150ec3c9-0005-4da4-99fb-d40780f7ccb6/concepts/2f928913-21f6-4611-9055-01744acc344f\n",
    "    \n",
    "    '''\n",
    "    curve_centers = tracker(Mywindow_width = window_width, Mywindow_height = window_height, Mymargin = 25, My_ym = 37/720, My_xm = 3.7/640,Mysmooth_factor = 15)\n",
    "    \n",
    "    window_centroids = curve_centers.find_window_centroids(warped)\n",
    "    \n",
    "    \n",
    "    # points used to draw all the left and right windows\n",
    "    \n",
    "    l_points = np.zeros_like(warped)\n",
    "    r_points = np.zeros_like(warped)\n",
    "    \n",
    "    # points used to find the left and right lanes\n",
    "    \n",
    "    rightx = []\n",
    "    leftx = []\n",
    "    \n",
    "    \n",
    "    # Go through each level and draw the windows\n",
    "    \n",
    "    for level in range(0,len(window_centroids)):\n",
    "        \n",
    "        leftx.append(window_centroids[level][0])\n",
    "        rightx.append(window_centroids[level][1])\n",
    "        \n",
    "        # window_mask is a function to draw window areas\n",
    "        l_mask = window_mask(window_width, window_height, warped, window_centroids[level][0], level)\n",
    "        r_mask = window_mask(window_width, window_height, warped, window_centroids[level][1], level)\n",
    "        \n",
    "        # add center value found in frame to the list of lane points per left,right\n",
    "        \n",
    "\n",
    "        \n",
    "        # add graphic points from window mask here to total pixels found\n",
    "        \n",
    "        l_points[(l_points == 255)|((l_mask == 1))] = 255\n",
    "        r_points[(r_points == 255)|((r_mask == 1))] = 255\n",
    "        \n",
    "    \n",
    "    #template = np.array(r_points+l_points,np.uint8)\n",
    "    #zero_channel = np.zeros_like(template)\n",
    "    #template = np.array(cv2.merge((zero_channel,template,zero_channel)),np.uint8)\n",
    "    #warpage = np.array(cv2.merge((warped,warped,warped)),np.uint8)\n",
    "    #result = cv2.addWeighted(warpage,1,template,0.5,0.0)\n",
    "                            \n",
    "    # result = warped\n",
    "    \n",
    "    \n",
    "    yvals = range(0,warped.shape[0])\n",
    "    \n",
    "    res_yvals = np.arange(warped.shape[0]-(window_height/2),0,-window_height)\n",
    "    \n",
    "    left_fit = np.polyfit(res_yvals,leftx,2)\n",
    "    left_fitx = left_fit[0]*yvals*yvals + left_fit[1]*yvals + left_fit[2]\n",
    "    left_fitx = np.array(left_fitx,np.int32)\n",
    "    \n",
    "    \n",
    "    right_fit = np.polyfit(res_yvals,rightx,2)\n",
    "    right_fitx = right_fit[0]*yvals*yvals + right_fit[1]*yvals + right_fit[2]\n",
    "    right_fitx = np.array(right_fitx,np.int32)\n",
    "    \n",
    "    left_lane = np.array(list(zip(np.concatenate((left_fitx-window_width/2,left_fitx[::-1]+window_width/2),axis= 0),np.concatenate((yvals,yvals[::-1]),axis = 0))),np.int32)\n",
    "    right_lane = np.array(list(zip(np.concatenate((right_fitx-window_width/2,right_fitx[::-1]+window_width/2),axis= 0),np.concatenate((yvals,yvals[::-1]),axis = 0))),np.int32)\n",
    "    inner_lane = np.array(list(zip(np.concatenate((left_fitx+window_width/2,right_fitx[::-1]-window_width/2),axis = 0),np.concatenate((yvals,yvals[::-1]),axis = 0))),np.int32)\n",
    "  \n",
    "    road = np.zeros_like(img)\n",
    "    road_bkg = np.zeros_like(img)\n",
    "    cv2.fillPoly(road,[left_lane],color = [255,0,0])\n",
    "    cv2.fillPoly(road,[right_lane],color = [0,0,255])\n",
    "    cv2.fillPoly(road,[inner_lane],color = [0,255,0])\n",
    "    \n",
    "    cv2.fillPoly(road_bkg,[left_lane],color=[255,255,255])\n",
    "    cv2.fillPoly(road_bkg,[right_lane],color = [255,255,255])\n",
    "    \n",
    "    #cv2.fillPoly(road_bkg,[left_lane],color=[255,0,0])\n",
    "    #cv2.fillPoly(road_bkg,[right_lane],color = [0,0,255])\n",
    "    \n",
    "    road_warped = cv2.warpPerspective(road,Minv,img_size,flags = cv2.INTER_LINEAR)\n",
    "    road_warped_bkg = cv2.warpPerspective(road_bkg,Minv,img_size,flags = cv2.INTER_LINEAR)\n",
    "     \n",
    "    base = cv2.addWeighted(img,1.0,road_warped_bkg,-1.0,0.0)\n",
    "    result = cv2.addWeighted(base,1.0,road_warped,0.7,0.0)\n",
    "    \n",
    "    \n",
    "    \n",
    "    ym_per_pix = curve_centers.ym_per_pix\n",
    "    xm_per_pix = curve_centers.xm_per_pix\n",
    "    \n",
    "    curve_fit_cr = np.polyfit(np.array(res_yvals,np.float32)*ym_per_pix,np.array(leftx,np.float32)*xm_per_pix,2)\n",
    "    curverad = ((1+(2*curve_fit_cr[0]*yvals[-1]*ym_per_pix + curve_fit_cr[1])**2)**1.5) /np.absolute(2*curve_fit_cr[0])\n",
    "    \n",
    "    #calculate the offset of the car on the road\n",
    "    \n",
    "    camera_center = (left_fitx[-1] + right_fitx[-1])/2\n",
    "    center_diff = (camera_center-warped.shape[1]/2)*xm_per_pix\n",
    "    side_pos= 'left'\n",
    "    if center_diff <= 0:\n",
    "        side_pos = 'right'\n",
    "\n",
    "        \n",
    "    # draw the text showing curvature, offset, and speed \n",
    "    \n",
    "    cv2.putText(result,'Radius of Curvature = ' +str(round(curverad,3))+'(m)',(50,50),cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,255),2)\n",
    "    cv2.putText(result,'Vehicle is '+str(abs(round(center_diff,3)))+'m '+ side_pos+' of center',(50,100) , cv2.FONT_HERSHEY_SIMPLEX,1,(255,255,255),2)\n",
    "    \n",
    "        \n",
    "        \n",
    "                        \n",
    "    write_name = 'test_images/final'+str(idx)+'.jpg'\n",
    "    \n",
    "    cv2.imwrite(write_name,result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}