face_recognition_dlib_tensorflow_MySQL.py

import cv2
import os
import re
import sys
import dlib
import facenet
import time
import align.detect_face
import numpy as np
import pymysql
from datetime import datetime
from scipy import misc
from PIL import Image,ImageDraw,ImageFont
from multiprocessing import Process,Manager,Queue
import tensorflow as tf
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"


detector = dlib.get_frontal_face_detector()    #先使用dlib检测人脸，后再使用卷积神经网络识别人脸
model_path="/home/boss/Study/face_recognition_flask/20180402-114759/model.pb"
test_result_path="/home/boss/Study/face_recognition_flask/test_result_dlib"

success_list=[]   #保存已识别的人的名字
global csv_rd

# 以当天日期为表名创建一张用于记录识别成功的表
def save_success():
    db1 = pymysql.connect('127.0.0.1','root','123456','success_recognition',charset='utf8')
    cursor1 = db1.cursor()
    sql = """CREATE TABLE IF NOT EXISTS %s""" % (time.strftime('%Y_%m_%d', time.localtime(time.time())))
    sql += """ (name VARCHAR(50) NOT NULL UNIQUE,time DATETIME NOT NULL,PRIMARY KEY (name))ENGINE=InnoDB DEFAULT CHARSET=utf8MB4;"""
    try:
        cursor1.execute(sql)
    except:
        print("表%s已创建"%(time.strftime('%Y_%m_%d', time.localtime(time.time()))))
    db1.close()


def known_faces(feature_known_list,name_list):
    db = pymysql.connect('127.0.0.1','root','123456','person_embeddings_db',charset='utf8')
    cursor = db.cursor()
    sql = """SELECT * FROM person_average_embeddings;"""
    try:
        cursor.execute(sql)
        resutls = cursor.fetchall()
    except:
        print("获取人脸数据失败！")

    for i in range(len(resutls)):
        embeddings = list(resutls[i])
        name_list.append(embeddings.pop(0))
        feature_known_list.append(embeddings)

    db.close()
    return feature_known_list,name_list


def put_text(img_rd,text,position,fillcolor="#FF0000"):   #在摄像头上面打印信息
    img = cv2.cvtColor(img_rd, cv2.COLOR_BGR2RGB)
    img_PIL = Image.fromarray(img)
    font = ImageFont.truetype('NotoSansCJK-Black.ttc', 20, encoding="utf-8")
    draw = ImageDraw.Draw(img_PIL)
    draw.text(position, text, fillcolor, font)
    img = cv2.cvtColor(np.array(img_PIL),cv2.COLOR_RGB2BGR)
    return img


# 裁剪人脸
def crop_image(image,bounding_boxes,margin,image_size):

    faces_queue=Queue()  #faces_queue存放裁剪下来的人脸
    img_size = np.asarray(image.shape)[0:2]
    for i in range(bounding_boxes.shape[0]):
        bb=np.zeros(4,dtype=np.int32)
        bb[0]=np.maximum(bounding_boxes[i][0]-margin/2,0)
        bb[1]=np.maximum(bounding_boxes[i][1]-margin/2,0)
        bb[2]=np.minimum(bounding_boxes[i][2]+margin/2,img_size[1])
        bb[3]=np.minimum(bounding_boxes[i][3]+margin/2,img_size[0])
        cropped=image[bb[1]:bb[3],bb[0]:bb[2],:]
        aligned=misc.imresize(cropped,(image_size,image_size),interp='bilinear')
        prewhitened=facenet.prewhiten(aligned)
        faces_queue.put(prewhitened)
    return faces_queue


def return_512D_features(image,bounding_boxes):

    emb_list=[]   #保存每一帧画面中所有人脸的特征
    faces_queue=crop_image(image,bounding_boxes,44,160)  #先裁剪人脸
    g=tf.get_default_graph()
    with g.as_default():
        sess=tf.get_default_session()
        with sess.as_default() :
            images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0")
            embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
            phase_train_placeholder = tf.get_default_graph().get_tensor_by_name("phase_train:0")

            for i in range(faces_queue.qsize()):
                face=faces_queue.get()       #从faces_queue中取出已裁剪的人脸
                face=face.reshape(1,160,160,3)

                #计算人脸特征
                feed_dict={images_placeholder:face,phase_train_placeholder:False}
                emb=sess.run(embeddings,feed_dict=feed_dict)
                emb=list(np.squeeze(emb))
                emb_list.append(emb)
            return emb_list


# 计算两个人脸向量间的欧式距离
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(np.subtract(feature_1,feature_2))))
    #print("欧式距离为: ", dist)
    return dist


#人脸识别
def face_recognition(image,bounding_boxes,feature_known_list,pos_namelist,print_namelist,name_list,db1,cursor1):

    del pos_namelist[:] # 人脸名字的坐标，每次用的时候先清空
    del print_namelist [:] # 人脸名字，每次用的时候先清空

    min_eculidean_position_list=[] #打印在人脸旁边的最小欧式距离的坐标


    features_cap_list = return_512D_features(image,bounding_boxes)   #features_cap_list为帧画面中所有人的人脸特征信息

    current_time = str(datetime.now())
    save_path = os.path.join(test_result_path, current_time)
    # 遍历捕获到的图像中所有的人脸
    for k in range(len(features_cap_list)):
        # 让人名跟随在矩形框的下方
        # 确定人名的位置坐标
        # 先默认所有人不认识
        print_namelist.append("未能识别")

        # 每个捕获人脸名字的坐标
        pos_namelist.append(
        tuple([bounding_boxes[k][0], int(bounding_boxes[k][3] + (bounding_boxes[k][3] - bounding_boxes[k][1]) / 15)]))

        # 每个捕获人脸最小欧士距离的坐标
        min_eculidean_position_list.append(tuple([bounding_boxes[k][0], int(pos_namelist[k][1]+50)]))

        person_euclidean_list=list()
        # 对于第k张人脸，遍历所有存储的人脸特征
        for i in range(len(feature_known_list)):
            # print("和本地数据第", str(i + 1), "个人相比， ", end='')
            # 将捕捉到的人脸与存储库中的所有人脸数据进行比对
            euclidean_dist  = return_euclidean_distance(features_cap_list[k], feature_known_list[i])
            person_euclidean_list.append(euclidean_dist)
        index=person_euclidean_list.index(min(person_euclidean_list))
        if person_euclidean_list[index] <= 0.7:  # 即使找到一个最相似的脸，也要设定一个阀值（根据实际情况自行设定），只有低于这个阀值时才能认为是同一个人
            print(person_euclidean_list[index])
            print_namelist[k] = str(name_list[index])
            cv2.rectangle(image,(bounding_boxes[k][0],bounding_boxes[k][1]),(bounding_boxes[k][2],bounding_boxes[k][3]),(0,255,0),2)  #在图片上用矩形框人脸
            image=put_text(image,str(name_list[index]),pos_namelist[k])     #在图片上打印名字
            sql = """INSERT INTO success_recognition.%s (name,time) VALUES(\'%s\',\'%s\');""" % (time.strftime('%Y_%m_%d', time.localtime(time.time())), str(name_list[index]),time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())))
            try:
                cursor1.execute(sql)
                db1.commit()
            except:
                print("插入数据失败,可能数据已存在")

            # image = put_text(image, str(round(person_euclidean_list[index],2)), min_eculidean_position_list[k])   #在图片上打印欧士距离
        else:
            print(person_euclidean_list[index])
            cv2.rectangle(image, (bounding_boxes[k][0], bounding_boxes[k][1]),(bounding_boxes[k][2], bounding_boxes[k][3]), (0, 255, 255), 2)  #在图片上用矩形框人脸
            # image=put_text(image,str(round(person_euclidean_list[index],2)),min_eculidean_position_list[k])    #在图片上打印欧士距离
    # cv2.imwrite(save_path+".jpg",image)
    cv2.namedWindow("frame",cv2.WINDOW_NORMAL)
    cv2.resizeWindow("frame",1280,720)
    cv2.imshow("frame",image)
    cv2.waitKey(1)
    print("\n")
    print("屏幕中的人脸为:", print_namelist,"\n")


# 打开摄像头保存帧
def save_frame(images_que, pos_namelist, print_namelist,name_list, open_time):
    url = 'rtsp://admin:root123456@192.168.1.104:1554//Streaming/Channels/1'       #这里采用的是海康威视的ip摄像头
    cap = cv2.VideoCapture(0)
    if cap.isOpened():
        f = open("info.txt", 'a')       #创建一个info.txt用于保存摄像头是否开启成功
        f.write("True\n")               #成功的话就写一个True进去
        f.close()
    temp = 0
    '''
    pid1 = os.getpid()
    f = open("info.txt", 'a')
    f.write('p1:' + str(pid1) + "\n")
    f.close()
    '''
    while True:
        ret, frame = cap.read()

        if ret:
            # cv2.namedWindow('frame', cv2.WINDOW_NORMAL)
            # cv2.resizeWindow('frame', 1280, 720)
            # cv2.imshow('frame',frame)
            # cv2.waitKey(1)
            temp += 1
            if temp == 4:      #这里设定每22帧就保存1帧，如果每一帧都要进行人脸识别的话可能会卡顿，可以根据自己的实际情况设定
                #print("保存一帧")
                images_que.put(frame)
                #print("队列帧数为：%d" % (images_que.qsize()))
                temp = 0
        # 20分钟后自动关闭摄像头，可以自行设定，因为采用的是多进程，所以要逐一kill
        if time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time() - 1200)) >= open_time:
            f = open("info.txt")
            info_list = f.readlines()
            f.close()
            flask_temp = 0
            for i in range(len(info_list)):
                temp = re.findall('\d+$', info_list[i])
                if temp:
                    flask_temp = temp[0]
            pid_list = os.popen("ps -ef | grep flask").readlines()
            for i in range(len(pid_list)):
                pid_list[i] = pid_list[i].split()[1]
                if str(pid_list[i]) != flask_temp and flask_temp != 0:
                    try:
                        os.popen("sudo kill -15 " + str(pid_list[i]))
                    except:
                        os.popen("sudo kill -9 " + str(pid_list[i]))
                    print("kill " + str(pid_list[i]) + "\n")
            if os.path.exists("info.txt"):
                os.remove("info.txt")
            time.sleep(4)
            sys.exit()


# 人脸检测和人脸识别
def face_check(images_que, feature_known_list, pos_namelist, print_namelist,name_list):
    '''
    pid2 = os.getpid()
    f = open("info.txt", 'a')
    f.write('p2:' + str(pid2) + "\n")
    f.close()
    '''
    db1 = pymysql.connect('127.0.0.1', 'root', '123456', 'success_recognition', charset='utf8')
    cursor1 = db1.cursor()
    with tf.Graph().as_default():

        with tf.Session()as sess:

            # Load the model
            facenet.load_model(model_path)

            while True:
                image = images_que.get()   #从image_que取一张图片
                img_gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
                #print("开始检测人脸")
                faces_coordinate = detector(img_gray, 0)        #检测人脸，faces_coordinate的形状为[n,4],n为边框数，即人脸数，4分别对应x1，y1，x2，y2
                faces_num=len(faces_coordinate)          #人脸数
                print("人脸数为：%d" % (faces_num))
                if faces_num != 0:
                    # cv2.namedWindow('frame', cv2.WINDOW_NORMAL)
                    # cv2.resizeWindow('frame', 1280, 720)
                    # cv2.imshow('frame',image)
                    # cv2.waitKey(1)
                    bounding_boxes = np.ndarray(shape=(faces_num, 4), dtype=np.int32)   #bounding_boxes存放每个人的人脸坐标
                    for k,d in enumerate(faces_coordinate):
                        bounding_boxes[k][0] = d.left()
                        bounding_boxes[k][1] = d.top()
                        bounding_boxes[k][2] = d.right()
                        bounding_boxes[k][3] = d.bottom()
                    face_recognition(image, bounding_boxes, feature_known_list, pos_namelist,print_namelist,name_list,db1,cursor1)  # 如果有人脸就调用人脸识别函数
                else:
                    cv2.namedWindow('frame', cv2.WINDOW_NORMAL)
                    cv2.resizeWindow('frame', 1280, 720)
                    cv2.imshow('frame', image)
                    cv2.waitKey(1)
                    print("\n")


#主进程
def main_process():
    '''
    p=os.getpid()
    f=open("info.txt",'w')
    f.write('p:'+str(p)+"\n")
    f.close()
    '''
    with Manager() as manager:
        feature_known_list = manager.list()  # 数据库中的人脸的特征list
        name_list = manager.list() # 数据库中的人脸名字
        pos_namelist = manager.list()  # 要在屏幕上打印的人脸名字的坐标
        print_namelist = manager.list()  # 要在屏幕上打印的人脸名字
        feature_known_list,name_list = known_faces(feature_known_list,name_list)  # 遍历所有已知的人脸数据
        save_success()
        images_que = Queue()         #用来保存从摄像头拍到的帧
        p1 = Process(target=save_frame, args=(images_que, pos_namelist,print_namelist, name_list,time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())),)) #进程1用于打开摄像头，并保存帧
        print("Create ProcessP1\n")
        p2 = Process(target=face_check,args=(images_que, feature_known_list, pos_namelist, print_namelist,name_list,))    #进程2用于人脸检测和人脸识别
        print("Create ProcessP2\n")
        p1.start()
        p2.start()
        p1.join()
        p2.join()