Face detection with Raspberry Pi

One nice thing that can be done with the latest technology is a really powerful image analysis. Also using a small unit like a Raspberry Pi can be enough to create tasks such as face detection and recognition.

These two tasks are quite similar. Detection is just the task of finding a face in an image (could be static image or a frame from a video stream). Recognition is finding a known face in a picture. 

For this post I will show you how to configure a small face detection system using a RPi and a PiCamera.

As always, remember to keep your system updated.

For this task I will use OpenCV libraries. I think these are the best open source libraries available to perform image processing and they are not too complicated. Also they can be used directly with Python. To install them use:

sudo apt-get install libopencv-dev python-opencv python-dev 

This is enough to create a script for detecting a face in a saved image. If you wish to get the image directly from the PiCamera, then you should also install the python libraries (if you do not have already installed them):

sudo apt-get install python-picamera

Now look at the following code:

import cv2

#Load an image from file

image = cv2.imread("face.jpg", 1)

#Load a cascade file for detecting faces

face_cascade = cv2.CascadeClassifier('/usr/share/opencv/haarcascades/haarcascade_frontalface_alt.xml')

#Convert to grayscale

gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)

#Look for faces in the image using the loaded cascade file

faces = face_cascade.detectMultiScale(gray, 1.1, 5)

print "Found "+str(len(faces))+" face(s)"

#Draw a rectangle around every found face

for (x,y,w,h) in faces:

    cv2.rectangle(image,(x,y),(x+w,y+h),(255,0,0),2)

#Save the result image

cv2.imwrite('result.jpg',image)

First of all we load the picture we want to analyze. After that we need to tell OpenCV what kind of "feature" we want to find opening a cascade file. As we are looking for faces, we just use the right one for this feature.
In the opencv folder there are several ready-made cascade files, but you could also create one on your own (these will be mandatory for face recognition).

We could talk about cascades for days. For our scope you just need to know that Haar cascades are a bit slower (because they use floating point math), but more precise. LBP are faster (use integer math) but have less precision. It's up to you to choose the one that's right for you.
You just need to change the file specified in the CascadeClassifier function.

Let's go further. The next step is to convert the loaded picture into grayscale. This is not really needed, but will improve speed and detection rate.

After converting the image, we will perform the real process executing the cascade. As you can see it's quite simple!
Here you may need to change the middle parameter (here is 1.1) to make it perform better. This is a scale factor and can greatly affect the detecting process. Unfortunately there is no "perfect" value for this and could change for different pictures...

The process will return a list (empty if no faces have been found) with the coordinates of the rectangle surrounding the detected faces. The length of the list gives of course the number of found features (used in the print statement).

After printing the message, we get all the values from the list and draw every rectangle around the detected faces. Then the resulting picture is saved in a new file.

Here you can see an example with the original image and the result after the processing:

If you prefer to get the image directly from the PiCamera you need to modify the script like this:

import io

import picamera

import cv2

import numpy

#Create a memory stream so photos doesn't need to be saved in a file

stream = io.BytesIO()

#Get the picture (low resolution, so it should be quite fast)

#Here you can also specify other parameters (e.g.:rotate the image)

with picamera.PiCamera() as camera:

    camera.resolution = (320, 240)

    camera.capture(stream, format='jpeg')

#Convert the picture into a numpy array

buff = numpy.fromstring(stream.getvalue(), dtype=numpy.uint8)

#Now creates an OpenCV image

image = cv2.imdecode(buff, 1)

#Load a cascade file for detecting faces

face_cascade = cv2.CascadeClassifier('/usr/share/opencv/haarcascades/haarcascade_frontalface_alt.xml')

#Convert to grayscale

gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)

#Look for faces in the image using the loaded cascade file

faces = face_cascade.detectMultiScale(gray, 1.1, 5)

print "Found "+str(len(faces))+" face(s)"

#Draw a rectangle around every found face

for (x,y,w,h) in faces:

    cv2.rectangle(image,(x,y),(x+w,y+h),(255,0,0),2)

#Save the result image

cv2.imwrite('result.jpg',image)

What we are doing here is just capturing an image into a memory stream and converting it to a numpy stream so that we can use it for OpenCV. The processing part of the script is just the same as before.

Let's see another example with a bunch of faces (NASA Astronaut Group 18 from Wikipedia):

Face detection could be used for several scopes.
In an home automation system it could be useful to detect an intrusion. Instead of saving the result image, we could for example send the picture to our smartphone using Whatsapp, so we could personally check if we need to take further actions.

In a future post I will describe how to make face recognition on a Raspberry Pi.