devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于python语言dlib库和opencv库的视频眨眼检测_python眨眼识别

作者：2023面试高手 | 2024-03-27 14:27:58

赞

踩

python眨眼识别

功能说明：

基于python编程语言，使用dlib 和opencv开发的视频眨眼检测。

环境：

*   python 3.6.8
*   opencv 3.4.2.16
*   dlib 19.7.0

原理：

1.使用opencv-python读取处理视频图像

2.使用线程机制处理人脸检测关键点

3.根据dlib算法检测到的关键点计算眼部特征，通过欧氏距离计算确定是睁眼还是闭眼

4.统计闭眼次数并在视频图片中绘制结果

原始代码：

  1. # 基于opencv-python和dlib库的视频眨眼检测
  2.  
  3. # 导入工具包
  4. from scipy.spatial import distance as dist
  5. from collections import OrderedDict
  6. import numpy as np
  7. import argparse
  8. import time
  9. # pip install dlib==19.6.1 -i https://mirrors.aliyun.com/pypi/simple
  10. import dlib
  11. # pip install opencv-python==3.4.1
  12. import cv2
  13.  
  14. # 关键点排序
  15. FACIAL_LANDMARKS_68_IDXS = OrderedDict([
  16.     ("mouth", (48, 68)),
  17.     ("right_eyebrow", (17, 22)),
  18.     ("left_eyebrow", (22, 27)),
  19.     ("right_eye", (36, 42)),
  20.     ("left_eye", (42, 48)),
  21.     ("nose", (27, 36)),
  22.     ("jaw", (0, 17))
  23. ])
  24.  
  25.  
  26. # http://vision.fe.uni-lj.si/cvww2016/proceedings/papers/05.pdf
  27. def eye_aspect_ratio(eye):
  28.     """
  29.     计算眼睛上下关键点欧式距离
  30.     :param eye:眼睛关键点位置
  31.     :return: 眼睛睁开程度
  32.     """
  33.     # 计算距离，竖直的
  34.     A = dist.euclidean(eye[1], eye[5])
  35.     B = dist.euclidean(eye[2], eye[4])
  36.     # 计算距离，水平的
  37.     C = dist.euclidean(eye[0], eye[3])
  38.     # ear值
  39.     ear = (A + B) / (2.0 * C)
  40.     return ear
  41.  
  42.  
  43. # 输入参数
  44. ap = argparse.ArgumentParser()
  45. ap.add_argument("-p", "--shape-predictor", required=True,
  46.                 help="path to facial landmark predictor")
  47. ap.add_argument("-v", "--video", type=str, default="",
  48.                 help="path to input video file")
  49. args = vars(ap.parse_args())
  50. print(args)
  51. # 设置判断参数
  52. EYE_AR_THRESH = 0.3 # 低于该值则判断为眨眼
  53. EYE_AR_CONSEC_FRAMES = 3
  54.  
  55. # 初始化计数器
  56. COUNTER = 0
  57. TOTAL = 0
  58.  
  59. # 检测与定位工具
  60. print("[INFO] loading facial landmark predictor...")
  61. detector = dlib.get_frontal_face_detector()
  62. #predictor = dlib.shape_predictor(args["shape_predictor"])
  63. predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')
  64. # 分别取两个眼睛区域
  65. (lStart, lEnd) = FACIAL_LANDMARKS_68_IDXS["left_eye"]
  66. (rStart, rEnd) = FACIAL_LANDMARKS_68_IDXS["right_eye"]
  67.  
  68. # 读取视频
  69. print("[INFO] starting video stream thread...")
  70. #vs = cv2.VideoCapture(args["video"])
  71. vs = cv2.VideoCapture(0)
  72. #vs = FileVideoStream(args["video"]).start()
  73. time.sleep(1.0)
  74.  
  75.  
  76. def shape_to_np(shape, dtype="int"):
  77.     # 创建68*2
  78.     coords = np.zeros((shape.num_parts, 2), dtype=dtype)
  79.     # 遍历每一个关键点
  80.     # 得到坐标
  81.     for i in range(0, shape.num_parts):
  82.         coords[i] = (shape.part(i).x, shape.part(i).y)
  83.     return coords
  84.  
  85.  
  86. # 遍历每一帧
  87. while True:
  88.     # 预处理
  89.     frame = vs.read()[1]
  90.     if frame is None:
  91.         break
  92.  
  93.     (h, w) = frame.shape[:2]
  94.     width = 1200
  95.     r = width / float(w)
  96.     dim = (width, int(h * r))
  97.     frame = cv2.resize(frame, dim, interpolation=cv2.INTER_AREA)
  98.     gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
  99.  
  100.     # 检测人脸
  101.     rects = detector(gray, 0)
  102.  
  103.     # 遍历每一个检测到的人脸
  104.     for rect in rects:
  105.         # 获取坐标
  106.         shape = predictor(gray, rect)
  107.         shape = shape_to_np(shape)
  108.  
  109.         # 分别计算ear值
  110.         leftEye = shape[lStart:lEnd]
  111.         rightEye = shape[rStart:rEnd]
  112.         leftEAR = eye_aspect_ratio(leftEye)
  113.         rightEAR = eye_aspect_ratio(rightEye)
  114.  
  115.         # 算一个平均的
  116.         ear = (leftEAR + rightEAR) / 2.0
  117.  
  118.         # 绘制眼睛区域
  119.         leftEyeHull = cv2.convexHull(leftEye)
  120.         rightEyeHull = cv2.convexHull(rightEye)
  121.         cv2.drawContours(frame, [leftEyeHull], -1, (0, 255, 0), 1)
  122.         cv2.drawContours(frame, [rightEyeHull], -1, (0, 255, 0), 1)
  123.  
  124.         # 检查是否满足阈值
  125.         if ear < EYE_AR_THRESH:
  126.             COUNTER += 1
  127.  
  128.         else:
  129.             # 如果连续几帧都是闭眼的，总数算一次
  130.             if COUNTER >= EYE_AR_CONSEC_FRAMES:
  131.                 TOTAL += 1
  132.  
  133.             # 重置
  134.             COUNTER = 0
  135.  
  136.         # 显示
  137.         cv2.putText(frame, "Blinks: {}".format(TOTAL), (10, 30),
  138.                     cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
  139.         cv2.putText(frame, "EAR: {:.2f}".format(ear), (300, 30),
  140.                     cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
  141.  
  142.     cv2.imshow("Frame", frame)
  143.     key = cv2.waitKey(10) & 0xFF
  144.  
  145.     if key == 27:
  146.         break
  147.  
  148. vs.release()
  149. cv2.destroyAllWindows()

运行该代码进行调用摄像头检测和读取本地视频检测的命令如下：

  1. python detect_blinks.py -p shape_predictor_68_face_landmarks.dat -v test.mp4
  2. python detect_blinks.py -p shape_predictor_68_face_landmarks.dat -v 0

原始代码需要借助于命令行参数才可以运行，后来经过修改后，可以直接在编译器中运行的，代码如下：

  1. # 视频眨眼检测
  2. # 导入工具包
  3. from scipy.spatial import distance as dist
  4. from collections import OrderedDict
  5. import numpy as np
  6. import argparse
  7. import time
  8. # pip install dlib==19.6.1 -i https://mirrors.aliyun.com/pypi/simple
  9. import dlib
  10. # pip install opencv-python==3.4.1
  11. import cv2
  12.  
  13. # 关键点排序
  14. FACIAL_LANDMARKS_68_IDXS = OrderedDict([
  15.     ("mouth", (48, 68)),
  16.     ("right_eyebrow", (17, 22)),
  17.     ("left_eyebrow", (22, 27)),
  18.     ("right_eye", (36, 42)),
  19.     ("left_eye", (42, 48)),
  20.     ("nose", (27, 36)),
  21.     ("jaw", (0, 17))
  22. ])
  23.  
  24.  
  25. # http://vision.fe.uni-lj.si/cvww2016/proceedings/papers/05.pdf
  26. def eye_aspect_ratio(eye):
  27.     """
  28.     计算眼睛上下关键点欧式距离
  29.     :param eye:眼睛关键点位置
  30.     :return: 眼睛睁开程度
  31.     """
  32.     # 计算距离，竖直的
  33.     A = dist.euclidean(eye[1], eye[5])
  34.     B = dist.euclidean(eye[2], eye[4])
  35.     # 计算距离，水平的
  36.     C = dist.euclidean(eye[0], eye[3])
  37.     # ear值
  38.     ear = (A + B) / (2.0 * C)
  39.     return ear
  40.     
  41. # 设置判断参数
  42. EYE_AR_THRESH = 0.3 # 低于该值则判断为眨眼
  43. EYE_AR_CONSEC_FRAMES = 3
  44.  
  45. # 初始化计数器
  46. COUNTER = 0
  47. TOTAL = 0
  48.  
  49. # 检测与定位工具
  50. print("[INFO] loading facial landmark predictor...")
  51. detector = dlib.get_frontal_face_detector()
  52. predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')
  53.  
  54. # 分别取两个眼睛区域
  55. (lStart, lEnd) = FACIAL_LANDMARKS_68_IDXS["left_eye"]
  56. (rStart, rEnd) = FACIAL_LANDMARKS_68_IDXS["right_eye"]
  57.  
  58. # 读取视频
  59. print("[INFO] starting video stream thread...")
  60. vs = cv2.VideoCapture(0)
  61. time.sleep(1.0)
  62.  
  63.  
  64. def shape_to_np(shape, dtype="int"):
  65.     # 创建68*2
  66.     coords = np.zeros((shape.num_parts, 2), dtype=dtype)
  67.     # 遍历每一个关键点
  68.     # 得到坐标
  69.     for i in range(0, shape.num_parts):
  70.         coords[i] = (shape.part(i).x, shape.part(i).y)
  71.     return coords
  72.  
  73.  
  74. # 遍历每一帧
  75. while True:
  76.     # 预处理
  77.     frame = vs.read()[1]
  78.     if frame is None:
  79.         break
  80.  
  81.     (h, w) = frame.shape[:2]
  82.     width = 1200
  83.     r = width / float(w)
  84.     dim = (width, int(h * r))
  85.     frame = cv2.resize(frame, dim, interpolation=cv2.INTER_AREA)
  86.     gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
  87.  
  88.     # 检测人脸
  89.     rects = detector(gray, 0)
  90.  
  91.     # 遍历每一个检测到的人脸
  92.     for rect in rects:
  93.         # 获取坐标
  94.         shape = predictor(gray, rect)
  95.         shape = shape_to_np(shape)
  96.  
  97.         # 分别计算ear值
  98.         leftEye = shape[lStart:lEnd]
  99.         rightEye = shape[rStart:rEnd]
  100.         leftEAR = eye_aspect_ratio(leftEye)
  101.         rightEAR = eye_aspect_ratio(rightEye)
  102.  
  103.         # 算一个平均的
  104.         ear = (leftEAR + rightEAR) / 2.0
  105.  
  106.         # 绘制眼睛区域
  107.         leftEyeHull = cv2.convexHull(leftEye)
  108.         rightEyeHull = cv2.convexHull(rightEye)
  109.         cv2.drawContours(frame, [leftEyeHull], -1, (0, 255, 0), 1)
  110.         cv2.drawContours(frame, [rightEyeHull], -1, (0, 255, 0), 1)
  111.  
  112.         # 检查是否满足阈值
  113.         if ear < EYE_AR_THRESH:
  114.             COUNTER += 1
  115.  
  116.         else:
  117.             # 如果连续几帧都是闭眼的，总数算一次
  118.             if COUNTER >= EYE_AR_CONSEC_FRAMES:
  119.                 TOTAL += 1
  120.  
  121.             # 重置
  122.             COUNTER = 0
  123.  
  124.         # 显示
  125.         cv2.putText(frame, "Blinks: {}".format(TOTAL), (10, 30),
  126.                     cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
  127.         cv2.putText(frame, "EAR: {:.2f}".format(ear), (300, 30),
  128.                     cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
  129.  
  130.     cv2.imshow("Frame", frame)
  131.     key = cv2.waitKey(10) & 0xFF
  132.  
  133.     if key == 27:
  134.         break
  135.  
  136. vs.release()
  137. cv2.destroyAllWindows()

检测效果如下：

下载链接：https://mp.csdn.net/mp_download/manage/download/UpDetailed

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号