OpenCV视频处理

import cv2
import os

folder=os.path.exists('frame')

# 检查‘frame’文件夹是否存在
# 如果不存在，则创建文件夹
if not folder:
    os.makedirs('frame')
    print('new folder...')
    print('OK')
else:
    print('There is this folder!')

# 帧编号
number=0

# 创建VideoCapture对象
cap=cv2.VideoCapture('video.mp4')

while True:
    # 从视频中读取一帧
    ret,frame=cap.read()

    # 帧编号增加
    number=number+1
    if ret:
        # 保存帧
        cv2.imwrite(f"./frame/save{number}.jpg",frame)

    # 退出循环
    else:
        break

print('Saved in the frame folder.')

print('Success!')

# 释放VideoCapture对象
cap.release()

import cv2

# 创建一个 VideoCapture 对象
cap = cv2.VideoCapture('video.mp4')

# 获取视频帧的尺寸和帧率
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = int(cap.get(cv2.CAP_PROP_FPS))

# 创建一个 VideoWriter 对象
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('output.avi', fourcc, fps, (width, height))

while True:
    # 从视频中读取一帧
    ret, frame = cap.read()

    if ret:
        # 处理帧
        # ...
        # 将处理后的帧写入输出视频
        out.write(frame)

    else:
        break

print('Succeed in saving!')

# 释放 VideoCapture 和 VideoWriter 对象
cap.release()
out.release()

import cv2
import matplotlib.pyplot as plt

# 读取图像，灰度格式
image_path = 'test.jpg'
img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

# 计算直方图
hist = cv2.calcHist([img], [0], None, [256], [0, 256])

# 可视化直方图
plt.figure()
plt.title('Grayscale Histogram')
plt.xlabel('Pixel Intensity')
plt.ylabel('Frequency')
plt.plot(hist, color='black')
plt.xlim([0, 256])

# 保存绘图
save_path = 'histogram.png'
plt.savefig(save_path)

print(f'Saved as: {save_path}')

import cv2

# 打开视频文件
cap = cv2.VideoCapture('video.mp4')

# 判断是否打开成功
if not cap.isOpened():
    print('Failed to open the video.')
    exit()

# 帧数
frame_count = 0

# 逐帧读取
while True:
    ret, frame = cap.read()
    if not ret:
        break

    frame_count += 1
    print(f"Processing frame {frame_count}.")

    # 每一帧的大小(H,W,C)
    height, width, channel = frame.shape

    for y in range(height):
        for x in range(width):
            # 获取RGB三个通道值
            b, g, r = frame[y, x]
            # 处理像素
            # ...
            pass

# 释放视频对象
cap.release()
print('Finished!')

import cv2
import numpy as np

# 视频路径
video_path = 'video.mp4'
cap = cv2.VideoCapture(video_path)

# 设置帧数
N = 50 # 总处理帧数
count = 0 # 已处理帧数

# 读取第一帧获取尺寸
ret, frame = cap.read()
if not ret:
    print('Cannot read the video!')
    exit()

# 每一帧的参数(H,W,C)
height, width, channels = frame.shape

# 初始化累加数组（浮点型）
accumulate = np.zeros((height, width, channels), dtype=np.float32)

# 将第一帧加入累加
accumulate += frame
count += 1

while count < N:
    ret, frame = cap.read()
    if not ret:
        break

    accumulate += frame
    count += 1

# 求均值
background = (accumulate / count).astype(np.uint8)

# 高斯滤波平滑背景，消除鬼影
background_smooth = cv2.GaussianBlur(background, (7, 7), 0)

# 左边是原始均值背景，右边是平滑后的背景
combined = np.hstack((background, background_smooth))

# 保存背景图像
cv2.imwrite('background_comparison.png', combined)
print('Comparison image saved!')

cap.release()

import cv2
import numpy as np

# 视频路径
video_path = 'video.mp4'
cap = cv2.VideoCapture(video_path)

# 设置使用的帧数
N = 50
count = 0
frames = []

# 读取前N帧
while count < N:
    ret, frame = cap.read()
    if not ret:
        break
    
    frames.append(frame.astype(np.float32)) # 转浮点，避免溢出
    count += 1

cap.release()

if len(frames) == 0:
    print('Failed to read any frames.')
    exit()

# 将帧堆叠为(N,H,W,C)
stacked_frames = np.stack(frames, axis=0)

# 沿时间轴计算中值
background = np.median(stacked_frames, axis=0).astype(np.uint8)

# 保存背景图像
cv2.imwrite('background_median_color.png', background)
print('Background saved!')

# %pip install opencv-python numpy matplotlib ipywidgets -q
import cv2, numpy as np, math, time
from pathlib import Path
import matplotlib.pyplot as plt
from IPython.display import Video, display

from matplotlib import pyplot as plt
from matplotlib import font_manager, rcParams
# 在 Windows 上常见的中文字体优先级列表
_candidate_fonts = [
    "SimHei",            # 黑体
    "Microsoft YaHei",   # 微软雅黑
    "SimSun",            # 宋体
    "KaiTi",             # 楷体
]
rcParams['font.sans-serif'] = _candidate_fonts
rcParams['axes.unicode_minus'] = False  # 使坐标轴等能正常显示负号
print("Matplotlib 中文字体设置完成：", rcParams['font.sans-serif'])

DATA = Path("data")
OUT = Path("outputs")
DATA.mkdir(exist_ok=True); OUT.mkdir(exist_ok=True)

video_path = str(DATA/"demo.mp4")
bg_path = str(DATA/"bg_estimated.jpg")
print("视频：", video_path)
print("背景：", bg_path)

# 准备单帧示例
cap = cv2.VideoCapture(str(Path("data")/"demo.mp4"))
ok, f1 = cap.read()
ok2, f2 = cap.read()  # 下一帧（用于帧间差分）
cap.release()

bg = cv2.imread(str(Path("data")/"bg_estimated.jpg"), cv2.IMREAD_COLOR)
assert f1 is not None and bg is not None, "请先完成任务1并确保存在 data/room.mp4 与 outputs/bg_estimated.jpg"

# 预处理：转灰度 & 轻微模糊（可调）
g1 = cv2.GaussianBlur(cv2.cvtColor(f1, cv2.COLOR_BGR2GRAY), (5,5), 0)
g2 = cv2.GaussianBlur(cv2.cvtColor(f2, cv2.COLOR_BGR2GRAY), (5,5), 0)
gbg = cv2.GaussianBlur(cv2.cvtColor(bg, cv2.COLOR_BGR2GRAY), (5,5), 0)

# TODO：可以自己实现一个absdiff函数
diff_bg = cv2.absdiff(g1, gbg)  # 背景差分
diff_fr = cv2.absdiff(g2, g1)   # 帧间差分

fig, ax = plt.subplots(1,3, figsize=(12,4))
ax[0].imshow(cv2.cvtColor(f1, cv2.COLOR_BGR2RGB)); ax[0].set_title("原始帧")
ax[1].imshow(diff_bg, cmap="gray"); ax[1].set_title("背景差分 absdiff(frame, bg)")
ax[2].imshow(diff_fr, cmap="gray"); ax[2].set_title("帧间差分 absdiff(frame_t, frame_t-1)")
for a in ax: a.axis("off")
plt.show()

# 复用上一节的 diff_bg
diff = diff_bg.copy()

# 固定阈值
T = 28
_, m_fixed = cv2.threshold(diff, T, 255, cv2.THRESH_BINARY)

# OTSU（会忽略手动阈值，返回自动T）
_, m_otsu = cv2.threshold(diff, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)

fig, ax = plt.subplots(1,4, figsize=(12,4))
ax[0].hist(diff.ravel(), bins=50); ax[0].set_title("差分直方图")
ax[1].imshow(diff, cmap="gray"); ax[1].set_title("差分图")
ax[2].imshow(m_fixed, cmap="gray"); ax[2].set_title(f"固定阈值 T={T}")
ax[3].imshow(m_otsu, cmap="gray"); ax[3].set_title("OTSU 自动阈值")
for a in ax: a.axis("off")
plt.show()

import cv2, numpy as np, matplotlib.pyplot as plt

# 先用固定阈值得到一个粗掩码
T = 28
_, mask0 = cv2.threshold(diff_bg, T, 255, cv2.THRESH_BINARY)


# 结构元素（核）
kernel3 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3,3))
kernel5 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5,5))

# 腐蚀（瘦身）
erode_3_1 = cv2.erode(mask0, kernel3, iterations=1)
erode_5_1 = cv2.erode(mask0, kernel5, iterations=1)
erode_5_2 = cv2.erode(mask0, kernel5, iterations=2)

# 膨胀（增粗）
dilate_3_1 = cv2.dilate(mask0, kernel3, iterations=1)
dilate_5_1 = cv2.dilate(mask0, kernel5, iterations=1)
dilate_5_2 = cv2.dilate(mask0, kernel5, iterations=2)

# 直接输出（不保存文件）
fig, ax = plt.subplots(2, 4, figsize=(12,6))
ax[0,0].imshow(mask0, cmap="gray"); ax[0,0].set_title("原始二值 mask0")
ax[0,1].imshow(erode_3_1, cmap="gray"); ax[0,1].set_title("Erode 3x3×1")
ax[0,2].imshow(erode_5_1, cmap="gray"); ax[0,2].set_title("Erode 5x5×1")
ax[0,3].imshow(erode_5_2, cmap="gray"); ax[0,3].set_title("Erode 5x5×2")

ax[1,0].imshow(mask0, cmap="gray"); ax[1,0].set_title("原始二值 mask0")
ax[1,1].imshow(dilate_3_1, cmap="gray"); ax[1,1].set_title("Dilate 3x3×1")
ax[1,2].imshow(dilate_5_1, cmap="gray"); ax[1,2].set_title("Dilate 5x5×1")
ax[1,3].imshow(dilate_5_2, cmap="gray"); ax[1,3].set_title("Dilate 5x5×2")

for a in ax.ravel(): a.axis("off")
plt.tight_layout(); plt.show()

# 开运算示例

# 先用固定阈值得到一个粗掩码
T = 28
_, mask0 = cv2.threshold(diff_bg, T, 255, cv2.THRESH_BINARY)

ks = [3,5,7]
outs = []
for k in ks:
    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (k,k))
    # 开运算示例
    m_open = cv2.morphologyEx(mask0, cv2.MORPH_OPEN, kernel)
    outs.append((k, m_open))

fig, ax = plt.subplots(1, len(outs)+1, figsize=(14,4))
ax[0].imshow(mask0, cmap="gray"); ax[0].set_title("原始二值")
for i,(k,m) in enumerate(outs, start=1):
    ax[i].imshow(m, cmap="gray"); ax[i].set_title(f"Open {k}x{k}")
for a in ax: a.axis("off")
plt.show()

# 闭运算示例：

# 先用固定阈值得到一个粗掩码
T = 28
_, mask0 = cv2.threshold(diff_bg, T, 255, cv2.THRESH_BINARY)

ks = [3, 5, 7]
outs = []
for k in ks:
    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (k, k))
    # 闭运算（Close）= 先膨胀后腐蚀：填小孔、连通细缝
    m_close = cv2.morphologyEx(mask0, cv2.MORPH_CLOSE, kernel)
    outs.append((k, m_close))

# 直接输出，不保存
fig, ax = plt.subplots(1, len(outs) + 1, figsize=(14, 4))
ax[0].imshow(mask0, cmap="gray"); ax[0].set_title("原始二值")
for i, (k, m) in enumerate(outs, start=1):
    ax[i].imshow(m, cmap="gray"); ax[i].set_title(f"Close {k}x{k}")
for a in ax: a.axis("off")
plt.show()

kernel5 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5,5))

# 开运算（去噪）
_, mask0 = cv2.threshold(diff_bg, 28, 255, cv2.THRESH_BINARY)
mask_open = cv2.morphologyEx(mask0, cv2.MORPH_OPEN, kernel5)

# 闭运算（填孔/连通）
mask_close = cv2.morphologyEx(mask_open, cv2.MORPH_CLOSE, kernel5)

fig, ax = plt.subplots(1,3, figsize=(12,4))
ax[0].imshow(mask0, cmap="gray"); ax[0].set_title("阈值后")
ax[1].imshow(mask_open, cmap="gray"); ax[1].set_title("开运算 → 去噪")
ax[2].imshow(mask_close, cmap="gray"); ax[2].set_title("闭运算 → 连通")
for a in ax: a.axis("off")
plt.show()

# 对差异背景图像进行二值化处理
# 参数说明：
# diff_bg: 输入的差异背景图像
# 28: 阈值，像素值超过此值会被处理
# 255: 最大值，超过阈值的像素会被设置为此值
# cv2.THRESH_BINARY: 二值化类型，超过阈值为255，否则为0
# 返回值：第一个为阈值（通常不用，用_接收），第二个为处理后的二值图像base
_, base = cv2.threshold(diff_bg, 28, 255, cv2.THRESH_BINARY)

# 定义不同类型和大小的形态学操作结构元素（卷积核）
# 用于后续的开运算和闭运算，比较不同结构元素的处理效果
kernels = {
    "ELLIPSE-3": cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3,3)),  # 3x3椭圆形结构元素
    "ELLIPSE-5": cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5,5)),  # 5x5椭圆形结构元素
    "RECT-5":    cv2.getStructuringElement(cv2.MORPH_RECT, (5,5)),     # 5x5矩形结构元素
    "CROSS-5":   cv2.getStructuringElement(cv2.MORPH_CROSS, (5,5)),    # 5x5十字形结构元素
}

# 存储不同结构元素处理后的结果
rows = []
# 遍历所有结构元素，分别进行两种顺序的形态学操作
for name,k in kernels.items():
    # 先进行开运算（去除噪点）再进行闭运算（填充孔洞）
    open_then_close = cv2.morphologyEx(cv2.morphologyEx(base, cv2.MORPH_OPEN, k), cv2.MORPH_CLOSE, k)
    # 先进行闭运算（填充孔洞）再进行开运算（去除噪点）
    close_then_open = cv2.morphologyEx(cv2.morphologyEx(base, cv2.MORPH_CLOSE, k), cv2.MORPH_OPEN, k)
    # 将结构元素名称和两种处理结果存入列表
    rows.append((name, open_then_close, close_then_open))

# 可视化所有结果，便于对比
# 创建子图：行数为结构元素数量+1（多一行放原始图），列数为3
# figsize设置图像整体大小
fig, ax = plt.subplots(len(rows)+1, 3, figsize=(10, 3*(len(rows)+1)))

# 第一行显示原始二值图像
ax[0,0].imshow(base, cmap="gray"); ax[0,0].set_title("原始二值")
# 第一行后两列不显示内容，关闭坐标轴
ax[0,1].axis("off"); ax[0,2].axis("off")

# 遍历处理结果，逐行显示
for i, (name, o_c, c_o) in enumerate(rows, start=1):
    # 第一列显示结构元素名称
    ax[i,0].text(0.0, 0.5, name, fontsize=12); ax[i,0].axis("off")
    # 第二列显示先开后闭的处理结果
    ax[i,1].imshow(o_c, cmap="gray"); ax[i,1].set_title("Open→Close")
    # 第三列显示先闭后开的处理结果
    ax[i,2].imshow(c_o, cmap="gray"); ax[i,2].set_title("Close→Open")

# 关闭所有子图的坐标轴，使图像更整洁
for a in ax.ravel():
    if hasattr(a, "set_axis_off"): a.set_axis_off()

# 自动调整子图间距
plt.tight_layout()
# 显示图像
plt.show()

def prepare_demo():
    """准备演示用的视频帧和前景掩码，用于展示背景差分与形态学处理效果"""
    # 读取视频文件（路径为data目录下的demo.mp4）
    # 使用Path处理路径，增强跨平台兼容性
    cap = cv2.VideoCapture(str(Path("data")/"demo.mp4"))
    
    # 读取视频的一帧画面，并释放视频捕获资源（仅需一帧用于演示）
    # ok为布尔值，表示是否成功读取帧；frame为读取到的视频帧
    ok, frame = cap.read(); cap.release()
    
    # 读取预估计的背景图像（路径为data目录下的bg_estimated.jpg）
    bg = cv2.imread(str(Path("data")/"bg_estimated.jpg"))
    
    # 断言检查：确保帧和背景图像都成功读取，否则提示错误信息
    # 防止后续处理因数据缺失而报错
    assert ok and bg is not None, "请先完成任务1，或放置 data/room.mp4 与 data/bg_estimated.jpg"
    
    # 对视频帧进行预处理：
    # 1. 从BGR格式转为灰度图（减少计算量，简化处理）
    # 2. 应用5x5的高斯模糊（平滑图像，减少高频噪声干扰）
    g1  = cv2.GaussianBlur(cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY), (5,5), 0)
    
    # 对背景图像进行同样的预处理（保持处理方式一致，确保差分有效性）
    gbg = cv2.GaussianBlur(cv2.cvtColor(bg,     cv2.COLOR_BGR2GRAY), (5,5), 0)
    
    # 计算视频帧与背景图像的灰度差分（获取两图的差异区域）
    # 绝对差分能有效突出前景目标（与背景不同的区域）
    diff = cv2.absdiff(g1, gbg)
    
    # 对差分结果进行二值化处理：
    # - 阈值设为28，像素值超过28的区域视为前景（设为255，白色）
    # - 低于等于28的区域视为背景（设为0，黑色）
    # 得到初始掩码mask0
    _, mask0 = cv2.threshold(diff, 28, 255, cv2.THRESH_BINARY)
    
    # 定义形态学操作的结构元素：5x5的椭圆形核
    # 椭圆形核在处理曲线边缘时效果更自然，适合大多数场景
    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5,5))
    
    # 对初始掩码进行形态学优化：
    # 1. 先开运算（MORPH_OPEN）：去除小面积噪点（如孤立的亮点）
    # 2. 再闭运算（MORPH_CLOSE）：填充前景区域内的小空洞，使掩码更完整
    mask = cv2.morphologyEx(cv2.morphologyEx(mask0, cv2.MORPH_OPEN, kernel), cv2.MORPH_CLOSE, kernel)
    
    # 返回处理后的视频帧和优化后的前景掩码
    return frame, mask

# 调用函数准备演示数据
frame_demo, mask_demo = prepare_demo()
# 提示用户数据准备完成
print("演示帧与掩码就绪。")

def diff_mask(frame, bg, thr=30, kernel_size=5):
    """
    计算视频帧与背景图像的差异，并生成优化后的前景掩码
    参数:
        frame: 输入的视频帧（BGR格式）
        bg: 背景图像（BGR格式）
        thr: 二值化阈值，默认30，用于区分前景和背景
        kernel_size: 形态学操作的结构元素大小，默认5
    返回:
        m: 优化后的前景掩码（二值图像，255表示前景，0表示背景）
    """
    # 将输入帧和背景图从BGR格式转为灰度图
    # 目的：减少通道数，降低计算复杂度，简化后续差异计算
    g1 = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    g2 = cv2.cvtColor(bg, cv2.COLOR_BGR2GRAY)
    
    # 计算灰度图的绝对差分
    # 作用：突出两图中像素值差异明显的区域（即可能的前景目标）
    d = cv2.absdiff(g1, g2)
    
    # 对差分结果进行二值化处理
    # 参数说明：thr为阈值，超过该值的像素设为255（前景），否则设为0（背景）
    # 目的：将连续的差异值转换为离散的二值掩码，明确区分前景和背景
    _, m = cv2.threshold(d, thr, 255, cv2.THRESH_BINARY)
    
    # 创建椭圆形结构元素，用于后续形态学操作
    # 椭圆形核在处理边缘时更平滑，适合大多数自然场景的前景提取
    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size))
    
    # 先进行开运算（去除小面积噪点），再进行闭运算（填充前景中的小空洞）
    # 开运算：消除孤立的小亮点，减少噪声干扰
    # 闭运算：填充前景区域内的小孔洞，使前景目标更完整
    m = cv2.morphologyEx(m, cv2.MORPH_OPEN, kernel)
    m = cv2.morphologyEx(m, cv2.MORPH_CLOSE, kernel)
    
    # 返回优化后的前景掩码
    return m

# 创建视频捕获对象，从指定路径读取视频文件
cap = cv2.VideoCapture(video_path)

# 获取视频帧的高度(H)和宽度(W)，用于后续图像处理和保存
H, W = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)), int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))

# 用于计数成功保存的可视化图像数量
sampled = 0

# 生成5个均匀分布的帧索引（从0到视频总帧数-1），用于采样关键帧
# np.linspace确保帧在视频中均匀分布，dtype=int转换为整数索引
for i in np.linspace(0, max(0, int(cap.get(cv2.CAP_PROP_FRAME_COUNT))-1), 5, dtype=int):
    # 设置视频捕获对象的当前帧位置为索引i，定位到要采样的帧
    cap.set(cv2.CAP_PROP_POS_FRAMES, int(i))
    
    # 读取当前帧，ok为是否读取成功的标志，f为读取到的帧数据
    ok, f = cap.read()
    if not ok:  # 如果读取失败，跳过当前帧
        continue
    
    # 调用diff_mask函数生成前景掩码：基于当前帧与背景的差异，应用阈值和形态学处理
    m = diff_mask(f, bg, thr=28, kernel_size=5)
    
    # 创建原始帧的副本作为覆盖层，用于标记前景区域
    overlay = f.copy()
    # 将掩码中不为0的区域（前景）标记为绿色(0,255,0)，便于可视化前景
    overlay[m>0] = (0,255,0)
    
    # 构建可视化网格：水平拼接4个图像
    # 1. 原始帧(f)
    # 2. 灰度差分图（转换为BGR格式以保持与其他图像通道一致）
    # 3. 前景掩码（转换为BGR格式）
    # 4. 标记了前景的覆盖层
    grid = np.hstack([
        f, 
        cv2.cvtColor(cv2.absdiff(cv2.cvtColor(f, cv2.COLOR_BGR2GRAY), 
                                cv2.cvtColor(bg, cv2.COLOR_BGR2GRAY)), 
                   cv2.COLOR_GRAY2BGR),  # 差分图转BGR
        cv2.cvtColor(m, cv2.COLOR_GRAY2BGR),  # 掩码转BGR
        overlay
    ])
    
    # 保存拼接后的网格图像到OUT目录，文件名包含采样计数
    cv2.imwrite(str(OUT/f"diff_vis_{sampled}.jpg"), grid)
    sampled += 1  # 递增采样计数

# 释放视频捕获资源，避免内存占用
cap.release()

# 打印成功保存的可视化图像数量
print("已保存关键帧可视化：", sampled, "张")

# 定义视频编码器，使用mp4v格式（支持MP4文件输出）
fourcc = cv2.VideoWriter_fourcc(*"mp4v")

# 创建视频捕获对象，读取输入视频
cap = cv2.VideoCapture(video_path)

# 获取视频的帧率(FPS)，若获取失败则默认使用20.0
fps = cap.get(cv2.CAP_PROP_FPS) or 20.0

# 创建视频写入对象，用于保存处理后的可视化视频
# 参数：输出路径、编码器、帧率、视频宽高(W,H)
out = cv2.VideoWriter(str(OUT/"detect_vis.mp4"), fourcc, fps, (W,H))

# 初始化列表，用于存储目标跟踪信息
centers = []    # 存储目标中心坐标 (cx, cy)
rect_wh = []    # 存储目标外接矩形的宽高 (w, h)
angles = []     # 存储目标外接矩形的旋转角度 theta

# 循环读取视频帧，直到所有帧处理完毕
while True:
    # 读取一帧视频，ok为读取成功标志，frame为帧数据
    ok, frame = cap.read()
    if not ok:  # 若读取失败（如到达视频末尾），退出循环
        break
    
    # 调用diff_mask函数生成前景掩码，提取视频帧与背景的差异区域
    m = diff_mask(frame, bg, thr=28, kernel_size=5)
    
    # 从掩码中查找轮廓（目标边界）
    # cv2.RETR_EXTERNAL：只保留最外层轮廓；cv2.CHAIN_APPROX_SIMPLE：简化轮廓点
    cnts, _ = cv2.findContours(m, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
    # 若未检测到轮廓，直接将原始帧写入输出视频并继续下一帧
    if len(cnts) == 0:
        out.write(frame)
        continue
    
    # 选择面积最大的轮廓（假设最大轮廓为目标）
    cnt = max(cnts, key=cv2.contourArea)
    
    # 计算轮廓的最小外接矩形（旋转矩形）
    # 返回值格式：((中心x, 中心y), (宽w, 高h), 旋转角度theta)
    rect = cv2.minAreaRect(cnt)
    
    # 计算矩形的四个顶点坐标（转换为整数用于绘制）
    box = cv2.boxPoints(rect).astype(int)
    
    # 提取矩形中心坐标（转换为整数）
    cx, cy = int(rect[0][0]), int(rect[0][1])
    # 提取矩形宽高和旋转角度
    w, h = rect[1]
    theta = rect[2]
    
    # 将目标信息存入对应列表，用于后续分析
    centers.append((cx, cy))
    rect_wh.append((w, h))
    angles.append(theta)
    
    # 创建原始帧的副本，用于绘制可视化元素（避免修改原图）
    vis = frame.copy()
    
    # 绘制最小外接矩形（绿色，线宽2）
    cv2.drawContours(vis, [box], 0, (0, 255, 0), 2)
    # 绘制目标中心（蓝色圆点，半径3，填充）
    cv2.circle(vis, (cx, cy), 3, (255, 0, 0), -1)
    # 绘制目标轮廓（红色，线宽1）
    cv2.drawContours(vis, [cnt], -1, (0, 0, 255), 1)
    # 在帧上添加文本信息：中心坐标、宽高、旋转角度
    cv2.putText(vis, 
                f"center=({cx},{cy}) w={w:.1f} h={h:.1f} ang={theta:.1f}", 
                (10, 20),                  # 文本位置（左上角）
                cv2.FONT_HERSHEY_SIMPLEX,  # 字体
                0.5,                       # 字体大小
                (0, 0, 0),                 # 文本颜色（黑色）
                1)                         # 线宽
    
    # 将绘制了目标信息的可视化帧写入输出视频
    out.write(vis)

# 释放视频捕获资源和视频写入资源，避免内存泄漏
cap.release()
out.release()

# 显示生成的检测视频（嵌入模式）
display(Video(str(OUT/"detect_vis.mp4"), embed=True))

# 提示视频导出完成
print("检测视频已导出。")