O3.4 opencv摄像头跟踪

最新推荐文章于 2025-09-17 15:58:15 发布

原创最新推荐文章于 2025-09-17 15:58:15 发布 · 1.6k 阅读

14 ·

CC 4.0 BY-SA版权

文章标签：

#opencv #人工智能 #计算机视觉

opencv 专栏收录该内容

12 篇文章

订阅专栏

摄像头OCR

逻辑

1. 导入库与辅助函数定义

python

import numpy as np
import cv2

def cv_show(name, img):
    cv2.imshow(name, img)
    cv2.waitKey(1)  # 等待1毫秒，实现实时显示（不阻塞循环）

def order_points(pts):
    # 对4个点排序：左上、右上、右下、左下
    rect = np.zeros((4, 2), dtype="float32")
    s = pts.sum(axis=1)  # 计算每个点的x+y之和
    rect[0] = pts[np.argmin(s)]  # 左上（和最小）
    rect[2] = pts[np.argmax(s)]  # 右下（和最大）
    diff = np.diff(pts, axis=1)  # 计算每个点的y-x之差
    rect[1] = pts[np.argmin(diff)]  # 右上（差最小）
    rect[3] = pts[np.argmax(diff)]  # 左下（差最大）
    return rect

def four_point_transform(image, pts):
    # 透视变换：将不规则四边形矫正为矩形
    rect = order_points(pts)  # 排序4个点
    (tl, tr, br, bl) = rect  # 解包为左上、右上、右下、左下

    # 计算矫正后图像的宽和高（取最长边）
    widthA = np.sqrt(((br[0]-bl[0])**2) + ((br[1]-bl[1])** 2))  # 下边长
    widthB = np.sqrt(((tr[0]-tl[0])**2) + ((tr[1]-tl[1])** 2))  # 上边长
    maxWidth = max(int(widthA), int(widthB))  # 最大宽度

    heightA = np.sqrt(((tr[0]-br[0])**2) + ((tr[1]-br[1])** 2))  # 右边长
    heightB = np.sqrt(((tl[0]-bl[0])**2) + ((tl[1]-bl[1])** 2))  # 左边长
    maxHeight = max(int(heightA), int(heightB))  # 最大高度

    # 定义矫正后的目标坐标（矩形）
    dst = np.array([[0, 0], [maxWidth-1, 0], [maxWidth-1, maxHeight-1], [0, maxHeight-1]], dtype="float32")

    # 计算透视变换矩阵并应用
    M = cv2.getPerspectiveTransform(rect, dst)  # 生成变换矩阵
    warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight))  # 应用变换
    return warped

cv_show：简化图像显示，waitKey(1)确保实时刷新不卡顿。
order_points：对四边形的 4 个顶点排序，为透视变换做准备。
four_point_transform：核心函数，通过透视变换将倾斜的文档矫正为正面矩形。

2. 摄像头初始化与主循环

python

cap = cv2.VideoCapture(0)  # 打开默认摄像头（0表示第一个摄像头）
if not cap.isOpened():  # 检查摄像头是否打开成功
    print("Cannot open camera")
    exit()

while True:
    flag = 0  # 标记是否检测到文档（1=检测到，0=未检测到）
    ret, image = cap.read()  # 读取一帧图像（ret：是否成功，image：图像数据）
    orig = image.copy()  # 保存原始图像（用于后续透视变换）
    if not ret:  # 读取失败则退出
        print("不能读取摄像头")
        break
    cv_show("image", image)  # 显示原始摄像头画面

初始化摄像头并进入循环，持续读取图像帧。
orig = image.copy()保留原始图像，避免后续处理修改原始数据。

3. 图像预处理与轮廓检测

python

# 预处理：灰度化→高斯滤波→边缘检测
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # 彩色转灰度
gray = cv2.GaussianBlur(gray, (5, 5), 0)  # 高斯滤波去噪（5x5卷积核）
edged = cv2.Canny(gray, 15, 45)  # Canny边缘检测（阈值15和45）
cv_show('1', edged)  # 显示边缘检测结果

# 轮廓检测与筛选
cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]  # 提取轮廓
cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:3]  # 按面积排序，取前3大轮廓（减少计算量）
image_contours = cv2.drawContours(image, cnts, -1, (0, 255, 0), 2)  # 在图像上绘制轮廓
cv_show("image_contours", image_contours)  # 显示带轮廓的图像

预处理流程：灰度化简化计算→高斯滤波减少噪声→Canny 边缘检测提取物体边缘。
轮廓检测：cv2.findContours提取边缘轮廓，按面积取前 3 大轮廓（文档通常是较大的物体）。

4. 文档轮廓识别（核心逻辑）

python

# 遍历前3大轮廓，判断是否为文档（四边形且面积足够大）
for c in cnts:
    peri = cv2.arcLength(c, True)  # 计算轮廓周长（闭合轮廓）
    approx = cv2.approxPolyDP(c, 0.05 * peri, True)  # 轮廓近似（0.05×周长为精度）
    area = cv2.contourArea(approx)  # 计算近似轮廓的面积

    # 条件：面积>20000（过滤小物体）且轮廓为4边形（文档通常是矩形）
    if area > 20000 and len(approx) == 4:
        screenCnt = approx  # 记录文档的4个顶点
        flag = 1  # 标记检测到文档
        print(peri, area)  # 打印周长和面积（调试用）
        print('检测到文档')
        break

轮廓近似：cv2.approxPolyDP将不规则轮廓简化为多边形（如矩形会被简化为 4 个顶点）。
筛选条件：面积足够大（>20000）且为 4 边形，排除小物体和非矩形轮廓。

5. 文档矫正与二值化

python

if flag == 1:  # 如果检测到文档
    # 绘制文档轮廓并显示
    image_contours = cv2.drawContours(image, [screenCnt], 0, (0, 255, 0), 2)
    cv_show("image", image_contours)

    # 透视变换矫正文档
    warped = four_point_transform(orig, screenCnt.reshape(4, 2))  # 用原始图像矫正
    cv_show("warped", warped)  # 显示矫正后的文档

    # 二值化处理（突出文字/内容）
    warped = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY)  # 转灰度
    ref = cv2.threshold(warped, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]  # 自动阈值二值化
    cv_show("ref", ref)  # 显示二值化结果

检测到文档后，先绘制轮廓标记位置，再通过four_point_transform矫正为正面视图。
二值化使用OTSU算法自动确定阈值，将文档内容（如文字）与背景分离。

6. 资源释放

python

cap.release()  # 关闭摄像头
cv2.destroyAllWindows()  # 关闭所有图像窗口

循环结束后释放摄像头资源，关闭所有窗口。

# 导入工具包
import numpy as np
import cv2

def cv_show(name, img):
    cv2.imshow(name, img)
    cv2.waitKey(1)
def order_points(pts):
    # 一共4个坐标点
    rect = np.zeros((4, 2), dtype="float32")

    # 按顺序找到对应坐标0123分别是 左上，右上，右下，左下
    # 计算左上，右下
    s = pts.sum(axis=1)
    rect[0] = pts[np.argmin(s)]
    rect[2] = pts[np.argmax(s)]

    # 计算右上和左下
    diff = np.diff(pts, axis=1)
    rect[1] = pts[np.argmin(diff)]
    rect[3] = pts[np.argmax(diff)]

    return rect
def four_point_transform(image, pts):
    # 获取输入坐标点
    rect = order_points(pts)
    (tl, tr, br, bl) = rect

    # 计算输入的w和h值
    widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2))
    widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2))
    maxWidth = max(int(widthA), int(widthB))

    heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2))
    heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2))
    maxHeight = max(int(heightA), int(heightB))

    # 变换后对应坐标位置
    dst = np.array([
        [0, 0],
        [maxWidth - 1, 0],
        [maxWidth - 1, maxHeight - 1],
        [0, maxHeight - 1]], dtype="float32")

    # 计算变换矩阵
    M = cv2.getPerspectiveTransform(rect, dst)
    warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight))

    # 返回变换后结果
    return warped

# 读取输入
import cv2
cap = cv2.VideoCapture(0)  # 确保摄像头是可以启动的状态。
if not cap.isOpened():  # 打开失败
    print("Cannot open camera")
    exit()

while True:
    flag = 0  # 用于标识 当前是否检测到文档
    ret, image = cap.read()  # 如果正确读取帧，ret为True
    orig = image.copy()
    if not ret:  # 读取失败，则退出循环
        print("不能读取摄像头")
        break  #
    cv_show("image", image)

    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)  # 图像处理-转换为灰度图
    # 预处理
    gray = cv2.GaussianBlur(gray, (5, 5), 0)  # 高斯滤波
    edged = cv2.Canny(gray, 15, 45)
    cv_show('1',edged)

    # 轮廓检测
    cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]

    cnts = sorted(cnts, key=cv2.contourArea, reverse=True)[:3]
    image_contours = cv2.drawContours(image, cnts, -1, (0, 255, 0), 2)
    cv_show("image_contours", image_contours)

    # 遍历轮廓
    for c in cnts:
        # 计算轮廓近似
        peri = cv2.arcLength(c, True)  #计算轮廓的周长
        # C表示输入的点集
        # epsilon表示从原始轮廓到近似轮廓的最大距离，它是一个准确度参数
        # True表示封闭的
        approx = cv2.approxPolyDP(c, 0.05 * peri, True)  # 轮廓近似
        area = cv2.contourArea(approx)
        # 4个点的时候就拿出来
        if area > 20000 and len(approx) == 4:     #20000
            screenCnt = approx
            flag = 1
            print(peri, area)
            print('检测到文档')
            break

    if flag == 1:
        # 展示结果
        # print("STEP 2: 获取轮廓")
        image_contours = cv2.drawContours(image, [screenCnt], 0, (0, 255, 0), 2)
        cv_show("image", image_contours)
        # 透视变换
        warped = four_point_transform(orig, screenCnt.reshape(4, 2))
        cv_show("warped", warped)
        # 二值处理
        warped = cv2.cvtColor(warped, cv2.COLOR_BGR2GRAY)
        # ref = cv2.threshold(warped, 220, 255, cv2.THRESH_BINARY)[1]
        ref = cv2.threshold(warped, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
        cv_show("ref", ref)

cap.release()  # 释放捕获器
cv2.destroyAllWindows()  # 关闭图像窗口

背景建模

背景建模是什么？

指在计算机视觉中，从视频序列中提取出静态背景的一种技术。在视频中，背景通常被定义为相对稳定的部分，例如墙壁、地面或天空等。背景建模的目标是将动态的前景对象与静态的背景进行分离，以便进一步分析和处理。

背景建模的目的？

通过背景建模，我们可以实现很多应用，例如运动检测、目标跟踪、

背景建模---帧差法

帧差法的原理

由于场景中的目标在运动，目标的影像在不同图像帧中的位置不同。该类算法对时间上连续的两帧图像进行差分运算，不同帧对应的像素点相减，判断灰度差的绝对值，当绝对值超过一定阈值时，即可判断为运动目标，从而实现目标的检测功能。

帧差法的优缺点

帧差法非常简单，但是会引入噪音和空洞(人物中间是黑色的)问题

逻辑

<think></think>这段代码实现了基于混合高斯模型的视频运动目标检测与跟踪功能，通过背景建模分离出前景运动目标，并对目标进行轮廓检测和框选。以下是详细的逻辑分析：

1. 导入库与初始化

python

import cv2

# 读取测试视频（若参数为0则调用摄像头）
cap = cv2.VideoCapture('test.avi')

# 创建3x3的十字形卷积核（用于后续形态学运算去噪）
kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3,3))

# 创建混合高斯模型背景减法器（用于分离前景和背景）
fgbg = cv2.createBackgroundSubtractorMOG2()

cv2.VideoCapture：读取视频文件（test.avi），若参数为0则切换为摄像头实时采集。
getStructuringElement：生成十字形卷积核，用于后续形态学开运算（去噪）。
createBackgroundSubtractorMOG2：创建混合高斯模型，能自适应学习背景并分离出前景（运动目标）。

2. 视频帧处理主循环

python

while (True):
    ret, frame = cap.read()  # 读取一帧视频（ret：是否成功读取，frame：当前帧图像）
    if not ret:  # 若视频读取完毕或出错，退出循环
        break

循环读取视频帧，ret标记是否读取成功，frame为当前帧的图像数据。

3. 背景建模与前景提取

python

cv2.imshow('frame', frame)  # 显示原始视频帧

# 应用混合高斯模型，提取前景掩码（fgmask：前景为白色255，背景为黑色0）
fgmask = fgbg.apply(frame)
cv2.imshow('fgmask', fgmask)  # 显示原始前景掩码（可能含噪点）

fgbg.apply(frame)：核心步骤，通过混合高斯模型对当前帧进行背景减法，输出前景掩码（fgmask）。运动目标（前景）被标记为白色，静止背景为黑色，但可能存在噪点。

4. 形态学开运算去噪

python

# 对前景掩码进行开运算（先腐蚀后膨胀），去除小噪点
fgmask_new = cv2.morphologyEx(fgmask, cv2.MORPH_OPEN, kernel)
cv2.imshow('fgmask1', fgmask_new)  # 显示去噪后的前景掩码

开运算：先腐蚀（消除小噪点）再膨胀（恢复目标轮廓），有效去除前景掩码中的孤立小噪点，使目标轮廓更清晰。

5. 轮廓检测与目标框选

python

# 从去噪后的前景掩码中提取轮廓（只检测外轮廓，简化轮廓点）
contours, h = cv2.findContours(fgmask_new, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# 遍历所有轮廓，筛选并框选符合条件的目标
for c in contours:
    # 计算轮廓周长（用于筛选较大目标，排除微小噪声）
    perimeter = cv2.arcLength(c, True)  # True表示轮廓闭合
    if perimeter > 188:  # 周长阈值（过滤小目标）
        # 获取轮廓的最小外接矩形（x,y：左上角坐标；w,h：宽高）
        x, y, w, h = cv2.boundingRect(c)
        # 在原始帧上绘制矩形框（绿色，线宽2）
        fgmask_new_rect = cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)

# 显示框选目标后的视频帧
cv2.imshow('fgmask_new_rect', fgmask_new_rect)

findContours：从去噪后的前景掩码中提取目标轮廓，RETR_EXTERNAL只保留外轮廓，CHAIN_APPROX_SIMPLE简化轮廓点（减少计算量）。
轮廓筛选：通过轮廓周长（perimeter > 188）过滤掉过小的噪声轮廓，只保留较大的运动目标。
绘制矩形：对符合条件的目标，用boundingRect获取外接矩形，并在原始帧上绘制绿色框标记目标。

6. 退出条件与资源释放

python

    # 按ESC键（ASCII码27）退出循环
    k = cv2.waitKey(6)  # 每帧等待6毫秒（控制视频播放速度）
    if k == 27:
        break

cap.release()  # 释放视频资源
cv2.destroyAllWindows()  # 关闭所有窗口

waitKey(6)：控制视频播放速度（每帧停留 6 毫秒），同时检测按键，若按下ESC则退出。
循环结束后释放视频资源并关闭窗口。

光流估计

光流估计是什么？

是空间运动物体在观测成像平面上的像素运动的“瞬时速度”，根据各个像素点的速度矢量特征，可以对图像进行动态分析，例如目标跟踪。

光流估计的前提？

（1）亮度恒定：同一点随着时间的变化，其亮度不会发生改变。（2）小运动：随着时间的变化不会引起位置的剧烈变化，只有小运动情况下才能用前后帧之间单位位置变化引起的灰度变化去近似灰度对位置的偏导数。（3）空间一致：一个场景上邻近的点投影到图像上也是邻近点，且邻近点速度一致。因为光流法基本方程约束只有一个，而要求x，y方向的速度，有两个未知变量。所以需要连立n多个方程求解。

逻辑

初始化部分

打开视频捕获设备：

python

cap = cv2.VideoCapture(0)

使用cv2.VideoCapture(0)打开默认的摄像头设备（若参数为视频文件名，则打开相应视频文件）。

随机生成颜色：

python

color = np.random.randint(0, 255, (100, 3))

生成 100 组随机颜色，用于绘制特征点的运动轨迹，每组颜色由 RGB 三个值组成。

读取并处理第一帧：

python

ret, old_frame = cap.read()
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)

读取视频的第一帧，并将其转换为灰度图像，因为光流计算通常在灰度图像上进行。

定义特征点检测参数并检测角点：

python

feature_params = dict(maxCorners=100, qualityLevel=0.3, minDistance=7)
p0 = cv2.goodFeaturesToTrack(old_gray, mask=None, **feature_params)

定义特征点检测的参数：

maxCorners指定最大角点数量为 100。
qualityLevel为角点质量的阈值，只有质量测量值高于该阈值的角点才会被保留。
minDistance设定角点之间的最小距离，以确保角点分散。
然后使用cv2.goodFeaturesToTrack函数在第一帧灰度图像中检测角点，并将检测到的角点存储在p0中。
创建掩模：

python

mask = np.zeros_like(old_frame)

创建一个与第一帧大小相同的全零掩模，用于绘制特征点的运动轨迹。

定义 Lucas - Kanade 光流参数：

python

lk_params = dict(winSize=(15, 15), maxLevel=2)

定义 Lucas - Kanade 光流法的参数：

winSize指定搜索窗口的大小为 15x15 像素。
maxLevel表示金字塔层数为 2。

主循环部分
- 读取视频帧并转换为灰度图：

python

ret, frame = cap.read()
if not ret:
    break
frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

在每次循环中读取视频的下一帧，检查是否成功读取。若成功读取，则将其转换为灰度图像frame_gray。

计算光流：

python

p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params)

使用cv2.calcOpticalFlowPyrLK函数计算光流，该函数根据 Lucas - Kanade 光流法计算前一帧（old_gray）中的特征点（p0）在当前帧（frame_gray）中的新位置（p1）。同时返回状态向量st，用于表示每个特征点是否被成功跟踪（st == 1表示成功跟踪），以及误差向量err。

选择成功跟踪的点：

python

good_new = p1[st == 1]
good_old = p0[st == 1]

从计算得到的新特征点位置p1和旧特征点位置p0中，选择状态为 1（即成功跟踪）的点，分别存储在good_new和good_old中。

绘制轨迹：

python

for i, (new, old) in enumerate(zip(good_new, good_old)):
    a, b = new.ravel()
    c, d = old.ravel()
    a, b, c, d = int(a), int(b), int(c), int(d)
    mask = cv2.line(mask,(a, b),(c, d),color[i].tolist(), 2)
    cv2.imshow('mask',mask)

遍历成功跟踪的特征点对，获取新点和旧点的坐标，并将其转换为整数类型。然后在掩模图像mask上使用cv2.line函数绘制从旧点到新点的线段，颜色从之前随机生成的颜色列表color中选取，线宽为 2。同时显示掩模图像。

合成并显示结果：

python

img = cv2.add(frame, mask)
cv2.imshow('frame', img)

将绘制了轨迹的掩模图像mask与当前帧图像frame进行叠加，生成最终的结果图像img，并显示在名为frame的窗口中。

检查按键并更新数据：

python

k = cv2.waitKey(150)
if k == 27:
    break
old_gray = frame_gray.copy()
p0 = good_new.reshape(-1, 1, 2)

等待 150 毫秒，检查是否有按键按下。如果按下的是 Esc 键（键码为 27），则退出循环。否则，更新旧灰度图像为当前帧的灰度图像，并将当前帧中成功跟踪的特征点位置good_new重新整理为适合下次光流计算的形状（(-1, 1, 2)），作为下一帧光流计算的起始特征点位置p0。

资源释放部分

python

cv2.destroyAllWindows()
cap.release()

循环结束后，释放视频捕获设备资源，并关闭所有 OpenCV 窗口。

物体跟踪

1. 初始化与参数设置

python

import cv2

# 创建CSRT跟踪器实例（CSRT算法适用于高精度跟踪，对遮挡和光照变化有一定鲁棒性）
tracker = cv2.TrackerCSRT_create()
tracking = False  # 跟踪状态标志，初始为未跟踪状态
cap = cv2.VideoCapture(0)  # 打开默认摄像头（0表示第一个摄像头）

CSRT 跟踪器：选择TrackerCSRT_create()是因为该算法在精度和速度之间平衡较好，适合实时跟踪场景。
跟踪标志：tracking用于标记是否处于跟踪状态，初始为False（未跟踪）。

2. 主循环：帧捕获与跟踪逻辑

python

while True:
    ret, frame = cap.read()  # 读取摄像头一帧图像
    if not ret:  # 若读取失败（如摄像头断开），退出循环
        break

循环读取摄像头帧，ret判断是否读取成功，frame为当前帧图像数据。

3. 手动选择跟踪目标（触发条件）

python

if cv2.waitKey(1) == ord('s'):  # 按下's'键时启动跟踪
    tracking = True  # 切换到跟踪状态
    # 让用户用鼠标框选目标区域（ROI），窗口名为'Tracking'，不显示十字准星
    roi = cv2.selectROI('Tracking', frame, showCrosshair=False)
    tracker.init(frame, roi)  # 用当前帧和选中的ROI初始化跟踪器

触发方式：按下键盘s键，激活目标选择模式。
ROI 选择：cv2.selectROI允许用户在图像上拖动鼠标框选目标区域，返回的roi是一个元组(x, y, w, h)（左上角坐标、宽、高）。
初始化跟踪器：tracker.init将选中的目标区域与当前帧关联，作为跟踪的初始状态。

4. 实时跟踪与结果绘制

python

if tracking:  # 若处于跟踪状态
    success, box = tracker.update(frame)  # 更新跟踪结果，返回是否成功及目标位置
    if success:  # 跟踪成功时绘制矩形框
        x, y, w, h = [int(v) for v in box]  # 转换为整数坐标
        # 在当前帧上绘制绿色矩形框（0,255,0），线宽2
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)

更新跟踪：tracker.update(frame)根据当前帧计算目标的新位置，success为True表示跟踪有效，box为目标区域坐标。
绘制结果：若跟踪成功，用矩形框标记目标位置，直观展示跟踪效果。

5. 窗口显示与退出机制

python

cv2.imshow('Tracking', frame)  # 显示当前帧（含跟踪框）

# 按下ESC键（ASCII码27）退出循环
if cv2.waitKey(1) == 27:
    break

实时显示处理后的帧，用户可观察跟踪效果。
按ESC键终止程序，避免无限循环。

6. 资源释放

python

cap.release()  # 释放摄像头资源
cv2.destroyAllWindows()  # 关闭所有显示窗口