OpenCV+MediaPipe实现手部关键点识别

快乐人L

目录

• 可视化辅助函数
  
• 单张图片
  
• 摄像头检测
  
• 改变关键点数据特征
  

可视化辅助函数

在下面的代码的注释内有大致的操作
基本操作与前面的人脸检测的操作相似，增加了可视化的辅助函数

1. import matplotlib.pyplot as plt
   
2. # 使用ipython的魔法方法，将绘制出的图像直接嵌入在notebook单元格中
   
3. import cv2
   
4. 
   
5. # 定义可视化图像函数
   
6. def look_img(img):
   
7.     '''opencv读入图像格式为BGR，matplotlib可视化格式为RGB，因此需将BGR转RGB'''
   
8.     img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
   
9.     plt.imshow(img_RGB)
   
10.     plt.show()
    
11. 
    
12. 
    
13. #调用摄像头拍照
    
14. 
    
15. time.sleep(2) # 运行本代码后两秒拍照
    
16. 
    
17. # 获取摄像头，0为电脑默认摄像头，1为外接摄像头
    
18. cap = cv2.VideoCapture(0)
    
19. # 从摄像头捕获一帧画面
    
20. success, image = cap.read()
    
21. 
    
22. # 关闭摄像头
    
23. cap.release()
    
24. # 关闭图像窗口
    
25. cv2.destroyAllWindows()
    
26. 
    
27. cv2.imwrite('photo.jpg', image)
    
28. 
    
29. 
    
30. #调用摄像头拍视频
    
31. import cv2
    
32. import time
    
33. # 定义逐帧处理函数，可不进行任何处理，直接将摄像头捕获的画面写入视频帧
    
34. def process_frame(img):
    
35.     return img
    
36. output_name = 'record_video.mp4'
    
37. 
    
38. # 获取摄像头，传入0表示获取系统默认摄像头
    
39. cap = cv2.VideoCapture(0)
    
40. 
    
41. # 打开cap
    
42. cap.open(0)
    
43. 
    
44. frame_size = (cap.get(cv2.CAP_PROP_FRAME_WIDTH), cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    
45. fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    
46. fps = cap.get(cv2.CAP_PROP_FPS)
    
47. 
    
48. out = cv2.VideoWriter(output_name, fourcc, fps, (int(frame_size[0]), int(frame_size[1])))
    
49. 
    
50. # 无限循环，直到break被触发
    
51. while cap.isOpened():
    
52.     # 获取画面
    
53.     success, frame = cap.read()
    
54.     if not success:
    
55.         break
    
56. 
    
57.     # 对捕获的帧进行图像处理
    
58.     frame = process_frame(frame)
    
59. 
    
60.     ## 将帧写入视频文件中
    
61.     out.write(frame)
    
62. 
    
63.     # 展示处理后的三通道图像
    
64.     cv2.imshow('press q to break', frame)
    
65. 
    
66.     if cv2.waitKey(1) in [ord('q'), 27]:  # 按键盘上的q或esc退出（在英文输入法下）
    
67.         break
    
68. # 关闭图像窗口
    
69. cv2.destroyAllWindows()
    
70. out.release()
    
71. # 关闭摄像头
    
72. cap.release()
    
73. print('视频已保存', output_name)

复制代码

单张图片

1. import cv2 as cv
   
2. import mediapipe as mp
   
3. import  tqdm
   
4. import time
   
5. import  matplotlib.pyplot as plt
   
6. def look_img(img):
   
7.     img_RGB=cv.cvtColor(img,cv.COLOR_BGR2RGB)
   
8.     plt.imshow(img_RGB)
   
9.     plt.show()
   
10. # 手部关键点检测模型
    
11. mp_hand=mp.solutions.hands
    
12. 
    
13. # 导入模型
    
14. hands=mp_hand.Hands(static_image_mode=False,
    
15.                     max_num_hands=5,
    
16.                     min_detection_confidence=0.3,
    
17.                     min_tracking_confidence=0.3
    
18.                     )
    
19. # 导入绘图函数
    
20. mpDraw=mp.solutions.drawing_utils
    
21. img=cv.imread('hand2.png')
    
22. # look_img(img)
    
23. img_RGB=cv.cvtColor(img,cv.COLOR_BGR2RGB)
    
24. results=hands.process(img_RGB)
    
25. if results.multi_hand_landmarks:
    
26.     for hand_idx in range(len(results.multi_hand_landmarks)):
    
27.         hand_21=results.multi_hand_landmarks[hand_idx]
    
28.         mpDraw.draw_landmarks(img, hand_21, mp_hand.HAND_CONNECTIONS)  # 可视化
    
29. look_img(img)
    
30. cv.imwrite('hands2.jpg',img)
    
31. # 在三维坐标系中可视化索引为0的手
    
32. mpDraw.plot_landmarks(results.multi_hand_landmarks[0], mp_

复制代码

摄像头检测

1. import cv2
   
2. # mediapipe人工智能工具包
   
3. import mediapipe as mp
   
4. # 进度条库
   
5. from tqdm import tqdm
   
6. # 时间库
   
7. import time
   
8. 
   
9. # 导入模型
   
10. # 导入solution
    
11. mp_hands = mp.solutions.hands
    
12. # 导入模型
    
13. hands = mp_hands.Hands(static_image_mode=False,        # 是静态图片还是连续视频帧
    
14.                        max_num_hands=2,                # 最多检测几只手
    
15.                        min_detection_confidence=0.7,   # 置信度阈值
    
16.                        min_tracking_confidence=0.5)    # 追踪阈值
    
17. # 导入绘图函数
    
18. mpDraw = mp.solutions.drawing_utils
    
19. 
    
20. # 处理单帧函数
    
21. 
    
22. # 处理帧函数
    
23. def process_frame(img):
    
24.     # 水平镜像翻转图像，使图中左右手与真实左右手对应
    
25.     # 参数 1：水平翻转，0：竖直翻转，-1：水平和竖直都翻转
    
26.     img = cv2.flip(img, 1)
    
27.     # BGR转RGB
    
28.     img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    
29.     # 将RGB图像输入模型，获取预测结果
    
30.     results = hands.process(img_RGB)
    
31. 
    
32.     if results.multi_hand_landmarks:  # 如果有检测到手
    
33.         # 遍历每一只检测出的手
    
34.         for hand_idx in range(len(results.multi_hand_landmarks)):
    
35.             hand_21 = results.multi_hand_landmarks[hand_idx]  # 获取该手的所有关键点坐标
    
36.             mpDraw.draw_landmarks(img, hand_21, mp_hands.HAND_CONNECTIONS)  # 可视化
    
37.         # 在三维坐标系中可视化索引为0的手
    
38.         # mpDraw.plot_landmarks(results.multi_hand_landmarks[0], mp_hands.HAND_CONNECTIONS)
    
39.     return img
    
40. 
    
41. 
    
42. # 导入opencv-python
    
43. import cv2
    
44. import time
    
45. 
    
46. # 获取摄像头，传入0表示获取系统默认摄像头
    
47. cap = cv2.VideoCapture(1)
    
48. 
    
49. # 打开cap
    
50. cap.open(0)
    
51. 
    
52. # 无限循环，直到break被触发
    
53. while cap.isOpened():
    
54.     # 获取画面
    
55.     success, frame = cap.read()
    
56.     if not success:
    
57.         print('Error')
    
58.         break
    
59. 
    
60.     ## !!!处理帧函数
    
61.     frame = process_frame(frame)
    
62. 
    
63.     # 展示处理后的三通道图像
    
64.     cv2.imshow('my_window', frame)
    
65. 
    
66.     if cv2.waitKey(1) in [ord('q'), 27]:  # 按键盘上的q或esc退出（在英文输入法下）
    
67.         break
    
68. 
    
69. # 关闭摄像头
    
70. cap.release()
    
71. 
    
72. # 关闭图像窗口
    
73. cv2.destroyAllWindows()

复制代码

改变关键点数据特征

1. import cv2
   
2. # mediapipe人工智能工具包
   
3. import mediapipe as mp
   
4. # 进度条库
   
5. from tqdm import tqdm
   
6. # 时间库
   
7. import time
   
8. # 导入solution
   
9. mp_hands = mp.solutions.hands
   
10. # 导入模型
    
11. hands = mp_hands.Hands(static_image_mode=False,        # 是静态图片还是连续视频帧
    
12.                        max_num_hands=2,                # 最多检测几只手
    
13.                        min_detection_confidence=0.7,   # 置信度阈值
    
14.                        min_tracking_confidence=0.5)    # 追踪阈值
    
15. # 导入绘图函数
    
16. mpDraw = mp.solutions.drawing_utils
    
17. 
    
18. def process_frame(img):
    
19.     # 记录该帧开始处理的时间
    
20.     start_time = time.time()
    
21.     # 获取图像宽高
    
22.     h, w = img.shape[0], img.shape[1]
    
23.     # 水平镜像翻转图像，使图中左右手与真实左右手对应
    
24.     # 参数 1：水平翻转，0：竖直翻转，-1：水平和竖直都翻转
    
25.     img = cv2.flip(img, 1)
    
26.     # BGR转RGB
    
27.     img_RGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    
28.     # 将RGB图像输入模型，获取预测结果
    
29.     results = hands.process(img_RGB)
    
30.     if results.multi_hand_landmarks:  # 如果有检测到手
    
31.         handness_str = ''
    
32.         index_finger_tip_str = ''
    
33.         for hand_idx in range(len(results.multi_hand_landmarks)):
    
34.             # 获取该手的21个关键点坐标
    
35.             hand_21 = results.multi_hand_landmarks[hand_idx]
    
36.             # 可视化关键点及骨架连线
    
37.             mpDraw.draw_landmarks(img, hand_21, mp_hands.HAND_CONNECTIONS)
    
38.             # 记录左右手信息
    
39.             temp_handness = results.multi_handedness[hand_idx].classification[0].label
    
40.             handness_str += '{}:{} '.format(hand_idx, temp_handness)
    
41.             # 获取手腕根部深度坐标
    
42.             cz0 = hand_21.landmark[0].z
    
43.             for i in range(21):  # 遍历该手的21个关键点
    
44.                 # 获取3D坐标
    
45.                 cx = int(hand_21.landmark[i].x * w)
    
46.                 cy = int(hand_21.landmark[i].y * h)
    
47.                 cz = hand_21.landmark[i].z
    
48.                 depth_z = cz0 - cz
    
49.                 # 用圆的半径反映深度大小
    
50.                 radius = max(int(6 * (1 + depth_z * 5)), 0)
    
51.                 if i == 0:  # 手腕
    
52.                     img = cv2.circle(img, (cx, cy), radius, (0, 0, 255), -1)
    
53.                 if i == 8:  # 食指指尖
    
54.                     img = cv2.circle(img, (cx, cy), radius, (193, 182, 255), -1)
    
55.                     # 将相对于手腕的深度距离显示在画面中
    
56.                     index_finger_tip_str += '{}:{:.2f} '.format(hand_idx, depth_z)
    
57.                 if i in [1, 5, 9, 13, 17]:  # 指根
    
58.                     img = cv2.circle(img, (cx, cy), radius, (16, 144, 247), -1)
    
59.                 if i in [2, 6, 10, 14, 18]:  # 第一指节
    
60.                     img = cv2.circle(img, (cx, cy), radius, (1, 240, 255), -1)
    
61.                 if i in [3, 7, 11, 15, 19]:  # 第二指节
    
62.                     img = cv2.circle(img, (cx, cy), radius, (140, 47, 240), -1)
    
63.                 if i in [4, 12, 16, 20]:  # 指尖（除食指指尖）
    
64.                     img = cv2.circle(img, (cx, cy), radius, (223, 155, 60), -1)
    
65.         scaler = 1
    
66.         img = cv2.putText(img, handness_str, (25 * scaler, 100 * scaler), cv2.FONT_HERSHEY_SIMPLEX, 1.25 * scaler,
    
67.                           (255, 0, 255), 2 * scaler)
    
68.         img = cv2.putText(img, index_finger_tip_str, (25 * scaler, 150 * scaler), cv2.FONT_HERSHEY_SIMPLEX,
    
69.                           1.25 * scaler, (255, 0, 255), 2 * scaler)
    
70.         # 记录该帧处理完毕的时间
    
71.         end_time = time.time()
    
72.         # 计算每秒处理图像帧数FPS
    
73.         FPS = 1 / (end_time - start_time)
    
74.         # 在图像上写FPS数值，参数依次为：图片，添加的文字，左上角坐标，字体，字体大小，颜色，字体粗细
    
75.         img = cv2.putText(img, 'FPS  ' + str(int(FPS)), (25 * scaler, 50 * scaler), cv2.FONT_HERSHEY_SIMPLEX,
    
76.                           1.25 * scaler, (255, 0, 255), 2 * scaler)
    
77.     return img
    
78. # 获取摄像头，传入0表示获取系统默认摄像头
    
79. cap = cv2.VideoCapture(0)
    
80. # 打开cap
    
81. cap.open(0)
    
82. # 无限循环，直到break被触发
    
83. while cap.isOpened():
    
84.     # 获取画面
    
85.     success, frame = cap.read()
    
86.     if not success:
    
87.         break
    
88.     frame = process_frame(frame)
    
89.     # 展示处理后的三通道图像
    
90.     cv2.imshow('my_window', frame)
    
91.     if cv2.waitKey(1) in [ord('q'), 27]:  # 按键盘上的q或esc退出（在英文输入法下）
    
92.         break
    
93. # 关闭摄像头
    
94. cap.release()
    
95. # 关闭图像窗口
    
96. cv2.destroyAllWindows()

复制代码

以上就是OpenCV+MediaPipe实现手部关键点识别的详细内容，更多关于OpenCV MediaPipe手部关键点识别的资料请关注脚本之家其它相关文章！
                                                        
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！