企业官网建设流程全解析

简介：本资源是一套基于Python与OpenCV实现的视频车辆测速系统实战项目，面向计算机视觉初学者、智能交通方向开发者及高校课程设计学习者，解决视频流中运动车辆速度估算这一典型工业检测问题。压缩包共14个文件，含2个实测MP4视频（含不同场景车流）、2个核心Python脚本（speed.py实现主流程，corner_detection.py辅助特征定位）、10个XML格式Haar级联分类器文件（覆盖多角度、多尺度车辆检测需求），整体59.38MB，结构清晰、即下即用。已有2424人学习下载，资源提供完整可运行代码链路：从视频读取、背景建模与运动目标检测、车辆ROI提取、像素位移跟踪，到结合物理标定参数的速度换算逻辑，同时隐含后端集成思路（如结果输出接口设计）与音视频协同处理扩展路径。

1. 为什么用 OpenCV 做车辆测速，比直接上深度学习模型更稳、更快、更可控？

你手头有一段城市主干道的监控视频，想实时知道每辆车经过某一段路时的瞬时速度——不是靠车牌识别再查数据库，而是纯视觉：从像素位移算出物理速度。这时候，很多人第一反应是“上 YOLOv8 + DeepSORT 再加速度估计算法”，但实际落地时，90% 的中小项目会卡在三个地方：模型推理延迟高（尤其在边缘设备上）、轨迹跳变导致速度抖动剧烈（同一辆车 ID 在帧间频繁切换）、以及最致命的——缺乏可解释性：车速突然飙到 120km/h，你根本不知道是算法误检了广告牌反光，还是真有超速行为。而 Python + OpenCV 的轻量级测速方案，恰恰能绕过这些黑匣子：它不依赖训练数据，不调 GPU，单线程 CPU 就能跑满 25 FPS；所有逻辑都在明处——你改一个 ROI 区域、调一个像素-米换算系数、删一帧异常光斑，结果立刻可见。这不是“退而求其次”的妥协方案，而是面向工业现场、交通巡检、教学验证等真实场景的确定性优先路径。本文就带你从零搭起一套可复现、可调试、可部署的 OpenCV 车辆测速流水线，重点讲清：怎么把视频里的像素位移，稳稳地落到 km/h 数字上。

2. 用 OpenCV 在本地跑通车辆测速：最小可行流程与四步核心链路

车辆测速的本质，是把视频中连续帧里同一目标的空间位移，结合时间间隔和空间尺度标定，换算成物理速度。OpenCV 不提供“测速模块”，但它提供了完成这四步所需的全部原子能力：ROI 定义、运动检测、目标跟踪、坐标映射。我们不堆复杂算法，只用cv2.createBackgroundSubtractorMOG2+cv2.findContours+ 简单质心跟踪 + 透视变换标定，构成一条清晰、低耦合、易打断点调试的链路。

2.1 定义测速区域：用多边形 ROI 锁定有效检测带，过滤无效运动

测速不是全图扫描，必须限定物理意义明确的“测量段”。比如你要测车辆通过 A-B 两个立柱之间的速度，就要在视频画面上框出对应路段的梯形区域（因透视变形）。OpenCV 提供cv2.polylines和鼠标回调，手动标定最可靠：

import cv2 import numpy as np def draw_roi(event, x, y, flags, param): global roi_points, drawing if event == cv2.EVENT_LBUTTONDOWN: drawing = True roi_points.append((x, y)) elif event == cv2.EVENT_MOUSEMOVE and drawing: # 实时连线预览 img_copy = frame.copy() cv2.polylines(img_copy, [np.array(roi_points)], False, (0, 255, 0), 2) if len(roi_points) > 1: cv2.line(img_copy, roi_points[-2], (x, y), (0, 255, 0), 2) cv2.imshow("ROI Selection", img_copy) elif event == cv2.EVENT_LBUTTONUP: drawing = False # 加载首帧，交互式标定 cap = cv2.VideoCapture("road.mp4") ret, frame = cap.read() roi_points = [] drawing = False cv2.namedWindow("ROI Selection") cv2.setMouseCallback("ROI Selection", draw_roi) print("Click to define ROI vertices (press 'q' when done)") while True: cv2.imshow("ROI Selection", frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cv2.destroyAllWindows() cap.release() # 保存 ROI 多边形（后续所有处理都先做掩膜） roi_mask = np.zeros(frame.shape[:2], dtype=np.uint8) cv2.fillPoly(roi_mask, [np.array(roi_points)], 255)

逻辑说明：这段代码不依赖任何预训练模型，纯靠人工点击定义物理测量区。roi_mask是二值掩膜，后续所有前景提取都只在该区域内进行，大幅降低误检率（如远处行人、树叶晃动）。
参数说明：roi_points是顺时针或逆时针顶点列表，至少需 4 个点构成凸四边形；cv2.fillPoly填充后生成的roi_mask将用于cv2.bitwise_and掩膜操作，确保运动检测只响应 ROI 内部变化。

2.2 提取运动目标：用 MOG2 背景建模 + 形态学滤波，稳定抠出车辆轮廓

监控视频背景基本静止，但光照渐变、树叶微动、摄像头噪声会导致简单帧差法崩溃。MOG2（高斯混合背景建模）是 OpenCV 内置的成熟方案，对缓慢光照变化鲁棒性强：

bg_subtractor = cv2.createBackgroundSubtractorMOG2( history=500, # 背景模型学习帧数，500≈20秒（按25FPS） varThreshold=16, # 像素方差阈值，越小越敏感（默认16，此处未调） detectShadows=True # 启用影子检测（对车辆底部阴影有效） ) # 主循环中逐帧处理 cap = cv2.VideoCapture("road.mp4") while True: ret, frame = cap.read() if not ret: break # 1. 应用 ROI 掩膜 masked_frame = cv2.bitwise_and(frame, frame, mask=roi_mask) # 2. 转灰度 + 背景减除 gray = cv2.cvtColor(masked_frame, cv2.COLOR_BGR2GRAY) fg_mask = bg_subtractor.apply(gray) # 3. 形态学去噪：先闭运算填车体空洞，再开运算去碎屑 kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)) fg_mask = cv2.morphologyEx(fg_mask, cv2.MORPH_CLOSE, kernel) # 填洞 fg_mask = cv2.morphologyEx(fg_mask, cv2.MORPH_OPEN, kernel) # 去噪 # 4. 连通域分析，过滤小区域（排除噪声点） contours, _ = cv2.findContours(fg_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) valid_contours = [] for cnt in contours: area = cv2.contourArea(cnt) if 500 < area < 50000: # 经验阈值：小车轮廓约1000~20000像素 valid_contours.append(cnt)

逻辑说明：createBackgroundSubtractorMOG2自动学习背景分布，对缓慢变化（如云层飘过）比帧差法稳定得多；MORPH_CLOSE先膨胀后腐蚀，能把车辆被遮挡时断裂的轮廓重新连起来；MORPH_OPEN则反向操作，消除孤立噪点。
参数说明：history=500保证背景模型足够“老”，适应长期光照漂移；varThreshold=16是默认值，若环境极暗可降至 8，极亮可升至 24；detectShadows=True对车辆底部阴影建模，提升低矮车辆检出率，但会略微增加计算量。

2.3 跟踪车辆并计算位移：用质心距离+时间戳，构建基础速度公式

OpenCV 本身不提供多目标跟踪器（如 KCF、CSRT），但对测速场景，我们不需要 ID 持久化，只需保证同一辆车在相邻帧内被赋予相同 ID，并记录其质心移动矢量。这里采用最简策略：基于 IoU（交并比）匹配当前帧轮廓与前一帧轮廓，匹配成功则继承 ID 并更新质心：

from collections import defaultdict, deque import time class SimpleTracker: def __init__(self, max_age=30): # ID 失效前最多丢失30帧 self.next_id = 0 self.tracks = {} # {id: {'centroid': (x,y), 'timestamps': deque, 'positions': deque}} self.max_age = max_age def update(self, contours, frame_time): current_centroids = [] for cnt in contours: M = cv2.moments(cnt) if M["m00"] != 0: cx = int(M["m10"] / M["m00"]) cy = int(M["m01"] / M["m00"]) current_centroids.append((cx, cy)) # 若无历史轨迹，直接分配新ID if not self.tracks: for i, c in enumerate(current_centroids): self.tracks[self.next_id] = { 'centroid': c, 'timestamps': deque([frame_time], maxlen=10), 'positions': deque([c], maxlen=10) } self.next_id += 1 return # 计算当前质心与历史质心的欧氏距离矩阵 if not current_centroids: # 本帧无检测，老化所有轨迹 to_delete = [] for tid in self.tracks: if len(self.tracks[tid]['timestamps']) >= 2: # 已有足够数据，尝试外推（此处简化为保持最后位置） pass if len(self.tracks[tid]['timestamps']) < 2: to_delete.append(tid) for tid in to_delete: del self.tracks[tid] return # 构建距离矩阵并贪心匹配 dist_matrix = np.zeros((len(self.tracks), len(current_centroids))) for i, (tid, track) in enumerate(self.tracks.items()): for j, c in enumerate(current_centroids): dist_matrix[i, j] = np.linalg.norm(np.array(track['centroid']) - np.array(c)) # 贪心匹配：找距离最小的未匹配对 matched_tracks = set() matched_contours = set() for i in range(len(self.tracks)): if i in matched_tracks: continue min_j = np.argmin(dist_matrix[i]) if min_j not in matched_contours and dist_matrix[i, min_j] < 50: # 50像素内才认为是同一车 tid = list(self.tracks.keys())[i] self.tracks[tid]['centroid'] = current_centroids[min_j] self.tracks[tid]['timestamps'].append(frame_time) self.tracks[tid]['positions'].append(current_centroids[min_j]) matched_tracks.add(i) matched_contours.add(min_j) # 为未匹配的轮廓分配新ID for j, c in enumerate(current_centroids): if j not in matched_contours: self.tracks[self.next_id] = { 'centroid': c, 'timestamps': deque([frame_time], maxlen=10), 'positions': deque([c], maxlen=10) } self.next_id += 1 # 使用示例 tracker = SimpleTracker() start_time = time.time() while True: ret, frame = cap.read() if not ret: break current_time = time.time() - start_time # ...（前面的 ROI、背景减除、轮廓提取代码） tracker.update(valid_contours, current_time) # 绘制跟踪结果 for tid, track in tracker.tracks.items(): if len(track['positions']) >= 2: # 取最近两帧计算瞬时速度 p0 = track['positions'][-2] p1 = track['positions'][-1] t0 = track['timestamps'][-2] t1 = track['timestamps'][-1] if t1 - t0 > 0.02: # 至少间隔20ms，避免除零 pixel_dist = np.linalg.norm(np.array(p1) - np.array(p0)) # 此处暂留空：像素距离 → 物理距离的换算将在第3章完成 # speed_px_per_sec = pixel_dist / (t1 - t0)

逻辑说明：这个SimpleTracker不追求 SOTA 跟踪精度，而是牺牲 ID 长期稳定性，换取位移计算的确定性。它只关心“同一辆车在相邻帧是否移动”，不处理遮挡重识别，因此代码极简、无外部依赖、全程可 debug。dist_matrix和贪心匹配保证了计算开销可控（O(N×M)），在 1080p 视频下 CPU 占用低于 15%。
参数说明：max_age=30是 ID 生命周期，设为 30 帧（约 1.2 秒）足够覆盖短暂遮挡；dist_matrix[i, j] < 50是匹配阈值，50 像素约等于 1 米（取决于标定），过大易误匹配，过小则 ID 断裂频繁。

2.4 速度换算核心：必须做空间标定，否则所有数字都是玄学

这是整个流程中最容易被跳过的一步，也是导致“测速结果看起来很准，实际误差超 30%”的根源。OpenCV 输出的是像素位移，而你需要的是 km/h。中间必须插入物理尺度标定环节，把图像坐标系映射到世界坐标系。最常用且实操性最强的是单应性矩阵（Homography）标定：在路面铺设已知尺寸的矩形标定板（如 2m×2m），拍摄其图像，用cv2.findHomography解算映射关系。

# 标定步骤：先拍一张标定板图像（已知物理尺寸） # 假设标定板四个角在世界坐标系中为： world_pts = np.array([ [0, 0], # 左上 [2, 0], # 右上（宽2米） [2, 2], # 右下（高2米） [0, 2] # 左下 ], dtype=np.float32) # 在图像中标记对应四点（用鼠标或已知坐标） img_pts = np.array([ [120, 85], # 左上像点 [320, 78], # 右上像点 [295, 210], # 右下像点 [95, 215] # 左下像点 ], dtype=np.float32) # 计算单应性矩阵 H（3x3），实现 img → world 映射 H, _ = cv2.findHomography(img_pts, world_pts, method=cv2.RANSAC, ransacReprojThreshold=3.0) # 应用：将图像中任意点 (x,y) 转为物理坐标 (X,Y)（单位：米） def pixel_to_world(x, y, H): # 齐次坐标转换 pt_h = np.array([[x, y, 1]], dtype=np.float32).T pt_world_h = H @ pt_h pt_world = pt_world_h[:2] / pt_world_h[2] # 除以齐次分量 return pt_world[0, 0], pt_world[1, 0] # 速度换算：取两帧质心，转物理坐标，算距离，除以时间 for tid, track in tracker.tracks.items(): if len(track['positions']) >= 2: p0_img = track['positions'][-2] p1_img = track['positions'][-1] t0 = track['timestamps'][-2] t1 = track['timestamps'][-1] p0_world = pixel_to_world(p0_img[0], p0_img[1], H) p1_world = pixel_to_world(p1_img[0], p1_img[1], H) world_dist_m = np.linalg.norm(np.array(p1_world) - np.array(p0_world)) time_s = t1 - t0 if time_s > 0.02: speed_mps = world_dist_m / time_s speed_kmph = speed_mps * 3.6 # m/s → km/h print(f"Vehicle {tid}: {speed_kmph:.1f} km/h")

逻辑说明：cv2.findHomography是 OpenCV 内置的鲁棒单应性求解器，RANSAC方法能自动剔除标定点误点（如手标偏差），ransacReprojThreshold=3.0表示重投影误差超过 3 像素的点视为外点。标定板不必完美正对镜头，倾斜、透视均可解。
参数说明：world_pts必须按顺时针或逆时针顺序与img_pts严格对应；H矩阵一旦标定完成，可序列化保存（np.save("homography.npy", H)），后续视频直接加载复用；pixel_to_world函数是核心换算入口，所有速度计算必须经过此函数，否则就是“伪测速”。

3. 车辆测速的 4 个必调参数：从 ROI 宽度到像素-米系数，调不对全白忙

参数不是调参，是校准。每个参数背后都对应一个物理约束或工程权衡。以下四个参数，我在线下实测过 17 个不同路口视频，总结出它们的典型范围、调节逻辑和失效现象：

提示：这四个参数不是独立调节的。例如，增大 ROI 高度后，车辆在 ROI 内停留时间变长，此时可适当降低varThreshold让背景模型更“沉稳”；而标定板尺寸误差会直接污染H矩阵，进而让所有基于它的速度计算失真——所以标定永远是第一步，且必须用钢尺实测，不能信图纸标注。

4. 避坑：OpenCV 车辆测速的 5 个翻车现场与硬核解法

这五个坑，是我帮三个不同团队落地时踩出来的，每个都导致项目延期 3~5 天。它们不常出现在教程里，但真实存在，且解决方法必须写死在代码里，不能靠“调参”蒙混过关。

4.1 现象：车辆在 ROI 边缘进出时，质心突跳导致速度爆表（如显示 200km/h）

原因：cv2.moments计算质心时，若轮廓被 ROI 边界截断，M["m00"]（轮廓面积）变小，但M["m10"]、M["m01"]仍按完整轮廓积分，导致质心坐标严重偏移。例如一辆车刚进入 ROI，只有半个车身可见，质心可能算到画面外。

解决：在SimpleTracker.update()中，对每个轮廓做ROI 边界内裁剪，再计算质心：

def safe_contour_centroid(cnt, roi_mask): # 获取轮廓的最小外接矩形 x, y, w, h = cv2.boundingRect(cnt) # 裁剪 ROI 区域，确保只在有效范围内计算 roi_crop = roi_mask[y:y+h, x:x+w] mask_crop = np.zeros_like(roi_crop) # 将轮廓映射到裁剪区域坐标系 cnt_local = cnt - np.array([x, y]) cv2.drawContours(mask_crop, [cnt_local], -1, 255, -1) # 与 ROI 掩膜做与运算，去除边界外部分 masked_cnt = cv2.bitwise_and(mask_crop, roi_crop) # 在 masked_cnt 上重新找轮廓并计算质心 contours_inner, _ = cv2.findContours(masked_cnt, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) if contours_inner: M = cv2.moments(contours_inner[0]) if M["m00"] != 0: cx = int(M["m10"] / M["m00"]) + x cy = int(M["m01"] / M["m00"]) + y return (cx, cy) return None # 无效轮廓，丢弃

关键点：不是简单if area > threshold，而是物理上切除被 ROI 截断的部分，再算质心。这样即使车辆只露出 1/3，质心也落在可见部分中心，不会飞到天边。

4.2 现象：阴天或多云天气下，MOG2 背景模型缓慢漂移，车辆逐渐“融入”背景消失

原因：MOG2 的history参数控制背景学习速度。history=500意味着背景模型以 1/500 的权重吸收新帧，但在持续阴天时，光照是渐进式变暗的，500 帧（20 秒）太长，模型来不及适应，导致前景变淡。

解决：动态调整history，根据帧间灰度均值变化率自适应：

# 在主循环中维护灰度均值滑动窗口 gray_means = deque(maxlen=30) # 30帧均值 current_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) gray_means.append(cv2.mean(current_gray)[0]) # 计算变化率 if len(gray_means) == 30: mean_diff = abs(gray_means[-1] - gray_means[0]) / gray_means[0] if mean_diff > 0.05: # 5% 变化率，判定为显著光照变化 # 临时缩短 history，加速背景更新 bg_subtractor.setHistory(100) # 从500降到100 else: bg_subtractor.setHistory(500)

关键点：OpenCV 的setHistory()可运行时修改，无需重建对象。5% 是经验值，阴天场景下，灰度均值变化超过此值，背景更新滞后就会显现。

4.3 现象：多辆车并行通过 ROI 时，轮廓粘连成一个大 blob，质心落在两车间隙，速度归零

原因：车辆间距小于形态学结构元素尺寸（如kernel=(5,5)），MORPH_CLOSE把两车“焊”在一起，findContours只返回一个轮廓。

解决：用cv2.distanceTransform+cv2.connectedComponents做轮廓分裂：

def split_connected_contours(fg_mask): # 二值化确保输入干净 _, binary = cv2.threshold(fg_mask, 127, 255, cv2.THRESH_BINARY) # 距离变换：每个前景点到最近背景点的距离 dist = cv2.distanceTransform(binary, cv2.DIST_L2, 5) # 归一化并二值化，得到“种子点”区域 _, sure_fg = cv2.threshold(dist, 0.7 * dist.max(), 255, 0) # 背景估计（膨胀前景得到） sure_bg = cv2.dilate(binary, kernel, iterations=3) # 未知区域 = 背景 - 前景 unknown = cv2.subtract(sure_bg, sure_fg) # 连通组件标记 _, markers = cv2.connectedComponents(np.uint8(sure_fg)) markers = markers + 1 markers[unknown == 255] = 0 # 分水岭分割 markers = cv2.watershed(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), markers) # 提取分割后的轮廓 segmented = np.zeros_like(fg_mask) segmented[markers == -1] = 255 contours, _ = cv2.findContours(segmented, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) return contours

关键点：cv2.watershed是 OpenCV 内置的分水岭算法，专治粘连目标。它不增加新模型，只用图像梯度信息做几何分割，对并行车效果极好，且计算量可控（比 YOLO 分割轻 10 倍）。

4.4 现象：夜间车灯过曝，MOG2 将光斑误判为运动目标，跟踪 ID 持续跳变

原因：车灯在灰度图中是极高亮区域，MOG2 默认将其建模为“前景”，但灯光无实体，无法形成稳定轮廓，导致 ID 频繁新建又丢失。

解决：在背景减除后，加入亮度抑制掩膜，屏蔽过曝区域：

def suppress_overexposure(gray, fg_mask, threshold=220): # 找出过曝区域（灰度 > 220） _, overexposed = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY) # 膨胀过曝区域，覆盖光晕 kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)) overexposed = cv2.dilate(overexposed, kernel, iterations=2) # 从前景掩膜中挖掉过曝区域 fg_mask_clean = cv2.bitwise_and(fg_mask, cv2.bitwise_not(overexposed)) return fg_mask_clean # 主循环中调用 fg_mask = bg_subtractor.apply(gray) fg_mask = suppress_overexposure(gray, fg_mask, threshold=220)

关键点：threshold=220是经验值，255 为纯白。车灯中心通常 >240，但光晕在 220~240 之间，此阈值能精准切掉光斑又保留车体。dilate是为了覆盖光晕扩散区。

4.5 现象：视频有轻微抖动（如杆架松动），导致 ROI 内所有质心集体漂移，速度全偏高

原因：摄像头物理抖动会让整个 ROI 区域像素平移，MOG2 误以为是“大面积运动”，背景模型被污染。

解决：在 ROI 内做帧间运动补偿（ECC），对齐背景：

def align_frames(prev_gray, curr_gray, roi_mask): # 提取 ROI 区域 prev_roi = cv2.bitwise_and(prev_gray, prev_gray, mask=roi_mask) curr_roi = cv2.bitwise_and(curr_gray, curr_gray, mask=roi_mask) # 计算仿射变换矩阵（ECC 算法） warp_mode = cv2.MOTION_EUCLIDEAN warp_matrix = np.eye(2, 3, dtype=np.float32) criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 100, 1e-5) try: (cc, warp_matrix) = cv2.findTransformECC(prev_roi, curr_roi, warp_matrix, warp_mode, criteria) except: pass # 对当前帧 ROI 做反向变换，补偿抖动 height, width = curr_gray.shape curr_aligned = cv2.warpAffine(curr_gray, warp_matrix, (width, height), flags=cv2.INTER_LINEAR + cv2.WARP_INVERSE_MAP) return curr_aligned # 主循环中，在 bg_subtractor.apply() 前调用 if prev_gray is not None: curr_gray = align_frames(prev_gray, curr_gray, roi_mask) prev_gray = curr_gray.copy()

关键点：cv2.findTransformECC是 OpenCV 内置的增强相关系数配准算法，专为小位移、小旋转设计，比光流法更稳。它只在 ROI 内计算，不增加全局计算负担，且WARP_INVERSE_MAP确保补偿方向正确。

5. 验证你的测速结果是否可信：三步交叉校验法与一个后悔药技巧

测速系统上线前，必须回答一个问题：当它说一辆车是 62km/h，你敢信吗？不能只靠“看起来合理”，要建立可重复、可追溯的验证链。我在线下验证中，强制执行以下三步，缺一不可。

5.1 第一步：用已知速度的标定车做物理验证（黄金标准）

找一辆车，装上高精度 GPS（如 u-blox M8T，定位误差 <1m），在 ROI 段匀速行驶（用定速巡航），记录 GPS 输出的真实速度。同步录制视频，用你的 OpenCV 系统跑一遍，对比两者：

操作要点：标定车必须走直线、匀速，GPS 数据导出为 CSV，用pandas对齐时间戳；OpenCV 输出也存为 CSV，列名为frame_id, timestamp, vehicle_id, speed_kmph；用时间戳插值对齐，而非帧号对齐（因视频可能丢帧）。

5.2 第二步：用双 ROI 法做内部一致性验证（自查工具）

在同一路段，平行设置两个 ROI（A 和 B），间距已知（如 10 米）。车辆依次通过 A、B，系统分别记录其在 A、B 的瞬时速度。理论上，若车辆匀速，speed_A ≈ speed_B；若加速，speed_B > speed_A。这是纯视频内部验证，无需外部设备：

# ROI_A 和 ROI_B 的掩膜、Homography 矩阵均已标定 # tracker_A 和 tracker_B 独立运行 # 当 tracker_A 检测到某车 ID，记录其通过 A 的时间 tA 和速度 vA # 当 tracker_B 同一 ID 出现在 B，记录 tB 和 vB # 计算理论通过时间：t_theory = distance_AB_m / vA # 实际通过时间：t_actual = tB - tA # 若 |t_actual - t_theory| < 0.3s，则认为一致

为什么是 0.3 秒？在 60km/h（16.7m/s）下，10 米间距理论耗时 0.6 秒，0.3 秒容差覆盖了计时抖动和车辆加速度变化。此方法能快速筛出 Homography 标定错误（如vA=60,vB=40，但tB-tA=0.5s，明显矛盾）。

5.3 第三步：用帧间位移热力图做可视化诊断（调试神器）

把所有车辆在 ROI 内的位移矢量（起点→终点）叠加到一张图上，生成热力图。正常情况应呈现清晰的水平条带（车辆沿道路方向移动）；若

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