传统方法眼角定位和dilb 进行疲劳检测（眨眼检测）

安装第三方库文件

* opencv
* Dlib,安装方法见
https://www.learnopencv.com/install-opencv-3-and-dlib-on-windows-python-only/
<https://www.learnopencv.com/install-opencv-3-and-dlib-on-windows-python-only/> 
* Numpy
* Imutils （一系列使得opencv 便利的功能，包括图像旋转、缩放、平移，骨架化、边缘检测、显示matplotlib
图像（imutils.opencv2matplotlib(image）)
传统方法进行眼角定位

思路是：

1、利用opencv 自带训练好的 haarcascade_frontalface_default.xml 和 haarcascade_eye.xml

来检测脸部和眼睛

以脸部加载xml为例：
face=cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
face.load(脸部xml的完整路径)
以上是加载xml方法，有很多介绍直接是face=cv2.CascadeClassifier(脸部xml的完整路径)，通常会报错。

2、加载完xml 文件后，下一步就是detect,opencv
函数为detectMultiScale（img,scaleFactor,minNeighbors,minsize,maxsize）

scaleFactor 是压缩率，越小金字塔数目越多，相应的检测准确相对好点

minNeighbors 是同一张脸至少被检测n次才认为是真正的

Minszie以元组方式，（检测眼睛时候会用到，避免鼻子和其他部位产生的假阳性）

3、先检测脸，然后再脸的基础上再检测眼睛，到了这一步后，就是自己设计检测的眼角方法：

     1）找轮廓，取最大轮廓

      2）凸缺陷检测，得到所有凸点

      3）眼角如何确定？----将凸点的x,y值相加，排序，最小的为左边眼角，最大的为右边眼角（见测试图）

dlib 疲劳检测

* 下载shape_predictor_68_face_landmarks.dat 文件，这是68个眼部特征点
* 初始化检测器和预测器 detector=dlib.get_frontal_face_detector() predictor =
dlib.shape_predictor(“dat文件路径”)
     3 如何确定疲劳？

          1） 计算眼睛的宽高比

          2）当前帧两双眼睛宽高比与前一帧的差值的绝对值大于0.2，则认为是疲劳

程序如下：
# -*- coding: utf-8 -*- import os import numpy as np import cv2 import dlib
import sys from imutils import face_utils class fatigue(object): def
__init__(self,file_dictory,landmask_path,facehaar_path,eyehaar_path):
self.file=os.path.abspath(str(file_dictory)) os.chdir(self.file)
self.roi_face=[] self.roi_eye=[] #
self.predictor_path=r'C:\Users\Y\Desktop\shape_predictor_68_face_landmarks.dat'
self.predictor_path=os.path.abspath(str(landmask_path)) #
self.face_haar_path=r'E:\opencv\opencv\sources\data\haarcascades\haarcascade_frontalface_default.xml'
self.face_haar_path=os.path.abspath(str(facehaar_path)) #
self.eye_haar_path=r'E:\opencv\opencv\sources\data\haarcascades\haarcascade_eye.xml'
self.eye_haar_path=os.path.abspath(str(eyehaar_path)) def detect_face(self):
face=cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
face.load(self.face_haar_path) i=1 for f in os.listdir(self.file):
face_image=cv2.imread(f) face_image=cv2.medianBlur(face_image,3) if
face_image.ndim==3: face_image_gray=cv2.cvtColor(face_image,cv2.COLOR_BGR2GRAY)
else: face_image_gray=face_image
faces=face.detectMultiScale(face_image_gray,1.3,5) if len(faces)!=0: for
(x,y,w,h) in faces: self.roi_face.append(face_image[y:y+h,x:x+w,:]) #
cv2.imwrite(self.file+"\\%g.jpg"%i,face_image_gray[y:y+h,x:x+w]) i+=1
print("人脸数%g"%len(self.roi_face)) def detect_eye(self):
eye=cv2.CascadeClassifier('haarcascade_eye.xml') eye.load(self.eye_haar_path)
i=1 for face in self.roi_face:
eyes=eye.detectMultiScale(face,1.03,20,0,(40,40))#(40,40)限制眼睛搜索最小尺寸，避免鼻子或者其他的阴影产生的假阳性
if len(eyes)!=0: for (x,y,w,h) in eyes:
self.roi_eye.append(face[y:y+h,x:x+w,:]) #
cv2.imwrite(self.file+"\\%g.jpg"%i,face[y+10:y+h,x+10:x+w,:]) i+=1
print("眼睛个数%g"%len(self.roi_eye)) #传统 def feature_eye(self): i=1 for e in
self.roi_eye: e_g=cv2.cvtColor(e,cv2.COLOR_BGR2GRAY)
_,thresh=cv2.threshold(e_g,0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
_,cnts,h=cv2.findContours(thresh,0,1) cnt_max=sorted(cnts,key=lambda
x:cv2.contourArea(x),reverse=True)[0] con_hull=cv2.convexHull(cnt_max)
hull_index=cv2.convexHull(cnt_max,returnPoints = False) defects =
cv2.convexityDefects(cnt_max,hull_index) temp=[] point=[] for j in
range(defects.shape[0]): _,_,f,d=defects[j,0]
point.append(tuple(cnt_max[f][0])) for t in point: temp.append(sum(t))
index=np.argsort(temp) close=point[index[0]]#两个眼角，colse,far
far=point[index[-1]] # np.sort() cv2.circle(e,close,5,(0,255,0),-1)
cv2.circle(e,far,5,(0,255,0),-1) cv2.drawContours(e,[con_hull],0,(0,0,255),2)
cv2.putText(e,str(cv2.contourArea(cnt_max)),(10,10),cv2.FONT_HERSHEY_SIMPLEX,0.5,(255,0,0))
cv2.imwrite(self.file+"\\%g.jpg"%i,e) i+=1 def dlib_detect(self):
detector=dlib.get_frontal_face_detector() predictor =
dlib.shape_predictor(self.predictor_path)
cap=cv2.VideoCapture(0)#也可以其它视频，打开本地摄像头 if cap.isOpened() is False: raise("IO
error") #抛出异常 cap.set(cv2.CAP_PROP_FPS,60) # cv2.namedWindow("Capture",
cv2.WINDOW_NORMAL) forward_left_eye_ratio=None forward_right_eye_ratio=None
flag=0 #根据faces个数来初始化forward_left.... while 1: ret,frame=cap.read()
frame=cv2.medianBlur(frame,3) # frame=cv2.cvtColor(frame,cv2.COLOR_BGR2RGB) if
ret==False: sys.exit() faces=detector(frame,1)#1 代表图像升采样一次，以便我们检测更多的人脸 if
len(faces)>0: if flag==0: #以第一帧检测到人脸个数为准,也就是程序每一帧检测到人脸个数相同，不然有错
temp=np.zeros((len(faces),1)) #初始化成一个数组
forward_left_eye_ratio,forward_right_eye_ratio=temp,temp else: # sys.exit() #
print("当前帧人脸消失,退出") print("当前帧人脸消失,继续下一帧") # break continue flag=1
#flag=1,标识着第二帧的时候不再预分配内存，temp if len(faces)>0: for i,d in enumerate(faces):
cv2.rectangle(frame,(d.left(),d.top()),(d.right(),d.bottom()),(0,255,0),2)
cv2.putText(frame,str(i+1),(d.left()-10,d.top()-10),cv2.FONT_HERSHEY_SIMPLEX,0.5,(0,0,255),2)
shape=predictor(frame,d)#检测68特征点 # print(shape,type(shape)) points =
face_utils.shape_to_np(shape) #将脸部特征点转为坐标（x,y)
long_left=self.distance(points[36,:],points[39,:])
short_left=self.distance((points[37,:]+points[38,:])/2,(points[41,:]+points[40,:])/2)
long_right=self.distance(points[42,:],points[45,:])
short_right=self.distance((points[43,:]+points[44,:])/2,(points[46,:]+points[47,:])/2)
if forward_left_eye_ratio[i]==0 and
forward_right_eye_ratio[i]==0:#取第一帧的人脸眼睛宽高比，取完后，进行下一帧，continue 后的语句不再执行
forward_left_eye_ratio[i]=short_left/long_left
forward_right_eye_ratio[i]=short_right/long_right continue #跳转下一个人脸眼睛的宽高比 ##下一帧
left_eye_ratio_now=np.zeros((forward_left_eye_ratio.shape))
right_eye_ratio_now=np.zeros((forward_right_eye_ratio.shape))
left_eye_ratio_now[i]=short_left/long_left
right_eye_ratio_now[i]=short_right/long_right
print("第%g个人脸当前左眼宽高比与前一帧的差值:%g"%(i+1,abs(left_eye_ratio_now[i]-forward_left_eye_ratio[i])))
if abs(left_eye_ratio_now[i]-forward_left_eye_ratio[i])>0.2:
print("第%g个人左眼变化%g"%(i+1,abs(left_eye_ratio_now-forward_left_eye_ratio))) if
abs(right_eye_ratio_now[i]-forward_right_eye_ratio[i])>0.2:
print("第%g个人左眼变化%g"%(i+1,abs(right_eye_ratio_now-forward_right_eye_ratio))) if
abs(left_eye_ratio_now[i]-forward_left_eye_ratio[i])>0.2 and
abs(right_eye_ratio_now[i]-forward_right_eye_ratio[i])>0.2:
print("%g号先生您很疲劳了,请注意休息"%(i+1)) forward_left_eye_ratio[i]=left_eye_ratio_now[i]
forward_right_eye_ratio[i]=right_eye_ratio_now[i] cv2.imshow("Capture",frame)
k=cv2.waitKey(10) if k==27: break cap.release() cv2.destroyAllWindows() def
distance(self,p1,p2): return np.sqrt(np.sum((p1-p2)*(p1-p2))) if
__name__=="__main__": # param=sys.argv[1] print("cmd---运行格式--python '****.py'
图像demo1文件夹路径 68_face_landmarks.dat路径 haarcascade_frontalface_default.xml路径
haarcascade_eye.xml路径") if len(sys.argv)!=5: print("参数不够") #
fold_param=r'C:\Users\Y\Desktop\demo1' # fatigue_drive=fatigue(fold_param)
fatigue_drive=fatigue(sys.argv[1],sys.argv[2],sys.argv[3],sys.argv[4])
print("**********传统方法人眼角定位*************\n") fatigue_drive.detect_face()
fatigue_drive.detect_eye() fatigue_drive.feature_eye()
print("*************疲劳测试************\n") fatigue_drive.dlib_detect()
测试图：



    

• « 上一篇：机器学习直接放弃
• » 下一篇：其实，搭建一个有品质的棋牌游戏平台没那么复杂