5 Best Ways to Detect a Face and Draw a Bounding Box Around It Using OpenCV Python

💡 Problem Formulation: With the increasing need for real-time face detection in applications such as security systems, photo tagging, and facial recognition, the solution lies in accurately identifying human faces within an image and marking them clearly with bounding boxes. In this article, we will explore how to perform this task using Python and the OpenCV library, aiming for an input of an image/video feed and an output that visually indicates where the faces are located.

Method 1: Haar Cascades

Haar Cascades is an effective object detection method used to identify faces in an image. Utilizing trained Haar feature-based cascade classifiers, it is a machine learning approach where a cascade function is trained with positive and negative images. Once trained, the classifier can detect faces in new images with high accuracy.

Here’s an example:

import cv2

face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
image = cv2.imread('image.jpg')
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray_image, 1.1, 4)

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

cv2.imshow('Faces Detected', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output is an image with rectangles drawn around detected faces.

This code snippet loads a pre-trained Haar Cascade classifier and applies it to the given image to detect faces. It converts the image to grayscale to simplify the computation, then uses the detectMultiScale() function to find faces, drawing red bounding boxes around them with the help of cv2.rectangle().

Method 2: Deep Learning with OpenCV’s DNN Module

The DNN (Deep Neural Network) module in OpenCV allows for face detection using deep learning models. This method provides high accuracy and is robust to variations in face orientation, lighting, and expression, by using a trained deep learning model such as a Caffe or TensorFlow model.

Here’s an example:

import cv2

modelFile = "res10_300x300_ssd_iter_140000.caffemodel"
configFile = "deploy.prototxt"
net = cv2.dnn.readNetFromCaffe(configFile, modelFile)

image = cv2.imread('image.jpg')
(h, w) = image.shape[:2]
blob = cv2.dnn.blobFromImage(cv2.resize(image, (300, 300)), 1.0,
    (300, 300), (104.0, 177.0, 123.0))

net.setInput(blob)
detections = net.forward()

for i in range(0, detections.shape[2]):
    confidence = detections[0, 0, i, 2]
    if confidence > 0.5:
        box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
        (x, y, x1, y1) = box.astype("int")
        cv2.rectangle(image, (x, y), (x1, y1), (0, 255, 0), 2)

cv2.imshow("Face Detection by DNN", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output is an image with rectangles drawn around detected faces with a confidence score above 50%.

This snippet demonstrates loading a deep learning model for face detection, pre-processing the input image as a blob, and using the net.forward() function to detect faces. It then iterates over detected faces, checking for a confidence score above a threshold before drawing a bounding box around each face.

Method 3: Using Dlib

Dlib is a toolkit containing machine learning algorithms and tools for creating complex software to solve real-world problems. Dlib’s face detector is built on a histogram of oriented gradients (HOG) feature combined with a linear classifier, an image pyramid, and a sliding window detection scheme.

Here’s an example:

import cv2
import dlib

detector = dlib.get_frontal_face_detector()
image = cv2.imread('image.jpg')
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
faces = detector(gray_image)

for face in faces:
    x, y, w, h = face.left(), face.top(), face.right() - face.left(), face.bottom() - face.top()
    cv2.rectangle(image, (x, y), (x+w, y+h), (0, 0, 255), 2)

cv2.imshow('Face Detection with Dlib', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output is an image with red bounding boxes around detected faces.

In this method, the dlib detector is applied to a grayscale image to find faces using HOG features. The code then draws a blue rectangle around each detected face using the coordinates provided by the dlib detector.

Method 4: Multi-task Cascaded Convolutional Networks (MTCNN)

MTCNN is a neural network that detects faces and facial landmarks. It uses a cascade structure with three networks; P-Net, R-Net, and O-Net, to detect faces in multiple stages, achieving impressive accuracy and efficiency.

Here’s an example:

from mtcnn.mtcnn import MTCNN
import cv2

detector = MTCNN()
image = cv2.imread('image.jpg')
results = detector.detect_faces(image)

for result in results:
    bounding_box = result['box']
    keypoints = result['keypoints']
    cv2.rectangle(image,
                  (bounding_box[0], bounding_box[1]),
                  (bounding_box[0]+bounding_box[2], bounding_box[1] + bounding_box[3]),
                  (255,255,0),
                  2)

cv2.imshow("Face Detection with MTCNN", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output is an image with yellow bounding boxes around detected faces and facial landmarks.

By leveraging the MTCNN detector, we can not only detect the bounding box of faces, but also identify facial landmarks such as eyes, nose, and mouth. Here the rectangles for the detected faces are drawn in yellow on the image.

Bonus One-Liner Method 5: Using cvlib

cvlib is a high-level library that simplifies the process of face detection using a single line of code. It is user-friendly and can be used for a quick implementation of face detection with minimal setup.

Here’s an example:

import cv2
import cvlib as cv
image = cv2.imread('image.jpg')
faces, confidences = cv.detect_face(image)
for face in faces:
    (startX, startY, endX, endY) = face[0], face[1], face[2], face[3]
    cv2.rectangle(image, (startX,startY), (endX,endY), (0,255,0), 2)
cv2.imshow("Face detection using cvlib", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

The output displays an image with green bounding boxes around detected faces.

This method showcases the simplicity of cvlib for face detection, where the function cv.detect_face() returns the bounding boxes and associated confidence levels, and the code then draws the boxes on the image.

Summary/Discussion

Method 1: Haar Cascades.

Method 2: DNN Module.

Method 3: Using Dlib.

Method 4: MTCNN.

Bonus Method 5: cvlib.