Python案例如何实现对象追踪？

wen python案例 2026-06-17 210

本文目录导读：

Python案例如何实现对象追踪？

基于OpenCV的颜色追踪
使用OpenCV内置追踪器
基于光流的追踪
基于深度学习的追踪（使用YOLO + Deep SORT）
选择建议

我来介绍几种Python实现对象追踪的常用方法：

基于OpenCV的颜色追踪

import cv2
import numpy as np
class ColorTracker:
    def __init__(self):
        # 定义要追踪的颜色范围 (例如红色)
        self.lower_red = np.array([0, 100, 100])
        self.upper_red = np.array([10, 255, 255])
    def track_color(self, frame):
        # 转换到HSV颜色空间
        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
        # 创建颜色掩码
        mask = cv2.inRange(hsv, self.lower_red, self.upper_red)
        # 形态学操作去除噪声
        mask = cv2.erode(mask, None, iterations=2)
        mask = cv2.dilate(mask, None, iterations=2)
        # 找到轮廓
        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, 
                                       cv2.CHAIN_APPROX_SIMPLE)
        # 找到最大轮廓
        if contours:
            largest_contour = max(contours, key=cv2.contourArea)
            if cv2.contourArea(largest_contour) > 500:  # 最小面积阈值
                # 获取外接矩形
                x, y, w, h = cv2.boundingRect(largest_contour)
                center = (x + w//2, y + h//2)
                # 绘制追踪框
                cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
                cv2.circle(frame, center, 5, (0, 0, 255), -1)
                return center
        return None
# 使用示例
cap = cv2.VideoCapture(0)
tracker = ColorTracker()
while True:
    ret, frame = cap.read()
    if not ret:
        break
    center = tracker.track_color(frame)
    cv2.imshow('Color Tracking', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

使用OpenCV内置追踪器

import cv2
class OpenCVTracker:
    def __init__(self, tracker_type='CSRT'):
        """
        可选追踪器类型：
        - 'BOOSTING', 'MIL', 'KCF', 'TLD', 'MEDIANFLOW'
        - 'GOTURN', 'MOSSE', 'CSRT' (推荐CSRT或KCF)
        """
        tracker_types = {
            'CSRT': cv2.TrackerCSRT_create,
            'KCF': cv2.TrackerKCF_create,
            'MOSSE': cv2.legacy.TrackerMOSSE_create,
            'MEDIANFLOW': cv2.legacy.TrackerMedianFlow_create
        }
        self.tracker = tracker_types[tracker_type]()
        self.initialized = False
    def init_tracker(self, frame, bbox):
        """初始化追踪器"""
        self.tracker.init(frame, bbox)
        self.initialized = True
    def update(self, frame):
        """更新追踪位置"""
        if not self.initialized:
            return None, False
        success, bbox = self.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)
            return (x+w//2, y+h//2), True
        return None, False
# 使用示例
cap = cv2.VideoCapture(0)
tracker = OpenCVTracker('CSRT')
# 首先框选要追踪的对象
ret, frame = cap.read()
bbox = cv2.selectROI('Select Object', frame, False)
cv2.destroyWindow('Select Object')
tracker.init_tracker(frame, bbox)
while True:
    ret, frame = cap.read()
    if not ret:
        break
    center, success = tracker.update(frame)
    if success:
        cv2.putText(frame, f"Tracking: ({center[0]}, {center[1]})", 
                   (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
    cv2.imshow('Object Tracking', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

基于光流的追踪

import cv2
import numpy as np
class OpticalFlowTracker:
    def __init__(self):
        # Lucas-Kanade光流参数
        self.lk_params = dict(
            winSize=(15, 15),
            maxLevel=2,
            criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03)
        )
        self.track_points = None
        self.old_gray = None
    def init_tracker(self, frame, points):
        """初始化追踪点"""
        self.old_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        self.track_points = np.array([points], dtype=np.float32).reshape(-1, 1, 2)
    def update(self, frame):
        """更新追踪点位置"""
        if self.track_points is None:
            return None
        frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        # 计算光流
        new_points, status, _ = cv2.calcOpticalFlowPyrLK(
            self.old_gray, frame_gray, 
            self.track_points, None, **self.lk_params
        )
        # 选择成功的追踪点
        good_new = new_points[status == 1]
        good_old = self.track_points[status == 1]
        # 更新点位置
        self.track_points = good_new.reshape(-1, 1, 2)
        self.old_gray = frame_gray.copy()
        # 绘制追踪点
        for new, old in zip(good_new, good_old):
            a, b = new.ravel()
            c, d = old.ravel()
            frame = cv2.line(frame, (int(a), int(b)), (int(c), int(d)), 
                           (0, 255, 0), 2)
            frame = cv2.circle(frame, (int(a), int(b)), 5, (0, 0, 255), -1)
        return good_new if len(good_new) > 0 else None
# 使用示例
cap = cv2.VideoCapture(0)
tracker = OpticalFlowTracker()
ret, frame = cap.read()
# 初始化时选择要追踪的点
points = cv2.goodFeaturesToTrack(
    cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY),
    maxCorners=5,
    qualityLevel=0.3,
    minDistance=7
)
tracker.init_tracker(frame, points)
while True:
    ret, frame = cap.read()
    if not ret:
        break
    result = tracker.update(frame)
    cv2.imshow('Optical Flow Tracking', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()

基于深度学习的追踪（使用YOLO + Deep SORT）

# 需要安装：pip install ultralytics deep-sort-realtime
import cv2
from ultralytics import YOLO
from deep_sort_realtime.deepsort_tracker import DeepSort
class DeepLearningTracker:
    def __init__(self, model_path='yolov8n.pt'):
        # 初始化YOLO检测器
        self.detector = YOLO(model_path)
        # 初始化DeepSORT追踪器
        self.tracker = DeepSort(max_age=30)
    def process_frame(self, frame):
        # 使用YOLO进行检测
        results = self.detector(frame)[0]
        detections = []
        for result in results.boxes.data.tolist():
            x1, y1, x2, y2, confidence, class_id = result
            if confidence > 0.5:  # 置信度阈值
                detections.append(([x1, y1, x2-x1, y2-y1], confidence, class_id))
        # 更新追踪器
        tracks = self.tracker.update_tracks(detections, frame=frame)
        # 绘制追踪结果
        for track in tracks:
            if not track.is_confirmed():
                continue
            track_id = track.track_id
            ltrb = track.to_ltrb()
            x1, y1, x2, y2 = [int(v) for v in ltrb]
            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
            cv2.putText(frame, f"ID: {track_id}", (x1, y1-10),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
        return frame
# 使用示例
cap = cv2.VideoCapture(0)
tracker = DeepLearningTracker()
while True:
    ret, frame = cap.read()
    if not ret:
        break
    frame = tracker.process_frame(frame)
    cv2.imshow('Deep Learning Tracking', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()