当前位置：首页 > news >正文

计算机视觉目标跟踪：模型与实践

news 2026/4/30 15:19:40

计算机视觉目标跟踪：模型与实践

1. 目标跟踪的挑战

1.1 外观变化

目标在跟踪过程中可能发生多种外观变化：

尺度变化：目标距离摄像头远近不同导致大小变化
姿态变化：目标姿态、视角的改变
光照变化：环境光照条件的变化
遮挡：目标被其他物体部分或完全遮挡

1.2 运动变化

快速运动：目标快速移动导致模糊
非刚性运动：目标自身的变形（如人体、动物）
复杂背景：背景与目标颜色、纹理相似

1.3 计算效率

实时性要求：许多应用需要实时跟踪
资源限制：在边缘设备上运行时的计算资源限制
多目标跟踪：同时跟踪多个目标的复杂性

2. 传统目标跟踪算法

2.1 基于相关滤波的方法

MOSSE (Minimum Output Sum of Squared Error)

import cv2 import numpy as np class MOSSETracker: def __init__(self, frame, bbox): # 初始化MOSSE跟踪器 self.tracker = cv2.TrackerMOSSE_create() self.tracker.init(frame, bbox) def update(self, frame): # 更新跟踪结果 success, bbox = self.tracker.update(frame) return success, bbox # 使用示例 cap = cv2.VideoCapture('video.mp4') ret, frame = cap.read() # 初始 bounding box (x, y, width, height) bbox = (50, 50, 100, 100) tracker = MOSSETracker(frame, bbox) while cap.isOpened(): ret, frame = cap.read() if not ret: break success, bbox = tracker.update(frame) if success: x, y, w, h = [int(v) for v in bbox] cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2) cv2.imshow('Tracking', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()

CSRT (Channel and Spatial Reliability Tracking)

import cv2 class CSRTTracker: def __init__(self, frame, bbox): # 初始化CSRT跟踪器 self.tracker = cv2.TrackerCSRT_create() self.tracker.init(frame, bbox) def update(self, frame): # 更新跟踪结果 success, bbox = self.tracker.update(frame) return success, bbox # 使用示例类似MOSSE

2.2 基于粒子滤波的方法

MeanShift

import cv2 import numpy as np def meanshift_tracking(video_path): cap = cv2.VideoCapture(video_path) ret, frame = cap.read() # 选择初始ROI r, h, c, w = 250, 90, 400, 125 # 简单的矩形 track_window = (c, r, w, h) # 提取ROI并计算直方图 roi = frame[r:r+h, c:c+w] hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv_roi, np.array((0., 60., 32.)), np.array((180., 255., 255.))) roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180]) cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX) # 设置终止条件 term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) while True: ret, frame = cap.read() if not ret: break hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1) # 应用meanshift ret, track_window = cv2.meanShift(dst, track_window, term_crit) # 绘制跟踪结果 x, y, w, h = track_window img2 = cv2.rectangle(frame, (x, y), (x+w, y+h), 255, 2) cv2.imshow('img2', img2) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()

CamShift

import cv2 import numpy as np def camshift_tracking(video_path): cap = cv2.VideoCapture(video_path) ret, frame = cap.read() # 选择初始ROI r, h, c, w = 250, 90, 400, 125 track_window = (c, r, w, h) # 提取ROI并计算直方图 roi = frame[r:r+h, c:c+w] hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv_roi, np.array((0., 60., 32.)), np.array((180., 255., 255.))) roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180]) cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX) # 设置终止条件 term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) while True: ret, frame = cap.read() if not ret: break hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1) # 应用camshift ret, track_window = cv2.CamShift(dst, track_window, term_crit) # 绘制跟踪结果 pts = cv2.boxPoints(ret) pts = np.int0(pts) img2 = cv2.polylines(frame, [pts], True, 255, 2) cv2.imshow('img2', img2) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()

3. 深度学习目标跟踪

3.1 基于Siamese网络的方法

SiamRPN

import torch from torchvision.models import resnet50 import torch.nn as nn class SiamRPN(nn.Module): def __init__(self): super(SiamRPN, self).__init__() # 特征提取网络 self.backbone = nn.Sequential(*list(resnet50(pretrained=True).children())[:-3]) # 分类分支 self.cls_head = nn.Conv2d(1024, 2*9, kernel_size=1) # 回归分支 self.reg_head = nn.Conv2d(1024, 4*9, kernel_size=1) def forward(self, z, x): # 提取模板和搜索区域特征 z_feat = self.backbone(z) x_feat = self.backbone(x) # 计算相关特征 # 这里简化实现，实际使用互相关操作 corr_feat = self.calculate_correlation(z_feat, x_feat) # 分类和回归 cls = self.cls_head(corr_feat) reg = self.reg_head(corr_feat) return cls, reg def calculate_correlation(self, z_feat, x_feat): # 简化的相关计算 batch_size, channels, height, width = x_feat.shape z_height, z_width = z_feat.shape[2], z_feat.shape[3] # 展开特征 z_feat = z_feat.view(batch_size, channels, -1) x_feat = x_feat.view(batch_size, channels, -1) # 计算相关 corr = torch.matmul(z_feat.transpose(1, 2), x_feat) corr = corr.view(batch_size, z_height*z_width, height, width) return corr # 使用示例 model = SiamRPN() # 模板和搜索区域 z = torch.randn(1, 3, 127, 127) x = torch.randn(1, 3, 255, 255) cls, reg = model(z, x) print(f"Classification output shape: {cls.shape}") print(f"Regression output shape: {reg.shape}")

SiamMask

import torch import torch.nn as nn class SiamMask(nn.Module): def __init__(self): super(SiamMask, self).__init__() # 特征提取网络 self.backbone = nn.Sequential(*list(resnet50(pretrained=True).children())[:-3]) # 分类分支 self.cls_head = nn.Conv2d(1024, 2*9, kernel_size=1) # 回归分支 self.reg_head = nn.Conv2d(1024, 4*9, kernel_size=1) # 掩码分支 self.mask_head = nn.Sequential( nn.Conv2d(1024, 256, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(256, 16*9, kernel_size=1) ) def forward(self, z, x): # 提取模板和搜索区域特征 z_feat = self.backbone(z) x_feat = self.backbone(x) # 计算相关特征 corr_feat = self.calculate_correlation(z_feat, x_feat) # 分类、回归和掩码 cls = self.cls_head(corr_feat) reg = self.reg_head(corr_feat) mask = self.mask_head(corr_feat) return cls, reg, mask def calculate_correlation(self, z_feat, x_feat): # 简化的相关计算 batch_size, channels, height, width = x_feat.shape z_height, z_width = z_feat.shape[2], z_feat.shape[3] z_feat = z_feat.view(batch_size, channels, -1) x_feat = x_feat.view(batch_size, channels, -1) corr = torch.matmul(z_feat.transpose(1, 2), x_feat) corr = corr.view(batch_size, z_height*z_width, height, width) return corr

3.2 基于Transformer的方法

TransT (Transformer Tracking)

import torch import torch.nn as nn import torch.nn.functional as F class TransT(nn.Module): def __init__(self, hidden_dim=256, num_heads=8, num_layers=6): super(TransT, self).__init__() # 特征提取网络 self.backbone = nn.Sequential(*list(resnet50(pretrained=True).children())[:-3]) # 特征投影 self.proj = nn.Conv2d(1024, hidden_dim, kernel_size=1) # Transformer encoder_layer = nn.TransformerEncoderLayer(d_model=hidden_dim, nhead=num_heads) self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers) # 预测头 self.cls_head = nn.Linear(hidden_dim, 1) self.reg_head = nn.Linear(hidden_dim, 4) def forward(self, z, x): # 提取特征 z_feat = self.backbone(z) x_feat = self.backbone(x) # 投影到隐藏维度 z_feat = self.proj(z_feat) x_feat = self.proj(x_feat) # 展平特征 z_feat = z_feat.flatten(2).permute(2, 0, 1) # [seq_len, batch, dim] x_feat = x_feat.flatten(2).permute(2, 0, 1) # 组合特征 features = torch.cat([z_feat, x_feat], dim=0) # Transformer编码 features = self.transformer(features) # 预测 cls = self.cls_head(features[-1]) # 使用最后一个token reg = self.reg_head(features[-1]) return cls, reg

3.3 多目标跟踪

ByteTrack

import numpy as np from collections import deque class ByteTracker: def __init__(self, max_age=30, n_init=3, track_thresh=0.6, track_buffer=30): self.max_age = max_age self.n_init = n_init self.track_thresh = track_thresh self.track_buffer = track_buffer self.tracks = [] self.next_id = 1 self.frame_id = 0 def update(self, detections): self.frame_id += 1 # 过滤低置信度检测 detections = [d for d in detections if d[4] > self.track_thresh] # 预测现有轨迹 for track in self.tracks: track.predict() # 匹配检测与轨迹 matches, unmatched_detections, unmatched_tracks = self._match(detections) # 更新匹配的轨迹 for track_idx, det_idx in matches: self.tracks[track_idx].update(detections[det_idx]) # 处理未匹配的检测 for det_idx in unmatched_detections: self._initiate_track(detections[det_idx]) # 处理未匹配的轨迹 self.tracks = [t for t in self.tracks if not t.marked_for_deletion()] # 返回当前轨迹 return [(t.id, t.bbox) for t in self.tracks if t.is_confirmed()] def _match(self, detections): # 简化的匹配逻辑，实际使用IoU或其他距离度量 matches = [] unmatched_detections = list(range(len(detections))) unmatched_tracks = list(range(len(self.tracks))) # 这里应该实现实际的匹配算法 # 例如使用Hungarian算法 return matches, unmatched_detections, unmatched_tracks def _initiate_track(self, detection): # 初始化新轨迹 track = Track(detection, self.next_id, self.n_init, self.max_age) self.tracks.append(track) self.next_id += 1 class Track: def __init__(self, detection, track_id, n_init, max_age): self.id = track_id self.bbox = detection[:4] self.confidence = detection[4] self.n_init = n_init self.max_age = max_age self.hits = 1 self.age = 1 self.time_since_update = 0 def predict(self): # 简单的运动预测 self.age += 1 self.time_since_update += 1 def update(self, detection): self.bbox = detection[:4] self.confidence = detection[4] self.hits += 1 self.time_since_update = 0 def is_confirmed(self): return self.hits >= self.n_init def marked_for_deletion(self): return self.time_since_update > self.max_age # 使用示例 tracker = ByteTracker() detections = [ [100, 100, 200, 200, 0.9], # [x, y, w, h, confidence] [300, 300, 400, 400, 0.8] ] tracks = tracker.update(detections) print(tracks)

4. 目标跟踪评估

4.1 评估指标

MOTA (Multiple Object Tracking Accuracy)

公式：MOTA = 1 - (FP + FN + IDSw) / GT
含义：综合考虑假阳性、漏检和ID切换
范围：[-∞, 1]，越高越好

MOTP (Multiple Object Tracking Precision)

公式：MOTP = Σ(d_i) / C
含义：跟踪框与真实框的平均IoU
范围：[0, 1]，越高越好

IDF1 (ID F1 Score)

公式：2 * (IDTP) / (2 * IDTP + IDFP + IDFN)
含义：ID匹配的F1分数
范围：[0, 1]，越高越好

4.2 常用数据集

数据集	场景	目标类型	特点
MOT17	行人	行人	拥挤场景，遮挡严重
MOT20	行人	行人	更多的行人，更具挑战性
KITTI	车辆	车辆、行人和骑行者	交通场景
LaSOT	通用物体	多种物体	长序列，复杂场景
GOT-10k	通用物体	多种物体	大规模基准

4.3 评估工具

import numpy as np def calculate_iou(bbox1, bbox2): """计算两个边界框的IoU""" x1 = max(bbox1[0], bbox2[0]) y1 = max(bbox1[1], bbox2[1]) x2 = min(bbox1[0]+bbox1[2], bbox2[0]+bbox2[2]) y2 = min(bbox1[1]+bbox1[3], bbox2[1]+bbox2[3]) intersection = max(0, x2 - x1) * max(0, y2 - y1) area1 = bbox1[2] * bbox1[3] area2 = bbox2[2] * bbox2[3] union = area1 + area2 - intersection return intersection / union if union > 0 else 0 def evaluate_tracking(tracks, ground_truths): """评估跟踪结果""" # 简化的评估逻辑 tp = 0 fp = 0 fn = 0 id_switches = 0 total_iou = 0 # 这里应该实现完整的评估逻辑 # 包括跟踪与 ground truth 的匹配 # 计算MOTA gt_count = sum(len(gt) for gt in ground_truths) if gt_count > 0: mota = 1 - (fp + fn + id_switches) / gt_count else: mota = 0 # 计算MOTP if tp > 0: motp = total_iou / tp else: motp = 0 return { 'MOTA': mota, 'MOTP': motp, 'TP': tp, 'FP': fp, 'FN': fn, 'ID_switches': id_switches } # 使用示例 tracks = [ # 格式: (frame_id, track_id, x, y, w, h) [1, 1, 100, 100, 50, 50], [2, 1, 105, 105, 50, 50], [3, 1, 110, 110, 50, 50] ] ground_truths = [ # 格式: (frame_id, obj_id, x, y, w, h) [1, 1, 100, 100, 50, 50], [2, 1, 105, 105, 50, 50], [3, 1, 110, 110, 50, 50] ] results = evaluate_tracking(tracks, ground_truths) print(results)

5. 目标跟踪应用

5.1 视频监控

应用场景：

安防监控：跟踪可疑人员
交通监控：跟踪车辆、行人
crowd monitoring：人群密度分析

技术挑战：

遮挡处理
光照变化
多目标跟踪

解决方案：

import cv2 # 视频监控中的目标跟踪 def video_surveillance(video_path): # 加载YOLOv5模型进行目标检测 model = cv2.dnn.readNetFromONNX('yolov5s.onnx') # 初始化跟踪器 tracker = cv2.TrackerCSRT_create() cap = cv2.VideoCapture(video_path) ret, frame = cap.read() # 第一帧检测目标 blob = cv2.dnn.blobFromImage(frame, 1/255, (640, 640), swapRB=True, crop=False) model.setInput(blob) outputs = model.forward() # 假设检测到第一个目标 # 这里简化处理，实际需要解析YOLO输出 bbox = (100, 100, 50, 50) tracker.init(frame, bbox) while cap.isOpened(): ret, frame = cap.read() if not ret: break # 更新跟踪 success, bbox = tracker.update(frame) if success: x, y, w, h = [int(v) for v in bbox] cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2) else: # 跟踪失败，重新检测 blob = cv2.dnn.blobFromImage(frame, 1/255, (640, 640), swapRB=True, crop=False) model.setInput(blob) outputs = model.forward() # 重新初始化跟踪器 # ... cv2.imshow('Surveillance', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()

5.2 自动驾驶

应用场景：

车辆跟踪
行人跟踪
障碍物跟踪

技术挑战：

实时性要求高
复杂交通场景
多传感器融合

解决方案：

import numpy as np import torch class AutoDriveTracker: def __init__(self, model_path): # 加载预训练的跟踪模型 self.model = torch.load(model_path) self.model.eval() def track_objects(self, frame, previous_detections): # 预处理帧 frame = self.preprocess(frame) # 跟踪 with torch.no_grad(): tracks = self.model(frame, previous_detections) return tracks def preprocess(self, frame): # 帧预处理 frame = cv2.resize(frame, (640, 480)) frame = frame / 255.0 frame = torch.tensor(frame).permute(2, 0, 1).unsqueeze(0) return frame # 使用示例 tracker = AutoDriveTracker('tracking_model.pth') frame = cv2.imread('frame.jpg') previous_detections = [] tracks = tracker.track_objects(frame, previous_detections)

5.3 体育分析

应用场景：

运动员跟踪
球跟踪
比赛分析

技术挑战：

快速运动
遮挡
多目标跟踪

解决方案：

import cv2 from collections import defaultdict def sports_analysis(video_path): # 初始化多目标跟踪器 trackers = {} next_id = 1 cap = cv2.VideoCapture(video_path) while cap.isOpened(): ret, frame = cap.read() if not ret: break # 检测运动员 # 这里简化处理，实际使用目标检测模型 detections = detect_players(frame) # 跟踪管理 updated_trackers = {} for detection in detections: x, y, w, h, confidence = detection # 匹配现有跟踪器 matched = False for track_id, tracker in trackers.items(): success, bbox = tracker.update(frame) if success: iou = calculate_iou([x, y, w, h], bbox) if iou > 0.5: updated_trackers[track_id] = tracker matched = True break # 新目标 if not matched: tracker = cv2.TrackerCSRT_create() tracker.init(frame, (x, y, w, h)) updated_trackers[next_id] = tracker next_id += 1 # 更新跟踪器 trackers = updated_trackers # 绘制跟踪结果 for track_id, tracker in trackers.items(): success, bbox = tracker.update(frame) if success: x, y, w, h = [int(v) for v in bbox] cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2) cv2.putText(frame, f'ID: {track_id}', (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) cv2.imshow('Sports Analysis', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()

6. 最佳实践

6.1 模型选择

场景	推荐模型	优势
实时监控	CSRT、ByteTrack	平衡速度和 accuracy
高精度要求	SiamRPN++、TransT	更高的 tracking accuracy
资源受限设备	MOSSE、LightTrack	轻量级，速度快
多目标场景	ByteTrack、JDE	专为多目标设计

6.2 性能优化

模型量化

import torch # 量化模型 def quantize_model(model): # 动态量化 quantized_model = torch.quantization.quantize_dynamic( model, {torch.nn.Linear, torch.nn.Conv2d}, dtype=torch.qint8 ) return quantized_model # 加载模型 model = torch.load('tracking_model.pth') quantized_model = quantize_model(model) # 保存量化模型 torch.save(quantized_model, 'quantized_tracking_model.pth')

推理优化

import torch # 使用TorchScript def optimize_inference(model): # 转换为TorchScript scripted_model = torch.jit.script(model) return scripted_model # 使用ONNX def export_onnx(model, input_shape): dummy_input = torch.randn(input_shape) torch.onnx.export( model, dummy_input, 'tracking_model.onnx', input_names=['input'], output_names=['output'] )

6.3 部署策略

边缘设备部署

# 使用TensorRT加速 import tensorrt as trt import pycuda.driver as cuda import pycuda.autoinit def build_tensorrt_engine(onnx_model_path): logger = trt.Logger(trt.Logger.WARNING) builder = trt.Builder(logger) network = builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)) parser = trt.OnnxParser(network, logger) with open(onnx_model_path, 'rb') as f: parser.parse(f.read()) config = builder.create_builder_config() config.max_workspace_size = 1 << 30 # 1GB engine = builder.build_engine(network, config) with open('tracking_engine.engine', 'wb') as f: f.write(engine.serialize()) return engine

云服务部署

# 使用FastAPI部署 from fastapi import FastAPI, UploadFile, File import cv2 import numpy as np app = FastAPI() # 加载模型 model = load_tracking_model() @app.post("/track") async def track(file: UploadFile = File(...)): # 读取图像 contents = await file.read() nparr = np.frombuffer(contents, np.uint8) frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR) # 跟踪 tracks = model.track(frame) # 返回结果 return {"tracks": tracks} if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000)

7. 案例研究

7.1 行人跟踪系统

案例：在拥挤场景中跟踪行人

挑战：

行人密度高，频繁遮挡
光照条件变化
实时性要求

解决方案：

使用ByteTrack：专为拥挤场景设计的多目标跟踪算法
结合YOLOv5：高精度目标检测
运动预测：使用卡尔曼滤波器预测目标位置

实现：

import cv2 import numpy as np from bytetrack import ByteTracker class PedestrianTracker: def __init__(self): # 加载YOLOv5模型 self.detector = cv2.dnn.readNetFromONNX('yolov5s.onnx') # 初始化ByteTracker self.tracker = ByteTracker() def track(self, frame): # 检测行人 detections = self.detect_pedestrians(frame) # 跟踪 tracks = self.tracker.update(detections) return tracks def detect_pedestrians(self, frame): # 预处理 blob = cv2.dnn.blobFromImage(frame, 1/255, (640, 640), swapRB=True, crop=False) self.detector.setInput(blob) outputs = self.detector.forward() # 解析输出 detections = [] # 这里需要根据YOLOv5的输出格式解析 # 只保留行人（class 0） return detections # 使用示例 tracker = PedestrianTracker() cap = cv2.VideoCapture('crowd_video.mp4') while cap.isOpened(): ret, frame = cap.read() if not ret: break tracks = tracker.track(frame) # 绘制跟踪结果 for track_id, bbox in tracks: x, y, w, h = bbox cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2) cv2.putText(frame, f'ID: {track_id}', (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) cv2.imshow('Pedestrian Tracking', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()

7.2 车辆跟踪系统

案例：交通场景中的车辆跟踪

挑战：

车辆速度快
遮挡频繁
多摄像头协同

解决方案：

使用SiamRPN++：高精度单目标跟踪
多目标跟踪：使用JDE或ByteTrack
跨摄像头跟踪：使用Re-ID技术

实现：

import cv2 from siamrpn import SiamRPN class VehicleTracker: def __init__(self): # 加载SiamRPN模型 self.model = SiamRPN() self.model.load_weights('siamrpn_weights.pth') def track_vehicle(self, initial_frame, bbox, video_frames): # 初始化跟踪 tracker = self.model.init(initial_frame, bbox) tracks = [] for frame in video_frames: # 更新跟踪 bbox = tracker.update(frame) tracks.append(bbox) return tracks # 使用示例 tracker = VehicleTracker() initial_frame = cv2.imread('initial_frame.jpg') bbox = (100, 100, 50, 30) # 车辆初始位置 # 读取视频帧 video_frames = [] cap = cv2.VideoCapture('traffic_video.mp4') while cap.isOpened(): ret, frame = cap.read() if not ret: break video_frames.append(frame) cap.release() # 跟踪车辆 tracks = tracker.track_vehicle(initial_frame, bbox, video_frames) # 可视化跟踪结果 cap = cv2.VideoCapture('traffic_video.mp4') frame_idx = 0 while cap.isOpened(): ret, frame = cap.read() if not ret: break if frame_idx < len(tracks): x, y, w, h = tracks[frame_idx] cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2) cv2.imshow('Vehicle Tracking', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break frame_idx += 1 cap.release() cv2.destroyAllWindows()