42 def relative_coordinate(arr, point):
43 """
44 转化为相对坐标
45 :param arr: numpy数组
46 :param point: 手掌根部坐标点
47 :return:
48 """
49 return arr - point
均值方差归一化（标准化）：
通过相对坐标的转化，虽然位置的影响几乎消除了，但是距离对数值的影响依然存在。当手部距离摄像头近时，相对位置差值较大；当手部距离摄像头远时，相对位置差值较小；
所以要将数据进行均值方差归一化，也称为标准化。
它是把所有数据归到均值为0，方差为1的分布中。即确保最终得到的数据均值为0，方差为1。如下图所示，同样的握拳姿势，在距离镜头近时，相对坐标大致分布在0.3至-0.4之间，而距离镜头远时，相对坐标大致分布在0.15至-0.15之间。经过标准化后，数据的分布被统一映射至-2至2之间，让每一个特征数据的影响力是相同的。这样就大大降低了手部与摄像头距离对数据的影响。
近距离握拳姿势的数据分布
远距离握拳姿势的数据分布
def standardization(hand_arr):
均值方差归一化
:param hand_arr:numpy数组
:return:
return (hand_arr - np.mean(hand_arr)) / np.std(hand_arr)
def process_mark_data(hand_arr):
处理手部坐标点信息数组
将所有点处理为相对于手掌根部点的相对位置
:param hand_arr: 手部numpy数组
:return:
lh_root = hand_arr[0, 0]
rh_root = hand_arr[1, 0]
lh_marks = relative_coordinate(hand_arr[0, 1:], lh_root)
rh_marks = relative_coordinate(hand_arr[1, 1:], lh_root)
if lh_marks.all() != 0:
lh_marks = standardization(lh_marks)
if rh_marks.all() != 0:
rh_marks = standardization(rh_marks)
return np.array([lh_marks, rh_marks])
测试效果：
经过以上的数据处理，转化为相对坐标大大降低了手部在图片中位置的影响，均值方差归一化（标准化）大大降低了手部距离摄像头距离的影响。这使得少量的训练数据得到充分的发挥，同样的手势数据可以适应在图片中的不同位置、不同距离。
在不使用图片数据增强的情况下，仅使用22张照片，包括16个正例和6个负例，就可以达到非常好的测试效果，可以基本满足通过手势识别操作计算机的需求。关于准确率等指标的探讨放在后面一章的神经网络中，这里只看效果。
测试握拳手势的训练集
因为只是测试阶段，这里仅仅做了一个握拳手势的识别，属于二分类问题。神经网络的输出层的激活函数为sigmoid，经过神经网络的训练后，将模型部署在电脑摄像头上。0表示步时握拳姿势，1表示握拳姿势。实际效果还是很不错的，在摄像头区域的各个位置，和较远距离的情况下，均能精准识别。
在距离摄像头不同距离和不同图片位置下的测试结果
前面直接用mediapipe提取出了手部的关键点，接下来要用神经网络来对关键点的坐标信息进行预测。
网络结构设计
神经网络的结构如下：
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
flatten (Flatten) (1, 60) 0
_________________________________________________________________
dense (Dense) (1, 512) 31232
_________________________________________________________________
dense_1 (Dense) (1, 512) 262656
_________________________________________________________________
dense_2 (Dense) (1, 4) 2052
=================================================================
Total params: 295,940
Trainable params: 295,940
Non-trainable params: 0
_________________________________________________________________
首先，神经网络的第一层为Flatten。这个层可以将输入的数据拉成一条向量，以便数据更好的输入神经网络。
其次就是真正发挥作用的隐藏层。这里仿照VGG，设计了两个神经元数量相同的隐藏层。理论上讲，只要神经网络的层数够深，它可以拟合任意一个函数。但神经网络的设计并不是越深越好，前面我们已经把手势识别的卷积问题，通过关键点的识别转换为了简单的回归问题，所以并不需要多么深的神经网络，过深的神经网络反而会造成过拟合、计算成本加大、梯度不稳定、网络退化等一系列问题。因为解决的问题比较简单，太宽的网络会提取过多重复特征，因此每层神经元的个数也没有选择VGG的4096，简化为512个神经元。
最后是输出层。因为要识别的是多个手势，输出层的激活函数为softmax，分别输出每个类别对应的预测概率。
神经网络结构图
def get_model():
model = models.Sequential([
layers.Flatten(),
layers.Dense(512, activation='relu', kernel_regularizer=keras.regularizers.l2(1e-3)),
layers.Dense(512, activation='relu', kernel_regularizer=keras.regularizers.l2(1e-3)),
layers.Dense(4, activation='softmax')
return model
引入激活函数是为了增加神经网络模型的非线性，没有激活函数的神经网络叠加了若干层之后，还是一个线性变换，失去了多层神经网络的作用。下图很好的诠释了激活函数的作用，使用激活函数的神经网络可以将数据拟合的更好，而未使用激活函数的神经网络只能拟合一个平面。
使用激活函数与未使用激活函数的神经网络函数图像对比
一开始我认为，隐藏层的第一层不应该使用流行的relu激活函数，原因是我认为特征值是相对坐标，所以有一大部分的值为负值，而relu激活函数会将负值变为0，这样会造成大部分数据的丢失。但后来我发现这样的理解是不对的，因为激活函数作用在神经元输出的位置。虽然relu会将负值变为0，但权重也可以是负数。负值的特征值与一个负值的权重参数相乘，再加上偏置参数，这才是激活函数的输入。权重参数和偏置参数是在反向传播的过程中逐步确定的。
所以特征值取值的正负对于激活函数的选择，有影响，但没有决定性作用。
那么应该如何选择合适的激活函数？
目前较为流行的激活函数是relu激活函数，它逐渐取代了一开始的sigmoid、tanh等激活函数，常被用于较深层的神经网络中。原因是sigmoid、tanh这样的函数存在饱和区，当数据靠近饱和区时，导数趋近于0，这样就会造成反向传播过程中的梯度消失，无法有效训练参数。
relu激活函数虽然目前是最流行的激活函数，但是它的劣势在于会将负数化0，会造成部分的数据丢失。况且我们的神经网络只有简单的两层，所以sigmoid与tanh这样的激活函数的效果也不一定会差。而tanh激活函数相较于sigmoid函数来说，我认为是更优的。因为sigmoid激活函数的输出是0-1的，而tanh函数的输出是-1-1的，相当于做了标准化处理。
具体到底哪个激活函数的效果比较好，只靠分析是难以确定的，因此我把激活函数也作为一个超参数，在训练时调整出最优解。
神经网络的训练过程
训练时将训练集分为多个批（batch）,Keras中权重参数的默认初始化为glorot uniform(均匀分布初始化)，可以理解为初始化权重参数都是随机数，每训练一批（batch）数据都会经过以下过程：
（1）正向传播（前向传播）：
特征数据会按照神经网络传播的方向，输入到神经网络中，并由神经网络给出输出数据，此时神经网络中的参数是随机的，肯定会得到误差很大的结果。
（2）计算误差：
要让神经网络做的更好，就要计算出预测值与真实值之间的误差，在分类问题中，最常用的误差为交叉熵损失函数（CrossEntropy Loss）。交叉熵是信息论中的一个重要概念，主要用于度量两个概率分布间的差异性。
p(x)表示样本的真实分布，q(x)表示模型所预测的分布。
（3）反向传播：
计算出预测值与真实值之间的误差后，就要不断缩小二者之间的误差，才能接近真实值的预测值。
获取到误差后通过随机梯度下降，更新每层的权重参数和偏置参数。因为每层的误差是由本层的权重参数、偏置参数、本层输入决定的，而本层的输入又是上一层的输出。所以我们可以将误差反传给上一层，再通过同样的方式更新上一层的参数，直至所有权重参数和偏置参数更新完毕。
经过以上三个步骤，一批（batch）训练数据就训练完毕，当训练集所有的批（batch）训练完毕，也就是训练集的所有数据都被用作训练，成为一代（epoch），训练多少epoch作为超参数在训练模型是确定。
一开始考虑到数据比较少，想用k折交叉验证的方式来进行训练和调参，但是后来借鉴别人的思路，写了一个截取帧数据的程序，可以很快的制造数据。并且数据比较简单，模型损失曲线可以很快收敛，准确度也比较高，所以就没必要再用k折交叉验证进行训练和调参了。
通过截取帧数据的程序，获取到了3000多个numpy数组数据（包括左右手的三个手势）作为训练数据，并随机打乱，以7：3的比例划分训练集与验证集。
训练过程中，神经网络两个隐藏层均使用relu激活函数；每个隐藏层均作L2正则化参数为1e-3；训练过程中使用Adam优化器，初始参数为1e-3；损失函数使用的是二元交叉熵损失函数；batch_size设置为64；训练50 epoch。
可能是因为数据比较简单，只是一个20*3的二维矩阵，神经网络可以很好的拟合这些数据。使用以上的超参数，训练集上的loss曲线收敛在0.05左右，验证集上的loss也收敛在0.05附近；训练集上的准确率最后达到了0.9930，验证集上的准确率也达到了0.9837。这样的准确率我认为不再需要进行别的调参，完全可以满足系统识别的需求。
以下为训练时控制台输出的部分数据。
Epoch 1/50
47/47 [==============================] - 1s 8ms/step - loss: 0.7626 - accuracy: 0.7665 - val_loss: 0.5135 - val_accuracy: 0.9199
………………
Epoch 50/50
47/47 [==============================] - 0s 4ms/step - loss: 0.0510 - accuracy: 0.9930 - val_loss: 0.0592 - val_accuracy: 0.9837
训练时各参数的变化曲线
作为对语音识别领域的一次简单探索，系统加入了语音唤醒的设计。预期效果为：程序运行后，当用户对电脑说出“Hi,Jarvis!”唤醒词，系统便进入正常运行状态。
因为本系统的主要任务是手势识别，所以实现语音唤醒仅作探索，不做深入研究。但是在研究过程中产生了一些对神经网络新的理解和看法，所以将其单独作为一章将其记录下来。
监听麦克风
要实现语音唤醒，就要实时监听麦克风，获取到麦克风中的音频，这里用pyaudio获取麦克风实例。以p.open()函数获取麦克风数据流，然后读取5个CHUNK，并从中获取一个最大值，这个最大值可以理解为音量。若音量高于设定的阈值，则在数据流中读取30个CHUNK。为了保证每次获取到的音频长度相同，这里设置了固定的30个CHUNK，30个CHUNK已经足够用户说出“Hi,Jarvis!”唤醒词，而如果用户说的语音较长，将会在30个CHUNK后截断。最后将录制的30个CHUNK保存至.wav格式的文件中。
这就实现了当麦克风中出现了一个较大声音后，开始录固定时长的音频。
def monitor_mic(th, filename):
CHUNK = 512
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 16000 # 录音时的采样率
WAVE_OUTPUT_FILENAME = filename + ".wav"
p = pyaudio.PyAudio()
stream = p.open(format=FORMAT,
channels=CHANNELS,
rate=RATE,
input=True,
frames_per_buffer=CHUNK)
frames = []
while True:
for i in range(0, 5):
data = stream.read(CHUNK)
frames.append(data)
audio_data = np.frombuffer(data, dtype=np.short)
temp = np.max(audio_data)
if temp > th:
frames2 = []
print("detected a signal")
print('current threshold：', temp)
# 这里只录制30个CHUNK
print("recording")
for i in range(0, 30):
data2 = stream.read(CHUNK)
frames2.append(data2)
stream.stop_stream()
stream.close()
p.terminate()
wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
wf.setnchannels(CHANNELS)
wf.setsampwidth(p.get_sample_size(FORMAT))
wf.setframerate(RATE)
wf.writeframes(b''.join(frames2))
wf.close()
break
将音频读取为numpy
获取到音频数据后，要对音频数据进行分析，才能识别出用户是否说出了唤醒词。这里使用scipy.io.wavfile.read()函数读取.wav格式的音频。读取到的rate为音频的采样率，是指录音设备在一秒钟内对声音信号的采样次数，数值越大声音的还原度越高，这里不考虑这个参数。data则是numpy格式的音频数据，并进行归一化处理，归一化处理将不同振幅的波形映射到同一尺度。data包含了这段音频的所有内容，是一个一维的向量，可以用matplotlib将其绘制出来，data其实就是音频的信号特征，可以将其可视化为波形图。
def read_wav_data(filename):
rate, data = wavfile.read(filename)
data = data - np.mean(data) # 消除直流分量
data_out = data / np.max(np.abs(data)) # 幅值归一化
return fs, data_out
def wav_show(data, title='positive'):
plt.plot(data)
plt.title(title)
plt.show()
“Hi,Jarvis!”唤醒词波形图
现在系统已经可以完成录音和读取了，接下来就是识别录制的语音是不是唤醒词。开始的思路是使用KNN这样较为简单的思路，来解问题，但考虑到音频特征较为复杂，用KNN难以解决问题，所以还是用到了神经网络。
判断是不是唤醒词，这显然是一个二分类问题，于是我训练了一个简单神经网络，两个隐藏层，神经元个数为2048，输出层为sigmoid。我的想法是直接用神经网络拟合波形图，通过拟合波形图判断用户说了什么。我录制了100个正例和100个负例用于训练。训练过程很快出现了问题。loss正常收敛，在训练集上的accuracy也很高，但是val_loss不断上升，且val_accuracy一直处在0.5左右。这种在训练集上表现很好，但是在验证集上表现很差的现象，我认为可能是出现了过拟合的问题。
语音识别神经网络训练loss与acc变化曲线
于是我在每个隐藏层的后面又加了一个BatchNormalization层，对每批的每个层都做归一化，防止过拟合。一开始效果还是不好，我认为可能是epoch较少的情况下偶然性比较大，于是我又训练了500个epoch，val_loss不稳定，且存在上升趋势，而val_acc还是稳定在0.5左右。结果还是不尽人意。
训练50epoch与500epoch的loss与acc变化曲线
特征和数据决定了机器学习的上限，而模型和算法只是尽可能逼近这个上限。所以我认为，应该是特征工程没有做到位，不能就这么直接拟合波形图。但是一定存在某种方法，可以在音频信号中解析出与说话内容相关的特征。下表中是音频中的常见特征。
常见的音频特征
我认为MFCC特征是对系统有帮助的。根据描述，MFCC是人耳对不同频率的感受程度，人的耳朵在接收信号的时候，不同的频率会引起耳蜗不同部位的震动。耳蜗就像一个频谱仪，自动在做特征提取并进行语音信号的处理。那么我认为这个特征就应该能获取人耳听到的有关于说话内容的一些指标。我尝试把从音频文件图中提取的信号特征转为MFCC，这里用到了librosa库，是一个专门用来处理音频的库。
def mfcc(file_name):
y, sr = librosa.load(file_name, sr=16000)
# 提取 MFCC feature
mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=40)
# 标准化
mfccs = StandardScaler().fit_transform(mfccs)
return mfccs
接下来就是把拿到的mfcc特征拉平为一条向量，输入进开始的神经网络。训练时跑了50个epoch，结果让我大吃一惊。loss与val_loss全部趋近收敛，acc与val_acc也都在接近于1的位置，在验证集上的表现非常好。经过评估，模型在测试集上的准确率可以达到0.9750（可能是因为测试集数据较少，导致准确率过高），而我做的也仅仅是更换了特征。
在使用MFCC作为特征后的loss与acc变化曲线
MFCC特征提取的步骤为：1.对语音信号进行分帧处理；2.用周期图(periodogram)法来进行功率谱(power spectrum)估计；3.对功率谱用Mel滤波器组进行滤波，计算每个滤波器里的能量；4.对每个滤波器的能量取log；5.进行离散余弦变换（DCT）变换；6.保留DCT的第2-13个系数，去掉其它。其中，前面两步是短时傅里叶变换，后面几步主要涉及梅尔频谱。
MFCC特征提取过程
从音频信号到MFCC特征的提取，是做了一系列的数学变换。数据和特征决定了机器学习的上限，而音频信号代表了这段音频的全部信息，所以它的上限应该是很高的。
理论上讲，我之前将音频信号直接输入进神经网络，应该是没有问题的。因为够深的神经网络可以拟合任意的数学函数，神经网络会自动在音频信号中提取对结果有影响的特征，给予不同的权重，输出正确的结果。我认为之前用音频信号作为特征失败的原因是，神经网络的宽度不够宽，深度不够深，神经网络的结构设计也没有加入卷积层这样提取特征的层。仅用两层2048个神经元的隐藏层，是很难将如此复杂的特征提取出来的。
因此我认为，只要神经网络够大够深，设计够合理，是完全可以在音频信号中提取出有用的特征的，但是因为硬件限制，我没有实现更大更深的神经网络。况且神经网络不能一味追求大和深，这样反而会带来训练困难、计算量过大等一系列问题。
不可否认的是，选择合适的特征为神经网络减少了大量的工作，即使简单的神经网络也可以预测出好的结果。特征工程做好了，神经网络才能以更简单的形式，实现最有利的价值。
识别缓冲区
为了保证手势识别等操作具有一定的容错性，我们设计了一个识别缓冲区，用于缓冲识别的结果。本系统中的缓冲区并不是传统意义上的缓冲区，里面存放的并不是实际的识别结果，而是几个int型的属性和两个函数，但它实现的作用与缓冲区相同，因此我们称之为Buffer。
class Buffer:
def __init__(self, volume=20):
self.__positive = 0
self.state = False
self.__negative = 0
self.__volume = volume
self.__count = 0
def add_positive(self):
self.__count += 1
if self.__positive >= self.__volume:
self.state = True
self.__negative = 0
self.__count = 0
else:
self.__positive += 1
if self.__count > self.__volume:
self.__positive = 0
self.__count = 0
def add_negative(self):
self.__count += 1
if self.__negative >= self.__volume:
self.state = False
self.__positive = 0
else:
self.__negative += 1
if self.__count > self.__volume:
self.__positive = 0
self.__count = 0
实例属性有以下几项：__positive、__negative、state、__volume、__count，函数有add_positive()与add_negative()。__positive是正例的个数（int），__negative是负例的个数(int)，state是状态表示是否进入识别正常的状态（bool），__volume表示缓冲区的容量，若正例数或负例数大于容量，则确定状态为True或Flase，__count代表识别计数，是实现容错的重要属性。
模型每识别出一个正例或负例，就调用一次add_positive()或add_negative()函数，向缓冲区内添加一个正例或负例，并记一次数。若正例或负例的个数大于缓冲区容量的个数，那么就可以确定，目前是识别状态或未识别状态。缓冲区通过__count属性来实现容错，每添加一个正例或一个负例，__count就会+1，如果__count大于了容量，也就是在规定的次数中模型识别的不全为正例或负例，那么这时就会将__positive或__negative清零。举个例子，若当前的state为True，也就是说现在是识别状态，即使在识别状态中出现了几个负例，负例的个数也会在容量次数的识别后清零，并不会退出当前的识别状态。
总结来说，缓冲区的设计保证了识别状态的稳定性，使系统有一定的容错性。但是这样也造成识别状态进入的不及时，要等待缓冲区满才能进入识别状态，可以缩小缓冲区的容量来减少进入时间，但容错也会相应减少。
PyWin32
系统通过pywin32库对windows进行操作。pywin32 是一个第三方模块库，主要的作用是方便 python 开发者快速调用 windows API 的一个模块库。它直接包装了几乎所有的 Windows API，可以方便地从 Python 直接调用。在安装了pwin32库之后，就可以导入需要的模块。用到的模块有win32api，win32gui，win32con等。
win32api中提供了常用的用户API，如创建虚拟设备信号（移动鼠标、点击鼠标、敲击键盘……）、向I/O设备发送消息等；
win32gui中是图形设备接口，提供了有关 windows 用户界面图形操作的API，可以对Windows的窗口进行操作。如标题获取句柄、根据句柄获取窗口位置、根据句柄置顶窗口等。
win32con模块内定义了 windows API 内的宏，即 宏常量。
识别区域的映射
鼠标的落点是由mediapipe识别出的关键点决定的，但是当手部在画面的边角时，这时手部的图像不完整，造成边角处无法识别出手部关键点。这时就需要对识别区域进行映射。原本是橙色点移动到画面的右上角，鼠标就移动到屏幕的右上角。在映射之后，橙色点移动到画面中蓝框的右上角，鼠标就可以整个屏幕的右上角。这样就有效避免了画面边缘区域识别不出关键点的情况。
识别区域的映射
在横坐标上，设坐标点在原画面上的坐标为x，这时的x是归一化后的坐标，在画面的最左侧为0，在画面的最右侧为1。蓝框左与距画面左侧的距离占画面宽度的占比为scalex，那么就可以计算出映射后点的横坐标为
纵坐标上同理。此时坐标点在蓝框左侧的横坐标为0，在蓝框右侧的横坐标为1，再用这个坐标乘以屏幕的宽高，就可以计算出鼠标在屏幕的实际落点。
鼠标的落点是通过食指指尖、中指指尖、无名指尖关键点围成三角形的中心决定的，这样做是为了使数据相对稳定。因为mdeiapipe不同帧之间识别出的关键点，位置会有少量的差异，产生一定程度的摆动，造成鼠标指针的不稳定。
开始只用食指指尖控制鼠标落点，小幅度的摆动通过鼠标映射至整个屏幕，就会使摆动幅度加大，难以控制鼠标落点。后来改为由两个关键点决定鼠标的位置，在一定程度上减轻关键点摆动造成的影响，但鼠标精度还是较差，无法稳定在小按钮处。因此改为由三个关键点决定鼠标的落点位置，三个摆动的关键点围成三角形的中心摆动幅度，，是小于等于任意一个摆动点的摆动幅度的，只会比任意一个关键点的摆动幅度小，而不会增大。三个摆动点形成互相牵制。
# 用三个坐标点决定鼠标落点
mid_point_x, mid_point_y = (hands_x[0, 8, 0] + hands_x[0, 12, 0] + hands_x[0, 16, 0]) / 3, (hands_y[0, 8, 0] + hands_y[0, 12, 0] + hands_y[0, 16, 0]) / 3
为了进一步减轻摆动，还做了缓冲的设计。在三个关键点中心的基础上，再由两帧坐标的平均值决定鼠标的落点。这样做虽然减轻了鼠标的摆动，但是造成了卡顿、不跟手的现象，最后还是做了权衡，把缓冲的设计去掉。
鼠标移动问题实现之后，接下来就是鼠标的点击问题。由于时间问题，这里只实现了鼠标点击左键，系统通过右手大拇指敲击食指左侧来实现鼠标点击。由于问题比较简单，这里直接计算的手部关键点的距离，若距离小于一个阈值，则为点击。因为要考虑到手掌的大小和距摄像头的距离，这里的阈值不能是固定的值。我这里选取的阈值为食指根部点（5.INDEX_FINGER_MCP）和中指根部点（9.MIDDLE_FINGER_MCP）的1.5倍距离。
# 用于衡量手部与摄影头的距离
scale = int(math.hypot(CAM_W * (arr[1, 5, 0] - arr[1, 9, 0]),
CAM_H * (arr[1, 5, 1] - arr[1, 9, 1]),
CAM_W * (arr[1, 5, 2] - arr[1, 9, 2])))
# 用于衡量手部的旋转
dis = int(math.hypot(CAM_W * (arr[1, 4, 0] - arr[1, 5, 0]),
CAM_H * (arr[1, 4, 1] - arr[1, 5, 1]),
CAM_W * (arr[1, 4, 2] - arr[1, 5, 2])))
if dis < 1.5 * scale:
# 点击鼠标
mouse_click()
但是鼠标点击又出现了一个新的问题。因为每帧的速度非常快，有时拇指敲击一下会判断成多次点击。为了解决这个问题，这里通过时间间隔来判断。如果调用mouse_click函数的时间间隔大于t，这时才执行一次点击操作。
last_time = 0
def mouse_click(t=0.15):
:return:
global last_time
current_time = time.time()
if current_time - last_time > t:
win32api.mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0)
win32api.mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0)
last_time = current_time
接下来就是滚轮操作。按照设想，滚轮操作是通过捏合手指上下移动来实现滚动。首先训练一个手指捏合的手势，当模型判断出当前手势是捏合状态，就判断滚轮的滚动方向。滚轮滚动是一个多帧的操作，要根据上一帧的图像判断手是上移还是下拉。这里在主循外定义了一个last_y用于保存上一帧的坐标，然后根据两帧之间坐标y的差异判断是上移还是下拉。
def mouse_wheel(up=True, speed=100):
移动鼠标滚轮
:param up:
:param speed:表示每次滚动几格
:return:
if up:
# -1代表页面向下，1代表页面向上
win32api.mouse_event(MOUSEEVENTF_WHEEL, 0, 0, speed)
else:
win32api.mouse_event(MOUSEEVENTF_WHEEL, 0, 0, -speed)
# 右手手势2操作鼠标滚轮
elif rh_index == 2:
# 通过食指指尖的移动来判断是上移还是下拉
current_y = int(arr[1, 8, 1] * CAM_H)
# 以食指指尖和食指第三个关节的距离为缩放尺度
scale = int(math.hypot(CAM_W * (arr[1, 7, 0] - arr[1, 8, 0]),
CAM_H * (arr[1, 7, 1] - arr[1, 8, 1]),
CAM_W * (arr[1, 7, 2] - arr[1, 8, 2])))
# 计算食指指尖与大拇指指尖的距离
dis = int(math.hypot(CAM_W * (arr[1, 4, 0] - arr[1, 8, 0]),
CAM_H * (arr[1, 4, 1] - arr[1, 8, 1]),
CAM_W * (arr[1, 4, 2] - arr[1, 8, 2])))
# 手指发生了下拉
if current_y > last_y and dis < scale:
# 鼠标滚轮向上滚
mouse_wheel()
# 手指发生了上移
elif current_y < last_y and dis < scale:
# 鼠标滚轮向下滚
mouse_wheel(up=False)
# 让当前位置等于上一次的位置
last_y = current_y
键盘的操作设想是想调用中文语音识别的接口，用语音识别取代键盘输入，但是了解到目前的实时语音识别是需要花钱的，所以就暂时不做这个。键盘的一些快捷键则由识别手势组合代替。
手势控制主要包括控制电脑扬声器的音量，和电脑屏幕的亮度。是左手与右手手势的组合实现的。当左手识别为手掌手势时，就会调出选择菜单。并根据手掌的旋转角度来判断选择了哪个菜单。
菜单的选择
计算旋转角度
系统要通过计算手掌的旋转角度来判断选择了哪个菜单。我选择了左手中指指尖与手掌根部点之间的连线作为参考线，计算出这条线的旋转角度，就代表了手掌的旋转角度。要注意的是，OpenCV中的坐标系与平时常用的坐标系并不相同。在数学中常用的坐标系为笛卡尔坐标系，也就是常说的直角坐标系。OpenCV中的坐标系原点位于图片左上角，原点向右为x轴正方向，原点向下为y轴正方向。
在坐标系中计算最方便的是正切函数（tan）。因为有了一个点的坐标(x,y)，可以很容易的计算出tanθ = y/x，然后使用反正切函数（arctan），就可以计算出角度。
# 计算tan值
tan = np.abs((arr[0, 0, 1] - arr[0, 12, 1]) / (arr[0, 0, 0] - arr[0, 12, 0]))
# 计算角度
angle = np.arctan(tan) * 180 / np.pi
为了简化问题，将算出来的tan取了绝对值，这样计算出的角度是恒正的。arctan函数计算出的角度为弧度制，所以要乘180/π，将弧度制转换为角度制。
计算出角度之后，根据角度划分不同的区间，不同的区间加载不同的图片，并向不同的缓冲区内添加正例或负例，这样就实现了菜单的切换。
调节亮度和音量
调节亮度和音量的难点主要在于将一个区间内的值映射至另一区间。
这里靠调用np.interp()函数实现映射关系。interp(x, xp, fp)函数称为线性插值，x: 数组 待插入数据的横坐标，xp: 一维浮点数序列（原始数据点的横坐标），fp: 一维浮点数或复数序列（原始数据点的纵坐标）。可以理解为，x是xp区间范围内的一个点，将其映射至fp区间范围内。假设我有一个在x0~x1范围内的点x，要求出其在y0~y1范围内的映射点y。
# 调节亮度
if buffer_light.state:
frame = cv2.putText(frame, 'light ready', (10, 35), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 127, 0))
frame = draw_line(frame, arr[1, 4], arr[1, 8], thickness=5, color=(255,188,66))
if dis != 0:
# 线性插值，可以理解为将一个区间中的一个值映射到另一区间内
light = np.interp(dis, [int(500 * s), int(3000 * s)], (0, 100))
# 调节亮度
screen_change(light)
# 调节声音
elif buffer_voice.state:
frame = cv2.putText(frame, 'voice ready', (10, 35), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 127, 0))
frame = draw_line(frame, arr[1, 4], arr[1, 8], thickness=5, color=(132,134,248))
if dis != 0:
vol = np.interp(dis, [int(500 * s), int(3000 * s)], voice_range)
# 调节音量
volume.SetMasterVolumeLevel(vol, None)
目录系统介绍OpenCVMediapipeTensorFlowPyWin32数据处理通过mediapipe提取特征转化为相对坐标：均值方差归一化（标准化）：测试效果：神经网络网络结构设计激活函数神经网络的训练过程模型调参语音唤醒监听麦克风将音频读取为numpy识别判断系统设计识别缓冲区键鼠控制PyWin32识别区域的映射鼠标操作键盘操作手势控制计算旋转角度调节亮度和音量本系统灵感源自钢铁侠的贾维斯是基于手势识别的计算机交互系统，利用OpenCV、Mediapipe识别手部关键点；利用TensorFlow搭建
【资源说明】
基于mediapipe+opencv+python的手势识别控制电脑音量小项目源码.zip基于mediapipe+opencv+python的手势识别控制电脑音量小项目源码.zip基于mediapipe+opencv+python的手势识别控制电脑音量小项目源码.zip基于mediapipe+opencv+python的手势识别控制电脑音量小项目源码.zip基于mediapipe+opencv+python的手势识别控制电脑音量小项目源码.zip基于mediapipe+opencv+python的手势识别控制电脑音量小项目源码.zip基于mediapipe+opencv+python的手势识别控制电脑音量小项目源码.zip
基于mediapipe+opencv+python的手势识别控制电脑音量小项目源码.zip
基于mediapipe+opencv+python的手势识别控制电脑音量小项目源码.zip基于mediapipe+opencv+python的手势识别控制电脑音量小项目源码.zip基于mediapipe+opencv+python的手势识别控制电脑音量小项目源码.zip
1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！
2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。
3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可直接用于毕设、课设、作业等。
欢迎下载，沟通交流，互相学习，共同进步！
# Python手势识别代码 基于MediaPipe手部关键点检测 识别数字手势
1. 使用MediaPipe库实现手部21个关键点实时检测；
2. 根据手部关键点坐标计算五根手指的角度；
3. 通过手指角度判断手势，例程中包含数字0~9的手势判断规则；
4. 可以在调试时查看五根手指的角度，根据经验扩展定义自己的手势规则；
5. 代码中附有详细注释，方便阅读和修改。
* 本程序依赖库有 opencv, numpy, mediapipe。运行代码前先安装库：
pip install opencv-python numpy mediapipe
各位同学好，今天和大家分享一下如何使用MediaPipe+Opencv 通过手势识别来控制电脑鼠标的移动和点击，如果有兴趣的话，可以代替鼠标去打游戏。先放图看效果。用画图板来测试
黄框代表电脑屏幕的范围，将黄框的宽高映射到电脑屏幕的宽高。食指竖起并且中指弯下时，移动鼠标。食指和中指都竖起，并且两个指尖距离小于50时，认为是点击鼠标。左上角30代表FPS值
移动鼠标：移动时，食指指尖有淡蓝色圆点，表明鼠标在移动，如右图的绿色线条是鼠标移动轨迹
点击鼠标：当食指和中指间的距离小于50，食指指尖圆点变.
Python的OpenCV库和MediaPipe工具包是可以一起使用的，以实现手势识别的功能。
首先，需要在Python中安装OpenCV库和MediaPipe工具包。可以使用pip命令来安装它们：
pip install opencv-python
pip install mediapipe
安装完成后，就可以开始使用了。
首先，导入必要的库：
```python
import cv2
import mediapipe as mp
接下来，创建一个MediaPipe的Hand对象和一个OpenCV的VideoCapture对象，用于读取摄像头输入：
```python
mp_hands = mp.solutions.hands
hands = mp_hands.Hands()
cap = cv2.VideoCapture(0)
然后，使用一个循环来读取摄像头输入并进行手势识别：
```python
while True:
ret, frame = cap.read()
if not ret:
break
frame_RGB = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
results = hands.process(frame_RGB)
if results.multi_handedness:
for hand_landmarks in results.multi_hand_landmarks:
# 在这里可以对hand_landmarks进行处理和识别手势的操作
cv2.imshow('Gesture Recognition', frame)
if cv2.waitKey(1) == ord('q'):
break
在循环中，首先将读取到的帧转换为RGB格式，然后使用Hands对象的process方法对该帧进行手势识别。得到的结果存储在results变量中。
在对每个检测到的手部进行循环处理时，可以使用hand_landmarks来获取该手的关键点坐标。可以根据这些关键点的位置和运动轨迹来实现手势的识别和分析。
最后，通过cv2.imshow方法显示图像，并使用cv2.waitKey方法等待用户操作。当用户按下"q"键时，循环终止，程序退出。
通过以上步骤，就可以使用Python的OpenCV库和MediaPipe工具包实现手势识别的功能了。当然，实际的手势识别算法和操作需要根据具体需求进行进一步的开发和优化。
### 回答2：
Python OpenCV和MediaPipe结合使用可以实现手势识别。首先，我们需要安装必要的库和工具，包括Python、opencv-python、mediapipe和其他依赖项。
然后，我们可以使用MediaPipe提供的HandTracking模块来检测手部的关键点。它使用机器学习模型来识别手势，并返回手部关键点的坐标。我们可以通过OpenCV的视频捕捉模块读取摄像头的实时图像。
接下来，我们通过应用MediaPipe的HandTracking模块获取手部关键点的坐标，并使用OpenCV将这些坐标绘制到图像上，以便我们可以实时看到手部的位置和动作。
完成这些基本的设置后，我们可以定义特定的手势，例如拇指和食指的指尖接触，作为一个简单的示例。我们可以通过检查特定的关键点之间的距离和角度来识别这种手势。如果关键点之间的距离较小并且角度较小，则我们可以确定手势是拇指和食指的指尖接触。
我们可以使用类似的方法来识别其他手势，比如手掌的张开和闭合，拳头的形成等等。我们可以定义一系列规则和阈值来确定特定手势的识别。
最后，我们可以根据检测到的手势执行特定的操作。例如，当识别到拇指和食指的指尖接触时，我们可以触发相机的快门，实现手势拍照。
总之，Python的OpenCV和MediaPipe结合使用可以实现手势识别。我们可以利用MediaPipe的HandTracking模块检测手部关键点，并使用OpenCV实时绘制手势位置。通过定义特定手势的规则，我们可以识别各种手势并执行相应操作。
起而行之987:
SpingBoot的请求参数获取问题
lhylhyq:
基于python+opencv+mediapipe实现手势识别详细讲解
G.E.N.:
基于python+opencv+mediapipe实现手势识别详细讲解
weixin_43869335:
