Python+OpenCV手势识别源码：HSV分割与凸缺陷计数实战

简介：面向Python图像处理与计算机视觉入门者及高校课程设计场景整理的手势识别源码包，围绕摄像头实时采集、肤色检测与手势轮廓分析展开，可用于课程设计、毕业设计原型验证或OpenCV练习项目。压缩包共67个文件、约42.46MB，包含30个Python源码文件、26个编译缓存文件、6张运行结果截图，以及许可证、AI接口调用相关文件与opencv_python的whl离线安装包，兼顾代码阅读、环境部署与效果对照。目前已有1894人学习下载。源码完整呈现按帧读取摄像头、镜像翻转、固定区域手势框选、HSV肤色检测、高斯滤波、轮廓提取、凸包凹凸点与手指夹角计算等流程，并附改进版代码与多组调试结果图，便于读者理解算法环节、复现实验现象、排查环境依赖问题；同时保留原始版与修改版代码，方便对比实现差异并在此基础上扩展手势指令识别。

1. 摄像头一开，手指数字却在上蹿下跳：这份源码解决的问题

把摄像头对准手掌，屏幕上识别出的数字却在 3 和 4 之间来回跳——这是很多人第一次跑 Python + OpenCV 手势识别代码时的真实体验。这份基于 Python + OpenCV 的手势识别算法设计源代码材料，做的就是把这条链路完整串起来：摄像头取帧、HSV 肤色分割、形态学去噪、轮廓筛选、凸包与凸缺陷计数，最后把"伸出几根手指"翻译成 0 到 5 的数字手势。它适合两类人：一类是在校做课程设计或毕设、需要一套能跑通的图像处理管线、不想卡在调参上的开发者；另一类是已经会用 OpenCV 读写图像，但没做过"从视频流到语义输出"完整流程，想拿一套结构清晰的项目改造成自己手势指令系统的人。整套代码用 PyCharm 按普通 Python 项目打开就能跑，不依赖深度学习框架，纯 CPU 推理，帧率取决于摄像头分辨率，调试过程里每一步中间结果都能可视化，这一点比黑匣子模型友好得多。

2. 项目骨架与技术选型：一条不用深度学习的识别链路是怎么搭的

手势识别这个题目，网上大致两派做法：一派直接上 CNN 训练分类，另一派老老实实做传统图像处理。这份材料走的是后者，核心判断是——在"手掌正对摄像头、背景相对干净、单人单手"这个典型场景下，肤色分割加凸缺陷分析已经能给出稳定结果，而它的调试成本比训练一个模型低一个数量级。模型训练要标数据、要调学习率、要等 GPU；传统管线每一步都能出图看，错在哪一环一目了然。至于它的短板，也得提前说明：背景里出现大面积肤色物体、光照剧烈变化、多人多手同框，这几类情况下传统方法会明显吃力，这是选型时就该知道的事。

2.1 目录结构与文件职责

工程结构不复杂，但如果一开始就把所有逻辑塞进一个main.py，改到第三天你自己都找不到阈值写在哪一行。一份清晰的分层大致是这样：

这个划分的价值在于：调参时你只开config.py，出问题时按"采集→分割→轮廓→特征→判定"的顺序逐层打印中间图，故障点基本不会跑出这个范围。

2.2 环境搭建：Python、OpenCV、PyCharm 三件事

依赖本身很轻，卡住人的通常是环境细节。比较稳妥的做法是给这个项目单独建虚拟环境，避免和你机器上已有的 OpenCV 版本互相干扰。

# 建议 Python 3.8 ~ 3.11，太新的版本某些 OpenCV 轮子还没跟上 python -m venv venv # Windows venv\Scripts\activate # macOS / Linux source venv/bin/activate # 只装这两个就够跑，opencv-python 自带常用编解码 pip install opencv-python numpy -i <你的常用镜像源>

装完先别急着跑主程序，用三行代码验证一下摄像头和 OpenCV 都能通：

import cv2 print(cv2.__version__) # 确认版本号打印正常 cap = cv2.VideoCapture(0) # 0 是默认摄像头，外接摄像头可能要试 1 或 2 ok, frame = cap.read() print("读取成功" if ok else "读取失败", None if frame is None else frame.shape) cap.release() # 用完必须释放，否则下次打开会占用设备

frame.shape打印出来是(480, 640, 3)这样的三元组，说明拿到了 480 行、640 列、3 通道的 BGR 图像。如果ok是False，先排除摄像头被其他软件占用、系统权限未授权这两件事，再怀疑代码。PyCharm 里记住把 Project Interpreter 指向刚建的 venv，否则终端装好了、IDE 里仍然ModuleNotFoundError，这是新手最常翻的车。

2.3 为什么用 HSV 而不是直接对灰度图做阈值

RGB 三个通道都和亮度强相关，同一只手在阳光下和背光下，R 值能差出一倍，你按 RGB 设的阈值换个房间就废了。HSV 把色相（H）、饱和度（S）、明度（V）拆开，肤色在 H 通道上的分布相当集中，光照变化主要影响 V，把 V 的下界放宽一点就能吸收大部分亮度波动。这套代码按 HSV 做肤色掩膜，是成本最低也最容易解释的方案。

如果遇到偏黄或偏白的光源，可以再叠一层 YCrCb 空间做与运算，Cr 通道在 133~173、Cb 通道在 77~127 是常用的肤色区间，两个空间同时命中的像素才保留，误检会明显下降，代价是阈值又多了一组要调。

import cv2 import numpy as np # HSV 肤色区间：H 覆盖红黄一段，S 和 V 给足下限过滤灰白与暗部 LOWER_HSV = np.array([0, 40, 80], dtype=np.uint8) UPPER_HSV = np.array([20, 255, 255], dtype=np.uint8) def skin_mask(bgr_frame): # 高斯模糊压掉传感器噪点，核必须是奇数 blurred = cv2.GaussianBlur(bgr_frame, (5, 5), 0) hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV) # inRange 输出单通道 0/255 掩膜，命中的像素为白 mask = cv2.inRange(hsv, LOWER_HSV, UPPER_HSV) return mask

LOWER_HSV里的[0, 40, 80]三个数分别对应色相下界、饱和度下界、明度下界。色相在 OpenCV 里被压缩到 0~179，所以红色到黄色的肤色大致落在 0~20；饱和度下限 40 是为了把接近灰白的墙面排除掉；明度下限 80 挡掉阴影。这三个数就是整个项目里最需要动手改的地方，后面第 5 章会专门讲怎么调。

3. 图像预处理链路：从一帧原始画面到一只干净的手

预处理这一段决定了后面所有环节的上限。掩膜里混进一块墙、轮廓上挂着半个袖子，凸缺陷算出来必然是错的，而你还以为是自己判定逻辑写错了。这一章按实际执行顺序拆开讲，每一段都给出可以直接抄的代码，以及"为什么放在这个位置"。

3.1 采集与镜像翻转：两行代码决定手感

摄像头读出来的画面默认是"别人看你"的视角，你抬右手，屏幕上是左边那只手在动，交互体验非常别扭。所以第一件事是水平翻转。

import cv2 cap = cv2.VideoCapture(0) cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640) # 分辨率不是越大越好，640x480 够用且省算力 cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480) cap.set(cv2.CAP_PROP_FPS, 30) while True: ok, frame = cap.read() if not ok: break # 读帧失败直接退出，别在循环里死等 frame = cv2.flip(frame, 1) # 1 表示水平翻转，0 是垂直，-1 是都翻 cv2.imshow("camera", frame) if cv2.waitKey(1) & 0xFF == 27: # ESC 退出 break cap.release() cv2.destroyAllWindows()

这里cv2.flip(frame, 1)的第二个参数是翻转模式，1为绕 y 轴水平镜像。分辨率设成 640×480 是个经验值：再高，单帧处理时间上去了帧率掉下来，画面反而更卡；再低，手掌边缘细节不够，凸缺陷位置偏移明显。cv2.waitKey(1)返回的是键盘码，& 0xFF是为了跨平台取低八位，不加在某些系统上 ESC 判定会失效——这个细节很多人抄代码时漏掉，然后在 Windows 上怎么按都没反应。

另外补一句，cap.read()的返回值一定要判。有些摄像头拔掉后不会抛异常，只是持续返回(False, None)，不判的话后面cvtColor会直接给你一个空指针错误，栈信息还指不到真正的原因。

3.2 HSV 肤色分割与阈值区间

拿到镜像帧之后进入分割。整个流程是"模糊 → 转 HSV → inRange → 形态学"，模糊放在最前面是因为噪声一旦被 inRange 放大成孤立白点，后面再用形态学去补，代价更高。

import cv2 import numpy as np def build_mask(bgr_frame, lower, upper): # 第一步：高斯模糊，核大小 (5,5)，标准差 0 表示由核大小自动推算 blurred = cv2.GaussianBlur(bgr_frame, (5, 5), 0) # 第二步：BGR -> HSV，注意 OpenCV 默认读进来就是 BGR，不是 RGB hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV) # 第三步：按区间二值化，落在区间内的置 255，其余置 0 mask = cv2.inRange(hsv, lower, upper) # 第四步：开运算去孤立噪点，闭运算补手掌内部空洞 kernel = np.ones((5, 5), np.uint8) mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=1) mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel, iterations=2) return mask

参数上，GaussianBlur的核必须是正奇数，(5,5)是轻度模糊，如果画面噪点重可以升到(7,7)，但别超过(9,9)，否则手指之间的缝隙会被糊掉，凸缺陷就找不到了。morphologyEx里MORPH_OPEN是先腐蚀后膨胀，作用是消除小面积白点；MORPH_CLOSE是先膨胀后腐蚀，用来填补掌心因为反光产生的小黑洞。闭运算的iterations=2比开运算多一次，因为手掌内部空洞比背景噪点更需要补。

提示：调阈值时把mask和原图并排imshow，比盯着识别结果猜要快得多。哪块背景被误判成肤色，一眼就能看见。

3.3 形态学之后，为什么还要做轮廓面积与凸性过滤

掩膜出来往往不止一个白色区域：脸上可能有、胳膊上可能有、背景里挂着的纸箱也可能有。直接取findContours的第一个结果，经常会抓到一块墙角。所以轮廓阶段要做三重筛选。

import cv2 def pick_hand_contour(mask, min_area=6000, max_area=200000): # RETR_EXTERNAL 只取最外层轮廓，忽略手掌内部的孔洞层级 contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) if not contours: return None best, best_area = None, 0 for cnt in contours: area = cv2.contourArea(cnt) # 第一重：面积过滤，太小是噪点，太大基本是把整个人框进去了 if area < min_area or area > max_area: continue # 第二重：凸性过滤，solidity = 轮廓面积 / 凸包面积 hull = cv2.convexHull(cnt) hull_area = cv2.contourArea(hull) if hull_area <= 0: continue solidity = area / hull_area if solidity < 0.6: # 手掌张开时 solidity 通常在 0.75 以上 continue # 第三重：取面积最大的那个，多手同框时只认最近的一只 if area > best_area: best, best_area = cnt, area return best

min_area=6000是针对 640×480 分辨率拍的：手离镜头半米左右，手掌加手指的轮廓面积大概在 1 万到 3 万像素之间，设 6000 能挡掉大部分噪点又不至于漏检。如果你的摄像头分辨率翻倍，这个值要按面积平方关系同步放大，否则会一直返回None——这是换设备后最常见的失效原因。solidity用轮廓面积除以凸包面积，手指张开时手指间的凹陷会让凸包略大，但整体还在 0.75 往上；如果抓到的是方形物体，这个比值接近 1，反而不会误判成手，真正的过滤器是面积和形状的综合。

3.4 把中间结果可视化，比加打印快十倍

调试阶段建议在主循环里加一个调试窗口，把原图、掩膜、轮廓三张图拼在一起看。

def debug_view(frame, mask, contour): mask_bgr = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR) # 单通道转三通道才能拼 canvas = frame.copy() if contour is not None: cv2.drawContours(canvas, [contour], -1, (0, 255, 0), 2) # 横向拼接：原图 | 掩膜 | 带轮廓的原图 return np.hstack([canvas, mask_bgr, cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)]) # 主循环里 vis = debug_view(frame, mask, contour) cv2.imshow("debug", cv2.resize(vis, None, fx=0.6, fy=0.6))

np.hstack要求三张图高度一致、通道数一致，所以mask必须先cvtColor成 BGR。cv2.resize里fx=0.6是缩放系数，三张 640 宽的图拼起来 1920 宽，很多笔记本屏幕放不下，缩到六成刚好。这套可视化在调阈值阶段能省掉大量"改了参数跑一遍看结果"的循环。

4. 手势特征提取：凸包、凸缺陷和掌心距离怎么配合

预处理拿到一只干净的轮廓之后，真正决定识别准不准的是特征提取。这一章的核心是三个几何量：凸包（convex hull）、凸缺陷（convexity defects）、掌心距离（palm distance）。单用任何一个都不够稳，组合起来才能把"伸出手指"这件事说清楚。

4.1 凸包与凸缺陷：手指缝就是那个"坑"

凸包是能包住轮廓的最小凸多边形，凸缺陷是轮廓上凹进去的部分——通俗讲就是手指之间的缝隙。伸 5 根手指有 4 个缝，握拳一个缝都没有，这就是"缺陷数 + 1 = 手指数"这个朴素结论的来源。

import cv2 import numpy as np def find_defects(contour): # returnPoints=False 返回的是轮廓点的索引，不是坐标，convexityDefects 需要索引 hull_idx = cv2.convexHull(contour, returnPoints=False) # 轮廓点少于 4 个时凸缺陷无意义，直接返回空 if hull_idx is None or len(hull_idx) < 4 or len(contour) < 4: return [] # 这一步在某些 OpenCV 版本上对点序有要求，失败会抛异常，所以包一层 try: defects = cv2.convexityDefects(contour, hull_idx) except cv2.error: return [] if defects is None: return [] result = [] for i in range(defects.shape[0]): s, e, f, d = defects[i, 0] start = tuple(contour[s][0]) # 缺陷起点 end = tuple(contour[e][0]) # 缺陷终点 far = tuple(contour[f][0]) # 凹陷最深的点 depth = d / 256.0 # OpenCV 存的是实际距离乘 256，必须还原 result.append((start, end, far, depth)) return result

convexityDefects的返回值每一行是四个整数[起点索引, 终点索引, 最远点索引, 深度]。深度这个字段是定点数，OpenCV 内部把浮点距离乘了 256 存成整数，所以取出来一定要除以 256，忘了这一步会导致阈值判断完全失真——这是我在别人的代码里见过最多的一个错误，因为它不报错，只是结果莫名其妙。

4.2 缺陷点角度与深度双重过滤

原始缺陷列表不能直接数，因为手腕和手掌根部之间那个大凹陷也会被算进去，而且噪声会在边缘制造大量浅坑。所以每一条缺陷都要过两道筛子：深度够不够，角度够不够尖。

import numpy as np def angle_at(far, start, end): # 余弦定理求凹陷点处的夹角，角度越小说明缝越尖 a = np.linalg.norm(np.array(start) - np.array(far)) b = np.linalg.norm(np.array(end) - np.array(far)) c = np.linalg.norm(np.array(start) - np.array(end)) if a * b == 0: return 180.0 cos_val = (a ** 2 + b ** 2 - c ** 2) / (2 * a * b) cos_val = np.clip(cos_val, -1.0, 1.0) # 浮点误差可能越界，必须 clip return float(np.degrees(np.arccos(cos_val))) def count_fingers(contour, defects, palm_center, palm_radius, min_depth=25.0, max_angle=90.0, max_dist_ratio=2.6): count = 0 for start, end, far, depth in defects: if depth < min_depth: continue # 深度太浅，是噪声不是指缝 if angle_at(far, start, end) > max_angle: continue # 角度太钝，多半是手腕那个大弯 dist = np.linalg.norm(np.array(far) - np.array(palm_center)) if dist > palm_radius * max_dist_ratio: continue # 离掌心太远，基本是手臂边缘 count += 1 return count + 1 if count > 0 else 0 # 有缝才算伸出手指，全握拳返回 0

三个阈值的作用要分清：min_depth=25.0是像素单位，深度小于这个数的凹陷直接丢，它在 640×480 下对应大概一根手指宽度的 1/4；max_angle=90.0是指缝的夹角上限，手指张开时夹角通常在 30~70 度，超过 90 度的钝角基本都是手腕；max_dist_ratio=2.6表示凹陷点到掌心的距离不能超过掌心半径的 2.6 倍，这一条专门用来砍掉手臂方向的假缺陷。最后那个count + 1的逻辑要注意，如果没有通过过滤的缺陷，说明是握拳，应该返回 0 而不是 1。

4.3 掌心距离法：给凸缺陷兜底

凸缺陷法有个天然缺陷：手指并拢时缝隙消失，明明伸了 3 根手指，缺陷数却是 0。所以需要一个不依赖缝隙的辅助判据——掌心距离法：以掌心为圆心画圆，看轮廓上有多少段落在圆外的"远处"。

掌心位置的计算常见做法是用距离变换找最大内切圆圆心：

import cv2 import numpy as np def palm_circle(mask): # 距离变换：每个前景像素到最近背景像素的距离 dist = cv2.distanceTransform(mask, cv2.DIST_L2, 5) # 最大值所在位置就是掌心，最大值就是掌心半径 _, max_val, _, max_loc = cv2.minMaxLoc(dist) return max_loc, max_val # max_loc 是 (x, y) def fingers_by_palm(contour, palm_center, palm_radius, factor=1.35): # 轮廓上每个点到掌心的距离，超过半径 factor 倍就认为伸出去了 far_points = [] for p in contour: pt = p[0] d = np.linalg.norm(pt - np.array(palm_center, dtype=np.float64)) if d > palm_radius * factor: far_points.append(tuple(pt)) return far_points

cv2.distanceTransform第二个参数cv2.DIST_L2表示欧氏距离，第三个参数 5 是掩膜尺寸，常用的取值就是 3 或 5，5 更平滑但略慢。minMaxLoc返回四个值，第二个是最大值、第四个是最大值坐标，很多人第一次用会搞混顺序，写成max_loc, max_val, _, _就全错位了。

factor=1.35这个系数的含义是"伸出手指尖到掌心的距离，至少是掌心半径的 1.35 倍"。这个值不能设太小，否则手掌边缘的凸起会被算进去；也不能太大，会把短手指漏掉。实际调的时候，把手掌正对镜头张开五指，打印d / palm_radius的分布，找那个明显的分界点。

两套方法怎么配合：凸缺陷数给出了一个初值，掌心距离法给出一个独立估计，两者一致就采信，不一致时以较小的那个为准（宁可少数一根，也不要多数）。这种"两个独立判据取保守值"的思路在传统视觉里很常见，比单点判断稳得多。

4.4 帧间平滑：让数字别在 3 和 4 之间反复横跳

单帧判定必然有抖动，摄像头噪声、手部微颤、阈值边界效应都会导致相邻两帧结果不同。最省事也最有效的做法是维护一个长度为 N 的队列，取众数作为输出。

from collections import deque, Counter class GestureSmoother: def __init__(self, window=9, min_votes=5): self.buf = deque(maxlen=window) # 只保留最近 window 帧 self.min_votes = min_votes # 至少这么多帧一致才输出 def update(self, value): self.buf.append(value) if len(self.buf) < self.buf.maxlen: return None # 预热期不输出，避免开头几次误判 counter = Counter(self.buf) most, votes = counter.most_common(1)[0] return most if votes >= self.min_votes else None

window=9大约对应 0.3 秒（按 30fps 算），min_votes=5表示九帧里至少五帧一致才认。这个组合的副作用是响应变慢了一点，但换来的是画面上的数字不再乱跳。如果你的应用对实时性要求更高，可以把窗口缩到 5、票数降到 3，代价是抖动会回来一些。返回None表示"当前不确定"，调用方可以保持上一次的显示值，而不是频繁闪烁。

5. 排查与避坑：光照、背景、抖动这三座大山

这套管线在实验室里跑得好好的，换到客厅、换到下午的窗边就开始失灵，问题基本集中在下面几类。每一条都是踩过的，按"现象 → 原因 → 解决"写清楚，遇到时对着排查能省不少时间。

5.1 现象：手一动掩膜就碎成一片一片；原因：阈值区间过窄叠加运动模糊

这是新手最常报的症状：手静止时掩膜还算完整，一挥手就变成一堆白点，轮廓面积掉到阈值以下，程序一直返回"未检测到手"。原因有两层，一是 HSV 的 S 和 V 下界设得太高，手掌边缘在快速移动时产生运动模糊，颜色被冲淡，像素直接掉出区间；二是高斯模糊核和形态学核不匹配，开运算把本来就细的边缘又削薄了一层。

解决办法是先把S下界从 40 降到 25 左右试试，同时把开运算的iterations从 1 降到 0 或者干脆去掉开运算——噪点主要靠后面的面积过滤和凸性过滤来挡，形态学不需要在前面承担全部责任。如果还不行，把GaussianBlur的核换回(3,3)，运动模糊严重时模糊本身是负收益。

5.2 现象：背景里的木桌、纸箱被识别成手；原因：肤色区间和背景色在 H 通道重叠

木头的颜色在 HSV 上经常落在 H 5~15、S 60~140 这个范围，和肤色高度重合，光靠调阈值很难分开。这时候要去动别的维度：一是把 V 的上界从 255 压到 220 左右，木头通常比手掌暗一点；二是加一层 YCrCb 的 Cr 通道约束，木头的 Cr 值和皮肤有明显差异；三是引入背景减除，用cv2.createBackgroundSubtractorMOG2拿到运动区域，只保留"既像肤色又在动"的像素。

第三种的代价是手静止超过几秒会被判成背景，所以更适合交互类应用，不适合静态手势识别。实际项目里我一般先试前两种，不够再上第三种。

5.3 现象：cv2.convexityDefects抛异常或者返回 None；原因：轮廓点不足或点序不符合要求

报错信息通常是The convex hull indices are not monotonous或者not enough points。前者是因为传入的轮廓点序不是标准的单调顺序——findContours在某些CHAIN_APPROX模式下返回的点序不满足凸包算法的假设；后者是轮廓点数少于 4 个，凸缺陷在数学上不成立。

处理办法很直接：一是findContours统一用cv2.CHAIN_APPROX_SIMPLE，它会压缩掉共线的冗余点，但保留了正确的绕行方向；二是在调用前判断len(contour) >= 4；三是把convexityDefects包在try/except cv2.error里，异常时返回空列表让主流程继续，不要让一帧异常把整个程序打断。很多示例代码不写这层保护，跑几分钟崩一次，非常难定位。

5.4 现象：识别结果整体偏一位，伸 3 根手指显示 4；原因：把手腕凹陷算成了指缝

这是凸缺陷法最经典的偏差。手腕和手掌根部之间天然存在一个很深的凹陷，深度往往比真实指缝还大，如果不做过滤，count + 1出来的值就永远多一。

判断并剔除它的方法有三个可叠加：一是位置，手腕凹陷的最远点 y 坐标明显低于掌心（画面里越靠下 y 越大），可以设一条far[1] > palm_center[1] + palm_radius * 0.8就丢弃；二是角度，手腕凹陷处夹角通常是钝角，max_angle=90能挡掉大半；三是距离，用max_dist_ratio限制凹陷点到掌心的距离。三个条件同时生效，基本不会误杀真实指缝。

注意：这几个阈值都是像素和比例的混合，改分辨率之后必须重新校准，不能直接照抄。

5.5 现象：程序跑几分钟后卡死、内存上涨；原因：帧对象和窗口未释放

表现是帧率逐渐下降，最后完全不动，任务管理器里内存一路往上爬。原因通常是两种情况：一是循环里不断cv2.namedWindow或者重复创建VideoCapture，没有对应释放；二是主循环里存在异常分支，异常抛出后跳过了cap.release()和destroyAllWindows()。

稳妥写法是把释放逻辑放进try/finally：

cap = cv2.VideoCapture(0) try: while True: ok, frame = cap.read() if not ok: break # ... 处理逻辑 if cv2.waitKey(1) & 0xFF == 27: break finally: cap.release() # 无论是否异常都释放设备 cv2.destroyAllWindows()

另外，长时间运行的应用建议每隔几百帧调用一次gc.collect()，虽然 Python 的内存管理本身够用，但 OpenCV 的 Mat 对象在异常路径上偶尔会延迟回收，主动触发一次能避免累积。

6. 二次开发：把手势 0-5 扩成你自己的指令集

这套代码最容易被低估的地方，是它输出的其实不是"数字"，而是"伸出的手指数量 + 每个指尖的坐标"。数字只是最浅的一层封装，真正值钱的是far_points这个列表——每个元素都是一根伸出的手指尖位置。你完全可以绕开数字，直接用指尖坐标做文章。

改造路径大致三条。第一条是加静态手势组合：把"手指数量"换成"哪几根手指伸出"的位掩码。做法是在count_fingers里不返回数量，而是返回一个 5 位布尔数组，判断每根手指是否伸出时，用指尖相对掌心的角度分区——以掌心为原点，把 360 度分成 5 个扇区，落在哪个扇区就算哪根手指。这样"OK 手势""比心""剪刀手"都能用一个位掩码表示，映射表放在config.py里，新增手势只改配置不改逻辑。

第二条是加动态手势：连续几帧的指尖坐标序列本身就是一条轨迹，画个圆就是"画圈"，快速横移就是"挥手"。最简单的实现是维护一个长度 30 的坐标队列，算起点到终点的位移方向和累计转角，超过阈值就触发事件。这一步不需要任何机器学习，纯粹是几何统计，但能把手势从"静态状态"升级成"动作指令"，交互丰富度提升很明显。

第三条是接业务：把识别结果通过一个回调函数抛出去，而不是直接在主循环里print。定义一个on_gesture(name)接口，主循环只管检测和调用回调，具体是控制幻灯片翻页、控制播放器、还是通过串口发给下位机，全部解耦到外部模块。这样整套视觉代码不需要为任何一个具体业务改一行，复用性直接上一个台阶。

验证方法上，我一般会做两件事：一是录一段固定动作的视频文件，用cv2.VideoCapture("test.mp4")替掉摄像头输入，跑完整管线统计每类手势的识别帧数和误判帧数，比实时看屏幕可靠得多；二是把config.py里所有阈值导出成一份表，改任何一项都在表里记一笔并注明原因，否则调了两周之后你完全不记得max_dist_ratio为什么是 2.6 而不是 2.4。

踩过的最大一个坑是：早期我为了"通用"，把所有阈值都做成运行时可通过滑条调整的，结果参数一多，反而没人知道正确值是多少，每次换环境都要重新拖一遍。后来改成固定一组默认值写死在配置里，只在调试模式才显示滑条，问题立刻少了。从那以后我每次动阈值之前，都强制先把原图、掩膜、轮廓三张图并排开一个调试窗口看一遍，确认问题到底出在哪一环再动手，而不是凭感觉调数字。希望帮到你。

本文还有配套的精品资源，点击获取