Zou XiKun / left_over

Commit 1bfead76831930393faebadb9f854e72fc475689

Authored by Zou XiKun
1 parent ef488d9a

update

Inline Side-by-side
Showing 4 changed files with 261 additions and 347 deletions
src/left_over/MSRegionSurveilance.cpp
  View file @1bfead7
... ... @@ -14,7 +14,7 @@ IRegionSurveillance *MS_RegionSurveillance::GetMS_RS()
14 14 return MS_RS;
15 15 else
16 16 {
17   - exit(0);
  17 + exit(0);
18 18 return NULL;
19 19 }
20 20 }
... ...
src/left_over/help.cpp
  View file @1bfead7
1 1 /*************************************************************
2 2 /* name: help.cpp
3   -/* Description: 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
4   -/* Purpose锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟较诧拷锟斤拷锟斤拷锟斤拷
5   -/* 1 锟斤拷锟斤拷邪锟斤拷锟叫★拷锟 2 锟津交诧拷 3 锟斤拷锟斤拷锟斤拷
  3 +/* Description: 辅助函数集合
  4 +/* Purpose：满足以下条件，合并两个框：
  5 +/* 1 大框中包含小框 2 框交叉 3 框相邻
6 6 /* Update Time: by zl 20160307
7 7 **************************************************************/
8 8 #include "help.h"
... ... @@ -11,7 +11,7 @@
11 11 #include <stdio.h>
12 12 #include <algorithm>
13 13 using namespace std;
14   -//锟斤拷锟斤拷
  14 +//排序
15 15 bool SortByPoint(const CForeground &C1,const CForeground &C2)
16 16 {
17 17 bool sign = false;
... ... @@ -28,7 +28,7 @@ bool SortByPoint(const CForeground &amp;C1,const CForeground &amp;C2)
28 28 return false;
29 29 }
30 30  
31   -//锟接达拷小
  31 +//从大到小
32 32 bool SortByArea(const CForeground &C1, const CForeground &C2)
33 33 {
34 34 bool sign = false;
... ... @@ -38,7 +38,7 @@ bool SortByArea(const CForeground &amp;C1, const CForeground &amp;C2)
38 38 return false;
39 39 }
40 40  
41   -//锟叫讹拷x锟角凤拷锟节边斤拷锟斤拷
  41 +//判断x是否在边界内
42 42 bool InRange(int x, int boundary1, int boundary2)
43 43 {
44 44 int max_b = boundary1 >= boundary2 ? boundary1 : boundary2;
... ... @@ -49,33 +49,33 @@ bool InRange(int x, int boundary1, int boundary2)
49 49 return false;
50 50 }
51 51  
52   -//锟斤拷锟节伙拷锟竭帮拷锟斤拷
  52 +//相邻或者包含
53 53 bool NeighbourorSub(CForeground c1, CForeground c2)
54 54 {
55   - //c2锟斤拷锟侥碉拷锟斤拷c1锟节诧拷 锟斤拷要锟较诧拷 锟斤拷锟斤拷true
  55 + //c2中心点在c1内部 需要合并 返回true
56 56 /*if (c2.m_ptCenter.x < c1.m_rtConnect.right && InRange(c2.m_ptCenter.y, c1.m_rtConnect.top, c1.m_rtConnect.bottom))
57 57 return true;
58 58 else */
59   - //锟斤拷锟斤拷锟斤拷锟斤拷为c2一锟斤拷锟斤拷c1锟斤拷锟揭诧拷 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟竭帮拷锟斤拷 c2锟斤拷锟斤拷锟铰碉拷 锟斤拷锟斤拷 锟斤拷锟较碉拷 锟较讹拷锟斤拷锟斤拷锟斤拷一锟斤拷锟斤拷c1锟斤拷锟节诧拷
  59 + //输入条件为c2一定在c1的右侧 因此若交叉或者包含 c2的左下点 或者 右上点 肯定至少有一个在c1的内部
60 60 if (c2.m_rtConnect.left <= c1.m_rtConnect.right)
61 61 {
62   - //锟斤拷锟斤拷锟斤拷锟竭斤拷锟斤拷
  62 + //包含或者交叉
63 63 if (InRange(c2.m_rtConnect.bottom, c1.m_rtConnect.top, c1.m_rtConnect.bottom) || InRange(c2.m_rtConnect.top, c1.m_rtConnect.top, c1.m_rtConnect.bottom))
64 64 return true;
65   - //锟较凤拷锟节斤拷 锟斤拷锟斤拷 锟铰凤拷锟节斤拷
  65 + //上方邻近 或者 下方邻近
66 66 else if (abs(c1.m_rtConnect.top - c2.m_rtConnect.bottom) < MergeMinDistance || abs(c1.m_rtConnect.bottom - c2.m_rtConnect.top) < MergeMinDistance)
67 67 return true;
68 68 }
69 69 else if (InRange(c2.m_rtConnect.bottom, c1.m_rtConnect.top, c1.m_rtConnect.bottom) || InRange(c2.m_rtConnect.top, c1.m_rtConnect.top, c1.m_rtConnect.bottom))
70 70 {
71   - if((abs(c1.m_rtConnect.right - c2.m_rtConnect.left) < MergeMinDistance)) //c2 锟斤拷 c1 锟揭诧拷 锟节斤拷
  71 + if((abs(c1.m_rtConnect.right - c2.m_rtConnect.left) < MergeMinDistance)) //c2 在 c1 右侧 邻近
72 72 return true;
73 73 }
74 74  
75 75 return false;
76 76 }
77 77  
78   -//锟较诧拷
  78 +//合并
79 79 void MergeNeighborBox(vector<CForeground> &ForegroundArray)
80 80 {
81 81 vector<CForeground>::iterator iter1 = ForegroundArray.begin();
... ... @@ -84,23 +84,23 @@ void MergeNeighborBox(vector&lt;CForeground&gt; &amp;ForegroundArray)
84 84 vector<CForeground>::iterator iter2 = iter1 + 1;
85 85 for (; iter2 != ForegroundArray.end(); )
86 86 {
87   - //if ((x2 <= iter1->m_rtConnect.right && y2 <= iter1->m_rtConnect.bottom && y2 >= iter1->m_rtConnect.top) || //锟斤拷锟叫★拷锟阶达拷锟
88   - // (iter2->m_rtConnect.left <= iter1->m_rtConnect.right && iter2->m_rtConnect.bottom <= iter1->m_rtConnect.bottom && iter2->m_rtConnect.bottom >= iter1->m_rtConnect.top) || //锟津交诧拷 锟斤拷锟较斤拷锟节碉拷一锟斤拷锟斤拷锟斤拷
89   - // (iter2->m_rtConnect.left <= iter1->m_rtConnect.right && iter2->m_rtConnect.top <= iter1->m_rtConnect.bottom && iter2->m_rtConnect.top >= iter1->m_rtConnect.top) ||//锟津交诧拷 锟斤拷锟铰斤拷锟节碉拷一锟斤拷锟斤拷锟斤拷
90   - // iter2->m_rtConnect.left <= iter1->m_ptCenter.x && abs(iter2->m_rtConnect.bottom - iter1->m_rtConnect.top) < 10 ||//锟斤拷锟斤拷辖锟斤拷锟
  87 + //if ((x2 <= iter1->m_rtConnect.right && y2 <= iter1->m_rtConnect.bottom && y2 >= iter1->m_rtConnect.top) || //大框含小框状况
  88 + // (iter2->m_rtConnect.left <= iter1->m_rtConnect.right && iter2->m_rtConnect.bottom <= iter1->m_rtConnect.bottom && iter2->m_rtConnect.bottom >= iter1->m_rtConnect.top) || //框交叉 左上角在第一个框内
  89 + // (iter2->m_rtConnect.left <= iter1->m_rtConnect.right && iter2->m_rtConnect.top <= iter1->m_rtConnect.bottom && iter2->m_rtConnect.top >= iter1->m_rtConnect.top) ||//框交叉 左下角在第一个框内
  90 + // iter2->m_rtConnect.left <= iter1->m_ptCenter.x && abs(iter2->m_rtConnect.bottom - iter1->m_rtConnect.top) < 10 ||//距离较近的
91 91 // iter2->m_rtConnect.left <= iter1->m_ptCenter.x && abs(iter2->m_rtConnect.top - iter1->m_rtConnect.bottom) < 10 ||
92   - // distance < 20 //锟斤拷锟斤拷辖锟斤拷锟
  92 + // distance < 20 //距离较近的
93 93 // )
94 94 if (NeighbourorSub(*iter1, *iter2))
95 95 {
96   - //锟较诧拷
  96 + //合并
97 97 iter1->m_rtConnect.left = min(iter1->m_rtConnect.left, iter2->m_rtConnect.left);
98 98 iter1->m_rtConnect.bottom = max(iter1->m_rtConnect.bottom, iter2->m_rtConnect.bottom);
99 99 iter1->m_rtConnect.right = max(iter1->m_rtConnect.right, iter2->m_rtConnect.right);
100 100 iter1->m_rtConnect.top = min(iter1->m_rtConnect.top, iter2->m_rtConnect.top);
101 101 iter1->m_ptCenter.x = (iter1->m_rtConnect.right + iter1->m_rtConnect.left) / 2;
102 102 iter1->m_ptCenter.y = (iter1->m_rtConnect.bottom + iter1->m_rtConnect.top) / 2;
103   - //删锟斤拷一锟斤拷
  103 + //删除一个
104 104 iter2 = ForegroundArray.erase(iter2);
105 105 iter1 = iter2;
106 106 iter1--;
... ... @@ -108,8 +108,8 @@ void MergeNeighborBox(vector&lt;CForeground&gt; &amp;ForegroundArray)
108 108 else
109 109 iter2++;
110 110 //else
111   - // break; //锟斤拷锟斤拷ForegroundArray锟斤拷x锟斤拷锟斤拷锟斤拷锟斤拷 锟斤拷锟斤拷锟斤拷为锟斤拷锟斤拷锟角帮拷锟斤拷院喜锟斤拷锟斤拷锟斤拷锌锟斤拷锟斤拷锟揭伙拷锟揭诧拷锟揭拷喜锟斤拷锟
112   - //锟斤拷锟斤拷锟斤拷前锟斤拷锟斤拷锟较合诧拷 锟斤拷锟斤拷一锟斤拷也锟斤拷锟斤拷锟斤拷希锟轿拷思锟斤拷偌锟斤拷锟斤拷锟斤拷锟斤拷
  111 + // break; //由于ForegroundArray按x坐标排列 所以认为如果当前可以合并，则有可能下一个也需要合并；
  112 + //但若当前不符合合并 则下一个也不会符合（为了减少计算次数）
113 113  
114 114 }
115 115 }
... ... @@ -125,9 +125,9 @@ int checkTime()
125 125 nYear = info->tm_year + 1900;
126 126 nMonth = info->tm_mon + 1;
127 127 nDay = info->tm_mday;
128   - if (nYear != 2021)//2017锟斤拷1锟斤拷1锟秸版本锟斤拷锟斤拷
  128 + if (nYear != 2021)//2017??1??1??汾????
129 129 {
130   - printf("锟芥本锟斤拷锟节ｏ拷\n");
  130 + printf("版本过期！\n");
131 131 return -1;
132 132 }
133 133 else
... ...
src/left_over/left_over_det.h
  View file @1bfead7
... ... @@ -117,7 +117,7 @@ typedef struct ms_trace {
117 117 ms_trace trace; // 轨迹及报警状态
118 118 int unique_id; // 当前目标的特点ID
119 119 sy_rect tar_box; // 目标外接矩形
120   - float confidence; // 置信度
  120 + float confidence; // 置信度
121 121 bool pb_alarm_state[MAXROINUM]; // 对应区域是否报警
122 122 int pb_alarm_type[MAXROINUM]; // 对应区域是哪种报警
123 123 }ms_object_info;
... ...
src/left_over/svibe.cpp
  View file @1bfead7
1   -// svibe.cpp : 锟斤拷锟斤拷锟斤拷锟教ㄓ︼拷贸锟斤拷锟斤拷锟斤拷诘恪
  1 +// svibe.cpp : 定义控制台应用程序的入口点。
2 2 #include <stdio.h>
3 3 #include <stddef.h>
4 4 #include "svibe.h"
... ... @@ -13,20 +13,20 @@
13 13 #include "help.h"
14 14 #include "left_over_det.h"
15 15 /************************************************************************/
16   -/* 锟斤拷锟斤拷: get_ArrowDir() by zl */
17   -/* 锟斤拷锟斤拷: 锟斤拷取锟斤拷锟斤拷锟斤拷锟斤拷诨锟斤拷萍锟酵凤拷锟斤拷锟斤拷锟斤拷说悖 */
18   -/* 锟斤拷锟斤拷: pROI0&pROI1锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟剿点； */
19   -/* dir锟斤拷确锟斤拷锟斤拷锟津警憋拷锟斤拷锟斤拷锟斤拷锟斤拷锟姐； */
20   -/* 锟斤拷锟斤拷: 1:锟斤拷锟斤拷锟斤拷0:锟斤拷锟斤拷锟斤拷 */
  16 +/* 函数: get_ArrowDir() by zl */
  17 +/* 作用: 获取方向和用于绘制箭头的两个端点； */
  18 +/* 参数: pROI0&pROI1：拌线两个端点； */
  19 +/* dir：确定单向警报方向的坐标点； */
  20 +/* 返回: 1:正方向；0:负方向 */
21 21 /************************************************************************/
22 22 int RegionSurveillance::get_ArrowDir(CMPoint pROI0, CMPoint pROI1, CMPoint dir)
23 23 {
24 24  
25 25 float distance = (float)abs(pROI0.y - pROI1.y);
26   - //锟斤拷取锟斤拷锟斤拷
27   - float k1, k2; //k1为原锟竭段碉拷斜锟斤拷
  26 + //获取方向
  27 + float k1, k2; //k1为原线段的斜率
28 28  
29   - if (pROI0.y > pROI1.y) //锟节帮拷锟竭匡拷锟斤拷图锟斤拷锟铰凤拷锟侥端点处锟斤拷锟斤拷头
  29 + if (pROI0.y > pROI1.y) //在拌线靠近图像下方的端点处画箭头
30 30 {
31 31 pStart.x = pROI0.x;
32 32 pStart.y = pROI0.y;
... ... @@ -37,18 +37,18 @@ int RegionSurveillance::get_ArrowDir(CMPoint pROI0, CMPoint pROI1, CMPoint dir)
37 37 pStart.y = pROI1.y;
38 38 }
39 39  
40   - if (pROI0.x != pROI1.x) //锟斤拷锟斤拷为一锟斤拷锟斤拷直锟斤拷
  40 + if (pROI0.x != pROI1.x) //若不为一根垂直线
41 41 {
42 42 k1 = (float)(pROI0.y - pROI1.y) / (float)(pROI0.x - pROI1.x);
43   - if (k1 != 0) //锟斤拷锟斤拷为一锟斤拷平锟斤拷锟斤拷
  43 + if (k1 != 0) //若不为一根平行线
44 44 {
45 45 k2 = -1 / k1;
46 46  
47 47  
48   - float b = pROI1.y - k1 * pROI1.x;//y = kx + b 锟斤拷锟斤拷系一图锟斤拷锟斤拷锟较讹拷锟斤拷为原锟姐，锟斤拷锟斤拷为x锟斤拷锟斤拷锟斤拷 锟斤拷锟斤拷为y锟斤拷锟斤拷锟斤拷
  48 + float b = pROI1.y - k1 * pROI1.x;//y = kx + b 坐标系一图像左上顶点为原点，向右为x正方形 向下为y正方向
49 49 if ((k1 < 0 && (float)((float)dir.y - k1 * (float)dir.x - b) < 0)||(k1 > 0 && (float)((float)dir.y - k1 * (float)dir.x - b) > 0))
50 50 {
51   - if (distance < 30) //锟斤拷锟斤拷锟斤拷y值锟斤拷锟斤拷锟叫∈憋拷锟斤拷锟斤拷弑冉隙锟 锟斤拷锟斤拷去20 锟斤拷锟杰碉拷锟铰硷拷头太锟斤拷
  51 + if (distance < 30) //当两点y值差异较小时，垂线比较陡 若减去20 可能导致箭头太长
52 52 {
53 53 pEnd.x = pStart.x - 2;
54 54 }
... ... @@ -66,7 +66,7 @@ int RegionSurveillance::get_ArrowDir(CMPoint pROI0, CMPoint pROI1, CMPoint dir)
66 66 }
67 67 pEnd.y = (int)((pEnd.x - pStart.x) * k2 + pStart.y);
68 68 }
69   - else //锟斤拷为水平锟斤拷
  69 + else //若为水平线
70 70 {
71 71 pEnd.x = pStart.x;
72 72 if (dir.y > pStart.y)
... ... @@ -77,7 +77,7 @@ int RegionSurveillance::get_ArrowDir(CMPoint pROI0, CMPoint pROI1, CMPoint dir)
77 77 }
78 78  
79 79 }
80   - else //锟斤拷为锟斤拷直锟斤拷
  80 + else //若为垂直线
81 81 {
82 82 pEnd.y = pStart.y;
83 83 if (dir.x > pStart.x)
... ... @@ -85,20 +85,20 @@ int RegionSurveillance::get_ArrowDir(CMPoint pROI0, CMPoint pROI1, CMPoint dir)
85 85 else
86 86 pEnd.x = pStart.x - 20;
87 87 }
88   - //锟斤拷止越锟斤拷
  88 + //防止越界
89 89 pEnd.x = pEnd.x >= 0 ? pEnd.x : 0;
90 90 pEnd.x = pEnd.x <= GlobelWidth ? pEnd.x : GlobelWidth;
91 91 pEnd.y = pEnd.y >= 0 ? pEnd.y : 0;
92 92 pEnd.y = pEnd.y <= GlobelHeight ? pEnd.y : GlobelHeight;
93 93  
94   - if (pROI0.x == pROI1.x) //锟斤拷为锟斤拷直锟斤拷
  94 + if (pROI0.x == pROI1.x) //若为垂直线
95 95 {
96 96 if (pEnd.x > pStart.x)
97 97 return 1;
98 98 else
99 99 return 0;
100 100 }
101   - else if (k1 <= 0) //锟斤拷锟斤拷为锟斤拷直锟斤拷锟斤拷斜锟斤拷小锟节碉拷锟斤拷0锟斤拷锟斤拷水平锟斤拷锟斤拷锟斤拷锟
  101 + else if (k1 <= 0) //若不为垂直线且斜率小于等于0（含水平线情况）
102 102 {
103 103 if ((pStart.x != pEnd.x && pEnd.x > pStart.x) || (pStart.x == pEnd.x && pEnd.y > pStart.y))
104 104 return 0;
... ... @@ -116,26 +116,26 @@ int RegionSurveillance::get_ArrowDir(CMPoint pROI0, CMPoint pROI1, CMPoint dir)
116 116  
117 117 /******************************************************************************
118 118 * Function: RSinit
119   -* Description: MaskImgData锟节达拷锟斤拷浼癡IBE 模锟酵筹拷始锟斤拷
  119 +* Description: MaskImgData内存非配及VIBE 模型初始化
120 120 * Calls: VibeModelInitC3
121 121 * Called By: main
122   -* Input: nWidth 图锟斤拷锟斤拷锟
123   - nHeight 图锟斤拷叨锟
124   - frameImgData 图锟斤拷RGB
125   -* Output: vbM VIBE 模锟斤拷
126   -* Return: 0 锟斤拷锟斤拷通锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷 1 锟斤拷锟斤拷
  122 +* Input: nWidth 图像宽度
  123 + nHeight 图像高度
  124 + frameImgData 图像RGB
  125 +* Output: vbM VIBE 模型
  126 +* Return: 0 输入通道参数不合理 1 正常
127 127 *******************************************************************************/
128 128  
129 129 int RegionSurveillance::RSinit(int nWidth, int nHeight, int widthstep, unsigned char* frameImgData,
130 130 int nChannel, int nChannel_deal, bool nfiltFlag, int maxObjNum, int minArea, int maxArea)
131 131 {
132 132 macDetectObjNum = maxObjNum;
133   - if(nWidth < 600 || nHeight < 300) //锟斤拷锟斤拷叽锟斤拷小 锟睫革拷vibe锟斤拷锟斤拷
  133 + if(nWidth < 600 || nHeight < 300) //???????С ???vibe????
134 134 VBPARAM = new VIBEPARAM(35, 18);
135 135 else
136 136 VBPARAM = new VIBEPARAM(20, 35);
137 137  
138   - //checkMID锟斤拷锟斤拷锟斤拷锟斤拷锟缴硷拷锟 by zl
  138 + //checkMID???????????? by zl
139 139 if (/*checkMIDkeySet() == -1 */ /*checkTime() == -1 || */(nChannel != 1 && nChannel != 3) || (nChannel_deal != 1 && nChannel_deal != 3) || (nChannel_deal > nChannel))
140 140 {
141 141 return 0;
... ... @@ -147,8 +147,8 @@ int RegionSurveillance::RSinit(int nWidth, int nHeight, int widthstep, unsigned
147 147 GlobelHeight = nHeight;
148 148 GlobelWidthstep = widthstep;
149 149 gfiltFlag = nfiltFlag;
150   - OBJECT_AREA_MIN = minArea; //默锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟轿,000,000 by zl 20160304
151   - OBJECT_AREA_MAX = maxArea; //默锟斤拷锟斤拷小锟斤拷锟斤拷锟斤拷锟轿00 by zl 20160304
  150 + OBJECT_AREA_MIN = minArea; //默认最大过滤面积为1,000,000 by zl 20160304
  151 + OBJECT_AREA_MAX = maxArea; //默认最小过滤面积为300 by zl 20160304
152 152 /*
153 153 int widthstep = nWidth * 3;
154 154 if (widthstep % 4)
... ... @@ -164,12 +164,12 @@ int RegionSurveillance::RSinit(int nWidth, int nHeight, int widthstep, unsigned
164 164 memset(MaskImgCfd, 0, sizeof(float)* GlobelWidth * GlobelHeight);
165 165 if (!vbM)
166 166 {
167   - // 锟斤拷始锟斤拷模锟斤拷
  167 + // 初始化模型
168 168 if (nChannel == 3)
169 169 {
170 170 if (nChannel_deal == 3)
171 171 {
172   - // 锟斤拷斯模锟斤拷
  172 + // 高斯模糊
173 173 if (nfiltFlag == 1)
174 174 {
175 175 unsigned char* inputData = NULL;
... ... @@ -207,10 +207,10 @@ int RegionSurveillance::RSinit(int nWidth, int nHeight, int widthstep, unsigned
207 207 {
208 208 greyImgData = (unsigned char*) malloc(sizeof(unsigned char*) * GlobelWidth * nHeight);
209 209 memset(greyImgData, 0, sizeof(unsigned char*));
210   - // 锟斤拷RGB图锟斤拷转锟斤拷为锟揭讹拷图锟斤拷
  210 + // 将RGB图像转换为灰度图像
211 211 VibeRGBToGray(frameImgData, greyImgData);
212 212  
213   - // 锟斤拷斯模锟斤拷
  213 + // 高斯模糊
214 214 if (nfiltFlag == 1)
215 215 {
216 216 unsigned char* inputData = NULL;
... ... @@ -241,7 +241,7 @@ int RegionSurveillance::RSinit(int nWidth, int nHeight, int widthstep, unsigned
241 241 }
242 242 else
243 243 {
244   - // 锟斤拷斯模锟斤拷
  244 + // 高斯模糊
245 245 if (nfiltFlag == 1)
246 246 {
247 247 unsigned char* inputData = NULL;
... ... @@ -272,10 +272,10 @@ int RegionSurveillance::RSinit(int nWidth, int nHeight, int widthstep, unsigned
272 272 }
273 273 }
274 274  
275   - left_flag = 1; // 锟斤拷锟斤拷锟斤拷志 0 锟斤拷锟斤拷 1锟狡筹拷
  275 + left_flag = 1; // 逗留标志 0 遗留 1移除
276 276  
277   - maskImg = new unsigned char[nWidth*nHeight]; //锟斤拷锟酵和革拷蚀 锟斤拷锟斤拷锟斤拷
278   - memset(maskImg, 0, sizeof(maskImg[0])*nWidth*nHeight); //锟斤拷锟酵和革拷蚀 锟斤拷锟斤拷锟斤拷
  277 + maskImg = new unsigned char[nWidth*nHeight]; //膨胀和腐蚀 加速用
  278 + memset(maskImg, 0, sizeof(maskImg[0])*nWidth*nHeight); //膨胀和腐蚀 加速用
279 279  
280 280 return 1;
281 281 }
... ... @@ -319,17 +319,17 @@ VibeModel_t * RegionSurveillance::VibeModelInitC1(uint8_t *image_data)
319 319  
320 320 /******************************************************************************
321 321 * Function: VibeModelInitC3
322   -* Description: VIBE模锟酵筹拷始锟斤拷
  322 +* Description: VIBE模型初始化
323 323 * Calls: RandInit
324 324 RandNeighborInit
325 325 GetRandNeighborXY
326 326 * Called By: RSinit
327   -* Input: image_data 图锟斤拷RGB
  327 +* Input: image_data 图像RGB
328 328 * Output: g_XNeighborTable 22100012
329 329 g_YNeighborTable 10001222
330   - g_randTable 65536锟斤拷锟斤拷锟斤拷锟
331   - g_XTable 0 0 1 2 3 ... 锟斤拷锟斤拷-1 锟斤拷锟斤拷-1
332   - g_YTable 0 0 1 2 3 ... 锟竭讹拷-1 锟竭讹拷-1
  330 + g_randTable 65536个随机数
  331 + g_XTable 0 0 1 2 3 ... 宽度-1 宽度-1
  332 + g_YTable 0 0 1 2 3 ... 高度-1 高度-1
333 333 * Return: vbM
334 334 *******************************************************************************/
335 335 VibeModel_t* RegionSurveillance::VibeModelInitC3(uint8_t *image_data)
... ... @@ -449,11 +449,11 @@ void RegionSurveillance::VibeModelUpdateC1(VibeModel_t *model, uint8_t *image, u
449 449 }// end of for y loop
450 450  
451 451  
452   - VibeModelDilation2(output, maskImg, model->width, model->height);// 锟斤拷锟斤拷
453   - VibeModelErosion2(maskImg, output, model->width, model->height);// 锟斤拷蚀
454   - //未锟斤拷锟劫版本
455   - //VibeModelDilation(output, model->width, model->height);// 锟斤拷锟斤拷
456   - //VibeModelErosion(output, model->width, model->height);// 锟斤拷蚀
  452 + VibeModelDilation2(output, maskImg, model->width, model->height);// 膨胀
  453 + VibeModelErosion2(maskImg, output, model->width, model->height);// 腐蚀
  454 + //未加速版本
  455 + //VibeModelDilation(output, model->width, model->height);// 膨胀
  456 + //VibeModelErosion(output, model->width, model->height);// 腐蚀
457 457  
458 458  
459 459 g_frameCount++;
... ... @@ -462,16 +462,16 @@ void RegionSurveillance::VibeModelUpdateC1(VibeModel_t *model, uint8_t *image, u
462 462  
463 463 /******************************************************************************
464 464 * Function: VibeModelUpdateC3
465   -* Description: VIBE模锟酵革拷锟斤拷
  465 +* Description: VIBE模型更新
466 466 * Calls: GetRand
467 467 GetRandNeighborXY
468 468 VibeModelDilation
469 469 VibeModelErosion
470 470 * Called By: RSDetect
471   -* Input: model VBM 模锟斤拷
472   - image 图锟斤拷RGB
473   -* Output: output 前锟斤拷锟斤拷255 锟斤拷锟斤拷锟斤拷0
474   - model VBM 模锟斤拷
  471 +* Input: model VBM 模型
  472 + image 图像RGB
  473 +* Output: output 前景是255 背景是0
  474 + model VBM 模型
475 475 *******************************************************************************/
476 476 void RegionSurveillance::VibeModelUpdateC3(VibeModel_t *model, uint8_t *image, uint8_t *output)
477 477 {
... ... @@ -487,10 +487,10 @@ void RegionSurveillance::VibeModelUpdateC3(VibeModel_t *model, uint8_t *image, u
487 487 {
488 488 for (x = 0; x < model->width; x++)
489 489 {
490   - // 锟斤拷前锟斤拷锟接︼拷锟侥ｏ拷锟斤拷械锟斤拷锟斤拷锟
  490 + // 当前点对应的模板中的索引
491 491 sampleOffset = ((y * model-> width * model->nSample + x * model->nSample) << 1) + (y * model-> width * model->nSample + x * model->nSample);
492 492  
493   - // 锟斤拷前锟斤拷锟接︼拷锟絉GB锟叫碉拷锟斤拷锟斤拷
  493 + // 当前点对应的RGB中的索引
494 494 imageOffset = ((y * model->width + x) << 1) + (y * model->width + x);
495 495  
496 496 // if (imageOffset>=(model->width * model->height))
... ... @@ -500,7 +500,7 @@ void RegionSurveillance::VibeModelUpdateC3(VibeModel_t *model, uint8_t *image, u
500 500 count = 0;
501 501 index = 0;
502 502  
503   - // 锟斤拷锟斤拷锟角帮拷锟斤拷锟斤拷锟街碉拷牡锟斤拷锟叫★拷诠娑ㄆワ拷锟斤拷锟斤拷 锟斤拷 锟斤拷前锟斤拷锟斤拷锟侥碉拷锟斤拷小锟斤拷20锟斤拷锟斤拷
  503 + // 如果当前满足阈值的点数小于规定匹配点数 且 当前评估的点数小于20个点
504 504 while ((count < model->nMatch) && (index < model->nSample))
505 505 {
506 506 //Euclidean distance computation
... ... @@ -508,10 +508,10 @@ void RegionSurveillance::VibeModelUpdateC3(VibeModel_t *model, uint8_t *image, u
508 508 dist = (double)((image[imageOffset] - model->bg_samples[tmpValue ])*(image[imageOffset] - model->bg_samples[tmpValue])) +
509 509 (double)((image[imageOffset + 1] - model->bg_samples[tmpValue + 1])*(image[imageOffset + 1] - model->bg_samples[tmpValue+ 1])) +
510 510 (double)((image[imageOffset + 2] - model->bg_samples[tmpValue + 2])*(image[imageOffset + 2] - model->bg_samples[tmpValue + 2]));
511   - // 锟斤拷通锟斤拷锟斤拷锟斤拷锟斤拷锟街拷锟
  511 + // 三通道计算距离之和
512 512 //dist = abs(image[imageOffset] - model->bg_samples[tmpValue]) + abs(image[imageOffset + 1] - model->bg_samples[tmpValue + 1])
513 513 //+ abs(image[imageOffset + 2] - model->bg_samples[tmpValue + 2]);
514   - // 锟斤拷锟斤拷锟斤拷值锟斤拷锟斤拷锟侥碉拷
  514 + // 满足阈值条件的点
515 515 if (dist < model->threshold * model->threshold * 3)
516 516 {
517 517 count++;
... ... @@ -520,22 +520,22 @@ void RegionSurveillance::VibeModelUpdateC3(VibeModel_t *model, uint8_t *image, u
520 520 index++;
521 521 }
522 522  
523   - // 锟斤拷锟斤拷锟角帮拷锟轿帮拷锟
  523 + // 如果当前点为前景
524 524 if (count < model->nMatch)
525 525 {
526 526 output[y * model->width + x] = VBPARAM->DEFAULT_COLOR_FOREGROUND;
527 527  
528   - // 前20帧锟斤拷锟斤拷模锟斤拷锟斤拷息
  528 + // 前20帧增加模板信息
529 529 if (g_frameCount < model->nSample)
530 530 {
531   - // 锟斤拷锟斤拷锟斤拷碌锟角帮拷锟斤拷应锟斤拷模锟斤拷锟叫碉拷某一锟斤拷锟斤拷
  531 + // 随机更新当前点对应的模板中的某一背景
532 532 rand = GetRand() % (model->nSample);
533 533 tmpValue = sampleOffset + ((rand << 1) +rand );
534 534 model->bg_samples[tmpValue] = image[imageOffset];
535 535 model->bg_samples[tmpValue + 1] = image[imageOffset + 1];
536 536 model->bg_samples[tmpValue + 2] = image[imageOffset + 2];
537 537  
538   - // 同时锟斤拷锟斤拷缘锟角帮拷锟斤拷某一锟斤拷锟斤拷锟节碉拷锟接︼拷锟侥ｏ拷锟斤拷械锟斤拷锟斤拷一锟斤拷锟斤拷锟斤拷锟叫革拷锟斤拷
  538 + // 同时随机对当前点的某一个相邻点对应的模板中的随机一背景进行更新
539 539 GetRandNeighborXY(x, y, &xNG, &yNG);
540 540 rand = GetRand() % (model->nSample);
541 541 tmpValue = ((yNG * model->width * model->nSample + xNG * model->nSample + rand) << 1)+ (yNG * model->width * model->nSample + xNG * model->nSample + rand);
... ... @@ -545,12 +545,12 @@ void RegionSurveillance::VibeModelUpdateC3(VibeModel_t *model, uint8_t *image, u
545 545 }
546 546 }
547 547  
548   - // 锟斤拷锟斤拷锟角帮拷锟轿拷锟斤拷锟
  548 + // 如果当前点为背景
549 549 else
550 550 {
551 551 output[y * model->width + x] = VBPARAM->DEFAULT_COLOR_BACKGROUND;
552 552  
553   - // 锟斤拷前20帧锟斤拷锟斤拷VIBE模锟斤拷锟斤拷拢锟酵帮拷锟斤拷锟
  553 + // 对前20帧进行VIBE模板更新（同前景）
554 554 if (g_frameCount < model->nSample)
555 555 {
556 556 //curr
... ... @@ -582,7 +582,7 @@ void RegionSurveillance::VibeModelUpdateC3(VibeModel_t *model, uint8_t *image, u
582 582 }
583 583  
584 584 //update neighboring pixel model
585   - // 锟斤拷锟斤拷锟斤拷锟斤拷锟脚斤拷锟叫憋拷锟斤拷锟斤拷锟铰ｏ拷为锟斤拷锟斤拷锟劫ｏ拷
  585 + // 满足条件才进行背景更新（为了提速）
586 586 rand = GetRand() % (model->upSpeed);
587 587 if (rand == 0 && left_flag == 1)
588 588 {
... ... @@ -606,11 +606,11 @@ void RegionSurveillance::VibeModelUpdateC3(VibeModel_t *model, uint8_t *image, u
606 606 }// end of for y loop
607 607  
608 608  
609   - //VibeModelDilation(output, model->width, model->height); // 锟斤拷锟斤拷
610   - //VibeModelErosion(output, model->width, model->height);// 锟斤拷蚀
  609 + //VibeModelDilation(output, model->width, model->height); // 膨胀
  610 + //VibeModelErosion(output, model->width, model->height);// 腐蚀
611 611  
612   - VibeModelDilation2(output, maskImg, model->width, model->height); // 锟斤拷锟斤拷 锟斤拷锟斤拷
613   - VibeModelErosion2(maskImg, output, model->width, model->height); // 锟斤拷锟斤拷 锟斤拷锟斤拷
  612 + VibeModelDilation2(output, maskImg, model->width, model->height); // 加速 膨胀
  613 + VibeModelErosion2(maskImg, output, model->width, model->height); // 加速 膨胀
614 614  
615 615 //VibeModelErosion(output,model->width,model->height);
616 616  
... ... @@ -629,11 +629,11 @@ void RegionSurveillance::RSDetect(unsigned char* frameImgData, RegionInfo* pRegi
629 629 }
630 630 */
631 631  
632   - // 锟斤拷玫锟角爸★拷锟角帮拷锟斤拷捅锟斤拷锟斤拷锟角帮拷锟55 锟斤拷锟斤拷0锟斤拷同时锟斤拷VIBE模锟斤拷锟斤拷懈锟斤拷锟
  632 + // 获得当前帧的前景和背景（前景255 背景0）同时对VIBE模板进行更新
633 633 //VibeModelUpdateC3(vbM, frameImgData, greyImgData, MaskImgData);
634 634 if (vbM->nChannel == 3)
635 635 {
636   - // 锟斤拷斯模锟斤拷
  636 + // 高斯模糊
637 637 if (gfiltFlag == 1)
638 638 {
639 639 unsigned char* inputData = NULL;
... ... @@ -671,10 +671,10 @@ void RegionSurveillance::RSDetect(unsigned char* frameImgData, RegionInfo* pRegi
671 671 {
672 672 if (channel_num == 3)
673 673 {
674   - // 锟斤拷RGB图锟斤拷转锟斤拷为锟揭讹拷图锟斤拷
  674 + // 将RGB图像转换为灰度图像
675 675 VibeRGBToGray(frameImgData, greyImgData);
676 676  
677   - // 锟斤拷斯模锟斤拷
  677 + // 高斯模糊
678 678 if (gfiltFlag == 1)
679 679 {
680 680 unsigned char* inputData = NULL;
... ... @@ -705,7 +705,7 @@ void RegionSurveillance::RSDetect(unsigned char* frameImgData, RegionInfo* pRegi
705 705 }
706 706 else
707 707 {
708   - // 锟斤拷斯模锟斤拷
  708 + // 高斯模糊
709 709 if (gfiltFlag == 1)
710 710 {
711 711 unsigned char* inputData = NULL;
... ... @@ -739,7 +739,7 @@ void RegionSurveillance::RSDetect(unsigned char* frameImgData, RegionInfo* pRegi
739 739  
740 740  
741 741 /*
742   - // 锟斤拷示锟斤拷值图锟斤拷
  742 + // 显示二值图像
743 743 CvSize a;
744 744 a.width = GlobelWidth;
745 745 a.height = GlobelHeight;
... ... @@ -756,12 +756,12 @@ void RegionSurveillance::RSDetect(unsigned char* frameImgData, RegionInfo* pRegi
756 756  
757 757 /******************************************************************************
758 758 * Function: VibeModelDilation
759   -* Description: VIBE模锟斤拷锟斤拷锟酵ｏ拷锟斤拷锟斤拷锟角帮拷锟轿帮拷锟斤拷锟斤拷叩锟角帮拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷一锟斤拷为前锟斤拷锟斤拷锟斤拷前锟斤拷位前锟斤拷锟斤拷
  759 +* Description: VIBE模型膨胀（如果当前点为前景或者当前点的邻域中有一个为前景，则当前点位前景）
760 760 * Called By: VibeModelUpdateC3
761   -* Input: inputdata 锟斤拷前图锟斤拷前锟斤拷锟斤拷锟斤拷锟斤拷前锟斤拷为255 锟斤拷锟斤拷为0锟斤拷
762   - width 图锟斤拷锟斤拷锟
763   - height 图锟斤拷叨锟
764   -* Output: inputdata 锟斤拷锟酵猴拷前图锟斤拷前锟斤拷锟斤拷锟斤拷
  761 +* Input: inputdata 当前图像前景背景（前景为255 背景为0）
  762 + width 图像宽度
  763 + height 图像高度
  764 +* Output: inputdata 膨胀后当前图像前景背景
765 765 *******************************************************************************/
766 766 void RegionSurveillance::VibeModelDilation(unsigned char* inputdata, int width, int height)
767 767 {
... ... @@ -805,12 +805,12 @@ void RegionSurveillance::VibeModelDilation(unsigned char* inputdata, int width,
805 805  
806 806 /******************************************************************************
807 807 * Function: VibeModelErosion
808   -* Description: VIBE模锟酵革拷蚀锟斤拷锟斤拷锟斤拷锟角帮拷锟斤拷前锟斤拷锟侥骋伙拷锟斤拷锟斤拷锟斤拷锟斤拷锟揭伙拷锟斤拷锟轿拷锟斤拷锟斤拷锟斤拷锟角拔拷锟斤拷锟斤拷锟
  808 +* Description: VIBE模型腐蚀（如果当前点或当前点的某一个邻域中有一个点为背景，则当前为背景）
809 809 * Called By: VibeModelUpdateC3
810   -* Input: inputdata 锟斤拷前图锟斤拷前锟斤拷锟斤拷锟斤拷锟斤拷前锟斤拷为255 锟斤拷锟斤拷为0锟斤拷
811   - width 图锟斤拷锟斤拷锟
812   - height 图锟斤拷叨锟
813   -* Output: inputdata 锟斤拷蚀锟斤拷前图锟斤拷前锟斤拷锟斤拷锟斤拷
  810 +* Input: inputdata 当前图像前景背景（前景为255 背景为0）
  811 + width 图像宽度
  812 + height 图像高度
  813 +* Output: inputdata 腐蚀后当前图像前景背景
814 814 *******************************************************************************/
815 815 void RegionSurveillance::VibeModelErosion(unsigned char* inputdata, int width, int height)
816 816 {
... ... @@ -871,7 +871,7 @@ typedef struct _int_128
871 871  
872 872 const _int_128 & int_128_max(const _int_128 & n1, const _int_128 & n2)
873 873 {
874   - if (platform_little_endian) //小锟斤拷
  874 + if (platform_little_endian) //С??
875 875 {
876 876 if (n1._n2 > n2._n2)
877 877 {
... ... @@ -899,7 +899,7 @@ const _int_128 &amp; int_128_max(const _int_128 &amp; n1, const _int_128 &amp; n2)
899 899 }
900 900 else
901 901 {
902   - if (n1._n1 > n2._n1) //锟斤拷锟
  902 + if (n1._n1 > n2._n1) //???
903 903 {
904 904 return n1;
905 905 }
... ... @@ -933,21 +933,21 @@ void int_128_store(_int_128 * n1, _int_128 &amp; n2)
933 933 void RegionSurveillance::VibeModelDilation2(unsigned char* inputdata, unsigned char *output, int width, int height)
934 934 {
935 935 memset(output, 0, sizeof(output[0])*width*height);
936   - if (width<32 || height<32 || inputdata == NULL || output == NULL)
  936 + if (width<32 || height<32 || inputdata==NULL || output==NULL)
937 937 return;
938 938 unsigned char *src = inputdata;
939 939 unsigned char *dst = output;
940 940  
941 941 //memcpy(output, inputdata, width*height);
942   - for (int i = 0; i<height; i++) {
943   - output[i*width + 0] = 0;
944   - output[i*width + width - 1] = 0;
  942 + for (int i=0; i<height; i++) {
  943 + output[i*width+0] = 0;
  944 + output[i*width+width-1] = 0;
945 945 }
946   - for (int j = 0; j<width; j++) {
  946 + for (int j=0; j<width; j++) {
947 947 output[j] = 0;
948   - output[(height - 1)*width + j] = 0;
  948 + output[(height-1)*width+j]=0;
949 949 }
950   - for (int i = 1; i<height - 1; i++)
  950 + for (int i=1; i<height-1; i++)
951 951 {
952 952 src = inputdata + i*width;
953 953 dst = output + i*width;
... ... @@ -972,24 +972,24 @@ void RegionSurveillance::VibeModelDilation2(unsigned char* inputdata, unsigned c
972 972 }
973 973  
974 974 }
975   -void RegionSurveillance::VibeModelErosion2(unsigned char* inputdata, unsigned char *output, int width, int height)
  975 +void RegionSurveillance::VibeModelErosion2(unsigned char* inputdata,unsigned char *output, int width,int height)
976 976 {
977 977 memset(output, 0, sizeof(output[0])*width*height);
978   - if (width<32 || height<32 || inputdata == NULL || output == NULL)
  978 + if (width<32 || height<32 || inputdata==NULL || output==NULL)
979 979 return;
980 980 unsigned char *src = inputdata;
981 981 unsigned char *dst = output;
982 982  
983 983 //memcpy(output, inputdata, width*height);
984   - for (int i = 0; i<height; i++) {
985   - output[i*width + 0] = 0;
986   - output[i*width + width - 1] = 0;
  984 + for (int i=0; i<height; i++) {
  985 + output[i*width+0] = 0;
  986 + output[i*width+width-1] = 0;
987 987 }
988   - for (int j = 0; j<width; j++) {
  988 + for (int j=0; j<width; j++) {
989 989 output[j] = 0;
990   - output[(height - 1)*width + j] = 0;
  990 + output[(height-1)*width+j]=0;
991 991 }
992   - for (int i = 1; i<height-1; i++)
  992 + for (int i=1; i<height-1; i++)
993 993 {
994 994 src = inputdata + i*width;
995 995 dst = output + i*width;
... ... @@ -1014,93 +1014,9 @@ void RegionSurveillance::VibeModelErosion2(unsigned char* inputdata, unsigned ch
1014 1014 }
1015 1015  
1016 1016 }
1017   -//void RegionSurveillance::VibeModelDilation2(unsigned char* inputdata,unsigned char *output, int width,int height)
1018   -//{
1019   -// memset(output, 0, sizeof(output[0])*width*height);
1020   -// if (width<32 || height<32 || inputdata==NULL || output==NULL)
1021   -// return;
1022   -// unsigned char *src = inputdata;
1023   -// unsigned char *dst = output;
1024   -//
1025   -// //memcpy(output, inputdata, width*height);
1026   -// for (int i=0; i<height; i++) {
1027   -// output[i*width+0] = 0;
1028   -// output[i*width+width-1] = 0;
1029   -// }
1030   -// for (int j=0; j<width; j++) {
1031   -// output[j] = 0;
1032   -// output[(height-1)*width+j]=0;
1033   -// }
1034   -// for (int i=1; i<height-1; i++)
1035   -// {
1036   -// src = inputdata + i*width;
1037   -// dst = output + i*width;
1038   -// for (int j = 1; j < width - 16; j += 16)
1039   -// {
1040   -// // 2 unaligned loads.
1041   -// __m128i m = _mm_loadu_si128((const __m128i*)(src + j ));
1042   -// m = _mm_max_epu8(m, _mm_loadu_si128((const __m128i*)(src + j - 1 - width)));
1043   -// m = _mm_max_epu8(m, _mm_loadu_si128((const __m128i*)(src + j + 1)));
1044   -// m = _mm_max_epu8(m, _mm_loadu_si128((const __m128i*)(src + j - width)));
1045   -// m = _mm_max_epu8(m, _mm_loadu_si128((const __m128i*)(src + j + 1 - width)));
1046   -//
1047   -// // 3 aligned loads: more efficient.
1048   -// m = _mm_max_epu8(m, _mm_loadu_si128((const __m128i*)(src + j -1)));
1049   -//
1050   -// m = _mm_max_epu8(m, _mm_loadu_si128((const __m128i*)(src + j + width)));
1051   -// m = _mm_max_epu8(m, _mm_loadu_si128((const __m128i*)(src + j -1 + width)));
1052   -// m = _mm_max_epu8(m, _mm_loadu_si128((const __m128i*)(src + j +1 + width)));
1053   -// // Store the result in the destination image.
1054   -// _mm_storeu_si128((__m128i*)(dst + j), m);
1055   -// }
1056   -// }
1057   -//
1058   -//}
1059   -//void RegionSurveillance::VibeModelErosion2(unsigned char* inputdata,unsigned char *output, int width,int height)
1060   -//{
1061   -// memset(output, 0, sizeof(output[0])*width*height);
1062   -// if (width<32 || height<32 || inputdata==NULL || output==NULL)
1063   -// return;
1064   -// unsigned char *src = inputdata;
1065   -// unsigned char *dst = output;
1066   -//
1067   -// //memcpy(output, inputdata, width*height);
1068   -// for (int i=0; i<height; i++) {
1069   -// output[i*width+0] = 0;
1070   -// output[i*width+width-1] = 0;
1071   -// }
1072   -// for (int j=0; j<width; j++) {
1073   -// output[j] = 0;
1074   -// output[(height-1)*width+j]=0;
1075   -// }
1076   -// for (int i=1; i<height-1; i++)
1077   -// {
1078   -// src = inputdata + i*width;
1079   -// dst = output + i*width;
1080   -// for (int j = 1; j < width - 16; j += 16)
1081   -// {
1082   -// // 2 unaligned loads.
1083   -// __m128i m = _mm_loadu_si128((const __m128i*)(src + j ));
1084   -// m = _mm_min_epu8(m, _mm_loadu_si128((const __m128i*)(src + j - 1 - width)));
1085   -// m = _mm_min_epu8(m, _mm_loadu_si128((const __m128i*)(src + j + 1)));
1086   -// m = _mm_min_epu8(m, _mm_loadu_si128((const __m128i*)(src + j - width)));
1087   -// m = _mm_min_epu8(m, _mm_loadu_si128((const __m128i*)(src + j + 1 - width)));
1088   -//
1089   -// // 3 aligned loads: more efficient.
1090   -// m = _mm_min_epu8(m, _mm_loadu_si128((const __m128i*)(src + j -1)));
1091   -//
1092   -// m = _mm_min_epu8(m, _mm_loadu_si128((const __m128i*)(src + j + width)));
1093   -// m = _mm_min_epu8(m, _mm_loadu_si128((const __m128i*)(src + j -1 + width)));
1094   -// m = _mm_min_epu8(m, _mm_loadu_si128((const __m128i*)(src + j +1 + width)));
1095   -// // Store the result in the destination image.
1096   -// _mm_storeu_si128((__m128i*)(dst + j), m);
1097   -// }
1098   -// }
1099   -//
1100   -//}
1101 1017  
1102 1018  
1103   -//锟斤拷锟斤拷锟斤拷锟侥碉拷锟轿伙拷媒锟斤拷锟斤拷锟斤拷锟 by zl
  1019 +//按照中心点的位置进行排序 by zl
1104 1020 void RegionSurveillance::SortForeground(vector<CForeground> &ForegroundArray)
1105 1021 {
1106 1022 std::sort(ForegroundArray.begin(),ForegroundArray.end(), SortByPoint);
... ... @@ -1111,30 +1027,30 @@ int RegionSurveillance::dwGlobalID;
1111 1027 /******************************************************************************
1112 1028 * Function: VibeModelGetTrace
1113 1029 * Description:
1114   -* Calls锟斤拷 ExtractContours
  1030 +* Calls： ExtractContours
1115 1031 * Called By: RSDetect
1116   -* Input: pSourceImg 锟斤拷前图锟斤拷前锟斤拷锟斤拷锟斤拷锟斤拷前锟斤拷为255 锟斤拷锟斤拷为0锟斤拷
1117   - pRGBIn 锟斤拷前图锟斤拷RGB
1118   - width 图锟斤拷锟斤拷锟
1119   - height 图锟斤拷叨锟
1120   - widthStep 图锟斤拷RGB step
1121   -* Output: pRGBIn 锟斤拷前锟斤拷锟斤拷锟斤拷锟斤拷RGB
  1032 +* Input: pSourceImg 当前图像前景背景（前景为255 背景为0）
  1033 + pRGBIn 当前图像RGB
  1034 + width 图像宽度
  1035 + height 图像高度
  1036 + widthStep 图像RGB step
  1037 +* Output: pRGBIn 将前景描绘过的RGB
1122 1038 m_TargetArray
1123   - m_ptArray 锟诫当前目锟斤拷匹锟斤拷晒锟斤拷锟斤拷锟斤拷锟角帮拷锟斤拷锟斤拷锟斤拷牡锟
1124   - m_VectorDirection 锟斤拷前目锟斤拷锟斤拷之前目锟斤拷锟斤拷锟斤拷锟
  1039 + m_ptArray 与当前目标匹配成功的所有前景的中心点
  1040 + m_VectorDirection 当前目标与之前目标的向量
1125 1041 //m_VectorDirectionNormal dx/sqrt(dx^2+dy^2) dy/sqrt(dx^2+dy^2)
1126   - m_CurRefPoint 目锟斤拷锟斤拷锟斤拷牡锟轿伙拷茫锟斤拷锟斤拷细锟斤拷拢锟饺拷锟斤拷锟狡斤拷锟街碉拷锟
1127   - m_LastRefPoint 目锟斤拷之前锟斤拷锟斤拷锟侥碉拷位锟矫ｏ拷锟斤拷锟较革拷锟铰ｏ拷取5锟斤拷锟斤拷平锟斤拷值锟斤拷
1128   - m_PredictionBasePoint 锟斤拷锟揭伙拷锟狡ワ拷锟斤拷锟斤拷锟斤拷位锟斤拷
1129   - m_PredictionPoint 锟斤拷一帧锟斤拷预锟斤拷位锟斤拷
1130   - m_bHaveDirection 锟斤拷前目锟斤拷锟角凤拷锟窖撅拷锟斤拷锟斤拷锟斤拷锟斤拷锟 true锟斤拷 flase锟斤拷
1131   - m_dwLostFrame 锟洁当前帧未匹锟戒到锟斤拷锟斤拷目锟斤拷锟斤拷锟斤拷锟叫讹拷锟角凤拷目锟疥丢失锟斤拷
1132   - m_dwID ID 锟斤拷锟斤拷锟皆诧拷同锟斤拷前锟斤拷锟斤拷图时锟斤拷锟斤拷锟斤拷色锟较碉拷锟斤拷锟斤拷
1133   - m_dwBestMatch 匹锟戒到锟斤拷前帧锟斤拷前锟斤拷锟斤拷锟
1134   - m_bCalc 锟斤拷志目锟斤拷锟斤拷锟斤拷锟节碉拷前帧锟斤拷锟角凤拷匹锟戒到 true匹锟戒到 false未匹锟戒到
1135   - m_AlarmState 锟斤拷锟斤拷状态 false锟斤拷 true锟斤拷锟斤拷
1136   - m_AlarmNum 锟斤拷锟斤拷锟斤拷锟
1137   - //m_TarBox 目锟斤拷锟斤拷锟接撅拷锟斤拷
  1042 + m_CurRefPoint 目标的中心点位置（不断更新，取5个的平均值）
  1043 + m_LastRefPoint 目标之前的中心点位置（不断更新，取5个的平均值）
  1044 + m_PredictionBasePoint 最后一个匹配点中心位置
  1045 + m_PredictionPoint 下一帧的预测位置
  1046 + m_bHaveDirection 当前目标是否已经计算过方向 true是 flase否
  1047 + m_dwLostFrame 距当前帧未匹配到的数目（用来判断是否目标丢失）
  1048 + m_dwID ID 用来对不同的前景绘图时进行颜色上的区分
  1049 + m_dwBestMatch 匹配到当前帧的前景序号
  1050 + m_bCalc 标志目标序列在当前帧中是否匹配到 true匹配到 false未匹配到
  1051 + m_AlarmState 报警状态 false否 true报警
  1052 + m_AlarmNum 报警编号
  1053 + //m_TarBox 目标的外接矩形
1138 1054 *******************************************************************************/
1139 1055 void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *MaskImgCfd, unsigned char* pRGBIn, RegionInfo* pRegionInfo)
1140 1056 {
... ... @@ -1150,13 +1066,13 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1150 1066 int m_dwMaxLost = 100;
1151 1067 int m_dwMinFrame = 6;
1152 1068 int dwTargetSize = 0;
1153   - CForeground testTarget; // testForgroundArray 锟叫碉拷testTarget
  1069 + CForeground testTarget; // testForgroundArray 中的testTarget
1154 1070  
1155   - //前锟斤拷图锟斤拷锟斤拷-zhm
  1071 + //前景图集合-zhm
1156 1072 vector<CContour> foreContours;
1157 1073 CConExtraction *pConExtraction = new CConExtraction();
1158 1074  
1159   - // 锟斤拷锟斤拷锟斤拷锟斤拷锟侥ｏ拷锟斤拷锟截碉拷 锟斤拷锟斤拷锟斤拷锟斤拷锟00锟斤拷前锟斤拷锟斤拷泳锟斤拷锟
  1075 + // 满足条件的（像素点 面积等条件100）前景外接矩形
1160 1076 if (channel_num == 3)
1161 1077 {
1162 1078 foreContours = pConExtraction->ExtractContours(pSourceImg, MaskImgCfd,GlobelWidth, GlobelHeight, GlobelWidthstep / 3);
... ... @@ -1166,8 +1082,8 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1166 1082 foreContours = pConExtraction->ExtractContours(pSourceImg, MaskImgCfd, GlobelWidth, GlobelHeight, GlobelWidthstep);
1167 1083 }
1168 1084  
1169   - //锟届迹匹锟斤拷-zhm
1170   - // 锟斤拷一锟斤拷锟斤拷foreContours锟侥伙拷锟斤拷锟较讹拷前锟斤拷锟斤拷泳锟斤拷蔚锟斤拷锟斤拷锟斤拷锟斤拷筛选 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟00锟斤拷锟斤拷泳锟斤拷锟斤拷锟斤拷锟紽oregroundArray锟斤拷
  1085 + //轨迹匹配-zhm
  1086 + // 进一步在foreContours的基础上对前景外接矩形的面积进行筛选 将满足面积大于300的外接矩形添入ForegroundArray中
1171 1087 int forNum = foreContours.size();
1172 1088 for (int i = 0; i < forNum; i++)
1173 1089 {
... ... @@ -1180,7 +1096,7 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1180 1096 testTarget.m_ptCenter.y = (testTarget.m_rtConnect.top + testTarget.m_rtConnect.bottom) / 2;
1181 1097 testTarget.m_cfd = foreContours[i].cfd;
1182 1098  
1183   - //锟斤拷锟斤拷锟斤拷小锟斤拷锟斤拷锟斤拷锟斤拷锟叫★拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷 by zl 20160304
  1099 + //??????С?????????С??????????? by zl 20160304
1184 1100 int targetArea = abs((testTarget.m_rtConnect.left - testTarget.m_rtConnect.right) * (testTarget.m_rtConnect.top - testTarget.m_rtConnect.bottom));
1185 1101 if ( targetArea > OBJECT_AREA_MIN && targetArea < OBJECT_AREA_MAX)
1186 1102 {
... ... @@ -1189,7 +1105,7 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1189 1105  
1190 1106  
1191 1107 }
1192   - if(ForegroundArray.size() > 0) //前锟斤拷锟解不锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷 by zl 20160307
  1108 + if(ForegroundArray.size() > 0) //前景库不空则排序处理 by zl 20160307
1193 1109 {
1194 1110 SortForeground(ForegroundArray);
1195 1111 MergeNeighborBox(ForegroundArray);
... ... @@ -1208,14 +1124,14 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1208 1124 delete pConExtraction;
1209 1125 // memory leak for 1 block
1210 1126 m_DelArray.clear();
1211   - //锟叫讹拷锟角凤拷帧锟斤拷目锟疥丢失锟斤拷锟斤拷锟斤拷失dwTargetSize锟皆硷拷
  1127 + //判断是否帧内目标丢失，若丢失dwTargetSize自减
1212 1128 vector<CTarget>::size_type countn = 0;
1213 1129 int dwStep = GlobelWidthstep;
1214 1130 /////////////////////////////////////////////////////////////////////////////////////////
1215 1131 dwTargetSize = m_TargetArray.size();
1216 1132 for (int i = 0; i < dwTargetSize; i++, countn++)
1217 1133 {
1218   - // 锟斤拷锟窖撅拷锟斤拷锟斤拷100帧未锟斤拷锟街革拷前锟斤拷 锟津将革拷前锟斤拷锟斤拷m_TargetArray锟斤拷删锟斤拷
  1134 + // 若已经超过100帧未出现该前景 则将该前景从m_TargetArray中删除
1219 1135 if (m_TargetArray[i].m_dwLostFrame++ > m_dwMaxLost)
1220 1136 {
1221 1137 m_DelArray.push_back(*(m_TargetArray.begin() + countn));
... ... @@ -1247,7 +1163,7 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1247 1163 dwTargetSize = m_TargetArray.size();
1248 1164 double * pDistanceMatrix = new double[dwForegroundCount * dwTargetSize];
1249 1165  
1250   - // 锟斤拷每一锟斤拷目锟斤拷透锟街★拷械锟角帮拷锟斤拷锟斤拷锟狡ワ拷锟
  1166 + // 将每一个目标和该帧中的前景进行匹配
1251 1167 for (int i = 0; i < dwTargetSize; i++)
1252 1168 {
1253 1169 //CMPointDouble directionPre;
... ... @@ -1279,7 +1195,7 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1279 1195 m_FinalArray.clear();
1280 1196 //m_TargetArray.clear();
1281 1197 // Tracking and draw
1282   - // 锟皆碉拷前帧锟斤拷每一锟斤拷前锟斤拷锟斤拷目锟斤拷锟斤拷锟狡ワ拷锟
  1198 + // 对当前帧的每一个前景与目标进行匹配
1283 1199 bool left_flag_c = 1;
1284 1200 for (int i = 0; i < dwForegroundCount; i++)
1285 1201 {
... ... @@ -1307,7 +1223,7 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1307 1223 }
1308 1224 }
1309 1225 //m_TargetArray.clear();
1310   - // 锟斤拷锟狡ワ拷锟缴癸拷 m_TargetArray[dwBestMatch].m_ptArray.size() !=500锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷为什么锟斤拷锟杰碉拷锟斤拷500
  1226 + // 如果匹配成功 m_TargetArray[dwBestMatch].m_ptArray.size() !=500？？？？？？？？？？？？？？？？？？？？？？不理解为什么不能等于500
1311 1227 if (dwBestMatch >= 0 && m_TargetArray[dwBestMatch].m_dwBestMatch == i && m_TargetArray[dwBestMatch].m_ptArray.size() < 500)
1312 1228 {
1313 1229 // Find it
... ... @@ -1335,10 +1251,10 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1335 1251 }
1336 1252  
1337 1253 // Update last reference point
1338   - // 锟斤拷锟斤拷锟侥匡拷锟狡ワ拷锟缴癸拷锟斤拷前锟斤拷锟斤到一锟斤拷锟斤拷锟斤拷
  1254 + // 如果与目标匹配成功的前景达到一定数量
1339 1255 if (dwPointCount > m_dwFrameDist)
1340 1256 {
1341   - // 目锟斤拷之前锟斤拷锟斤拷锟侥碉拷位锟矫ｏ拷5帧帧平锟斤拷锟斤拷
  1257 + // 目标之前的中心点位置（5帧帧平均）
1342 1258 m_TargetArray[dwBestMatch].m_LastRefPoint.x +=
1343 1259 (double) m_TargetArray[dwBestMatch].m_ptArray[dwPointCount - m_dwFrameDist - 1].x / m_dwFrameWnd;
1344 1260 m_TargetArray[dwBestMatch].m_LastRefPoint.y +=
... ... @@ -1371,13 +1287,13 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1371 1287 }
1372 1288 else
1373 1289 {
1374   - // 锟斤拷獾斤拷碌锟侥匡拷锟
  1290 + // 检测到新的目标
1375 1291 // New object found
1376 1292 CTarget NewTarget;
1377 1293 //NewTarget.GetID();
1378 1294 NewTarget.m_dwID= ++dwGlobalID; // GlobalID assigned for target
1379 1295  
1380   - // 锟铰碉拷前锟斤拷锟斤拷锟斤拷锟斤拷位锟斤拷
  1296 + // 新的前景的中心位置
1381 1297 NewTarget.m_ptArray.push_back(ForegroundArray[i].m_ptCenter);
1382 1298  
1383 1299 m_TargetArray.push_back(NewTarget);
... ... @@ -1392,7 +1308,7 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1392 1308 dwBestMatch = m_TargetArray.size() - 1;
1393 1309  
1394 1310 // Update current reference point
1395   - //m_TargetArray-m_CurRefPoint锟斤拷前前锟斤拷锟斤拷锟斤拷锟侥碉拷位锟矫ｏ拷取锟斤拷帧锟斤拷平锟斤拷锟斤拷锟斤拷
  1311 + //m_TargetArray-m_CurRefPoint当前前景的中心点位置（取五帧的平均数）
1396 1312 m_TargetArray[dwBestMatch].m_CurRefPoint.x += (double)ForegroundArray[i].m_ptCenter.x / m_dwFrameWnd;
1397 1313 m_TargetArray[dwBestMatch].m_CurRefPoint.y += (double)ForegroundArray[i].m_ptCenter.y / m_dwFrameWnd;
1398 1314  
... ... @@ -1414,7 +1330,7 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1414 1330 }
1415 1331 }
1416 1332  
1417   - //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟侥匡拷锟
  1333 + //保存最终输出目标
1418 1334 m_FinalArray.push_back(m_TargetArray[dwBestMatch]);
1419 1335 /*
1420 1336 // Draw it
... ... @@ -1427,8 +1343,8 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1427 1343 unsigned char bBlue = (unsigned char) ((m_TargetArray[dwBestMatch].m_dwID % 13) * 20 + 15);
1428 1344  
1429 1345 // Draw rectangle
1430   - //锟斤拷锟斤拷
1431   - // 目锟斤拷锟斤拷泳锟斤拷锟 锟斤拷色
  1346 + //横线
  1347 + // 目标外接矩形 红色
1432 1348 for (int t = ForegroundArray[i].m_rtConnect.left; t <= ForegroundArray[i].m_rtConnect.right; t++)
1433 1349 {
1434 1350 pRGBIn[ForegroundArray[i].m_rtConnect.top * dwStep + t * 3] = 0;
... ... @@ -1455,11 +1371,11 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1455 1371 int d = ForegroundArray[i].m_rtConnect.right;
1456 1372  
1457 1373  
1458   - // ROI 锟斤拷锟
  1374 + // ROI 监控
1459 1375 for (int ii = 0; ii < m_numROI; ii++)
1460 1376 {
1461   - // 目锟斤拷锟斤拷泳锟斤拷谓锟斤拷锟斤拷锟斤拷锟斤拷锟侥匡拷锟斤拷锟斤拷牡锟斤拷锟斤拷锟斤拷锟斤拷冢锟斤拷虮ň锟
1462   - if (pAlarmInfo[ii] == 1) //锟斤拷止锟斤拷锟斤拷
  1377 + // 目标外接矩形进行区域且目标中心点在区域内，则报警
  1378 + if (pAlarmInfo[ii] == 1) //禁止区域
1463 1379 {
1464 1380 if (pRegion[ii][GlobelWidth * a + c] ||
1465 1381 pRegion[ii][GlobelWidth * b + c] ||
... ... @@ -1475,8 +1391,8 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1475 1391 }
1476 1392 }
1477 1393 }
1478   - // 只要目锟斤拷锟斤拷泳锟斤拷锟斤拷锟揭伙拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟津报撅拷
1479   - if (pAlarmInfo[ii] == 2) //锟斤拷锟斤拷
  1394 + // 只要目标外接矩形有一个点进入区域则报警
  1395 + if (pAlarmInfo[ii] == 2) //拌线
1480 1396 {
1481 1397 int xmin = min(c, d), xmax = max(c, d), ymin = min(a, b), ymax = max(a, b);
1482 1398 for (int iy = ymin; iy <= ymax; iy++)
... ... @@ -1493,8 +1409,8 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1493 1409 }
1494 1410 }
1495 1411  
1496   - // 只要目锟斤拷锟斤拷泳锟斤拷谓锟斤拷锟斤拷锟斤拷锟斤拷校锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷ROI锟斤拷锟斤拷锟斤拷锟斤拷锟揭伙拷锟酵憋拷锟接撅拷锟斤拷锟斤拷锟侥碉拷锟斤拷锟斤拷锟斤拷锟节ｏ拷锟津报撅拷
1497   - if (pAlarmInfo[ii] == 3) //锟斤拷锟斤拷锟斤拷锟
  1412 + // 只要目标外接矩形进入区域中，且面积大于ROI区域面积的一半同时外接矩形中心点在区域内，则报警
  1413 + if (pAlarmInfo[ii] == 3) //遗留检测
1498 1414 {
1499 1415 int TotalArea = 0;
1500 1416 if (TotalArea == 0)
... ... @@ -1522,19 +1438,19 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1522 1438 }
1523 1439 }
1524 1440  
1525   - //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟侥匡拷锟
  1441 + //保存最终输出目标
1526 1442 m_FinalArray.push_back(m_TargetArray[dwBestMatch]);
1527 1443  
1528 1444 CMPoint ptLast = m_TargetArray[dwBestMatch].m_ptArray[0];
1529 1445  
1530   - // 锟斤拷目锟斤拷锟矫恳伙拷锟狡ワ拷锟斤拷锟斤拷锟叫憋拷锟斤拷
  1446 + // 对目标的每一个匹配项进行遍历
1531 1447 for (int l = 1; l < dwPointNum; l++)
1532 1448 {
1533 1449 ForegroundArray[i].m_ptCenter = m_TargetArray[dwBestMatch].m_ptArray[l];
1534 1450 if (ForegroundArray[i].m_ptCenter == ptLast)
1535 1451 {
1536 1452 // Draw a point
1537   - //锟斤拷锟侥匡拷锟斤拷锟斤拷牡锟
  1453 + //描绘目标中心点
1538 1454 pRGBIn[ForegroundArray[i].m_ptCenter.y * dwStep + ForegroundArray[i].m_ptCenter.x * 3] = bBlue;
1539 1455 pRGBIn[ForegroundArray[i].m_ptCenter.y * dwStep + ForegroundArray[i].m_ptCenter.x * 3 + 1] = bGreen;
1540 1456 pRGBIn[ForegroundArray[i].m_ptCenter.y * dwStep + ForegroundArray[i].m_ptCenter.x * 3 + 2] = bRed;
... ... @@ -1636,10 +1552,10 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1636 1552 ///////////////////////////////////////////////////////////////////////////////////////
1637 1553 // Prediction
1638 1554 int dwObjectCount = m_TargetArray.size();
1639   - // 锟斤拷锟斤拷锟斤拷锟叫碉拷目锟斤拷
  1555 + // 遍历所有的目标
1640 1556 for (int i=0; i < dwObjectCount; i++)
1641 1557 {
1642   - // 锟斤拷锟斤拷锟侥匡拷锟斤拷诘锟角爸★拷锟矫伙拷锟狡ワ拷锟缴癸拷锟斤拷锟角碉拷前目锟斤拷锟窖撅拷锟斤拷锟斤拷锟斤拷锟斤拷锟
  1558 + // 如果该目标在当前帧中没有匹配成功但是当前目标已经计算过方向
1643 1559 if (!m_TargetArray[i].m_bCalc && m_TargetArray[i].m_bHaveDirection)
1644 1560 {
1645 1561 // Record prediction as current point
... ... @@ -1700,15 +1616,15 @@ void RegionSurveillance::VibeModelGetTrace(unsigned char* pSourceImg, float *Mas
1700 1616  
1701 1617 /******************************************************************************
1702 1618 * Function: RSRegion
1703   -* Description: 锟斤拷锟斤拷趣锟斤拷锟斤拷锟斤拷锟斤拷
  1619 +* Description: 感兴趣区域设置
1704 1620 * Calls: vibeMask
1705 1621 * Called By: main
1706   -* Input: numROI ROI锟斤拷锟斤拷
1707   - pRegionInfo ROI锟斤拷锟斤拷
1708   - iflog true:锟斤拷锟斤拷锟街 false锟斤拷锟斤拷锟斤拷锟斤拷锟街
1709   -* Output: pRegion 10锟斤拷ROI指锟诫（bool锟斤拷每锟斤拷锟斤拷小为锟斤拷图锟斤拷锟*图锟斤拷撸锟斤拷锟斤拷锟饺わ拷锟斤拷锟街滴 锟斤拷锟斤拷为0
1710   - //regionAlarm 10锟斤拷ROI 锟斤拷锟斤拷锟斤拷志锟斤拷bool锟斤拷
1711   - pAlarmInfo 10锟斤拷ROI 锟斤拷锟斤拷锟斤拷志锟斤拷int锟斤拷
  1622 +* Input: numROI ROI个数
  1623 + pRegionInfo ROI区域
  1624 + iflog true:输出日志 false：不输出日志
  1625 +* Output: pRegion 10个ROI指针（bool）每个大小为（图像宽*图像高）感兴趣区域值为1 其余为0
  1626 + //regionAlarm 10个ROI 报警标志（bool）
  1627 + pAlarmInfo 10个ROI 报警标志（int）
1712 1628 * Return: 3 1
1713 1629 *******************************************************************************/
1714 1630 void printAlarmType(fstream *file, int style)
... ... @@ -1716,22 +1632,22 @@ void printAlarmType(fstream *file, int style)
1716 1632 switch (style)
1717 1633 {
1718 1634 case 1:
1719   - *file<<"锟斤拷锟斤拷锟斤拷锟, ";
  1635 + *file<<"进入禁区, ";
1720 1636 break;
1721 1637 case 2:
1722   - *file<<"锟诫开锟斤拷锟斤拷, ";
  1638 + *file<<"离开禁区, ";
1723 1639 break;
1724 1640 case 3:
1725   - *file<<"锟斤拷锟斤拷越锟斤拷, ";
  1641 + *file<<"单向越界, ";
1726 1642 break;
1727 1643 case 4:
1728   - *file<<"双锟斤拷越锟斤拷, ";
  1644 + *file<<"双向越界, ";
1729 1645 break;
1730 1646 case 5:
1731   - *file<<"锟角伙拷, ";
  1647 + *file<<"徘徊, ";
1732 1648 break;
1733 1649 case 6:
1734   - *file<<"锟斤拷锟斤拷, ";
  1650 + *file<<"丢包, ";
1735 1651 break;
1736 1652 default :
1737 1653 break;
... ... @@ -1741,12 +1657,12 @@ void printAlarmType(fstream *file, int style)
1741 1657  
1742 1658 int RegionSurveillance::RSRegion(int numROI, int alarm_info/*, bool iflog*/)
1743 1659 {
1744   - //fstream file;//锟斤拷锟斤拷锟斤拷锟斤拷锟街
  1660 + //fstream file;//用于输出日志
1745 1661 if (numROI > MAXROINUM)
1746 1662 {
1747 1663 return 0;
1748 1664 }
1749   - //锟皆讹拷锟斤拷锟斤拷锟斤拷锟斤拷确锟斤拷锟斤拷锟斤拷牡锟
  1665 + //自动设置用于确定方向的点
1750 1666 //for(int i = 0; i < numROI; i++)
1751 1667 //{
1752 1668 // if (iflog)
... ... @@ -1760,13 +1676,13 @@ int RegionSurveillance::RSRegion(int numROI, int alarm_info/*, bool iflog*/)
1760 1676 //
1761 1677 // if (pRegionInfo[i].AlarmInfo == 3)
1762 1678 // {
1763   - // pRegionInfo[i].finaldir = get_ArrowDir(pRegionInfo[i].pROI[0], pRegionInfo[i].pROI[1], pRegionInfo[i].dirPoint);//确锟斤拷锟斤拷锟斤拷锟斤拷悖拷锟酵凤拷说锟斤拷锟斤拷锟
  1679 + // pRegionInfo[i].finaldir = get_ArrowDir(pRegionInfo[i].pROI[0], pRegionInfo[i].pROI[1], pRegionInfo[i].dirPoint);//确定方向计算，箭头端点坐标
1764 1680 //
1765 1681 // if (iflog)
1766 1682 // file<<", DirPoint("<<pRegionInfo[i].dirPoint.x<<","<<pRegionInfo[i].dirPoint.y<<")";
1767 1683 //
1768   - // pRegionInfo[i].ArrowStartPoint = pStart; //锟斤拷头锟斤拷锟斤拷始锟剿碉拷 锟斤拷头指锟斤拷锟斤拷锟斤拷锟斤拷
1769   - // pRegionInfo[i].ArrowEndPoint = pEnd; //锟斤拷头锟斤拷锟斤拷止锟剿碉拷 锟斤拷头指锟斤拷锟斤拷锟斤拷锟斤拷
  1684 + // pRegionInfo[i].ArrowStartPoint = pStart; //箭头的起始端点 箭头指向正方形
  1685 + // pRegionInfo[i].ArrowEndPoint = pEnd; //箭头的终止端点 箭头指向正方形
1770 1686 // }
1771 1687  
1772 1688 // if (iflog)
... ... @@ -1807,10 +1723,10 @@ int RegionSurveillance::RSRegion(int numROI, int alarm_info/*, bool iflog*/)
1807 1723 }
1808 1724  
1809 1725  
1810   - // 锟斤拷每一锟斤拷锟斤拷锟桔诧拷锟絉OI锟斤拷锟叫硷拷锟
  1726 + // 对每一个待观察的ROI进行监测
1811 1727 //for (int i = 0; i < numROI; i++)
1812 1728 {
1813   - // 锟斤拷每一锟斤拷锟斤拷锟斤拷趣锟斤拷锟斤拷锟斤拷斜锟街 锟斤拷锟斤拷趣锟斤拷锟斤拷pRegion值为1 锟斤拷锟斤拷为0
  1729 + // 对每一个感兴趣区域进行标志 感兴趣区域pRegion值为1 其余为0
1814 1730 //vibeMask(pRegionInfo[i].nPointNum, pRegionInfo[i].pROI, pRegion[i]);
1815 1731 }
1816 1732  
... ... @@ -1916,7 +1832,7 @@ int RegionSurveillance::RSRegion(int numROI, int alarm_info/*, bool iflog*/)
1916 1832 // int y = (int) (((LineMin.y - LineMax.y) / (double) (LineMin.x - LineMax.x)) * (double) (x - LineMin.x) + 0.5 + (double)LineMin.y);
1917 1833 // //pRegion[GlobelWidth * y + x] = 1;
1918 1834 //
1919   -// //原锟斤拷锟斤拷锟斤拷锟皆斤拷锟 锟斤拷锟斤拷芸锟睫革拷锟斤拷锟斤拷
  1835 +// //原程序存在越界 苏晓芸修改如下
1920 1836 // if (y > -1 && y < GlobelHeight && x > -1 && x < GlobelWidth)
1921 1837 // {
1922 1838 // pRegion[GlobelWidth * y + x] = 1;
... ... @@ -1932,7 +1848,7 @@ int RegionSurveillance::RSRegion(int numROI, int alarm_info/*, bool iflog*/)
1932 1848 // int y = (int) (((LineMin.y - LineMax.y) / (double)(LineMin.x - LineMax.x)) * (double)(x - LineMin.x) + 0.5 + (double)LineMin.y);
1933 1849 // //pRegion[GlobelWidth * y + x] = 1;
1934 1850 //
1935   -// //原锟斤拷锟斤拷锟斤拷锟皆斤拷锟 锟斤拷锟斤拷芸锟睫革拷锟斤拷锟斤拷
  1851 +// //原程序存在越界 苏晓芸修改如下
1936 1852 // if (y > -1 && y < GlobelHeight && x > -1 && x < GlobelWidth)
1937 1853 // {
1938 1854 // pRegion[GlobelWidth * y + x] = 1;
... ... @@ -1947,7 +1863,7 @@ int RegionSurveillance::RSRegion(int numROI, int alarm_info/*, bool iflog*/)
1947 1863 // {
1948 1864 // //pRegion[GlobelWidth * i + pPointList[startp].x] = 1;
1949 1865 //
1950   -// //原锟斤拷锟斤拷锟斤拷锟皆斤拷锟 锟斤拷锟斤拷芸锟睫革拷锟斤拷锟斤拷
  1866 +// //原程序存在越界 苏晓芸修改如下
1951 1867 // if (i > -1 && i < GlobelHeight && pPointList[startp].x > -1 && pPointList[startp].x < GlobelWidth)
1952 1868 // {
1953 1869 // pRegion[GlobelWidth * i + pPointList[startp].x] = 1;
... ... @@ -1966,7 +1882,7 @@ int RegionSurveillance::RSRegion(int numROI, int alarm_info/*, bool iflog*/)
1966 1882 // int x = (int) (((LineMin.x - LineMax.x) / (double) (LineMin.y - LineMax.y)) * (double) (y - LineMin.y) + 0.5 + (double)LineMin.x);
1967 1883 // //pRegion[GlobelWidth * y + x] = 1;
1968 1884 //
1969   -// //原锟斤拷锟斤拷锟斤拷锟皆斤拷锟 锟斤拷锟斤拷芸锟睫革拷锟斤拷锟斤拷
  1885 +// //原程序存在越界 苏晓芸修改如下
1970 1886 // if (y > -1 && y < GlobelHeight && x > -1 && x < GlobelWidth)
1971 1887 // {
1972 1888 // pRegion[GlobelWidth * y + x] = 1;
... ... @@ -1982,7 +1898,7 @@ int RegionSurveillance::RSRegion(int numROI, int alarm_info/*, bool iflog*/)
1982 1898 // int x = (int) (((LineMin.x - LineMax.x) / (double) (LineMin.y - LineMax.y)) * (double) (y - LineMin.y) + 0.5 + (double)LineMin.x);
1983 1899 // //pRegion[GlobelWidth * y + x] = 1;
1984 1900 //
1985   -// //原锟斤拷锟斤拷锟斤拷锟皆斤拷锟 锟斤拷锟斤拷芸锟睫革拷锟斤拷锟斤拷
  1901 +// //原程序存在越界 苏晓芸修改如下
1986 1902 // if (y > -1 && y < GlobelHeight && x > -1 && x < GlobelWidth)
1987 1903 // {
1988 1904 // pRegion[GlobelWidth * y + x] = 1;
... ... @@ -1997,7 +1913,7 @@ int RegionSurveillance::RSRegion(int numROI, int alarm_info/*, bool iflog*/)
1997 1913 // {
1998 1914 // //pRegion[GlobelWidth * pPointList[startp].y + i] = 1;
1999 1915 //
2000   -// //原锟斤拷锟斤拷锟斤拷锟皆斤拷锟 锟斤拷锟斤拷芸锟睫革拷锟斤拷锟斤拷
  1916 +// //原程序存在越界 苏晓芸修改如下
2001 1917 // if (pPointList[startp].y > -1 && pPointList[startp].y < GlobelHeight && i > -1 && i < GlobelWidth)
2002 1918 // {
2003 1919 // pRegion[GlobelWidth * pPointList[startp].y + i] = 1;
... ... @@ -2007,7 +1923,7 @@ int RegionSurveillance::RSRegion(int numROI, int alarm_info/*, bool iflog*/)
2007 1923 // }
2008 1924 // }
2009 1925 //
2010   -// // 锟睫改憋拷欠锟绞 锟斤拷锟斤拷锟斤拷锟皆碉拷锟街撅拷锟轿
  1926 +// // 修改标记方式 将区域边缘标志置为0
2011 1927 // for (int i = 0; i < GlobelHeight; i++)
2012 1928 // {
2013 1929 // for (int j = 0; j < GlobelWidth; j++)
... ... @@ -2153,9 +2069,8 @@ void RegionSurveillance::getObjectInfo(int ObjCount, MS_ObjectInfo* ObjInfo)
2153 2069 }
2154 2070 */
2155 2071 // unique ID for current object
2156   - ObjInfo[i].TarBox = m_FinalArray[i].m_TarBox; //目锟斤拷锟斤拷泳锟斤拷锟
2157   - ObjInfo[i].UniqueID = m_FinalArray[i].m_dwID; //锟斤拷前目锟斤拷锟斤拷氐锟絀D
2158   - //printf("UniqueID = %d, cfd = %f\n", ObjInfo[i].UniqueID, ObjInfo[i].confidence);
  2072 + ObjInfo[i].TarBox = m_FinalArray[i].m_TarBox; //目标外接矩形
  2073 + ObjInfo[i].UniqueID = m_FinalArray[i].m_dwID; //当前目标的特点ID
2159 2074 }
2160 2075 }
2161 2076  
... ... @@ -2167,7 +2082,6 @@ void RegionSurveillance::getDeleteInfo(int DelCount, MS_ObjectInfo* ObjInfo)
2167 2082 {
2168 2083 int dwPointCount = m_DelArray[i].m_ptArray.size();
2169 2084 ObjInfo[i].curPos = m_DelArray[i].m_ptArray[dwPointCount - 1];
2170   -
2171 2085 int temp_dwPointCount = dwPointCount;
2172 2086 if (dwPointCount > MAXTRACENUM)
2173 2087 {
... ... @@ -2214,14 +2128,14 @@ void RegionSurveillance::getDeleteInfo(int DelCount, MS_ObjectInfo* ObjInfo)
2214 2128 }
2215 2129 */
2216 2130 // unique ID for current object
2217   - ObjInfo[i].TarBox = m_DelArray[i].m_TarBox; //目锟斤拷锟斤拷泳锟斤拷锟
2218   - ObjInfo[i].UniqueID = m_DelArray[i].m_dwID; //锟斤拷前目锟斤拷锟斤拷氐锟絀D
  2131 + ObjInfo[i].TarBox = m_DelArray[i].m_TarBox; //?????????
  2132 + ObjInfo[i].UniqueID = m_DelArray[i].m_dwID; //??????????ID
2219 2133 ObjInfo[i].confidence = m_DelArray[i].cfd;
2220 2134 }
2221 2135 }
2222 2136  
2223 2137  
2224   -// 锟斤拷图锟斤拷转锟斤拷为锟揭讹拷图锟斤拷
  2138 +// 将图像转换为灰度图像
2225 2139 void RegionSurveillance::VibeRGBToGray(unsigned char* RgbData, unsigned char* GrayData)
2226 2140 {
2227 2141 int nHeight, nWidth;
... ... @@ -2240,11 +2154,11 @@ void RegionSurveillance::VibeRGBToGray(unsigned char* RgbData, unsigned char* Gr
2240 2154  
2241 2155  
2242 2156  
2243   -//pAlarmInfo 1锟斤拷锟斤拷锟斤拷锟 2锟诫开锟斤拷锟斤拷 3锟斤拷锟斤拷越锟斤拷 4双锟斤拷越锟斤拷 5锟角伙拷 6锟斤拷锟斤拷
  2157 +//pAlarmInfo 1进入禁区 2离开禁区 3单向越界 4双向越界 5徘徊 6丢包
2244 2158 void RegionSurveillance::MonitoringAlarm(unsigned char* pRGBIn, CForeground ForegroundArray_i, int dwBestMatch, RegionInfo* pRegionInfo)
2245 2159 {
2246 2160  
2247   - // 目锟斤拷锟斤拷锟斤拷
  2161 + // 目标锁定
2248 2162 //ExternalRectangle(pRGBIn, ForegroundArray_i, dwBestMatch, widthStep, 255, 0, 0);
2249 2163 /*
2250 2164 int dwStep = widthStep;
... ... @@ -2254,7 +2168,7 @@ void RegionSurveillance::MonitoringAlarm(unsigned char* pRGBIn, CForeground Fore
2254 2168 unsigned char bBlue = (unsigned char) ((m_TargetArray[dwBestMatch].m_dwID % 13) * 20 + 15);
2255 2169  
2256 2170  
2257   - // 前锟斤拷目锟斤拷锟斤拷泳锟斤拷锟斤拷锟斤拷
  2171 + // 前景目标外接矩形描绘
2258 2172 for (int t = ForegroundArray_i.m_rtConnect.left; t <= ForegroundArray_i.m_rtConnect.right; t++)
2259 2173 {
2260 2174 pRGBIn[ForegroundArray_i.m_rtConnect.top * dwStep + t * 3] = 0;
... ... @@ -2281,11 +2195,11 @@ void RegionSurveillance::MonitoringAlarm(unsigned char* pRGBIn, CForeground Fore
2281 2195 int c = ForegroundArray_i.m_rtConnect.left;
2282 2196 int d = ForegroundArray_i.m_rtConnect.right;
2283 2197  
2284   - // 锟斤拷锟斤拷锟斤拷
  2198 + // 区域监控
2285 2199 for (int ii = 0; ii < m_numROI; ii++)
2286 2200 {
2287 2201  
2288   - if (pAlarmInfo[ii] == 1) //锟斤拷锟斤拷锟斤拷锟
  2202 + if (pAlarmInfo[ii] == 1) //进入禁区
2289 2203 {
2290 2204 //AccessToRestrictedAreas(pRegion[ii], dwBestMatch,a, b, c, d, ii);
2291 2205 /*
... ... @@ -2295,7 +2209,7 @@ void RegionSurveillance::MonitoringAlarm(unsigned char* pRGBIn, CForeground Fore
2295 2209 }
2296 2210 */
2297 2211 }
2298   - else if (pAlarmInfo[ii] == 2) //锟诫开锟斤拷锟斤拷
  2212 + else if (pAlarmInfo[ii] == 2) //离开禁区
2299 2213 {
2300 2214 //LeaveTheRestrictedAreas(pRegion[ii], dwBestMatch,a, b, c, d, ii);
2301 2215 /*
... ... @@ -2306,7 +2220,7 @@ void RegionSurveillance::MonitoringAlarm(unsigned char* pRGBIn, CForeground Fore
2306 2220 */
2307 2221 }
2308 2222  
2309   - else if (pAlarmInfo[ii] == 3) //锟斤拷锟斤拷越锟斤拷
  2223 + else if (pAlarmInfo[ii] == 3) //单向越界
2310 2224 {
2311 2225 //OneWayCrossBorder(pRegion[ii], dwBestMatch, a, b, c, d, ii, pRegionInfo);
2312 2226 /*
... ... @@ -2317,7 +2231,7 @@ void RegionSurveillance::MonitoringAlarm(unsigned char* pRGBIn, CForeground Fore
2317 2231 */
2318 2232  
2319 2233 }
2320   - else if (pAlarmInfo[ii] == 4) //双锟斤拷越锟斤拷
  2234 + else if (pAlarmInfo[ii] == 4) //双向越界
2321 2235 {
2322 2236 //TwoWayCrossBorder(pRegion[ii], dwBestMatch, a, b, c, d, ii);
2323 2237 /*
... ... @@ -2328,7 +2242,7 @@ void RegionSurveillance::MonitoringAlarm(unsigned char* pRGBIn, CForeground Fore
2328 2242 */
2329 2243  
2330 2244 }
2331   - else if (pAlarmInfo[ii] == 5) //锟角伙拷
  2245 + else if (pAlarmInfo[ii] == 5) //徘徊
2332 2246 {
2333 2247 //WanderMonitoring(pRegion[ii], dwBestMatch, a, b, c, d, ii, pRegionInfo, pRGBIn);
2334 2248 /*
... ... @@ -2338,7 +2252,7 @@ void RegionSurveillance::MonitoringAlarm(unsigned char* pRGBIn, CForeground Fore
2338 2252 }
2339 2253 */
2340 2254 }
2341   - else if (pAlarmInfo[ii] == 6) //锟斤拷锟斤拷
  2255 + else if (pAlarmInfo[ii] == 6) //丢包
2342 2256 {
2343 2257 StayMonitoring( dwBestMatch, a, b, c, d, ii, pRegionInfo, pRGBIn);
2344 2258 /*
... ... @@ -2357,7 +2271,7 @@ void RegionSurveillance::MonitoringAlarm(unsigned char* pRGBIn, CForeground Fore
2357 2271  
2358 2272  
2359 2273  
2360   - // 锟届迹锟斤拷锟
  2274 + // 轨迹描绘
2361 2275 //Trajectory(pRGBIn, ForegroundArray_i, dwBestMatch, width, height, widthStep);
2362 2276 /*
2363 2277 int dwStep = widthStep;
... ... @@ -2368,14 +2282,14 @@ void RegionSurveillance::MonitoringAlarm(unsigned char* pRGBIn, CForeground Fore
2368 2282 int dwPointNum = m_TargetArray[dwBestMatch].m_ptArray.size();
2369 2283 CMPoint ptLast = m_TargetArray[dwBestMatch].m_ptArray[0];
2370 2284  
2371   - // 锟斤拷目锟斤拷锟矫恳伙拷锟狡ワ拷锟斤拷锟斤拷锟叫憋拷锟斤拷
  2285 + // 对目标的每一个匹配项进行遍历
2372 2286 for (int l = 1; l < dwPointNum; l++)
2373 2287 {
2374 2288 ForegroundArray_i.m_ptCenter = m_TargetArray[dwBestMatch].m_ptArray[l];
2375 2289 if (ForegroundArray_i.m_ptCenter == ptLast)
2376 2290 {
2377 2291 // Draw a point
2378   - //锟斤拷锟侥匡拷锟斤拷锟斤拷牡锟
  2292 + //描绘目标中心点
2379 2293 pRGBIn[ForegroundArray_i.m_ptCenter.y * dwStep + ForegroundArray_i.m_ptCenter.x * 3] = bBlue;
2380 2294 pRGBIn[ForegroundArray_i.m_ptCenter.y * dwStep + ForegroundArray_i.m_ptCenter.x * 3 + 1] = bGreen;
2381 2295 pRGBIn[ForegroundArray_i.m_ptCenter.y * dwStep + ForegroundArray_i.m_ptCenter.x * 3 + 2] = bRed;
... ... @@ -2458,13 +2372,13 @@ void RegionSurveillance::MonitoringAlarm(unsigned char* pRGBIn, CForeground Fore
2458 2372 }
2459 2373  
2460 2374 /*
2461   -//锟斤拷泳锟斤拷锟斤拷锟斤拷
  2375 +//外接矩形描绘
2462 2376 void RegionSurveillance::ExternalRectangle(unsigned char* pRGBIn, CForeground ForegroundArray_i, int dwBestMatch, int widthStep,
2463 2377 int rgb_b, int rgb_g, int rgb_r)
2464 2378 {
2465 2379 int dwStep = widthStep;
2466 2380  
2467   - // 前锟斤拷目锟斤拷锟斤拷泳锟斤拷锟斤拷锟斤拷
  2381 + // 前景目标外接矩形描绘
2468 2382 for (int t = ForegroundArray_i.m_rtConnect.left; t <= ForegroundArray_i.m_rtConnect.right; t++)
2469 2383 {
2470 2384 pRGBIn[ForegroundArray_i.m_rtConnect.top * dwStep + t * 3] = rgb_b;
... ... @@ -2487,7 +2401,7 @@ void RegionSurveillance::ExternalRectangle(unsigned char* pRGBIn, CForeground Fo
2487 2401  
2488 2402 void RegionSurveillance::Trajectory(unsigned char* pRGBIn, CForeground ForegroundArray_i, int dwBestMatch, int width, int height, int widthStep)
2489 2403 {
2490   - // 锟届迹锟斤拷锟
  2404 + // 轨迹描绘
2491 2405 int dwStep = widthStep;
2492 2406 unsigned char bRed = (unsigned char) ((m_TargetArray[dwBestMatch].m_dwID % 3) * 85 + 85);
2493 2407 unsigned char bGreen = (unsigned char) ((m_TargetArray[dwBestMatch].m_dwID % 7) * 36 + 36);
... ... @@ -2496,14 +2410,14 @@ void RegionSurveillance::Trajectory(unsigned char* pRGBIn, CForeground Foregroun
2496 2410 int dwPointNum = m_TargetArray[dwBestMatch].m_ptArray.size();
2497 2411 CMPoint ptLast = m_TargetArray[dwBestMatch].m_ptArray[0];
2498 2412  
2499   - // 锟斤拷目锟斤拷锟矫恳伙拷锟狡ワ拷锟斤拷锟斤拷锟叫憋拷锟斤拷
  2413 + // 对目标的每一个匹配项进行遍历
2500 2414 for (int l = 1; l < dwPointNum; l++)
2501 2415 {
2502 2416 ForegroundArray_i.m_ptCenter = m_TargetArray[dwBestMatch].m_ptArray[l];
2503 2417 if (ForegroundArray_i.m_ptCenter == ptLast)
2504 2418 {
2505 2419 // Draw a point
2506   - //锟斤拷锟侥匡拷锟斤拷锟斤拷牡锟
  2420 + //描绘目标中心点
2507 2421 pRGBIn[ForegroundArray_i.m_ptCenter.y * dwStep + ForegroundArray_i.m_ptCenter.x * 3] = bBlue;
2508 2422 pRGBIn[ForegroundArray_i.m_ptCenter.y * dwStep + ForegroundArray_i.m_ptCenter.x * 3 + 1] = bGreen;
2509 2423 pRGBIn[ForegroundArray_i.m_ptCenter.y * dwStep + ForegroundArray_i.m_ptCenter.x * 3 + 2] = bRed;
... ... @@ -2589,26 +2503,26 @@ void RegionSurveillance::Trajectory(unsigned char* pRGBIn, CForeground Foregroun
2589 2503  
2590 2504 /******************************************************************************
2591 2505 * Function: RAccessToRestrictedAreas
2592   -* Description: 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
2593   -* Input: pRegion_i 锟斤拷锟斤拷趣锟斤拷锟斤拷锟斤拷
2594   - dwBestMatch 目锟斤拷锟斤拷锟斤拷
2595   - ForBottom 锟斤拷前前锟斤拷锟斤拷泳锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟叫≈
2596   - ForTop 锟斤拷前前锟斤拷锟斤拷泳锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷值
2597   - ForLeft 锟斤拷前前锟斤拷锟斤拷泳锟斤拷魏锟斤拷锟斤拷锟斤拷锟叫≈
2598   - ForRight 锟斤拷前前锟斤拷锟斤拷泳锟斤拷魏锟斤拷锟斤拷锟斤拷锟斤拷值
2599   - indexROI ROI 锟斤拷锟斤拷
2600   -* Output: m_TargetArray 目锟斤拷锟斤拷息
  2506 +* Description: 进入禁区监测
  2507 +* Input: pRegion_i 感兴趣区域标记
  2508 + dwBestMatch 目标索引
  2509 + ForBottom 当前前景外接矩形纵坐标最小值
  2510 + ForTop 当前前景外接矩形纵坐标最大值
  2511 + ForLeft 当前前景外接矩形横坐标最小值
  2512 + ForRight 当前前景外接矩形横坐标最大值
  2513 + indexROI ROI 索引
  2514 +* Output: m_TargetArray 目标信息
2601 2515 *******************************************************************************/
2602 2516 //void RegionSurveillance::AccessToRestrictedAreas(bool *pRegion_i, int dwBestMatch, int ForBottom, int ForTop, int ForLeft, int ForRight, int indexROI)
2603 2517 //{
2604 2518 //
2605   -// // 目锟斤拷锟斤拷泳锟斤拷锟斤拷锟揭伙拷锟斤拷呓锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷泳锟斤拷锟斤拷锟斤拷牡锟轿伙拷诮锟斤拷锟斤拷锟
  2519 +// // 目标外接矩形有一个边进入禁区且外接矩形中心点位于禁区内
2606 2520 // //if (pRegion_i[GlobelWidth * ForBottom + ForLeft] ||
2607 2521 // // pRegion_i[GlobelWidth * ForTop + ForLeft] ||
2608 2522 // // pRegion_i[GlobelWidth * ForTop + ForRight] ||
2609 2523 // // pRegion_i[GlobelWidth * ForBottom + ForRight])
2610 2524 // {
2611   -// //锟斤拷锟叫讹拷锟角凤拷锟斤拷锟斤拷锟斤拷趣锟斤拷锟斤拷某锟斤拷司锟斤拷锟斤拷锟斤拷牡锟斤拷锟斤拷锟斤拷锟斤拷锟揭猴拷锟斤拷锟斤拷锟斤拷锟斤拷愣硷拷锟斤拷锟斤拷锟斤拷锟斤拷卸锟轿拷锟斤拷锟
  2525 +// //将判断是否进入感兴趣区域改成了矩形中心点的上下左右和中心五个点都进入区域，判定为进入
2612 2526 // if (pRegion_i[GlobelWidth * (int) ((ForBottom + ForTop) / 2) + (ForLeft + ForRight) / 2] && \
2613 2527 // pRegion_i[GlobelWidth * (int)((ForBottom + ForTop) / 2) + (ForLeft + ForRight) / 2 + 1] && \
2614 2528 // pRegion_i[GlobelWidth * (int)((ForBottom + ForTop) / 2) + (ForLeft + ForRight) / 2 - 1] && \
... ... @@ -2626,7 +2540,7 @@ void RegionSurveillance::Trajectory(unsigned char* pRGBIn, CForeground Foregroun
2626 2540 //
2627 2541 //}
2628 2542  
2629   -//锟诫开锟斤拷锟斤拷
  2543 +//离开禁区
2630 2544 //void RegionSurveillance::LeaveTheRestrictedAreas(bool *pRegion_i, int dwBestMatch, int ForBottom, int ForTop, int ForLeft, int ForRight, int indexROI)
2631 2545 //{
2632 2546 // if (pRegion_i[GlobelWidth * ForBottom + ForLeft] ||
... ... @@ -2664,11 +2578,11 @@ void RegionSurveillance::Trajectory(unsigned char* pRGBIn, CForeground Foregroun
2664 2578 // m_TargetArray[dwBestMatch].pbAlarmType[indexROI] = 0;
2665 2579 //}
2666 2580  
2667   -//锟斤拷锟斤拷越锟斤拷
2668   -//dir: 1 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟酵拷锟斤拷锟斤拷锟较碉拷锟 0锟斤拷锟斤拷锟斤拷
  2581 +//单向越界
  2582 +//dir: 1 正方向（相对于通常坐标系） 0负方向
2669 2583 //void RegionSurveillance::OneWayCrossBorder(bool *pRegion_i, int dwBestMatch, int ForBottom, int ForTop, int ForLeft, int ForRight, int indexROI, RegionInfo* pRegionInfo)
2670 2584 //{
2671   -// // 只要目锟斤拷锟斤拷泳锟斤拷锟斤拷锟揭伙拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟津报撅拷
  2585 +// // 只要目标外接矩形有一个点进入区域则报警
2672 2586 // int tar_size = m_TargetArray[dwBestMatch].m_ptArray.size();
2673 2587 // int xmin = min(ForLeft, ForRight), xmax = max(ForLeft, ForRight), ymin = min(ForBottom, ForTop), ymax = max(ForBottom, ForTop);
2674 2588 // for (int iy = ymin; iy <= ymax; iy++)
... ... @@ -2681,7 +2595,7 @@ void RegionSurveillance::Trajectory(unsigned char* pRGBIn, CForeground Foregroun
2681 2595 // point_x = m_TargetArray[dwBestMatch].m_ptArray[tar_size - 4].x;
2682 2596 // point_y = m_TargetArray[dwBestMatch].m_ptArray[tar_size - 4].y;
2683 2597 //
2684   -// // 锟叫断凤拷锟斤拷
  2598 +// // 判断方向
2685 2599 // if (indexROI >= 0 && indexROI < m_numROI && pRegionInfo[indexROI].nPointNum >= 2)
2686 2600 // {
2687 2601 // if (abs(pRegionInfo[indexROI].pROI[0].x - pRegionInfo[indexROI].pROI[1].x) >= 1)
... ... @@ -2916,10 +2830,10 @@ void RegionSurveillance::Trajectory(unsigned char* pRGBIn, CForeground Foregroun
2916 2830 // m_TargetArray[dwBestMatch].pbAlarmType[indexROI] = 0;
2917 2831 //}
2918 2832  
2919   -////双锟斤拷越锟斤拷
  2833 +////双向越界
2920 2834 //void RegionSurveillance::TwoWayCrossBorder(bool *pRegion_i, int dwBestMatch, int ForBottom, int ForTop, int ForLeft, int ForRight, int indexROI)
2921 2835 //{
2922   -// // 只要目锟斤拷锟斤拷泳锟斤拷锟斤拷锟揭伙拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟津报撅拷
  2836 +// // 只要目标外接矩形有一个点进入区域则报警
2923 2837 // int xmin = min(ForLeft, ForRight), xmax = max(ForLeft, ForRight), ymin = min(ForBottom, ForTop), ymax = max(ForBottom, ForTop);
2924 2838 // for (int iy = ymin; iy <= ymax; iy++)
2925 2839 // {
... ... @@ -2937,10 +2851,10 @@ void RegionSurveillance::Trajectory(unsigned char* pRGBIn, CForeground Foregroun
2937 2851 // m_TargetArray[dwBestMatch].pbAlarmType[indexROI] = 0;
2938 2852 //}
2939 2853  
2940   -////双锟斤拷越锟斤拷
  2854 +////双向越界
2941 2855 //void RegionSurveillance::TwoWayCrossBorder(bool *pRegion_i, int dwBestMatch, int ForBottom, int ForTop, int ForLeft, int ForRight, int indexROI)
2942 2856 //{
2943   -// // 只要目锟斤拷锟斤拷泳锟斤拷锟斤拷锟揭伙拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟津报撅拷
  2857 +// // 只要目标外接矩形有一个点进入区域则报警
2944 2858 // int xmin = min(ForLeft, ForRight), xmax = max(ForLeft, ForRight), ymin = min(ForBottom, ForTop), ymax= max(ForBottom, ForTop);
2945 2859 // for (int iy = ymin; iy <= ymax; iy++)
2946 2860 // {
... ... @@ -2958,7 +2872,7 @@ void RegionSurveillance::Trajectory(unsigned char* pRGBIn, CForeground Foregroun
2958 2872 // m_TargetArray[dwBestMatch].pbAlarmType[indexROI] = -1;
2959 2873 //}
2960 2874  
2961   -// 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷瞥锟 0 锟斤拷锟斤拷 1锟狡筹拷
  2875 +// 监测遗留或移除 0 遗留 1移除
2962 2876 bool RegionSurveillance::detectLeftRemove(unsigned char* pRGBIn, int ForBottom, int ForTop, int ForLeft, int ForRight)
2963 2877 {
2964 2878 bool flag;
... ... @@ -3071,11 +2985,11 @@ bool RegionSurveillance::detectLeftRemove(unsigned char* pRGBIn, int ForBottom,
3071 2985 }
3072 2986 }
3073 2987  
3074   - if (ratio >= 0.85 && ratio <= 1.0) //锟斤拷锟斤拷锟绞撅拷瞥锟
  2988 + if (ratio >= 0.85 && ratio <= 1.0) //相近表示移除
3075 2989 {
3076 2990 flag = 1;
3077 2991 }
3078   - else // 锟斤拷锟斤拷锟绞撅拷锟斤拷锟
  2992 + else // 否则表示遗留
3079 2993 {
3080 2994 flag = 0;
3081 2995 }
... ... @@ -3091,10 +3005,10 @@ bool CTargetFunc (CTarget &amp;a, CTarget &amp;b)
3091 3005 else
3092 3006 return false;
3093 3007 }
3094   -// 锟角伙拷锟斤拷锟
  3008 +// 徘徊监测
3095 3009 void RegionSurveillance::WanderMonitoring(bool *pRegion_i, int dwBestMatch, int ForBottom, int ForTop, int ForLeft, int ForRight, int indexROI, RegionInfo* pRegionInfo, unsigned char* pRGBIn)
3096 3010 {
3097   - // 目锟斤拷锟斤拷泳锟斤拷锟斤拷锟揭伙拷锟斤拷呓锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷泳锟斤拷锟斤拷锟斤拷牡锟轿伙拷诮锟斤拷锟斤拷锟
  3011 + // 目标外接矩形有一个边进入禁区且外接矩形中心点位于禁区内
3098 3012 bool flag = 0;
3099 3013  
3100 3014 if ((pRegion_i[GlobelWidth * ForBottom + ForLeft] ||
... ... @@ -3121,7 +3035,7 @@ void RegionSurveillance::WanderMonitoring(bool *pRegion_i, int dwBestMatch, int
3121 3035 m_TargetArray[dwBestMatch].lastFrame = 0;
3122 3036 }
3123 3037 }
3124   - if ((1 == m_TargetArray[dwBestMatch].m_ptArray.size() && m_TargetArray[dwBestMatch].nFrameCurr == 1) && m_TargetArray[dwBestMatch].m_bFirstInWander == true ) //锟斤拷锟斤拷锟角伙拷锟斤拷锟斤拷锟节ｏ拷锟斤拷锟侥匡拷锟斤拷锟斤拷锟叫讹拷为锟铰讹拷锟襟，斤拷锟斤拷锟铰讹拷锟斤拷锟絥FrameCurr锟斤拷锟斤拷锟斤拷为锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷咏锟斤拷亩锟斤拷锟斤拷nFrameCurr
  3038 + if ((1 == m_TargetArray[dwBestMatch].m_ptArray.size() && m_TargetArray[dwBestMatch].nFrameCurr == 1) && m_TargetArray[dwBestMatch].m_bFirstInWander == true ) //因在徘徊区域内，检测目标对象判定为新对象，将该新对象的nFrameCurr，设置为该区域内最接近的对象的nFrameCurr
3125 3039 {
3126 3040 double bestDistance = 0;
3127 3041 CTarget best;
... ... @@ -3199,7 +3113,7 @@ void RegionSurveillance::WanderMonitoring(bool *pRegion_i, int dwBestMatch, int
3199 3113 m_TargetArray[dwBestMatch].m_bFirstInWander = false;
3200 3114  
3201 3115  
3202   - // 锟叫讹拷模锟斤拷锟角凤拷锟斤拷懈锟斤拷锟 0 锟斤拷锟斤拷 1锟狡筹拷
  3116 + // 判断模板是否进行更新 0 遗留 1移除
3203 3117 left_flag_now_w = detectLeftRemove(pRGBIn, ForBottom, ForTop, ForLeft, ForRight);
3204 3118 }
3205 3119 else
... ... @@ -3227,10 +3141,10 @@ void RegionSurveillance::WanderMonitoring(bool *pRegion_i, int dwBestMatch, int
3227 3141 }
3228 3142  
3229 3143  
3230   -// 锟斤拷锟斤拷锟斤拷锟
  3144 +// 丢包监测
3231 3145 void RegionSurveillance::StayMonitoring( int dwBestMatch, int ForBottom, int ForTop, int ForLeft, int ForRight, int indexROI, RegionInfo* pRegionInfo, unsigned char* pRGBIn)
3232 3146 {
3233   - // 目锟斤拷锟斤拷泳锟斤拷锟斤拷锟揭伙拷锟斤拷呓锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷泳锟斤拷锟斤拷锟斤拷牡锟轿伙拷诮锟斤拷锟斤拷锟
  3147 + // 目标外接矩形有一个边进入禁区且外接矩形中心点位于禁区内
3234 3148 int tar_size = m_TargetArray[dwBestMatch].m_ptArray.size();
3235 3149 int cur_dis;
3236 3150 bool flag = 0;
... ... @@ -3290,7 +3204,7 @@ void RegionSurveillance::StayMonitoring( int dwBestMatch, int ForBottom, int For
3290 3204 }
3291 3205 }
3292 3206  
3293   - // 锟叫讹拷模锟斤拷锟角凤拷锟斤拷懈锟斤拷锟 0 锟斤拷锟斤拷 1锟狡筹拷
  3207 + // 判断模板是否进行更新 0 遗留 1移除
3294 3208 left_flag_now_s = detectLeftRemove(pRGBIn, ForBottom, ForTop, ForLeft, ForRight);
3295 3209 }
3296 3210 //else
... ... @@ -3330,7 +3244,7 @@ void RegionSurveillance::RSrelease()
3330 3244 pAlarmInfo = NULL;
3331 3245 }
3332 3246  
3333   - // 锟酵凤拷m_TargetArray
  3247 + // 释放m_TargetArray
3334 3248 int i;
3335 3249 for (i = 0; i < (int)m_TargetArray.size(); i++)
3336 3250 {
... ...