Lane Recognition.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "import math\n",
    "from operator import itemgetter, attrgetter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def display(img):\n",
    "    cv2.imshow('image', img)\n",
    "    cv2.waitKey(0)\n",
    "    cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = cv2.imread('photos\\WrongLane1.jpg', flags=cv2.IMREAD_COLOR)\n",
    "resized = cv2.resize(image, (1280, 720), interpolation = cv2.INTER_AREA)\n",
    "display(resized)\n",
    "\n",
    "gray_image = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY)\n",
    "display(gray_image)\n",
    "\n",
    "recontrasted = cv2.equalizeHist(gray_image)\n",
    "display(recontrasted)\n",
    "\n",
    "img_hsv = cv2.cvtColor(resized, cv2.COLOR_RGB2HSV)\n",
    "lower_yellow = np.array([20, 100, 100], dtype = 'uint8')\n",
    "upper_yellow = np.array([30, 255, 255], dtype='uint8')\n",
    "mask_yellow = cv2.inRange(img_hsv, lower_yellow, upper_yellow)\n",
    "mask_white = cv2.inRange(gray_image, 200, 255)\n",
    "mask_yw = cv2.bitwise_or(mask_white, mask_yellow)\n",
    "mask_yw_image = cv2.bitwise_and(gray_image, mask_yw)\n",
    "display(mask_yw_image)\n",
    "\n",
    "kernel_size = 5\n",
    "gauss_gray = cv2.GaussianBlur(mask_yw_image, (5,5), 0)\n",
    "display(gauss_gray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Setting thresholds for yellow and white"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Detecting edges with Canny"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "low_threshold = 50\n",
    "high_threshold = 150\n",
    "canny_edges = cv2.Canny(gauss_gray, low_threshold, high_threshold)\n",
    "display(canny_edges)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cropping the image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(720, 1280)\n"
     ]
    }
   ],
   "source": [
    "imshape = canny_edges.shape\n",
    "print(imshape)\n",
    "\n",
    "roi_image = canny_edges[int(imshape[0]/2):imshape[0]-40, 0:imshape[1]]\n",
    "display(roi_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Doing some magic with Hough space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filterLines(lines):\n",
    "    filteredLines = []\n",
    "    for i in range(0, len(lines)):\n",
    "        rho = lines[i][0][0]\n",
    "        theta = lines[i][0][1]\n",
    "        if math.sin(theta) == 0:\n",
    "            continue\n",
    "        a = math.cos(theta)/math.sin(theta)\n",
    "        if -0.5 <= a <= 0.5:\n",
    "            continue\n",
    "        if sum(1 for line in filteredLines if abs(line[0][1] - theta) < 0.25) == 0:\n",
    "             filteredLines.append(lines[i])\n",
    "    return filteredLines\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 14422 lines\n",
      "Filtering lines\n",
      "Found 4948 lines\n",
      "Filtering lines\n",
      "Found 1944 lines\n",
      "Filtering lines\n",
      "Found 864 lines\n",
      "Filtering lines\n",
      "Found 438 lines\n",
      "Filtering lines\n",
      "Found 277 lines\n",
      "Filtering lines\n",
      "Found 173 lines\n",
      "Filtering lines\n",
      "After filtering 2 lines\n",
      "line 0: rho=-529.0 theta=2.583087205886841\n",
      "From point (-81, -1128) to (978, 567)\n",
      "line 1: rho=337.0 theta=1.0821040868759155\n",
      "From point (-724, 767) to (1041, -171)\n"
     ]
    }
   ],
   "source": [
    "line_image = cv2.cvtColor(roi_image, cv2.COLOR_GRAY2RGB)\n",
    "rho = 1\n",
    "theta = np.pi/180\n",
    "threshold = 10\n",
    "min_line_len = 200\n",
    "max_line_gap = 100\n",
    "\n",
    "while True:\n",
    "    lines = cv2.HoughLines(roi_image, rho, theta, threshold, min_line_len, max_line_gap)\n",
    "    print('Found ' + str(len(lines)) + ' lines')\n",
    "    print('Filtering lines')\n",
    "    filteredLines = filterLines(lines)\n",
    "    if len(filteredLines) <= 3:\n",
    "        break\n",
    "    threshold += 10\n",
    "\n",
    "\n",
    "if filteredLines is not None:\n",
    "    print('After filtering ' + str(len(filteredLines)) + ' lines')\n",
    "    for i in range(0, len(filteredLines)):\n",
    "        rho = filteredLines[i][0][0]\n",
    "        theta = filteredLines[i][0][1]\n",
    "        print(f'line {i}: rho={rho} theta={theta}')\n",
    "        a = math.cos(theta)\n",
    "        b = math.sin(theta)\n",
    "        x0 = a * rho\n",
    "        y0 = b * rho\n",
    "        pt1 = (int(x0 + 1000*(-b)), int(y0 + 1000*(a)))\n",
    "        pt2 = (int(x0 - 1000*(-b)), int(y0 - 1000*(a)))\n",
    "        print(f'From point {pt1} to {pt2}')\n",
    "        cv2.line(line_image, pt1, pt2, (0, 0, 255), 5)\n",
    "        \n",
    "imshape = line_image.shape\n",
    "cv2.line(line_image, (int(imshape[1]/2), 0), (int(imshape[1]/2), imshape[1]), (255, 0, 0), 2)\n",
    "\n",
    "display(line_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can do it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=0.5317094949770185 x00=115.99589189609142\n",
      "a=-1.6003342189973113 x00=823.7436406652968\n"
     ]
    }
   ],
   "source": [
    "imshape = line_image.shape\n",
    "y = imshape[0]\n",
    "cutoffPoint = int(imshape[1]/2)\n",
    "\n",
    "linesData = []\n",
    "for i in range(0, len(filteredLines)):\n",
    "    rho = filteredLines[i][0][0]\n",
    "    theta = filteredLines[i][0][1]\n",
    "    a = -1 * math.cos(theta)/math.sin(theta)\n",
    "    b = rho/math.sin(theta)\n",
    "    x00 = (y - b)/a\n",
    "    a *= -1 #convenience\n",
    "    if (x00 < cutoffPoint and a > 0) or (x00 > cutoffPoint and a < 0):      \n",
    "        linesData.append((a, x00))\n",
    "        \n",
    "linesData = sorted(linesData, key=itemgetter(1))\n",
    "\n",
    "for i in range(0, len(linesData)):\n",
    "    print(f'a={linesData[i][0]} x00={linesData[i][1]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CAUTION! You are on the WRONG side! MURDERER!\n"
     ]
    }
   ],
   "source": [
    "cutoffPoint = int(imshape[1]/2)\n",
    "correctSideMsg = 'You are on correct side of the road'\n",
    "wrongSideMsg = 'CAUTION! You are on the WRONG side! MURDERER!'\n",
    "\n",
    "linesOnLeft = [l for l in linesData if l[1] < cutoffPoint]\n",
    "linesOnRight = [l for l in linesData if l[1] > cutoffPoint]\n",
    "    \n",
    "if len(linesData) == 3:\n",
    "    if(len(linesOnLeft) < len(linesOnRight)): #LEFT SIDE\n",
    "        print(correctSideMsg)\n",
    "    else: #RIGHT SIDe\n",
    "        print(wrongSideMsg)\n",
    "elif len(filteredLines) == 2 and (len(linesOnLeft) == len(linesOnRight)):\n",
    "    if abs(linesOnLeft[0][0]) > abs(linesOnRight[0][0]): #LEFT SIDE\n",
    "        print(correctSideMsg)\n",
    "    else:\n",
    "        print(wrongSideMsg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}