OpenCv之简单的人脸识别项目（动态处理页面）_opencv人脸识别项目

准备

本篇将展示动态处理页面，并与登录页面连接起来。动态处理页面分为视频处理和相机抓取两个分页面。

九、动态处理页面

1.导入所需的包

tkinter:

Tkinter是Python的标准GUI（图形用户界面）库。它提供了一个快速和简单的方式来创建GUI应用程序。tkinter模块是Tkinter库的主模块，包含了创建窗口、按钮、文本框等基本GUI组件的类和函数。

messagebox:

这个模块是tkinter的一个扩展，提供了一个对话框，允许您显示消息框、警告框、错误框等。它是tkinter的一部分，通常与tkinter一起使用来与用户进行交互。

subprocess:

这个模块允许您启动新的进程，连接到它们的输入/输出/错误管道，并获取它们的返回码。通常用于执行系统命令或运行外部程序。

ImageTk:

ImageTk是PIL库中用于与Tkinter一起使用的模块，它提供了在Tkinter中显示图像的功能。它通常与Tkinter的PhotoImage类一起使用，以在Tkinter应用程序中显示PIL的Image对象。

import tkinter as tk
from tkinter import messagebox
import subprocess
from PIL import ImageTk, Image
1
2
3
4
'
运行
运行

2.设置窗口

2.1定义窗口外观和大小

实例化窗口，设置窗口标题，尺寸。

#设置窗口
win=tk.Tk()
win.title('动态处理')
win.geometry('600x450')
1
2
3
4

2.2设置窗口背景

2.2.1设置背景图片

调用image对象的resize方法来调整图像的大小。将调整大小后的PIL Image对象转换为Tkinter兼容的PhotoImage对象。

#背景设计
image = Image.open("10.gif")
image = image.resize((600, 450))  # 调整背景图片大小
photo1 = ImageTk.PhotoImage(image)
canvas = tk.Label(win, image=photo1)
canvas.pack()
1
2
3
4
5
6

2.2.2创建label控件

Label控件可以用来显示文本、图像或其他内容。在这里，它被用来显示前面创建的PhotoImage对象，即背景图片。

canvas = tk.Label(win, image=photo1)
canvas.pack()
1
2

3.定义视频处理脚本

定义一个名为Spcl的函数，在Python中运行另一个名为 “视频处理.py” 的脚本，并在成功执行后关闭当前的Tkinter窗口 win。如果在这个过程中出现任何异常，它会弹出一个错误消息框，显示具体的错误信息。

# 定义视频处理
def Spcl():
    script_path = "视频处理.py"
    try:
        #运行文件
        subprocess.Popen(["python", script_path])
        win.destroy()
    except Exception as e:
        # 如果有错误，弹出消息框
        messagebox.showerror("Error", f"无法打开脚本：{e}")
1
2
3
4
5
6
7
8
9
10
'
运行
运行

4.定义相机抓取脚本

定义一个名为Xjzq的函数，在Python中运行另一个名为 “相机抓取.py” 的脚本，并在成功执行后关闭当前的Tkinter窗口 win。如果在这个过程中出现任何异常，它会弹出一个错误消息框，显示具体的错误信息。

# 定义相机抓取
def TWO():
    script_path = "相机抓取.py"
    try:
        #运行文件
        subprocess.Popen(["python", script_path])
        win.destroy()
    except Exception as e:
        # 如果有错误，弹出消息框
        messagebox.showerror("Error", f"无法打开脚本：{e}")
1
2
3
4
5
6
7
8
9
10
'
运行
运行

5.定义关闭窗口的函数

当用户点击一个按钮或执行其他操作以触发 close 函数时，当前的 Tkinter 窗口将

被关闭，并且一个新的 Python 进程将被启动来执行 登录页面.py 脚本。
def close():
    subprocess.Popen(["python","登录页面.py"])
    win.destroy()
1
2
3
4

用法：close函数可以用来在应用程序中创建一个简单的退出功能，或者在需要时启动新的应用程序或脚本。

6.按钮设计

6.1视频处理按钮

设计一个按钮，用于在Tkinter图形用户界面中触发人脸识别功能。当用户点击这个按钮时，会调用之前定义的 Spcl函数。

# 按钮设计
image = Image.open("F6.gif")  # 加载一张图片
photo2 = ImageTk.PhotoImage(image)
bt1 = tk.Button(win, image=photo2, width=198, height=31,command=Spcl)
bt1.place(x=190, y=130)
1
2
3
4
5

6.2相机抓取按钮

设计一个按钮，用于在Tkinter图形用户界面中触发人脸识别功能。当用户点击这个按钮时，会调用之前定义的 Xjzq函数。

image = Image.open("F7.gif")  # 加载一张图片
photo3 = ImageTk.PhotoImage(image)
bt2 = tk.Button(win, image=photo3, width=198, height=31,command=TWO)
bt2.place(x=190, y=230)
1
2
3
4

6.3返回按钮

定义一个名为 bt3的按钮，该按钮将显示一个前面导入的名为 “B.gif” 的 图像，并且当用户点击这个按钮时，会执行一个名为 sb 的函数。

image = Image.open("B.gif")  # 加载一张图片
photo4 = ImageTk.PhotoImage(image)
bt3 = tk.Button(win, image=photo4, width=198, height=32,command=close)
bt3.place(x=520, y=30)
1
2
3
4

用法：close函数通常这个函数用来关闭应用程序窗口。

7.定义关键函数

win.mainloop() 是 Tkinter GUI 应用程序中的一个关键函数，它启动了 Tkinter 的事件循环。
这个事件循环是 GUI 应用程序的核心，它负责处理用户输入（如鼠标点击、按键等），更新窗口内容，以及响应用户的操作。

win.mainloop()
1

注：当你调用 win.mainloop() 时，以下几件事情会发生：
1.窗口 win 会显示在屏幕上。
2.应用程序会开始监听和响应事件，如按钮点击、输入框文字变化等。
3.当用户进行操作（如点击按钮），Tkinter 会触发相应的事件处理函数（例如，你设置的 command 参数对应的函数）。
4.如果没有事件发生，应用程序会保持空闲状态，不会占用太多CPU资源。
5.当你关闭窗口或者调用 win.destroy() 时，win.mainloop() 会退出，事件循环结束，应用程序终止。

8.动态处理页面运行结果图

动态处理页面完整代码

import tkinter as tk
from tkinter import messagebox
import subprocess
from PIL import ImageTk, Image



#设置窗口
win=tk.Tk()
win.title('动态处理')
win.geometry('600x450')


#背景设计
image = Image.open("10.gif")
image = image.resize((600, 450))  # 调整背景图片大小
photo1 = ImageTk.PhotoImage(image)
canvas = tk.Label(win, image=photo1)
canvas.pack()

#定义视频处理
def Spcl():
    script_path = "视频处理.py"
    try:
        #运行文件
        subprocess.Popen(["python", script_path])
        win.destroy()
    except Exception as e:
        # 如果有错误，弹出消息框
        messagebox.showerror("Error", f"无法打开脚本：{e}")

#定义相机抓取
def Xjzq():
    script_path = "相机抓取.py"
    try:
        # 运行文件
        subprocess.Popen(["python", script_path])
        win.destroy()
    except Exception as e:
        # 如果有错误，弹出消息框
        messagebox.showerror("Error", f"无法打开脚本：{e}")

def close():
    subprocess.Popen(["python","登录页面.py"])
    win.destroy()

#按钮、
image = Image.open("F6.gif")  # 加载一张图片
photo2 = ImageTk.PhotoImage(image)
bt1 = tk.Button(win, image=photo2, width=198, height=32,command=Spcl)
bt1.place(x=190, y=130)

image = Image.open("F7.gif")  # 加载一张图片
photo3 = ImageTk.PhotoImage(image)
bt2 = tk.Button(win, image=photo3, width=198, height=32,command=Xjzq)
bt2.place(x=190, y=230)

image = Image.open("B.gif")  # 加载一张图片
photo4 = ImageTk.PhotoImage(image)
bt3 = tk.Button(win, image=photo4, width=198, height=32,command=close)
bt3.place(x=190, y=330)


win.mainloop()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

十、视频处理页面

1.导入所需的包

cv2 (OpenCV):

OpenCV是一个开源的计算机视觉库，它提供了大量用于图像和视频处理的功能。cv2模块是OpenCV的Python接口，它允许您在Python中使用OpenCV的功能。OpenCV广泛用于图像识别、图像处理、物体检测、视频分析等任务。

tkinter:

Tkinter是Python的标准GUI（图形用户界面）库。它提供了一个快速和简单的方式来创建GUI应用程序。tkinter模块是Tkinter库的主模块，包含了创建窗口、按钮、文本框等基本GUI组件的类和函数。

filedialog:

这个模块是tkinter的一个扩展，提供了一个文件对话框，允许用户选择文件或目录。它是tkinter的一部分，通常与tkinter一起使用来创建文件选择器。

face_recognition:

这个模块是一个Python库，用于对人脸进行识别和对图片中的人脸进行定位。它使用深度学习算法来识别人脸，并且可以处理实时视频或静态图片。

os:

os模块提供了与操作系统交互的功能。它提供了用于文件和目录操作的函数，如文件读写、目录遍历、文件路径处理等。

subprocess:

这个模块允许您启动新的进程，连接到它们的输入/输出/错误管道，并获取它们的返回码。通常用于执行系统命令或运行外部程序。

PIL (Python Imaging Library):

PIL是一个强大的图像处理库，它支持多种图像文件格式，并提供了一系列图像处理功能，如打开、修改、保存图像，以及图像处理操作（如缩放、裁剪、颜色转换等）。

import cv2
import tkinter as tk
from tkinter import filedialog
import face_recognition
import os
import subprocess
from PIL import Image, ImageTk
1
2
3
4
5
6
7

2.设置窗口

2.1定义窗口外观和大小

实例化窗口，设置窗口标题，尺寸。
#设置窗口

win=tk.Tk()
win.title('Welocome')
win.geometry('750x600')
1
2
3

2.2设置窗口背景

2.2.1设置背景图片

调用image对象的resize方法来调整图像的大小。将调整大小后的PIL Image对象转换为Tkinter兼容的PhotoImage对象。

#背景设计
image = Image.open("12.gif")
image = image.resize((750, 600))  # 调整背景图片大小
photo1 = ImageTk.PhotoImage(image)
canvas = tk.Label(win, image=photo1)
canvas.pack()
1
2
3
4
5
6

2.2.2创建label控件

Label控件可以用来显示文本、图像或其他内容。在这里，它被用来显示前面创建的PhotoImage对象，即背景图片。

canvas = tk.Label(win, image=photo1)
canvas.pack()
1
2

3.定义全局变量

用了None来初始化它们，这意味着在程序开始时，它们不指向任何具体的文件路径、组件对象或检测结果。在实际的应用程序中，您会通过用户的操作或程序的逻辑来更新这些变量，以便它们能够存储视频文件的路径、显示视频内容以及存储人脸检测结果。

# 定义一个全局变量来保存视频路径
save_video = None
canvas = None
face_dir = None
1
2
3
4
'
运行
运行

用法：
save_video:
这个变量被用来保存用户选择的视频文件的路径。在视频处理或显示视频的应用程序中，您可能需要存储用户选择的视频文件的路径，以便之后进行操作，如加载、显示或处理视频。

canvas:
这个变量通常用于在Tkinter应用程序中显示视频。在Tkinter中，Canvas组件可以用来绘制图形和文本，以及放置其他组件。在这个上下文中，canvas可能被用来引用一个Canvas组件，该组件被配置为显示视频。

face_dir:
这个变量通常用于存储与视频相关的人脸检测结果。在视频处理和分析的应用程序中，您可能需要存储检测到的人脸的位置或属性，以便后续分析和处理。

4.定义选择视频并自动识别人脸函数

让用户通过文件对话框选择一个视频文件，然后将这个视频文件的路径保存到全局变量 save_video 中，并调用 sb_video 函数来处理这个视频文件。

# 选择视频并自动识别人脸
def xz_video():
    global save_video
    file_path = filedialog.askopenfilename(title="选择视频",
                                           filetypes=(("视频文件", "*.mp4;*.avi;*.mkv;*.mov"),
                                                      ("所有文件", "*.*")))
    if file_path:
        save_video = file_path
        sb_video()
1
2
3
4
5
6
7
8
9
'
运行
运行

5.定义识别人脸函数

5.1 函数定义和全局变量声明

定义一个名为 sb_video 的函数，并在函数内部声明了三个全局变量 save_video、canvas 和 face_dir。这意味着函数内部对这些变量的修改将会影响函数外部的同名变量。

# 识别视频并在Canvas上显示
def sb_video():
    global save_video, canvas, face_dir
1
2
3
'
运行
运行

5.2 条件判断和文件夹创建

首先检查 save_video 是否有值，如果有，则定义 face_dir 为 ‘video_image’。然后，它检查这个文件夹是否存在。如果不存在，它会创建这个文件夹。

if save_video:
    # 创建保存人脸的文件夹
    if not face_dir:
        face_dir = 'video_image'
        if not os.path.exists(face_dir):
            os.makedirs(face_dir)
1
2
3
4
5
6

5.3 加载视频和初始化Canvas

使用 OpenCV 库的 VideoCapture 函数加载 save_video 指定的视频文件。然后，它创建了一个 Canvas 组件，用于显示视频帧。

# 加载视频
video_capture = cv2.VideoCapture(save_video)

# 初始化Canvas
canvas = tk.Canvas(win, width=640, height=480)
canvas.place(x=80,y=180)
1
2
3
4
5
6

5.4 视频处理循环

这部分代码包含在一个 try 和 finally 块中，确保在视频处理过程中出现任何异常时能够正确释放视频。
在循环中，它逐帧读取视频，并转换颜色从BGR到RGB。然后，它使用 face_recognition 库来查找图像中的人脸位置，并在每个检测到的人脸周围画框。接着，它裁剪人脸并保存到 face_dir 指定的文件夹中。
它还使用 PIL 库将OpenCV图像格式转换为PIL图像格式，并使用 ImageTk 将其转换为Tkinter可以显示的格式。最后，它将图像显示在 canvas 上，并更新Tkinter窗口。
如果用户按下 ‘q’ 键，循环会提前终止。

try:
    # 初始化变量
    face_count = 0

    while True:
        # 抓取一帧视频
        ret, frame = video_capture.read()
        if not ret:
            break

        # 转换颜色从BGR到RGB
        rgb_frame = frame[:, :, ::-1]

        # 查找图像中的人脸位置
        face_locations = face_recognition.face_locations(rgb_frame)

        # 在每个检测到的人脸周围画框
        for top, right, bottom, left in face_locations:
            cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)

            # 裁剪人脸并保存
            face_image = frame[top:bottom, left:right]
            face_path = os.path.join(face_dir, f'face_{face_count}.jpg')
            cv2.imwrite(face_path, face_image)
            face_count += 1

        # 转换OpenCV图像格式到PIL图像格式
        pil_image = Image.fromarray(frame[:, :, ::-1])
        photo = ImageTk.PhotoImage(image=pil_image)

        # 在Canvas上显示图像
        canvas.create_image(0, 0, anchor=tk.NW, image=photo)
        win.update_idletasks()
        win.update()

        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

5.5 释放视频和清理资源

确保在处理完视频后，视频捕获对象被正确释放，释放所有分配的资源。
finally:

    # 释放视频
video_capture.release()
1
2

6.定义打开人脸文件夹的函数

检查是否存在一个名为 face_dir 的文件夹，并如果存在，则打开这个文件夹。这个函数通常会在应用程序中用于允许用户查看和浏览检测到的人脸图像。

def open_face():
    if face_dir and os.path.exists(face_dir):
        os.startfile(face_dir)
1
2
3
'
运行
运行

7.定义关闭窗口的函数

当用户点击一个按钮或执行其他操作以触发 close 函数时，当前的 Tkinter 窗口将被关闭，并且一个新的 Python 进程将被启动来执行 登录页面.py 脚本。

def close():
    subprocess.Popen(["python","动态页面.py"])
    win.destroy()
1
2
3
'
运行
运行

用法：close函数可以用来在应用程序中创建一个简单的退出功能，或者在需要时启动新的应用程序或脚本。

8.按钮设计

8.1选择视频按钮

定义一个名为 bt1 的按钮，该按钮将显示一个前面导入的名为 “F8…gif” 的 图像，并且当用户点击这个按钮时，会执行一个名为 xz_video 的函数。

image = Image.open("F8.gif")  # 加载一张图片
photo2 = ImageTk.PhotoImage(image)
bt1 = tk.Button(win, image=photo2, width=198, height=32,command=xz_video)
bt1.place(x=30, y=30)
1
2
3
4

8.2打开文件夹按钮

定义一个名为 bt2 的按钮，该按钮将显示一个前面导入的名为 “F9.gif” 的 图像，并且当用户点击这个按钮时，会执行一个名为 open_face的函数。

image = Image.open("F1.gif")  # 加载一张图片
photo3 = ImageTk.PhotoImage(image)
bt2 = tk.Button(win, image=photo3, width=198, height=32,command=open_face)
bt2.place(x=275, y=30)
1
2
3
4

8.3返回按钮

定义一个名为 bt3的按钮，该按钮将显示一个前面导入的名为 “B.gif” 的 图像，并且当用户点击这个按钮时，会执行一个名为 close的函数。

image = Image.open("B.gif")  # 加载一张图片
photo4 = ImageTk.PhotoImage(image)
bt3 = tk.Button(win, image=photo4, width=198, height=32,command=close)
bt3.place(x=520, y=30)
1
2
3
4

用法：close函数通常这个函数用来关闭应用程序窗口。

9.定义关键函数

win.mainloop() 是 Tkinter GUI 应用程序中的一个关键函数，它启动了 Tkinter 的事件循环。
这个事件循环是 GUI 应用程序的核心，它负责处理用户输入（如鼠标点击、按键等），更新窗口内容，以及响应用户的操作。

win.mainloop()
1

注：当你调用 win.mainloop() 时，以下几件事情会发生：
1.窗口 win 会显示在屏幕上。
2.应用程序会开始监听和响应事件，如按钮点击、输入框文字变化等。
3.当用户进行操作（如点击按钮），Tkinter 会触发相应的事件处理函数（例如，你设置的 command 参数对应的函数）。
4.如果没有事件发生，应用程序会保持空闲状态，不会占用太多CPU资源。
5.当你关闭窗口或者调用 win.destroy() 时，win.mainloop() 会退出，事件循环结束，应用程序终止。

10. 视频处理页面运行结果图

11.视频处理页面功能展示图

视频处理页面完整代码

import cv2
import tkinter as tk
from tkinter import filedialog
import face_recognition
import os
import subprocess
from PIL import Image, ImageTk

win = tk.Tk()
win.title('Welcome')
win.geometry('750x600')

# 背景设计
image = Image.open("12.gif")
image = image.resize((750, 600))  # 调整背景图片大小
photo1 = ImageTk.PhotoImage(image)
canvas = tk.Label(win, image=photo1)
canvas.pack()

# 定义一个全局变量来保存视频路径
save_video = None
canvas = None
face_dir = None

# 选择视频并自动识别人脸
def xz_video():
    global save_video
    file_path = filedialog.askopenfilename(title="选择视频",
                                           filetypes=(("视频文件", "*.mp4;*.avi;*.mkv;*.mov"),
                                                      ("所有文件", "*.*")))
    if file_path:
        save_video = file_path
        sb_video()

# 识别视频并在Canvas上显示
def sb_video():
    global save_video, canvas, face_dir
    if save_video:
        # 创建保存人脸的文件夹
        if not face_dir:
            face_dir = 'video_image'
            if not os.path.exists(face_dir):
                os.makedirs(face_dir)

        # 加载视频
        video_capture = cv2.VideoCapture(save_video)

        # 初始化Canvas
        canvas = tk.Canvas(win, width=640, height=480)
        canvas.place(x=80,y=180)

        try:
            # 初始化变量
            face_count = 0

            while True:
                # 抓取一帧视频
                ret, frame = video_capture.read()
                if not ret:
                    break

                # 转换颜色从BGR到RGB
                rgb_frame = frame[:, :, ::-1]

                # 查找图像中的人脸位置
                face_locations = face_recognition.face_locations(rgb_frame)

                # 在每个检测到的人脸周围画框
                for top, right, bottom, left in face_locations:
                    cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)

                    # 裁剪人脸并保存
                    face_image = frame[top:bottom, left:right]
                    face_path = os.path.join(face_dir, f'face_{face_count}.jpg')
                    cv2.imwrite(face_path, face_image)
                    face_count += 1

                # 转换OpenCV图像格式到PIL图像格式
                pil_image = Image.fromarray(frame[:, :, ::-1])
                photo = ImageTk.PhotoImage(image=pil_image)

                # 在Canvas上显示图像
                canvas.create_image(0, 0, anchor=tk.NW, image=photo)
                win.update_idletasks()
                win.update()

                if cv2.waitKey(1) & 0xFF == ord('q'):
                    break
        finally:
            # 释放视频
            video_capture.release()

def open_face():
    if face_dir and os.path.exists(face_dir):
        os.startfile(face_dir)

def close():
    subprocess.Popen(["python", "动态处理.py"])
    win.destroy()

#按钮设计
image = Image.open("F8.gif")  # 加载一张图片
photo2 = ImageTk.PhotoImage(image)
bt1 = tk.Button(win, image=photo2, width=198, height=32,command=xz_video)
bt1.place(x=30, y=30)

image = Image.open("F9.gif")  # 加载一张图片
photo3 = ImageTk.PhotoImage(image)
bt2 = tk.Button(win, image=photo3, width=198, height=32,command=open_face)
bt2.place(x=275, y=30)

image = Image.open("B.gif")  # 加载一张图片
photo4 = ImageTk.PhotoImage(image)
bt3 = tk.Button(win, image=photo4, width=198, height=32,command=close)
bt3.place(x=520, y=30)

win.mainloop()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

十一、相机抓取页面

1.导入所需的包

cv2 (OpenCV):

OpenCV是一个开源的计算机视觉库，它提供了大量用于图像和视频处理的功能。cv2模块是OpenCV的Python接口，它允许您在Python中使用OpenCV的功能。OpenCV广泛用于图像识别、图像处理、物体检测、视频分析等任务。

tkinter:

Tkinter是Python的标准GUI（图形用户界面）库。它提供了一个快速和简单的方式来创建GUI应用程序。tkinter模块是Tkinter库的主模块，包含了创建窗口、按钮、文本框等基本GUI组件的类和函数。

filedialog:

这个模块是tkinter的一个扩展，提供了一个文件对话框，允许用户选择文件或目录。它是tkinter的一部分，通常与tkinter一起使用来创建文件选择器。

face_recognition:

这个模块是一个Python库，用于对人脸进行识别和对图片中的人脸进行定位。它使用深度学习算法来识别人脸，并且可以处理实时视频或静态图片。

os:

os模块提供了与操作系统交互的功能。它提供了用于文件和目录操作的函数，如文件读写、目录遍历、文件路径处理等。

subprocess:

这个模块允许您启动新的进程，连接到它们的输入/输出/错误管道，并获取它们的返回码。通常用于执行系统命令或运行外部程序。

PIL (Python Imaging Library):

PIL是一个强大的图像处理库，它支持多种图像文件格式，并提供了一系列图像处理功能，如打开、修改、保存图像，以及图像处理操作（如缩放、裁剪、颜色转换等）。

import cv2
import os
import tkinter as tk
from tkinter import filedialog
import subprocess
from PIL import Image, ImageTk
1
2
3
4
5
6

2.设置窗口

2.1定义窗口外观和大小

实例化窗口，设置窗口标题，尺寸。

#设置窗口
win=tk.Tk()
win.title('相机抓取')
win.geometry('750x600')
1
2
3
4

2.2设置窗口背景

2.2.1设置背景图片

调用image对象的resize方法来调整图像的大小。将调整大小后的PIL Image对象转换为Tkinter兼容的PhotoImage对象。

#背景设计
image = Image.open("12.gif")
image = image.resize((750, 600))  # 调整背景图片大小
photo1 = ImageTk.PhotoImage(image)
canvas = tk.Label(win, image=photo1)
canvas.pack()
1
2
3
4
5
6

2.2.2创建label控件

Label控件可以用来显示文本、图像或其他内容。在这里，它被用来显示前面创建的PhotoImage对象，即背景图片。

canvas = tk.Label(win, image=photo1)
canvas.pack()
1
2

3.定义全局变量存储文件夹

使用了 None 来初始化它们，这意味着在程序开始时，它们不指向任何具体的文件路径。在实际的应用程序中，您会通过用户的操作或程序的逻辑来更新这些变量，以便它们能够存储图像文件的路径和检测到的人脸图像的路径。
接下来，代码检查这两个文件夹是否已经存在。如果不存在，它会使用 os 模块的 makedirs 函数来创建这些文件夹。os.makedirs 函数会创建指定的文件夹路径，包括所有必要的父文件夹。

# 创建一个文件夹来保存图像，如果文件夹不存在的话
save_images = 'tq_faces'
save_faces = 'tq_faces'
if not os.path.exists(save_images):
    os.makedirs(save_images)
if not os.path.exists(save_faces):
    os.makedirs(save_faces)
1
2
3
4
5
6
7

用法：
save_images:
这个变量被用来保存图像的文件夹路径。在图像处理或显示图像的应用程序中，您可能需要存储用户选择的图像文件的路径，以便之后进行操作，如加载、显示或处理图像。
save_faces:
这个变量被用来保存检测到的人脸图像的文件夹路径。在图像处理和分析的应用程序中，您可能需要存储检测到的人脸的位置或属性，以便后续分析和处理。

4.创建一个实时视频流

4.1加载 Haar 级联分类器

使用 OpenCV 的 CascadeClassifier 函数加载了一个预先训练的人脸检测模型。

# 加载Haar级联分类器用于人脸检测
faceCascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
1
2

4.2打开摄像头

cap 是一个视频捕获对象，它允许您读取摄像头捕获的帧。

# 打开摄像头（0表示默认摄像头，如果有多个摄像头，可以使用不同的编号）
cap = cv2.VideoCapture(0)
1
2

5.定义使用摄像头捕获视频帧的函数

5.1函数定义和初始化

定义了一个名为 xzsp 的函数，并在函数内部初始化了一个帧计数器 frame_count。然后，它进入一个无限循环，用于捕获和处理摄像头捕获的帧。

def xzsp():
    frame_count = 0  # 初始化帧计数器
    while True:
        # 从摄像头中读取一帧图像
        ret, image = cap.read()
1
2
3
4
5
'
运行
运行

说明：ret 是一个布尔值，表示是否成功读取了帧。如果成功，image 将包含摄像头捕获的帧。

5.2处理摄像头帧

首先将捕获的图像进行水平翻转，因为通常摄像头捕捉到的图像是镜像的。然后，它检查是否成功读取了图像。如果未成功读取图像，可能是由于摄像头故障或未连接，此时循环会提前终止。

# 水平翻转图像，因为通常摄像头捕捉到的图像是镜像的
image = cv2.flip(image, 1)

# 如果无法读取图像（可能是摄像头故障或摄像头未连接），则退出循环
if not ret:
    break
1
2
3
4
5
6

5.3转换图像颜色和检测人脸

将摄像头捕获的图像转换为灰度图像，以便进行人脸检测。然后，它使用 faceCascade 对象（之前在函数外部定义的Haar级联分类器）来检测灰度图像中的人脸。detectMultiScale 函数返回一个包含所有检测到的人脸的边界框的列表。

# 将图像转换为灰度图像，以便进行人脸检测
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)


# 使用Haar级联分类器检测灰度图像中的人脸
faces = faceCascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
1
2
3
4
5
6

5.4处理检测到的人脸

遍历检测到的人脸，并在原始图像上绘制矩形框来标记这些人脸。它还提取每个检测到的人脸，并将其保存到指定的文件夹中。

# 遍历检测到的人脸
for (x, y, w, h) in faces:
    # 在图像上绘制矩形框来标记检测到的人脸，颜色为绿色，线宽为2
    cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)

    # 提取人脸图像并保存到文件夹
    face_img = image[y:y+h, x:x+w]
    if face_img.any():  # 检查人脸图像是否为空
        face_save_path = f"{save_faces}/face_{frame_count}.jpg"
        cv2.imwrite(face_save_path, face_img)
1
2
3
4
5
6
7
8
9
10

5.5保存整个图像和显示处理后的图像

保存整个图像到指定的文件夹中，并在一个名为 ‘rljc’ 的窗口中显示带有人脸标记的图像。

# 保存整个图像到文件夹
save_path = f"{save_images}/frame_{frame_count}.jpg"
cv2.imwrite(save_path, image)
frame_count += 1  # 帧计数器增加

# 显示带有人脸标记的图像
cv2.imshow('rljc', image)
1
2
3
4
5
6
7

5.6等待用户操作和退出循环

等待用户操作，如按下键盘上的Esc键（ASCII码为27），并检查是否按下了Esc键。如果按下，循环会提前终止。

# 等待10毫秒，同时检查是否按下了键盘上的Esc键（ASCII码为27）
key = cv2.waitKey(10)

# 如果按下了Esc键，则退出循环
if key == 27:
    break
1
2
3
4
5
6

5.7释放摄像头资源和关闭窗口

释放摄像头资源，并关闭所有打开的图像窗口。

# 释放摄像头资源
cap.release()

# 关闭所有打开的图像窗口
cv2.destroyAllWindows()
1
2
3
4
5

6.定义选择文件夹的函数

用 os 模块的 startfile 函数来打开这个文件夹。

def xzwj():
    folder_path = filedialog.askopenfilename(title="选择文件")

    if os.path.exists(folder_path):  # 检查文件夹路径是否存在
        os.startfile
1
2
3
4
5
'
运行
运行

7.定义关闭窗口的函数

当用户点击一个按钮或执行其他操作以触发 close 函数时，当前的 Tkinter 窗口将被关闭，并且一个新的 Python 进程将被启动来执行 登录页面.py 脚本。

def close():
    subprocess.Popen(["python","动态页面.py"])
    win.destroy()
1
2
3
'
运行
运行

用法：close函数可以用来在应用程序中创建一个简单的退出功能，或者在需要时启动新的应用程序或脚本。

8.按钮设计

8.1打开相机按钮

定义一个名为 bt1 的按钮，该按钮将显示一个前面导入的名为 “F10…gif” 的 图像，并且当用户点击这个按钮时，会执行一个名为 xzsp的函数。

image = Image.open("F10.gif")  # 加载一张图片
photo2 = ImageTk.PhotoImage(image)
bt1 = tk.Button(win, image=photo2, width=198, height=32,command=xzsp)
bt1.place(x=30, y=30)
1
2
3
4

8.2打开文件夹按钮

定义一个名为 bt2 的按钮，该按钮将显示一个前面导入的名为 “F9.gif” 的 图像，并且当用户点击这个按钮时，会执行一个名为 xzwj的函数。

image = Image.open("F9.gif")  # 加载一张图片
photo3 = ImageTk.PhotoImage(image)
bt2 = tk.Button(win, image=photo3, width=198, height=32,command=xzwj)
bt2.place(x=275, y=30)
1
2
3
4

8.3返回按钮

定义一个名为 bt3的按钮，该按钮将显示一个前面导入的名为 “B.gif” 的 图像，并且当用户点击这个按钮时，会执行一个名为 close的函数。

image = Image.open("B.gif")  # 加载一张图片
photo4 = ImageTk.PhotoImage(image)
bt3 = tk.Button(win, image=photo4, width=198, height=32,command=close)
bt3.place(x=520, y=30)
1
2
3
4

用法：close函数通常这个函数用来关闭应用程序窗口。

10.定义关键函数

win.mainloop() 是 Tkinter GUI 应用程序中的一个关键函数，它启动了 Tkinter 的事件循环。
这个事件循环是 GUI 应用程序的核心，它负责处理用户输入（如鼠标点击、按键等），更新窗口内容，以及响应用户的操作。

win.mainloop()
1

注：当你调用 win.mainloop() 时，以下几件事情会发生：
1.窗口 win 会显示在屏幕上。
2.应用程序会开始监听和响应事件，如按钮点击、输入框文字变化等。
3.当用户进行操作（如点击按钮），Tkinter 会触发相应的事件处理函数（例如，你设置的 command 参数对应的函数）。
4.如果没有事件发生，应用程序会保持空闲状态，不会占用太多CPU资源。
5.当你关闭窗口或者调用 win.destroy() 时，win.mainloop() 会退出，事件循环结束，应用程序终止。

11. 相机抓取页面运行结果图

11.相机抓取功能展示结果图

相机抓取页面完整代码

import cv2
import os
import tkinter as tk
from tkinter import filedialog
import subprocess
from PIL import Image, ImageTk

# 初始化Tkinter窗口
win = tk.Tk()
win.title('相机抓取')
win.geometry('750x600')

# 背景设计
image = Image.open("11.gif")
image = image.resize((750, 600))  # 调整背景图片大小
photo1 = ImageTk.PhotoImage(image)
canvas = tk.Label(win, image=photo1)
canvas.pack()

# 创建一个文件夹来保存图像，如果文件夹不存在的话
save_images = 'tq_faces'
save_faces = 'tq_faces'
if not os.path.exists(save_images):
    os.makedirs(save_images)
if not os.path.exists(save_faces):
    os.makedirs(save_faces)

# 加载Haar级联分类器用于人脸检测
faceCascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

# 打开摄像头（0表示默认摄像头，如果有多个摄像头，可以使用不同的编号）
cap = cv2.VideoCapture(0)

def xzsp():
    frame_count = 0  # 初始化帧计数器
    while True:
        # 从摄像头中读取一帧图像
        ret, image = cap.read()

        # 水平翻转图像，因为通常摄像头捕捉到的图像是镜像的
        image = cv2.flip(image, 1)

        # 如果无法读取图像（可能是摄像头故障或摄像头未连接），则退出循环
        if not ret:
            break

        # 将图像转换为灰度图像，以便进行人脸检测
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

        # 使用Haar级联分类器检测灰度图像中的人脸
        faces = faceCascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

        # 遍历检测到的人脸
        for (x, y, w, h) in faces:
            # 在图像上绘制矩形框来标记检测到的人脸，颜色为绿色，线宽为2
            cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)

            # 提取人脸图像并保存到文件夹
            face_img = image[y:y+h, x:x+w]
            if face_img.any():  # 检查人脸图像是否为空
                face_save_path = f"{save_faces}/face_{frame_count}.jpg"
                cv2.imwrite(face_save_path, face_img)

        # 保存整个图像到文件夹
        save_path = f"{save_images}/frame_{frame_count}.jpg"
        cv2.imwrite(save_path, image)
        frame_count += 1  # 帧计数器增加

        # 显示带有人脸标记的图像
        cv2.imshow('rljc', image)

        # 等待10毫秒，同时检查是否按下了键盘上的Esc键（ASCII码为27）
        key = cv2.waitKey(10)

        # 如果按下了Esc键，则退出循环
        if key == 27:
            break

    # 释放摄像头资源
    cap.release()

    # 关闭所有打开的图像窗口
    cv2.destroyAllWindows()

def xzwj():
    folder_path = filedialog.askopenfilename(title="选择文件")

    if os.path.exists(folder_path):  # 检查文件夹路径是否存在
        os.startfile

def close():
    subprocess.Popen(["python", "动态处理.py"])
    win.destroy()

#按钮设计
image = Image.open("F10.gif")  # 加载一张图片
photo2 = ImageTk.PhotoImage(image)
bt1 = tk.Button(win, image=photo2, width=198, height=32, command=xzsp)
bt1.place(x=210, y=130)

image = Image.open("F9.gif")  # 加载一张图片
photo3 = ImageTk.PhotoImage(image)
bt2 = tk.Button(win, image=photo3, width=198, height=32, command=xzwj)
bt2.place(x=310, y=230)

image = Image.open("B.gif")  # 加载一张图片
photo4 = ImageTk.PhotoImage(image)
bt3 = tk.Button(win, image=photo4, width=198, height=32, command=close)
bt3.place(x=440, y=330)

win.mainloop()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112