Python 3 利用 Dlib 实现摄像头实时人脸识别

0. 引言

利用 Python 开发，借助 Dlib 库捕获摄像头中的人脸，提取人脸特征，通过计算特征值之间的欧氏距离，来和预存的人脸特征进行对比，判断是否匹配，达到人脸识别的目的；

可以从摄像头中抠取人脸图片存储到本地，然后提取构建预设人脸特征；

根据抠取的 / 已有的同一个人多张人脸图片提取 128D 特征值，然后计算该人的 128D 特征均值；

然后和摄像头中实时获取到的人脸提取出的特征值，计算欧氏距离，判定是否为同一张人脸；　　

Python + OpenCV + Dlib ; 

识别模型：基于 Dlib 的 ResNet 预训练模型（dlib_face_recognition_resnet_model_v1.dat）

识别算法：ResNet 神经网络（This model is a ResNet network with 29 conv layers. It's essentially a version of the ResNet-34 network from the paper Deep Residual Learning for Image Recognition by He, Zhang, Ren, and Sun with a few layers removed and the number of filters per layer reduced by half）

1. 人脸检测

faces = detector(img_gray, 0) -> <class 'dlib.dlib.rectangles'> -> 

2. 计算特征点

shape = predictor(img_rd, faces[i]) -> <class 'dlib.dlib.full_object_detection'> -> 

3. 特征描述子

facerec.compute_face_descriptor(img_rd, shape) -> <class 'dlib.dlib.vector'>

博客中代码以 GitHub 为准，博客中可能没有及时更新；

　　# Blog : 　　 http://www.cnblogs.com/AdaminXie
　　# GitHub : 　 https://github.com/coneypo/Dlib_face_recognition_from_camera

Features :

• 支持人脸数据采集，自行建立人脸数据库 / Support face register
• 调用摄像头实时人脸检测和识别 / Using camera to real-time detect and recognize faces
• 支持多张人脸 / Support multi-faces

人脸识别 / Face Recognition 的说明：

Wikipedia 上关于人脸识别系统 / Face Recognition System 的描述：they work by comparing selected facial features from given image with faces within a database.

本项目中就是比较 预设的人脸的特征 和 摄像头实时获取到的人脸的特征 ；

核心就是 提取 128D 人脸特征，然后计算 摄像头人脸特征 和 预设的特征脸的欧式距离，进行比对；

 

效果如下：

　　 

图 1 摄像头多个人脸时识别效果 

 

1. 总体流程

先说下 人脸检测 ( Face detection ) 和 人脸识别 ( Face Recognition ) ，前者是达到检测出场景中人脸的目的就可以了，而后者不仅需要检测出人脸，还要和已有人脸数据进行比对，识别出是否在数据库中，或者进行身份标注之类处理，人脸检测和人脸识别两者有时候可能会被理解混淆；

我的之前一些项目都是用 Dlib 做人脸检测这块，这个项目想要实现的功能是人脸识别功能，借助的是 Dlib 官网中 face_recognition.py 这个例程 （ Link：http://dlib.net/face_recognition.py.html ）；

我们直接利用“dlib_face_recognition_resnet_model_v1.dat” 这个 pre-trained model，提取人脸图像的 128D 特征，然后比对不同人脸图片的 128D 特征的欧式距离，设定一个 Threshold / 阈值 来判断是否为同一张脸；

# face recognition model, the object maps human faces into 128D vectors
facerec = dlib.face_recognition_model_v1("dlib_face_recognition_resnet_model_v1.dat")

shape = predictor(img, dets[0])
face_descriptor = facerec.compute_face_descriptor(img, shape)

 

　　 

 

图 2 总体设计流程

 

2.源码介绍

主要有

• get_faces_from_camera.py 
  
• features_extraction_to_csv.py
• face_reco_from_camera.py

这三个 Python 文件，接下来会分别介绍实现功能；

 

2.1 get_faces_from_camera.py / 人脸注册录入

人脸识别需要将 提取到的图像数据 和 已有图像数据 进行比对分析，所以这部分代码实现的功能就是 人脸录入；

程序会生成一个窗口，显示调用的摄像头实时获取的图像；

（关于摄像头的调用方式可以参考这里： Python 3 利用 Dlib 19.7 实现摄像头人脸检测特征点标定）；

　　

然后根据键盘输入进行人脸捕获：

• “N” 新录入人脸，新建文件夹 person_X/  用来存储某人的人脸图像
•   "S" 开始捕获人脸，将捕获到的人脸放到 person_X/ 路径下
• “Q” 退出窗口

　　

摄像头的调用是利用 opencv 库的 cv2.VideoCapture(0), 此处参数为 0 代表调用的是笔记本的默认摄像头，你也可以让它调用传入已有视频文件；

可以参考 https://github.com/coneypo/Dlib_face_recognition_from_camera/blob/master/how_to_use_camera.py 如何通过 OpenCV 调用摄像头； 

　

图 3  get_face_from_camera.py 的界面

 　　

“N”+“S”之后捕获到的一组人脸示例；

图 4 捕获到的一组人脸

 

get_faces_from_camera.py 源码:

# 进行人脸录入 / face register
# 录入多张人脸 / support multi-faces

# Author:   coneypo
# Blog:     http://www.cnblogs.com/AdaminXie
# GitHub:   https://github.com/coneypo/Dlib_face_recognition_from_camera
# Mail:     coneypo@foxmail.com

# Created at 2018-05-11
# Updated at 2020-04-02

import dlib         # 人脸处理的库 Dlib
import numpy as np  # 数据处理的库 Numpy
import cv2          # 图像处理的库 OpenCv
import os           # 读写文件
import shutil       # 读写文件

# Dlib 正向人脸检测器 / frontal face detector
detector = dlib.get_frontal_face_detector()

# OpenCv 调用摄像头 / Use camera
cap = cv2.VideoCapture(0)

# 人脸截图的计数器 / The counter for screen shoot
cnt_ss = 0

# 存储人脸的文件夹 / The folder to save face images
current_face_dir = ""

# 保存 faces images 的路径 / The directory to save images of faces
path_photos_from_camera = "data/data_faces_from_camera/"


# 1. 新建保存人脸图像文件和数据CSV文件夹
# 1. Mkdir for saving photos and csv
def pre_work_mkdir():

    # 新建文件夹 / make folders to save faces images and csv
    if os.path.isdir(path_photos_from_camera):
        pass
    else:
        os.mkdir(path_photos_from_camera)


pre_work_mkdir()


##### optional/可选, 默认关闭 #####
# 2. 删除之前存的人脸数据文件夹
# 2. Delete the old data of faces
def pre_work_del_old_face_folders():
    # 删除之前存的人脸数据文件夹
    # 删除 "/data_faces_from_camera/person_x/"...
    folders_rd = os.listdir(path_photos_from_camera)
    for i in range(len(folders_rd)):
        shutil.rmtree(path_photos_from_camera+folders_rd[i])

    if os.path.isfile("data/features_all.csv"):
        os.remove("data/features_all.csv")

# 这里在每次程序录入之前, 删掉之前存的人脸数据
# 如果这里打开，每次进行人脸录入的时候都会删掉之前的人脸图像文件夹 person_1/,person_2/,person_3/...
# If enable this function, it will delete all the old data in dir person_1/,person_2/,/person_3/...
# pre_work_del_old_face_folders()
##################################


# 3. Check people order: person_cnt
# 如果有之前录入的人脸 / If the old folders exists
# 在之前 person_x 的序号按照 person_x+1 开始录入 / Start from person_x+1
if os.listdir("data/data_faces_from_camera/"):
    # 获取已录入的最后一个人脸序号 / Get the num of latest person
    person_list = os.listdir("data/data_faces_from_camera/")
    person_num_list = []
    for person in person_list:
        person_num_list.append(int(person.split('_')[-1]))
    person_cnt = max(person_num_list)

# 如果第一次存储或者没有之前录入的人脸, 按照 person_1 开始录入
# Start from person_1
else:
    person_cnt = 0

# 之后用来控制是否保存图像的 flag / The flag to control if save
save_flag = 1

# 之后用来检查是否先按 'n' 再按 's' / The flag to check if press 'n' before 's'
press_n_flag = 0

while cap.isOpened():
    flag, img_rd = cap.read()
    # print(img_rd.shape)
    # It should be 480 height * 640 width in Windows and Ubuntu by default
    # Maybe 1280x720 in macOS

    kk = cv2.waitKey(1)

    # 人脸 / Faces
    faces = detector(img_rd, 0)

    # 待会要写的字体 / Font to write
    font = cv2.FONT_ITALIC

    # 4. 按下 'n' 新建存储人脸的文件夹 / press 'n' to create the folders for saving faces
    if kk == ord('n'):
        person_cnt += 1
        current_face_dir = path_photos_from_camera + "person_" + str(person_cnt)
        os.makedirs(current_face_dir)
        print('
')
        print("新建的人脸文件夹 / Create folders: ", current_face_dir)

        cnt_ss = 0              # 将人脸计数器清零 / clear the cnt of faces
        press_n_flag = 1        # 已经按下 'n' / have pressed 'n'

    # 检测到人脸 / Face detected
    if len(faces) != 0:
        # 矩形框 / Show the rectangle box of face
        for k, d in enumerate(faces):
            # 计算矩形大小
            # Compute the width and height of the box
            # (x,y), (宽度width, 高度height)
            pos_start = tuple([d.left(), d.top()])
            pos_end = tuple([d.right(), d.bottom()])

            # 计算矩形框大小 / compute the size of rectangle box
            height = (d.bottom() - d.top())
            width = (d.right() - d.left())

            hh = int(height/2)
            ww = int(width/2)

            # 设置颜色 / the color of rectangle of faces detected
            color_rectangle = (255, 255, 255)

            # 判断人脸矩形框是否超出 480x640
            if (d.right()+ww) > 640 or (d.bottom()+hh > 480) or (d.left()-ww < 0) or (d.top()-hh < 0):
                cv2.putText(img_rd, "OUT OF RANGE", (20, 300), font, 0.8, (0, 0, 255), 1, cv2.LINE_AA)
                color_rectangle = (0, 0, 255)
                save_flag = 0
                if kk == ord('s'):
                    print("请调整位置 / Please adjust your position")
            else:
                color_rectangle = (255, 255, 255)
                save_flag = 1

            cv2.rectangle(img_rd,
                          tuple([d.left() - ww, d.top() - hh]),
                          tuple([d.right() + ww, d.bottom() + hh]),
                          color_rectangle, 2)

            # 根据人脸大小生成空的图像 / Create blank image according to the shape of face detected
            img_blank = np.zeros((int(height*2), width*2, 3), np.uint8)

            if save_flag:
                # 5. 按下 's' 保存摄像头中的人脸到本地 / Press 's' to save faces into local images
                if kk == ord('s'):
                    # 检查有没有先按'n'新建文件夹 / check if you have pressed 'n'
                    if press_n_flag:
                        cnt_ss += 1
                        for ii in range(height*2):
                            for jj in range(width*2):
                                img_blank[ii][jj] = img_rd[d.top()-hh + ii][d.left()-ww + jj]
                        cv2.imwrite(current_face_dir + "/img_face_" + str(cnt_ss) + ".jpg", img_blank)
                        print("写入本地 / Save into：", str(current_face_dir) + "/img_face_" + str(cnt_ss) + ".jpg")
                    else:
                        print("请在按 'S' 之前先按 'N' 来建文件夹 / Please press 'N' before 'S'")

    # 显示人脸数 / Show the numbers of faces detected
    cv2.putText(img_rd, "Faces: " + str(len(faces)), (20, 100), font, 0.8, (0, 255, 0), 1, cv2.LINE_AA)

    # 添加说明 / Add some statements
    cv2.putText(img_rd, "Face Register", (20, 40), font, 1, (0, 0, 0), 1, cv2.LINE_AA)
    cv2.putText(img_rd, "N: Create face folder", (20, 350), font, 0.8, (0, 0, 0), 1, cv2.LINE_AA)
    cv2.putText(img_rd, "S: Save current face", (20, 400), font, 0.8, (0, 0, 0), 1, cv2.LINE_AA)
    cv2.putText(img_rd, "Q: Quit", (20, 450), font, 0.8, (0, 0, 0), 1, cv2.LINE_AA)

    # 6. 按下 'q' 键退出 / Press 'q' to exit
    if kk == ord('q'):
        break

    # 如果需要摄像头窗口大小可调 / Uncomment this line if you want the camera window is resizeable
    # cv2.namedWindow("camera", 0)

    cv2.imshow("camera", img_rd)

# 释放摄像头 / Release camera and destroy all windows
cap.release()
cv2.destroyAllWindows()

考虑到有可能需要保存的矩形框超出摄像头范围，对于这种异常，如果矩形框超出范围，矩形框会从白变红，然后提示 "OUT OF RANGE";

 

图 5 人脸录入异常（Out of range）处理

get_face_from_camera.py 的输出 log

新建的人脸文件夹 / Create folders:  data/data_faces_from_camera/person_1
写入本地 / Save into： data/data_faces_from_camera/person_1/img_face_1.jpg
写入本地 / Save into： data/data_faces_from_camera/person_1/img_face_2.jpg
写入本地 / Save into： data/data_faces_from_camera/person_1/img_face_3.jpg
写入本地 / Save into： data/data_faces_from_camera/person_1/img_face_4.jpg


新建的人脸文件夹 / Create folders:  data/data_faces_from_camera/person_2
写入本地 / Save into： data/data_faces_from_camera/person_2/img_face_1.jpg
写入本地 / Save into： data/data_faces_from_camera/person_2/img_face_2.jpg


新建的人脸文件夹 / Create folders:  data/data_faces_from_camera/person_3
写入本地 / Save into： data/data_faces_from_camera/person_3/img_face_1.jpg
写入本地 / Save into： data/data_faces_from_camera/person_3/img_face_2.jpg

2.2 features_extraction_to_csv.py / 将图像文件中人脸数据提取出来存入 CSV

这部分代码实现的功能是将之前捕获到的人脸图像文件，提取出 128D 特征，然后计算出某人人脸数据的特征均值存入 CSV 中，方便之后识别时候进行比对；

利用 numpy.mean() 计算特征均值，生成一个存储所有录入人脸数据 database 的 "features_all.csv"；

features_extraction_to_csv.py 源码:

# 从人脸图像文件中提取人脸特征存入 CSV
# Features extraction from images and save into features_all.csv

# Author:   coneypo
# Blog:     http://www.cnblogs.com/AdaminXie
# GitHub:   https://github.com/coneypo/Dlib_face_recognition_from_camera
# Mail:     coneypo@foxmail.com

# Created at 2018-05-11
# Updated at 2020-04-02

import cv2
import os
import dlib
from skimage import io
import csv
import numpy as np

# 要读取人脸图像文件的路径
path_images_from_camera = "data/data_faces_from_camera/"

# Dlib 正向人脸检测器
detector = dlib.get_frontal_face_detector()

# Dlib 人脸预测器
predictor = dlib.shape_predictor("data/data_dlib/shape_predictor_68_face_landmarks.dat")

# Dlib 人脸识别模型
# Face recognition model, the object maps human faces into 128D vectors
face_rec = dlib.face_recognition_model_v1("data/data_dlib/dlib_face_recognition_resnet_model_v1.dat")


# 返回单张图像的 128D 特征
def return_128d_features(path_img):
    img_rd = io.imread(path_img)
    faces = detector(img_rd, 1)

    print("%-40s %-20s" % ("检测到人脸的图像 / image with faces detected:", path_img), '
')

    # 因为有可能截下来的人脸再去检测，检测不出来人脸了
    # 所以要确保是 检测到人脸的人脸图像 拿去算特征
    if len(faces) != 0:
        shape = predictor(img_rd, faces[0])
        face_descriptor = face_rec.compute_face_descriptor(img_rd, shape)
    else:
        face_descriptor = 0
        print("no face")

    return face_descriptor


# 将文件夹中照片特征提取出来, 写入 CSV
def return_features_mean_personX(path_faces_personX):
    features_list_personX = []
    photos_list = os.listdir(path_faces_personX)
    if photos_list:
        for i in range(len(photos_list)):
            # 调用return_128d_features()得到128d特征
            print("%-40s %-20s" % ("正在读的人脸图像 / image to read:", path_faces_personX + "/" + photos_list[i]))
            features_128d = return_128d_features(path_faces_personX + "/" + photos_list[i])
            #  print(features_128d)
            # 遇到没有检测出人脸的图片跳过
            if features_128d == 0:
                i += 1
            else:
                features_list_personX.append(features_128d)
    else:
        print("文件夹内图像文件为空 / Warning: No images in " + path_faces_personX + '/', '
')

    # 计算 128D 特征的均值
    # personX 的 N 张图像 x 128D -> 1 x 128D
    if features_list_personX:
        features_mean_personX = np.array(features_list_personX).mean(axis=0)
    else:
        features_mean_personX = '0'

    return features_mean_personX


# 获取已录入的最后一个人脸序号 / get the num of latest person
person_list = os.listdir("data/data_faces_from_camera/")
person_num_list = []
for person in person_list:
    person_num_list.append(int(person.split('_')[-1]))
person_cnt = max(person_num_list)

with open("data/features_all.csv", "w", newline="") as csvfile:
    writer = csv.writer(csvfile)
    for person in range(person_cnt):
        # Get the mean/average features of face/personX, it will be a list with a length of 128D
        print(path_images_from_camera + "person_"+str(person+1))
        features_mean_personX = return_features_mean_personX(path_images_from_camera + "person_"+str(person+1))
        writer.writerow(features_mean_personX)
        print("特征均值 / The mean of features:", list(features_mean_personX))
        print('
')
    print("所有录入人脸数据存入 / Save all the features of faces registered into: data/features_all.csv")

我们可以看下对于某张图片，face_descriptor 这个 128D vectors 的输出结果：

绿色框内是我们的返回 128D 特征的函数；

在红色框内调用该函数来计算 img_face_13.jpg；

可以看到黄色框中的输出为 128D 的向量；

图 6 返回单张图像的 128D 特征的计算结果

 

之后就需要人脸图像进行批量化操作，提取出 128D 的特征，然后计算特征均值，存入 features_all.csv；

features_all.csv 是一个 n 行 128 列的 CSV， n 是录入的人脸数，128 列是某人的 128D 特征；

这存储的就是 录入的人脸数据，之后 摄像头捕获的人脸 将要拿过来和 这些特征值 进行比对，如果欧式距离比较近的话，就可以认为是同一张人脸；

 

 get_features_into_CSV.py 的输出 log：

##### person_1 #####
data/data_csvs_from_camera/person_1.csv
正在读的人脸图像 / image to read:                data/data_faces_from_camera/person_1/img_face_1.jpg
检测到人脸的图像 / image with faces detected:    data/data_faces_from_camera/person_1/img_face_1.jpg 

正在读的人脸图像 / image to read:                data/data_faces_from_camera/person_1/img_face_2.jpg
检测到人脸的图像 / image with faces detected:    data/data_faces_from_camera/person_1/img_face_2.jpg 

正在读的人脸图像 / image to read:                data/data_faces_from_camera/person_1/img_face_3.jpg
检测到人脸的图像 / image with faces detected:    data/data_faces_from_camera/person_1/img_face_3.jpg 

正在读的人脸图像 / image to read:                data/data_faces_from_camera/person_1/img_face_4.jpg
检测到人脸的图像 / image with faces detected:    data/data_faces_from_camera/person_1/img_face_4.jpg 

##### person_2 #####
data/data_csvs_from_camera/person_2.csv
正在读的人脸图像 / image to read:                data/data_faces_from_camera/person_2/img_face_1.jpg
检测到人脸的图像 / image with faces detected:    data/data_faces_from_camera/person_2/img_face_1.jpg 

正在读的人脸图像 / image to read:                data/data_faces_from_camera/person_2/img_face_2.jpg
检测到人脸的图像 / image with faces detected:    data/data_faces_from_camera/person_2/img_face_2.jpg 

##### person_3 #####
data/data_csvs_from_camera/person_3.csv
正在读的人脸图像 / image to read:                data/data_faces_from_camera/person_3/img_face_1.jpg
检测到人脸的图像 / image with faces detected:    data/data_faces_from_camera/person_3/img_face_1.jpg 

正在读的人脸图像 / image to read:                data/data_faces_from_camera/person_3/img_face_2.jpg
检测到人脸的图像 / image with faces detected:    data/data_faces_from_camera/person_3/img_face_2.jpg 


...

2.3 face_reco_from_camera.py / 实时人脸识别对比分析

这部分源码实现的功能：调用摄像头，捕获摄像头中的人脸，然后如果检测到人脸，将 摄像头中的人脸提取出 128D 的特征，然后和 之前录入人脸的 128D 特征 进行计算欧式距离，如果比较小，可以判定为一个人，否则不是一个人；

伪代码如下：

# 人脸检测器/预测器/识别模型
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor('data/data_dlib/shape_predictor_68_face_landmarks.dat')
facerec = dlib.face_recognition_model_v1("data/data_dlib/dlib_face_recognition_resnet_model_v1.dat")

faces = detector(img_gray, 0)

# 如果检测到人脸
if len(faces) != 0:
    # 遍历所有检测到的人脸
    for i in range(len(faces)):
        # 进行人脸比对
        shape = predictor(img_rd, faces[i])
        facerec.compute_face_descriptor(img_rd, shape)

 关于用到的 dlib 检测器，预测器，识别器:

1. dlib.get_frontal_face_detector

Link:

http://dlib.net/python/index.html#dlib.get_frontal_face_detector

简介 / intro:

返回默认的人脸检测器，为下面的 fhog_object_detectorm / Returns the default face detector

 

2. class dlib.fhog_object_detector

Link:

http://dlib.net/python/index.html#dlib.fhog_object_detector

简介 / intro:

基于滑动窗的HOG进行目标检测;

This object represents a sliding window histogram-of-oriented-gradients based object detector.

参数 / parameters:

__call__(self: dlib.fhog_object_detector, image: array, upsample_num_times: int=0L) → dlib.rectangles

 

3. class dlib.shape_predictor

Link:

http://dlib.net/python/index.html#dlib.shape_predictor

简介 / intro:

人脸图像作为输入, 输出面部特征点;

This object is a tool that takes in an image region containing some object and outputs a set of point locations that define the pose of the object. 

The classic example of this is human face pose prediction, where you take an image of a human face as input and are expected to identify

the locations of important facial landmarks such as the corners of the mouth and eyes, tip of the nose, and so forth.

参数 / parameters:

__call__(self: dlib.shape_predictor, image: array, box: dlib.rectangle) → dlib.full_object_detection

输入: dlib.rectangle 输出: dlib.full_object_detection

 

4. class dlib.face_recognition_model_v1

Link:

http://dlib.net/python/index.html#dlib.face_recognition_model_v1

简介 / intro:

将人脸转换为128D特征向量, 这样的话相似人脸会比较相近, 不相像的会比较远;

This object maps human faces into 128D vectors where pictures of the same person are mapped near to each other and pictures of different people are mapped far apart.

The constructor loads the face recognition model from a file. The model file is available here: http://dlib.net/files/dlib_face_recognition_resnet_model_v1.dat.bz2

参数 / parameters:

compute_face_descriptor(self: dlib.face_recognition_model_v1, img: numpy.ndarray[(rows,cols,3),uint8], face: dlib.full_object_detection, num_jitters: int=0L, padding: float=0.25) -> dlib.vector

 

通过 print(type()) 可以更清楚的看到 dlib 对象的传递:

# 人脸检测器/预测器/识别模型
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor('data/data_dlib/shape_predictor_68_face_landmarks.dat')
facerec = dlib.face_recognition_model_v1("data/data_dlib/dlib_face_recognition_resnet_model_v1.dat")

faces = detector(img_gray, 0)

# 如果检测到人脸
if len(faces) != 0:
    print(type(faces)                                                # <class 'dlib.dlib.rectangles'>
    # 遍历所有检测到的人脸
    for i in range(len(faces)):
        # 进行人脸比对
        shape = predictor(img_rd, faces[i])
        print(type(shape))                                            # <class 'dlib.dlib.full_object_detection'>
        facerec.compute_face_descriptor(img_rd, shape)
        print(type(facerec.compute_face_descriptor(img_rd, shape))    # <class 'dlib.dlib.vector'>

这样一个对象传递过程：

faces = detector(img_gray, 0) -> <class 'dlib.dlib.rectangles'> -> 
shape = predictor(img_rd, faces[i]) -> <class 'dlib.dlib.full_object_detection'> -> 
facerec.compute_face_descriptor(img_rd, shape) -> <class 'dlib.dlib.vector'>

欧氏距离对比的阈值设定，是在 return_euclidean_distance 函数的 dist  变量；

我这里程序里面指定的 欧氏距离判断阈值是 0.4，具体阈值可以根据实际情况或者测得结果进行修改；

　　

这边做了一个，让人名跟随显示在头像下方，如果想要在人脸矩形框下方显示人名，首先需要知道 Dlib 生成的矩形框的尺寸怎么读取；

Dlib 返回的 dets 变量是一系列人脸的数据，此处对单张人脸处理，所以取 dets[0] 的参数；

可以通过 dets[0].top(), dets[0].bottom(), dets[0].left() 和 dets[0].right() 来确定要显示的人名的坐标；

图 7 dets[0].top() 等参数说明 

　　

得到矩形框的坐标，就可以获取人名的相对位置；

这是我这边取的坐标：

 pos_text_1 = tuple([dets[0].left(), int(dets[0].bottom()+(dets[0].bottom()-dets[0].top())/4)])

 

　　

 

图 8 face_reco_from_camera.py 生成的人脸识别窗口界面

   如果想定制输出显示的名字而不是“Person_1”,"Person_2"...；

图 9 定制显示名字

face_reco_from_camera.py 源码：

# 摄像头实时人脸识别
# Real-time face recognition

# Author:   coneypo
# Blog:     http://www.cnblogs.com/AdaminXie
# GitHub:   https://github.com/coneypo/Dlib_face_recognition_from_camera

# Created at 2018-05-11
# Updated at 2020-04-02

import dlib          # 人脸处理的库 Dlib
import numpy as np   # 数据处理的库 numpy
import cv2           # 图像处理的库 OpenCv
import pandas as pd  # 数据处理的库 Pandas
import os

# 人脸识别模型，提取128D的特征矢量
# face recognition model, the object maps human faces into 128D vectors
# Refer this tutorial: http://dlib.net/python/index.html#dlib.face_recognition_model_v1
facerec = dlib.face_recognition_model_v1("data/data_dlib/dlib_face_recognition_resnet_model_v1.dat")


# 计算两个128D向量间的欧式距离
# Compute the e-distance between two 128D features
def return_euclidean_distance(feature_1, feature_2):
    feature_1 = np.array(feature_1)
    feature_2 = np.array(feature_2)
    dist = np.sqrt(np.sum(np.square(feature_1 - feature_2)))
    return dist


# 1. Check 存放所有人脸特征的 csv
if os.path.exists("data/features_all.csv"):
    path_features_known_csv = "data/features_all.csv"
    csv_rd = pd.read_csv(path_features_known_csv, header=None)

    # 用来存放所有录入人脸特征的数组
    # The array to save the features of faces in the database
    features_known_arr = []

    # 2. 读取已知人脸数据
    # Print known faces
    for i in range(csv_rd.shape[0]):
        features_someone_arr = []
        for j in range(0, len(csv_rd.iloc[i])):
            features_someone_arr.append(csv_rd.iloc[i][j])
        features_known_arr.append(features_someone_arr)
    print("Faces in Database：", len(features_known_arr))

    # Dlib 检测器和预测器
    # The detector and predictor will be used
    detector = dlib.get_frontal_face_detector()
    predictor = dlib.shape_predictor('data/data_dlib/shape_predictor_68_face_landmarks.dat')

    # 创建 cv2 摄像头对象
    cap = cv2.VideoCapture(0)

    # 3. When the camera is open
    while cap.isOpened():

        flag, img_rd = cap.read()
        faces = detector(img_rd, 0)

        # 待会要写的字体 font to write later
        font = cv2.FONT_ITALIC

        # 存储当前摄像头中捕获到的所有人脸的坐标/名字
        # The list to save the positions and names of current faces captured
        pos_namelist = []
        name_namelist = []

        kk = cv2.waitKey(1)

        # 按下 q 键退出
        # press 'q' to exit
        if kk == ord('q'):
            break
        else:
            # 检测到人脸 when face detected
            if len(faces) != 0:
                # 4. 获取当前捕获到的图像的所有人脸的特征，存储到 features_cap_arr
                # 4. Get the features captured and save into features_cap_arr
                features_cap_arr = []
                for i in range(len(faces)):
                    shape = predictor(img_rd, faces[i])
                    features_cap_arr.append(facerec.compute_face_descriptor(img_rd, shape))

                # 5. 遍历捕获到的图像中所有的人脸
                # 5. Traversal all the faces in the database
                for k in range(len(faces)):
                    print("##### camera person", k+1, "#####")
                    # 让人名跟随在矩形框的下方
                    # 确定人名的位置坐标
                    # 先默认所有人不认识，是 unknown
                    # Set the default names of faces with "unknown"
                    name_namelist.append("unknown")

                    # 每个捕获人脸的名字坐标 the positions of faces captured
                    pos_namelist.append(tuple([faces[k].left(), int(faces[k].bottom() + (faces[k].bottom() - faces[k].top())/4)]))

                    # 对于某张人脸，遍历所有存储的人脸特征
                    # For every faces detected, compare the faces in the database
                    e_distance_list = []
                    for i in range(len(features_known_arr)):
                        # 如果 person_X 数据不为空
                        if str(features_known_arr[i][0]) != '0.0':
                            print("with person", str(i + 1), "the e distance: ", end='')
                            e_distance_tmp = return_euclidean_distance(features_cap_arr[k], features_known_arr[i])
                            print(e_distance_tmp)
                            e_distance_list.append(e_distance_tmp)
                        else:
                            # 空数据 person_X
                            e_distance_list.append(999999999)
                    # Find the one with minimum e distance
                    similar_person_num = e_distance_list.index(min(e_distance_list))
                    print("Minimum e distance with person", int(similar_person_num)+1)

                    if min(e_distance_list) < 0.4:
                        ####### 在这里修改 person_1, person_2 ... 的名字 ########
                        # 可以在这里改称 Jack, Tom and others
                        # Here you can modify the names shown on the camera
                        name_namelist[k] = "Person "+str(int(similar_person_num)+1)
                        print("May be person "+str(int(similar_person_num)+1))
                    else:
                        print("Unknown person")

                    # 矩形框
                    # draw rectangle
                    for kk, d in enumerate(faces):
                        # 绘制矩形框
                        cv2.rectangle(img_rd, tuple([d.left(), d.top()]), tuple([d.right(), d.bottom()]), (0, 255, 255), 2)
                    print('
')

                # 6. 在人脸框下面写人脸名字
                # 6. write names under rectangle
                for i in range(len(faces)):
                    cv2.putText(img_rd, name_namelist[i], pos_namelist[i], font, 0.8, (0, 255, 255), 1, cv2.LINE_AA)

        print("Faces in camera now:", name_namelist, "
")

        cv2.putText(img_rd, "Press 'q': Quit", (20, 450), font, 0.8, (84, 255, 159), 1, cv2.LINE_AA)
        cv2.putText(img_rd, "Face Recognition", (20, 40), font, 1, (0, 0, 0), 1, cv2.LINE_AA)
        cv2.putText(img_rd, "Faces: " + str(len(faces)), (20, 100), font, 1, (0, 0, 255), 1, cv2.LINE_AA)

        cv2.imshow("camera", img_rd)

    cap.release()
    cv2.destroyAllWindows()

else:
    print('##### Warning #####', '
')
    print("'features_all.py' not found!")
    print("Please run 'get_faces_from_camera.py' and 'features_extraction_to_csv.py' before 'face_reco_from_camera.py'", '
')
    print('##### Warning #####')

face_reco_from_camera.py 输出 log：

##### camera person 1 #####
with person 1 the e distance: 0.21153867687451736
with person 2 the e distance: 0.20646924127167549
with person 4 the e distance: 0.19824469336759548
Minimum e distance with person 4
May be person 4


##### camera person 2 #####
with person 1 the e distance: 0.7403020289640347
with person 2 the e distance: 0.7375521667680703
with person 4 the e distance: 0.7077921161820342
Minimum e distance with person 4
Unknown person


##### camera person 3 #####
with person 1 the e distance: 0.6975665799095466
with person 2 the e distance: 0.7070867672498581
with person 4 the e distance: 0.6727276688350984
Minimum e distance with person 4
Unknown person


Faces in camera now: ['Person 4', 'unknown', 'unknown'] 

如果对单个人脸，进行实时对比输出：

图 10 实时输出的欧氏距离结果

 

　　通过实时的输出结果，看的比较明显；

　　输出绿色部分：当是我自己时，计算出来的欧式距离基本都在 0.2 左右；

　　输出红色部分：而换一张图片上去比如特朗普，明显看到欧式距离计算结果 达到了 0.8，此时就可以判定，后来这张人脸不是一张人脸；

　　所以之前提到的欧式距离计算对比的阈值可以由此设定，本项目中取的是 dist=0.4；

　　 dist 的确切取值自己权衡，http://dlib.net/face_recognition.py.html 的说明：

#   When using a distance threshold of 0.6, the dlib model obtains an accuracy
#   of 99.38% on the standard LFW face recognition benchmark, which is
#   comparable to other state-of-the-art methods for face recognition as of
#   February 2017. This accuracy means that, when presented with a pair of face
#   images, the tool will correctly identify if the pair belongs to the same
#   person or is from different people 99.38% of the time.

3. 总结

核心就是 提取人脸特征，然后计算欧式距离和预设的特征脸进行比对；

不过这个实时获取摄像头人脸进行比对，要实时的进行计算摄像头脸的特征值，然后还要计算欧氏距离，所以计算量比较大，可能摄像头视频流会出现卡顿；

此项目仅个人学习爱好研究，开源供大家一起学习；

 

# 请尊重他人劳动成果，转载或者使用源码请注明出处：http://www.cnblogs.com/AdaminXie

# 代码已上传到了我的 GitHub，如果对您有帮助欢迎 Star 支持我下：https://github.com/coneypo/Dlib_face_recognition_from_camera

# 如有问题请留言或者联系邮箱: coneypo@foxmail.com

# Last update: 6 Apr