DCF 跟踪器

概述

此应用程序跟踪输入视频中的边界框，在每一帧上绘制它们，并将结果保存在一系列图像文件中。您可以定义用于处理的后端。

它作为一个简单的示例（或框架），展示了 DCF 跟踪器 算法如何在管道中实现。

注意

此示例实现了一个使用低跟踪质量的简单跟踪管道。为了获得生产级别的跟踪质量，您必须在名为“Custom target update”的代码部分实现正确的对象生命周期管理和边界框细化阶段。

说明

命令行参数是

./vpi_sample_19_dcf_tracker <backend> <input video> <input bboxes>

其中

• backend：cuda 或 pva；它定义了将执行处理的后端。
• input video：输入视频文件名，它接受 OpenCV 的 cv::VideoCapture 接受的所有视频类型。
• input bboxes：包含输入边界框以及它们在哪个帧中出现的文件。该文件由多行组成，格式如下

    <target_id> <frame> <bbox_x> <bbox_y> <bbox_width> <bbox_height>

这是一个示例

• C++

  ./vpi_sample_19_dcf_tracker cuda ../assets/pedestrians.mp4 ../assets/pedestrians_bboxes.txt

这是使用 CUDA 后端以及提供的示例视频和边界框之一。它会将跟踪的边界框渲染成一系列图像，然后保存到磁盘。

结果

简单跟踪结果

注意

视频输出需要支持 HTML5 且支持 H.264 mp4 视频解码的浏览器。

源代码

为了方便起见，这里是也安装在 samples 目录中的代码。

语言 C++

#include <opencv2/core.hpp>
#include <opencv2/features2d.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/videoio.hpp>
#include <vpi/OpenCVInterop.hpp>

#include <vpi/Array.h>
#include <vpi/Image.h>
#include <vpi/Pyramid.h>
#include <vpi/Status.h>
#include <vpi/Stream.h>
#include <vpi/algo/ConvertImageFormat.h>
#include <vpi/algo/CropScaler.h>
#include <vpi/algo/DCFTracker.h>

#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <optional>
#include <sstream>
#include <vector>

#define CHECK_STATUS(STMT) \
 do \
 { \
 VPIStatus status = (STMT); \
 if (status != VPI_SUCCESS) \
 { \
 char buffer[VPI_MAX_STATUS_MESSAGE_LENGTH]; \
 vpiGetLastStatusMessage(buffer, sizeof(buffer)); \
 std::ostringstream ss; \
 ss << vpiStatusGetName(status) << ": " << buffer; \
 throw std::runtime_error(ss.str()); \
 } \
 } while (0);

namespace {

// 目标跟踪信息。
struct TrackInfo
{
 int idTarget;
 cv::Scalar color;
 bool enabled; // 目标是否丢失。
};

// idTarget -> 信息
using TargetTrackInfoMap = std::map<int, TrackInfo>;

// 存储有关检测到的目标的信息。
struct DetectedTargetInfo
{
 int idTarget;

 VPIAxisAlignedBoundingBoxF32 bbox;

 bool lostTrack() const
 {
 return bbox.width == 0 || bbox.height == 0;
 }
};

// idTarget -> 信息
using DetectedTargetInfoMap = std::multimap<int, DetectedTargetInfo>;

VPIBackend ParseBackend(const std::string &str)
{
 if (str == "cuda")
 {
 return VPI_BACKEND_CUDA;
 }
 else if (str == "pva")
 {
 return VPI_BACKEND_PVA;
 }
 else
 {
 throw std::runtime_error("Backend '" + str + "' not recognized, it must be either cuda or pva.");
 }
}

// 打开由文件名指定的视频。
cv::VideoCapture ParseVideo(const std::string &fname)
{
 cv::VideoCapture video;
 if (!video.open(fname))
 {
 throw std::runtime_error("Can't open '" + fname + "'");
 }
 return video;
}

// 解析目标边界框，以及它们出现的帧。
DetectedTargetInfoMap ParseTargetInfoAtFrame(const std::string &fname)
{
 std::ifstream in(fname);
 if (!in)
 {
 throw std::runtime_error("Can't open '" + fname + "'");
 }

 DetectedTargetInfoMap out;

// 对于每个边界框，
 int frame;
 DetectedTargetInfo tinfo;
 while (in >> tinfo.idTarget >> frame >> tinfo.bbox.left >> tinfo.bbox.top >> tinfo.bbox.width >> tinfo.bbox.height)
 {
 out.emplace(frame, tinfo);
 }

 return out;
}

// 返回随机的高饱和度颜色。
cv::Scalar GetRandomColor(cv::RNG &rng)
{
 std::vector<cv::Vec3b> color = {cv::Vec3b{(unsigned char)rng.uniform(0, 180), 255, 255}};
 cvtColor(color, color, cv::COLOR_HSV2BGR);
 return cv::Scalar(color[0][0], color[0][1], color[0][2], 255);
}

// 将在帧 'idxFrame' 中找到的新目标添加到 'targets'。
bool AddNewTargetsFromFrame(int idxFrame, DetectedTargetInfoMap &tgtInfos, TargetTrackInfoMap &trackInfo,
 VPIArrayData &targets)
{
 // 尝试将新目标添加到现有目标的槽位中
 // 这些现有目标的跟踪已丢失。如果没有这样的目标，则会追加到
 // 数组的末尾。

 auto *pTarget = static_cast<VPIDCFTrackedBoundingBox *>(targets.buffer.aos.data);
 const auto *tgtBegin = pTarget;

 static cv::RNG rng(1);

 // 对于 'idxFrame' 中的所有新目标，
 auto tgtInfoRange = tgtInfos.equal_range(idxFrame);
 for (auto it = tgtInfoRange.first; it != tgtInfoRange.second; ++it)
 {
 // 如果信息表明目标的跟踪已完成，
 if (it->second.lostTrack())
 {
 // 跳过它，我们这里只添加新目标。
 continue;
 }

 // 如果相应的目标已启用（即正在被跟踪）
 auto itTrackInfo = trackInfo.find(it->second.idTarget);
 if (itTrackInfo != trackInfo.end() && itTrackInfo->second.enabled)
 {
 // 也跳过它
 continue;
 }

 // @注意：当分配数组时，其内容将填充零，
 // 直到其容量。这意味着目标的状态丢失了。
 static_assert(VPI_TRACKING_STATE_LOST == 0, "Unexpected value for lost state");

 // 搜索第一个跟踪丢失的目标。
 while (pTarget->state != VPI_TRACKING_STATE_LOST && pTarget < tgtBegin + targets.buffer.aos.capacity)
 {
 ++pTarget;
 }

 assert(pTarget < tgtBegin + targets.buffer.aos.capacity);

 pTarget->bbox = it->second.bbox;
 pTarget->state = VPI_TRACKING_STATE_NEW;
 pTarget->seqIndex = 0;
 // 合理的默认值。
 pTarget->filterLR = 0.075;
 pTarget->filterChannelWeightsLR = 0.1;

 // 这是我们第一次看到这个目标吗？
 if (itTrackInfo == trackInfo.end())
 {
 // 为其创建跟踪信息。
 TrackInfo tinfo;
 tinfo.idTarget = it->second.idTarget;
 tinfo.color = GetRandomColor(rng);
 tinfo.enabled = true;
 itTrackInfo = trackInfo.emplace(tinfo.idTarget, tinfo).first;
 }
 else
 {
 // 现在已启用。
 itTrackInfo->second.enabled = true;
 }

 pTarget->userData = &itTrackInfo->second;

 ++pTarget;
 }

 // 仅当我们将目标追加到数组末尾时才更新数组大小。
 *targets.buffer.aos.sizePointer = std::max<int32_t>(*targets.buffer.aos.sizePointer, pTarget - tgtBegin);

 assert(*targets.buffer.aos.sizePointer >= 0);

 return true;
}

// 将边界框超出帧区域或被检测器认为丢失的目标标记为丢失。
bool DetectTrackingLost(int idxFrame, DetectedTargetInfoMap &tgtInfos, VPIArrayData &targets, cv::Size frameSize)
{
 auto tgtInfoRange = tgtInfos.equal_range(idxFrame);

 // 这是一种简单的方法，在鲁棒的跟踪器中不可靠。
 // 鲁棒的方法需要由用户实现。

 bool atLeastOneLost = false;

 // 对于所有目标，从后向前，以便在需要时轻松减小数组大小。
 for (auto *pBeginTarget = static_cast<VPIDCFTrackedBoundingBox *>(targets.buffer.aos.data),
 *pTarget = pBeginTarget + *targets.buffer.aos.sizePointer - 1;
 pTarget >= pBeginTarget; --pTarget)
 {
 bool trackingLost = false;

 // 这是一个有效的目标，但其边界框并非完全在帧内，
 if (pTarget->state != VPI_TRACKING_STATE_LOST && (pTarget->bbox.left < 0 || pTarget->bbox.top < 0 ||
 pTarget->bbox.left + pTarget->bbox.width > frameSize.width ||
 pTarget->bbox.top + pTarget->bbox.height > frameSize.height))
 {
 // 认为它的跟踪丢失。
 trackingLost = true;
 }
 else
 {
 // 遍历当前帧中的所有目标信息
 for (auto itInfo = tgtInfoRange.first; itInfo != tgtInfoRange.second; ++itInfo)
 {
 // 这是当前目标的信息，并且跟踪丢失了吗？
 if (pTarget->state != VPI_TRACKING_STATE_LOST &&
 static_cast<const TrackInfo *>(pTarget->userData)->idTarget == itInfo->second.idTarget &&
 itInfo->second.lostTrack())
 {
 // 标记它，
 trackingLost = true;
 break;
 }
 }
 }

 if (trackingLost)
 {
 atLeastOneLost = true;

 // 更新目标状态以反映它。
 pTarget->state = VPI_TRACKING_STATE_LOST;
 static_cast<TrackInfo *>(pTarget->userData)->enabled = false;

 assert(*targets.buffer.aos.sizePointer >= 1);

 // 如果目标位于目标数组的末尾，
 if (pTarget == pBeginTarget + *targets.buffer.aos.sizePointer - 1)
 {
 // 我们可以减小数组大小以提高跟踪处理时间。
 *targets.buffer.aos.sizePointer = -1;
 }
 }
 }

 return atLeastOneLost;
}

// 使用来自检测器输出的输入更新目标的边界框。
bool RefineTracksAtFrame(int idxFrame, DetectedTargetInfoMap &tgtInfos, VPIArrayData &targets)
{
 auto tgtInfoRange = tgtInfos.equal_range(idxFrame);

 bool atLeastOneUpdated = false;

 for (auto *pBeginTarget = static_cast<VPIDCFTrackedBoundingBox *>(targets.buffer.aos.data), *pTarget = pBeginTarget;
 pTarget < pBeginTarget + *targets.buffer.aos.sizePointer; ++pTarget)
 {
 // 如果跟踪丢失，
 if (pTarget->state == VPI_TRACKING_STATE_LOST)
 {
 // 则无需优化。
 continue;
 }

 bool found = false;

 // 对于 'idxFrame' 中的所有目标，
 for (auto itInfo = tgtInfoRange.first; itInfo != tgtInfoRange.second; ++itInfo)
 {
 // 如果信息指示跟踪丢失，
 if (itInfo->second.lostTrack())
 {
 // 跳过它，我们只更新现有目标。
 continue;
 }

 if ((pTarget->state == VPI_TRACKING_STATE_TRACKED || pTarget->state == VPI_TRACKING_STATE_SHADOW_TRACKED) &&
 static_cast<const TrackInfo *>(pTarget->userData)->idTarget == itInfo->second.idTarget)
 {
 pTarget->bbox = itInfo->second.bbox;
 found = true;
 break;
 }
 }

 if (found)
 {
 atLeastOneUpdated = true;
 pTarget->state = VPI_TRACKING_STATE_TRACKED;
 }
 else if (pTarget->state == VPI_TRACKING_STATE_TRACKED)
 {
 pTarget->state = VPI_TRACKING_STATE_SHADOW_TRACKED;
 }
 }

 return atLeastOneUpdated;
}

void DrawTargets(cv::Mat &frame, VPIArray targets)
{
 VPIArrayData tgtData;
 CHECK_STATUS(vpiArrayLockData(targets, VPI_LOCK_READ, VPI_ARRAY_BUFFER_HOST_AOS, &tgtData));

 auto *ptgt = static_cast<VPIDCFTrackedBoundingBox *>(tgtData.buffer.aos.data);
 int numObjs = *tgtData.buffer.aos.sizePointer;

 for (int o = 0; o < numObjs; ++o, ++ptgt)
 {
 // 仅绘制未丢失的对象
 if (ptgt->state == VPI_TRACKING_STATE_LOST)
 {
 continue;
 }

 auto &tinfo = *static_cast<TrackInfo *>(ptgt->userData);

 rectangle(frame,
 cv::Rect{(int)ptgt->bbox.left, (int)ptgt->bbox.top, (int)ptgt->bbox.width, (int)ptgt->bbox.height},
 tinfo.color);
 }

 CHECK_STATUS(vpiArrayUnlock(targets));
}

void WriteToDisk(const cv::Mat &img, std::string name, int idx)
{
 char buf[128];
 snprintf(buf, sizeof(buf) - 1, "%s_%03d.jpg", name.c_str(), idx);
 buf[sizeof(buf) - 1] = '\0';

 imwrite(buf, img);
}

void PreprocessFrame(VPIStream stream, const cv::Mat &in, VPIImage &wrapper, VPIImage out)
{
 // 预处理当前帧
 if (wrapper == NULL)
 {
 CHECK_STATUS(vpiImageCreateWrapperOpenCVMat(in, 0, &wrapper));
 }
 else
 {
 CHECK_STATUS(vpiImageSetWrappedOpenCVMat(wrapper, in));
 }

 CHECK_STATUS(vpiSubmitConvertImageFormat(stream, VPI_BACKEND_CUDA, wrapper, out, NULL));
}

} // namespace

int main(int argc, char *argv[])
{
 VPIPayload cropScale = NULL;
 VPIPayload dcf = NULL;
 VPIStream stream = NULL;
 VPIArray inTargets = NULL, outTargets = NULL;
 VPIImage tgtPatches = NULL;
 VPIImage frame = NULL;
 VPIImage wrappedOCVFrame = NULL;

 int retval = 0;
 try
 {
 // 命令行参数处理
 // --------------------------------
 if (argc != 4)
 {
 throw std::runtime_error(std::string("Usage: ") + argv[0] + " <pva|cuda> <input_video> <bbox descr>");
 }

 VPIBackend backend = ParseBackend(argv[1]);
 cv::VideoCapture invid = ParseVideo(argv[2]);
 DetectedTargetInfoMap targetInfoAtFrame = ParseTargetInfoAtFrame(argv[3]);

 TargetTrackInfoMap trackInfo;

 // 分配所有需要的 VPI 资源
 // ---------------------------------

 const int maxTrackedTargets = targetInfoAtFrame.size();

 // 创建 CropScale 有效负载
 CHECK_STATUS(vpiCreateCropScaler(backend,
 1, // 最大序列数（仅处理一个视频）
 maxTrackedTargets, &cropScale));

 // 配置并创建 DCFTracker 有效负载
 VPIDCFTrackerCreationParams dcfInitParams;
 CHECK_STATUS(vpiInitDCFTrackerCreationParams(&dcfInitParams));

 VPIPayload dcf;
 CHECK_STATUS(vpiCreateDCFTracker(backend,
 1, // 最大序列数
 maxTrackedTargets, &dcfInitParams, &dcf));

 // （可选）用户可以检索内部数组，该数组存储通道权重和
 // 每个被跟踪目标的最大相关性响应。这些可以与
 // 相关性图一起使用，以确定跟踪是否丢失。
 // 尽管在本示例中没有这样做。
 /*
 VPIArray channelWeights;
 int32_t numFeatureChannels
 CHECK_STATUS(vpiDCFTrackerGetChannelWeights(dcf, &channelWeights, &numFeatureChannels));
 */

 // 创建目标数组
 VPIArray inTargets, outTargets;
 CHECK_STATUS(vpiArrayCreate(maxTrackedTargets, VPI_ARRAY_TYPE_DCF_TRACKED_BOUNDING_BOX, 0, &inTargets));
 CHECK_STATUS(vpiArrayCreate(maxTrackedTargets, VPI_ARRAY_TYPE_DCF_TRACKED_BOUNDING_BOX, 0, &outTargets));

 // 创建图像以存储目标块
 const int tgtPatchSize = dcfInitParams.featurePatchSize * dcfInitParams.hogCellSize;
 const VPIImageFormat tgtPatchFormat = backend == VPI_BACKEND_PVA
 ? VPI_IMAGE_FORMAT_RGB8p
 : VPI_IMAGE_FORMAT_RGBA8; // 使用后端支持的块格式

 CHECK_STATUS(vpiImageCreate(tgtPatchSize, tgtPatchSize * maxTrackedTargets, tgtPatchFormat, 0, &tgtPatches));

 // 创建用于处理的流
 CHECK_STATUS(vpiStreamCreate(0, &stream));

 // 创建图像以存储输入帧
 CHECK_STATUS(vpiImageCreate(invid.get(cv::CAP_PROP_FRAME_WIDTH), invid.get(cv::CAP_PROP_FRAME_HEIGHT),
 VPI_IMAGE_FORMAT_RGBA8, 0, &frame));

 // 目标跟踪
 // ---------------

 int curFrame = 0;

 // 使用在第一帧中找到的目标填充目标数组。
 VPIArrayData tgtData;
 CHECK_STATUS(vpiArrayLockData(inTargets, VPI_LOCK_READ_WRITE, VPI_ARRAY_BUFFER_HOST_AOS, &tgtData));
 try
 {
 AddNewTargetsFromFrame(curFrame, targetInfoAtFrame, trackInfo, tgtData);
 }
 catch (...)
 {
 CHECK_STATUS(vpiArrayUnlock(inTargets));
 throw;
 }
 CHECK_STATUS(vpiArrayUnlock(inTargets));

 // 对于每个输入帧，
 cv::Mat cvFrame;
 while (invid.read(cvFrame))
 {
 printf("Frame %d\n", curFrame);

 // 将 opencv 帧 (cvFrame) 转换为合适的 VPIImage (frame)。
 PreprocessFrame(stream, cvFrame, wrappedOCVFrame, frame);

 // 使用来自先前迭代的边界框从当前帧中裁剪目标，
 // 然后将它们重新缩放到 tgtPatches 中。
 CHECK_STATUS(vpiSubmitCropScalerBatch(stream, 0, cropScale, &frame, 1, inTargets, tgtPatchSize,
 tgtPatchSize, tgtPatches));

 // 如果我们在第一帧中，
 VPIArray targets;
 if (curFrame == 0)
 {
 // 目标只是找到的那些。
 targets = inTargets;
 }
 else
 {
 // 在当前帧中定位和优化当前目标的边界框。
 CHECK_STATUS(vpiSubmitDCFTrackerLocalizeBatch(stream, 0, dcf, NULL, 0, // 处理所有序列
 NULL, // 特征掩蔽窗口（不需要）
 tgtPatches, inTargets, outTargets,
 NULL, // outCorrelationResponses（不需要）
 NULL, // outMaxCorrelationResponses（不需要）
 NULL)); // 算法旋钮（使用默认值）
 targets = outTargets;

 // 自定义目标更新
 // --------------------

 // 此时可以进行其他额外的处理，
 // 例如目标生命周期管理和边界框优化。
 // 它通常使用来自 'outMaxCorrelationResponses'、
 // 'outCorrelationResponses' 和/或 'channelWeights' 的信息。
 // 由于此处理通常很耗时，
 // 因此通常每隔几帧执行一次。

 // 由于我们正在主机上更新目标数组，因此我们需要同步流。
 CHECK_STATUS(vpiStreamSync(stream));

 // 如果对应的目标是新的，或者其边界框被优化，则必须更新目标块。
 // 框被优化。
 bool mustUpdateTargetPatches = false;

 VPIArrayData tgtData;
 CHECK_STATUS(vpiArrayLockData(targets, VPI_LOCK_READ_WRITE, VPI_ARRAY_BUFFER_HOST_AOS, &tgtData));
 try
 {
 // 这些函数基于当前帧上的对象检测器的
 // 输出更新目标数组。此
 // 检测器负责关联检测到的
 // 对象与相应的现有目标（如果
 // 可能）。
 //
 // 基于此信息，这些函数更新
 // 对象生命周期（对象是新的还是跟踪
 // 丢失），并更新其边界框和状态。
 //
 // 对于此示例应用程序，检测和
 // 重新关联在 'targetInfoAtFrame' 中硬编码。对于
 // 生产级质量，需要用户实现稳健且通用的解决方案。
 // 需要用户实现稳健且通用的解决方案。

 // 注意：为了演示目的，目标更新在三个单独的
 // 函数中实现。

 // 检测目标跟踪是否丢失，并相应地更新 tgtData。
 DetectTrackingLost(curFrame, targetInfoAtFrame, tgtData, cv::Size{cvFrame.cols, cvFrame.rows});

 // 目标边界框优化
 mustUpdateTargetPatches |= RefineTracksAtFrame(curFrame, targetInfoAtFrame, tgtData);

 // 检测当前帧中是否找到新目标。
 mustUpdateTargetPatches |= AddNewTargetsFromFrame(curFrame, targetInfoAtFrame, trackInfo, tgtData);
 }
 catch (...)
 {
 CHECK_STATUS(vpiArrayUnlock(targets));
 throw;
 }
 CHECK_STATUS(vpiArrayUnlock(targets));

 if (mustUpdateTargetPatches)
 {
 // 裁剪+缩放更新后的目标，并将它们复制到 tgtPatches 中。
 CHECK_STATUS(vpiSubmitCropScalerBatch(stream, 0, cropScale, &frame, 1, targets, tgtPatchSize,
 tgtPatchSize, tgtPatches));
 }
 }

 // 根据目标的新边界框更新目标的内部元数据。
 CHECK_STATUS(vpiSubmitDCFTrackerUpdateBatch(stream, 0, dcf, nullptr, 0, // 处理所有序列
 NULL, // featureMaskingWindow（不需要）
 NULL, // modelMaskingWindow（不需要）
 tgtPatches, targets,
 NULL)); // 算法旋钮（使用默认值）

 // 等待帧处理完成
 CHECK_STATUS(vpiStreamSync(stream));

 // 将帧写入磁盘
 DrawTargets(cvFrame, targets);
 WriteToDisk(cvFrame, "frame", curFrame);

 // 乒乓操作目标数组：
 // 本次迭代中更新的目标将作为下一次迭代的输入 (inTargets)，
 // 而当前输入将存储更新后的目标。
 std::swap(inTargets, targets);
 ++curFrame;
 }
 }
 catch (std::exception &e)
 {
 std::cerr << e.what() << std::endl;
 retval = 1;
 }

 // 销毁所有 VPI 资源
 // -------------------------

 vpiStreamDestroy(stream);

 vpiPayloadDestroy(cropScale);
 vpiPayloadDestroy(dcf);
 vpiArrayDestroy(inTargets);
 vpiArrayDestroy(outTargets);
 vpiImageDestroy(tgtPatches);
 vpiImageDestroy(frame);
 vpiImageDestroy(wrappedOCVFrame);

 return retval;
}