How to Build an Algorithm for Face and License Plate Blurring Using OpenCV and Python

In today's world, privacy is of the utmost importance. As the cost of buying high-resolution cameras has decreased over the years, it became easier than ever to capture and share images and videos.

Whilst the increasing volume of available data is definitively good news for accelerating the development of even more advanced computer vision applications (e.g., autonomous vehicles, asset management, etc), ethical questions must be asked when personal data are involved.

As we extensively argued in previous articles, blurring is the most effective instrument to secure personal data from a legal and technical perspective. In this article, we'll show you how to build an algorithm for blurring faces and license plates using OpenCV and Python.

Installing OpenCV and its dependencies

OpenCV is an open-source computer vision library that allows developers to build image and video processing applications. It provides various features such as image and video capture, filtering, and object detection.

Before we start coding, we need to install OpenCV and its dependencies. We'll be using the pip package manager to install OpenCV, which can be done with the following command:

pip install opencv-python

We'll also need to install numpy, which is a package for scientific computing with Python. This can be done with the following command:

pip install numpy

Loading the image and detecting faces and license plates

Once we've installed OpenCV and its dependencies, we can start coding. The first step is to load the image and detect faces in the image. We'll be using OpenCV's CascadeClassifier to detect faces and license plates. First, download the classifiers from GitHub:

[pip install numpy](https://github.com/opencv/opencv/blob/master/data/haarcascades/haarcascade_frontalface_default.xml
https://github.com/opencv/opencv/blob/3.4/data/haarcascades/haarcascade_russian_plate_number.xml
)

Here's the code to load the image and detect faces and license plates:

import cv2
import numpy as np

# Load the image
image = cv2.imread('image.jpg')

# Create a CascadeClassifier object for face detection
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

# Create a CascadeClassifier object for license plate detection
plate_cascade = cv2.CascadeClassifier('haarcascade_russian_plate_number.xml')

# Convert the image to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Detect faces and license plates in the image
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)
plates = plate_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)

# Optional: Draw rectangles around the detected faces and license plates
for (x, y, w, h) in faces:
    cv2.rectangle(image, (x, y), (x+w, y+h), (0, 0, 255), 10)

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

This code loads the image 'image.jpg' and creates CascadeClassifier objects for face and license plate detection. It then converts the image to grayscale and detects faces and license plates in the image using the detectMultiScale() method. Finally, it draws rectangles around the detected faces and license plates.

Applying blurring to the detected regions

Now that we've detected the faces and license plates in the image, we can apply blurring to these regions to anonymize them. There are several methods of blurring, including pixelation and Gaussian blurring. For this example, we'll be using Gaussian blurring, which produces a smoother and more natural-looking blur.

Here's the code to apply Gaussian blurring to the detected faces and license plates, display the results and save the resulting image:

# Apply Gaussian blurring to the detected faces and license plates
for (x, y, w, h) in faces:
    roi = image[y:y+h, x:x+w]
    blurred_roi = cv2.GaussianBlur(roi, (255, 255), 0)
    image[y:y+h, x:x+w] = blurred_roi

for (x, y, w, h) in plates:
    roi = image[y:y+h, x:x+w]
    blurred_roi = cv2.GaussianBlur(roi, (255, 255), 0)
    image[y:y+h, x:x+w] = blurred_roi

# Optional: Display the image with the detected faces and license plates
cv2.imshow('Image', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

# Save the anonymized image to disk
cv2.imwrite('anonymized_image.jpg', image)

This code applies Gaussian blurring to the detected faces and license plates using the GaussianBlur() method. We create a region of interest (ROI) for each detected face and license plate, apply the blur to the ROI, and then replace the original region with the blurred region in the image. Finally, we display the anonymized image and save it to disk using the imwrite() method.

Building Your Solution vs. Using a Ready-to-Go Solution

While building your solution using OpenCV and Python might seem the best option to have full control over the code and customize it to your specific needs, it presents some disadvantages:

• It can be time-consuming to build and test a solution from scratch.
• You need to have good ML segmentation or objection model. You’ll soon realize that the Cascade Classifiers are very limited in accuracy and efficiency (especially for specific use cases)
• It defocuses you from the core aspects of your project
• Maintenance and updates may require additional time and resources.

Avoid the hassle, use Celantur instead

Celantur Edge SDK is a real-time image and video blurring SDK. It is easy to integrate into your C++ or Python workflows and can run on various platforms.

Celantur Container is a Docker Container for image and video anonymization. It can be deployed on-premise and in the cloud, scalable for massive amounts of data.

Celantur API is a public REST-based web API for image anonymization. Perfect for small projects and integrations into web apps and solutions.

Conclusion

In conclusion, face and license plate blurring can be accomplished using OpenCV and Python. while there are benefits to building your solution, using Celantur can save time and provide a superior solution in terms of accuracy, maintenance, and deployment options. Regardless of the approach taken, the most important goal is protecting privacy in images and videos.