【最新】基于OpenCV的Python人脸识别、检测、框选（遍历目录下所有照片依次识别视频随时标注）

﹏ヽ暗。殇╰゛Y 2022-09-03 05:11 195阅读 0赞

基于OpenCV的Python人脸识别、检测、框选  
（遍历目录下所有照片依次识别 视频随时标注）

**一、功能概览**

可以实现在摄像头下实时的人脸识别、检测、框选功能

原理是将摄像头下的图像人脸和存放照片的目录下的人脸依次进行对比 调用百度的API人脸识别接口 返回相似度的值进行识别

识别成功和失败均有提示 成功时能将对应的信息写入到识别记录中 并终止程序 当所有照片对比后均失败则提示失败 终止程序

窗口利用tkinter函数所写 利用PIL和opencv对图像进行处理 最后将识别结果和人脸框选图像在窗口中显示出来

人脸框选功能用到了opencv官方的人脸识别器 然后利用opencv画出相应外框即可

另外在测试时 用matplotlib.pyplot的相关函数进行输出图像的测试

文件资源包：（文章末尾有百度网盘版）https://download.csdn.net/download/weixin\_53403301/20670370?spm=1001.2014.3001.5501

主要代码为工程包内的api\_face.py和gui\_face\_new.py文件

对应识别速度更快的版本为api\_face\_faster.py和gui\_face\_new\_faster.py文件

另外 gui\_face.py文件所对应的程序功能为选择任一目录下的指定图像进行识别 在我之前的文章中有写到 gui\_face\_new.py文件是在其上的改进

之前的文章和资源：  
https://blog.csdn.net/weixin\_53403301/article/details/117464715  
https://download.csdn.net/download/weixin\_53403301/19651352?spm=1001.2014.3001.5503

另外还有应用在树莓派和89C52单片机上的硬件控制版本：  
https://blog.csdn.net/weixin\_53403301/article/details/118575731  
https://download.csdn.net/download/weixin\_53403301/20086349

如下图为源文件根目录下的所有文件图示  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70]  
**二、使用说明**

主要代码为工程包内的api\_face.py和gui\_face\_new.py文件 运行gui\_face\_new.py文件即可工作

对应识别速度更快的版本为api\_face\_faster.py和gui\_face\_new\_faster.py文件

OpenCV版本号为4.40.46 4.5.1版本以上调用摄像头会出现很明显的色差问题

需要在img目录先放入照片 最好为正脸证件照

运行程序 点击“使用相机识别”则识别开始 依次对img目录下的照片和摄像头内容进行对比识别

返回的相似度值大于80则成功 小于80则失败

若识别成功 则不在遍历目录下的剩余文件 直接提示成功窗口 中断识别

若识别失败 则继续遍历目录下的剩余文件进行识别 直到识别成功

若所有文件都以识别完 但仍然未识别成功 则提示失败窗口 中断识别

已有的识别记录为Windows系统下创建

Linux系统下的识别记录若为乱码 则需要更改code编码 或删除后重新运行程序 自动建立

在Linux系统建立的识别记录文件 在Windows环境下可以正常读取 不受影响

**三、分部测试功能程序**

**1.遍历目录功能**  
采用os库遍历img目录下的所有文件 并将其文件名存入到列表中  
再利用opencv读取 mat进行显示测试  
代码如下：

# -*- coding: utf-8 -*-
    """
    Created on Sun Aug  1 11:16:18 2021
    
    @author: 16016
    """
    
    import cv2
    import os
    
    import matplotlib.pyplot as plt # 调用matplotlib绘图库
    plt.rcParams['font.sans-serif'] = ['SimHei'] # 载入字体
    
    def pshow(words,picture):
        plt.imshow(picture[:,:,::-1])   # 将读取的图片以RGB转换为BGR
        plt.title(words), plt.xticks([]), plt.yticks([])
        plt.show() # 显示图片
        
    dir_name='./img'
    fileimg_list = []
    fileimg_list=os.listdir(dir_name)
    file_num=len(fileimg_list)
    i=0
    while True:
        if i<file_num:
            print(i)
            img=cv2.imread(dir_name + '/' + fileimg_list[i])    
            pshow(fileimg_list[i],img)
            i=i+1
        else:
            break

运行结果如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 1]  
**2.界面获取目录功能**  
此功能是应用在gui\_face.py文件夹 目的是通过按钮选择图像并输出图像路径  
代码如下：

#coding=utf-8
    
    
    #建立容器
    import tkinter as tk
    from tkinter import ttk
    from tkinter.filedialog import *
    import tkinter.messagebox
    tk=Tk()
    tk.title("个人GUI界面学习")
    mainfarm=Frame(tk,width=800, height=100,bg="black")
    mainfarm.grid_propagate(0)
    mainfarm.grid()
    fram=Frame(mainfarm,width=400, height=100,bg="black")
    fram.grid_propagate(0)
    fram.grid()
    
    
    e = Entry(fram)
    e.grid(row=0,column=2)
    
    e.delete(0, END)  # 将输入框里面的内容清空
    e.insert(0, '选择人像图片')
    filepath=StringVar()
    def filefound():
        filepath= askopenfilename()
        print (filepath)
        e.delete(0, END)  # 将输入框里面的内容清空
        e.insert(0, filepath)
    
    #button1=Button(fram,text="button1").grid(row=0,column=1)
    button2=Button(fram,text="选择文件",command=filefound).grid(row=0,column=3)
    #print (fram.size())
    
    mainloop()

运行结果如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 2]  
**3.人脸框选功能**  
加载目录下的opencv官方人脸识别器（haarcascade\_frontalface\_default.xml） 进行识别后画出外框  
代码如下：

import cv2
    import matplotlib.pyplot as plt
    plt.rcParams['font.sans-serif'] = ['SimHei'] # 载入字体
    
    #print('请输入需录入的人脸图片路径/文件名：')
    #pic_name=input()
    
    # 利用MATLAB显示图片  
    def pshow(words,picture):
        plt.imshow(picture[:,:,::-1])
        plt.title(words), plt.xticks([]), plt.yticks([])
        plt.show()
    
    # 图像路径 我用的相对路径
    filepath = 'img/123.jpg'
    # 读取文件
    faceImg = cv2.imread(filepath)
    # 转换灰色
    gray = cv2.cvtColor(faceImg,cv2.COLOR_BGR2GRAY)
    
    # 加载人脸识别分类器
    # 官方已有的分类器  https://github.com/opencv/opencv/tree/master/data/haarcascades
    # github的不好下载, 可以从码云上找
    # Python\Python38-32\Lib\site-packages\cv2\data  这个目录下也有
    classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
    color = (0,255,0)
    
    # 识别器进行识别
    faceRects = classifier.detectMultiScale(gray,scaleFactor=1.2,minNeighbors=3,minSize=(32, 32))
    # 识别器返回一个列表, 里面是每个识别出的人脸的区域, 左上和右下定点的坐标
    # print(faceRects)  #[[113  42  60  60]]    前两个值是左上定点的xy坐标,第三个是width 宽度对应y的变化, 另一个就是x的
    
    # 判断识别结果集合长度
    if len(faceRects):
        for faceRect in faceRects:
            x,y,w,h = faceRect
            # 框选出人脸   最后一个参数2是框线宽度
            cv2.rectangle(faceImg,(x, y), (x + h, y + w), color, 2)
            
    
    pshow('1',faceImg)
    # 显示图像

运行结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 3]  
**4.摄像头及框选功能**  
同上一个功能 不过是对摄像头图像进行实时的框选 并实时显示 同时还加上了人眼部分框选（haarcascade\_eye.xml）  
通过opencv进行显示 同时按esc键退出  
代码如下：

import cv2
    
    cap = cv2.VideoCapture(0)  # 开启摄像头
    
    # 循环读取图像
    while True:
        ok, img = cap.read()  # 读取摄像头图像
        if ok is False:
            print('无法读取到摄像头！')
            break
        
       
        faceImg = img
        
        gray = cv2.cvtColor(faceImg,cv2.COLOR_BGR2GRAY)
    
        # 加载人脸识别分类器
        # 官方已有的分类器  https://github.com/opencv/opencv/tree/master/data/haarcascades
        # github的不好下载, 可以从码云上找
        # Python\Python38-32\Lib\site-packages\cv2\data  这个目录下也有
        classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
        color = (0,255,0)
    
        # 识别器进行识别
        faceRects = classifier.detectMultiScale(gray,scaleFactor=1.2,minNeighbors=3,minSize=(32, 32))
    
        if len(faceRects):
            for faceRect in faceRects:
                x,y,w,h = faceRect
                # 框选出人脸   最后一个参数2是框线宽度
                cv2.rectangle(faceImg,(x, y), (x + h, y + w), color, 2)
    
        
        
        
        # 转换灰色
        gray = cv2.cvtColor(faceImg,cv2.COLOR_BGR2GRAY)
    
        # 加载人脸识别分类器
        # 官方已有的分类器  https://github.com/opencv/opencv/tree/master/data/haarcascades
        # github的不好下载, 可以从码云上找
        # Python\Python38-32\Lib\site-packages\cv2\data  这个目录下也有
        classifier = cv2.CascadeClassifier('haarcascade_eye.xml')
        color = (255,0,0)
    
        # 识别器进行识别
        faceRects = classifier.detectMultiScale(gray,scaleFactor=1.2,minNeighbors=3,minSize=(32, 32))
    
        if len(faceRects):
            for faceRect in faceRects:
                x,y,w,h = faceRect
                # 框选出人脸   最后一个参数2是框线宽度
                cv2.rectangle(faceImg,(x, y), (x + h, y + w), color, 2)
                
        
        #faceImg= cv2.cvtColor(faceImg,cv2.COLOR_RGB2BGR)
        cv2.imshow("faceImg",faceImg)
        # 展示图像
        
        
    
        k = cv2.waitKey(10)  # 键盘值
        if k == 27:   # 通过esc键退出摄像
            break
    
    # 关闭摄像头
    cap.release()
    cv2.destroyAllWindows()

运行结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 4]  
**5.延时功能**  
此功能主要用于测试time库 获取系统时间的功能  
测试这个功能的目的主要是为了在主程序中 通过控制时间减少资源的使用 使其每隔一段时间读取、识别一次（0.1s）  
主程序中 识别函数为一个循环 读取一次摄像头并进行人脸识别 若识别成功 则中断循环 若识别失败 也跳出循环  
代码如下：

# -*- coding: utf-8 -*-
    """
    Created on Tue Jun  1 00:14:45 2021
    
    @author: ZHOU
    """
    
    import time
    import threading
    
    
    
    def delay(a):
        print( time.time(),'10s',a)
        print( time.time())
        s = threading.Timer(10,delay,("delay",))
        s.start()
        print( time.time())
        
    def main():
        print('1')
        delay(10)
        print('2')
    
    main()

运行结果如下：  
延时时间为10s  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 5]  
**四、主程序部分**  
**1.API算法部分**  
调用 requests的HTTP协议库  
调用os多操作系统接口库  
调用base64编码库  
调用JavaScript Object Notation数据交换格式  
登入百度的人脸识别API 然后对给出的两个图像进行对比识别 输出相相似度  
所有相关功能和函数的语句已在代码中注释好了  
代码如下：（第一段为常规版，第二段为快速版）

# -*- coding: utf-8 -*-
    """
    Created on Mon May 31 23:40:16 2021
    
    @author: ZHOU
    """
    
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    import requests # 调用 requests的HTTP协议库
    import os # 调用os多操作系统接口库
    import base64 # 调用base64编码库
    import json # 调用JavaScript Object Notation数据交换格式
     
    ACCESS_TOKEN = ''
    BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) #去掉文件名,返回目录 
     
    # ID,KEY的配置信息
    INFO_CONFIG = {
         
        'ID': '15788358',
        'API_KEY': 'ohtGa5yYoQEZ8Try8lnL99UK',
        'SECRET_KEY': 'qaDjyuXkf5MZ28g5C8pwFngDZenhswC3'
    }
     
    # URL配置
    URL_LIST_URL = {
        
        # ACCESS_TOKEN_URL用于获取ACCESS_TOKEN, POST请求,
        #  grant_type必须参数,固定为client_credentials,client_id必须参数,应用的API Key,client_secre 必须参数,应用的Secret Key.
        'ACCESS_TOKEN_URL': 'https://aip.baidubce.com/oauth/2.0/token?' + 'grant_type=client_credentials&client_id={API_KEYS}&client_secret={SECRET_KEYS}&'.format(
            API_KEYS=INFO_CONFIG['API_KEY'], SECRET_KEYS=INFO_CONFIG['SECRET_KEY']),
        # 登入人脸识别机器学习库
        'FACE_PLATE': 'https://aip.baidubce.com/rest/2.0/face/v3/match',
     
    }
     
     
    class AccessTokenSuper(object):
        pass
     
     
    class AccessToken(AccessTokenSuper): # 定义登陆API大类
        def getToken(self):
            accessToken = requests.post(url=URL_LIST_URL['ACCESS_TOKEN_URL']) #登入网址
            accessTokenJson = accessToken.json()
            if dict(accessTokenJson).get('error') == 'invalid_client':
                return '获取accesstoken错误，请检查API_KEY，SECRET_KEY是否正确！'
            return accessTokenJson
     
     
    ACCESS_TOKEN = AccessToken().getToken()['access_token']
     
    LICENSE_PLATE_URL = URL_LIST_URL['FACE_PLATE'] + '?access_token={}'.format(ACCESS_TOKEN)
     
     
    class faceSuper(object):
        pass
     
     
    class face(faceSuper): # 定义图像输入大类
     
        def __init__(self, image=None, image2=None): # 定义初始化函数
            self.HEADER = {
        
                'Content-Type': 'application/json; charset=UTF-8',
            }
            if image is not None: 	# 没有图像1
                imagepath = os.path.exists(image)
                if imagepath == True:
                    images = image
                    with open(images, 'rb') as images:
                        img1 = base64.b64encode(images.read())
                else:
                    print("图像1不存在")
                    return
            if image2 is not None: 	# 没有图像2
                imagepath2 = os.path.exists(image2)
                if imagepath2 == True:
                    images2 = image2
                    with open(images2, 'rb') as images2:
                        img2 = base64.b64encode(images2.read())
                else:
                    print("图像2不存在")
                    return
            self.img = img1
            self.imgs = img2
            self.IMAGE_CONFIG1 = {
        "image": str(img1, 'utf-8'), "image_type": "BASE64"}
            self.IMAGE_CONFIG2 = {
        "image": str(img2, 'utf-8'), "image_type": "BASE64"}
            self.IMAGE_CONFIG = json.dumps([self.IMAGE_CONFIG1, self.IMAGE_CONFIG2])
     
        def postface(self):  # 定义从服务器进行数据获取函数
            if (self.img==None and self.imgs==None):
                return '图像不存在'
            face = requests.post(url=LICENSE_PLATE_URL, headers=self.HEADER, data=self.IMAGE_CONFIG)
            # 登陆服务器获取数据
            return face.json() 	# 输出结果
     
     
    def facef(FA1, FA2): # 人脸识别逻辑函数
        testAccessToken = AccessToken() # 获取API配置
        testface = face(image=FA1, image2=FA2) # 赋值给图像输入大类
        result_json = testface.postface()  # 从服务器获取数据
        result = result_json['result']['score'] #输出结果
        print('人脸相似度：', result)
        if result > 80: # 识别结果大于80则成功
            print("人脸匹配成功！")        
    #    if result < 20:
    #        print("未检测到人脸！")
        else:
            print("人脸匹配失败！")
        return '人脸相似度：' + str(result), result # 输出字符串结果

# -*- coding: utf-8 -*-
    """
    Created on Mon May 31 23:40:16 2021
    
    @author: ZHOU
    """
    
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    import requests # 调用 requests的HTTP协议库
    import os # 调用os多操作系统接口库
    import base64 # 调用base64编码库
    import json # 调用JavaScript Object Notation数据交换格式
     
    ACCESS_TOKEN = ''
    BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) #去掉文件名,返回目录 
     
    # ID,KEY的配置信息
    INFO_CONFIG = {
         
        'ID': '15788358',
        'API_KEY': 'ohtGa5yYoQEZ8Try8lnL99UK',
        'SECRET_KEY': 'qaDjyuXkf5MZ28g5C8pwFngDZenhswC3'
    }
     
    # URL配置
    URL_LIST_URL = {
        
        # ACCESS_TOKEN_URL用于获取ACCESS_TOKEN, POST请求,
        #  grant_type必须参数,固定为client_credentials,client_id必须参数,应用的API Key,client_secre 必须参数,应用的Secret Key.
        'ACCESS_TOKEN_URL': 'https://aip.baidubce.com/oauth/2.0/token?' + 'grant_type=client_credentials&client_id={API_KEYS}&client_secret={SECRET_KEYS}&'.format(
            API_KEYS=INFO_CONFIG['API_KEY'], SECRET_KEYS=INFO_CONFIG['SECRET_KEY']),
        # 登入人脸识别机器学习库
        'FACE_PLATE': 'https://aip.baidubce.com/rest/2.0/face/v3/match',
     
    }
     
     
    class AccessTokenSuper(object):
        pass
     
     
    class AccessToken(AccessTokenSuper): # 定义登陆API大类
        def getToken(self):
            accessToken = requests.post(url=URL_LIST_URL['ACCESS_TOKEN_URL']) #登入网址
            accessTokenJson = accessToken.json()
            if dict(accessTokenJson).get('error') == 'invalid_client':
                return '获取accesstoken错误，请检查API_KEY，SECRET_KEY是否正确！'
            return accessTokenJson
     
     
    ACCESS_TOKEN = AccessToken().getToken()['access_token']
     
    LICENSE_PLATE_URL = URL_LIST_URL['FACE_PLATE'] + '?access_token={}'.format(ACCESS_TOKEN)
     
     
    class faceSuper(object):
        pass
     
     
    class face(faceSuper): # 定义图像输入大类
     
        def __init__(self, image=None, image2=None): # 定义初始化函数
            self.HEADER = {
        
                'Content-Type': 'application/json; charset=UTF-8',
            }
            if image is not None: 	# 没有图像1
                imagepath = os.path.exists(image)
                if imagepath == True:
                    images = image
                    with open(images, 'rb') as images:
                        img1 = base64.b64encode(images.read())
                else:
                    print("图像1不存在")
                    return
            if image2 is not None: 	# 没有图像2
                imagepath2 = os.path.exists(image2)
                if imagepath2 == True:
                    images2 = image2
                    with open(images2, 'rb') as images2:
                        img2 = base64.b64encode(images2.read())
                else:
                    print("图像2不存在")
                    return
            self.img = img1
            self.imgs = img2
            self.IMAGE_CONFIG1 = {
        "image": str(img1, 'utf-8'), "image_type": "BASE64"}
            self.IMAGE_CONFIG2 = {
        "image": str(img2, 'utf-8'), "image_type": "BASE64"}
            self.IMAGE_CONFIG = json.dumps([self.IMAGE_CONFIG1, self.IMAGE_CONFIG2])
     
        def postface(self):  # 定义从服务器进行数据获取函数
            if (self.img==None and self.imgs==None):
                return '图像不存在'
            face = requests.post(url=LICENSE_PLATE_URL, headers=self.HEADER, data=self.IMAGE_CONFIG)
            # 登陆服务器获取数据
            return face.json() 	# 输出结果
     
     
    def facef(FA1, FA2): # 人脸识别逻辑函数
        testAccessToken = AccessToken() # 获取API配置
        testface = face(image=FA1, image2=FA2) # 赋值给图像输入大类
        result_json = testface.postface()  # 从服务器获取数据
        result = result_json['result']['score'] #输出结果
        print('人脸相似度：', result)
    #    if result > 80: # 识别结果大于80则成功
    #        print("人脸匹配成功！")        
    #    if result < 20:
    #        print("未检测到人脸！")
    #    else:
    #        print("人脸匹配失败！")
        return '人脸相似度：' + str(result), result # 输出字符串结果

此函数需要配合网络进行使用  
单独运行时不报错则可以连接上API

利用facef(FA1, FA2)函数 传入入两个图像值 则能进行识别

**2.界面程序部分**  
测试时 利用mat显示图像 pshow函数展示 在实际运行中 为了加快运行速度 将测试部分的代码注释掉了  
所有相关功能和函数的语句已在代码中注释好了  
（测试图片中为原始版本，文字提示中没有姓名，现代码已更新为包含姓名提示的版本）  
代码如下：（第一段为常规版，第二段为快速版）

# -*- coding: utf-8 -*-
    """
    Created on Mon May 31 23:39:19 2021
    
    @author: ZHOU
    """
    
    # -*- coding: utf-8 -*-
     
    import tkinter as tk # 调用窗口tk
    from tkinter import ttk
    from tkinter.filedialog import *
    import tkinter.messagebox
    from PIL import Image, ImageTk # 调用图像处理库pillow
    import api_face # 调用本地函数库 用于登入外部机器学习库并调用人脸识别函数
    import cv2 # 调用OpenCV图像处理库
    import threading # 调用threading多线程运行库
    import time # 调用系统时间戳库
    import os # 调用os多操作系统接口库
    import matplotlib.pyplot as plt # 调用matplotlib绘图库
    plt.rcParams['font.sans-serif'] = ['SimHei'] # 载入字体
    
    #print('请输入需录入的人脸图片路径/文件名：')
    #pic_name=input()
    
    # 利用matplotlib显示图片函数  
    def pshow(words,picture):
        plt.imshow(picture[:,:,::-1])   # 将读取的图片以RGB转换为BGR
        plt.title(words), plt.xticks([]), plt.yticks([])
        plt.show() # 显示图片
        
    
    class Login(ttk.Frame): # 定义窗口大类
        def __init__(self, win):
            ttk.Frame.__init__(self, win)
            frame0 = ttk.Frame(self)
            frame1 = ttk.Frame(self)
            win.title("人脸识别")
            win.minsize(1240, 620)
            self.center_window()    # 执行中置窗口函数
            self.thread_run = None 	# 赋值 线程1默认关闭
            self.thread_run2 = None 	# 线程2默认关闭
            self.camera = None 	# 摄像头默认关闭
     
            #定义tk窗口属性
            
            #self.pilImage = Image.open("img/start.png")
            #self.tkImage = ImageTk.PhotoImage(image=self.pilImage)
            #self.image_ctl = tk.Label(frame0, image=self.tkImage)
            #self.image_ctl.pack()
     
            frame0.pack(side=TOP, fill=tk.Y, expand=1)
            frame1.pack(side=TOP, fill=tk.Y, expand=1)
     
            self.facer = ttk.Label(frame1, text='', font=('Times', '20')) # 字体
            self.facer.pack()
            
    
    #        def filefound(): # 定义获取图片路径的函数
    #            filepath= askopenfilename() # 获取文件路径
    #            pic_name=filepath
    #            self.pic_path2 = pic_name # 赋值给图像2
    #            
    #            pshow('所选人像图片',pic_img) # 显示所选图片
            self.pic_path3='./star.png'
    #        pic_img=cv2.imread(self.pic_path3)
    #        pic_xz = pic_img.shape # 计算图像大小
    #        pic_h=pic_xz[0] # 得出图片高度
    #        pic_w=pic_xz[1] # 得出图片宽度
    #        turn_w=pic_w*500/pic_h # 限制最大高度为580 以防窗口过小不完全显示 等比例转换宽度
    #        turn_w=int(turn_w)
    #            print('人像图像大小（高 宽）：',pic_h,pic_w)
    #            print ('路径：',filepath)
    #            # 在tk窗口中显示所选图片
            
            self.pilImage = Image.open(self.pic_path3)            
            self.photo = self.pilImage.resize((500,500)) # 限制最大高度为580 等比缩放显示
            self.tkImage = ImageTk.PhotoImage(image=self.photo)
            self.image_ctl = tk.Label(frame0, image=self.tkImage)
            self.image_ctl.pack()
    #            #e.delete(0, END)  # 将输入框里面的内容清空
    #            #e.insert(0, filepath)
    #        
    #        #button2=Button(frame1,text="button2",command=filefound).grid(row=0,column=3)
    #        # 按钮1 调用filefound函数 获取选择图片的路径 并赋值给self.pic_path2 输出图像
    #        self.face_button1 = ttk.Button(frame1, text="1. 选择人像图片", width=15, command=filefound)
    #        self.face_button1.pack(side=TOP)        
            # 按钮2 调用摄像头函数
            self.url_face_button = ttk.Button(frame1, text="使用相机识别", width=15, command=self.cv_face)
            self.url_face_button.pack(side=TOP)
            #self.file_pic_button = ttk.Button(frame1, text="本地文件识别", width=15, command=self.file_pic)
            #self.file_pic_button.pack(side=TOP)
     
            self.pack(fill=tk.BOTH, expand=tk.YES, padx="10", pady="10")
     
        #使弹出的窗体处于屏幕的中间位置
        def center_window(self):
            screenwidth = log.winfo_screenwidth()	# 获取屏幕分辨率宽
            screenheight = log.winfo_screenheight()	# 获取屏幕分辨率高
            log.update()	# 更新窗口
            width = log.winfo_width()	# 重新赋值
            height = log.winfo_height()
            size = '+%d+%d' % ((screenwidth - width)/2, (screenheight - height)/2)
            # 重新赋值大小 大小为屏幕大小/2
            log.geometry(size) 	# 以新大小定义窗口
     
    #    def file1(self):
    #        self.pic_path = askopenfilename(title="选择识别图片", filetypes=[("jpg图片", "*.jpg"), ("png图片", "*.png")])
     
        def cv_face(self):   # 调用摄像头函数
            if self.thread_run:
                if self.camera.isOpened(): # 如果已经打开则关闭
                    self.camera.release()
                    print("关闭摄像头")
                    self.camera = None
                    self.thread_run = False
                return
            if self.camera is None: # 如果没有摄像头则尝试打开
                self.camera = cv2.VideoCapture(1) # 利用OpenCV调用外摄像头
                if not self.camera.isOpened(): # 如果没有打开 则调用内摄像头
                    self.camera = None
                    print("没有外置摄像头")
                    self.camera = cv2.VideoCapture(0) # 用OpenCV调用内摄像头
                    if not self.camera.isOpened(): # 如果没有打开 则打开失败
                        print("没有内置摄像头")
                        tkinter.messagebox.showinfo('警告', '摄像头打开失败！')
                        self.camera = None
                        return
                    else:
                        print("打开内置摄像头")
                else:
                    print("打开外置摄像头")
            self.thread = threading.Thread(target=self.video_thread) # 多线程函数执行摄像头运行函数
            self.thread.setDaemon(True)
            self.thread.start()
            self.thread_run = True
     
        def video_thread(self): # 开始摄像头运行
            self.thread_run = True # 多线程1开启
            self.thread2 = threading.Thread(target=self.video_pic)
            self.thread2.setDaemon(True)
            self.thread2.start()
            self.thread_run2 = True
            while self.thread_run: # 循环一直调用摄像头
                _, img_bgr = self.camera.read() # 以bgr格式读取摄像头内的截图 
                gray = cv2.cvtColor(img_bgr,cv2.COLOR_BGR2GRAY) # 灰度转换
                # 在CV官方机器学习库内加载人脸识别分类器                
                # Python\Python38-32\Lib\site-packages\cv2\data  这个目录下也有
                classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
                color = (0,255,0) # 绿色线
                # 识别器进行识别
                faceRects = classifier.detectMultiScale(gray,scaleFactor=1.2,minNeighbors=3,minSize=(32, 32))
                # 识别器返回一个列表, 里面是每个识别出的人脸的区域, 左上和右下定点的坐标
                # print(faceRects)  #[[113  42  60  60]]    前两个值是左上定点的xy坐标,第三个是width 宽度对应y的变化, 另一个就是x的
    
                # 判断识别结果集合长度
                if len(faceRects):
                    for faceRect in faceRects:
                        x,y,w,h = faceRect
                        # 用矩形框选出人脸   最后一个参数2是框线宽度
                        cv2.rectangle(img_bgr,(x, y), (x + h, y + w), color, 2)                 
                img = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB) # 颜色转换
                im = Image.fromarray(img)
                w, h = im.size
                pil_image_resized = self.resize(w, h, im) # 调整大小函数
                self.imgtk = ImageTk.PhotoImage(image=pil_image_resized)
                self.image_ctl.configure(image=self.imgtk)
            print("结束运行")
     
        def video_pic(self): # 视频截图保存及框选函数
            dir_name='./img' # 给出图片目录路径
            fileimg_list = [] # 建立列表型图片列表
            fileimg_list=os.listdir(dir_name) # 获取目录下文件名
            file_num=len(fileimg_list) # 获取列表长度
            fileimg_num=0   # 定义文件序号初始值为0
            self.thread_run2 = True     # 开启多线程
            predict_time = time.time() # 获得系统时间
            while self.thread_run2: # 循环读取
                if time.time() - predict_time > 0.1: #每0.1s读取一次摄像头截图
                    print("正在识别中")
                    _, img_bgr = self.camera.read() # 重新读取摄像头图像
                    cv2.imwrite("tmp/test.jpg", img_bgr) #利用cv写入到tmp/test.jpg路径下
    #                test_pic=cv2.imread('tmp/test.jpg') # 重新读取截图
    #                pshow('识别截图',test_pic) # 显示截图
    #                
    #                # 图像路径 我用的相对路径
    #                face_mark = 'tmp/test.jpg'
    #                # 读取截图
    #                faceImg = cv2.imread(face_mark)
    #                # 转换灰色
    #                gray = cv2.cvtColor(faceImg,cv2.COLOR_RGB2GRAY) # 由于tmp/test.jpg路径下的已经转换成RGB保存 所以不用再进行BGR转换
    #
    #                # 在CV官方机器学习库内加载人脸识别分类器                
    #                # Python\Python38-32\Lib\site-packages\cv2\data  这个目录下也有
    #                classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
    #                color = (0,255,0) # 绿色线
    #
    #                # 识别器进行识别
    #                faceRects = classifier.detectMultiScale(gray,scaleFactor=1.2,minNeighbors=3,minSize=(32, 32))
    #                # 识别器返回一个列表, 里面是每个识别出的人脸的区域, 左上和右下定点的坐标
    #                # print(faceRects)  #[[113  42  60  60]]    前两个值是左上定点的xy坐标,第三个是width 宽度对应y的变化, 另一个就是x的
    #
    #                # 判断识别结果集合长度
    #                if len(faceRects):
    #                    for faceRect in faceRects:
    #                        x,y,w,h = faceRect
    #                        # 用矩形框选出人脸   最后一个参数2是框线宽度
    #                        cv2.rectangle(faceImg,(x, y), (x + h, y + w), color, 2)
    #        
    #                
    #                pshow('识别结果',faceImg)    # 输出框选结果图像并显示
    #                cv2.imwrite("tmp/test2.jpg", faceImg)
                    self.pic_path = "tmp/test.jpg" # 重新读取摄像头截图
    #                self.pilImage = Image.open(self.pic_path)
    #                self.tkImage = ImageTk.PhotoImage(image=self.pilImage)
    #                self.image_ctl = tk.Label(frame0, image=self.tkImage)
    #                self.image_ctl.pack()
                    try:
    
                    
                        if fileimg_num<file_num: #当文件序号小于总列表长度时
                            #print(fileimg_num)
                            #img=cv2.imread(dir_name + '/' + fileimg_list[fileimg_num])    
                            #pshow(fileimg_list[fileimg_num],img)
                            self.pic_path2 = dir_name + '/' + fileimg_list[fileimg_num] # 给出pic_path2的值为目录名+/+文件名
                            #print(self.pic_path2)
    #                        self.pic_path2='./img/111.jpg'
                            facestr, result = api_face.facef(self.pic_path, self.pic_path2) # 调用api_face库的人脸识别函数
                            self.facer.configure(text=str(facestr))
                                    #self.pic() # 对摄像头图像进行尺度变换
                            if result > 80: #识别结果大于80
                                humantitle='  姓名：  '+fileimg_list[fileimg_num].partition('.')[0]+"  人脸匹配成功！  \n"
                                print(humantitle) # 输出人像文件文件名
                                tkinter.messagebox.showinfo('提示', humantitle) # tk窗口提示
                                
                                try:
                                    f=open("识别记录.txt","r")
                                    fi=open("识别记录.txt","a")
                                    txt=time.ctime()
                                    fi.write(txt+humantitle)
                                    f.close()
                                    fi.close() # 将识别成功的记录保存在txt文件下
                                except:
                                    f=open("识别记录.txt","w")
                                    txt=time.ctime()
                                    f.write(txt+humantitle)
                                    f.close()
                                            
                                        
                                        
                                        # close_window()
                                        # os.system("python3 ./main.py")
                                    #if result < 20:
                                    #    tkinter.messagebox.showinfo('提示', '未检测到人脸！')
                                break
                            else: # 小于80失败
                                fileimg_num=fileimg_num+1 # 文件序号+1
                                    
                                
                        else: # 超出文件列表长度
                            tkinter.messagebox.showinfo('提示', '查无此人！人脸匹配失败！')
                            break
                    except:
                        pass
                    predict_time = time.time()      # 读取时间          
                    print("识别结束")
                    
                    # 看门狗程序（调试用）
                    # 防止程序关闭时进入死循环跑飞
                    #print('请输入任意值以继续，否则请关闭窗口以终止程序：')
                    #a=input()
                    #print(a)
            pass
     
    #    def file_pic(self): #识别函数
    #        dir_name='./img'
    #        fileimg_list = []
    #        fileimg_list=os.listdir(dir_name)
    #        file_num=len(fileimg_list)
    #        fileimg_num=0   
    #        while True:
    #            if fileimg_num<file_num:
    #                print(fileimg_num)
    #                img=cv2.imread(dir_name + '/' + fileimg_list[fileimg_num])    
    #                pshow(fileimg_list[fileimg_num],img)
    #                self.pic_path2 = dir_name + '/' + fileimg_list[fileimg_num]
    #                print(self.pic_path2)
    ##                self.pic_path2='./img/111.jpg'
    #                facestr, result = api_face.facef(self.pic_path, self.pic_path2) # 调用api_face库的人脸识别函数
    #                self.facer.configure(text=str(facestr))
    #                        #self.pic() # 对摄像头图像进行尺度变换
    #                if result > 80: #识别结果大于80
    #                    tkinter.messagebox.showinfo('提示', '人脸匹配成功！') # tk窗口提示
    #                    print('人像图片路径：'+self.pic_path2) # 输出人像文件路径
    #                    try:
    #                        f=open("识别记录.txt","r")
    #                        fi=open("识别记录.txt","a")
    #                        txt=time.ctime()
    #                        fi.write(txt+'   人像图片路径：   '+self.pic_path2+"     人脸匹配成功！ \n")
    #                        f.close()
    #                        fi.close() # 将识别成功的记录保存在txt文件下
    #                    except:
    #                        f=open("识别记录.txt","w")
    #                        txt=time.ctime()
    #                        f.write(txt+'   人像图片路径：   '+self.pic_path2+"     人脸匹配成功！ \n")
    #                        f.close()
    #                                
    #                            
    #                            
    #                            # close_window()
    #                            # os.system("python3 ./main.py")
    #                        #if result < 20:
    #                        #    tkinter.messagebox.showinfo('提示', '未检测到人脸！')
    #                        break
    #                    else: # 小于80失败
    #                        fileimg_num=fileimg_num+1
    #                        
    #                    
    #            else:
    #                tkinter.messagebox.showinfo('提示', '人脸匹配失败！')
    #                break
            
            
     
    #    def pic(self): # 对摄像头图像进行尺度变换
    #        self.pilImage3 = Image.open(self.pic_path) # 用pillow读取摄像头图像
    #        w, h = self.pilImage3.size # 计算大小赋值给宽 高
    #        pil_image_resized = self.resize(w, h, self.pilImage3) # 调整大小函数
    #        self.tkImage3 = ImageTk.PhotoImage(image=pil_image_resized) 
    #        self.image_ctl.configure(image=self.tkImage3) # 输出结果
     
        def resize(self, w, h, pil_image): # 调整大小函数
            w_box = 1000 # 定义最大宽度
            h_box = 500 # 最大高度
            f1 = 1.0*w_box/w # 最大值/真实值
            f2 = 1.0*h_box/h
            factor = min([f1, f2]) # 取最小值
            width = int(w*factor) # 用最小值*对应值 调整到最大定义值 等比调整另一个值
            height = int(h*factor)
            return pil_image.resize((width, height), Image.ANTIALIAS) # 输出调整
     
     
    def close_window():
        print("已关闭人脸识别")
        if Login.thread_run:
            Login.thread_run = False
            Login.thread.join(2.0)
        log.destroy()
        
    
        
    if __name__ == '__main__':
        log = tk.Tk()
     
        login = Login(log)
        # close,退出输出destroy
        log.protocol('清除窗口', close_window)
        # 进入消息循环
        log.mainloop()

# -*- coding: utf-8 -*-
    """
    Created on Mon May 31 23:39:19 2021
    
    @author: ZHOU
    """
    
    # -*- coding: utf-8 -*-
     
    import tkinter as tk # 调用窗口tk
    from tkinter import ttk
    from tkinter.filedialog import *
    import tkinter.messagebox
    from PIL import Image, ImageTk # 调用图像处理库pillow
    import api_face_faster # 调用本地函数库 用于登入外部机器学习库并调用人脸识别函数
    import cv2 # 调用OpenCV图像处理库
    import threading # 调用threading多线程运行库
    import time # 调用系统时间戳库
    import os # 调用os多操作系统接口库
    import matplotlib.pyplot as plt # 调用matplotlib绘图库
    plt.rcParams['font.sans-serif'] = ['SimHei'] # 载入字体
    
    #print('请输入需录入的人脸图片路径/文件名：')
    #pic_name=input()
    
    # 利用matplotlib显示图片函数  
    def pshow(words,picture):
        plt.imshow(picture[:,:,::-1])   # 将读取的图片以RGB转换为BGR
        plt.title(words), plt.xticks([]), plt.yticks([])
        plt.show() # 显示图片
        
    
    class Login(ttk.Frame): # 定义窗口大类
        def __init__(self, win):
            ttk.Frame.__init__(self, win)
            frame0 = ttk.Frame(self)
            frame1 = ttk.Frame(self)
            win.title("人脸识别")
            win.minsize(1240, 620)
            self.center_window()    # 执行中置窗口函数
            self.thread_run = None 	# 赋值 线程1默认关闭
            self.thread_run2 = None 	# 线程2默认关闭
            self.camera = None 	# 摄像头默认关闭
     
            #定义tk窗口属性
            
            #self.pilImage = Image.open("img/start.png")
            #self.tkImage = ImageTk.PhotoImage(image=self.pilImage)
            #self.image_ctl = tk.Label(frame0, image=self.tkImage)
            #self.image_ctl.pack()
     
            frame0.pack(side=TOP, fill=tk.Y, expand=1)
            frame1.pack(side=TOP, fill=tk.Y, expand=1)
     
            self.facer = ttk.Label(frame1, text='', font=('Times', '20')) # 字体
            self.facer.pack()
            
    
    #        def filefound(): # 定义获取图片路径的函数
    #            filepath= askopenfilename() # 获取文件路径
    #            pic_name=filepath
    #            self.pic_path2 = pic_name # 赋值给图像2
    #            
    #            pshow('所选人像图片',pic_img) # 显示所选图片
            self.pic_path3='./star.png'
    #        pic_img=cv2.imread(self.pic_path3)
    #        pic_xz = pic_img.shape # 计算图像大小
    #        pic_h=pic_xz[0] # 得出图片高度
    #        pic_w=pic_xz[1] # 得出图片宽度
    #        turn_w=pic_w*500/pic_h # 限制最大高度为580 以防窗口过小不完全显示 等比例转换宽度
    #        turn_w=int(turn_w)
    #            print('人像图像大小（高 宽）：',pic_h,pic_w)
    #            print ('路径：',filepath)
    #            # 在tk窗口中显示所选图片
            
            self.pilImage = Image.open(self.pic_path3)            
            self.photo = self.pilImage.resize((500,500)) # 限制最大高度为580 等比缩放显示
            self.tkImage = ImageTk.PhotoImage(image=self.photo)
            self.image_ctl = tk.Label(frame0, image=self.tkImage)
            self.image_ctl.pack()
    #            #e.delete(0, END)  # 将输入框里面的内容清空
    #            #e.insert(0, filepath)
    #        
    #        #button2=Button(frame1,text="button2",command=filefound).grid(row=0,column=3)
    #        # 按钮1 调用filefound函数 获取选择图片的路径 并赋值给self.pic_path2 输出图像
    #        self.face_button1 = ttk.Button(frame1, text="1. 选择人像图片", width=15, command=filefound)
    #        self.face_button1.pack(side=TOP)        
            # 按钮2 调用摄像头函数
            self.url_face_button = ttk.Button(frame1, text="使用相机识别", width=15, command=self.cv_face)
            self.url_face_button.pack(side=TOP)
            #self.file_pic_button = ttk.Button(frame1, text="本地文件识别", width=15, command=self.file_pic)
            #self.file_pic_button.pack(side=TOP)
     
            self.pack(fill=tk.BOTH, expand=tk.YES, padx="10", pady="10")
     
        #使弹出的窗体处于屏幕的中间位置
        def center_window(self):
            screenwidth = log.winfo_screenwidth()	# 获取屏幕分辨率宽
            screenheight = log.winfo_screenheight()	# 获取屏幕分辨率高
            log.update()	# 更新窗口
            width = log.winfo_width()	# 重新赋值
            height = log.winfo_height()
            size = '+%d+%d' % ((screenwidth - width)/2, (screenheight - height)/2)
            # 重新赋值大小 大小为屏幕大小/2
            log.geometry(size) 	# 以新大小定义窗口
     
    #    def file1(self):
    #        self.pic_path = askopenfilename(title="选择识别图片", filetypes=[("jpg图片", "*.jpg"), ("png图片", "*.png")])
     
        def cv_face(self):   # 调用摄像头函数
            if self.thread_run:
                if self.camera.isOpened(): # 如果已经打开则关闭
                    self.camera.release()
                    print("关闭摄像头")
                    self.camera = None
                    self.thread_run = False
                return
            if self.camera is None: # 如果没有摄像头则尝试打开
                self.camera = cv2.VideoCapture(1) # 利用OpenCV调用外摄像头
                if not self.camera.isOpened(): # 如果没有打开 则调用内摄像头
                    self.camera = None
                    print("没有外置摄像头")
                    self.camera = cv2.VideoCapture(0) # 用OpenCV调用内摄像头
                    if not self.camera.isOpened(): # 如果没有打开 则打开失败
                        print("没有内置摄像头")
                        tkinter.messagebox.showinfo('警告', '摄像头打开失败！')
                        self.camera = None
                        return
                    else:
                        print("打开内置摄像头")
                else:
                    print("打开外置摄像头")
            self.thread = threading.Thread(target=self.video_thread) # 多线程函数执行摄像头运行函数
            self.thread.setDaemon(True)
            self.thread.start()
            self.thread_run = True
     
        def video_thread(self): # 开始摄像头运行
            self.thread_run = True # 多线程1开启
            self.thread2 = threading.Thread(target=self.video_pic)
            self.thread2.setDaemon(True)
            self.thread2.start()
            self.thread_run2 = True
            while self.thread_run: # 循环一直调用摄像头
                _, img_bgr = self.camera.read() # 以bgr格式读取摄像头内的截图 
                gray = cv2.cvtColor(img_bgr,cv2.COLOR_BGR2GRAY) # 灰度转换
                # 在CV官方机器学习库内加载人脸识别分类器                
                # Python\Python38-32\Lib\site-packages\cv2\data  这个目录下也有
                classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
                color = (0,255,0) # 绿色线
                # 识别器进行识别
                faceRects = classifier.detectMultiScale(gray,scaleFactor=1.2,minNeighbors=3,minSize=(32, 32))
                # 识别器返回一个列表, 里面是每个识别出的人脸的区域, 左上和右下定点的坐标
                # print(faceRects)  #[[113  42  60  60]]    前两个值是左上定点的xy坐标,第三个是width 宽度对应y的变化, 另一个就是x的
    
                # 判断识别结果集合长度
                if len(faceRects):
                    for faceRect in faceRects:
                        x,y,w,h = faceRect
                        # 用矩形框选出人脸   最后一个参数2是框线宽度
                        cv2.rectangle(img_bgr,(x, y), (x + h, y + w), color, 2)                 
                img = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB) # 颜色转换
                im = Image.fromarray(img)
                w, h = im.size
                pil_image_resized = self.resize(w, h, im) # 调整大小函数
                self.imgtk = ImageTk.PhotoImage(image=pil_image_resized)
                self.image_ctl.configure(image=self.imgtk)
            print("结束运行")
     
        def video_pic(self): # 视频截图保存及框选函数
            dir_name='./img' # 给出图片目录路径
            fileimg_list = [] # 建立列表型图片列表
            fileimg_list=os.listdir(dir_name) # 获取目录下文件名
            file_num=len(fileimg_list) # 获取列表长度
            fileimg_num=0   # 定义文件序号初始值为0
            self.thread_run2 = True     # 开启多线程
    #        predict_time = time.time() # 获得系统时间
            while self.thread_run2: # 循环读取
    #            if time.time() - predict_time > 0.1: #每0.1s读取一次摄像头截图
    #            print("正在识别中")
                _, img_bgr = self.camera.read() # 重新读取摄像头图像
                cv2.imwrite("tmp/test.jpg", img_bgr) #利用cv写入到tmp/test.jpg路径下
    #                test_pic=cv2.imread('tmp/test.jpg') # 重新读取截图
    #                pshow('识别截图',test_pic) # 显示截图
    #                
    #                # 图像路径 我用的相对路径
    #                face_mark = 'tmp/test.jpg'
    #                # 读取截图
    #                faceImg = cv2.imread(face_mark)
    #                # 转换灰色
    #                gray = cv2.cvtColor(faceImg,cv2.COLOR_RGB2GRAY) # 由于tmp/test.jpg路径下的已经转换成RGB保存 所以不用再进行BGR转换
    #
    #                # 在CV官方机器学习库内加载人脸识别分类器                
    #                # Python\Python38-32\Lib\site-packages\cv2\data  这个目录下也有
    #                classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
    #                color = (0,255,0) # 绿色线
    #
    #                # 识别器进行识别
    #                faceRects = classifier.detectMultiScale(gray,scaleFactor=1.2,minNeighbors=3,minSize=(32, 32))
    #                # 识别器返回一个列表, 里面是每个识别出的人脸的区域, 左上和右下定点的坐标
    #                # print(faceRects)  #[[113  42  60  60]]    前两个值是左上定点的xy坐标,第三个是width 宽度对应y的变化, 另一个就是x的
    #
    #                # 判断识别结果集合长度
    #                if len(faceRects):
    #                    for faceRect in faceRects:
    #                        x,y,w,h = faceRect
    #                        # 用矩形框选出人脸   最后一个参数2是框线宽度
    #                        cv2.rectangle(faceImg,(x, y), (x + h, y + w), color, 2)
    #        
    #                
    #                pshow('识别结果',faceImg)    # 输出框选结果图像并显示
    #                cv2.imwrite("tmp/test2.jpg", faceImg)
                self.pic_path = "tmp/test.jpg" # 重新读取摄像头截图
    #                self.pilImage = Image.open(self.pic_path)
    #                self.tkImage = ImageTk.PhotoImage(image=self.pilImage)
    #                self.image_ctl = tk.Label(frame0, image=self.tkImage)
    #                self.image_ctl.pack()
                try:
    
                    
                    if fileimg_num<file_num: #当文件序号小于总列表长度时
                            #print(fileimg_num)
                            #img=cv2.imread(dir_name + '/' + fileimg_list[fileimg_num])    
                            #pshow(fileimg_list[fileimg_num],img)
                        self.pic_path2 = dir_name + '/' + fileimg_list[fileimg_num] # 给出pic_path2的值为目录名+/+文件名
                            #print(self.pic_path2)
    #                        self.pic_path2='./img/111.jpg'
                        facestr, result = api_face_faster.facef(self.pic_path, self.pic_path2) # 调用api_face库的人脸识别函数
                        self.facer.configure(text=str(facestr))
                                    #self.pic() # 对摄像头图像进行尺度变换
                        if result > 80: #识别结果大于80
                            humantitle='  姓名：  '+fileimg_list[fileimg_num].partition('.')[0]+"  人脸匹配成功！  \n"
                            print(humantitle) # 输出人像文件文件名
                            tkinter.messagebox.showinfo('提示', humantitle) # tk窗口提示                          
                            try:
                                f=open("识别记录.txt","r")
                                fi=open("识别记录.txt","a")
                                txt=time.ctime()
                                fi.write(txt+humantitle)
                                f.close()
                                fi.close() # 将识别成功的记录保存在txt文件下
                            except:
                                f=open("识别记录.txt","w")
                                txt=time.ctime()
                                f.write(txt+humantitle)
                                f.close()
                                            
                                        
                                        
                                        # close_window()
                                        # os.system("python3 ./main.py")
                                    #if result < 20:
                                    #    tkinter.messagebox.showinfo('提示', '未检测到人脸！')
                            break
                        else: # 小于80失败
                            fileimg_num=fileimg_num+1 # 文件序号+1
                                    
                                
                    else: # 超出文件列表长度
                        tkinter.messagebox.showinfo('提示', '查无此人！人脸匹配失败！')
                        break
                except:
                    pass
    #                predict_time = time.time()      # 读取时间          
    #            print("识别结束")
                    
                    # 看门狗程序（调试用）
                    # 防止程序关闭时进入死循环跑飞
                    #print('请输入任意值以继续，否则请关闭窗口以终止程序：')
                    #a=input()
                    #print(a)
            pass
     
    #    def file_pic(self): #识别函数
    #        dir_name='./img'
    #        fileimg_list = []
    #        fileimg_list=os.listdir(dir_name)
    #        file_num=len(fileimg_list)
    #        fileimg_num=0   
    #        while True:
    #            if fileimg_num<file_num:
    #                print(fileimg_num)
    #                img=cv2.imread(dir_name + '/' + fileimg_list[fileimg_num])    
    #                pshow(fileimg_list[fileimg_num],img)
    #                self.pic_path2 = dir_name + '/' + fileimg_list[fileimg_num]
    #                print(self.pic_path2)
    ##                self.pic_path2='./img/111.jpg'
    #                facestr, result = api_face.facef(self.pic_path, self.pic_path2) # 调用api_face库的人脸识别函数
    #                self.facer.configure(text=str(facestr))
    #                        #self.pic() # 对摄像头图像进行尺度变换
    #                if result > 80: #识别结果大于80
    #                    tkinter.messagebox.showinfo('提示', '人脸匹配成功！') # tk窗口提示
    #                    print('人像图片路径：'+self.pic_path2) # 输出人像文件路径
    #                    try:
    #                        f=open("识别记录.txt","r")
    #                        fi=open("识别记录.txt","a")
    #                        txt=time.ctime()
    #                        fi.write(txt+'   人像图片路径：   '+self.pic_path2+"     人脸匹配成功！ \n")
    #                        f.close()
    #                        fi.close() # 将识别成功的记录保存在txt文件下
    #                    except:
    #                        f=open("识别记录.txt","w")
    #                        txt=time.ctime()
    #                        f.write(txt+'   人像图片路径：   '+self.pic_path2+"     人脸匹配成功！ \n")
    #                        f.close()
    #                                
    #                            
    #                            
    #                            # close_window()
    #                            # os.system("python3 ./main.py")
    #                        #if result < 20:
    #                        #    tkinter.messagebox.showinfo('提示', '未检测到人脸！')
    #                        break
    #                    else: # 小于80失败
    #                        fileimg_num=fileimg_num+1
    #                        
    #                    
    #            else:
    #                tkinter.messagebox.showinfo('提示', '人脸匹配失败！')
    #                break
            
            
     
    #    def pic(self): # 对摄像头图像进行尺度变换
    #        self.pilImage3 = Image.open(self.pic_path) # 用pillow读取摄像头图像
    #        w, h = self.pilImage3.size # 计算大小赋值给宽 高
    #        pil_image_resized = self.resize(w, h, self.pilImage3) # 调整大小函数
    #        self.tkImage3 = ImageTk.PhotoImage(image=pil_image_resized) 
    #        self.image_ctl.configure(image=self.tkImage3) # 输出结果
     
        def resize(self, w, h, pil_image): # 调整大小函数
            w_box = 1000 # 定义最大宽度
            h_box = 500 # 最大高度
            f1 = 1.0*w_box/w # 最大值/真实值
            f2 = 1.0*h_box/h
            factor = min([f1, f2]) # 取最小值
            width = int(w*factor) # 用最小值*对应值 调整到最大定义值 等比调整另一个值
            height = int(h*factor)
            return pil_image.resize((width, height), Image.ANTIALIAS) # 输出调整
     
     
    def close_window():
        print("已关闭人脸识别")
        if Login.thread_run:
            Login.thread_run = False
            Login.thread.join(2.0)
        log.destroy()
        
    
        
    if __name__ == '__main__':
        log = tk.Tk()
     
        login = Login(log)
        # close,退出输出destroy
        log.protocol('清除窗口', close_window)
        # 进入消息循环
        log.mainloop()

**五、最终测试**  
**1.识别成功测试**  
读取img目录下所有图像 对摄像头图像依次进行对比识别 相似度不断变化 当大于80时 输出成功提示 并获取图像名称、写入记录文档中  
如图所示，我的图像位于img目录下的第4个 列表序号为3 程序应在识别到此的时候停止  
（测试图片中为原始版本，文字提示中没有姓名，现代码已更新为包含姓名提示的版本）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 6]  
初始界面：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 7]  
点击“使用相机识别”后开始开启摄像头识别  
如图所示为识别成功结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 8]  
点击确认后终止程序  
在识别记录.txt文档中可以看到刚刚的照片名称 识别时间  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 9]  
在实际运行时 对前三个图像的相似度较低 最大只有36 成功后程序停止 不再对后面的图像进行识别  
如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 11]  
**2.识别失败功能测试**  
戴上口罩进行识别（或删掉目录下对应人物的图像） 相似度达不到80 遍历的图片都无法成功识别 最后提示失败

删除对应图像：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 12]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 13]  
戴上口罩 相似度最高只有60多 识别失败：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 14]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 15]  
**六、总结**  
参考文章链接：  
https://blog.csdn.net/weixin\_53403301/article/details/118575731  
https://blog.csdn.net/weixin\_53403301/article/details/118005313  
https://blog.csdn.net/weixin\_53403301/article/details/117464715  
主程序部分代码注释完整 基本上每一行都有说明和注释 直接看主程序代码就可以弄懂其原理  
关于树莓派的人脸识别 目前还是之前的版本（指定图像进行识别） 由于还没开学 没有硬件可以测试 所以尚未加入遍历目录下所有文件的功能进行 等加上以后 我会单独再写一篇  
树莓派效果展示图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 16]

最后 此次开源系统的百度网盘资源包：  
链接：https://pan.baidu.com/s/1oOZKc\_I3G5OdcRDpkZM7yQ  
提取码：hml1

这里是光电Mike Zhou 一位光电专业在读的网易独家签约音乐人  
歌手页面：  
https://music.163.com/\#/artist?id=12115205

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70]: /images/20220829/6a3faa4552c2463ca8ae42e7b7c697b9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 1]: /images/20220829/b723c1d5332c4678bab9a400f0812564.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 2]: /images/20220829/5afcea02c68b46b78be9512c1e98db3f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 3]: /images/20220829/3a99bababb014bb0b75a9f903e0b8527.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 4]: /images/20220829/484cec6392a64f338c747354fe0d66ba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 5]: /images/20220829/9d200973abcb42478919dedbfd7bfd10.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 6]: /images/20220829/8bd71d866184496b84ff085e4ae17d50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 7]: /images/20220829/ebe7de7368a74a9687e674b4826bf2c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 8]: /images/20220829/faabe90b98704954ac38cbde6d945dd3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 9]: /images/20220829/22489ba70ce84af081c081ebff5d311a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 10]: /images/20220829/1b83d50f71544932a5cc1da4ee6289f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 11]: /images/20220829/c69e963ff1b24bcca4d686a4a6d9b09a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 12]: /images/20220829/a6cb019e92b94599ad38775ff31bd37f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 13]: /images/20220829/276fb5529a2241b180af6a92774c5ef7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 14]: /images/20220829/0394b94a2e5a4887afbc4f60c693fc9c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 15]: /images/20220829/698899c35a474ebeb6a5062cab311d59.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzQwMzMwMQ_size_16_color_FFFFFF_t_70 16]: /images/20220829/f9b4fbe97fd34019ba7cb0f63c7a80dd.png