How to detect a face and draw a bounding box around it using OpenCV Python?

Are you interested in learning how to detect a face and draw a bounding box around it using OpenCV Python? This is a great skill to have for various computer vision projects, and it’s not as hard as you might think. In this article, we will cover all the necessary steps to detect a face, draw a bounding box around it, and even add some text to indicate the position of the detected face.

Prerequisites

Before we dive into the code, let’s ensure that we have all the prerequisites set up. You will need the following:

• Python 3.x (recommended version 3.7 or above)
• OpenCV-Python library (version 4.x recommended)

To install OpenCV-Python, you may use the pip package manager. Open your terminal or command prompt and run the following command:

pip install opencv-python

This will install the latest version of OpenCV-Python.

Basic Code for Face Detection

Let’s start by writing some basic code to detect a face using OpenCV Python. We will be using the built-in haarcascade_frontalface_default.xml file from OpenCV to detect the frontal face. The code is as follows:

import cv2

face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
img = cv2.imread('image.jpg')

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.3, 5)

for (x,y,w,h) in faces:
    cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)

cv2.imshow('img',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

Let’s go through this code line by line. Firstly, we imported the OpenCV library using the import statement. Then, we loaded the face cascade XML file using the cv2.CascadeClassifier() function and assigned it to the variable face_cascade. Next, we loaded an image using the cv2.imread() function and assigned it to the variable img.

Since we are detecting faces in grayscale, we converted our image to grayscale using the cv2.cvtColor() function. We then use the detectMultiScale() function on the grayscale image to detect any faces in the image. The detectMultiScale() function returns a list of rectangles, where each rectangle represents a detected face.

We then looped through the list of rectangles, drawing a rectangle around each detected face. The cv2.rectangle() function takes several parameters: the image, the top-left and bottom-right points of the rectangle, the color of the rectangle (in BGR format), and the thickness of the rectangle. We then displayed the image using the cv2.imshow() function, waited for a key press using the cv2.waitKey() function, and finally destroyed all windows using the cv2.destroyAllWindows() function.

We have successfully detected and drawn bounding boxes around the faces in the image!

Adding Text to the Detected Face

Now that we have successfully detected and drawn a bounding box around the face, we can further enhance our output by adding text to indicate the position of the detected face. The updated code is as follows:

import cv2

face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
img = cv2.imread('image.jpg')

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.3, 5)

for (x,y,w,h) in faces:
    cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
    font = cv2.FONT_HERSHEY_SIMPLEX
    cv2.putText(img,'Face',(x,y-10), font, 0.7, (255,0,0), 2, cv2.LINE_AA)

cv2.imshow('img',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

In this updated code, we have added the cv2.putText() function to display the word “Face” on top of the detected face. We first defined the font using the cv2.FONT_HERSHEY_SIMPLEX parameter, and then passed several arguments to thecv2.putText() function, including the image, the text to be displayed, the position of the text (just above the detected face), the font, the font scale, the color, the thickness, and the line type. We used the cv2.LINE_AA line type to ensure that the text appears smooth.

And there we have it! We have successfully detected and drawn a bounding box around the face, as well as added text to indicate the position of the detected face.

Real-time Face Detection with Live Camera Feed

Finally, let’s take a step further and use OpenCV Python to detect faces in real-time with a live camera feed. We will be using the built-in camera of our device for this purpose. The code is as follows:

import cv2

face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
cap = cv2.VideoCapture(0)

while True:
    _, img = cap.read()
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)

    for (x,y,w,h) in faces:
        cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
        font = cv2.FONT_HERSHEY_SIMPLEX
        cv2.putText(img,'Face',(x,y-10), font, 0.7, (255,0,0), 2, cv2.LINE_AA)

    cv2.imshow('img',img)
    k = cv2.waitKey(30) & 0xff
    if k == 27:
        break

cap.release()
cv2.destroyAllWindows()

Let’s go through this code line by line. We first imported the necessary libraries and loaded the face cascade XML file just as before. We then used the cv2.VideoCapture() function to capture video from our device’s camera.

Inside the while loop, we read each frame from the video using the cap.read() function. We then convert the frame to grayscale using the cv2.cvtColor() function. We use the detectMultiScale() function to detect any faces in the grayscale frame, and draw a bounding box and add text to each detected face as before.

We then displayed each frame using the cv2.imshow() function and waited for a key press using the cv2.waitKey() function. If the key pressed is the esc key, we break out of the loop. Finally, we release the camera and destroy all windows using the cap.release() and cv2.destroyAllWindows() functions, respectively.

As we can see, the OpenCV Python program is successfully detecting faces in real-time with the live camera feed!

Conclusion

In this article, we have covered how to detect a face and draw a bounding box around it using OpenCV Python. We started by writing some basic code to detect a face, then added text to enhance the output, and finally implemented real-time face detection using live camera feed.

By following these steps, you should now have a good understanding of how to detect faces using OpenCV Python, and can further apply this skill to various computer vision projects.