\

Now face recognition technology has been very widely used, payment fields, authentication, beauty cameras have its applications. Those of you who have an iPhone should be familiar with the following features

Facial recognition technology is also behind a “people” feature in iPhone photos that identifies and classifies faces in photos. \

This article describes how to implement face detection in Python. Face detection is the basis of face recognition. The purpose of face detection is to identify the face in the photo and locate the facial feature points, face recognition is to tell you who the person is on the basis of face detection.

Well, that’s all for the introduction. Next, start preparing our environment.

The preparatory work

Face detection in this article is based on dlib, which relies on Boost and cmake, so you need to install these packages first, using Ubuntu as an example:

  

$ sudo apt-get install build-essential cmake

$ sudo apt-get install libgtk-3-dev

$ sudo apt-get install libboost-all-dev
Copy the code

We also use Numpy and OpencV in our program, so we need to install these libraries as well:

  

$ pip install numpy

$ pip install scipy

$ pip install opencv-python

$ pip install dlib
Copy the code

Face detection is based on pre-trained model data, which can be lowered from here to model data

  

http://dlib.net/files/shape_predictor_68_face_landmarks.dat.bz2
Copy the code

Download to the local path after decompression, write down the decompression file path, the program will be used.

Dlib face feature points

The model data downloaded above is used to estimate the coordinate positions of 68 feature points (x, y) on human face. The positions of these 68 coordinate points are shown in the figure below:

Our program will consist of two steps: \

The first step is to examine the area of the face in the photo

The second step is to further examine the organs (eyes, nose, mouth, chin, eyebrows) in the detected face area.

Face detection code

Let’s start by defining some utility functions:

  

def rect_to_bb(rect):

    x = rect.left()

    y = rect.top()

    w = rect.right() - x 

    h = rect.bottom() - y 

    return (x, y, w, h)
Copy the code

The rect in this function is the output of the dlib face region detection. Here the RECT is converted to a sequence containing the boundary information of the rectangular region.

  

def shape_to_np(shape, dtype="int"):

    coords = np.zeros((68, 2), dtype=dtype)

    for i in range(0, 68):

            coords[i] = (shape.part(i).x, shape.part(i).y)

    return coords
Copy the code

The shape in this function is the output of the dlib face detection. A shape contains 68 points of the face mentioned above. This function converts shape to Numpy Array for subsequent processing.

  

def resize(image, width=1200):

    r = width * 1.0 / image.shape[1]

    dim = (width, int(image.shape[0] * r)) 

    resized = cv2.resize(image, dim, interpolation=cv2.INTER_AREA)

    return resized
Copy the code

The image in this function is the image we want to detect. At the end of the face detection program, we will display the detection result picture for verification. Resize is made here to avoid the picture being too large to exceed the screen scope.

Next, start our main program

  

import sys 

import numpy as np

import dlib

import cv2 

if len(sys.argv) < 2:

    print "Usage: %s <image file>" % sys.argv[0]

    sys.exit(1)

image_file = sys.argv[1]

detector = dlib.get_frontal_face_detector()

predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat")
Copy the code

We read the image of the face to be detected from sys.argv[1], and then initialize the Detector for face region detection and Predictor for face feature detection. The parameters in shape_Predictor are the paths to the files we extracted earlier.

  

image = cv2.imread(image_file)

image = resize(image, width=1200)

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

rects = detector(gray, 1)
Copy the code

Before detecting the feature area, we need to detect the face area first. This code calls OpencV to load the image, resize it to a proper size, turn it into a grayscale image, and finally detect the face region with detector. Because a photo can contain multiple faces, what you get here is an array rects that contains information about multiple faces.

for (i, rect) in enumerate(rects): shape = predictor(gray, rect) shape = shape_to_np(shape) (x, y, w, h) = rect_to_bb(rect) cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2) cv2.putText(image, "Face #{}".format(i + 1), (x - 10, y - 10), FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) for (x, y) in shape: cv2.circle(image, (x, y), 2, (0, 0, 255), -1) cv2.imshow("Output", image) cv2.waitKey(0)Copy the code

For each face detected, we further examined facial features (nose, eyes, eyebrows, etc.). For the face area, we marked it with a green box; For facial features, we mark them with red dots.

Finally, we display the photo with the detection identifier. WaitKey (0) means that you can exit the program by pressing any key.

That’s all for our program

test

Now comes the exciting moment, the moment to test our results.

Below is the original image

Below are the results of program identification

You can see that the face area is framed by green rectangles, and the features of the face (nose, eyes, etc.) are marked by red dots.

Isn’t that easy?

Appreciate the author

* * * *

In this paper, the author

Strong elder brother

Columnist for the Python Chinese Community. He worked at Morgan Stanley and eBay. Zhihu: Python and data analysis

Join the CodingGo programming community

**** Learn programming knowledge, harvest Internet insiders.