How to Blur Faces with Python

If you're looking for a quick and easy way to blur faces in your photos, then you've come to the right place! In this short tutorial, we'll show you how to use the cv2.GaussianBlur() function to blur faces in photos. Python offers a number of libraries for image processing, including the popular OpenCV Library. One of the things you can do with OpenCV is blur faces in images. This can be useful for privacy purposes, or for creating artistic effects.

To power the face detection we will use the CaffeNet Model. You'll need to run the command below to save the weights locally.

mkdir weights && cd weights
curl -L https://raw.githubusercontent.com/ConceptCodes/Wheres-Waldo/master/weights/deploy.prototxt.txt > deploy.prototxt.txt
curl -L https://github.com/ConceptCodes/Wheres-Waldo/raw/master/weights/res10_300x300_ssd_iter_140000_fp16.caffemodel > res10_300x300_ssd_iter_140000_fp16.caffemodel

Afterwards your directory should look similar to this.

Nows a good time to create a main.py file in the root directory if you have not already. Also make sure to add your input image to the root directory.

project
│   input.jpg
│   main.py    
│
--- weights
    │   deploy.prototxt.txt
    │   res10_300x300_ssd_iter_140000_fp16.caffemodel

First we want to import the necessary libraries. We will be using the cv2 library for image processing and the numpy library for array manipulation. tqdm is a library that provides a progress bar for long running tasks.

main.py

import os
import cv2
import numpy as np
from tqdm import tqdm

# set path to your current directory
path = os.getcwd()

# load in the model & weights
weights = os.path.join(path,'weights','deploy.prototxt.txt')
models = os.path.join(path,'weights','res10_300x300_ssd_iter_140000_fp16.caffemodel')

# build the face detector
face_detector = cv2.dnn.readNetFromCaffe(weights, models)
print('Face Detection Model Loaded Successfully!\n')

Now that our face detector is built we'll need to load in our input image. For this we'll use the imread() method from opencv. This is used to read an image from a file and return a numpy array containing the image data.

main.py

img_path = os.path.join(path,'input.jpg')
img = cv2.imread(img_path)
h, w = img.shape[:2]

kernel_width = (w // 7) | 1
kernel_height = (h // 7) | 1

Once the image is processed, we will need to set the (kernel_width, kernel_height). This is the size that the GaussianBlur will cover in final photo. Okay, now we can start detecting faces in the image.

main.py

blob = cv2.dnn.blobFromImage(img, 1.0, (300, 300), (104.0, 177.0, 123.0))
face_detector.setInput(blob)

output = np.squeeze(face_detector.forward())
print('Processing image...')

for i in tqdm(range(0, output.shape[0])): 
  confidence = output[i, 2]

  if confidence > 0.4:
    box = output[i, 3:7] * np.array([w, h, w, h])
    start_x, start_y, end_x, end_y = box.astype(np.int)
    face = img[start_y: end_y, start_x: end_x]
    face = cv2.GaussianBlur(face, (kernel_width, kernel_height), 0)
    img[start_y: end_y, start_x: end_x] = face

output_dir = os.path.join(path,'output.jpg')
cv2.imwrite(output_dir, img)
print('Success, Photo located at {}'.format(output_dir))

And if we wanted to go for more of a pixelated effect, First we need to add this function that takes a numpy array as input and splits it into a 21x21 grid. For each of the grid squares, we calculate the mean of the (r,g,b) values, and then color that grid square with those mean values. Finally we use cv2.rectangle() to merge the pixelated face into the image.

def pixels(image):
	(h, w) = image.shape[:2]
	xSteps = np.linspace(0, w, 21, dtype="int")
	ySteps = np.linspace(0, h, 21, dtype="int")
	for i in range(1, len(ySteps)):
		for j in range(1, len(xSteps)):
		
			startX = xSteps[j - 1]
			startY = ySteps[i - 1]
			endX = xSteps[j]
			endY = ySteps[i]

			roi = image[startY:endY, startX:endX]
			(B, G, R) = [int(x) for x in cv2.mean(roi)[:3]]
			cv2.rectangle(image, (startX, startY), (endX, endY),
				(B, G, R), -1)
	
	return image

Now to pixelate the face we need to modify our code from earlier

face = img[start_y: end_y, start_x: end_x]
#  face = cv2.GaussianBlur(face, (kernel_width, kernel_height), 0)
#  img[start_y: end_y, start_x: end_x] = face
img[start_y: end_y, start_x: end_x] = pixels(face)

Results

Blurring faces in images is a simple way to protect peoples privacy. It's also a fun way to create artistic effects. Python is a versatile language that can be used for a variety of purposes. In addition to image manipulation, python can be used for web development, data analysis, and machine learning.

Original	Gaussian	Pixelated