Advanced Lane Lines.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "import glob\n",
    "import pickle\n",
    "import time\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Flags that control the algorithm\n",
    "\n",
    "flagundistort=False\n",
    "flagsavetemp=False\n",
    "flagvideo=True\n",
    "flagM=False\n",
    "flagM1=False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "##Hyper Parameters\n",
    "\n",
    "LowerThres=50  \n",
    "DestThres=100\n",
    "M=[]\n",
    "M1=[]\n",
    "nwindows = 9\n",
    "margin = 100\n",
    "minpix = 50\n",
    "src=[]\n",
    "dst=[]\n",
    "left_fit=[]\n",
    "right_fit=[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## Picking up lane lines using Thresholding and Colors\n",
    "def abs_sobel_thresh(img, orient='x', sobel_kernel=3, thresh=(0, 255)):\n",
    "   \n",
    "    if orient=='x':\n",
    "        sobel_thresh=cv2.Sobel(img,cv2.CV_64F,1,0,sobel_kernel)      \n",
    "    else:\n",
    "        sobel_thresh=cv2.Sobel(img,cv2.CV_64F,0,1,sobel_kernel)\n",
    "    abs_sobel=np.absolute(sobel_thresh)\n",
    "    scaled_sobel=np.uint8(255*abs_sobel/np.max(abs_sobel))\n",
    "    grad_binary=np.zeros_like(scaled_sobel)\n",
    "    grad_binary[(scaled_sobel>=thresh[0])&(scaled_sobel<=thresh[1])]=1\n",
    "    return grad_binary\n",
    "\n",
    "def mag_thresh(img, sobel_kernel=3, mag_thresh=(0, 255)):\n",
    "    \n",
    "    sobelx=cv2.Sobel(img,cv2.CV_64F,1,0,sobel_kernel)  \n",
    "    sobely=cv2.Sobel(img,cv2.CV_64F,0,1,sobel_kernel)\n",
    "    abs_sobel=np.sqrt((sobelx**2)+(sobely**2))\n",
    "    scalefactor=np.max(abs_sobel)/255\n",
    "    abs_sobel=(abs_sobel/scalefactor).astype(np.uint8)\n",
    "    mag_binary=np.zeros_like(abs_sobel)\n",
    "    mag_binary[(abs_sobel>=mag_thresh[0])&(abs_sobel<=mag_thresh[1])]=1\n",
    "    return mag_binary\n",
    "\n",
    "def dir_threshold(img, sobel_kernel=3, thresh=(0, np.pi/2)):\n",
    "    \n",
    "    sobelx=cv2.Sobel(img,cv2.CV_64F,1,0,sobel_kernel)  \n",
    "    sobely=cv2.Sobel(img,cv2.CV_64F,0,1,sobel_kernel)\n",
    "    abs_sobelx=np.absolute(sobelx)\n",
    "    abs_sobely=np.absolute(sobely)\n",
    "    dir_sobel=np.arctan(abs_sobely/abs_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\n",
    "   \n",
    "def hls_select(img, thresh=(0, 255)):\n",
    "    \n",
    "    imgs=cv2.cvtColor(img,cv2.COLOR_BGR2HLS)\n",
    "    s=imgs[:,:,2]\n",
    "    hls_binary=np.zeros_like(s)\n",
    "    hls_binary[(s>thresh[0])&(s<=thresh[1])]=1  \n",
    "    return hls_binary\n",
    "    \n",
    "def hsv(img):\n",
    "    \n",
    "    img1 = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)\n",
    "    yellow1 = np.array([ 0,120, 120], dtype=np.uint8)\n",
    "    yellow2 = np.array([ 100,255, 255,], dtype=np.uint8)\n",
    "    yellow = cv2.inRange(img, yellow1, yellow2)\n",
    "    white1 = np.array([0, 0, 200], dtype=np.uint8)\n",
    "    white2 = np.array([255, 30, 255], dtype=np.uint8)\n",
    "    white = cv2.inRange(img1, white1, white2)\n",
    "    out=cv2.bitwise_and(img, img, mask=(yellow | white))\n",
    "    out=cv2.cvtColor(out,cv2.COLOR_BGR2GRAY)\n",
    "    im_bw = cv2.threshold(out, 0, 255, cv2.THRESH_BINARY)[1]\n",
    "    return im_bw/255\n",
    "\n",
    "def save_img(gradx,grady,combined,hls_binary,dir_binary,mag_binary,color):\n",
    "    \n",
    "    cv2.imwrite('Temp/Sobelx'+'.jpg',gradx*255)\n",
    "    cv2.imwrite('Temp/Sobely'+'.jpg',grady*255)\n",
    "    cv2.imwrite('Temp/combined'+'.jpg',combined*255)\n",
    "    cv2.imwrite('Temp/hls_binary'+'.jpg',hls_binary*255)\n",
    "    cv2.imwrite('Temp/dir_binary'+'.jpg',dir_binary*255)\n",
    "    cv2.imwrite('Temp/mag_binary'+'.jpg',mag_binary*255) \n",
    "    cv2.imwrite('Temp/color'+'.jpg',color*255)\n",
    "    \n",
    "def color_mag_dir_thresh(img): \n",
    "    \n",
    "    gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n",
    "    gradx=abs_sobel_thresh(gray,'x',3,(40,160))\n",
    "    grady=abs_sobel_thresh(gray,'y',3,(40,160))\n",
    "    mag_binary=mag_thresh(gray,3,(80,180))\n",
    "    dir_binary = dir_threshold(gray, sobel_kernel=3, thresh=(0, np.pi/2))\n",
    "    hls_binary=hls_select(img,(150,240))\n",
    "    color=hsv(img)\n",
    "    combined = np.zeros_like(color)\n",
    "    combined[((gradx == 1) & (grady == 1)) | (color==1)| (( mag_binary==1) &  ( dir_binary==1)) |( hls_binary==1) ]=1\n",
    "    if flagsavetemp:\n",
    "        save_img(gradx,grady,combined,hls_binary,dir_binary,mag_binary,color)\n",
    "\n",
    "    return combined    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Bird's eye perspective transform\n",
    "\n",
    "def p_transform(img,H,W,LO,DO,M,flagM,src,dst):\n",
    "\n",
    "    if not(flagM):\n",
    "        src=np.float32([[W/2.28,H/1.6],[W/1.77,H/1.6],[W/1.2,H-LO],[W/5.73,H-LO]])\n",
    "        dst=np.float32([[0+DO/2,0],[W-DO/2,0],[W-2*DO,H],[0+2*DO,H]])\n",
    "        M = cv2.getPerspectiveTransform(src, dst)\n",
    "        flagM=True\n",
    "    warped = cv2.warpPerspective(img, M, (W,H), flags=cv2.INTER_LINEAR)\n",
    "    return warped,M,src,dst,flagM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Finding Lane lines.\n",
    "\n",
    "def find_lanes_window(warped):\n",
    "    \n",
    "    histogram = np.sum(warped[warped.shape[0]//2:,:], axis=0)\n",
    "    midpoint = np.int(histogram.shape[0]//2)\n",
    "    leftx_base = np.argmax(histogram[:midpoint])\n",
    "    rightx_base = np.argmax(histogram[midpoint:]) + midpoint\n",
    "    window_height = np.int(warped.shape[0]//nwindows)\n",
    "    nonzero = warped.nonzero()\n",
    "    nonzeroy = np.array(nonzero[0])\n",
    "    nonzerox = np.array(nonzero[1])\n",
    "    leftx_current = leftx_base\n",
    "    rightx_current = rightx_base\n",
    "    left_lane_inds=[]\n",
    "    right_lane_inds=[]\n",
    "    for window in range(nwindows):\n",
    "        win_y_low=warped.shape[0]-(window+1)*window_height\n",
    "        win_y_high=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",
    "        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",
    "                         \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",
    "        left_lane_inds.append(good_left_inds) \n",
    "        right_lane_inds.append(good_right_inds)\n",
    "        \n",
    "    try:\n",
    "        left_lane_inds = np.concatenate(left_lane_inds)\n",
    "        right_lane_inds = np.concatenate(right_lane_inds)\n",
    "    except ValueError:\n",
    "        \n",
    "        pass\n",
    "    \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",
    "    left_fit = np.polyfit(lefty, leftx, 2)\n",
    "    right_fit = np.polyfit(righty, rightx, 2)\n",
    "    return leftx,lefty,rightx,righty,left_fit,right_fit\n",
    "\n",
    "def find_lanes_search(warped,left_fit,right_fit):\n",
    "    margin = 50\n",
    "    nonzero = warped.nonzero()\n",
    "    nonzeroy = np.array(nonzero[0])\n",
    "    nonzerox = np.array(nonzero[1])\n",
    "\n",
    "    left_lane_inds = ((nonzerox > (left_fit[0]*(nonzeroy**2) + left_fit[1]*nonzeroy + \n",
    "                    left_fit[2] - margin)) & (nonzerox < (left_fit[0]*(nonzeroy**2) + \n",
    "                    left_fit[1]*nonzeroy + left_fit[2] + margin)))\n",
    "    right_lane_inds = ((nonzerox > (right_fit[0]*(nonzeroy**2) + right_fit[1]*nonzeroy + \n",
    "                    right_fit[2] - margin)) & (nonzerox < (right_fit[0]*(nonzeroy**2) + \n",
    "                    right_fit[1]*nonzeroy + right_fit[2] + margin)))\n",
    "    \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",
    "    left_fit = np.polyfit(lefty, leftx, 2)\n",
    "    right_fit = np.polyfit(righty, rightx, 2)\n",
    "    return leftx,lefty,rightx,righty,left_fit,right_fit\n",
    "    \n",
    "def draw_lanes(warped,M,src,dst,flagM1,M1,left_fit,right_fit):\n",
    "    \n",
    "    if len(left_fit) and len(right_fit):\n",
    "#        leftx,lefty,rightx,righty,left_fit,right_fit=find_lanes_search(warped,left_fit,right_fit)\n",
    "        leftx,lefty,rightx,righty,left_fit,right_fit=find_lanes_window(warped)\n",
    "    else:   \n",
    "        leftx,lefty,rightx,righty,left_fit,right_fit=find_lanes_window(warped)\n",
    "    \n",
    "    ploty = np.linspace(0, warped.shape[0]-1, 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",
    "    mask=np.zeros_like(warped).astype(np.uint8)\n",
    "    color_warp = np.dstack((mask, mask, mask))\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",
    "    cv2.polylines(color_warp, np.int32([pts_left]), isClosed=False, color=(255,0,0), thickness=15)\n",
    "    cv2.polylines(color_warp, np.int32([pts_right]), isClosed=False, color=(255,0,0), thickness=15)\n",
    "    \n",
    "    if not(flagM1):\n",
    "        M1 = cv2.getPerspectiveTransform(dst, src)\n",
    "        flagM1=True\n",
    "    newwarp = cv2.warpPerspective(color_warp, M1, (warped.shape[1], warped.shape[0]))\n",
    "    curve,distance=CalculateRadiusOfCurvature(warped,left_fit,right_fit)\n",
    "    cv2.putText(newwarp,\"Radius of Curvature is \" + str(int(curve))+ \"m\", (100,100), 2, 1, (255,255,0),2)\n",
    "    cv2.putText(newwarp,\"Distance from center is {:2f}\".format(distance)+ \"m\", (100,150), 2, 1, (255,255,0),2)\n",
    "    return newwarp,flagM1,M1,left_fit,right_fit\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Finding Radious of Curvature\n",
    "\n",
    "def CalculateRadiusOfCurvature(binary_warped,left_fit,right_fit):\n",
    "    \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",
    "    ploty = np.linspace(0, binary_warped.shape[0]-1, binary_warped.shape[0] )\n",
    "    leftx = left_fit[0]*ploty**2 + left_fit[1]*ploty +left_fit[2]\n",
    "    rightx = right_fit[0]*ploty**2 + right_fit[1]*ploty + right_fit[2]\n",
    "    positionCar= binary_warped.shape[1]/2\n",
    "    left_fit_cr = np.polyfit(ploty*ym_per_pix, leftx*xm_per_pix, 2)\n",
    "    right_fit_cr = np.polyfit(ploty*ym_per_pix, rightx*xm_per_pix, 2)    \n",
    "    y_eval=np.max(ploty)\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",
    "    left_lane_bottom = (left_fit[0]*y_eval)**2 + left_fit[0]*y_eval + left_fit[2]\n",
    "    right_lane_bottom = (right_fit[0]*y_eval)**2 + right_fit[0]*y_eval + right_fit[2]\n",
    "    actualPosition= (left_lane_bottom+ right_lane_bottom)/2\n",
    "    distance= (positionCar - actualPosition)* xm_per_pix\n",
    "    return (left_curverad + right_curverad)/2, distance\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Camera Calibration Functions\n",
    "\n",
    "def findcampar(): \n",
    "\n",
    "    if len(glob.glob('Temp/CameraCalibration.p')):\n",
    "        dist_mtx=pickle.load(open(\"Temp/CameraCalibration.p\",\"rb\"))\n",
    "        mtx=dist_mtx[1]\n",
    "        dist=dist_mtx[2]\n",
    "    else:\n",
    "        PIK='Temp/CameraCalibration.p'\n",
    "        imgpoints=[]\n",
    "        objpoints=[]\n",
    "        objp=np.zeros((9*6,3),np.float32)\n",
    "        objp[:,:2]=np.mgrid[0:9,0:6].T.reshape(-1,2)\n",
    "        images=glob.glob('camera_cal/calibration*.jpg')\n",
    "        for image in images:\n",
    "            img=mpimg.imread(image)\n",
    "            gray=cv2.cvtColor(img,cv2.COLOR_RGB2GRAY)\n",
    "            ret, corners = cv2.findChessboardCorners(gray, (9,6), None)\n",
    "            if ret== True:\n",
    "                image=image.split('\\\\')\n",
    "                imgpoints.append(corners)\n",
    "                objpoints.append(objp)\n",
    "                img=cv2.drawChessboardCorners(img,(9,6),corners,ret)\n",
    "                cv2.imwrite('camera_cal/chessboard/'+image[1],img)\n",
    "        ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera(objpoints, imgpoints, gray.shape[::-1], None, None) \n",
    "        with open(PIK, \"wb\") as f:\n",
    "            data=[ret, mtx, dist, rvecs, tvecs]\n",
    "            pickle.dump(data, f)\n",
    "            \n",
    "    return mtx,dist\n",
    "        \n",
    "def undistortimg():\n",
    "    \n",
    "    images=glob.glob('Temp/Distorted/*.jpg')\n",
    "    if len(images)>0:\n",
    "        f,ax=plt.subplots(len(images),2)\n",
    "        f.tight_layout()\n",
    "        for i,image in enumerate(images):\n",
    "            img=mpimg.imread(image)\n",
    "            image=image.split('\\\\')\n",
    "            undimg=cv2.undistort(img, mtx, dist, None, mtx)\n",
    "            cv2.imwrite('Temp/Undistorted/Undistorted_'+image[1],undimg)       \n",
    "            ax[i][0].imshow(img)\n",
    "            ax[i][0].set_title('Original Image', fontsize=20)\n",
    "            ax[i][1].imshow(undimg)\n",
    "            ax[i][1].set_title('Undistorted Image', fontsize=20)\n",
    "            \n",
    "def undistort(img,mtx,dist):\n",
    "    \n",
    "    undimg=cv2.undistort(img, mtx, dist, None, mtx)\n",
    "    return undimg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Other Functions \n",
    "\n",
    "def region_of_interest(img, vertices):\n",
    "    mask = np.zeros_like(img)     \n",
    "    cv2.fillPoly(mask, vertices, 255)\n",
    "    masked_image = cv2.bitwise_and(img, mask)\n",
    "    return masked_image\n",
    "    \n",
    "def gaussian_blur(img, kernel_size):\n",
    "   \n",
    "    return cv2.GaussianBlur(img, (kernel_size, kernel_size), 0)\n",
    "\n",
    "def weighted_img(img, initial_img, α=1, β=1, γ=0):\n",
    " \n",
    "    return cv2.addWeighted(initial_img, α, img, β, γ)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## To undistort images in 'Temp/Distorted' folder.\n",
    "if flagundistort:\n",
    "    undistortimg()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if flagvideo:\n",
    "    fourcc = cv2.VideoWriter_fourcc(*'MJPG')\n",
    "    cap=cv2.VideoCapture('test_videos/project_video.mp4')\n",
    "    W = int(cap.get(3) )\n",
    "    H = int(cap.get(4))\n",
    "    video = cv2.VideoWriter('output_videos/Annotated_'+'project_video'+'.mp4', fourcc, cap.get(5), (W,H))\n",
    "    start=time.time()\n",
    "    midx=W/2\n",
    "    maxt=H/1.6\n",
    "    kernel = np.ones((3,3),np.uint8)\n",
    "    vertices = np.array([[(30,H),(midx-100, maxt), (midx+100, maxt), (W-30,H)]], dtype=np.int32)\n",
    "    while True:\n",
    "        ret,img=cap.read()\n",
    "        \n",
    "        if ret:\n",
    "            img=undistort(img,mtx,dist)\n",
    "            combined=color_mag_dir_thresh(img)\n",
    "            combined=gaussian_blur(combined,3)\n",
    "            combined=cv2.dilate(combined,kernel,iterations = 1)\n",
    "            masked_image=region_of_interest(combined,vertices)\n",
    "            # Perspective Transform\n",
    "            warped,M,src,dst,flagM=p_transform(masked_image,H,W,LowerThres,DestThres,M,flagM,src,dst)\n",
    "            color_warp,flagM1,M1,left_fit,right_fit=draw_lanes(warped,M1,src,dst,flagM1,M1,left_fit,right_fit)\n",
    "            out = weighted_img(img, color_warp, 0.6, 1, 0) \n",
    "            video.write(out)\n",
    "            cv2.imshow('Output',out)\n",
    "            k=cv2.waitKey(1)\n",
    "            if k==ord('q'):\n",
    "                break\n",
    "        else:\n",
    "            break\n",
    "    end=time.time()\n",
    "    print(\"Time:\",end-start)\n",
    "    cap.release()\n",
    "    video.release()\n",
    "    cv2.destroyAllWindows()\n",
    "            \n",
    "else:\n",
    "    files=glob.glob(os.path.join('test_images/','*.jpg'))\n",
    "    for i in files:\n",
    "        left_fit=[]\n",
    "        right_fit=[]\n",
    "        tmpname=str.split(i,'\\\\')\n",
    "        tmpname=str.split(tmpname[1],'.')\n",
    "        img=cv2.imread(i)\n",
    "        img=undistort(img,mtx,dist)\n",
    "        H=img.shape[0]\n",
    "        W=img.shape[1]\n",
    "        midx=W/2\n",
    "        maxt=H/1.6\n",
    "        kernel = np.ones((3,3),np.uint8)\n",
    "        vertices = np.array([[(30,H),(midx-100, maxt), (midx+100, maxt), (W-30,H)]], dtype=np.int32)\n",
    "        combined=color_mag_dir_thresh(img) \n",
    "        combined=gaussian_blur(combined,3)\n",
    "        combined=cv2.dilate(combined,kernel,iterations = 1)\n",
    "        masked_image=region_of_interest(combined,vertices)\n",
    "        warped,M,src,dst,flagM=p_transform(combined,H,W,LowerThres,DestThres,M,flagM,src,dst)\n",
    "        color_warp,flagM1,M1,left_fit,right_fit=draw_lanes(warped,M1,src,dst,flagM1,M1,left_fit,right_fit)\n",
    "        out = weighted_img(img, color_warp, 0.6, 1, 0) \n",
    "        cv2.imwrite('output_images/Annotated_'+tmpname[0]+'.jpg',out)\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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": 1
}