Here in this Python tutorial, we will perform edge detection in Python using OpenCV methods. We will also build a Python program that finds the edges for a live video. In edge and gradient detection of an image, we find out the boundaries around the object, and it is generally done with the changing intensities between two colors.
Although edges and gradients are two different concepts in mathematics, in image processing with programming, you can interchangeably use both in many cases.
As we will be processing our image using Python, we assume you have installed Python on your system, and you have the latest or Python 3.4 or a newer version. For this tutorial, we will be using OpenCV to process the image and find edges. You can easily install OpenCV using the following Python pip terminal command:
pip install opencv-python
In some parts of our program, we will also be using the Python numpy library, so make sure that it is also installed for your Python environment. Although you do not need to install Numpy separately because when you install
, it will automatically install numpy for you, just to ensure run the following command on your terminal or command prompt to install numpy:
pip install numpy
How to Perform Edge Detection in Python Using OpenCV?
In OpenCV, there are three methods to detect edges in an image:
We will be using the following birds.jpg image for this tutorial and detecting its object edges:
Now, open your Python IDE or text editor and start coding.
1) OpenCV Edge Detection with Canny Edge Detector
Canny Edge detection is an advanced and multi-level edge detection algorithm. But with OpenCV, you do not have to worry about writing this algorithm from scratch. OpenCV provides the
method, which can detect all the edges of an image.
Let's start with importing the OpenCV module and loaing our birds.jpg image.
import cv2 as cv #load birds image image = cv.imread("birds.jpg")
Our Python script and the
image are in the same directory. Thus, we have specified the relative path by just specifying the image name. Next, we convert the loaded BGR
to a grayscale image because a colorful image can have multiple color intensities.
Therefore, by converting it to grayscale (black and white), we reduce the intensity of the colors between black and white, and it helps in better edge detection.
#convert to gray image gray_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
will convert the BGR
to the GrayScale image. You can see the converted GrayScale image with the
cv.imshow("Gray Image:", gray_image)
statement, and you will see a similar image.
After converting the image into a GrayScale image, now pass the
to the OpenCV
cv.Canny(image, threshold1, thresold2)
method. The Canny() method will return all the edges of the image.
#detect edges canny_edges = cv.Canny(gray_image, 120, 150)
Here, 120 represents the first threshold for the hysteresis procedure, and 150 represents the second threshold for the hysteresis procedure. Next, show the edges using the
#show edges cv.imshow("Canny Edges", canny_edges) cv.waitKey(0)
When you execute the program, you will see a similar image:
2) OpenCV Edge Detection with Laplacian Edge Sharpening
Laplacian is an edge sharpening algorithm, and in OpenCV, we can use this algorithm with the
method and detect edges in an image. Let's start with importing the required modules followed by loading the image, and like Canny Edges detection, converting the BGR image to GrayScale.
import cv2 as cv import numpy as np #load birds image image = cv.imread("birds.jpg") #convert to gray image gray_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
Here you can see that we have also imported the
module. We will be using it in this program. After converting the BGR
, now detect the gradients or edges of the
using the OpenCV
#detect gradients, edges lap_edges = cv.Laplacian(gray_image, cv.CV_64F)
Here, we are detecting the edges or gradient of
, with destination depth
method detects the gradients for black and white, and due to its vector nature, it converts some of its slope to negative, resulting in negative pixels.
Now, let's set all
values to absolute using the numpy
method, and then convert all those absolute values to an image array using the
method. The unit8 is the data type of the image.
#convert all -ve pixels to positives lap_edges = np.uint8(np.absolute(lap_edges))
cv.imshow("Laplacian Edges", lap_edges) cv.waitKey(0)
When you execute the above program, you will see a similar image:
3) OpenCV Edge Detection with Sobel Edge Detector
Sobel Edge detection detects the gradient of the image in two directions, X and Y axes. When we detect the gradients in an image using Sobel in the x-direction, we use
and, when we detect the gradients in an image using Sobel in the y-direction, we use
import cv2 as cv import numpy as np #load birds image image = cv.imread("birds.jpg") #convert to gray image gray_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY) #detect sobel gradients sobel_x_edges = cv.Sobel(gray_image, cv.CV_64F,1, 0) sobel_y_edges = cv.Sobel(gray_image, cv.CV_64F,0, 1) #convert all -ve pixels to positives sobel_x_edges = np.uint8(np.absolute(sobel_x_edges)) sobel_y_edges = np.uint8(np.absolute(sobel_y_edges)) #show images cv.imshow("Sobel X Edges", sobel_x_edges) cv.imshow("Sobel y Edges", sobel_y_edges) cv.waitKey(0)
When you execute the above program, you will see the following images:
Edge Detection of a Live Video
Now you know how to detect the edges in an image. Next, let's write a Python program that can detect edges from a live video of a webcam. As OpenCV is capable of image as well as video processing, we will be using it with the
method to detect edges from a live webcam.
import cv2 as cv #start web cam capture = cv.VideoCapture(0) # 0 for web-cam while True: #read video frame by frame isTrue, frame= capture.read() canny_edges = cv.Canny(frame, 120, 150) #show edges Video cv.imshow("Edges Video", canny_edges) #to display real web cam # cv.imshow("Real Web Cam",frame ) #press e to exit if cv.waitKey(20) ==ord("e"): break capture.release() capture.destroyAllWindows()
In most cases, you will be using the
method to detect edges in an image. The Laplacian() and Sobel() methods are generally used to detect gradients, and with these two methods, you need to convert the negative pixels to their absolute value using the
People are also reading: