• 闭眼检测实现

    引言

            这段代码是一个实时眼睛状态监测程序，可以用于监测摄像头捕获的人脸图像中的眼睛状态，判断眼睛是否闭合。具体应用实现作用说明如下：

    1. 实时监测眼睛状态
       通过摄像头捕获的实时视频流，检测人脸关键点并计算眼睛的 EAR，实时判断眼睛是否闭合。

    2. 闭眼警报
       当程序检测到用户闭眼时，通过在图像上显示 "Eyes Closed" 的文本和相应的标志，发出闭眼警报。

    3. 可视化眼睛区域：
       通过在图像上绘制眼睛区域的多边形线段，直观地展示程序检测到的眼睛的位置。

    4. 实时图像显示：
       将处理后的图像实时显示在窗口中，使用户能够实时观察眼睛状态的监测结果。

    5. 交互式退出：
       用户可以通过按下键盘上的 Esc 键来退出程序，实现交互式控制。

    啊啊啊啊啊啊那有那些应用场景呢？^_^

    具体应用场景：

    - 驾驶员状态监测：
              在汽车驾驶过程中，监测驾驶员的眼睛状态，及时发现驾驶员是否疲劳或注意力不集中。

    - 睡眠监测：
              用于睡眠监测系统，检测用户在睡眠时的眼睛状态，可能用于分析睡眠质量。

    - 用户注意力监测：
              在用户界面交互系统中，监测用户的眼睛状态，判断用户是否在关注屏幕。

    - 医疗应用：
              在医疗领域中，监测患者的眼睛状态，特别是在眼科医疗中可能会有一些应用。

    注意：
            这段代码的精度和稳定性可能受多方面因素影响，如光照条件、摄像头质量等。在实际应用中，可能需要进一步优化和调整参数，以适应不同场景和需求。

    1.依赖组件：

            这段代码使用了以下几个主要的组件和库：

    1. OpenCV (cv2): OpenCV 是一个计算机视觉库，用于图像和视频处理。在这里，它被用于打开摄像头、转换图像格式、进行图像处理以及显示图像。

    2. Dlib: Dlib 是一个包含用于机器学习、计算机视觉和图像处理的工具的 C++ 库。在这里，它的 Python 接口被用于进行人脸检测和关键点检测。

    3. NumPy: NumPy 是一个用于科学计算的 Python 库，提供了对多维数组的支持。在这里，NumPy 用于处理数组和数学计算。

    4. SciPy: SciPy 是一个用于科学计算的 Python 库，提供了在 NumPy 基础上构建的更多高级功能。在这里，SciPy 的 `distance` 模块被用于计算欧氏距离。

            这些库的组合使得这段代码能够实现从摄像头中检测人脸，提取关键点，并通过计算眼睛的纵横比 (EAR) 判断眼睛是否闭上。如果您有关于这些库的具体问题，或者希望了解它们的更多细节，请随时提问。

    2.欧氏距离

            因为涉及到了欧氏距离这个数学知识，所以我还是介绍一下，以免大家懵了

            欧式距离（Euclidean Distance）是欧几里德空间中两点之间的直线距离。对于二维空间中的两个点(x1,y1) 和 (x2,y2)，它们之间的欧式距离 d 可以通过以下公式计算：

    d = \sqrt{(x1 - x2)^{2} + (y1 - y2)^{2}}

            这个公式基于勾股定理，即直角三角形的斜边长度等于两条直角边长度的平方和的平方根。

            在计算机视觉和图像处理中，欧式距离常用于测量两个点之间的空间距离，或者两个向量之间的相似度。在这里，代码中可能使用了欧式距离来计算眼睛的宽度和高度，从而进行进一步的眼睛状态判断。

    3.计算眼睛的横纵比

    1. # 计算眼睛的纵横比 (EAR)
    2. def calculate_ear(eye):
    3.     # 计算垂直方向的欧氏距离
    4.     vertical_1 = distance.euclidean(eye[1], eye[5])
    5.     vertical_2 = distance.euclidean(eye[2], eye[4])
    6.  
    7.     # 计算水平方向的欧氏距离
    8.     horizontal = distance.euclidean(eye[0], eye[3])
    9.  
    10.     # 计算纵横比
    11.     ear = (vertical_1 + vertical_2) / (2.0 * horizontal)
    12.     return ear

            在眼睛特征点的标记中，通常使用一个包含多个关键点的列表或数组表示眼睛的形状。这些关键点的索引通常按照特定的顺序排列，以表示眼睛的不同部位。

            在计算眼睛的 EAR 时，eye[x] 中的 x 是眼睛特征点列表中的索引值，代表了不同的关键点。具体的含义取决于你使用的眼睛特征点标记方案，但一般而言，这些关键点通常按照眼睛的周围轮廓从左上角开始，按逆时针方向标记。

    常见的眼睛特征点标记包括：

    - eye[0]：眼睛的左侧，水平中心
    - eye[1]：眼睛的上边缘，左侧
    - eye[2]：眼睛的上边缘，右侧
    - eye[3]：眼睛的右侧，水平中心
    - eye[4]：眼睛的下边缘，右侧
    - eye[5]：眼睛的下边缘，左侧

    请注意，具体的标记方案可能会因使用的数据集或库而有所不同。

    4.加载 Dlib 的人脸检测器和关键点检测器

    1. # 加载 Dlib 的人脸检测器和关键点检测器
    2. detector = dlib.get_frontal_face_detector()
    3. predictor = dlib.shape_predictor("D:\\Study\\PythonStudy\\people_68_face\\shape_predictor_68_face_landmarks.dat")

            1. dlib.get_frontal_face_detector(): 这是 Dlib 库提供的一个人脸检测器，用于检测图像中的人脸。get_frontal_face_detector() 返回一个人脸检测器对象，可以用于在图像中找到人脸的位置。

            2.dlib.shape_predictor("D:people_68_face\\shape_predictor_68_face_landmarks.dat文件路径"): 这是 Dlib 提供的关键点检测器，用于检测人脸的关键点，通常是面部的特定位置，如眼睛、鼻子、嘴巴等。shape_predictor 对象需要一个训练好的模型文件，该文件包含了在训练过程中学到的关键点位置的信息。在这里，模型文件的路径是指定的 shape_predictor_68_face_landmarks.dat 文件。

            这两个检测器的结合通常用于在图像中检测人脸并找到人脸的关键点位置，为后续的任务（如眼睛状态检测）提供基础。

            这个文件我已经上传

    5.获取左右眼的索引

    1. # 获取左右眼的索引
    2. (left_eye_start, left_eye_end) = (42, 48)
    3. (right_eye_start, right_eye_end) = (36, 42)

            这部分代码定义了左眼和右眼在检测到的人脸关键点中的索引范围。

    - left_eye_start 和 left_eye_end 分别表示左眼的起始索引和结束索引。在人脸的 68 个关键点中，左眼的关键点通常是从索引 42 开始，到索引 48 结束。

    - right_eye_start 和 right_eye_end 分别表示右眼的起始索引和结束索引。在人脸的 68 个关键点中，右眼的关键点通常是从索引 36 开始，到索引 42 结束。

            这些索引范围用于从检测到的人脸关键点中提取左眼和右眼的具体位置信息，以便后续进行眼睛状态的检测。

    6.获取两只眼睛的关键点索引
     

    1. # 获取两只眼睛的关键点索引
    2. (left_eye_indices, right_eye_indices) = (
    3. list(range(left_eye_start, left_eye_end)), list(range(right_eye_start, right_eye_end)))

            这部分代码用于创建包含左眼和右眼关键点索引的列表。

    - left_eye_indices 是一个包含左眼关键点索引的列表，使用 list(range(left_eye_start, left_eye_end)) 来生成一个范围从 left_eye_start 到 left_eye_end - 1 的索引列表。

    - right_eye_indices 是一个包含右眼关键点索引的列表，使用 list(range(right_eye_start, right_eye_end)) 来生成一个范围从 right_eye_start 到 right_eye_end - 1 的索引列表。

    这两个列表将用于提取左眼和右眼的具体关键点位置信息。

    7. 打开摄像头

    老演员了，不介绍了

    1. # 打开摄像头
    2. cap = cv2.VideoCapture(0)

    8.读取一帧图像用于处理

    1.     ret, frame = cap.read()
    2.     if not ret:
    3.         break

            这部分代码是从摄像头读取一帧图像的常见做法。在视频处理中，cap.read() 会读取视频的下一帧，ret 表示读取是否成功，如果成功，则 ret 为 True，同时 frame 包含了读取到的图像帧。如果 ret 为 False，说明视频已经读取到结尾，此时应该退出循环。

            这种检查 ret 的方式是一种常见的确保视频读取不会超出结尾的方法。

    9.转换为灰度图

    1.     # 转换为灰度图
    2.     gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

            这一部分代码将读取到的彩色图像转换为灰度图像。在图像处理中，有时候我们会选择在灰度图像上进行操作，因为它只有一个通道，处理起来相对简单，而且对于一些任务如人脸检测来说，灰度图像已经足够。 cv2.cvtColor() 函数用于颜色空间的转换，cv2.COLOR_BGR2GRAY 表示将图像从BGR（彩色）转换为灰度。

            但是在这里主要是为了减轻处理的难度，提升性能，毕竟我的电脑是轻薄本，真的太难受了。没办法使用GPU处理

    10.人脸检测

    1.     # 人脸检测
    2.     faces = detector(gray)

            这一部分代码使用 detector 对灰度图像进行人脸检测。detector(gray) 返回检测到的人脸的矩形区域的列表。这里使用的是 Dlib 的人脸检测器

    11.获取脸部关键点

    1. # 获取关键点
    2. landmarks = predictor(gray, face)
    3. landmarks_points = [(landmarks.part(point).x, landmarks.part(point).y) for point in range(68)]


    - predictor(gray, face): 使用Dlib的关键点检测器 predictor 检测人脸上的关键点。
    - landmarks: 包含检测到的人脸关键点的对象。
    - landmarks_points: 将关键点的 x 和 y 坐标存储为元组的列表。

            这部分代码使用 Dlib 的关键点检测器 (predictor) 获取人脸上的 68 个关键点的坐标。 landmarks_points 变量包含了这些坐标。

    12.获取眼部关键点坐标

    1.         # 获取左右眼的关键点坐标
    2.         left_eye = landmarks_points[left_eye_indices[0]:left_eye_indices[-1] + 1]
    3.         right_eye = landmarks_points[right_eye_indices[0]:right_eye_indices[-1] + 1]

    这段代码用于从检测到的面部关键点中提取左眼和右眼的关键点坐标。

    - left_eye_indices 和 right_eye_indices 是左右眼的关键点索引范围，分别包含了人脸关键点中左眼和右眼的索引。

    - landmarks_points 包含了检测到的面部的所有68个关键点的坐标。

    - left_eye 存储了左眼的关键点坐标，通过使用左眼的索引范围从 landmarks_points 中进行切片操作得到。

    - right_eye 存储了右眼的关键点坐标，同样是通过切片操作得到。

            这样，通过 left_eye 和 right_eye，你可以获得左眼和右眼的关键点坐标，从而进行后续的处理，比如计算眼睛的形状、检测眨眼等。

    13.计算左右眼的横纵比

    1. # 计算左右眼的EAR
    2. left_ear = calculate_ear(left_eye)
    3. right_ear = calculate_ear(right_eye)

    这段代码用于计算左眼和右眼的EAR（Eye Aspect Ratio，眼睛纵横比）。

    - calculate_ear 是一个函数，接收一个眼睛的关键点坐标列表作为参数，并返回计算得到的眼睛的EAR值。

    - left_ear 存储了左眼的EAR值，通过调用 calculate_ear 函数传入左眼的关键点坐标得到。

    - right_ear 存储了右眼的EAR值，通过调用 calculate_ear 函数传入右眼的关键点坐标得到。

    通过计算眼睛的EAR值，可以用来判断眼睛的状态，例如是否闭眼。

    14.判断是否闭眼

    1. # 判断是否闭眼
    2. if left_ear < 0.2 and right_ear < 0.2:
    3.     cv2.putText(frame, "Eyes Closed", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)

    这段代码用于根据左眼和右眼的 EAR 值来判断是否闭眼。具体来说：

    - 如果左眼和右眼的 EAR 值都小于 0.2，那么被认为是闭眼状态。

            通过 cv2.putText 函数，在视频帧上添加文字信息，显示 "Eyes Closed"，文字的位置是 (50, 50)，字体大小为 1，颜色为红色 (0, 0, 255)，厚度为 2。这是一种简单的闭眼状态的可视化提示。

    15.绘制眼部线条

    1. # 可视化眼睛区域
    2. left_eye_int = np.array(left_eye, dtype=np.int32)
    3. right_eye_int = np.array(right_eye, dtype=np.int32)
    4. cv2.polylines(frame, [left_eye_int], isClosed=True, color=(255, 255, 0), thickness=1)
    5. cv2.polylines(frame, [right_eye_int], isClosed=True, color=(255, 255, 0), thickness=1)

    这段代码的目的是在视频帧上可视化左右眼的区域，具体来说：

    - left_eye_int 和 right_eye_int 分别将左眼和右眼的关键点坐标转换为整数型数组。

    - cv2.polylines 函数用于绘制多条线段，这里用于绘制眼睛区域的轮廓线。

            [left_eye_int] 和 [right_eye_int] 是轮廓线的坐标，isClosed=True 表示将轮廓线闭合（连接起点和终点），color=(255, 255, 0) 设置线的颜色为蓝色，thickness=1 设置线的厚度。这样就在视频帧上画出了左右眼的轮廓线，以便于可视化。

    16.显示画面

    1.  
    2.     # 显示图像
    3.     cv2.imshow('Eye Status', frame)

            这部分代码用于在窗口中显示处理后的图像。cv2.imshow('Eye Status', frame) 将处理后的图像（带有眼睛状态信息和可视化的眼睛区域）显示在名为 "Eye Status" 的窗口中。在这个窗口中，你可以看到实时的视频流，并且通过绘制的眼睛区域和相应的文字（例如 "Eyes Closed"）来表示眼睛的状态。

    17.监听键盘退出

    1.     # 退出循环
    2.     if cv2.waitKey(1) & 0xFF == 27:
    3.         break

            这段代码是为了检测键盘输入，如果检测到按键为 "Esc" 键（其ASCII码为27），就退出循环，从而结束程序的执行。通常，在实时视频处理中，这样的退出机制可以帮助你方便地停止程序的执行。

            cv2.waitKey(1) 会等待键盘输入，其参数表示等待的时间（单位为毫秒）。如果在这段时间内检测到键盘输入，那么它会返回按键的 ASCII 码值。因为我们通常是检测是否按下了某个特定的按键，所以要与某个 ASCII 码值进行比较。

            在这里，0xFF 是一个十六进制常数，对应于二进制的 11111111。这是一个掩码，通过与 cv2.waitKey(1) 的结果进行按位与（bitwise AND）操作，可以获取按键的 ASCII 码值。

            所以，cv2.waitKey(1) & 0xFF == 27 这个条件表达式的意思是：如果检测到的按键的 ASCII 码值为 27（对应于 Esc 键），则条件成立。在这种情况下，通常会退出循环，结束程序的执行。

     18.释放资源

    1. # 释放资源
    2. cap.release()
    3. cv2.destroyAllWindows()

    19.整体参考代码

    1. import cv2
    2. import dlib
    3. from scipy.spatial import distance
    4. import numpy as np
    5.  
    6. # WenJGo
    7. # 计算眼睛的纵横比 (EAR)
    8. def calculate_ear(eye):
    9.     # 计算垂直方向的欧氏距离
    10.     vertical_1 = distance.euclidean(eye[1], eye[5])
    11.     vertical_2 = distance.euclidean(eye[2], eye[4])
    12.  
    13.     # 计算水平方向的欧氏距离
    14.     horizontal = distance.euclidean(eye[0], eye[3])
    15.  
    16.     # 计算纵横比
    17.     ear = (vertical_1 + vertical_2) / (2.0 * horizontal)
    18.     return ear
    19.  
    20.  
    21. # 加载 Dlib 的人脸检测器和关键点检测器
    22. detector = dlib.get_frontal_face_detector()
    23. predictor = dlib.shape_predictor("D:\\Study\\PythonStudy\\people_68_face\\shape_predictor_68_face_landmarks.dat")
    24.  
    25. # 获取左右眼的索引
    26. (left_eye_start, left_eye_end) = (42, 48)
    27. (right_eye_start, right_eye_end) = (36, 42)
    28.  
    29. # 获取两只眼睛的关键点索引
    30. (left_eye_indices, right_eye_indices) = (
    31. list(range(left_eye_start, left_eye_end)), list(range(right_eye_start, right_eye_end)))
    32.  
    33. # 打开摄像头
    34. cap = cv2.VideoCapture(0)
    35.  
    36. while True:
    37.     ret, frame = cap.read()
    38.     if not ret:
    39.         break
    40.  
    41.     # 转换为灰度图
    42.     gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    43.  
    44.     # 人脸检测
    45.     faces = detector(gray)
    46.  
    47.     for face in faces:
    48.         # 获取关键点
    49.         landmarks = predictor(gray, face)
    50.         landmarks_points = [(landmarks.part(point).x, landmarks.part(point).y) for point in range(68)]
    51.  
    52.         # 获取左右眼的关键点坐标
    53.         left_eye = landmarks_points[left_eye_indices[0]:left_eye_indices[-1] + 1]
    54.         right_eye = landmarks_points[right_eye_indices[0]:right_eye_indices[-1] + 1]
    55.  
    56.         # 计算左右眼的EAR
    57.         left_ear = calculate_ear(left_eye)
    58.         right_ear = calculate_ear(right_eye)
    59.  
    60.         # 判断是否闭眼
    61.         if left_ear < 0.2 and right_ear < 0.2:
    62.             cv2.putText(frame, "Eyes Closed", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
    63.  
    64.         # 可视化眼睛区域
    65.         left_eye_int = np.array(left_eye, dtype=np.int32)
    66.         right_eye_int = np.array(right_eye, dtype=np.int32)
    67.         cv2.polylines(frame, [left_eye_int], isClosed=True, color=(255, 255, 0), thickness=1)
    68.         cv2.polylines(frame, [right_eye_int], isClosed=True, color=(255, 255, 0), thickness=1)
    69.  
    70.     # 显示图像
    71.     cv2.imshow('Eye Status', frame)
    72.  
    73.     # 退出循环
    74.     if cv2.waitKey(1) & 0xFF == 27:
    75.         break
    76.  
    77. # 释放资源
    78. cap.release()
    79. cv2.destroyAllWindows()

    结语

    呃，如果我会自己训练模型然后使用就好了。我只能说，加油吧加油吧！！！

    期待有一天

    春风得意马蹄疾，一日看尽长安花

    ヾ(￣▽￣)Bye~Bye~

    拜拜

  • 相关阅读:
    webpack 基础配置
    视频号如何下载到相册，无水印高清下载保存到手机相册
    九、Vue3基础之九
    使用VBA实现快速模糊查询数据
    Linux进程间通信
    winscope怎么实现user版本上导出方案设计探讨-千里马android framework车载车机手机系统开发
    MFC程序设计——用button更改静态文本+显示内容并弹出新内容+静态文本动态打开位图
    半桥BUCK电路—记录篇
    NFS使用-动态供应
    线性代数学习笔记3-4：描述线性变换的空间压缩情况（列空间、秩）
  • 原文地址：https://blog.csdn.net/DDDDWJDDDD/article/details/134468142