这是我的本科毕设题目，刚开始接触机器学习这方面，感谢CSDN和GitHub上的大佬，网上类似项目很多，方法也有很多，自己顺带进行了整理，边做毕设边分享一下自己学习心得吧，也算是梳理一下所学知识，各大佬有什么好的建议还请指出，不吝赐教。

项目简介：基于Win10 + Python3.7的环境，利用Python的OpenCV、Sklearn和PyQt5等库搭建了一个较为完整的手势识别系统，用于识别日常生活中1-10的静态手势。

整个项目的资源：https://download.csdn.net/download/qq_41562704/11471042（包含手势库和已训练的模型，可以直接运行使用）

环境：Win10 + Python3.7 + OpenCV3.4.5，各个库的安装就不多说了

最终的效果图如图所示：

整个项目分为四个部分，即预处理，特征提取，模型训练，界面设计

预处理

1.获取手势

2.图像预处理

2.1去噪

2.2 肤色检测 + 二值化处理

2.3 形态学处理

2.4 轮廓提取

特征提取

3 傅里叶算子提取

4 建立特征库

4.1 数据增强

4.2 计算手势库的特征

模型训练

5 训练SVM模型

界面设计

6 PyQt设计界面

预处理

这部分需要完成摄像头录制手势后，提取出手的轮廓线

这部分参考资料：

https://blog.csdn.net/ifruoxi/article/details/78091954（获取手势，基于Python）

https://blog.csdn.net/qq_22527639/article/details/81501565（肤色检测：方法全，理论介绍的也很全面，基于C++）

https://blog.csdn.net/shadow_guo/article/details/43602051（基于RGB空间肤色检测，基于Python）

https://blog.csdn.net/weixin_40893939/article/details/84527037（基于HSV空间和YCrCb空间肤色检测，基于Python）

https://blog.csdn.net/Eastmount/article/details/83581277（腐蚀膨胀理论介绍，基于Python）

https://blog.csdn.net/dz4543/article/details/80655067（轮廓提取，基于Python）

1.获取手势

主要是调用OpenCV，创建main.py和 picture.py

main.py 当前负责录像，picture负责处理图像

main.py

  1. import cv2
  2. import picture as pic
  3. font = cv2.FONT_HERSHEY_SIMPLEX #设置字体
  4. size = 0.5 #设置大小
  5. width, height = 300, 300 #设置拍摄窗口大小
  6. x0,y0 = 300, 100 #设置选取位置
  7. cap = cv2.VideoCapture(0) #开摄像头
  8. if __name__ == "__main__":
  9. while(1):
  10. ret, frame = cap.read() #读取摄像头的内容
  11. frame = cv2.flip(frame, 2)
  12. roi = pic.binaryMask(frame, x0, y0, width, height) #取手势所在框图并进行处理
  13. key = cv2.waitKey(1) & 0xFF#按键判断并进行一定的调整
  14. #按'j''l''u''j'分别将选框左移，右移，上移，下移
  15. #按'q'键退出录像
  16. if key == ord('i'):
  17. y0 += 5
  18. elif key == ord('k'):
  19. y0 -= 5
  20. elif key == ord('l'):
  21. x0 += 5
  22. elif key == ord('j'):
  23. x0 -= 5
  24. if key == ord('q'):
  25. break
  26. cv2.imshow('frame', frame) #播放摄像头的内容
  27. cap.release()
  28. cv2.destroyAllWindows() #关闭所有窗口

2.图像预处理

预处理在picture.py中完成。

预处理的主要步骤为：去噪 -> 肤色检测 -> 二值化 -> 形态学处理 -> 轮廓提取，其中最麻烦的两项为肤色检测和轮廓提取。

2.1去噪

即滤波，主要是为了实现对图像噪声的消除，增强图像的效果，其实个人感觉这里滤波的作用不是很明显，也可以选择不滤波，在肤色检测后会有二次滤波。

  1. #以3*3的模板进行均值滤波
  2. blur = cv2.blur(roi, (3,3))
  3. #以3*3的模板进行高斯滤波，最后一个参数表示x与y方向的标准差，给0的话，函数会自己运算
  4. blur = cv2.GaussianBlur(roi, (3,3), 0)
  5. #中值滤波
  6. blur = cv2.medianBlur(roi,5)
  7. #双边滤波，9为区域的直径，后面两个参数是空间高斯函数标准差和灰度值相似性高斯函数标准差
  8. blur = cv2.bilateralFilter(img,9,75,75)

均值滤波器、高斯滤波器、中值滤波器、双边滤波器都可以进行使用。推荐使用双边滤波器，该滤波器考虑了图像的空间关系，也考虑图像的灰度关系。双边滤波同时使用了空间高斯权重和灰度相似性高斯权重，确保了边界不会被模糊掉。不过我在处理中直接省去了去噪这个过程。

2.2 肤色检测 + 二值化处理

picture.py

方法一：基于RGB颜色空间

判断条件：

在均匀光照下，R>95 AND G>40 B>20 AND MAX(R,G,B)-MIN(R,G,B)>15 AND ABS(R-G)>15 AND R>G AND R>B；

在侧光拍摄环境下，R>220 AND G>210 AND B>170 AND ABS(R-G)<=15 AND R>B AND G>B

  1. import cv2
  2. import numpy as np
  3. def binaryMask(frame, x0, y0, width, height):
  4. cv2.rectangle(frame,(x0,y0),(x0+width, y0+height),(0,255,0)) #画出截取的手势框图
  5. roi = frame[y0:y0+height, x0:x0+width] #获取手势框图
  6. cv2.imshow("roi", roi) #显示手势框图
  7. res = skinMask(roi) #进行肤色检测
  8. cv2.imshow("res", res) #显示肤色检测后的图像
  9. return res
  10. ##########方法一###################
  11. ##########BGR空间的手势识别#########
  12. def skinMask(roi):
  13. rgb = cv2.cvtColor(roi, cv2.COLOR_BGR2RGB) #转换到RGB空间
  14. (R,G,B) = cv2.split(rgb) #获取图像每个像素点的RGB的值，即将一个二维矩阵拆成三个二维矩阵
  15. skin = np.zeros(R.shape, dtype = np.uint8) #掩膜
  16. (x,y) = R.shape #获取图像的像素点的坐标范围
  17. for i in range(0, x):
  18. for j in range(0, y):
  19. #判断条件，不在肤色范围内则将掩膜设为黑色，即255
  20. if (abs(R[i][j] - G[i][j]) > 15) and (R[i][j] > G[i][j]) and (R[i][j] > B[i][j]):
  21. if (R[i][j] > 95) and (G[i][j] > 40) and (B[i][j] > 20) \
  22. and (max(R[i][j],G[i][j],B[i][j]) - min(R[i][j],G[i][j],B[i][j]) > 15):
  23. skin[i][j] = 255
  24. elif (R[i][j] > 220) and (G[i][j] > 210) and (B[i][j] > 170):
  25. skin[i][j] = 255
  26. res = cv2.bitwise_and(roi,roi, mask = skin) #图像与运算
  27. return res

效果图：

方法二：基于HSV颜色空间

判断条件：0<=H<=20，S>=48，V>=50

肤色检测的方式不同影响的是skinMask，之后的代码只是修改skinMask函数，picture.py中其他代码不需要改动。

  1. ##########方法二###################
  2. ########HSV颜色空间H范围筛选法######
  3. def skinMask(roi):
  4. low = np.array([0, 48, 50]) #最低阈值
  5. high = np.array([20, 255, 255]) #最高阈值
  6. hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) #转换到HSV空间
  7. mask = cv2.inRange(hsv,low,high) #掩膜，不在范围内的设为255
  8. res = cv2.bitwise_and(roi,roi, mask = mask) #图像与运算
  9. return res

效果图：

方法三：椭圆肤色检测模型

在YCrCb空间，肤色像素点会聚集到一个椭圆区域。先定义一个椭圆模型，然后将每个RGB像素点转换到YCrCb空间比对是否在椭圆区域，是的话判断为皮肤。

  1. ##########方法三###################
  2. #########椭圆肤色检测模型##########
  3. def skinMask(roi):
  4. skinCrCbHist = np.zeros((256,256), dtype= np.uint8)
  5. cv2.ellipse(skinCrCbHist, (113,155),(23,25), 43, 0, 360, (255,255,255), -1) #绘制椭圆弧线
  6. YCrCb = cv2.cvtColor(roi, cv2.COLOR_BGR2YCR_CB) #转换至YCrCb空间
  7. (y,Cr,Cb) = cv2.split(YCrCb) #拆分出Y,Cr,Cb值
  8. skin = np.zeros(Cr.shape, dtype = np.uint8) #掩膜
  9. (x,y) = Cr.shape
  10. for i in range(0, x):
  11. for j in range(0, y):
  12. if skinCrCbHist [Cr[i][j], Cb[i][j]] > 0: #若不在椭圆区间中
  13. skin[i][j] = 255
  14. res = cv2.bitwise_and(roi,roi, mask = skin)
  15. return res

效果图：

方法四：YCrCb颜色空间的Cr分量+Otsu法阈值分割算法

针对YCrCb中Cr分量的处理，对CR通道单独进行Otsu处理，Otsu方法opencv里用threshold，Otsu算法是对图像的灰度级进行聚类。

  1. ################方法四####################
  2. ####YCrCb颜色空间的Cr分量+Otsu法阈值分割算法
  3. def skinMask(roi):
  4. YCrCb = cv2.cvtColor(roi, cv2.COLOR_BGR2YCR_CB) #转换至YCrCb空间
  5. (y,cr,cb) = cv2.split(YCrCb) #拆分出Y,Cr,Cb值
  6. cr1 = cv2.GaussianBlur(cr, (5,5), 0)
  7. _, skin = cv2.threshold(cr1, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) #Ostu处理
  8. res = cv2.bitwise_and(roi,roi, mask = skin)
  9. return res

效果图：

方法五：Cr，Cb范围筛选法

该方法与方法一、二类似，不同的只是颜色空间不相同

判断条件：133<=Cr<=173 77<=Cb<=127

  1. ##########方法五###################
  2. ########Cr，Cb范围筛选法###########
  3. def skinMask(roi):
  4. YCrCb = cv2.cvtColor(roi, cv2.COLOR_BGR2YCR_CB) #转换至YCrCb空间
  5. (y,cr,cb) = cv2.split(YCrCb) #拆分出Y,Cr,Cb值
  6. skin = np.zeros(cr.shape, dtype = np.uint8)
  7. (x,y) = cr.shape
  8. for i in range(0, x):
  9. for j in range(0, y):
  10. #每个像素点进行判断
  11. if(cr[i][j] > 130) and (cr[i][j] < 175) and (cb[i][j] > 77) and (cb[i][j] < 127):
  12. skin[i][j] = 255
  13. res = cv2.bitwise_and(roi,roi, mask = skin)
  14. return res

效果图：

方法六：OpenCV自带AdaptiveSkinDetector

关于该函数的使用可以参考http://www.cnblogs.com/tornadomeet/archive/2012/11/20/2778740.html

最终方案选择：在几种方式中选择效果比较好的，RGB和HSV的效果一般，而且曝光的话，效果更差，YCrCb是一个单独把亮度分离开来的颜色模型，使用这个颜色模型的话，像肤色不会受到光线亮度而发生改变，方法三和四均可。

2.3 形态学处理

即便是比较好的肤色检测算法，分割出来的手势，也难免有黑点，或者背景有白点，这时候需要对分割出来的手势图进行进一步处理，主要是腐蚀膨胀两个操作。

腐蚀和膨胀是针对白色部分（高亮部分而言）。从数学角度来说，膨胀或者腐蚀操作就是将图像（或图像的一部分区域，称之为A）与核（称之为B）进行卷积。 
膨胀就是求局部最大值操作，即计算核B覆盖的区域的像素点的最大值，并把这个最大值赋值给参考点指定的像素，这样就会使图像中的高亮区域逐渐增长。 
腐蚀就是求局部最小值操作，即计算核B覆盖的区域的像素点的最小值，并把这个最小值赋值给参考点指定的像素，这样就会使图像中的高亮区域逐渐减少。

开运算：先腐蚀后膨胀，去除孤立的小点，毛刺

闭运算：先膨胀后腐蚀，填平小孔，弥合小裂缝

在binaryMask函数中return前面添加以下代码，进行开运算

  1. kernel = np.ones((3,3), np.uint8) #设置卷积核
  2. erosion = cv2.erode(res, kernel) #腐蚀操作
  3. cv2.imshow("erosion",erosion)
  4. dilation = cv2.dilate(erosion, kernel)#膨胀操作
  5. cv2.imshow("dilation",dilation)

效果如图：

可以看到背景杂质点去掉了

2.4 轮廓提取

在binaryMask函数中return前面添加以下代码，对肤色检测后的图像提取手势区域

  1. binaryimg = cv2.Canny(res, 50, 200) #二值化，canny检测
  2. h = cv2.findContours(binaryimg,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE) #寻找轮廓
  3. contours = h[1] #提取轮廓
  4. ret = np.ones(res.shape, np.uint8) #创建黑色幕布
  5. cv2.drawContours(ret,contours,-1,(255,255,255),1) #绘制白色轮廓
  6. cv2.imshow("ret", ret)

特征提取

这部分主要任务是对第一部分提取的轮廓点坐标提取出他们的傅里叶描述子，建立手势特征库

参考资料：

https://github.com/timfeirg/Fourier-Descriptors（提取特征代码比较完整）

https://github.com/alessandroferrari/elliptic-fourier-descriptors（椭圆傅里叶描述子的提取）

https://www.cnblogs.com/edie0902/p/3658174.html（傅里叶算子的数学思想）

3 傅里叶算子提取

将picture.py中的提取轮廓点部分删去，添加

  1. import fourierDescriptor as fd
  2. ret, fourier_result = fd.fourierDesciptor(res)

创建fourierDescriptor.py

在这个文件中完成对轮廓点坐标的傅里叶描述子的提取，具体代码如下：

  1. import cv2
  2. import numpy as np
  3. MIN_DESCRIPTOR = 32 # surprisingly enough, 2 descriptors are already enough
  4. ##计算傅里叶描述子
  5. def fourierDesciptor(res):
  6. #Laplacian算子进行八邻域检测
  7. gray = cv2.cvtColor(res, cv2.COLOR_BGR2GRAY)
  8. dst = cv2.Laplacian(gray, cv2.CV_16S, ksize = 3)
  9. Laplacian = cv2.convertScaleAbs(dst)
  10. contour = find_contours(Laplacian)#提取轮廓点坐标
  11. contour_array = contour[0][:, 0, :]#注意这里只保留区域面积最大的轮廓点坐标
  12. ret_np = np.ones(dst.shape, np.uint8) #创建黑色幕布
  13. ret = cv2.drawContours(ret_np,contour[0],-1,(255,255,255),1) #绘制白色轮廓
  14. contours_complex = np.empty(contour_array.shape[:-1], dtype=complex)
  15. contours_complex.real = contour_array[:,0]#横坐标作为实数部分
  16. contours_complex.imag = contour_array[:,1]#纵坐标作为虚数部分
  17. fourier_result = np.fft.fft(contours_complex)#进行傅里叶变换
  18. #fourier_result = np.fft.fftshift(fourier_result)
  19. descirptor_in_use = truncate_descriptor(fourier_result)#截短傅里叶描述子
  20. #reconstruct(ret, descirptor_in_use)
  21. return ret, descirptor_in_use
  22. def find_contours(Laplacian):
  23. #binaryimg = cv2.Canny(res, 50, 200) #二值化，canny检测
  24. h = cv2.findContours(Laplacian,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE) #寻找轮廓
  25. contour = h[1]
  26. contour = sorted(contour, key = cv2.contourArea, reverse=True)#对一系列轮廓点坐标按它们围成的区域面积进行排序
  27. return contour
  28. #截短傅里叶描述子
  29. def truncate_descriptor(fourier_result):
  30. descriptors_in_use = np.fft.fftshift(fourier_result)
  31. #取中间的MIN_DESCRIPTOR项描述子
  32. center_index = int(len(descriptors_in_use) / 2)
  33. low, high = center_index - int(MIN_DESCRIPTOR / 2), center_index + int(MIN_DESCRIPTOR / 2)
  34. descriptors_in_use = descriptors_in_use[low:high]
  35. descriptors_in_use = np.fft.ifftshift(descriptors_in_use)
  36. return descriptors_in_use
  37. ##由傅里叶描述子重建轮廓图
  38. def reconstruct(img, descirptor_in_use):
  39. #descirptor_in_use = truncate_descriptor(fourier_result, degree)
  40. #descirptor_in_use = np.fft.ifftshift(fourier_result)
  41. #descirptor_in_use = truncate_descriptor(fourier_result)
  42. #print(descirptor_in_use)
  43. contour_reconstruct = np.fft.ifft(descirptor_in_use)
  44. contour_reconstruct = np.array([contour_reconstruct.real,
  45. contour_reconstruct.imag])
  46. contour_reconstruct = np.transpose(contour_reconstruct)
  47. contour_reconstruct = np.expand_dims(contour_reconstruct, axis = 1)
  48. if contour_reconstruct.min() < 0:
  49. contour_reconstruct -= contour_reconstruct.min()
  50. contour_reconstruct *= img.shape[0] / contour_reconstruct.max()
  51. contour_reconstruct = contour_reconstruct.astype(np.int32, copy = False)
  52. black_np = np.ones(img.shape, np.uint8) #创建黑色幕布
  53. black = cv2.drawContours(black_np,contour_reconstruct,-1,(255,255,255),1) #绘制白色轮廓
  54. cv2.imshow("contour_reconstruct", black)
  55. #cv2.imwrite('recover.png',black)
  56. return black

这里需要注意：

轮廓提取后进行了二次去噪，即只保留区域面积最大的曲线，效果如图

其次关于利用傅里叶算子重建轮廓图，在实际使用过程中并不需要，仅仅为了在测试阶段检验效果

取32项傅里叶算子的时候，重建效果如下，基本可以还原手势形状。

4 建立特征库

这个部分的任务是采集手势1-10，同时利用旋转平移等操作对得到的手势库进行扩充。然后对整个手势库中的每张照片中的手势轮廓线计算傅里叶描述子并保存。我采取的方案是每个手势采集20份，然后扩充为200份，这里的数目可以自己调节。保存格式为"x_i"，表示手势_x的第i张图片

4.1 数据增强

在数据增强前，先采集手势，在项目文件夹中创建一个“image”文件夹保存样本库，"test_image"保存测试库（看需求，可以不用）

创建data_augmention.py

对测试库进行操作的时候仅仅需要修改一下path及相关的数字

  1. import random
  2. import cv2
  3. path = './' + 'image' + '/'
  4. #旋转
  5. def rotate(image, scale=0.9):
  6. angle = random.randrange(-90, 90)#随机角度
  7. w = image.shape[1]
  8. h = image.shape[0]
  9. #rotate matrix
  10. M = cv2.getRotationMatrix2D((w/2,h/2), angle, scale)
  11. #rotate
  12. image = cv2.warpAffine(image,M,(w,h))
  13. return image
  14. if __name__ == "__main__":
  15. for i in range(5, 6):
  16. cnt = 21#计数
  17. for j in range(1, 21):
  18. roi = cv2.imread(path + str(i) + '_' + str(j)+'.png')
  19. for k in range(12):
  20. img_rotation = rotate(roi)#旋转
  21. cv2.imwrite(path + str(i) + '_' + str(cnt)+ '.png',img_rotation)
  22. cnt += 1
  23. img_flip = cv2.flip(img_rotation,1)#翻转
  24. cv2.imwrite(path + str(i) + '_' + str(cnt)+ '.png',img_flip)
  25. cnt += 1
  26. print(i,'_',j,'完成')

4.2 计算手势库的特征

创建loadData.py文件

  1. import fourierDescriptor as fd
  2. import cv2
  3. import numpy as np
  4. path = './' + 'feature' + '/'
  5. path_img = './' + 'image' + '/'
  6. if __name__ == "__main__":
  7. for i in range(1, 11):
  8. for j in range(1, 201):
  9. roi = cv2.imread(path_img + str(i) + '_' + str(j) + '.png')
  10. descirptor_in_use = abs(fd.fourierDesciptor(roi))
  11. fd_name = path + str(i) + '_' + str(j) + '.txt'
  12. # fd_name = path + str(i) + '.txt'
  13. with open(fd_name, 'w', encoding='utf-8') as f:
  14. temp = descirptor_in_use[1]
  15. for k in range(1, len(descirptor_in_use)):
  16. x_record = int(100 * descirptor_in_use[k] / temp)
  17. f.write(str(x_record))
  18. f.write(' ')
  19. f.write('\n')
  20. print(i, '_', j, '完成')

对手势库中10个手势的200份图片一一进行操作，保存的特征的格式与图片格式一致，用txt文件进行保存

模型训练

这个部分的主要任务是利用已有的样本库训练SVM模型并保存

这部分参考资料：

https://cuijiahua.com/blog/2017/11/ml_8_svm_1.html（SVM的原理）

https://cuijiahua.com/blog/2017/11/ml_9_svm_2.html（sklearn的使用）

https://blog.csdn.net/qysh123/article/details/80063447（SVM调参）

5 训练SVM模型

使用网格搜索法进行调参，利用joblib模块保存模型

  1. import numpy as np
  2. from os import listdir
  3. from sklearn.externals import joblib
  4. from functools import reduce
  5. from sklearn.svm import SVC
  6. from sklearn.model_selection import GridSearchCV
  7. import matplotlib.pyplot as plt
  8. path = './' + 'feature' + '/'
  9. model_path = "./model/"
  10. test_path = "./test_feature/"
  11. test_accuracy = []
  12. #读txt文件并将每个文件的描述子改为一维的矩阵存储
  13. def txtToVector(filename, N):
  14. returnVec = np.zeros((1,N))
  15. fr = open(filename)
  16. lineStr = fr.readline()
  17. lineStr = lineStr.split(' ')
  18. for i in range(N):
  19. returnVec[0, i] = int(lineStr[i])
  20. return returnVec
  21. def tran_SVM(N):
  22. svc = SVC()
  23. parameters = {'kernel':('linear', 'rbf'),
  24. 'C':[1, 3, 5, 7, 9, 11, 13, 15, 17, 19],
  25. 'gamma':[0.00001, 0.0001, 0.001, 0.1, 1, 10, 100, 1000]}#预设置一些参数值
  26. hwLabels = []#存放类别标签
  27. trainingFileList = listdir(path)
  28. m = len(trainingFileList)
  29. trainingMat = np.zeros((m,N))
  30. for i in range(m):
  31. fileNameStr = trainingFileList[i]
  32. classNumber = int(fileNameStr.split('_')[0])
  33. hwLabels.append(classNumber)
  34. trainingMat[i,:] = txtToVector(path+fileNameStr,N)#将训练集改为矩阵格式
  35. print("数据加载完成")
  36. clf = GridSearchCV(svc, parameters, cv=5, n_jobs=8)#网格搜索法，设置5-折交叉验证
  37. clf.fit(trainingMat,hwLabels)
  38. print(clf.return_train_score)
  39. print(clf.best_params_)#打印出最好的结果
  40. best_model = clf.best_estimator_
  41. print("SVM Model save...")
  42. save_path = model_path + "svm_efd_" + "train_model.m"
  43. joblib.dump(best_model,save_path)#保存最好的模型
  44. def test_SVM(clf,N):
  45. testFileList = listdir(test_path)
  46. errorCount = 0#记录错误个数
  47. mTest = len(testFileList)
  48. for i in range(mTest):
  49. fileNameStr = testFileList[i]
  50. classNum = int(fileNameStr.split('_')[0])
  51. vectorTest = txtToVector(test_path+fileNameStr,N)
  52. valTest = clf.predict(vectorTest)
  53. #print("分类返回结果为%d\t真实结果为%d" % (valTest, classNum))
  54. if valTest != classNum:
  55. errorCount += 1
  56. print("总共错了%d个数据\n错误率为%f%%" % (errorCount, errorCount/mTest * 100))
  57. ####训练 + 验证#####
  58. if __name__ == "__main__":
  59. tran_SVM(31)
  60. clf = joblib.load(model_path + "svm_efd_" + "train_model.m")
  61. test_SVM(clf,31)

训练结果如图：

界面设计

字面意思，这部分的任务就是设计一个界面可以实时调用已经训练好的模型预测手势

小声嘀咕一句：原来Python有这么好用的写界面的库呀(。-ω-)zzz

这个部分也不是必须的，只不过为了稍微好看那么一点，可以直接修改main.py，使得按p的时候就进行预测

  1. import classfier as cf
  2. ......
  3. elif key == ord('p'):
  4. descirptor_in_use = abs(fourier_result)
  5. fd_test = np.zeros((1,31))
  6. temp = descirptor_in_use[1]
  7. for k in range(1,len(descirptor_in_use)):
  8. fd_test[0,k-1] = int(100 * descirptor_in_use[k] / temp)
  9. test_svm = cf.test_fd(fd_test)
  10. print("test_svm =",test_svm)
  11. test_svm_efd = cf.test_efd(efd_test)
  12. print("test_svm_efd =",test_svm_efd)
  13. cv2.imshow('frame', frame) #播放摄像头的内容

这部分参考资料：

https://blog.csdn.net/niuyongjie/article/details/81161559（PyQt安装，我安装的是5.11.3版本）

http://code.py40.com/pyqt5/16.html（PyQt教程）

6 PyQt设计界面

创建myGUI.py文件

第一次用PyQt这个库，所以尺寸方面的控制用来最古老的方式（数字控制）还请大家见谅(╥╯^╰╥)

  1. import sys
  2. from PyQt5.QtWidgets import QApplication, QWidget, QToolTip, \
  3. QPushButton,QMessageBox,QDesktopWidget, QLabel
  4. from PyQt5.QtGui import QFont,QIcon,QPixmap,QImage
  5. from PyQt5.QtCore import QTimer
  6. import cv2
  7. import picture as pic
  8. import classify as cf
  9. import numpy as np
  10. class myWindow(QWidget):
  11. def __init__(self,parent = None):
  12. super(myWindow,self).__init__(parent)
  13. self.timer_camera = QTimer()
  14. self.cap = cv2.VideoCapture()
  15. self.initUI()
  16. self.slot_init()
  17. def initUI(self):
  18. self.mylabel()
  19. self.myButton()
  20. self.myLabelPic()
  21. self.setFixedSize(670,520)
  22. self.center()
  23. self.setWindowIcon(QIcon('icon.jpg'))
  24. self.setWindowTitle('gesture recognition')
  25. def mylabel(self):
  26. label_roi = QLabel('原图',self)
  27. label_roi.setStyleSheet("QLabel{font-size:18px;}")
  28. label_roi.resize(60,30)
  29. label_roi.move(120,15)
  30. label_res = QLabel('轮廓线', self)
  31. label_res.setStyleSheet("QLabel{font-size:18px;}")
  32. label_res.resize(60, 30)
  33. label_res.move(480, 15)
  34. label_pre = QLabel('预测', self)
  35. label_pre.setStyleSheet("QLabel{font-size:20px;}")
  36. label_pre.resize(50,30)
  37. label_pre.move(400,400)
  38. label_result = QLabel('结果', self)
  39. label_result.setStyleSheet("QLabel{font-size:20px;}")
  40. label_result.resize(50, 30)
  41. label_result.move(400,430)
  42. def myLabelPic(self):
  43. self.label_show_roi = QLabel(self)
  44. self.label_show_roi.setFixedSize(301,301)
  45. self.label_show_roi.move(20,50)
  46. self.label_show_roi.setStyleSheet("QLabel{background:white;}")
  47. self.label_show_roi.setAutoFillBackground(True)
  48. self.label_show_ret = QLabel(self)
  49. self.label_show_ret.setFixedSize(301, 301)
  50. self.label_show_ret.move(350, 50)
  51. self.label_show_ret.setStyleSheet("QLabel{background:white;}")
  52. self.label_show_ret.setAutoFillBackground(True)
  53. self.label_show_recognition = QLabel('0',self)
  54. self.label_show_recognition.setStyleSheet("QLabel{background:white;}")
  55. self.label_show_recognition.setStyleSheet("QLabel{font-size:50px;}")
  56. self.label_show_recognition.setFixedSize(100,100)
  57. self.label_show_recognition.move(500, 380)
  58. self.label_show_recognition.setAutoFillBackground(True)
  59. def myButton(self):
  60. QToolTip.setFont(QFont('SansSerif', 10))
  61. self.button_open_camera = QPushButton('打开相机', self)
  62. self.button_open_camera.setToolTip('按i,k,j,l可以进行上下左右调整')
  63. self.button_open_camera.resize(100,30)
  64. self.button_open_camera.move(100, 400)
  65. self.butoon_recognition = QPushButton('开始预测', self)
  66. self.butoon_recognition.setFixedSize(100, 30)
  67. self.butoon_recognition.move(100, 450)
  68. def slot_init(self):
  69. self.button_open_camera.clicked.connect(self.button_open_camera_click)
  70. self.butoon_recognition.clicked.connect(self.button_recognition_click)
  71. self.timer_camera.timeout.connect(self.show_camera)
  72. def button_open_camera_click(self):
  73. if self.timer_camera.isActive() == False:
  74. self.cap.open(0)
  75. self.timer_camera.start(30)
  76. self.button_open_camera.setText(u'关闭相机')
  77. else:
  78. self.timer_camera.stop()
  79. self.cap.release()
  80. self.label_show_roi.clear()
  81. self.label_show_ret.clear()
  82. self.label_show_recognition.setText('0')
  83. self.button_open_camera.setText(u'打开相机')
  84. def button_recognition_click(self):
  85. descirptor_in_use = abs(self.fourier_result)
  86. fd_test = np.zeros((1, 31))
  87. temp = descirptor_in_use[1]
  88. for k in range(1, len(descirptor_in_use)):
  89. fd_test[0, k - 1] = int(100 * descirptor_in_use[k] / temp)
  90. efd_test = np.zeros((1, 15))
  91. for k in range(1, len(self.efd_result)):
  92. temp = np.sqrt(self.efd_result[k][0] ** 2 + self.efd_result[k][1] ** 2) + np.sqrt(
  93. self.efd_result[k][2] ** 2 + self.efd_result[k][3] ** 2)
  94. efd_test[0, k - 1] = (int(1000 * temp))
  95. test_knn, test_svm = cf.test_fd(fd_test)
  96. print("test_knn =", test_knn)
  97. print("test_svm =", test_svm)
  98. test_knn_efd, test_svm_efd = cf.test_efd(efd_test)
  99. print("test_knn_efd =", test_knn_efd)
  100. print("test_svm_efd =", test_svm_efd)
  101. num = [0]*11
  102. num[test_knn[0]] += 1
  103. num[test_svm[0]] += 1
  104. num[test_knn_efd[0]] += 1
  105. num[test_svm_efd[0]] += 1
  106. res = 0
  107. for i in range(1, 11):
  108. if num[i] >= 2:
  109. res = i
  110. break
  111. print(res)
  112. self.label_show_recognition.setText(str(res))
  113. def show_camera(self):
  114. width, height = 300, 300 # 设置拍摄窗口大小
  115. x0, y0 = 300, 100 # 设置选取位置
  116. flag, frame = self.cap.read()
  117. roi, res, ret, self.fourier_result, self.efd_result = pic.binaryMask(frame, x0, y0, width, height)
  118. roi = cv2.cvtColor(roi, cv2.COLOR_BGR2RGB)
  119. show_roi = QImage(roi.data, roi.shape[1], roi.shape[0], QImage.Format_RGB888)
  120. show_ret = QImage(ret.data, ret.shape[1], ret.shape[0], QImage.Format_Grayscale8)
  121. self.label_show_roi.setPixmap(QPixmap.fromImage(show_roi))
  122. self.label_show_ret.setPixmap(QPixmap.fromImage(show_ret))
  123. def closeEvent(self, QCloseEvent):
  124. reply = QMessageBox.question(self, 'Message',"Are you sure to quit?",
  125. QMessageBox.Yes |QMessageBox.No, QMessageBox.No)
  126. if reply == QMessageBox.Yes:
  127. if self.cap.isOpened():
  128. self.cap.release()
  129. if self.timer_camera.isActive():
  130. self.timer_camera.stop()
  131. QCloseEvent.accept()
  132. else:
  133. QCloseEvent.ignore()
  134. def center(self):
  135. qr = self.frameGeometry()
  136. cp = QDesktopWidget().availableGeometry().center()
  137. qr.moveCenter(cp)
  138. self.move(qr.topLeft())
  139. if __name__ == "__main__":
  140. app = QApplication(sys.argv)
  141. win = myWindow()
  142. win.show()
  143. sys.exit(app.exec())

后面几个部分由于时间关系，讲得不如前面的详细，向大家表示歉意，一些细节部分建议大家下载我的源码来看。有问题的地方欢迎讨论~源码中另外也用了椭圆傅里叶描述子作为特征。

基于傅里叶算子的手势识别相关推荐

  1. Linux 手势识别,基于嵌入式Linux的手势识别技术研究

    摘要: 随着科学技术的发展,手势识别技术也得到了很大的提升,基于视觉的手势识别逐渐成为人机交互技术中的研究热点.它应用于各种控制领域,如智能控制,机械手以及手语识别等.目前,嵌入式技术和相关产品也早已 ...

  2. 深度学习-Resolution-robust Large Mask Inpainting with Fourier Convolutions基于傅里叶卷积的对分辨率鲁棒的掩模修复

    Resolution-robust Large Mask Inpainting with Fourier Convolutions基于傅里叶卷积的对分辨率鲁棒的掩模修复 0.摘要 1.概述 2.方法 ...

  3. 基于卷积神经网络的手势识别研究论文

    1.卷积神经网络 有哪些改进的地方 卷积神经网络的研究的最新进展引发了人们完善立体匹配重建热情.从概念看,基于学习算法能够捕获全局的语义信息,比如基于高光和反射的先验条件,便于得到更加稳健的匹配.目前 ...

  4. 基于深度学习的手势识别系统（Python代码，UI界面版）

    摘要:本文详细介绍基于深度学习的手势识别系统,在介绍手势识别算法原理的同时,给出了_P__y__t__h__o__n_的实现代码以及_P__y__Q__t_的UI界面.手势识别采用了基于MediaPi ...

  5. OpenCV图像处理 空间域图像增强（图像锐化 1 基于拉普拉斯算子）

    http://ggicci.blog.163.com/blog/static/210364096201262123236955/ OpenCV OpenCV 图像锐化 拉普拉斯算子 ( Laplaci ...

  6. 基于MATLAB的简单手势识别

    匆匆在看完了MOOC的<数字图像处理>,为了巩固所学,做了一个简单的手势识别(只能识别手势1.2.3)! 0.安装硬件支持包软硬件安装 0.1.MATLAB R2021b安装 软件包下载地 ...

  7. 【OpenCV图像处理入门学习教程四】基于LoG算子的图像边缘检测

    OpenCV图像处理入门学习教程系列,上一篇第三篇:基于SIFT特征和SURF特征的微旋转图像拼接与融合生成全景图像的比较 LoG边缘检测算子 LoG边缘检测算子是David Courtnay Mar ...

  8. matlab实现sobel边缘检测图像,基于Sobel算子图像边缘检测的MATLAB实现

    <基于Sobel算子图像边缘检测的MATLAB实现>由会员分享,可在线阅读,更多相关<基于Sobel算子图像边缘检测的MATLAB实现(3页珍藏版)>请在人人文库网上搜索. 1 ...

  9. 基于毫米波的远距离手势识别

    背景介绍 基于毫米波的远距手势识别可应用于智能家居.智能音箱等物联网设备应用场景下:当用户在远处做某些特定的手势时,实时系统可以自动识别并响应该手势. 该研发的基本原理是系统通过毫米波在身体上的反射信 ...

最新文章

  1. ()shi linux字符设备,Linux字符设备驱动基础（三）
  2. python3.7界面设计_基于selenium+Python3.7+yaml+Robot Framework的UI自动化测试框架
  3. 【数据结构与算法】之深入解析“课程表III”的求解思路与算法示例
  4. Git账号以及TortoiseGit配置
  5. 课堂练习课下作业----用户场景分析
  6. 张老师讲Python~
  7. java 不允许默认构造_java – 如何使用ObjectMapper去除/序列化不可变对象而不使用默认构造函数？...
  8. 宏锦软件2015年的计划
  9. 【今日CV 视觉论文速览】28 Nov 2018
  10. 音视频开发（31）---H.264格式分析
  11. （转）10条名言，让你少走弯路
  12. C++ 输出日志到 DbgView
  13. MATLAB图像处理学习日记之图像的自定义裁剪imcrop操作
  14. Python 函数的定义与调用
  15. 基于stm32的智能输液系统设计
  16. 贝塞尔曲线和B样条曲线
  17. mysql jdbc怎么用问号传参_java – jdbc PreparedStatement中的问号问题
  18. 成都精灵云-C++开发工程师-技术面经（30min左右）
  19. C2000 系列DSP使用Syscfg配置CLB模块记录
  20. redis和zookeeper实现分布式锁的区别

热门文章

  1. 洛谷 P1202 模拟 - 黑色星期五 Friday the Thirteenth
  2. c++输入输出流加速器
  3. centos7安装svn服务
  4. 【Java 笔记】 java 格式化输出
  5. ASP.NET MVC经典项目ProDinner项目解析（3）
  6. 基于SOA的体系架构设计
  7. 如何打开手机端口_微信接收图纸dwg怎么打开？如何手机查看CAD图纸，三步免费教你...
  8. 7-11 有重复的数据 (10 分)
  9. C语言简单题-找最大的字符串
  10. react 合并数组_React 常被忽视的细节。