Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1055059
  • 博文数量: 228
  • 博客积分: 474
  • 博客等级: 下士
  • 技术积分: 1930
  • 用 户 组: 普通用户
  • 注册时间: 2010-03-19 18:40
文章分类

全部博文(228)

文章存档

2019年(3)

2018年(12)

2017年(13)

2016年(11)

2015年(55)

2014年(75)

2013年(39)

2012年(2)

2011年(18)

我的朋友

分类: Python/Ruby

2018-10-28 12:16:46

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/hongbin_xu/article/details/79033116
前言


我们要使用opencv和dlib实现在视频流中实时检测和计数眨眼次数。 
参考论文:Real-Time Eye Blink Detection using Facial Landmarks 
作者在这篇文章中提出了一个眼睛纵横比(eye aspect ratio (EAR))的概念,通过计算这个EAR的数值,我们可以判断眼睛是张开还是闭合,从而检测眨眼动作。 
首先,参考别人翻译的这篇文章OpenCV/Python/dlib眨眼检测,我稍微修改了一下代码,实现了初步检测;后面会进一步使用若干帧中检测到的EAR组成一个特征向量,送到一个SVM中来进行分类。


眼睛纵横比(EAR)


在讨论EAR之前,先看看68个人脸特征点: 


人脸特征点检测本身的算法是很复杂的,dlib中给出了相关的实现。程序实现可以参考我以前的博客:python dlib学习(二):人脸特征点标定。想深入研究的可以参考这篇论文。


从图中我们可以看到左眼和右眼分别对应了6个特征点,我们后面的讨论都是基于这6个特征点来进行。


论文中国给出的EAR定义的图片如下: 
 
上图中的6个特征点p1p1、p2p2、p3p3、p4p4、p5p5、p6p6是人脸特征点中对应眼睛的6个特征点。 
我们想关注的重点是:这些点在眼睛睁开和闭合时,彼此坐标之间的关系。 
如图中直线所示,我们可以看出,长宽比在眼睛睁开和闭合时会有所不同。 
顺理成章地,我们可以导出EAR的方程: 
EAR=∥p2?p6∥+∥p3?p5∥2∥p1?p4∥
EAR=‖p2?p6‖+‖p3?p5‖2‖p1?p4‖
分子中计算的是眼睛的特征点在垂直方向上的距离,分母计算的是眼睛的特征点在水平方向上的距离。由于水平点只有一组,而垂直点有两组,所以分母乘上了2,以保证两组特征点的权重相同。 
接下来看看,上面的那个表格。我们不难发现,EAR在眼睛睁开时是基本保持不变的,在小范围内会上下浮动,然而,当眼睛闭合时,EAR会迅速下降。这也就是我们进行眨眼检测的原理,十分简单。当然想了解更详细的内容还是请查阅论文。


程序实现


程序1:直接使用阈值判断


导入模块


#coding=utf-8  
import numpy as np 
import cv2
import dlib
from scipy.spatial import distance
import os
from imutils import face_utils
1
2
3
4
5
6
7
导入检测器


shape_predictor_68_face_landmarks.dat这个模型文件我是存放在当前目录下的model文件夹中的。


pwd = os.getcwd()# 获取当前路径
model_path = os.path.join(pwd, 'model')# 模型文件夹路径
shape_detector_path = os.path.join(model_path, 'shape_predictor_68_face_landmarks.dat')# 人脸特征点检测模型路径


detector = dlib.get_frontal_face_detector()# 人脸检测器
predictor = dlib.shape_predictor(shape_detector_path)# 人脸特征点检测器
1
2
3
4
5
6
定义一些参数


EYE_AR_THRESH = 0.3# EAR阈值
EYE_AR_CONSEC_FRAMES = 3# 当EAR小于阈值时,接连多少帧一定发生眨眼动作


# 对应特征点的序号
RIGHT_EYE_START = 37 - 1
RIGHT_EYE_END = 42 - 1
LEFT_EYE_START = 43 - 1
LEFT_EYE_END = 48 - 1
1
2
3
4
5
6
7
8
EYE_AR_THRESH是判断阈值,默认为0.3。如果EAR大于它,则认为眼睛是睁开的;如果EAR小于它,则认为眼睛是闭上的。 
EYE_AR_CONSEC_FRAMES表示的是,当EAR小于阈值时,接连多少帧一定发生眨眼动作。只有小于阈值的帧数超过了这个值时,才认为当前眼睛是闭合的,即发生了眨眼动作;否则则认为是误操作。 
RIGHT_EYE_START、RIGHT_EYE_END、LEFT_EYE_START、LEFT_EYE_END:这几个都对应了人脸特征点中对应眼睛的那几个特征点的序号。由于list中默认从0开始,为保持一致,所以减一。


处理视频流


frame_counter = 0# 连续帧计数 
blink_counter = 0# 眨眼计数
cap = cv2.VideoCapture(1)
while(1):
    ret, img = cap.read()# 读取视频流的一帧


    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)# 转成灰度图像
    rects = detector(gray, 0)# 人脸检测
    for rect in rects:# 遍历每一个人脸
        print('-'*20)
        shape = predictor(gray, rect)# 检测特征点
        points = face_utils.shape_to_np(shape)# convert the facial landmark (x, y)-coordinates to a NumPy array
        leftEye = points[LEFT_EYE_START:LEFT_EYE_END + 1]# 取出左眼对应的特征点
        rightEye = points[RIGHT_EYE_START:RIGHT_EYE_END + 1]# 取出右眼对应的特征点
        leftEAR = eye_aspect_ratio(leftEye)# 计算左眼EAR
        rightEAR = eye_aspect_ratio(rightEye)# 计算右眼EAR
        print('leftEAR = {0}'.format(leftEAR))
        print('rightEAR = {0}'.format(rightEAR))


        ear = (leftEAR + rightEAR) / 2.0# 求左右眼EAR的均值


        leftEyeHull = cv2.convexHull(leftEye)# 寻找左眼轮廓
        rightEyeHull = cv2.convexHull(rightEye)# 寻找右眼轮廓
        cv2.drawContours(img, [leftEyeHull], -1, (0, 255, 0), 1)# 绘制左眼轮廓
        cv2.drawContours(img, [rightEyeHull], -1, (0, 255, 0), 1)# 绘制右眼轮廓


        # 如果EAR小于阈值,开始计算连续帧,只有连续帧计数超过EYE_AR_CONSEC_FRAMES时,才会计做一次眨眼
        if ear < EYE_AR_THRESH:
            frame_counter += 1
        else:
            if frame_counter >= EYE_AR_CONSEC_FRAMES:
                blink_counter += 1
            frame_counter = 0


        # 在图像上显示出眨眼次数blink_counter和EAR
        cv2.putText(img, "Blinks:{0}".format(blink_counter), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,0,255), 2)
        cv2.putText(img, "EAR:{:.2f}".format(ear), (300, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,0,255), 2)




    cv2.imshow("Frame", img)


    if cv2.waitKey(1) & 0xFF == ord("q"):
        break


cap.release()
cv2.destroyAllWindows()
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
运行结果


注:我测试时,我的摄像头只有30帧,如果按照我们通常眨眼的速度,眨眼速度实在太快摄像头根本来不及捕捉,更别说检测到了。所以,如果你的摄像头帧数不够,检测时眨眼放慢点,那样效果会好一点。还有,尽量别戴眼镜,眼睛反光可能会导致检测眼睛轮廓时出错,计算出的结果自然也是错的。 




程序2:使用SVM来划分特征向量


这一部分相对要麻烦一点,我们需要自己采集数据,并训练SVM模型,随后才能在程序中读取模型来使用。


采集数据


导入包


#coding=utf-8  
import numpy as np 
import os
import dlib
import cv2
from scipy.spatial import distance
from imutils import face_utils
import pickle
1
2
3
4
5
6
7
8
队列(特征向量)


VECTOR_SIZE = 3
def queue_in(queue, data):
    ret = None
    if len(queue) >= VECTOR_SIZE:
        ret = queue.pop(0)
    queue.append(data)
    return ret, queue
1
2
3
4
5
6
7
VECTOR_SIZE表示你的特征向量维度多少,我默认取了3维的。注意你采集数据程序中的VECTOR_SIZE要和其他程序中一致。用了一个队列简单实现,比较简单不做赘述。


采集数据前准备


这些都与前面程序1中的一样,不做赘述。


def eye_aspect_ratio(eye):
    # print(eye)
    A = distance.euclidean(eye[1], eye[5])
    B = distance.euclidean(eye[2], eye[4])
    C = distance.euclidean(eye[0], eye[3])
    ear = (A + B) / (2.0 * C)
    return ear


pwd = os.getcwd()
model_path = os.path.join(pwd, 'model')
shape_detector_path = os.path.join(model_path, 'shape_predictor_68_face_landmarks.dat')


detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(shape_detector_path)


cv2.namedWindow("frame", cv2.WINDOW_AUTOSIZE)


cap = cv2.VideoCapture(0)


# 对应特征点的序号
RIGHT_EYE_START = 37 - 1
RIGHT_EYE_END = 42 - 1
LEFT_EYE_START = 43 - 1
LEFT_EYE_END = 48 - 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
采集眼睛睁开时的样本


print('Prepare to collect images with your eyes open')
print('Press s to start collecting images.')
print('Press e to end collecting images.')
print('Press q to quit')
flag = 0
txt = open('train_open.txt', 'wb')
data_counter = 0
ear_vector = []
while(1):
    ret, frame = cap.read()
    key = cv2.waitKey(1)
    if key & 0xFF == ord("s"):
        print('Start collecting images.')
        flag = 1
    elif key & 0xFF == ord("e"):
        print('Stop collecting images.')
        flag = 0
    elif key & 0xFF == ord("q"):
        print('quit')
        break


    if flag == 1:
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        rects = detector(gray, 0)
        for rect in rects:
            shape = predictor(gray, rect)
            points = face_utils.shape_to_np(shape)# convert the facial landmark (x, y)-coordinates to a NumPy array
            # points = shape.parts()
            leftEye = points[LEFT_EYE_START:LEFT_EYE_END + 1]
            rightEye = points[RIGHT_EYE_START:RIGHT_EYE_END + 1]
            leftEAR = eye_aspect_ratio(leftEye)
            rightEAR = eye_aspect_ratio(rightEye)
            # print('leftEAR = {0}'.format(leftEAR))
            # print('rightEAR = {0}'.format(rightEAR))


            ear = (leftEAR + rightEAR) / 2.0


            leftEyeHull = cv2.convexHull(leftEye)
            rightEyeHull = cv2.convexHull(rightEye)
            cv2.drawContours(frame, [leftEyeHull], -1, (0, 255, 0), 1)
            cv2.drawContours(frame, [rightEyeHull], -1, (0, 255, 0), 1)


            ret, ear_vector = queue_in(ear_vector, ear)
            if(len(ear_vector) == VECTOR_SIZE):
                # print(ear_vector)
                # input_vector = []
                # input_vector.append(ear_vector)


                txt.write(str(ear_vector))
                txt.write('\n')
                data_counter += 1
                print(data_counter)


            cv2.putText(frame, "EAR:{:.2f}".format(ear), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,0,255), 2)


    cv2.imshow("frame", frame)
txt.close()
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
这一部分与程序1中也很类似,都是读取视频流,识别人脸特征点,计算EAR。可以通过按键控制:按q键退出;按s键,开始采集信息,采集时请保证眼睛睁开,随后会将计算得到的ear组成的特征向量写入train_open.txt文件中;按e键,停止采集信息,眼睛闭合休息时用。 
采集数据时真的是比较尴尬,因为眼睛对着摄像头睁久了真的很累,我只能循环按s键和e键来断断续续地采集。


采集眼睛闭合时的样本


print('-'*40)
print('Prepare to collect images with your eyes close')
print('Press s to start collecting images.')
print('Press e to end collecting images.')
print('Press q to quit')
flag = 0
txt = open('train_close.txt', 'wb')
data_counter = 0
ear_vector = []
while(1):
    ret, frame = cap.read()
    key = cv2.waitKey(1)
    if key & 0xFF == ord("s"):
        print('Start collecting images.')
        flag = 1
    elif key & 0xFF == ord("e"):
        print('Stop collecting images.')
        flag = 0
    elif key & 0xFF == ord("q"):
        print('quit')
        break


    if flag == 1:
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        rects = detector(gray, 0)
        for rect in rects:
            shape = predictor(gray, rect)
            points = face_utils.shape_to_np(shape)# convert the facial landmark (x, y)-coordinates to a NumPy array
            # points = shape.parts()
            leftEye = points[LEFT_EYE_START:LEFT_EYE_END + 1]
            rightEye = points[RIGHT_EYE_START:RIGHT_EYE_END + 1]
            leftEAR = eye_aspect_ratio(leftEye)
            rightEAR = eye_aspect_ratio(rightEye)
            # print('leftEAR = {0}'.format(leftEAR))
            # print('rightEAR = {0}'.format(rightEAR))


            ear = (leftEAR + rightEAR) / 2.0


            leftEyeHull = cv2.convexHull(leftEye)
            rightEyeHull = cv2.convexHull(rightEye)
            cv2.drawContours(frame, [leftEyeHull], -1, (0, 255, 0), 1)
            cv2.drawContours(frame, [rightEyeHull], -1, (0, 255, 0), 1)


            ret, ear_vector = queue_in(ear_vector, ear)
            if(len(ear_vector) == VECTOR_SIZE):
                # print(ear_vector)
                # input_vector = []
                # input_vector.append(ear_vector)


                txt.write(str(ear_vector))
                txt.write('\n')


                data_counter += 1
                print(data_counter)


            cv2.putText(frame, "EAR:{:.2f}".format(ear), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,0,255), 2)


    cv2.imshow("frame", frame)
txt.close()
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
程序结构跟前面采集眼睛睁开时的样本的程序一模一样,唯一的区别就是这次采集的数据不一样。采集时可以通过键盘按键控制:按q键退出;按s键开始采集图像,并计算EAR,并将特征向量保存到train_close.txt文件中,采集时注意眼睛闭合后再采集;按e结束采集。循环按s键和e键控制采集。


关闭摄像头和窗口


cap.release()
cv2.destroyAllWindows()
1
2
运行结果


采集结束后会生成两个文本文件:train_close.txt、train_open.txt。两个文件分别对应眼睛闭合和睁开时,EAR构成的特征向量,即SVM的负样本和正样本。






这里的数据维度是前面自己定的,可以改变的。 








训练SVM


导入包


import numpy as np 
from sklearn import svm
from sklearn.externals import joblib
1
2
3
解析数据


train = []
labels = []


print('Reading train_open.txt...')
line_ctr = 0
for txt_str in train_open_txt.readlines():
    temp = []
    # print(txt_str)
    datas = txt_str.strip()
    datas = datas.replace('[', '')
    datas = datas.replace(']', '')
    datas = datas.split(',')
    print(datas)
    for data in datas:
        # print(data)
        data = float(data)
        temp.append(data)
    # print(temp)
    train.append(temp)
    labels.append(0)


print('Reading train_close.txt...')
line_ctr = 0
temp = []
for txt_str in train_close_txt.readlines():
    temp = []
    # print(txt_str)
    datas = txt_str.strip()
    datas = datas.replace('[', '')
    datas = datas.replace(']', '')
    datas = datas.split(',')
    print(datas)
    for data in datas:
        # print(data)
        data = float(data)
        temp.append(data)
    # print(temp)
    train.append(temp)
    labels.append(1)


for i in range(len(labels)):
    print("{0} --> {1}".format(train[i], labels[i]))


train_close_txt.close()
train_open_txt.close()


# print(train)
# print(labels)
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
从两个txt文件中解析数据,提取出特征向量,放入列表train中,同时并把对应的标签放入列表labels中。程序写的很简单,就不注释了。


训练并保存模型


clf = svm.SVC(C=0.8, kernel='linear', gamma=20, decision_function_shape='ovo')
clf.fit(train, labels)
joblib.dump(clf, "ear_svm.m")
1
2
3
这里使用sickit-learn中的svm模块,SVM本身实现还是比较复杂的,但是这里为了简便就直接调用实现好的api函数了。 
稍微介绍一下参数: 
C=0.8表示软间隔; 
kernel='linear'表示采用线性核;kernel='rbf'时(default),为高斯核,gamma值越小,分类界面越连续;gamma值越大,分类界面越“散”; 
decision_function_shape='ovr',表示one v rest,即一个类别与其他类别划分,多分类;decision_function_shape='ovo',表示one v one,即一个类别与另一个类别划分,二分类;


使用joblib模块,我们会将模型文件保存到当前文件夹中。 




测试准确率


一般来说我们还需要另外准备一部分测试集,来对我们的模型进行评估。考虑到篇幅可能过大,删去了那一部分。直接取几个样本简单测试一下,看下输出。


print('predicting [[0.34, 0.34, 0.31]]')
res = clf.predict([[0.34, 0.34, 0.31]])
print(res)


print('predicting [[0.19, 0.18, 0.18]]')
res = clf.predict([[0.19, 0.18, 0.18]])
print(res)
1
2
3
4
5
6
7




这种做法其实并不严谨,正确的做法是我们要像前面一样另外采集一组测试集,或是从已经采集好的数据中分出一部分作为测试集,随后计算准确率进行评估。考虑到篇幅限制,这里只给出了思路,程序实现无非就是那前面的代码改一改。


进行实时检测


这一段的代码跟程序1很类似,唯一的区别就是检测部分采用了SVM。下面就直接贴代码了。 
注意一点,就是所有的程序中的VECTOR_SIZE一定要保持一致,因为这是你的特征向量的维度。


程序实现


#coding=utf-8  
import numpy as np 
import cv2
import dlib
from scipy.spatial import distance
import os
from imutils import face_utils
from sklearn import svm
from sklearn.externals import joblib


VECTOR_SIZE = 3
def queue_in(queue, data):
    ret = None
    if len(queue) >= VECTOR_SIZE:
        ret = queue.pop(0)
    queue.append(data)
    return ret, queue


def eye_aspect_ratio(eye):
    # print(eye)
    A = distance.euclidean(eye[1], eye[5])
    B = distance.euclidean(eye[2], eye[4])
    C = distance.euclidean(eye[0], eye[3])
    ear = (A + B) / (2.0 * C)
    return ear


pwd = os.getcwd()
model_path = os.path.join(pwd, 'model')
shape_detector_path = os.path.join(model_path, 'shape_predictor_68_face_landmarks.dat')


detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(shape_detector_path)


# 导入模型
clf = joblib.load("ear_svm.m")


EYE_AR_THRESH = 0.3# EAR阈值
EYE_AR_CONSEC_FRAMES = 3# 当EAR小于阈值时,接连多少帧一定发生眨眼动作


# 对应特征点的序号
RIGHT_EYE_START = 37 - 1
RIGHT_EYE_END = 42 - 1
LEFT_EYE_START = 43 - 1
LEFT_EYE_END = 48 - 1


frame_counter = 0
blink_counter = 0
ear_vector = []
cap = cv2.VideoCapture(1)
while(1):
    ret, img = cap.read()


    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    rects = detector(gray, 0)
    for rect in rects:
        print('-'*20)
        shape = predictor(gray, rect)
        points = face_utils.shape_to_np(shape)# convert the facial landmark (x, y)-coordinates to a NumPy array
        # points = shape.parts()
        leftEye = points[LEFT_EYE_START:LEFT_EYE_END + 1]
        rightEye = points[RIGHT_EYE_START:RIGHT_EYE_END + 1]
        leftEAR = eye_aspect_ratio(leftEye)
        rightEAR = eye_aspect_ratio(rightEye)
        print('leftEAR = {0}'.format(leftEAR))
        print('rightEAR = {0}'.format(rightEAR))


        ear = (leftEAR + rightEAR) / 2.0


        leftEyeHull = cv2.convexHull(leftEye)
        rightEyeHull = cv2.convexHull(rightEye)
        cv2.drawContours(img, [leftEyeHull], -1, (0, 255, 0), 1)
        cv2.drawContours(img, [rightEyeHull], -1, (0, 255, 0), 1)


        ret, ear_vector = queue_in(ear_vector, ear)
        if(len(ear_vector) == VECTOR_SIZE):
            print(ear_vector)
            input_vector = []
            input_vector.append(ear_vector)
            res = clf.predict(input_vector)
            print(res)


            if res == 1:
                frame_counter += 1
            else:
                if frame_counter >= EYE_AR_CONSEC_FRAMES:
                    blink_counter += 1
                frame_counter = 0


        cv2.putText(img, "Blinks:{0}".format(blink_counter), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,0,255), 2)
        cv2.putText(img, "EAR:{:.2f}".format(ear), (300, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,0,255), 2)




    cv2.imshow("Frame", img)


    if cv2.waitKey(1) & 0xFF == ord("q"):
        break


cap.release()
cv2.destroyAllWindows()


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
运行结果


注:论文的原作者说使用眼长宽比(第 N-6 帧到第 N + 6帧)的13维特征向量,然后将该特征向量馈送到线性SVM分类,可以实现更好的效果。我尝试了13维的情况,发现延迟太厉害,在你眨眼之后,要过一下子才能检测到。因为我们是一帧一帧计算EAR然后才送入特征向量更新的,在摄像头帧数低时,可能还是要使用低一些维度的特征向量,所以在程序中我是用了3维的特征向量。










后记


本来只是看了下论文,打算玩一下眨眼检测的。结果在调试程序过程中还是遇到了不少坑,不知不觉就花了不少时间。尤其是选择特征向量维度时,我试了3维、6维、13维等的特征向量,每次都是专门采集了1000多组正样本和1000多组负样本,训练结果是3维的比较好。更大的原因还是我的摄像头帧率太低吧,理论上来说,维度更高能得到更高的准确率,但是由于帧率低导致特征向量更新太慢,以致于延迟过长。
--------------------- 
作者:hongbin_xu 
来源:CSDN 
原文:https://blog.csdn.net/hongbin_xu/article/details/79033116 
版权声明:本文为博主原创文章,转载请附上博文链接!
阅读(784) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册