Lane Detection OpenCV Python Read it later

In this blog, we’ll explore lane detection using OpenCV in Python. Lane detection plays a crucial role in autonomous driving and advanced driver assistance systems. With OpenCV’s powerful computer vision library, we’ll learn how to process images and extract lane information. Throughout the blog, we’ll provide clear explanations and concise code examples to help you grasp the concepts easily. Let’s dive into the captivating world of lane detection and unlock new possibilities in computer vision. Let’s get started!

What is Lane Detection?

Lane detection is the process of identifying the lane boundaries on the road. It is an essential task for autonomous driving systems and driver assistance systems.

These systems use sensors, cameras, and computer vision algorithms to detect lane markings and determine the vehicle’s position relative to the lane boundaries.

Applications of Lane Detection

Lane detection has numerous practical applications across various industries. Here are some key areas where lane detection technology is utilized:

1. Advanced Driver Assistance Systems (ADAS): Lane detection is a critical component of ADAS, which improves driver safety. It enables features such as lane departure warnings, lane-keeping assistance, and adaptive cruise control, reducing the risk of accidents and enhancing the driving experience.
2. Autonomous Vehicles: In self-driving cars, lane detection is essential for navigation and path planning. It helps vehicles interpret the road environment, identify lane boundaries, and make informed decisions based on lane markings, ensuring precise and safe positioning within lanes.
3. Traffic Monitoring and Control: Lane detection is used in traffic monitoring systems to analyze lane occupancy and traffic flow patterns. This information helps traffic management authorities optimize signal timings, monitor congestion, and implement intelligent transportation systems for more efficient traffic management.
4. Road Sign Recognition: By combining lane detection with road sign recognition, systems can improve the accuracy of sign interpretation. Lane detection provides contextual information, enabling better decision-making based on the surrounding lanes, and enhancing the reliability of road sign recognition systems.
5. Augmented Reality (AR) Navigation: AR-based navigation systems integrate lane detection with live camera feeds and overlays. This allows real-time guidance by superimposing lane information and turn-by-turn directions onto the driver’s field of view, improving situational awareness, especially in complex road environments.
6. Video Surveillance: Lane detection is employed in video surveillance systems to monitor traffic violations. It helps identify unauthorized lane changes, illegal overtaking, or wrong-way driving, triggering alerts or notifying law enforcement authorities for improved road safety and enforcement.

Lane Detection Techniques

Lane detection involves identifying and tracking lanes on the road using computer vision techniques. Here are some commonly used techniques for accurate lane detection:

1. Edge Detection: By detecting the boundaries of objects in an image, edge detection helps distinguish lanes from the surrounding environment. The Canny edge detector is a popular algorithm for this task.
2. Hough Transform: The Hough Transform is used to detect lines in an image. It converts the image space into a parameter space and can accurately detect straight lines. The Probabilistic Hough Transform is often preferred for lane detection due to its efficiency and robustness.
3. Region of Interest (ROI) Selection: Defining a region of interest allows us to focus on the relevant portion of the image where lanes are expected. By limiting the detection process to this area, we improve accuracy and eliminate unwanted features.
4. Perspective Transformation: Perspective transformation provides a bird’s-eye view of the road, improving lane detection accuracy. By applying geometric transformations, we can transform the image from the driver’s viewpoint to a top-down view, removing perspective distortions.
5. Color Filtering and Thresholding: Lanes often have distinct colors compared to the road and surroundings. Color filtering and thresholding techniques isolate the lane markings based on their color properties, making it easier to detect and track them.
6. Machine Learning and Deep Learning: These techniques involve training models on annotated images to learn lane features and patterns. Machine learning algorithms, such as Convolutional Neural Networks (CNNs), have shown promising results in lane detection, achieving high accuracy and robustness.

Lane Detection using OpenCV and Python

In this section, we will explore how to detect lanes using OpenCV and Python. We will use edge detection and the Hough transform to detect the lanes.

Step 1: Import Libraries

We will start by importing the required libraries. We will use the OpenCV library for image processing and Matplotlib for visualization.

import cv2
import numpy as np
import matplotlib.pyplot as plt

Step 2: Read the Image

Next, we will read the image on which we want to detect the lanes. We will use the imread() function of OpenCV to read the image.

image = cv2.imread('road.jpg')

Step 3: Convert Image to Grayscale

We will convert the color image to grayscale using the cvtColor() function of OpenCV.

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

Step 4: Apply Gaussian Blur

We will apply Gaussian blur to the grayscale image to reduce the noise using the GaussianBlur() function of OpenCV.

blur = cv2.GaussianBlur(gray, (5, 5), 0)

Step 5: Detect Edge Using Canny

We will use the Canny edge detection algorithm to detect the edges of the lane markings. We will use the Canny() function of OpenCV for this.

edges = cv2.Canny(blur, 50, 150)

Step 6: Region of Interest

Now, we will define a region of interest (ROI) in the image where we expect the lane markings to be present. We will mask the rest of the image to focus only on the ROI. We will use the fillPoly() function of OpenCV to create a mask and the bitwise_and() function to apply the mask to the image.

mask = np.zeros_like(edges)

Next, we will define the vertices of the ROI polygon. We will use the fillPoly() function of OpenCV to create a mask and the bitwise_and() function to apply the mask to the image.

height, width = image.shape[:2]
roi_vertices = [(0, height), (width/2, height/2), (width, height)]
mask_color = 255
cv2.fillPoly(mask, np.array([roi_vertices], dtype=np.int32), mask_color)
masked_edges = cv2.bitwise_and(edges, mask)

Step 7: Hough Transform

We will use the Hough transform to detect the lines in the masked image. We will use the HoughLinesP() function of OpenCV for this. The function returns a list of lines, where each line is represented by its endpoints.

lines = cv2.HoughLinesP(masked_edges, rho=6, theta=np.pi/60, threshold=160, minLineLength=40, maxLineGap=25)

The rho parameter specifies the distance resolution of the Hough accumulator in pixels. theta parameter specifies the angular resolution of the Hough accumulator in radians.

The threshold parameter specifies the minimum number of votes (intersections) required for a line to be detected.

minLineLength parameter specifies the minimum length of a line in pixels. The maxLineGap parameter specifies the maximum gap between two lines to be considered as a single line.

Step 8: Draw Lines on the Image

We will draw the detected lines on the original image using the line() function of OpenCV.

line_image = np.zeros_like(image)
for line in lines:
    x1, y1, x2, y2 = line[0]
    cv2.line(line_image, (x1, y1), (x2, y2), (0, 255, 0), 5)

Step 9: Overlaying the Lines on the Original Image

Finally, we will overlay the detected lines on the original image using the addWeighted() function of OpenCV.

final_image = cv2.addWeighted(image, 0.8, line_image, 1, 0)

Step 10: Display Result

We will use the imshow() function of Matplotlib to display the final result.

plt.imshow(final_image)
plt.show()

Here’s the complete source code for Lane Detection in OpenCV Python:

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Step 1: Importing Libraries
image = cv2.imread('road.jpg')

# Step 2: Reading the Image
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Step 3: Converting to Grayscale
blur = cv2.GaussianBlur(gray, (5, 5), 0)

# Step 4: Gaussian Blur
edges = cv2.Canny(blur, 50, 150)

# Step 5: Canny Edge Detection
height, width = image.shape[:2]
roi_vertices = [(0, height), (width/2, height/2), (width, height)]
mask_color = 255
mask = np.zeros_like(edges)
cv2.fillPoly(mask, np.array([roi_vertices], dtype=np.int32), mask_color)
masked_edges = cv2.bitwise_and(edges, mask)

# Step 6: Region of Interest
lines = cv2.HoughLinesP(masked_edges, rho=6, theta=np.pi/60, threshold=160, minLineLength=40, maxLineGap=25)

# Step 7: Hough Transform
line_image = np.zeros_like(image)
for line in lines:
    x1, y1, x2, y2 = line[0]
    cv2.line(line_image, (x1, y1), (x2, y2), (0, 255, 0), 5)

# Step 8: Drawing the Lines
final_image = cv2.addWeighted(image, 0.8, line_image, 1, 0)

# Step 9: Overlaying the Lines on the Original Image
plt.imshow(final_image)

# Step 10: Display Image
plt.show()

Wrapping Up

In conclusion, lane detection using OpenCV in Python offers exciting opportunities in computer vision. By leveraging OpenCV’s powerful functions, you can develop accurate and reliable lane detection systems for various applications. From installing OpenCV to applying techniques like Gaussian blur, Canny edge detection, and the Hough Transform, you now have the tools to get started.

Explore further, experiment, and unleash your creativity to push the boundaries of computer vision technology. Good luck on your lane detection journey and happy coding!

Frequently Asked Questions (FAQs)

Reference

1. OpenCV Documentation: https://docs.opencv.org/
2. OpenCV-Python Tutorials: https://opencv-python-tutroals.readthedocs.io/