Readme.md-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# self Driving car Advanced Lane line \n",
    "\n",
    "\n",
    "\n",
    "#### The aim of the project \n",
    "     * Using computer vision for various taskes \n",
    "        1 Measuring distortion\n",
    "        2 Calibrating Camera\n",
    "        3 Correction for distortion\n",
    "        5 Use color transforms\n",
    "        6 Apply a perspective transform to rectify binary image (\"birds-eye view\")\n",
    "        7 Detect lane pixels and fit to find the lane boundary\n",
    "        8 Determine the curvature of the lane\n",
    "        9 Warp the detected lane boundaries back onto the original image\n",
    "        10 O/P the lane image with estimates of curved and boundary defined for accurate path for car to stay on the\n",
    "        path \n",
    "    \n",
    "    \n",
    "-----    \n",
    "            \n",
    "#### Rubric Point\n",
    "    * Here I will consider the rubric points individually and describe how I addressed each point in my \n",
    "      implementation.\n",
    "      \n",
    "##### File Submission and Code qualiy\n",
    "    \n",
    "    File submission inculde all the required files that are necessary to quialy the project submission\n",
    "    \n",
    "       1) project.ipynb\n",
    "       2) Readme.md\n",
    "       3) Writeup.up\n",
    "    \n",
    "#### Below are the steps described individually that are implement in the project \n",
    "        \n",
    "        1) Finding corners\n",
    "        \n",
    "        2) Camera calibration\n",
    "\n",
    "        4) Perspective Transform to bird's eye view\n",
    "        \n",
    "        5) Binary lane line image using gradient and color transforms\n",
    "        \n",
    "        6) Sobel Utilisation\n",
    "        \n",
    "        6) Identifying lane line pixels using sliding windows\n",
    "\n",
    "        7) Extracting the local curvature of the road and vehicle localization\n",
    "\n",
    "        8) Projecting the detected lane lines onto the original image\n",
    "        \n",
    "        9) Video Processing Pipeline\n",
    "\n",
    "###### 1) Finding corners\n",
    "\n",
    "Corders of the chess board are spoted so that the further calibration can be done.\n",
    "\n",
    "\n",
    "\n",
    "##### 2) Camera calibration\n",
    "\n",
    "Image distortion occurs when a camera looks at 3D objects in the real world and transforms them into a 2D image; this transformation isn’t perfect. Distortion actually changes what the shape and size of these 3D objects appear to be. So, the first step in analyzing camera images, is to undo this distortion so that you can get correct and useful information out of them.\n",
    "\n",
    "\n",
    "\n",
    "####  Test Image Pipeline\n",
    "<img src='output_images/undistorted.png' />\n",
    "\n",
    "##### 3)Example of a distortion corrected image\n",
    "Applying the undistortion transformation to a test image yields the following result (left distorted, right corrected) \n",
    "\n",
    "<img src=\"output_images/undistort_traffic_img.png\" />\n",
    "\n",
    "##### 4) Perspective Transform to bird's eye view\n",
    "A perspective transform to and from \"bird's eye\" perspective is done in a function called warp(), The warp() function takes as input an color image (img), as well as the tobird boolean paramter. The parameters src and  dst of the transform.\n",
    "\n",
    "<img src=\"output_images/unwarped.png\" />\n",
    "\n",
    "##### 5) Binary lane line image using gradient and color transforms\n",
    "\n",
    "color traformation was done using RGB , HSV and HLS below is the image porduced after the color transformation\n",
    "\n",
    "<img src = \"output_images/color_depth.png\" />\n",
    "\n",
    "##### 6) Sobel Utilisation\n",
    "\n",
    "    I used variouts sobel Operators in order to find the image details\n",
    "    \n",
    "    1) absolute Sobel threshold\n",
    "<img src =\"output_images/sobel_threshold.png\" width='500'/>\n",
    "    2. magnitue threshold\n",
    "<img src =\"output_images/sobel_magnitued.png\" width='500'/>\n",
    "    3. direction threshold\n",
    "<img src =\"output_images/sobel_mag_and_dir.png\" width='500' />\n",
    "\n",
    "\n",
    "#### Identifying lane line pixels using sliding windows\n",
    "\n",
    "\n",
    "depending upon the threshold the image pixel were recognised and sliding window was implemented in order to get results, The bootom of the image was recognised and pipline filted was run over in order to get the accurate results, further cuvers were recognised on each fram and x along with y value was recognised on which green shade was build over \n",
    "<img src =\"output_images/sliding_window_rectangle.png\" width='300' />  <img src =\"output_images/sliding_window2.png\" width='300' />  <img src=\"output_images/sliding_window_rectangle.png\" width=\"300\" />\n",
    "\n",
    "\n",
    "##### 7) mExtracting the local curvature of the road and vehicle localization\n",
    "\n",
    "The radius of curvature is computed upon calling the Line.update() method of a line. The method that does the computation is called Line.get_radius_of_curvature(). The mathematics involved is summarized in this tutorial here.\n",
    "For a second order polynomial f(y)=A y^2 +B y + C the radius of curvature is given by R = [(1+(2 Ay +B)^2 )^3/2]/|2A|.\n",
    "\n",
    "The distance from the center of the lane is computed in the Line.set_line_base_pos() method, which essentially measures the distance to each lane and computes the position assuming the lane has a given fixed width of 3.7m.\n",
    "<img src=\"output_images/embeding_curv.png\" width=\"300\" />\n",
    "\n",
    "#### Video Processing Pipeline\n",
    "\n",
    "ALL the gathered knowledge was applied into single piple line and result was achieved \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "[![Everything Is AWESOME](output_images/embeding_curv.png)](./project_video.mp4 \"Everything Is AWESOME\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# self Driving car Advanced Lane line \n",
    "\n",
    "\n",
    "\n",
    "#### The aim of the project \n",
    "     * Using computer vision for various taskes \n",
    "        1 Measuring distortion\n",
    "        2 Calibrating Camera\n",
    "        3 Correction for distortion\n",
    "        5 Use color transforms\n",
    "        6 Apply a perspective transform to rectify binary image (\"birds-eye view\")\n",
    "        7 Detect lane pixels and fit to find the lane boundary\n",
    "        8 Determine the curvature of the lane\n",
    "        9 Warp the detected lane boundaries back onto the original image\n",
    "        10 O/P the lane image with estimates of curved and boundary defined for accurate path for car to stay on the\n",
    "        path \n",
    "    \n",
    "    \n",
    "-----    \n",
    "            \n",
    "#### Rubric Point\n",
    "    * Here I will consider the rubric points individually and describe how I addressed each point in my \n",
    "      implementation.\n",
    "      \n",
    "##### File Submission and Code qualiy\n",
    "    \n",
    "    File submission inculde all the required files that are necessary to quialy the project submission\n",
    "    \n",
    "       1) project.ipynb\n",
    "       2) Readme.md\n",
    "       3) Writeup.up\n",
    "    \n",
    "#### Below are the steps described individually that are implement in the project \n",
    "        \n",
    "        1) Finding corners\n",
    "        \n",
    "        2) Camera calibration\n",
    "\n",
    "        4) Perspective Transform to bird's eye view\n",
    "        \n",
    "        5) Binary lane line image using gradient and color transforms\n",
    "        \n",
    "        6) Sobel Utilisation\n",
    "        \n",
    "        6) Identifying lane line pixels using sliding windows\n",
    "\n",
    "        7) Extracting the local curvature of the road and vehicle localization\n",
    "\n",
    "        8) Projecting the detected lane lines onto the original image\n",
    "        \n",
    "        9) Video Processing Pipeline\n",
    "\n",
    "###### 1) Finding corners\n",
    "\n",
    "Corders of the chess board are spoted so that the further calibration can be done.\n",
    "\n",
    "\n",
    "\n",
    "##### 2) Camera calibration\n",
    "\n",
    "Image distortion occurs when a camera looks at 3D objects in the real world and transforms them into a 2D image; this transformation isnâ€™t perfect. Distortion actually changes what the shape and size of these 3D objects appear to be. So, the first step in analyzing camera images, is to undo this distortion so that you can get correct and useful information out of them.\n",
    "\n",
    "\n",
    "\n",
    "####  Test Image Pipeline\n",
    "<img src='output_images/undistorted.png' />\n",
    "\n",
    "##### 3)Example of a distortion corrected image\n",
    "Applying the undistortion transformation to a test image yields the following result (left distorted, right corrected) \n",
    "\n",
    "<img src=\"output_images/undistort_traffic_img.png\" />\n",
    "\n",
    "##### 4) Perspective Transform to bird's eye view\n",
    "A perspective transform to and from \"bird's eye\" perspective is done in a function called warp(), The warp() function takes as input an color image (img), as well as the tobird boolean paramter. The parameters src and  dst of the transform.\n",
    "\n",
    "<img src=\"output_images/unwarped.png\" />\n",
    "\n",
    "##### 5) Binary lane line image using gradient and color transforms\n",
    "\n",
    "color traformation was done using RGB , HSV and HLS below is the image porduced after the color transformation\n",
    "\n",
    "<img src = \"output_images/color_depth.png\" />\n",
    "\n",
    "##### 6) Sobel Utilisation\n",
    "\n",
    "    I used variouts sobel Operators in order to find the image details\n",
    "    \n",
    "    1) absolute Sobel threshold\n",
    "<img src =\"output_images/sobel_threshold.png\" width='500'/>\n",
    "    2. magnitue threshold\n",
    "<img src =\"output_images/sobel_magnitued.png\" width='500'/>\n",
    "    3. direction threshold\n",
    "<img src =\"output_images/sobel_mag_and_dir.png\" width='500' />\n",
    "\n",
    "\n",
    "#### Identifying lane line pixels using sliding windows\n",
    "\n",
    "\n",
    "depending upon the threshold the image pixel were recognised and sliding window was implemented in order to get results, The bootom of the image was recognised and pipline filted was run over in order to get the accurate results, further cuvers were recognised on each fram and x along with y value was recognised on which green shade was build over \n",
    "<img src =\"output_images/sliding_window_rectangle.png\" width='300' />  <img src =\"output_images/sliding_window2.png\" width='300' />  <img src=\"output_images/sliding_window_rectangle.png\" width=\"300\" />\n",
    "\n",
    "\n",
    "##### 7) mExtracting the local curvature of the road and vehicle localization\n",
    "\n",
    "The radius of curvature is computed upon calling the Line.update() method of a line. The method that does the computation is called Line.get_radius_of_curvature(). The mathematics involved is summarized in this tutorial here.\n",
    "For a second order polynomial f(y)=A y^2 +B y + C the radius of curvature is given by R = [(1+(2 Ay +B)^2 )^3/2]/|2A|.\n",
    "\n",
    "The distance from the center of the lane is computed in the Line.set_line_base_pos() method, which essentially measures the distance to each lane and computes the position assuming the lane has a given fixed width of 3.7m.\n",
    "<img src=\"output_images/embeding_curv.png\" width=\"300\" />\n",
    "\n",
    "#### Video Processing Pipeline\n",
    "\n",
    "ALL the gathered knowledge was applied into single piple line and result was achieved \n",
    "\n",
    "## Writeup Template\n",
    "\n",
    "### You can use this file as a template for your writeup if you want to submit it as a markdown file, but feel free to use some other method and submit a pdf if you prefer.\n",
    "\n",
    "---\n",
    "\n",
    "**Advanced Lane Finding Project**\n",
    "\n",
    "The goals / steps of this project are the following:\n",
    "\n",
    "     * Using computer vision for various taskes \n",
    "        1 Measuring distortion\n",
    "        2 Calibrating Camera\n",
    "        3 Correction for distortion\n",
    "        5 Use color transforms\n",
    "        6 Apply a perspective transform to rectify binary image (\"birds-eye view\")\n",
    "        7 Detect lane pixels and fit to find the lane boundary\n",
    "        8 Determine the curvature of the lane\n",
    "        9 Warp the detected lane boundaries back onto the original image\n",
    "        10 O/P the lane image with estimates of curved and boundary defined for accurate path for car to stay on the\n",
    "        path \n",
    "\n",
    "[//]: # (Image References)\n",
    "\n",
    "[image1]: ./output_images/undistorted.png \"Undistorted\"\n",
    "[image2]: ./output_images/undistort_traffic_img.png \"Road Transformed\"\n",
    "[image3]: ./output_images/warped_straight_lines.jpg \"Warp Example\"\n",
    "[image4]: ./output_images/color_depth.png \"Binary Example\"\n",
    "[image5]: ./output_images/finding_lane.png \"Fit Visual\"\n",
    "[image6]: ./output_images/embeding_curv.png \"Output\"\n",
    "[image7]: ./output_images/unwarped.png \"Output\"\n",
    "[image8]: ./output_images/pip_img_1.png \"Output\"\n",
    "[image9]: ./output_images/pip_img_2.png \"Output\"\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "[video1]: ./project_video.mp4 \"Video\"\n",
    "\n",
    "## [Rubric](https://review.udacity.com/#!/rubrics/571/view) Points\n",
    "\n",
    "\n",
    "### Writeup / README\n",
    "\n",
    "\n",
    "### Camera Calibration\n",
    "\n",
    "#### 1. Briefly state how you computed the camera matrix and distortion coefficients. Provide an example of a distortion corrected calibration image.\n",
    "\n",
    "*Camera Calibration\n",
    "\n",
    "Image distortion occurs when a camera looks at 3D objects in the real world and transforms them into a 2D image; this transformation isnâ€™t perfect. Distortion actually changes what the shape and size of these 3D objects appear to be. So, the first step in analyzing camera images, is to undo this distortion so that you can get correct and useful information out of them.\n",
    "\n",
    "this process is done by converting the image into grey image and then finding the corders , dwaing the corners using cv2.drawChessboardCorners()\n",
    "\n",
    "then i calibrated the image using function cv2.calibrateCamera\n",
    "![alt text][image1]\n",
    "\n",
    "\n",
    "### Pipeline (single images)\n",
    "\n",
    "#### 1. Provide an example of a distortion-corrected image.\n",
    "\n",
    "To demonstrate this step, I will describe how I apply the distortion correction to one of the test images like this one:\n",
    "\n",
    "---\n",
    "```python\n",
    "def undistort(img,mtx=mtx, dist=dist):\n",
    "\n",
    "    undist = cv2.undistort(img, mtx, dist, None, mtx)\n",
    "    return undist\n",
    "![alt text][image2]\n",
    "```\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "### 2. In this step i warped the image to get the bird's eye vie ange of the lane \n",
    "\n",
    "```python\n",
    "def unWarpedImg(img,src,dst):\n",
    "    M = cv2.getPerspectiveTransform(src, dst)\n",
    "\n",
    "    Minv = cv2.getPerspectiveTransform(dst, src)\n",
    "\n",
    "    warped=cv2.warpPerspective(img,M,img.shape[1::-1],flags=cv2.INTER_LINEAR)\n",
    "    return warped,M,Minv\n",
    "\n",
    "```\n",
    "![alt text][image7]\n",
    "\n",
    "#### 3. I used color transforms, gradients or other methods to create a thresholded binary image.  Provide an example of a binary image result.\n",
    "\n",
    "i have used various starter method of color and sobel operator in order to get the respective image which can help in indification of traffic lane\n",
    "<dl>\n",
    "<img src=\"./output_images/HLS_L.png\"  width=\"200\" /> \n",
    "<img src=\"./output_images/HLS_S.png\" width=\"200\" />\n",
    "<img src=\"./output_images/HLS_S.png\" width=\"200\" />\n",
    "<img src=\"./output_images/sobel_mag_and_dir.png\" width=\"200\" />\n",
    "<img src=\"./output_images/sobel_magnitued.png\" width=\"200\" />\n",
    "<img src=\"./output_images/sobel_magnitued.png\" width=\"200\" />\n",
    "<img src=\"./output_images/threshold_grad_dir.png\" width=\"200\" />\n",
    "</dl>\n",
    "#### 4. Performed a perspective transform and provide an example of a transformed image.\n",
    "\n",
    "The code for my perspective transform includes a function called `warper()`, which appears in lines 1 through 8 in the file `example.py` (output_images/examples/example.py) (or, for example, in the 3rd code cell of the IPython notebook).  The `warper()` function takes as inputs an image (`img`), as well as source (`src`) and destination (`dst`) points.  I chose the hardcode the source and destination points in the following manner:\n",
    "\n",
    "```python\n",
    "src = np.float32(\n",
    "    [[(img_size[0] / 2) - 55, img_size[1] / 2 + 100],\n",
    "    [((img_size[0] / 6) - 10), img_size[1]],\n",
    "    [(img_size[0] * 5 / 6) + 60, img_size[1]],\n",
    "    [(img_size[0] / 2 + 55), img_size[1] / 2 + 100]])\n",
    "dst = np.float32(\n",
    "    [[(img_size[0] / 4), 0],\n",
    "    [(img_size[0] / 4), img_size[1]],\n",
    "    [(img_size[0] * 3 / 4), img_size[1]],\n",
    "    [(img_size[0] * 3 / 4), 0]])\n",
    "```\n",
    "\n",
    "This resulted in the following source and destination points:\n",
    "\n",
    "| Source        | Destination   | \n",
    "|:-------------:|:-------------:| \n",
    "| 585, 460      | 320, 0        | \n",
    "| 203, 720      | 320, 720      |\n",
    "| 1127, 720     | 960, 720      |\n",
    "| 695, 460      | 960, 0        |\n",
    "\n",
    "I verified that my perspective transform was working as expected by drawing the `src` and `dst` points onto a test image and its warped counterpart to verify that the lines appear parallel in the warped image.\n",
    "\n",
    "![alt text][image4]\n",
    "\n",
    "#### 5. Describing the pipeline\n",
    "\n",
    "After exprimenting all stuff i made a piple line in which i found that the HTS_L and HLS_S when combined give the best lane line result \n",
    "\n",
    "<img src=\"./output_images/pip_img_1.png\" width=\"400\"/>\n",
    "<img src=\"./output_images/pip_img_2.png\" width=\"400\" />\n",
    "\n",
    "\n",
    "#### 6. Describe how (and identify where in your code) you identified lane-line pixels and fit their positions with a polynomial?\n",
    "\n",
    "sliding window method was used twice but only one of them was used which was having detailed description \n",
    "\n",
    "one of them is just for learning purpose \n",
    "\n",
    "<img src=\"./output_images/sliding_window1.png\" width=\"400\" />\n",
    "\n",
    "Another process in which I used  function sliding_window_polyfit() it included window masking and along with that \n",
    "i try to find the center of the lane line and one the lane line is detected i skipped the sliding window and fit the next frame into the video which can be check in polyfit_using_prev_fit() function\n",
    "\n",
    "later the green shade was embeded in order get the video result with higligt track line\n",
    "\n",
    "\n",
    "<img src=\"./output_images/sliding_window2.png\" width=\"400\" />\n",
    "<img src=\"./output_images/sliding_window_rectangle.png\" width=\"400\" />\n",
    "\n",
    "\n",
    "\n",
    "#### 7. Describe how (and identify where in your code) you calculated the radius of curvature of the lane and the position of the vehicle with respect to center.\n",
    "\n",
    "usgin function calc_curv_rad_and_center_dist left radius , right radius and center is discovered the change in radius before that   draw_lane() function is used in order in which left fit and right fit used are used as the one of the main parameter to get extream left and right position and get the green higlit of the path\n",
    "\n",
    "<img src=\"./output_images/finding_lane.png\" width=\"400\" />\n",
    "\n",
    "<img src=\"./output_images/embeding_curv.png\" width=\"400\" />\n",
    "\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "### Pipeline (video)\n",
    "\n",
    "#### 1. Provide a link to your final video output.  Your pipeline should perform reasonably well on the entire project video (wobbly lines are ok but no catastrophic failures that would cause the car to drive off the road!).\n",
    "\n",
    "Here's a [link to my video result](./project_video.mp4)\n",
    "\n",
    "\n",
    "<video width=\"320\" height=\"240\" controls>\n",
    "  <source src=\"./project_video.mp4\" type=\"video/mp4\">\n",
    "Your browser does not support the video tag.\n",
    "</video>\n",
    "---\n",
    "\n",
    "\n",
    "### Soution to problems I faced \n",
    "\n",
    "##### i faced lots of problems but i thing main thing to look at is the portion to unwrap  and pipeline \n",
    "\n",
    "##### The thing that worked for me was \n",
    "```python \n",
    "    combined[( ((hls_binary_s == 1)  & (hls_select_L==1) & (mag_thresh_val==1)| (LBThresh_img==1) ) )==1] = 1\n",
    "    ```\n",
    "    \n",
    "and finally i was able to resubmit my code "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:self_drive]",
   "language": "python",
   "name": "conda-env-self_drive-py"
  },
  "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}