使用的darknet实现区域人头统计、目标跟踪

使用的darknet实现区域人头统计、目标跟踪 风清扬 2023-07-06 09:53:53 887
YOLO
深度学习

该功能使用的darknet框架，训练的yolo-tiny人头模型，之后使用opencv4.5.1版本调用的yolo-tiny模型，跟踪使用KCF跟踪算法，整体上实现了三个功能：

1、区域内的人头统计；

2、区域内的绊线检测功能；

3、区域内目标跟踪，统计人头数量的功能。

一、网址：https://github.com/AlexeyAB/darknet

二、参考训练参考我的另两篇博客：

Darknet下的Yolo v3_dragon_perfect的博客-CSDN博客

深度学习 客流统计 人流计数dragon_perfect的博客-CSDN博客人流统计算法

跟踪部分的代码如下：

  1. #pragma once
  3. #include "HeadDetect.h"
  4. #include "opencv2/opencv.hpp"
  5. #include "KCFLib/kcftracker.hpp"
  7. using namespace cv;
  8. using namespace std;
  10. #define MAX_TRACK_COUNT            100//目标的最大个数
  11. #define MAX_TRAJECTORY_COUNT    200//目标轨迹的最大个数
  12. #define MAX_MISS_FRAME            10//最大丢失帧数
  13. #define MAX_MATCH_FRAME            3//最大匹配帧数
  14. #define MAX_TRACK_DIST          40000//最大跟踪距离
  16. struct ZTracker 
  17. {
  18.     int nID;
  19.     int nMissTimes;
  20.     bool bMatchID;
  21.     bool bTrack;
  22.     bool bStatOK;
  23.     bool bInitDirection;
  24.     int nInitDirection;
  25.     cv::KalmanFilter *kf;
  26.     cv::Point predPoint;
  27.     cv::Point curCentre;
  28.     cv::Rect curRect;
  29.     int nTrajCount;
  30.     cv::Point centres[MAX_TRAJECTORY_COUNT];
  31.     cv::Rect blobs[MAX_TRAJECTORY_COUNT];
  32. };
  34. class ZHeadTrack
  35. {
  36. public:
  37.     ZHeadTrack();
  38.     ~ZHeadTrack();
  40.     int m_InCount;
  41.     int m_OutCount;
  42.     int m_RegionCount;
  43.     ZTracker *m_pTrackers;
  44.     KCFTracker m_pKCF[MAX_TRACK_COUNT];
  46.     void trackInitial(cv::Point arrowStart, cv::Point arrowEnd, cv::Point lineStart, cv::Point lineEnd, vector<Point> regionPonits,int width,int height);
  48.     void trackProcess(HDBox_Container *pHDBox_Container, HDRect *rect,bool bMask);
  50.     void kcfProcess(HDBox_Container *pHDBox_Container, HDRect *rect, cv::Mat image);
  52.     void trackInOutStatistics();
  54.     void trackRegionStatistics();
  56.     int pointInLineSide(cv::Point point, cv::Point lineStart, cv::Point lineEnd);
  58.     float CalculateIou(cv::Rect& det, cv::Rect& track);
  60. public:
  62.     int m_trackID;
  63.     int m_nArrowStart;
  64.     int    m_nArrowEnd;
  65.     cv::Point m_lineStart;
  66.     cv::Point m_lineEnd;
  67.     cv::Mat m_detectRegion;
  68.     HDBox_Container m_boxContainer;
  69.     HDTracker_Region m_trackeRegion;
  70. };
  2. #include "HeadTrack.h"
  4. ZHeadTrack::ZHeadTrack()
  5. {
  6.     m_trackID = 0;
  7.     m_InCount = 0;
  8.     m_OutCount = 0;
  9.     m_RegionCount = 0;
  10.     m_nArrowStart = 0;
  11.     m_nArrowEnd = 0;
  13.     m_pTrackers = new ZTracker[MAX_TRACK_COUNT];
  14.     memset(m_pTrackers, 0, sizeof(ZTracker));
  15. }
  17. ZHeadTrack::~ZHeadTrack()
  18. {
  19.     delete m_pTrackers;
  20. }
  22. void ZHeadTrack::trackInitial(cv::Point arrowStart, cv::Point arrowEnd, cv::Point lineStart, cv::Point lineEnd, vector<Point> regionPonits, int width, int height)
  23. {
  24.     m_trackID = 0;
  25.     m_InCount = 0;
  26.     m_OutCount = 0;
  27.     m_nArrowStart = pointInLineSide(arrowStart, lineStart, lineEnd);
  28.     m_nArrowEnd = pointInLineSide(arrowEnd, lineStart, lineEnd);
  29.     m_lineStart = lineStart;
  30.     m_lineEnd = lineEnd;
  32.     vector<vector<Point>> vpts;
  33.     vpts.push_back(regionPonits);
  35.     cv::Mat detectRegion = cv::Mat::zeros(height, width, CV_8UC3);
  37.     cv::fillPoly(detectRegion, vpts, cv::Scalar(255, 255, 255));
  38.     cv::cvtColor(detectRegion, m_detectRegion, COLOR_BGR2GRAY);
  39.     //m_detectRegion = detectRegion.clone();
  41.     //cv::imshow("detectRegion", m_detectRegion);
  42.     //cv::waitKey(0);
  43. }
  45. void ZHeadTrack::trackProcess(HDBox_Container *pHDBox_Container, HDRect *rect, bool bMask)
  46. {
  47.     int i = 0, j = 0;
  49.     //把太小的rect删除
  50.     m_boxContainer.headCount = 0;
  51.     int width = m_detectRegion.cols;
  52.     uchar *pDetectData = m_detectRegion.data;
  54.     int step1 = m_detectRegion.step1();
  55.     //cv::imshow("m_detectRegion", m_detectRegion);
  56.     //cv::waitKey(10);
  58.     for (i = 0;i< pHDBox_Container->headCount;i++)
  59.     {
  60.         HDRect *pHDRect = &pHDBox_Container->candidates[i];
  61.         int nx = (pHDRect->right + pHDRect->left) / 2;
  62.         int ny = (pHDRect->top + pHDRect->bottom) / 2;
  63.         int rectW = pHDRect->right - pHDRect->left;
  64.         int rectH = pHDRect->bottom - pHDRect->top;
  65.         if (bMask)
  66.         {
  67.             if (rectW > 60 && rectH > 60 && (*(pDetectData + ny*width + nx) == 255))
  68.             {
  69.                 m_boxContainer.candidates[m_boxContainer.headCount++] = pHDBox_Container->candidates[i];
  70.             }
  71.         }
  72.         else
  73.         {
  74.             if (rectW > 40 && rectH > 40 && nx > rect->left && nx < rect->right && ny > rect->top && ny < rect->bottom)
  75.             {
  76.                 m_boxContainer.candidates[m_boxContainer.headCount++] = pHDBox_Container->candidates[i];
  77.             }
  78.         }
  79.     }
  81.     bool bMatch[HD_MAX_HEADS] = { false };
  82.     for (i = 0;i< m_boxContainer.headCount;i++)
  83.     {
  84.         bMatch[i] = false;
  85.     }
  87.     for (i = 0; i < MAX_TRACK_COUNT; i++)
  88.     {
  89.         ZTracker *pTracker = &m_pTrackers[i];
  90.         if (pTracker->bTrack)
  91.         {
  92.             bool bMinst = false;
  93.             int nMatchID = -1;
  94.             int maxDist = MAX_TRACK_DIST;
  95.             for (j = 0; j < m_boxContainer.headCount; j++)
  96.             {
  97.                 if (!bMatch[j])
  98.                 {
  99.                     HDRect *pHDRect = &m_boxContainer.candidates[j];
  100.                     cv::Rect curRect;
  101.                     curRect.x = pHDRect->left;
  102.                     curRect.y = pHDRect->top;
  103.                     curRect.width = pHDRect->right - pHDRect->left;
  104.                     curRect.height = pHDRect->bottom - pHDRect->top;
  105.                     int nx = (pHDRect->left + pHDRect->right) / 2;
  106.                     int ny = (pHDRect->top + pHDRect->bottom) / 2;
  108.                     int dist = (pTracker->predPoint.x - nx)*(pTracker->predPoint.x - nx) + (pTracker->predPoint.y - ny)*(pTracker->predPoint.y - ny);
  109.                     if (dist < maxDist)
  110.                     {
  111.                         maxDist = dist;
  112.                         pTracker->curRect = curRect;//后面更新用
  113.                         pTracker->curCentre.x = nx;
  114.                         pTracker->curCentre.y = ny;
  115.                         nMatchID = j;
  116.                         bMinst = true;
  117.                     }
  118.                 }
  119.             }
  121.             //找到了blob
  122.             if (bMinst)
  123.             {
  124.                 bMatch[nMatchID] = true;
  126.                 HDRect *pHDRect = &m_boxContainer.candidates[nMatchID];
  127.                 cv::Rect curRect;
  128.                 curRect.x = pHDRect->left;
  129.                 curRect.y = pHDRect->top;
  130.                 curRect.width = pHDRect->right - pHDRect->left;
  131.                 curRect.height = pHDRect->bottom - pHDRect->top;
  132.                 int nx = (pHDRect->left + pHDRect->right) / 2;
  133.                 int ny = (pHDRect->top + pHDRect->bottom) / 2;
  135.                 pTracker->bMatchID = true;
  136.                 pTracker->nMissTimes = 0;
  137.                 pTracker->curCentre.x = nx;
  138.                 pTracker->curCentre.y = ny;
  139.                 pTracker->curRect = curRect;
  141.                 //更新预测值
  142.                 Mat measurement = Mat::zeros(2, 1, CV_32F);
  143.                 measurement.at<float>(0) = (float)nx;
  144.                 measurement.at<float>(1) = (float)ny;
  145.                 pTracker->kf->correct(measurement);
  147.                 Mat prediction = pTracker->kf->predict();
  148.                 pTracker->predPoint = Point(prediction.at<float>(0), prediction.at<float>(1)); //预测值(x',y')
  150.                 cv::Point centre = pTracker->centres[pTracker->nTrajCount - 1];
  151.                 if ((centre.x - nx)*(centre.x - nx) + (centre.y - ny)*(centre.y - ny) > 30)
  152.                 {
  153.                     pTracker->centres[pTracker->nTrajCount].x = nx;
  154.                     pTracker->centres[pTracker->nTrajCount].y = ny;
  155.                     pTracker->blobs[pTracker->nTrajCount] = curRect;
  156.                     pTracker->nTrajCount++;
  157.                     if (pTracker->nTrajCount >= MAX_TRAJECTORY_COUNT - 1)
  158.                     {
  159.                         pTracker->nTrajCount = MAX_TRAJECTORY_COUNT - 1;
  160.                         for (int k = 1; k < pTracker->nTrajCount; k++)
  161.                         {
  162.                             pTracker->centres[k - 1] = pTracker->centres[k];
  163.                             pTracker->blobs[k - 1] = pTracker->blobs[k];
  164.                         }
  165.                     }
  166.                 }
  167.             }    
  168.             else//没找到blob
  169.             {
  170.                 pTracker->nMissTimes++;
  171.                 //Mat prediction = pTracker->kf->predict();
  172.                 //pTracker->predPoint = Point(prediction.at<float>(0), prediction.at<float>(1)); //预测值(x',y')
  173.                                                                                                //更新预测值
  174.                 Mat measurement = Mat::zeros(2, 1, CV_32F);
  175.                 measurement.at<float>(0) = (float)pTracker->curCentre.x;
  176.                 measurement.at<float>(1) = (float)pTracker->curCentre.y;
  177.                 pTracker->kf->correct(measurement);
  179.                 Mat prediction = pTracker->kf->predict();
  180.                 pTracker->predPoint = Point(prediction.at<float>(0), prediction.at<float>(1)); //预测值(x',y')
  182.                 if (pTracker->nMissTimes > MAX_MISS_FRAME)
  183.                 {
  184.                     pTracker->bTrack = false;
  185.                     delete pTracker->kf;
  186.                 }
  187.             }
  188.         }
  189.     }
  191.     //没有匹配上的，需要重新创建目标
  192.     for (i = 0; i < m_boxContainer.headCount; i++)
  193.     {
  194.         HDRect *pHDRect = &m_boxContainer.candidates[i];
  195.         cv::Rect curRect;
  196.         curRect.x = pHDRect->left;
  197.         curRect.y = pHDRect->top;
  198.         curRect.width = pHDRect->right - pHDRect->left;
  199.         curRect.height = pHDRect->bottom - pHDRect->top;
  200.         int nx = (pHDRect->left + pHDRect->right) / 2;
  201.         int ny = (pHDRect->top + pHDRect->bottom) / 2;
  202.         if (!bMatch[i])
  203.         {
  204.             for (j = 0; j < MAX_TRACK_COUNT; j++)
  205.             {
  206.                 ZTracker *pTracker = &m_pTrackers[j];
  207.                 if (!pTracker->bTrack)
  208.                 {
  209.                     pTracker->bTrack = true;
  210.                     pTracker->bMatchID = true;
  211.                     pTracker->bStatOK = false;
  212.                     pTracker->bInitDirection = false;
  213.                     pTracker->nID = ++m_trackID;
  215.                     pTracker->curCentre.x = nx;
  216.                     pTracker->curCentre.y = ny;
  217.                     pTracker->curRect = curRect;
  218.                     pTracker->nMissTimes = 0;
  219.                     pTracker->predPoint.x = nx;
  220.                     pTracker->predPoint.y = ny;
  222.                     pTracker->kf = new cv::KalmanFilter(4, 2, 0);
  223.                     pTracker->kf->transitionMatrix = (Mat_<float>(4, 4) << 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1);//转移矩阵A
  224.                     cv::setIdentity(pTracker->kf->measurementMatrix);                     //测量矩阵H
  225.                     cv::setIdentity(pTracker->kf->processNoiseCov, Scalar::all(1e-5));    //系统噪声方差矩阵Q
  226.                     cv::setIdentity(pTracker->kf->measurementNoiseCov, Scalar::all(1e-1));//测量噪声方差矩阵R
  227.                     cv::setIdentity(pTracker->kf->errorCovPost, Scalar::all(1));          //后验错误估计协方差矩阵P
  228.                     pTracker->kf->statePost = (Mat_<float>(4, 1) << nx, ny, 0, 0);
  230.                     Mat prediction = pTracker->kf->predict();
  231.                     pTracker->predPoint = Point(prediction.at<float>(0), prediction.at<float>(1)); //预测值(x',y')
  233.                     pTracker->centres[0].x = nx;
  234.                     pTracker->centres[0].y = ny;
  235.                     pTracker->blobs[0] = curRect;
  236.                     pTracker->nTrajCount = 1;
  237.                     break;
  238.                 }
  239.             }
  240.         }
  241.     }
  242. }
  244. float ZHeadTrack::CalculateIou(cv::Rect& det, cv::Rect& track) 
  245. {
  246.     // get min/max points
  247.     auto xx1 = std::max(det.tl().x, track.tl().x);
  248.     auto yy1 = std::max(det.tl().y, track.tl().y);
  249.     auto xx2 = std::min(det.br().x, track.br().x);
  250.     auto yy2 = std::min(det.br().y, track.br().y);
  251.     auto w = std::max(0, xx2 - xx1);
  252.     auto h = std::max(0, yy2 - yy1);
  254.     // calculate area of intersection and union
  255.     float det_area = det.area();
  256.     float trk_area = track.area();
  257.     auto intersection_area = w * h;
  258.     float union_area = det_area + trk_area - intersection_area;
  259.     auto iou = intersection_area / union_area;
  260.     return iou;
  261. }
  263. void ZHeadTrack::kcfProcess(HDBox_Container *pHDBox_Container, HDRect *rect,cv::Mat image)
  264. {
  265.     int i = 0, j = 0;
  266.     //HDBox_Container container;
  268.     m_boxContainer.headCount = 0;
  269.     for (i = 0; i < pHDBox_Container->headCount; i++)
  270.     {
  271.         HDRect *pHDRect = &pHDBox_Container->candidates[i];
  272.         int nx = (pHDRect->right + pHDRect->left) / 2;
  273.         int ny = (pHDRect->top + pHDRect->bottom) / 2;
  274.         int rectW = pHDRect->right - pHDRect->left;
  275.         int rectH = pHDRect->bottom - pHDRect->top;
  277.         if (rectW > 20 && rectH > 20 && nx > rect->left && nx < rect->right && ny > rect->top && ny < rect->bottom)
  278.         {
  279.             m_boxContainer.candidates[m_boxContainer.headCount++] = pHDBox_Container->candidates[i];
  280.         }
  281.     }
  283.     bool bMatch[HD_MAX_HEADS] = { false };
  284.     for (i = 0; i < m_boxContainer.headCount; i++)
  285.     {
  286.         bMatch[i] = false;
  287.     }
  289.     for (i = 0; i < MAX_TRACK_COUNT; i++)
  290.     {
  291.         KCFTracker *pKCF = &m_pKCF[i];
  292.         if (pKCF->bTrack)
  293.         {
  294.             cv::Rect tRect = pKCF->update(image);
  296.             pKCF->nTrackTimes++;
  297.             pKCF->curRect = tRect;
  298.             int nx = tRect.x + tRect.width / 2;
  299.             int ny = tRect.y + tRect.height / 2;
  300.             int dist = 10000000;
  301.             float dfiou = 0.4;
  302.             cv::Rect roiRect;
  303.             int nFlag = 0;
  304.             bool bOK = false;
  305.             int nlimit = 0.6*std::sqrt(tRect.width*tRect.width + tRect.height*tRect.height);
  306.             for (j = 0; j < m_boxContainer.headCount; j++)
  307.             {
  308.                 HDRect *pHDRect = &m_boxContainer.candidates[j];
  309.                 int x0 = (pHDRect->left + pHDRect->right) / 2;
  310.                 int y0 = (pHDRect->top + pHDRect->bottom) / 2;
  311.                 int tempDist = std::sqrt((nx - x0)*(nx - x0) + (ny - y0)*(ny - y0));
  312.                 cv::Rect trackR;
  313.                 trackR.x = pHDRect->left;
  314.                 trackR.y = pHDRect->top;
  315.                 trackR.width = pHDRect->right - pHDRect->left;
  316.                 trackR.height = pHDRect->bottom - pHDRect->top;
  317.                 float fiou = CalculateIou(tRect, trackR);
  318.                 if (fiou > dfiou)
  319.                 {
  320.                     dfiou = fiou;
  321.                     nFlag = j;
  322.                     bOK = true;
  323.                     roiRect = trackR;
  324.                 }
  325.             }
  327.             if (bOK)
  328.             {
  329.                 bMatch[nFlag] = true;
  330.                 pKCF->nMissFrame = 0;
  331.                 pKCF->init(roiRect, image);
  332.                 pKCF->curRect = roiRect;
  333.                 pKCF->nMatchTimes++;
  334.                 if (!pKCF->bValid)
  335.                 {
  336.                     if (/*pKCF->nMatchTimes > MAX_MATCH_FRAME && */pKCF->nTrackTimes == pKCF->nMatchTimes)
  337.                     {
  338.                         pKCF->bValid = true;
  339.                         pKCF->nID = ++m_trackID;
  340.                     }
  341.                     else
  342.                     {
  343.                         pKCF->bTrack = false;
  344.                         pKCF->bValid = false;
  345.                     }
  346.                 }
  347.             }
  348.             else
  349.             {
  350.                 pKCF->nMissFrame++;
  351.                 if (pKCF->nMissFrame > MAX_MISS_FRAME)
  352.                 {
  353.                     pKCF->bTrack = false;
  354.                     pKCF->bValid = false;
  355.                 }
  356.             }
  357.         }
  358.     }
  360.     for (j = 0; j < m_boxContainer.headCount; j++)
  361.     {
  362.         if (!bMatch[j])
  363.         {
  364.             HDRect *pHDRect = &m_boxContainer.candidates[j];
  365.             for (i = 0; i < MAX_TRACK_COUNT; i++)
  366.             {
  367.                 KCFTracker *pKCF = &m_pKCF[i];
  368.                 if (!pKCF->bTrack)
  369.                 {
  370.                     pKCF->nID = -1;// ++m_trackID;
  371.                     pKCF->nMissFrame = 0;
  372.                     pKCF->nTrackTimes = 0;
  373.                     pKCF->nMatchTimes = 0;
  374.                     pKCF->bValid = false;
  375.                     cv::Rect roiRect;
  376.                     roiRect.x = pHDRect->left;
  377.                     roiRect.y = pHDRect->top;
  378.                     roiRect.width = pHDRect->right - pHDRect->left;
  379.                     roiRect.height = pHDRect->bottom - pHDRect->top;
  380.                     pKCF->bTrack = true;
  381.                     pKCF->init(roiRect, image);
  382.                     break;
  383.                 }
  384.             }
  385.         }
  386.     }
  387. }
  389. int ZHeadTrack::pointInLineSide(cv::Point point, cv::Point lineStart, cv::Point lineEnd)
  390. {
  391.     int x0 = 0, x1 = 0;
  392.     int y0 = 0, y1 = 0;
  393.     int v0 = 0, v1 = 0;
  394.     bool bFlag = false;
  395.     bool bFlagX = false;
  396.     bool bFlagY = false;
  398.     x0 = lineStart.x;
  399.     x1 = lineEnd.x;
  400.     y0 = lineStart.y;
  401.     y1 = lineEnd.y;
  403.     先保证点在线段内
  404.     if (x0 > x1)
  405.     {
  406.         bFlagX = point.x > x1 && point.x < x0;
  407.     }
  408.     else
  409.     {
  410.         bFlagX = point.x <x1 && point.x >x0;
  411.     }
  413.     if (y0 > y1)
  414.     {
  415.         bFlagY = point.y > y1 && point.y < y0;
  416.     }
  417.     else
  418.     {
  419.         bFlagY = point.y <y1 && point.y >y0;
  420.     }
  422.     bFlag = bFlagX || bFlagY;
  423.     if (!bFlag)
  424.     {
  425.         return 0;
  426.     }
  428.     v0 = (point.x - x0)*(y1 - y0) - (point.y - y0)*(x1 - x0);
  429.     v1 = x1 - x0;
  431.     if (x1 - x0 == 0)
  432.     {
  433.         if (v0 < 0)
  434.         {
  435.             return -1;
  436.         }
  437.         else
  438.         {
  439.             return 1;
  440.         }
  441.     }
  442.     else
  443.     {
  444.         if (v0*v1 < 0)
  445.         {
  446.             return -1;
  447.         }
  448.         else
  449.         {
  450.             return 1;
  451.         }
  452.     }
  454.     return 0;
  455. }
  457. void ZHeadTrack::trackInOutStatistics()
  458. {
  459.     int i = 0, j = 0;
  461.     for (i = 0; i < MAX_TRACK_COUNT; i++)
  462.     {
  463.         ZTracker *pTracker = &m_pTrackers[i];
  464.         if (pTracker->bTrack && pTracker->nTrajCount > 20 && !pTracker->bStatOK)
  465.         {
  466.             连续确认跟踪起始点的方向
  467.             if (!pTracker->bInitDirection)
  468.             {
  469.                 int count0 = 0;
  470.                 for (j = 0; j < 10; j++)
  471.                 {
  472.                     int flag = pointInLineSide(pTracker->centres[j], m_lineStart, m_lineEnd);
  473.                     count0 += flag;
  474.                 }
  475.                 if (count0 > 0)
  476.                 {
  477.                     pTracker->nInitDirection = 1;
  478.                 }
  479.                 else
  480.                 {
  481.                     pTracker->nInitDirection = -1;
  482.                 }
  483.             }
  485.             跟踪过线需要连续确认
  486.             int count1 = 0;
  487.             for (j = pTracker->nTrajCount - 10; j < pTracker->nTrajCount - 1; j++)
  488.             {
  489.                 int flag = pointInLineSide(pTracker->centres[j], m_lineStart, m_lineEnd);
  490.                 if (flag != 0 && pTracker->nInitDirection != flag)
  491.                 {
  492.                     count1++;
  493.                 }
  494.             }
  496.             if (count1 > 6)
  497.             {
  498.                 if (pTracker->nInitDirection == m_nArrowStart)
  499.                 {
  500.                     m_InCount++;
  501.                 }
  502.                 else
  503.                 {
  504.                     m_OutCount++;
  505.                 }
  506.                 pTracker->bStatOK = true;
  507.             }
  508.         }
  509.     }
  510. }
  512. void ZHeadTrack::trackRegionStatistics()
  513. {
  514.     int i = 0, j = 0;
  516.     m_trackeRegion.currentCount = 0;
  517.     for (i = 0; i < MAX_TRACK_COUNT; i++)
  518.     {
  519.         ZTracker *pTracker = &m_pTrackers[i];
  520.         if (pTracker->bTrack && pTracker->nTrajCount > 5 && !pTracker->bStatOK)
  521.         {
  522.             m_trackeRegion.rect[m_trackeRegion.currentCount].id = pTracker->nID;
  523.             m_trackeRegion.rect[m_trackeRegion.currentCount].left = pTracker->curRect.x;
  524.             m_trackeRegion.rect[m_trackeRegion.currentCount].top = pTracker->curRect.y;
  525.             m_trackeRegion.rect[m_trackeRegion.currentCount].right = pTracker->curRect.x + pTracker->curRect.width;
  526.             m_trackeRegion.rect[m_trackeRegion.currentCount].bottom = pTracker->curRect.y + pTracker->curRect.height;
  527.             m_trackeRegion.currentCount++;
  528.             m_RegionCount++;
  529.             pTracker->bStatOK = true;
  530.         }
  531.     }
  532. }

效果展示：

跟踪的原理：

用yolo-tiny检测出来的结果，送到KCF跟踪 器中，连续匹配上两次，则确认为一个目标，之后采用tracking-by-detection的方式进行人头跟踪。

人头跟踪的demo（内涵KCF跟踪代码部分）：

链接：百度网盘 请输入提取码
提取码：dr2a

声明：本文内容由易百纳平台入驻作者撰写，文章观点仅代表作者本人，不代表易百纳立场。如有内容侵权或者其他问题，请联系本站进行删除。
风清扬
红包 点赞 收藏 评论 打赏
  • 分享
  • 举报
评论
0个
时间排序
内容存在敏感词
手气红包
    易百纳技术社区暂无数据
相关专栏
关于作者
风清扬

风清扬

暂无个性签名~

原创10
阅读1.1w
收藏1
点赞1
评论0
TA最新文章
打赏用户 共 0 位
我要创作
分享技术经验，可获取创作收益
分类专栏
热门专栏
置顶时间设置
结束时间
删除原因
  • 广告/SPAM
  • 恶意灌水
  • 违规内容
  • 文不对题
  • 重复发帖
打赏作者
易百纳技术社区
风清扬
您的支持将鼓励我继续创作！
打赏金额：
￥1易百纳技术社区
￥5易百纳技术社区
￥10易百纳技术社区
￥50易百纳技术社区
￥100易百纳技术社区
支付方式：
微信支付
支付宝支付
易百纳技术社区微信支付
易百纳技术社区
打赏成功!

感谢您的打赏，如若您也想被打赏，可前往 发表专栏 哦~

举报反馈

举报类型

  • 内容涉黄/赌/毒
  • 内容侵权/抄袭
  • 政治相关
  • 涉嫌广告
  • 侮辱谩骂
  • 其他

详细说明

审核成功

发布时间设置
立即发布
延迟发布
发布时间：
是否关联周任务-专栏模块
是
否

审核失败

失败原因
备注
拼手气红包 红包规则
祝福语
恭喜发财，大吉大利！
红包金额
元
红包最小金额不能低于5元
红包数量
个
红包数量范围10~50个
余额支付
当前余额：
可前往问答、专栏板块获取收益 去获取
取 消 确 定

小包子的红包

恭喜发财，大吉大利

红包规则
开

已领取20/40，共1.6元 红包规则

    易百纳技术社区