手部姿态检测（按帧）

最新推荐文章于 2024-08-17 15:27:20 发布
最新推荐文章于 2024-08-17 15:27:20 发布
阅读量1.1k 收藏 13
点赞数 3
分类专栏： 手部姿态识别 文章标签： 机器学习 svm 姿态识别
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gm_ergou/article/details/118393011
版权

目的：识别手部在脸上的动作，比如：涂眼霜、涂水乳、敷面膜、没动作

参考链接：

https://github.com/xinghaochen/awesome-hand-pose-estimation

https://github.com/lmb-freiburg/hand3d

https://github.com/FORTH-ModelBasedTracker/MonocularRGB_3D_Handpose_WACV18

openpose：https://blog.csdn.net/zziahgf/article/details/90706693

方法1：svm
数据集：20-30人，3w+张图片
准确度：0.85（opencv的手部特征检测器不准）


训练技巧：
1.分别选取稳定的几个点代表整个手部，脸部也是如此
2.坏帧清洗，自动剔除没有检测到手或者图片模糊导致检测不准的帧
3.数据做归一化处理


特征：
1.计算手部中心点和脸部中心点的欧氏距离
2.计算指尖中心点到内眼角的欧氏距离
3.计算指尖与眼睛的y轴距离
4.计算手部和脸部所有关键点向量的欧式距离
5.计算手部和脸部所有关键点向量的曼哈顿距离

数据处理：

1.把视频流按帧保存下来：

import sys
import os
import dlib
import cv2
from PIL import Image
import numpy as np
import time
import imutils


def getImageVar(image):
	img2gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
	imageVar = cv2.Laplacian(img2gray, cv2.CV_64F).var()
	return imageVar



video_path = 'data2/vedio/width/1.mp4'
save_path='data2/5/'
cap = cv2.VideoCapture(video_path)

hasFrame, frame = cap.read()
frameWidth = frame.shape[1]
frameHeight = frame.shape[0]

#开始进入循环取帧
k=0
while (hasFrame):
	k += 1
	hasFrame, frame = cap.read()   #读取视频帧
	frame=frame[0:480,150:530]
	h,w,_=frame.shape
	frame=cv2.resize(frame,(int(w*0.9),int(h*0.9)))
	
	# frame=cv2.resize(frame,(640,480))
	# frame=frame[0:480,150:530]
	# frame=cv2.resize(frame,(432,342))
	# print(h,w)
	if k%5==0:
		# print(k,hasFrame)
		fm=getImageVar(frame)
		if fm>=50:
			print(k,fm)
			cv2.imwrite(save_path+'frame_%d.jpg' %k, frame)   #保存视频帧

cap.release()

2.清洗掉没有人脸的帧：

import matplotlib.pyplot as plt
import cv2
import numpy as np
import  dlib
import os

# 如果未检测到人脸,那么返回false,否则返回true
face_detector = dlib.get_frontal_face_detector()
landmark_predictor = dlib.shape_predictor("class\shape_predictor_68_face_landmarks.dat")   #加载人脸特征点模型

def geteye_rect(imgpath):
    bgrImg = cv2.imread(imgpath)
    name=imgpath.split('/')[-1].split('.')[0]

    if bgrImg is None:
        return False
        
    # rgbImg = cv2.cvtColor(bgrImg, cv2.COLOR_BGR2RGB)
    facesrect = face_detector(bgrImg, 1)
    
    if len(facesrect) != 1:
        print(imgpath,"none.")
        os.remove(imgpath)
n=0
path='data2/5/'
for root,dirs,files in os.walk(path):
    for file in files:  # 遍历文件
        if file.endswith('jpg'):
            n += 1
            file_name= root+'/'+file
            print(n, file_name)
            geteye_rect(file_name)

提取特征：

3.坐标点检测（人脸/手部关键点）

import sys
import os
import dlib
import cv2
from PIL import Image
import numpy as np
import time
import imutils

detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor('class/shape_predictor_68_face_landmarks.dat')

def face_detect(pic):
    img = np.copy(pic)
    # img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)

    # 人脸数rects
    rects = detector(img, 1)
    if len(rects)!=1:
        print(len(rects),"face detection fail!")
        exit()

    landmarks = np.matrix([[p.x, p.y] for p in predictor(img,rects[0]).parts()])

    for idx, point in enumerate(landmarks):
        x=point[0, 0]
        y=point[0, 1]
        f1.write(str(x)+","+str(y)+"  ")

        # 画图和点
        cv2.circle(img, (x,y), 2, (0, 255, 0), thickness=-1, lineType=cv2.FILLED)
        cv2.putText(img, str(idx), (x,y), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (0, 0, 255), 1,cv2.LINE_AA)

    f1.write("\n")

    return img

def hand_detect(pic, label, img_face, file_name):
    protoFile = "class/hand/pose_deploy.prototxt"
    weightsFile = "class/hand/pose_iter_102000.caffemodel"
    nPoints = 22
    POSE_PAIRS = [[0, 1], [1, 2], [2, 3], [3, 4], [0, 5], [5, 6], [6, 7], [7, 8], [0, 9], [9, 10], [10, 11], [11, 12],
                  [0, 13], [13, 14], [14, 15], [15, 16], [0, 17], [17, 18], [18, 19], [19, 20]]
    net = cv2.dnn.readNetFromCaffe(protoFile, weightsFile)
    
    img_hand=np.copy(img_face)   #用来画手的坐标点
    frame = np.copy(pic)   #用来做手部检测
    frameWidth = frame.shape[1]
    frameHeight = frame.shape[0]
    aspect_ratio = frameWidth / frameHeight

    threshold = 0.1

    t = time.time()
    # input image dimensions for the network
    inHeight = 368
    inWidth = int(((aspect_ratio * inHeight) * 8) // 8)
    inpBlob = cv2.dnn.blobFromImage(frame, 1.0 / 255, (inWidth, inHeight), (0, 0, 0), swapRB=False, crop=False)

    net.setInput(inpBlob)

    output = net.forward()
    print("time taken by network : {:.3f}".format(time.time() - t))

    # Empty list to store the detected keypoints
    points = []

    for i in range(nPoints):
        # 对应身体部位的置信度图
        probMap = output[0, i, :, :]
        probMap = cv2.resize(probMap, (frameWidth, frameHeight))
        # cv2.minMaxLoc：返回矩阵的最小值，最大值，并得到最大值，最小值的索引
        minVal, prob, minLoc, point = cv2.minMaxLoc(probMap)   #找最大值及其下标（即置信度最大的点）

        if prob >= threshold:
            # 获取坐标点
            x,y=(int(point[0]), int(point[1]))
            f2.write(str(x)+","+str(y)+"  ")

            # 画图和点
            cv2.circle(img_hand, (x,y), 2, (255, 255, 0), thickness=-1, lineType=cv2.FILLED)
            cv2.putText(img_hand, str(i), (x,y), cv2.FONT_HERSHEY_SIMPLEX, 0.3, (0, 0, 0), 1,cv2.LINE_AA)
        else:
            # 获取坐标点
            x,y=(0, 0)
            f2.write(str(x)+","+str(y)+"  ")


    if label=='a':
        gg=0
    elif label=='b':
        gg=1
    elif label=='c':
        gg=2
    else:
        gg=9
    f2.write(str(gg)+"  "+file_name+"  \n")

    return img_hand


f1=open("data2/val2/face_point.txt","w+")
f2=open("data2/val2/hand_point.txt","w+")
path = "data2/val2/"
save_path = "data2/0/"

n=0
for root,dirs,files in os.walk(path):
    for file in files:
        if file.endswith('jpg'):
            file_name=root+"/"+file
            label=root.split('/')[-1]
            n+=1
            print(n,file_name,label)

            # 获取坐标点
            pic=cv2.imread(file_name)
            img_face=face_detect(pic)   #人脸检测
            img_hand=hand_detect(pic, label, img_face, file_name)   #手部检测
            
            cv2.imwrite(save_path+label+"/"+file,img_hand)

f1.close()
f2.close()

4.计算距离特征

import glob
import os
import numpy as np
from numpy import *
import cv2


# 4.计算特征
def feature(data_hand, label_hand, data_face, max_num):
    feature=[]
    # 计算欧氏距离
    num=data_hand.shape[0]
    for i in range(num):
        label=label_hand[i]

        key_point_hand1=[8,12,16]
        # key_point_hand2=[7,11,15,20]
        
        # 计算手部指尖中心坐标
        hand_point,mask=center_point(i, data_hand, key_point_hand1)

        # 判断图片是否有手
        if mask<=2:
            # print("action_Z：no hand!","mack:",mask)
            continue

        # 左右眼的坐标（计算中心点）
        left_eye=[37,38,40,41]
        right_eye=[43,44,46,47]

        # 向量距离的坐标（指尖和眼睛）
        vector_point_hand=[8,12,16]
        vector_left_eye=[37,38,40]
        vector_right_eye=[43,44,46]

        vector_hand=vector(i, data_hand,vector_point_hand)   #指尖的向量

        # 判断手在左边还是右边（依据：指尖与左右外眼角的距离）
        if abs(hand_point[0]-data_face[i][36][0]) <= abs(hand_point[0]-data_face[i][45][0]):
            eye_point,_=center_point(i, data_face, left_eye)   #眼睛的中心坐标
            inner_eye_point=data_face[i][39]                   #内眼角坐标
            vector_eye=vector(i, data_face,vector_left_eye)   #眼睛的向量
        else:
            eye_point,_=center_point(i, data_face, right_eye)
            inner_eye_point=data_face[i][42]
            vector_eye=vector(i, data_face,vector_right_eye)


        # 特征1：计算欧氏距离
        featur1=int(np.sqrt(np.sum(np.square(hand_point-eye_point))))

        # 特征2：计算指尖中心点到内眼角的欧氏距离
        featur2=int(np.sqrt(np.sum(np.square(hand_point-inner_eye_point))))

        # 特征3：计算指尖与眼睛的y轴距离
        featur3=int(abs(hand_point[1]-eye_point[1]))

        # 特征4：计算向量的欧氏距离
        featur4=int(np.sqrt(np.sum(np.square(mat(vector_hand)-mat(vector_eye)))))
        
        # 特征5：计算向量的曼哈顿距离
        featur5=int(sum(abs(mat(hand_point)-mat(eye_point))))

        # 特征归一化
        if len(max_num)>=3:
            featur1=featur1/max_num[0]
            featur2=featur2/max_num[1]
            featur3=featur3/max_num[2]
            featur4=featur4/max_num[3]
            featur5=featur5/max_num[4]

        # 写入txt
        f3.write(str(featur1)+"  "+str(featur2)+"  "+str(featur3)+"  "+str(featur4)+"  "+str(featur5)+"  "+label+"\n")
        
        feature.append((featur1,featur2,featur3,featur4,featur5))

        # print("欧氏距离：{}".format(featur1),"标签：{}".format(label))
        # print("指尖中心点到内眼角的欧氏距离：{}".format(featur2),"标签：{}".format(label))
        # print("指尖与眼睛的y轴距离：{}".format(featur3),"标签：{}".format(label))
        # print ('向量欧氏距离：',featur4,"标签：{}".format(label))
        # print("向量曼哈顿距离：",featur5,"标签：{}".format(label))

        # print(featur1,featur2,featur3,featur4,featur5,label)

    return feature


# 3.坐标向量
def vector(i, data,key_point):
    vector=[]
    for idx in key_point:
        x=data[i][idx][0]
        y=data[i][idx][1]
        vector.append((x,y))
    return vector

# 2.计算中心坐标点
def center_point(i, data, key_point):
    # 计算手尖坐标
    sum_x=0
    sum_y=0
    n=0
    for idx in key_point:
        x=data[i][idx][0]
        y=data[i][idx][1]
        # print(x,y)
        if x!=0:
            sum_x+=x
            sum_y+=y
            n+=1
    if n!=0:
        avg_x=int(sum_x/n)
        avg_y=int(sum_y/n)
    else:
        avg_x=avg_y=0

    point=(avg_x,avg_y)


    return np.array(point),n
    
# 1.读取坐标点数据
def read_data(file_name):
    f1=open(file_name,"r")
    lines=f1.readlines()

    pic_num=len(lines)   #照片数量，行数
    point_num=len(lines[0].split('  '))   #手部关键点数量

    data=[]   #存所有照片的手部关键点
    label=[]
    for n in range(pic_num):
        point=[]   #存每一个关键点的坐标
        line=lines[n].split('  ')
        
        if point_num==69:
            for i in range(68):
                x=line[i].split(",")[0]
                y=line[i].split(",")[1]
                point.append([int(x),int(y)])   #把一张照片的所有关键点存入point
        else:
            for i in range(22):
                x=line[i].split(",")[0]
                y=line[i].split(",")[1]
                point.append([int(x),int(y)])   #把一张照片的所有关键点存入point
        
        data.append(point)   #把所有照片的关键点存入data
        label.append(line[22])


    data=np.array(data)
    label=np.array(label)
    return data,label



# 获取手部数据、标签
f1="data3/train/hand_point.txt"
data_hand,label_hand=read_data(f1)

# 获取脸部数据
f2="data3/train/face_point.txt"
data_face,_=read_data(f2)
print(data_hand.shape)

# 计算特征
f3=open("data3/train/feature.txt","w+")
max_num=[]   #特征归一化，最大值
feature=feature(data_hand, label_hand, data_face, max_num)

5.使用svm进行训练

from numpy import *
import numpy as np
import cv2
import matplotlib.pyplot as plt
import shutil

def loadDataSet(fileName):
    dataMat = []
    labelMat = []
    with open(fileName) as fr:
        for line in fr.readlines():
            lineArr = line.strip().split('  ')
            # print(lineArr)

            # dataMat.append([float(lineArr[0]), float(lineArr[1]), 
            #                 float(lineArr[2]), float(lineArr[3]), float(lineArr[4])])
            dataMat.append([float(lineArr[0]), float(lineArr[1]), float(lineArr[2])])
            
            labelMat.append([int(lineArr[5])])
    return dataMat, labelMat

#加载训练集
train_data,train_label = loadDataSet('data3/train/feature-shuffle.txt')   #1.加载一个txt数据集
train_data = mat(train_data)
train_data=np.array(train_data, dtype='float32')
train_label = mat(train_label)
# print(train_data)
print(train_label.shape)

#加载测试集
test_data,test_label = loadDataSet('data3/val2/feature.txt')   #1.加载一个txt数据集
test_data = mat(test_data)
test_data=np.array(test_data, dtype='float32')
test_label=mat(test_label)
print(test_label.shape)


# 创建分类器
svm = cv2.ml.SVM_create()
svm.setType(cv2.ml.SVM_C_SVC)  # SVM类型
svm.setKernel(cv2.ml.SVM_LINEAR) # 使用线性核
svm.setC(1e-5)

# 训练
ret = svm.train(train_data, cv2.ml.ROW_SAMPLE, train_label)
svm.save('data2/train/hand_class.xml')

# 支持向量
vec = svm.getSupportVectors()
print("最终结果:",vec)


# 测试
# svm = cv2.ml.SVM_load("weight/test3/hand_detect.xml")
(ret, res) = svm.predict(test_data)
# print(res)

# # 准确率
# f1=open("data/val2/0/hand_point.txt","r")
# lines=f1.readlines()
# save_path='data/error/val2/'

n=0
lens=len(test_data)
for i in range(lens):
    if res[i]==test_label[i]:
        n=n+1
    # else:
    #     root=lines[i].split('  ')[23]
    #     file_name=root.split('/')[-1]
    #     # print(file_name)
    #     shutil.copy(root,save_path+file_name+str(test_label[i])+".jpg")

Accuracy=n/lens
print("准确度为:",Accuracy)

合并测试：提取特征+svm预测

import sys
import os
import dlib
import cv2
from PIL import Image
import numpy as np
import time
import imutils
from numpy import *


# 4.计算特征
def feature(data_hand, data_face, max_num):
    feature=[]

    # 指尖关键点
    key_point_hand=[8,12,16]

    # 计算手部指尖中心坐标
    hand_point,mask=center_point(data_hand, key_point_hand)
    # print(hand_point,mask)
    
    # 判断图片是否有手
    if mask<=1:
        print("action_Z：no hand!","mack:",mask)
        exit()

    
    # 左右眼的坐标（计算中心点）
    left_eye=[37,38,40,41]
    right_eye=[43,44,46,47]

    # 向量距离的坐标（指尖和眼睛）
    vector_point_hand=[8,12,16,20]
    vector_left_eye=[37,38,40,41]
    vector_right_eye=[43,44,46,47]

    vector_hand=vector(data_hand,vector_point_hand)   #指尖的向量

    # 判断手在左边还是右边（依据：指尖与左右外眼角的距离）
    if abs(hand_point[0]-data_face[36][0]) <= abs(hand_point[0]-data_face[45][0]):
        eye_point,_=center_point(data_face, left_eye)   #眼睛的中心坐标
        inner_eye_point=data_face[39]                   #内眼角坐标
        vector_eye=vector(data_face,vector_left_eye)   #眼睛的向量
    else:
        eye_point,_=center_point(data_face, right_eye)
        inner_eye_point=data_face[42]
        vector_eye=vector(data_face,vector_right_eye)


    # 特征1：计算欧氏距离
    featur1=int(np.sqrt(np.sum(np.square(hand_point-eye_point))))

    # 特征2：计算指尖中心点到内眼角的欧氏距离
    featur2=int(np.sqrt(np.sum(np.square(hand_point-inner_eye_point))))

    # 特征3：计算指尖与眼睛的y轴距离
    featur3=int(abs(hand_point[1]-eye_point[1]))

    # 特征4：计算向量的欧氏距离
    featur4=int(np.sqrt(np.sum(np.square(mat(vector_hand)-mat(vector_eye)))))
    
    # 特征5：计算向量的曼哈顿距离
    featur5=int(sum(abs(mat(vector_hand)-mat(vector_eye))))

    # 特征归一化
    if len(max_num)>=3:
        featur1=featur1/max_num[0]
        featur2=featur2/max_num[1]
        featur3=featur3/max_num[2]
        featur4=featur4/max_num[3]
        featur5=featur5/max_num[4]

    
    feature.append((featur1,featur2,featur3,featur4,featur5))

    # print("欧氏距离：{}".format(featur1),"标签：{}".format(label))
    # print("指尖中心点到内眼角的欧氏距离：{}".format(featur2),"标签:{}".format(label))
    # print("指尖与眼睛的y轴距离：{}".format(featur3),"标签：{}".format(label))
    # print ('向量欧氏距离：',featur4,"标签：{}".format(label))
    # print("向量曼哈顿距离：",featur5,"标签：{}".format(label))

    return feature


# 3.坐标向量
def vector(data,key_point):
    vector=[]
    for idx in key_point:
        x=data[idx][0]
        y=data[idx][1]
        vector.append((x,y))
    return vector


# 2.计算中心坐标点
def center_point(data, key_point):
    # 计算手尖坐标
    sum_x=0
    sum_y=0
    n=0
    for idx in key_point:
        x=data[idx][0]
        y=data[idx][1]
        # print(x,y)
        if x!=0:
            sum_x+=x
            sum_y+=y
            n+=1
    if n!=0:
        avg_x=int(sum_x/n)
        avg_y=int(sum_y/n)
    else:
        avg_x=avg_y=0

    point=(avg_x,avg_y)


    return np.array(point),n


def face_detect(pic):
    detector = dlib.get_frontal_face_detector()
    predictor = dlib.shape_predictor('class/shape_predictor_68_face_landmarks.dat')
    img = np.copy(pic)
    # img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)

    # 人脸数rects
    rects = detector(img, 1)
    if len(rects)!=1:
        print("face detection fail!")
        exit()

    landmarks = np.matrix([[p.x, p.y] for p in predictor(img,rects[0]).parts()])
    points=[]
    for idx, point in enumerate(landmarks):
        x=point[0, 0]
        y=point[0, 1]
        points.append([x,y])

        # # 画图和点
        # cv2.circle(img, (x,y), 9, (0, 255, 0), thickness=-1, lineType=cv2.FILLED)
        # cv2.putText(img, str(idx), (x,y), cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 0, 255), 2,cv2.LINE_AA)


    return img, np.array(points)


def hand_detect(pic, label, img_face):
    protoFile = "class/hand/pose_deploy.prototxt"
    weightsFile = "class/hand/pose_iter_102000.caffemodel"
    nPoints = 22
    POSE_PAIRS = [[0, 1], [1, 2], [2, 3], [3, 4], [0, 5], [5, 6], [6, 7], [7, 8], [0, 9], [9, 10], [10, 11], [11, 12],
                  [0, 13], [13, 14], [14, 15], [15, 16], [0, 17], [17, 18], [18, 19], [19, 20]]
    net = cv2.dnn.readNetFromCaffe(protoFile, weightsFile)
    
    img_hand=np.copy(img_face)   #用来画手的坐标点
    frame = np.copy(pic)   #用来做手部检测
    frameWidth = frame.shape[1]
    frameHeight = frame.shape[0]
    aspect_ratio = frameWidth / frameHeight

    threshold = 0.1

    t = time.time()
    # input image dimensions for the network
    inHeight = 368
    inWidth = int(((aspect_ratio * inHeight) * 8) // 8)
    inpBlob = cv2.dnn.blobFromImage(frame, 1.0 / 255, (inWidth, inHeight), (0, 0, 0), swapRB=False, crop=False)

    net.setInput(inpBlob)

    output = net.forward()
    print("time taken by network : {:.3f}".format(time.time() - t))

    # Empty list to store the detected keypoints
    points = []

    for i in range(nPoints):
        # 对应身体部位的置信度图
        probMap = output[0, i, :, :]
        probMap = cv2.resize(probMap, (frameWidth, frameHeight))
        # cv2.minMaxLoc：返回矩阵的最小值，最大值，并得到最大值，最小值的索引
        minVal, prob, minLoc, point = cv2.minMaxLoc(probMap)   #找最大值及其下标（即置信度最大的点）

        # 获取坐标点
        x,y=(int(point[0]), int(point[1]))
        points.append([x,y])

        # # 画图和点
        # cv2.circle(img_hand, (x,y), 9, (255, 255, 0), thickness=-1, lineType=cv2.FILLED)
        # cv2.putText(img_hand, str(i), (x,y), cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 0, 0), 2,cv2.LINE_AA)

    return img_hand,np.array(points)


path = "data/test2/"
save_path = "data/0/"
svm_model="data/train/hand_class.xml"
for root,dirs,files in os.walk(path):
    for file in files:
        if file.endswith('jpg'):
            file_name=root+"/"+file
            label=root.split('/')[-1]
            # print(file_name,label)
            # 
            # 

            # 获取坐标点
            pic=cv2.imread(file_name)
            img_face, point_face=face_detect(pic)   #人脸检测
            img_hand, point_hand=hand_detect(pic, label, img_face)   #手部检测

            # print(point_face.shape, point_hand.shape)
            # cv2.imwrite(save_path+label+"/"+file,img_hand)

            # 计算特征
            max_num=[]   #特征归一化，最大值
            features=feature(point_hand, point_face, max_num)
            features=mat(features)
            features=np.array(features, dtype='float32')
            print("特征：",features)


            # 创建分类器
            svm = cv2.ml.SVM_create()
            svm.setType(cv2.ml.SVM_C_SVC)  # SVM类型
            svm.setKernel(cv2.ml.SVM_LINEAR) # 使用线性核
            svm.setC(1e-5)

            # 加载模型、测试
            svm = cv2.ml.SVM_load(svm_model)
            (ret, res) = svm.predict(features)
            print("预测结果：",res)

尼古拉斯·two_dog
关注
专栏目录
实时手部检测
02-18
实时手部检测
opencv+qt 摄像头手部检测识别（剪刀石头布）
12-02
opencv+qt 摄像头手部检测识别（剪刀石头布） http://www.cnblogs.com/hebaichuanyeah/p/5014519.html
实时手势识别（1）- 基于手部检测+手部分类
qq_40387714的博客
08-17 1894
利用YOLOv8获取手部区域，然后对手部区域进行分类，实现手势识别。本文使用检测+分类，对于一类手势只需200张训练图片，即可达到99%的准确率。在下一篇基于关键点+关键点分类，无需训练图片，即可实现对任意手势的识别，且达到99%的准确率。
mini2440实现采集摄像头数据在开发板的LCD显示
10-31
mini2440实现采集摄像头数据在开发板的LCD显示
入门级！超简单的python跳帧提取视频文件中出现过的所有人脸（附代码）
09-01 3272
1.准备 人脸识别可以使用python里的cv2库，该库可以实现提取图片或者视频中的人脸信息。本文使用的是cv2库配合百度智能云的人脸识别接口准确率比较高，最后会附带代码 cv2库安装： pip install opencv-python 百度智能云的人脸识别：百度智能云 需要安装百度的库，这是接口文档 pip install baidu-aip 2.从视频提取图片 由于视频是无法直接进行人脸识别的，我们只需要使用cv2库将图片切割为一帧一帧的就可以使用图片进行人脸识别了 import
小模型的手部目标检测训练和部署
step by step
07-19 4247
利用目标检测算法实现手部检测的四种方法实操指南及相关代码，包含调用MideaPipe，使用yolo v3相关代码资源，使用yolo_fastestV2，使用TensorFlow API。
手部姿态检测（按视频段）_v1（数据处理）
gm_Ergou的博客
07-02 510
参考时空图卷积，加上了空间信息，把二维的坐标点加上时间帧的维度，形成三维的矩阵数据。 方法2：st-gcn、hcn、2s-agcn 数据集：20人，7k+段视频 准确度：0.95 训练技巧： 1.自动清洗数据，判断人脸检测是否变形，判断一段视频的有效帧是否足够 2.尝试了1s/2s/4s视频进行预测，最终选择2s 64帧作为一条数据，有15帧有效则数据可用，否则是无效数据 3.数据预处理，把一段视频的所有帧，脸部和手部的检测点转化成3维数据（2d坐标+置信度），等于加上时间信息 数据处理步骤：
使用python语言的超轻量openpose源码，能实时对人体进行姿态检测，下载可直接运行
05-24
在本项目中，我们关注的是一个使用Python实现的轻量级OpenPose库，它专为人体姿态检测设计，能够在实时环境中高效运行。 OpenPose是一个开源计算机视觉库，主要用于多人实时的关键点检测，包括但不限于人体、面部和...
opencv深度学习识别手部姿态
12-05
【标题】"OpenCV深度学习识别手部姿态"是一个基于计算机视觉和深度学习技术的项目，旨在通过OpenCV库在Linux环境下实现对手部姿态的精确识别。OpenCV（开源计算机视觉库）是一个强大的工具，广泛应用于图像处理和...
使用 Python 和 MediaPipe 进行 AI 面部、身体和手部姿势检测
04-01
为了使用 Python 和 MediaPipe 进行 AI 姿态检测，首先需要安装必要的依赖包： 1. **Python**：推荐使用 Python 3.6 或更高版本。 2. **pip**：Python 的包管理工具，用于安装外部库。 3. **MediaPipe**：核心库，...
深度学习手势检测与识别算法 - opencv python 计算机竞赛
Mr.D学长
11-30 1948
🔥 优质竞赛项目系列，今天要分享的是🚩深度学习图像识别手势检测识别系统该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！🥇学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：3分创新点：4分🧿🧿。
毕业设计之 --- 基于机器视觉的手势检测和识别算法
HUXINY的博客
01-29 1万+
文章目录0 前言1 实现效果2 技术原理2.1 手部检测2.1.1 基于肤色空间的手势检测方法2.1.2 基于运动的手势检测方法2.1.3 基于边缘的手势检测方法2.1.4 基于模板的手势检测方法2.1.5 基于机器学习的手势检测方法3 手部识别3.1 SSD网络3.2 数据集3.3 最终改进的网络结构4 最后 0 前言 今天学长向大家介绍一个关于深度学习在图像识别领域应用的又一个课题，基于深度学习的手势检测与识别算法，该课题十分适合用于毕业设计哦～ 计算机相关毕设(论文)需要帮助的同学及时联系学
手部关键点检测2：YOLOv5实现手部检测(含训练代码和数据集)
AI吃大瓜的博客
10-12 9109
项目基于开源YOLOv5项目，实现一个高精度的手部检测算法目前，基于YOLOv5s的手部检测。手掌检测，手部检测，手检测，手势检测
手势识别3：Android实现手部检测和手势识别（可实时运行，含Android源码）
热门推荐
AI吃大瓜的博客
09-26 1万+
开发一个Android手势识别，手势动作识别，手势数据集，手势识别APP，YOLO手势识别；APP在普通Android手机上可以达到实时的手势识别效果，CPU(4线程)约30ms左右，GPU约25ms左右 ，基本满足业务的性能需求
手指和手势识别算法原理和解析
zpeien
03-30 8649
1、问题陈述 我们将从视频序列中识别手势。为了从实时视频序列中识别这些手势，我们首先需要单独取出手部区域，以去除视频序列中所有不需要的部分。在分割手部区域之后，我们对视频序列中显示的手指进行计数，以基于手指计数来指示机器人。因此，可以使用2个简单的步骤解决整个问题 １．从视频序列中找到并分割手部区域。 ２．从视频序列中分割的手区域计算手指的数量。 2、分割手区域 手势识别的第一步显然是通过消除视频序列中所有其他不需要的部分来找到手部区域。起初这似乎令人恐惧。但是不用担心。使......
Opencv + MediaPipe -＞ 手势识别
weixin_44686138的博客
03-26 9729
利用OpenCV mediapipe，快速实现简单的手势识别
手部姿态打分（初步简易版）
weixin_44736559的博客
10-03 854
在了解了上篇文章OpenPose笔记——win10下，VS2017和Python API可成功编译OpenPose啦！！！的前提下，我们利用OpenPose已训练的手部关键点检测模型，进行手部姿态的打分。 具体实现 主要针对握拳这个手部动作进行打分，使用DTW算法，根据两个视频序列相似度打分。 1、下载手部关键点检测模型 [1] - hand/pose_deploy.prototxt [2] - hand/pose_iter_102000.caffemodel 2、关键代码部分 #!/usr/bin/pyt
mediapipe进行人体姿态检测代码
最新发布
09-12
MediaPipe 是一个由 Google 开发的跨平台框架，用于构建多媒体处理管道，它提供了多种预建的解决方案，包括用于人体姿态检测的解决方案。MediaPipe Pose 可以实时地检测人体的关键点，包括面部、手部、整体姿态等。 以下是一个使用 MediaPipe 进行人体姿态检测的基本代码示例（以 Python 为例）： ```python import cv2 import mediapipe as mp # 初始化 MediaPipe 姿态检测 mp_pose = mp.solutions.pose pose = mp_pose.Pose(static_image_mode=False, model_complexity=1, enable_segmentation=False, min_detection_confidence=0.5, min_tracking_confidence=0.5) # 初始化绘图工具 mp_drawing = mp.solutions.drawing_utils # 打开摄像头 cap = cv2.VideoCapture(0) while cap.isOpened(): ret, frame = cap.read() if not ret: continue # 将图像从BGR转换到RGB rgb_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # 做姿态检测 results = pose.process(rgb_image) # 将图像从RGB转换回BGR image = cv2.cvtColor(rgb_image, cv2.COLOR_RGB2BGR) # 绘制姿态关键点 if results.pose_landmarks: mp_drawing.draw_landmarks(image, results.pose_landmarks, mp_pose.POSE_CONNECTIONS) # 显示图像 cv2.imshow('MediaPipe Pose', image) # 按'q'退出循环 if cv2.waitKey(5) & 0xFF == ord('q'): break # 释放摄像头资源 cap.release() cv2.destroyAllWindows() ``` 上述代码首先导入了必要的库，然后初始化了 MediaPipe 姿态检测模块，并设置了摄像头。在摄像头的主循环中，它读取帧，将其转换为RGB格式，然后传递给 MediaPipe Pose 进行处理。处理的结果包括关键点位置信息，随后在图像上绘制这些关键点，并显示结果。当用户按下'q'键时，循环结束，程序退出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值