2.2: Face Detection

Before looking at a face, let’s look at an example that has fewer features. You have no problem identifying the sign as a stop sign, but how do you know it’s a stop sign? What difficulties will a computer have in trying to do the same task?

The easiest way to identify that this is a stop sign is by identifying particular features, such as color and shape. You can train a computer to recognize a stop sign by collecting multiple pictures of stop signs, called positive images, as well as images that do not have stop signs, called negative images. The model that is produced is known as a Haar cascade. This process is similar to how humans learn. We are exposed to signs that are stop signs and signs that are not.

A Haar cascade is named aher a mathematical function, but it was invented by Paul Viola and Michael Jones in 2001. They based their algorithm on the idea that certain features, called Haar features, can represent objects. Think back to the lesson on color classification. Remember that an image is a set of pixels, and each pixel in the color image is normally represented by a set of three numbers. Now convert that stop sign image to grayscale.

In a grayscale image, you only need one number to represent each pixel instead of three. The lowest value is 0, representing black, and the highest value is 255, representing white. Any value in between is a shade of grey.

With this in mind, you can start to understand Haar features. In a stop sign, there will be a certain pattern of lighter pixels representing the letters in “STOP” and slightly darker pixels surrounding them. Now apply this concept to a human face. Faces have multiple features, including eyes, noses, and mouths. If you feed the computer multiple grayscale images of faces, it will start to find a pattern in the average pixel values. Down the bridge of the nose, it is more likely to find a column of lighter pixels surrounded by darker pixels on the sides. The computer might also find that the area with our eyes and eyebrows generally has darker pixels than our cheeks.

Even though the computer isn’t aware of what it’s looking at, it can see pixel value patterns in certain arrangements (for example, your nose wouldn’t be above your eyes) to classify the image as a human face. These are the Haar features that the program will be looking for when presented with a new image it has never seen before.

Training a Haar Cascade is time-consuming. To make a really good classifier, you would need thousands of positive and negative images and some computing power. For detecting faces, the cascade file has already been provided for you! It’s a file with thousands of lines of code that contain all of the information for classifying whatever it was trained to detect.

First, you need to import all of the necessary libraries. You will need the camera library for taking pictures, the vision library for detecting faces, and the screen library for drawing on the screen.

from zumi.util.camera import Camera
from zumi.zumi import Zumi
from zumi.util.screen import Screen
from zumi.util.vision import Vision
import	time

    
zumi =	Zumi()
camera	= Camera()
screen	= Screen()
vision	= Vision()

For a Haar cascade to calculate pixel differences, it needs a grayscale image as input. In the vision library, there is a function that you can use that accepts an image parameter and returns the same image in grayscale. For example, if you take an image and save it inimage, you can convert the color image to grayscale like this:

image = vision.convert to gray(image)

Note: The computer vision library will always convert it to gray in the background for you, but it’s a good habit to convert the image yourself as a reminder of how Haar cascades work. Now, you can use this grayscale version of the image in the function vision.find_face(). This function will look for the Haar features that represent a face and draw a box around any faces the algorithm finds. Here is how you call the function:

vision.find face(image)

Finally, don’t forget to show the image on the screen with vision.show_image().

We know that’s a lot to remember, so we leh you some pseudocode to follow!

start camera
take an image
close the camera
convert the image to gray
try and find a face in the image
show the image

Try taking pictures with your face close up and very far away. How close does your face need to be for the camera to classify it as a face? How far away? The Haar cascade actually has some default values that determine how good your algorithm will be at detecting faces. Depending on your use case, these can be changed.

minSize

Setting a minimum size will only return faces that it finds bigger than (x,y) area.

maxSize

Setting a maximum size will only return faces that it finds smaller than (x,y) area.

minNeighbors

Each feature is a rectangle of pixels. Neighbors are any features that have similarities. If you increase this number, it will detect fewer faces because the conditions for meeting the requirements of a face require more similar features.

scaleFactor

Images are ohen reduced in size to make training easier. This is a computationally heavy process, so the default is reducing the image by 5% at each scale.

Here is the complete function with all the default parameters:

vision.find_face(image, scale_factor = 1.05, min_neighbors=8, min_size= (40,40))

Start changing the numbers slowly and see how this affects the detection algorithm. Find some objects that might look like a face. If you change the parameters, can the computer tell the difference between a real face and something else?

Bonus: Write the code in a for loop to show detection as a video!