利用OpenCV进行对象跟踪的示例代码

opencv 对象跟踪

这篇文章使用 opencv 中内置的八种不同的对象跟踪算法，实现对物体的跟踪。

首先，介绍一下8种跟踪算法。

然后，演示如何使用opencv实现这些跟踪算法。

最后，对本文做总结。

opencv 对象跟踪器

opencv 八种对象跟踪器：

boosting tracker：基于用于驱动 haar 级联 (adaboost) 背后的机器学习的相同算法，但与 haar 级联一样，已有十多年的历史。这个跟踪器很慢，而且效果不太好。仅出于遗留原因和比较其他算法而感兴趣。 （最低 opencv 3.0.0）

mil tracker：比 boosting 跟踪器更准确，但在报告失败方面做得很差。 （最低 opencv 3.0.0）

kcf 跟踪器：内核化相关过滤器。比 boosting 和 mil 更快。与 mil 和 kcf 类似，不能很好地处理完全遮挡。 （最低 opencv 3.1.0）

csrt tracker：判别相关滤波器（具有通道和空间可靠性）。往往比 kcf 更准确，但速度稍慢。 （最低 opencv 3.4.2）

medianflow tracker：很好地报告失败；但是，如果运动中的跳跃太大，例如快速移动的物体，或者外观快速变化的物体，模型就会失败。 （最低 opencv 3.0.0）

tld 跟踪器：我不确定 tld 跟踪器的 opencv 实现或实际算法本身是否存在问题，但 tld 跟踪器极易出现误报。我不推荐使用这个 opencv 对象跟踪器。 （最低 opencv 3.0.0）

mosse tracker：非常非常快。不如 csrt 或 kcf 准确，但如果您需要纯粹的速度，这是一个不错的选择。 （最低 opencv 3.4.1）

goturn tracker：opencv 中唯一基于深度学习的目标检测器。它需要额外的模型文件才能运行（本文不会涉及）。我最初的实验表明，尽管据说它可以很好地处理查看变化，但使用起来还是有点痛苦（尽管我最初的实验并没有证实这一点）。我将尝试在以后的帖子中介绍它，但与此同时，请看一下 satya 的文章。 （最低 opencv 3.2.0）

个人建议：

• 当需要更高的对象跟踪精度并且可以容忍较慢的 fps 吞吐量时，请使用 csrt
• 当需要更快的 fps 吞吐量但可以处理稍低的对象跟踪精度时使用 kcf
• 当需要纯粹的速度时使用 mosse

物体跟踪

在开始算法之前，先写辅助方法和类。

fps类：

import datetime

class fps:
    def __init__(self):
        # 定义开始时间、结束时间和总帧数
        self._start = none
        self._end = none
        self._numframes = 0

    def start(self):
        # 开始计时
        self._start = datetime.datetime.now()
        return self

    def stop(self):
        # 停止计时
        self._end = datetime.datetime.now()

    def update(self):
        # 增加在开始和结束间隔期间检查的总帧数
        self._numframes += 1

    def elapsed(self):
        # 返回开始和结束间隔之间的总秒数
        return (self._end - self._start).total_seconds()

    def fps(self):
        # 计算每秒帧数
        return self._numframes / self.elapsed()

请打开一个新文件，将其命名为 object_tracker.py ，定义resize方法，等比例缩放图片。

import cv2
from fps import fps
def resize(image, width=none, height=none, inter=cv2.inter_area):
    # 初始化要调整大小的图像的尺寸并抓取图像大小
    dim = none
    (h, w) = image.shape[:2]
    # 如果宽高都为none，则返回原图
    if width is none and height is none:
        return image
    # 检查宽度是否为none
    if width is none:
        # 计算高度的比例并构造尺寸
        r = height / float(h)
        dim = (int(w * r), height)
    # 否则，高度为 none
    else:
        # 计算宽度的比例并构造尺寸
        r = width / float(w)
        dim = (width, int(h * r))
    resized = cv2.resize(image, dim, interpolation=inter)
    return resized

定义全局变量：

videos = 0
tracker_type = 'kcf'

我们的命令行参数包括：

videos：输入视频文件或者摄像头的id。

tracker_type：跟踪器的类型，接下来的代码定义了跟踪器列表。

接下来定义不同类型的跟踪器：

# 提取 opencv 版本信息
(major, minor) = cv2.__version__.split(".")[:2]
# 如果我们使用 opencv 3.2 或之前版本，我们可以使用特殊的工厂函数来创建我们的对象跟踪器
if int(major) == 3 and int(minor) < 3:
    tracker = cv2.tracker_create(tracker_type)
# 否则，对于 opencv 3.3 或更新版本，我们需要显式调用对应的对象跟踪器构造函数：
else:
    # 初始化一个字典，将字符串映射到其对应的 opencv 对象跟踪器实现
    opencv_object_trackers = {
        "csrt": cv2.trackercsrt_create,
        "kcf": cv2.trackerkcf_create,
        "boosting": cv2.legacy.trackerboosting_create,
        "mil": cv2.trackermil_create,
        "tld": cv2.legacy.trackertld_create,
        "medianflow": cv2.legacy.trackermedianflow_create,
        "mosse": cv2.legacy.trackermosse_create
    }
    # 使用我们的 opencv 对象跟踪器对象字典获取适当的对象跟踪器
    tracker = opencv_object_trackers[tracker_type]()

在opencv 3.3之前，必须使用cv2.tracker_create创建跟踪器对象，并传递跟踪器名称的大写字符串。

对于opencv 3.3+，可以使用各自的函数调用创建每个跟踪器，例如cv2.trackercsrt_create。字典opencv_object_trackers包含8个内置opencv对象跟踪器中的七个。它将对象跟踪器命令行参数字符串（键）与实际的opencv对象跟踪器函数（值）进行映射。

# 初始化我们要追踪的物体的边界框坐标
initbb = none
vs = cv2.videocapture(videos)
fps = none

initbb初始化为none，此变量将保存我们使用鼠标选择的对象的边界框坐标。

接下来，初始化videocapture对象和fps计数器。

让我们开始循环来自视频流的帧：

# 循环播放视频流中的帧
while true:
    # 抓取当前帧。
    (grabbed, frame) = vs.read()
    if not grabbed:
        break
    # 调整框架大小并获取框架尺寸。
    frame = resize(frame, width=500)
    (h, w) = frame.shape[:2]

    # 检查是否正在跟踪一个对象
    if initbb is not none:
        # 抓取物体的新边界框坐标
        (success, box) = tracker.update(frame)
        # 检查跟踪是否成功
        if success:
            (x, y, w, h) = [int(v) for v in box]
            cv2.rectangle(frame, (x, y), (x + w, y + h),
                          (0, 255, 0), 2)
        # 更新 fps 计数器
        fps.update()
        fps.stop()
        # 初始化在框架上显示的信息集
        info = [
            ("tracker", tracker_type),
            ("success", "yes" if success else "no"),
            ("fps", "{:.2f}".format(fps.fps())),
        ]
        # 遍历信息元组并将它们绘制在框架上
        for (i, (k, v)) in enumerate(info):
            text = "{}: {}".format(k, v)
            cv2.puttext(frame, text, (10, h - ((i * 20) + 20)),
                        cv2.font_hershey_simplex, 0.6, (0, 0, 255), 2)

    # 显示输出帧
    cv2.imshow("frame", frame)
    key = cv2.waitkey(1) & 0xff

抓住一个帧，如果获取不到帧，则退出。

为了使对象跟踪算法能够更快地处理帧，我们将输入帧的大小调整为500像素。

然后输出框架的高和宽。

如果已选择对象，则需要更新对象的位置。 update方法将定位对象的新位置并返回成功布尔值和对象的边界框。

如果成功，我们在框架上绘制新的，更新的边界框位置。

更新fps。

初始化显示的文本信息列表。随后，绘制到frame上。

显示输出帧。

   # 使用's'键选择一个边界框来跟踪
    if key == ord("s"):
        # 选择跟踪的对象的边界框（选择 roi 后按 enter 或 space）
        initbb = cv2.selectroi("frame", frame, fromcenter=false,
                               showcrosshair=true)
        # 使用提供的边界框坐标启动 opencv 对象跟踪器，然后也启动 fps 吞吐量估计器
        tracker.init(frame, initbb)
        fps = fps().start()
    # 如果 `q` 键被按下，则退出循环
    elif key == ord("q"):
        break
vs.release()
cv2.destroyallwindows()

按下“s”键时，使用cv2.selectroi“选择”对象roi。此时，视频帧冻结，用鼠标绘制跟踪对象的边界框。

绘制完边界框，然后按“enter”或“space”确认选择。如果需要重新选择区域，只需按“escape”即可。

然后，启动opencv 对象跟踪器，再启动 fps 吞吐量估计器。

最后一个段代码只是处理我们已经脱离循环的情况。释放所有指针并关闭窗口。

总结

在今天的博客文章中，您学习了如何利用opencv进行对象跟踪。具体来说，我们回顾了opencv库中包含的8个对象跟踪算法（从opencv 3.4开始）：

csrt、kcf、boosting、mil、tld、medianflow、mosse、goturn。

建议对大多数对象跟踪应用程序使用csrt，kcf或mosse：

当需要更高的对象跟踪精度并且可以容忍更慢的fps吞吐量时，请使用csrt

当需要更快的fps吞吐量时使用kcf，但可以处理稍低的对象跟踪精度

当需要纯粹的速度时使用mosse

到此这篇关于利用opencv进行对象跟踪的示例代码的文章就介绍到这了,更多相关opencv对象跟踪内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！