|
|
/*********版权所有（C）2014，武汉高德红外股份有限公司***************
|
|
|
* 文件名称：Arith_BkgMonitor.cpp
|
|
|
* 文件标识：背景监控
|
|
|
* 内容摘要：目标跟踪的过程中，监控目标周围的背景的均值和方差变化，提高跟踪的抗干扰能力
|
|
|
* 其它说明："Arith_BkgMonitor"的函数、全局变量、宏定义，统一前缀为简写"BKM"。
|
|
|
* 当前版本：固化V2.0
|
|
|
* 创建作者：MSSu
|
|
|
* 创建日期：2015.03.16
|
|
|
*
|
|
|
* 修改记录1：
|
|
|
* 修改日期：2015.04.20
|
|
|
* 版 本 号：固化V2.0
|
|
|
* 修 改 人：MSSu
|
|
|
* 修改内容：算法整理及优化。
|
|
|
* 修改记录2：…
|
|
|
*******************************************************************/
|
|
|
#include "Arith_ImgOperate.h"
|
|
|
#include "Arith_Detector.h"
|
|
|
#include "Arith_BkgMonitor.h"
|
|
|
#include "Arith_TrackSAObj.h"
|
|
|
#include <opencv2/opencv.hpp>
|
|
|
|
|
|
BkgMonitor::BkgMonitor()
|
|
|
{
|
|
|
memset(g_GLB_bObj8BkgStatus, 0, sizeof(BBOOL) * GLB_OBJ_BKG_NUM); //20170227Whao，目标跟踪时8邻域方差异常标志
|
|
|
g_GLB_bComplexEnv = FALSE; //20170301，连续退出复杂环境帧计数及进入复杂环境标志
|
|
|
g_GLB_bCrossInterference = FALSE; //20170603，wsa,场景分析：判断是否有交错目标干扰
|
|
|
g_GLB_bMultiObj = FALSE; //20170301，连续多目标帧计数及标志
|
|
|
g_GLB_bMultiObjMerge = FALSE; //20170306，多目标合并标志位
|
|
|
g_GLB_bInterferenceMem = FALSE; //20170217Whao，干扰进记忆跟踪标志位和干扰方向
|
|
|
g_GLB_bInfrnDirection = GLB_INFRN_DIR_NONE; //20170217Whao，干扰进记忆跟踪标志位和干扰方向
|
|
|
g_GLB_nObj8BkgArrayIndex = 0; //20170220Whao，目标跟踪时8邻域背景监控均值与方差数据记录的数组当前下标
|
|
|
g_GLB_nObj8BkgFrames = 0; //20170220Whao，目标跟踪时8邻域背景监控均值与方差数据记录的总帧数
|
|
|
g_GLB_nExitInfrnMemCnt = 0; //20170302Whao，退出干扰进记忆跟踪帧计数
|
|
|
g_GLB_nMultiObjCnt = 0; //20170301，连续多目标帧计数及标志
|
|
|
g_GLB_nExitComplexEnv = 0; //20170301，连续退出复杂环境帧计数及进入复杂环境标志【DSP-B核移植】
|
|
|
g_GLB_nCrossInterferenceCnt = 0; //20170603，wsa,场景分析：交错目标干扰时目标逼近计数器
|
|
|
g_GLB_bObjGrayMean = 0.0; //20170216Whao，目标跟踪时目标4邻域均值【DSP-B核移植】
|
|
|
|
|
|
g_GLB_NearEdge = FALSE;
|
|
|
bJudgeBkgMean = FALSE;
|
|
|
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
//背景监控空间
|
|
|
memset(mrnBkgBlks, 0, 8 * sizeof(MINMAXRECT32S)); //目标跟踪时8邻域框
|
|
|
memset(DSP_GLB_Obj8BkgMeanArray, 0, sizeof(FLOAT32) * GLB_OBJ_BKG_FRM_NUM * GLB_OBJ_BKG_NUM);//目标跟踪时8邻域背景均值数组
|
|
|
memset(DSP_GLB_Obj8BkgStdArray, 0, sizeof(FLOAT32) * GLB_OBJ_BKG_FRM_NUM * GLB_OBJ_BKG_NUM);//目标跟踪时8邻域背景标准差数组
|
|
|
}
|
|
|
|
|
|
BkgMonitor::~BkgMonitor()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
//--函数定义
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
/**********************************************************
|
|
|
* 函数名称：BKM_BkgMonitor()
|
|
|
* 功能描述：对目标8邻域区域进行监控
|
|
|
* 输入参数：PIXELTYPE *pFrame
|
|
|
* SINT32 nWidth -- 图像宽度
|
|
|
* SINT32 nHeight -- 图像高度
|
|
|
* CENTERRECT crnObjRect -- 目标矩形
|
|
|
* SPEED32F AngleSpeed -- 角速度
|
|
|
* 输出参数：g_GLB_bComplexEnv
|
|
|
* g_GLB_bInterferenceMem
|
|
|
* 返 回 值：无
|
|
|
* 调用关系：无
|
|
|
* 其它说明：无
|
|
|
**********************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
/*************************************
|
|
|
* Method: BKM_BkgMonitor()
|
|
|
* Function Description:
|
|
|
* CreateData: 2025/2/18
|
|
|
* Input Param: GD_VIDEO_FRAME_S img -- 原始图像
|
|
|
* Input Param: GLB_INPUT * p_GLB_Input -- 随帧输入参数
|
|
|
* Input Param: GrayType nTrackGrayType -- 亮暗目标类型
|
|
|
* Input Param: CENTERRECT crCenterRect -- 搜索区域矩形
|
|
|
* Input Param: OBJECTSTATUS * pTrackStatus -- 跟踪状态结构体
|
|
|
* Output Param:
|
|
|
* Return: void
|
|
|
* Call Relation:
|
|
|
* Other Description:
|
|
|
*************************************/
|
|
|
void BkgMonitor::BKM_BkgMonitor(GD_VIDEO_FRAME_S img, GLB_INPUT* p_GLB_Input, GrayType nTrackGrayType, CENTERRECT crCenterRect, OBJECTSTATUS* pTrackStatus)
|
|
|
{
|
|
|
//20170216，监控目标的8邻域区域
|
|
|
MINMAXRECT32S mrnObj; //目标跟踪矩形
|
|
|
OBJECTMONITOR ObjectMONI; //目标场景监控信息
|
|
|
SINT16 nObjOutRadius = 5; //目标扩展半径，防止背景点包含目标点计算得出的均值和标准差有偏差
|
|
|
SINT16 nObjCenterX = 0; //目标中心点X坐标
|
|
|
SINT16 nObjCenterY = 0; //目标中心点Y坐标
|
|
|
SINT16 nObjWidth = 0; //目标中心点X坐标
|
|
|
SINT16 nObjHeight = 0; //目标中心点Y坐标
|
|
|
DOUBLE64 dGrayMean = 0.0f;
|
|
|
SINT16 nCnt = 0;
|
|
|
SINT16 i = 0;
|
|
|
SINT16 j = 0;
|
|
|
SINT16 nBkgWRadius = 0; //目标场景监控半径
|
|
|
SINT16 nBkgHRadius = 0; //目标场景监控半径
|
|
|
|
|
|
CENTERRECT crnObjRect = { 0 };
|
|
|
SINT32 nWidth = img.u32Width;
|
|
|
SINT32 nHeight = img.u32Height;
|
|
|
crnObjRect.cx = (SINT16)pTrackStatus->ptPos.x;
|
|
|
crnObjRect.cy = (SINT16)pTrackStatus->ptPos.y;
|
|
|
crnObjRect.w = MAX((SINT16)pTrackStatus->sfSize.w, 8);
|
|
|
crnObjRect.h = MAX((SINT16)pTrackStatus->sfSize.h, 8);
|
|
|
|
|
|
nBkgWRadius = (SINT16)(MAX(crnObjRect.w * 0.75, (crCenterRect.w - crnObjRect.w) / 2));
|
|
|
nBkgHRadius = (SINT16)(MAX(crnObjRect.h * 0.75, (crCenterRect.h - crnObjRect.h) / 2));
|
|
|
|
|
|
nObjCenterX = crnObjRect.cx;
|
|
|
nObjCenterY = crnObjRect.cy;
|
|
|
nObjWidth = crnObjRect.w;
|
|
|
nObjHeight = crnObjRect.h;
|
|
|
|
|
|
//20171208，这样取值对于形状姿态不规律的目标，可能取到背景区域
|
|
|
mrnObj.minX = MAX(0, MIN(nObjCenterX - nObjWidth / 2 - nObjOutRadius, nWidth - 1));
|
|
|
mrnObj.maxX = MAX(0, MIN(nObjCenterX + nObjWidth / 2 + nObjOutRadius, nWidth - 1));
|
|
|
mrnObj.minY = MAX(0, MIN(nObjCenterY - nObjHeight / 2 - nObjOutRadius, nHeight - 1));
|
|
|
mrnObj.maxY = MAX(0, MIN(nObjCenterY + nObjHeight / 2 + nObjOutRadius, nHeight - 1));
|
|
|
|
|
|
#if 0
|
|
|
// 计算区域的左上角坐标
|
|
|
int minX = mrnObj.minX;
|
|
|
int minY = mrnObj.minY;
|
|
|
|
|
|
// 计算扣取区域的宽度和高度
|
|
|
int width = nObjWidth;
|
|
|
int height = nObjHeight;
|
|
|
|
|
|
// 计算扣取区域在原始图像中的偏移量
|
|
|
int offset = minY * nWidth + minX;
|
|
|
|
|
|
// 构造 cv::Mat 对象
|
|
|
cv::Mat croppedImage(height, width, CV_8UC1);
|
|
|
|
|
|
for (int i = 0; i < height; ++i)
|
|
|
{
|
|
|
for (int j = 0; j < width; ++j)
|
|
|
{
|
|
|
croppedImage.at<uchar>(i, j) = ((UBYTE8*)img.u64VirAddr[0])[(i + minY)* nWidth + minX + j];
|
|
|
}
|
|
|
}
|
|
|
#endif
|
|
|
|
|
|
// 计算目标区域的均值
|
|
|
for (j = mrnObj.minY; j <= mrnObj.maxY; j++)
|
|
|
{
|
|
|
for (i = mrnObj.minX; i <= mrnObj.maxX; i++)
|
|
|
{
|
|
|
//dGrayMean += pFrame[j * nWidth + i];
|
|
|
if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
|
|
|
{
|
|
|
dGrayMean += ((UBYTE8*)img.u64VirAddr[0])[j * nWidth + i];
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
dGrayMean += ((UINT16*)img.u64VirAddr[0])[j * nWidth + i];
|
|
|
}
|
|
|
nCnt++;
|
|
|
}
|
|
|
}
|
|
|
g_GLB_bObjGrayMean = FLOAT32(dGrayMean / nCnt);
|
|
|
|
|
|
// 对目标8邻域区域进行监控
|
|
|
BKM_CalObjBkgMonitor(img, nWidth, nHeight, mrnObj, nBkgWRadius, nBkgHRadius, &ObjectMONI, nTrackGrayType, pTrackStatus->sfAglSpeed,
|
|
|
(FLOAT32*)DSP_GLB_Obj8BkgMeanArray, (FLOAT32*)DSP_GLB_Obj8BkgStdArray);
|
|
|
|
|
|
//区域场景分析，主要针对过杆
|
|
|
//20170221Whao，监控数组大于10以后才进行处理
|
|
|
//20170303Whao，仅对低空时判定过杆（伺服俯仰角<10°）
|
|
|
if ((g_GLB_nObj8BkgFrames > GLB_OBJ_BKG_FRM_NUM - 1) /*&& g_SERVO_stInput.fPitching < GLB_INFRN_PT_THRES*/)
|
|
|
{
|
|
|
BKM_AnalyzeBkg(p_GLB_Input, g_GLB_bObjGrayMean, (FLOAT32*)DSP_GLB_Obj8BkgMeanArray, (FLOAT32*)DSP_GLB_Obj8BkgStdArray, pTrackStatus);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
g_GLB_bInterferenceMem = false;
|
|
|
g_GLB_bInfrnDirection = GLB_INFRN_DIR_NONE;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**********************************************************
|
|
|
* 函数名称：BKM_CleanUpResult()
|
|
|
* 功能描述：清空场景监控结果
|
|
|
* 输入参数：
|
|
|
* 输出参数:
|
|
|
* 返 回 值：无
|
|
|
* 调用关系：无
|
|
|
* 其它说明：无
|
|
|
**********************************************************/
|
|
|
void BkgMonitor::BKM_CleanUpResult()
|
|
|
{
|
|
|
//20170220Whao，清空场景监控结果
|
|
|
memset(mrnBkgBlks, 0, 8 * sizeof(MINMAXRECT32S));
|
|
|
memset(&DSP_GLB_Obj8BkgMeanArray, 0, GLB_OBJ_BKG_FRM_NUM * GLB_OBJ_BKG_NUM * sizeof(FLOAT32));//目标跟踪时8邻域背景均值数组
|
|
|
memset(&DSP_GLB_Obj8BkgStdArray, 0, GLB_OBJ_BKG_FRM_NUM * GLB_OBJ_BKG_NUM * sizeof(FLOAT32)); //目标跟踪时8邻域背景标准差数组
|
|
|
memset(&g_GLB_bObj8BkgStatus, 0, GLB_OBJ_BKG_NUM * sizeof(BBOOL)); //目标跟踪时8邻域背景监控方差的变化趋势矩阵
|
|
|
g_GLB_nObj8BkgArrayIndex = 0;
|
|
|
g_GLB_nObj8BkgFrames = 0;
|
|
|
g_GLB_bInterferenceMem = false;
|
|
|
g_GLB_nExitInfrnMemCnt = 0;
|
|
|
g_GLB_bInfrnDirection = GLB_INFRN_DIR_NONE;
|
|
|
bJudgeBkgMean = false;
|
|
|
|
|
|
//20170603，清空交错干扰标志位和计数器
|
|
|
g_GLB_bCrossInterference = false;
|
|
|
g_GLB_nCrossInterferenceCnt = 0;
|
|
|
|
|
|
//20170301，清空多目标计数及标志
|
|
|
g_GLB_nMultiObjCnt = 0;
|
|
|
g_GLB_bMultiObj = false;
|
|
|
|
|
|
//20170306，清空多目标合并标志位
|
|
|
g_GLB_bMultiObjMerge = false;
|
|
|
|
|
|
//20170301，清空连续退出复杂环境帧计数及进入复杂环境标志
|
|
|
g_GLB_nExitComplexEnv = 0;
|
|
|
g_GLB_bComplexEnv = false;
|
|
|
}
|
|
|
|
|
|
|
|
|
/**********************************************************
|
|
|
* 函数名称：TO_CalObjBkgMonitor()
|
|
|
* 功能描述：对目标8邻域区域进行监控
|
|
|
* 输入参数：PIXELTYPE *pFrame -- 原始图像
|
|
|
* SINT32 nWidth -- 图像宽度
|
|
|
* SINT32 nHeight -- 图像高度
|
|
|
* MINMAXRECT32S mrnObj -- 目标矩形
|
|
|
* SINT32 nBkgRadius -- 邻域背景半径
|
|
|
* UBYTE8 nDetectGrayType -- 目标检测的灰度类型
|
|
|
* SPEED32F AngleSpeed -- 角速度
|
|
|
* 输出参数：OBJECTMONITOR *objSNR -- 目标场景监控结构体指针
|
|
|
* FLOAT32 *pdObj8BkgMeanArray-- 目标跟踪时8邻域背景监控均值
|
|
|
* FLOAT32 *pdObj8BkgStdArray -- 目标跟踪时8邻域背景监控方差
|
|
|
* 返 回 值：无
|
|
|
* 调用关系：无
|
|
|
* 其它说明：无
|
|
|
**********************************************************/
|
|
|
void BkgMonitor::BKM_CalObjBkgMonitor(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight,
|
|
|
MINMAXRECT32S mrnObj, SINT32 nBkgWRadius, SINT32 nBkgHRadius,
|
|
|
OBJECTMONITOR *objSNR, GrayType nDetectGrayType, SPEED32F AngleSpeed,
|
|
|
FLOAT32 *pdObj8BkgMeanArray, FLOAT32 *pdObj8BkgStdArray)
|
|
|
{
|
|
|
SINT32 i, j, k;
|
|
|
SINT32 nBGValue, nBGCnt; //背景点灰度、背景点计数
|
|
|
double dBGMean, dBGStd; //背景均值、方差
|
|
|
MINMAXRECT32S mrnBkg; //背景区域矩形
|
|
|
SINT32 nLineIndex, nIndex;
|
|
|
FLOAT32 fGrayMax, fGrayMin, fGrayMean;
|
|
|
SINT32 nGrayCnt;
|
|
|
SINT32 CenterX, CenterY;
|
|
|
|
|
|
//20170220，获取帧间的下标
|
|
|
if (g_GLB_nObj8BkgFrames < GLB_OBJ_BKG_FRM_NUM - 1)
|
|
|
{
|
|
|
g_GLB_nObj8BkgArrayIndex = g_GLB_nObj8BkgFrames;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
g_GLB_nObj8BkgArrayIndex = g_GLB_nObj8BkgFrames % GLB_OBJ_BKG_FRM_NUM;
|
|
|
}
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
//获取目标灰度值极值、均值【重复计算】及其坐标
|
|
|
nLineIndex = mrnObj.minY * nWidth;
|
|
|
CenterX = (mrnObj.minX + mrnObj.maxX) >> 1;
|
|
|
CenterY = (mrnObj.minY + mrnObj.maxY) >> 1;
|
|
|
//objSNR->ObjGray = pFrame[CenterY * nWidth + CenterX];
|
|
|
if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
|
|
|
{
|
|
|
objSNR->ObjGray = ((UBYTE8*)img.u64VirAddr[0])[CenterY * nWidth + CenterX];
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
objSNR->ObjGray = ((UINT16*)img.u64VirAddr[0])[CenterY * nWidth + CenterX];
|
|
|
}
|
|
|
fGrayMax = objSNR->ObjGray;
|
|
|
fGrayMin = objSNR->ObjGray;
|
|
|
fGrayMean = 0.0f;
|
|
|
nGrayCnt = 0;
|
|
|
for (i = mrnObj.minY; i <= mrnObj.maxY; i++)
|
|
|
{
|
|
|
for (j = mrnObj.minX; j <= mrnObj.maxX; j++)
|
|
|
{
|
|
|
nIndex = nLineIndex + j;
|
|
|
|
|
|
//目标灰度均值
|
|
|
//fGrayMean += (FLOAT32)(pFrame[nIndex]);
|
|
|
if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
|
|
|
{
|
|
|
fGrayMean += ((UBYTE8*)img.u64VirAddr[0])[nIndex];
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
fGrayMean += ((UINT16*)img.u64VirAddr[0])[nIndex];
|
|
|
}
|
|
|
nGrayCnt++;
|
|
|
}
|
|
|
nLineIndex += nWidth;
|
|
|
}
|
|
|
if (nGrayCnt > 0)
|
|
|
{
|
|
|
fGrayMean /= nGrayCnt;
|
|
|
}
|
|
|
|
|
|
//根据检测类型，获取目标灰度极值
|
|
|
//亮目标
|
|
|
if (GrayType::BrightTarget == nDetectGrayType)
|
|
|
{
|
|
|
objSNR->ObjGray = fGrayMax;
|
|
|
objSNR->ObjGrayMean = fGrayMean;
|
|
|
}
|
|
|
//暗目标
|
|
|
else if (GrayType::DarkTarget == nDetectGrayType)
|
|
|
{
|
|
|
objSNR->ObjGray = fGrayMin;
|
|
|
objSNR->ObjGrayMean = fGrayMean;
|
|
|
}
|
|
|
//亮暗全检测
|
|
|
else
|
|
|
{
|
|
|
objSNR->ObjGray = fGrayMean;
|
|
|
objSNR->ObjGrayMean = fGrayMean;
|
|
|
}
|
|
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
|
//统计背景均值、方差：划分为0-上、1-右上、2-右、3-右下、4-下、5-左下、6-左、7-左上8个背景区域
|
|
|
//计算背景窗口边界
|
|
|
mrnBkg.minX = MAX(0, MIN(mrnObj.minX - nBkgWRadius, nWidth - 1));
|
|
|
mrnBkg.maxX = MAX(0, MIN(mrnObj.maxX + nBkgWRadius, nWidth - 1));
|
|
|
mrnBkg.minY = MAX(0, MIN(mrnObj.minY - nBkgHRadius, nHeight - 1));
|
|
|
mrnBkg.maxY = MAX(0, MIN(mrnObj.maxY + nBkgHRadius, nHeight - 1));
|
|
|
|
|
|
//20170303，【防错】如果目标运动到图像边界，则方差数组和均值数组清零
|
|
|
if ((0 == mrnObj.minX) || (0 == mrnObj.minY) || ((nWidth - 1) == mrnObj.maxX) || ((nWidth - 1) == mrnObj.maxY))
|
|
|
{
|
|
|
for (i = 0; i < GLB_OBJ_BKG_NUM; i++)
|
|
|
{
|
|
|
nIndex = g_GLB_nObj8BkgArrayIndex * GLB_OBJ_BKG_NUM + i;
|
|
|
pdObj8BkgMeanArray[nIndex] = 0.0;
|
|
|
pdObj8BkgStdArray[nIndex] = 0.0;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
//MSSu, 20170607: 以下代码可简化到一个for循环内执行，先保存每个每个背景区域的边界矩形数组即可。
|
|
|
//背景区域0-上
|
|
|
mrnBkgBlks[0] = mrnObj;
|
|
|
mrnBkgBlks[0].minY = mrnBkg.minY;
|
|
|
mrnBkgBlks[0].maxY = mrnObj.minY - 1;
|
|
|
//背景区域1-右上
|
|
|
mrnBkgBlks[1] = mrnBkgBlks[0];
|
|
|
mrnBkgBlks[1].minX = mrnObj.maxX + 1;
|
|
|
mrnBkgBlks[1].maxX = mrnBkg.maxX;
|
|
|
//背景区域2-右
|
|
|
mrnBkgBlks[2] = mrnObj;
|
|
|
mrnBkgBlks[2].minX = mrnBkgBlks[1].minX;
|
|
|
mrnBkgBlks[2].maxX = mrnBkgBlks[1].maxX;
|
|
|
//背景区域3-右下
|
|
|
mrnBkgBlks[3] = mrnBkgBlks[2];
|
|
|
mrnBkgBlks[3].minY = mrnObj.maxY + 1;
|
|
|
mrnBkgBlks[3].maxY = mrnBkg.maxY;
|
|
|
//背景区域4-下
|
|
|
mrnBkgBlks[4] = mrnObj;
|
|
|
mrnBkgBlks[4].minY = mrnBkgBlks[3].minY;
|
|
|
mrnBkgBlks[4].maxY = mrnBkgBlks[3].maxY;
|
|
|
//背景区域5-左下
|
|
|
mrnBkgBlks[5] = mrnBkgBlks[4];
|
|
|
mrnBkgBlks[5].minX = mrnBkg.minX;
|
|
|
mrnBkgBlks[5].maxX = mrnObj.minX - 1;
|
|
|
#if 0
|
|
|
// 计算区域的左上角坐标
|
|
|
int minX = mrnBkgBlks[5].minX;
|
|
|
int minY = mrnBkgBlks[5].minY;
|
|
|
|
|
|
// 计算扣取区域的宽度和高度
|
|
|
int width = mrnBkgBlks[5].maxX - mrnBkgBlks[5].minX;
|
|
|
int height = mrnBkgBlks[5].maxY - mrnBkgBlks[5].minY;
|
|
|
|
|
|
// 计算扣取区域在原始图像中的偏移量
|
|
|
int offset = minY * nWidth + minX;
|
|
|
|
|
|
// 构造 cv::Mat 对象
|
|
|
cv::Mat region5(height, width, CV_8UC1);
|
|
|
|
|
|
for (int i = 0; i < height; ++i)
|
|
|
{
|
|
|
for (int j = 0; j < width; ++j)
|
|
|
{
|
|
|
region5.at<uchar>(i, j) = ((UBYTE8*)img.u64VirAddr[0])[(i + minY) * nWidth + minX + j];
|
|
|
}
|
|
|
}
|
|
|
#endif
|
|
|
//背景区域6-左
|
|
|
mrnBkgBlks[6] = mrnObj;
|
|
|
mrnBkgBlks[6].minX = mrnBkgBlks[5].minX;
|
|
|
mrnBkgBlks[6].maxX = mrnBkgBlks[5].maxX;
|
|
|
//背景区域7-左上
|
|
|
mrnBkgBlks[7] = mrnBkgBlks[6];
|
|
|
mrnBkgBlks[7].minY = mrnBkgBlks[0].minY;
|
|
|
mrnBkgBlks[7].maxY = mrnBkgBlks[0].maxY;
|
|
|
|
|
|
//遍历每个背景分块，抛掉最大值、最小值
|
|
|
for (k = 0; k < GLB_OBJ_BKG_NUM; k++)
|
|
|
{
|
|
|
//统计背景均值、方差
|
|
|
double dBlkMin = 1e6;
|
|
|
double dBlkMax = 1e-6;
|
|
|
nBGCnt = 0;
|
|
|
dBGMean = 0;
|
|
|
dBGStd = 0;
|
|
|
nLineIndex = mrnBkgBlks[k].minY * nWidth;
|
|
|
for (i = mrnBkgBlks[k].minY; i <= mrnBkgBlks[k].maxY; i++)
|
|
|
{
|
|
|
for (j = mrnBkgBlks[k].minX; j <= mrnBkgBlks[k].maxX; j++)
|
|
|
{
|
|
|
nIndex = nLineIndex + j;
|
|
|
//nBGValue = pFrame[nIndex];
|
|
|
if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
|
|
|
{
|
|
|
nBGValue = ((UBYTE8*)img.u64VirAddr[0])[nIndex];
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
nBGValue = ((UINT16*)img.u64VirAddr[0])[nIndex];
|
|
|
}
|
|
|
//背景灰度及灰度平方累加
|
|
|
dBGMean += (double)nBGValue;
|
|
|
dBGStd += (double)nBGValue * nBGValue;
|
|
|
nBGCnt++;
|
|
|
dBlkMin = MIN(dBlkMin, nBGValue);
|
|
|
dBlkMax = MAX(dBlkMax, nBGValue);
|
|
|
}
|
|
|
nLineIndex += nWidth;
|
|
|
}
|
|
|
|
|
|
//计算上背景均值、方差
|
|
|
nIndex = g_GLB_nObj8BkgArrayIndex * GLB_OBJ_BKG_NUM + k;
|
|
|
dBGMean -= (dBlkMin + dBlkMax);
|
|
|
dBGStd -= (dBlkMin * dBlkMin + dBlkMax * dBlkMax);
|
|
|
nBGCnt -= 2;
|
|
|
pdObj8BkgMeanArray[nIndex] = FLOAT32( dBGMean / (double)nBGCnt);
|
|
|
pdObj8BkgStdArray[nIndex] = FLOAT32(dBGStd / (double)nBGCnt);
|
|
|
pdObj8BkgStdArray[nIndex] -= pdObj8BkgMeanArray[nIndex] * pdObj8BkgMeanArray[nIndex];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//20170227，更新邻域背景是否异常状态，如分割不准确导致的方差异常
|
|
|
BKM_UpdateObjBkgStatus(pdObj8BkgStdArray);
|
|
|
|
|
|
//BKM_UpdateObjBkgMean(pdObj8BkgMeanArray);
|
|
|
|
|
|
//20170220，帧数累加
|
|
|
g_GLB_nObj8BkgFrames++;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
/**********************************************************
|
|
|
* 函数名称：BKM_AnalyzeBkg()
|
|
|
* 功能描述：目标背景区域场景分析，过杆分析
|
|
|
* 输入参数：SPEED32F AngleSpeed -- 角速度
|
|
|
* DOUBLE64 bObjGrayMean -- 目标灰度均值
|
|
|
* DOUBLE64 *pdObj8BkgMeanArray-- 目标跟踪时8邻域背景监控均值
|
|
|
* DOUBLE64 *pdObj8BkgStdArray -- 目标跟踪时8邻域背景监控方差
|
|
|
* 输出参数：无
|
|
|
* 返 回 值：无
|
|
|
* 调用关系：无
|
|
|
* 其它说明：无
|
|
|
**********************************************************/
|
|
|
void BkgMonitor::BKM_AnalyzeBkg(GLB_INPUT* p_GLB_Input, FLOAT32 bObjGrayMean,
|
|
|
FLOAT32 *pdObj8BkgMeanArray, FLOAT32 *pdObj8BkgStdArray, OBJECTSTATUS* pTrackStatus)
|
|
|
{
|
|
|
SINT32 i;
|
|
|
SINT16 nValidCnt = 0; //判别有效性计数
|
|
|
BBOOL bJudgeBkgStd = false; //判别背景区域方差可转自动跟踪标志位
|
|
|
SINT32 nStdThreshold = 5000; //2500; //方差预警阈值
|
|
|
SINT32 nIndexCurrFrm = g_GLB_nObj8BkgArrayIndex * GLB_OBJ_BKG_NUM; //10
|
|
|
FLOAT32 fSpeedThresh = 0.0025f; //目标过杆判断速度阈值 20161216141048目标过杆速度为0.029
|
|
|
SPEED32F AngleSpeed = pTrackStatus->sfAglSpeed;
|
|
|
//20170301，如果已经判断在过云，则不进行过杆判断，防止已经在过云过程中进此条件进记忆跟踪
|
|
|
//20170302，【屏蔽】过杆优先级更高
|
|
|
if (g_GLB_bComplexEnv)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
// 调整可见光的方差阈值
|
|
|
if (GLB_VIDEO_TYPE::GLB_VIDEO_VL == p_GLB_Input->unVideoSrc)
|
|
|
{
|
|
|
nStdThreshold = 500;
|
|
|
}
|
|
|
|
|
|
|
|
|
// 单帧分左右会受到预测不准确，目标特征的影响
|
|
|
FLOAT32 leftMean = (pdObj8BkgMeanArray[nIndexCurrFrm + 5] + pdObj8BkgMeanArray[nIndexCurrFrm + 6] + pdObj8BkgMeanArray[nIndexCurrFrm + 7]) / 3;
|
|
|
FLOAT32 rightMean = (pdObj8BkgMeanArray[nIndexCurrFrm + 1] + pdObj8BkgMeanArray[nIndexCurrFrm + 2] + pdObj8BkgMeanArray[nIndexCurrFrm + 3]) / 3;
|
|
|
//过杆判断
|
|
|
if (!g_GLB_bInterferenceMem)
|
|
|
{
|
|
|
//20170302，水平过杆
|
|
|
if (fabs(AngleSpeed.vx) > fabs(AngleSpeed.vy))
|
|
|
{
|
|
|
//水平过杆方向判断
|
|
|
//20171207，过杆判断采用速度阈值，防止静止的目标判断为过杆
|
|
|
if(AngleSpeed.vx < -fSpeedThresh)
|
|
|
{
|
|
|
//目标向左运动，判断左侧三个邻域的均值和方差，若左+左上或左+左下的梯度值大于预警阈值
|
|
|
g_GLB_bInfrnDirection = GLB_INFRN_DIR_LEFT;
|
|
|
//判断前方有杆，提前进记忆跟踪
|
|
|
if ((pdObj8BkgStdArray[nIndexCurrFrm + 7] > nStdThreshold
|
|
|
&& pdObj8BkgStdArray[nIndexCurrFrm + 6] > nStdThreshold)
|
|
|
|| (pdObj8BkgStdArray[nIndexCurrFrm + 6] > nStdThreshold
|
|
|
&& pdObj8BkgStdArray[nIndexCurrFrm + 5] > nStdThreshold))
|
|
|
{
|
|
|
//置干扰进记忆跟踪标志为真
|
|
|
g_GLB_bInterferenceMem = true;
|
|
|
}
|
|
|
|
|
|
//单凭借方差在轮廓不清晰的背景，无法准确判断，需要结合背景灰度(默认可见光为暗目标)
|
|
|
if (GLB_VIDEO_TYPE::GLB_VIDEO_VL == p_GLB_Input->unVideoSrc)
|
|
|
{
|
|
|
if (rightMean - leftMean > 20)
|
|
|
{
|
|
|
g_GLB_bInterferenceMem = true;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
|
|
|
}
|
|
|
}
|
|
|
//else
|
|
|
//20171207，过杆判断采用速度阈值，防止静止的目标判断为过杆
|
|
|
if (AngleSpeed.vx > fSpeedThresh)
|
|
|
{
|
|
|
//目标向右运动，判断右侧三个邻域的均值和方差，若左+左上或左+左下的梯度值大于预警阈值
|
|
|
g_GLB_bInfrnDirection = GLB_INFRN_DIR_RIGHT;
|
|
|
//判断前方有杆，提前进记忆跟踪
|
|
|
if ((pdObj8BkgStdArray[nIndexCurrFrm + 1] > nStdThreshold
|
|
|
&& pdObj8BkgStdArray[nIndexCurrFrm + 2] > nStdThreshold)
|
|
|
|| (pdObj8BkgStdArray[nIndexCurrFrm + 2] > nStdThreshold
|
|
|
&& pdObj8BkgStdArray[nIndexCurrFrm + 3] > nStdThreshold))
|
|
|
{
|
|
|
//置干扰进记忆跟踪标志为真
|
|
|
g_GLB_bInterferenceMem = true;
|
|
|
}
|
|
|
|
|
|
//单凭借方差在轮廓不清晰的背景，无法准确判断，需要结合背景灰度(默认可见光为暗目标)
|
|
|
if (GLB_VIDEO_TYPE::GLB_VIDEO_VL == p_GLB_Input->unVideoSrc)
|
|
|
{
|
|
|
if (leftMean - rightMean > 20)
|
|
|
{
|
|
|
g_GLB_bInterferenceMem = true;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
// //不考虑垂直方向过杆，避免云层干扰
|
|
|
// else
|
|
|
// {
|
|
|
// //垂直方向判断
|
|
|
// if (AngleSpeed.vy < 0)
|
|
|
// {
|
|
|
// //目标向下运动，判断下侧三个邻域的均值和方差，若下+左下或下+右下的梯度值大于预警阈值
|
|
|
// //判断下方有杆，提前进记忆跟踪
|
|
|
// if ((pdObj8BkgStdArray[nIndexCurrFrm + 3] > nStdThreshold
|
|
|
// && pdObj8BkgStdArray[nIndexCurrFrm + 4] > nStdThreshold)
|
|
|
// || (pdObj8BkgStdArray[nIndexCurrFrm + 4] > nStdThreshold
|
|
|
// && pdObj8BkgStdArray[nIndexCurrFrm + 5] > nStdThreshold))
|
|
|
// {
|
|
|
// //置干扰进记忆跟踪标志为真
|
|
|
// g_GLB_bInterferenceMem = true;
|
|
|
// g_GLB_bInfrnDirection = GLB_INFRN_DIR_DOWN;
|
|
|
// }
|
|
|
// }
|
|
|
// else
|
|
|
// {
|
|
|
// //目标向上运动，判断下侧三个邻域的均值和方差，若上+左上或上+右上的梯度值大于预警阈值
|
|
|
// //判断上方有杆，提前进记忆跟踪
|
|
|
// if ((pdObj8BkgStdArray[nIndexCurrFrm + 7] > nStdThreshold
|
|
|
// && pdObj8BkgStdArray[nIndexCurrFrm + 0] > nStdThreshold)
|
|
|
// || (pdObj8BkgStdArray[nIndexCurrFrm + 0] > nStdThreshold
|
|
|
// && pdObj8BkgStdArray[nIndexCurrFrm + 1] > nStdThreshold))
|
|
|
// {
|
|
|
// //置干扰进记忆跟踪标志为真
|
|
|
// g_GLB_bInterferenceMem = true;
|
|
|
// g_GLB_bInfrnDirection = GLB_INFRN_DIR_UP;
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
}
|
|
|
|
|
|
//解除干扰，置干扰进记忆跟踪标志为假
|
|
|
if (g_GLB_bInterferenceMem)
|
|
|
{
|
|
|
////背景区域均值均小于目标均值，【这里考虑的是亮目标过杆】
|
|
|
//for (i = 0; i < GLB_OBJ_BKG_NUM; i++)
|
|
|
//{
|
|
|
// if (bObjGrayMean > pdObj8BkgMeanArray[nIndexCurrFrm + i])
|
|
|
// {
|
|
|
// nValidCnt++;
|
|
|
// }
|
|
|
//}
|
|
|
|
|
|
if (GLB_INFRN_DIR_RIGHT == g_GLB_bInfrnDirection)
|
|
|
{
|
|
|
//水平运动时，目标的上三背景区域方差或者下三背景区域方差均小于阈值，即场景趋于平坦
|
|
|
if ((pdObj8BkgStdArray[nIndexCurrFrm + 0] < nStdThreshold
|
|
|
&& pdObj8BkgStdArray[nIndexCurrFrm + 1] < nStdThreshold)
|
|
|
|| (pdObj8BkgStdArray[nIndexCurrFrm + 4] < nStdThreshold
|
|
|
&& pdObj8BkgStdArray[nIndexCurrFrm + 3] < nStdThreshold))
|
|
|
{
|
|
|
bJudgeBkgStd = true;
|
|
|
}
|
|
|
|
|
|
if (GLB_VIDEO_TYPE::GLB_VIDEO_VL == p_GLB_Input->unVideoSrc)
|
|
|
{
|
|
|
// 暗目标向右出遮挡区域
|
|
|
if (pdObj8BkgMeanArray[nIndexCurrFrm + 7] + 20 < pdObj8BkgMeanArray[nIndexCurrFrm + 1] ||
|
|
|
pdObj8BkgMeanArray[nIndexCurrFrm + 5] + 20 < pdObj8BkgMeanArray[nIndexCurrFrm + 3])
|
|
|
{
|
|
|
bJudgeBkgMean = true;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (pdObj8BkgMeanArray[nIndexCurrFrm + 7] > pdObj8BkgMeanArray[nIndexCurrFrm + 1] + 100 ||
|
|
|
pdObj8BkgMeanArray[nIndexCurrFrm + 5] > pdObj8BkgMeanArray[nIndexCurrFrm + 3] + 100)
|
|
|
{
|
|
|
bJudgeBkgMean = true;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
else if (GLB_INFRN_DIR_LEFT == g_GLB_bInfrnDirection)
|
|
|
{
|
|
|
//水平运动时，目标的上三背景区域方差或者下三背景区域方差均小于阈值，即场景趋于平坦
|
|
|
if ((pdObj8BkgStdArray[nIndexCurrFrm + 0] < nStdThreshold
|
|
|
&& pdObj8BkgStdArray[nIndexCurrFrm + 7] < nStdThreshold)
|
|
|
|| (pdObj8BkgStdArray[nIndexCurrFrm + 5] < nStdThreshold
|
|
|
&& pdObj8BkgStdArray[nIndexCurrFrm + 4] < nStdThreshold))
|
|
|
{
|
|
|
bJudgeBkgStd = true;
|
|
|
}
|
|
|
|
|
|
if (GLB_VIDEO_TYPE::GLB_VIDEO_VL == p_GLB_Input->unVideoSrc)
|
|
|
{
|
|
|
if (pdObj8BkgMeanArray[nIndexCurrFrm + 7] > pdObj8BkgMeanArray[nIndexCurrFrm + 1] + 20 ||
|
|
|
pdObj8BkgMeanArray[nIndexCurrFrm + 5] > pdObj8BkgMeanArray[nIndexCurrFrm + 3] + 20)
|
|
|
{
|
|
|
bJudgeBkgMean = true;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (pdObj8BkgMeanArray[nIndexCurrFrm + 7] + 100 < pdObj8BkgMeanArray[nIndexCurrFrm + 1] ||
|
|
|
pdObj8BkgMeanArray[nIndexCurrFrm + 5] + 100 < pdObj8BkgMeanArray[nIndexCurrFrm + 3])
|
|
|
{
|
|
|
bJudgeBkgMean = true;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//20170414，暂不判断垂直运动
|
|
|
// else if (GLB_INFRN_DIR_DOWN == g_GLB_bInfrnDirection || GLB_INFRN_DIR_UP == g_GLB_bInfrnDirection)
|
|
|
// {
|
|
|
// //垂直运动时，目标的左三背景区域方差或者右三背景区域方差均小于阈值，即场景趋于平坦
|
|
|
// if ((pdObj8BkgStdArray[nIndexCurrFrm + 5] < nStdThreshold
|
|
|
// && pdObj8BkgStdArray[nIndexCurrFrm + 6] < nStdThreshold
|
|
|
// && pdObj8BkgStdArray[nIndexCurrFrm + 7] < nStdThreshold)
|
|
|
// || (pdObj8BkgStdArray[nIndexCurrFrm + 3] < nStdThreshold
|
|
|
// && pdObj8BkgStdArray[nIndexCurrFrm + 2] < nStdThreshold
|
|
|
// && pdObj8BkgStdArray[nIndexCurrFrm + 1] < nStdThreshold))
|
|
|
// {
|
|
|
// //除了考虑目标左右背景之外，上下背景方差用来区别进入干扰和退出干扰
|
|
|
// if (pdObj8BkgStdArray[nIndexCurrFrm + 0] < nStdThreshold
|
|
|
// && pdObj8BkgStdArray[nIndexCurrFrm + 4] < nStdThreshold)
|
|
|
// {
|
|
|
// bJudgeBkgStd = true;
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
else
|
|
|
{
|
|
|
//暂不处理
|
|
|
}
|
|
|
|
|
|
//20170914,wsa，对20161201_170642_2进行测试发现6400帧过杆时，由于面目标偏离预测位置一点点，导致计算
|
|
|
//出来的背景（包含真实目标区域）方差并不是很准，不满足方差条件导致无法退出干扰，改进时加入相似度判别
|
|
|
//若均值和方差条件均满足可转自动跟踪情况，置标志位为假
|
|
|
if (bJudgeBkgMean && bJudgeBkgStd || pTrackStatus->unContiLostCnt > p_GLB_Input->unFreq * 3)
|
|
|
{
|
|
|
g_GLB_nExitInfrnMemCnt++;
|
|
|
if (g_GLB_nExitInfrnMemCnt > GLB_EXIT_INFRN_MEM_CNT)
|
|
|
{
|
|
|
g_GLB_bInterferenceMem = false;
|
|
|
bJudgeBkgMean = false;
|
|
|
g_GLB_nExitInfrnMemCnt = 0;
|
|
|
g_GLB_bInfrnDirection = GLB_INFRN_DIR_NONE;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
g_GLB_nExitInfrnMemCnt = 0;
|
|
|
//g_GLB_bInfrnDirection = GLB_INFRN_DIR_NONE;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**********************************************************
|
|
|
* 函数名称：BKM_UpdateObjBkgStatus()
|
|
|
* 功能描述：更新邻域背景是否异常状态，如分割不准确导致的方差异常
|
|
|
* 输入参数：FLOAT32 *pdObj8BkgStdArray -- 目标跟踪时8邻域背景监控方差
|
|
|
* 输出参数：无
|
|
|
* 返 回 值：无
|
|
|
* 调用关系：无
|
|
|
* 其它说明：无
|
|
|
**********************************************************/
|
|
|
void BkgMonitor::BKM_UpdateObjBkgStatus(FLOAT32 *pdObj8BkgStdArray)
|
|
|
{
|
|
|
FLOAT32 ardMeanOf8BkgStd[GLB_OBJ_BKG_FRM_NUM] = {0.0}; //方差的均值，10帧
|
|
|
SINT32 i, j;
|
|
|
SINT32 nAbnormalCnt = 0; //异常帧计数器
|
|
|
FLOAT32 dBGMean = 0.0; //均值
|
|
|
FLOAT32 dBGValue = 0.0; //当前值
|
|
|
FLOAT32 dAbnormalStdThres = 2000; //超过阈值2000直接视为异常
|
|
|
|
|
|
//20170301，如果已经判断在过杆，则不进行过杆云判断，过杆优先级更高
|
|
|
if (g_GLB_bInterferenceMem)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
//若不满10帧不进行变化趋势计算
|
|
|
if (g_GLB_nObj8BkgFrames < GLB_OBJ_BKG_FRM_NUM - 1)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
//计算最近10帧背景方差的均值
|
|
|
//MSSu, 20170307: 此处重复计算。可在每帧保存背景块方差时，直接计算好
|
|
|
for (j = 0; j < GLB_OBJ_BKG_FRM_NUM; j++)
|
|
|
{
|
|
|
dBGMean = 0.0;
|
|
|
//遍历每帧记录
|
|
|
for (i = 0; i < GLB_OBJ_BKG_NUM; i++)
|
|
|
{
|
|
|
//当前值，求和
|
|
|
dBGValue = pdObj8BkgStdArray[j * GLB_OBJ_BKG_NUM + i];
|
|
|
dBGMean += (FLOAT32)dBGValue;
|
|
|
}
|
|
|
ardMeanOf8BkgStd[j] = dBGMean / GLB_OBJ_BKG_NUM;
|
|
|
}
|
|
|
|
|
|
//分别比较8块邻域和背景方差的差异，找出异常背景块
|
|
|
for (i = 0; i < GLB_OBJ_BKG_NUM; i++)
|
|
|
{
|
|
|
nAbnormalCnt = 0;
|
|
|
for (j = 0; j < GLB_OBJ_BKG_FRM_NUM; j++)
|
|
|
{
|
|
|
if (pdObj8BkgStdArray[j * GLB_OBJ_BKG_NUM + i] > 1.5 * ardMeanOf8BkgStd[j])
|
|
|
{
|
|
|
nAbnormalCnt++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//10帧的异常帧数超过5帧且大于阈值则认为该背景块异常
|
|
|
if (nAbnormalCnt > 0.5 * GLB_OBJ_BKG_FRM_NUM
|
|
|
|| pdObj8BkgStdArray[g_GLB_nObj8BkgArrayIndex * GLB_OBJ_BKG_NUM + i] > dAbnormalStdThres)
|
|
|
{
|
|
|
g_GLB_bObj8BkgStatus[i] = GLB_OBJ_BKG_STD_ABNORMAL;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
g_GLB_bObj8BkgStatus[i] = GLB_OBJ_BKG_STD_NORMAL;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
//// 判断接近强边缘,此时异常块大概率呈现一边倒趋势，至少出现连续3个true
|
|
|
//for (SINT32 i = 0; i < GLB_OBJ_BKG_NUM; i++)
|
|
|
//{
|
|
|
// SINT32 BLK1 = i;
|
|
|
// SINT32 BLK2 = (i + 1) % GLB_OBJ_BKG_NUM;
|
|
|
// SINT32 BLK3 = (i + 2) % GLB_OBJ_BKG_NUM;
|
|
|
// if (g_GLB_bObj8BkgStatus[BLK1] + g_GLB_bObj8BkgStatus[BLK2] + g_GLB_bObj8BkgStatus[BLK3] == 3)
|
|
|
// {
|
|
|
// int a = 0;
|
|
|
// }
|
|
|
//}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//20170228，若背景环境复杂，如鱼鳞状云，8邻域区域有一半方差异常，不进行合并
|
|
|
SINT16 nAbnormalBlkCnt = 0; //异常背景块计数
|
|
|
//统计异常背景块个数
|
|
|
for (i = 0; i < GLB_OBJ_BKG_NUM; i++)
|
|
|
{
|
|
|
if (g_GLB_bObj8BkgStatus[i])
|
|
|
{
|
|
|
nAbnormalBlkCnt++;
|
|
|
}
|
|
|
}
|
|
|
//更新复杂场景标志位及退出复杂场景帧计数
|
|
|
if (nAbnormalBlkCnt > GLB_OBJ_BKG_NUM / 2 - 1)
|
|
|
{
|
|
|
//退出复杂场景帧数清零
|
|
|
g_GLB_nExitComplexEnv = 0;
|
|
|
|
|
|
//进入复杂场景第一帧，复杂场景标志位置为真
|
|
|
if (!g_GLB_bComplexEnv)
|
|
|
{
|
|
|
g_GLB_bComplexEnv = true;
|
|
|
}
|
|
|
|
|
|
////人工调整一次分割阈值，保证目标与背景的区分度
|
|
|
//if (g_DAT_stPara.nGrayThresMinBright < DAT_GRAY_THRES_MAX)
|
|
|
//{
|
|
|
// g_DAT_stPara.nGrayThresMinBright = (g_DAT_stPara.nGrayThresMinBright + DAT_GRAY_THRES_MAX) / 2;
|
|
|
//}
|
|
|
|
|
|
//if (g_DAT_stPara.nGrayThresMinDark < DAT_GRAY_THRES_MAX)
|
|
|
//{
|
|
|
// g_DAT_stPara.nGrayThresMinDark = (g_DAT_stPara.nGrayThresMinDark + DAT_GRAY_THRES_MAX) / 2;
|
|
|
//}
|
|
|
|
|
|
//if (g_DAT_stPara.nGradThresMin < DAT_GRAD_THRES_MAX)
|
|
|
//{
|
|
|
// g_DAT_stPara.nGradThresMin = (g_DAT_stPara.nGradThresMin + DAT_GRAD_THRES_MAX) / 2;
|
|
|
//}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
//累计退出复杂场景帧计数
|
|
|
g_GLB_nExitComplexEnv++;
|
|
|
|
|
|
//若帧计数超过阈值，则异常环境标志位置为假
|
|
|
if (g_GLB_nExitComplexEnv > GLB_EXIT_CMPLX_ENV_CNT && g_GLB_bComplexEnv)
|
|
|
{
|
|
|
g_GLB_bComplexEnv = false;
|
|
|
////人工调整一次分割阈值，保证目标分割的完整性
|
|
|
//if (g_DAT_stPara.nGrayThresMinBright > DAT_GRAY_THRES_MIN)
|
|
|
//{
|
|
|
// g_DAT_stPara.nGrayThresMinBright = DAT_GRAY_THRES_MIN;
|
|
|
//}
|
|
|
|
|
|
//if (g_DAT_stPara.nGrayThresMinDark > DAT_GRAY_THRES_MIN)
|
|
|
//{
|
|
|
// g_DAT_stPara.nGrayThresMinDark = DAT_GRAY_THRES_MIN;
|
|
|
//}
|
|
|
|
|
|
//if (g_DAT_stPara.nGradThresMin > DAT_GRAD_THRES_MIN)
|
|
|
//{
|
|
|
// g_DAT_stPara.nGradThresMin = DAT_GRAD_THRES_MIN;
|
|
|
//}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void BkgMonitor::BKM_UpdateObjBkgMean(FLOAT32* pdObj8BkgMeanArray)
|
|
|
{
|
|
|
FLOAT32 ardMeanOf8BkgGray[GLB_OBJ_BKG_NUM] = { 0.0 }; //灰度的均值，8个方向
|
|
|
SINT32 i, j;
|
|
|
SINT32 nAbnormalCnt = 0; //异常帧计数器
|
|
|
FLOAT32 dBGMean = 0.0; //均值
|
|
|
FLOAT32 dBGValue = 0.0; //当前值
|
|
|
FLOAT32 dAbnormalStdThres = 2000; //超过阈值2000直接视为异常
|
|
|
|
|
|
////20170301，如果已经判断在过杆，则不进行过杆云判断，过杆优先级更高
|
|
|
//if (g_GLB_bInterferenceMem)
|
|
|
//{
|
|
|
// return;
|
|
|
//}
|
|
|
|
|
|
//若不满10帧不进行变化趋势计算
|
|
|
if (g_GLB_nObj8BkgFrames < GLB_OBJ_BKG_FRM_NUM - 1)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
|
|
|
//每个块计算连续10帧灰度的均值
|
|
|
for (i = 0; i < GLB_OBJ_BKG_NUM; i++)
|
|
|
{
|
|
|
dBGMean = 0.0;
|
|
|
for (j = 0; j < GLB_OBJ_BKG_FRM_NUM; j++)
|
|
|
{
|
|
|
dBGValue = pdObj8BkgMeanArray[i + j * GLB_OBJ_BKG_FRM_NUM];
|
|
|
dBGMean += (FLOAT32)dBGValue;
|
|
|
}
|
|
|
ardMeanOf8BkgGray[i] = dBGMean / GLB_OBJ_BKG_FRM_NUM;
|
|
|
}
|
|
|
|
|
|
////分别比较8块邻域和背景方差的差异，找出异常背景块
|
|
|
//for (i = 0; i < GLB_OBJ_BKG_NUM; i++)
|
|
|
//{
|
|
|
// nAbnormalCnt = 0;
|
|
|
// for (j = 0; j < GLB_OBJ_BKG_FRM_NUM; j++)
|
|
|
// {
|
|
|
// if (pdObj8BkgStdArray[j * GLB_OBJ_BKG_NUM + i] > 1.5 * ardMeanOf8BkgStd[j])
|
|
|
// {
|
|
|
// nAbnormalCnt++;
|
|
|
// }
|
|
|
// }
|
|
|
|
|
|
// //10帧的异常帧数超过5帧且大于阈值则认为该背景块异常
|
|
|
// if (nAbnormalCnt > 0.5 * GLB_OBJ_BKG_FRM_NUM
|
|
|
// || pdObj8BkgStdArray[g_GLB_nObj8BkgArrayIndex * GLB_OBJ_BKG_NUM + i] > dAbnormalStdThres)
|
|
|
// {
|
|
|
// g_GLB_bObj8BkgStatus[i] = GLB_OBJ_BKG_STD_ABNORMAL;
|
|
|
// }
|
|
|
// else
|
|
|
// {
|
|
|
// g_GLB_bObj8BkgStatus[i] = GLB_OBJ_BKG_STD_NORMAL;
|
|
|
// }
|
|
|
//}
|
|
|
|
|
|
|
|
|
|
|
|
////20170228，若背景环境复杂，如鱼鳞状云，8邻域区域有一半方差异常，不进行合并
|
|
|
//SINT16 nAbnormalBlkCnt = 0; //异常背景块计数
|
|
|
////统计异常背景块个数
|
|
|
//for (i = 0; i < GLB_OBJ_BKG_NUM; i++)
|
|
|
//{
|
|
|
// if (g_GLB_bObj8BkgStatus[i])
|
|
|
// {
|
|
|
// nAbnormalBlkCnt++;
|
|
|
// }
|
|
|
//}
|
|
|
////更新复杂场景标志位及退出复杂场景帧计数
|
|
|
//if (nAbnormalBlkCnt > GLB_OBJ_BKG_NUM / 2 - 1)
|
|
|
//{
|
|
|
// //退出复杂场景帧数清零
|
|
|
// g_GLB_nExitComplexEnv = 0;
|
|
|
|
|
|
// //进入复杂场景第一帧，复杂场景标志位置为真
|
|
|
// if (!g_GLB_bComplexEnv)
|
|
|
// {
|
|
|
// g_GLB_bComplexEnv = true;
|
|
|
// }
|
|
|
//}
|
|
|
//else
|
|
|
//{
|
|
|
// //累计退出复杂场景帧计数
|
|
|
// g_GLB_nExitComplexEnv++;
|
|
|
|
|
|
// //若帧计数超过阈值，则异常环境标志位置为假
|
|
|
// if (g_GLB_nExitComplexEnv > GLB_EXIT_CMPLX_ENV_CNT && g_GLB_bComplexEnv)
|
|
|
// {
|
|
|
// g_GLB_bComplexEnv = false;
|
|
|
// }
|
|
|
//}
|
|
|
}
|
|
|
|
|
|
/**********************************************************
|
|
|
* 函数名称：BKM_MergeMultiTarget()
|
|
|
* 功能描述：合并目标数组中重合的面目标
|
|
|
* 输入参数：TARGET_OBJECT *ptTargetArray-- 单帧目标数组
|
|
|
* SINT32 nObjsCnt -- 单帧目标数组中的目标个数
|
|
|
* 输出参数：TARGET_OBJECT *ptTargetArray-- 目标合并后的目标数组
|
|
|
* 返 回 值：nTargetNum -- 目标合并后的目标数目
|
|
|
* 调用关系：
|
|
|
* 其它说明：
|
|
|
**********************************************************/
|
|
|
//SINT16 BKM_MergeMultiTarget(TARGET_OBJECT *ptTargetArray, SINT32 nObjsCnt)
|
|
|
//{
|
|
|
// SINT32 i = 0;
|
|
|
// SINT32 j = 0;
|
|
|
// SINT32 k = 0;
|
|
|
// TARGET_OBJECT *ptOtherTarget = NULL;
|
|
|
// TARGET_OBJECT *ptCurrentTarget = NULL;
|
|
|
// //SINT32 nXDistance = 0;
|
|
|
// //SINT32 nYDistance = 0;
|
|
|
// SINT16 nDist = 0; //两个目标框间的最小距离
|
|
|
// SINT16 nMinDistThres = 2 * g_DAT_stPara.nDSmpScale; //合并的最小距离阈值【DSP移植注意B核g_DAT_stPara.nDSmpScale的赋值】
|
|
|
// SINT32 nDeltetID = 0; //待删除目标下标
|
|
|
//
|
|
|
// //初始化多目标合并标志
|
|
|
// g_GLB_bMultiObjMerge = false;
|
|
|
//
|
|
|
// //仅一个目标或者无最优管道目标直接返回
|
|
|
// if (nObjsCnt < 2)
|
|
|
// {
|
|
|
// return nObjsCnt;
|
|
|
// }
|
|
|
//
|
|
|
// for (i = 0; i < nObjsCnt - 1; i++)
|
|
|
// {
|
|
|
// //候选目标
|
|
|
// ptCurrentTarget = &ptTargetArray[i];
|
|
|
//
|
|
|
// for (j = i + 1; j < nObjsCnt; j++)
|
|
|
// {
|
|
|
// //待合并目标
|
|
|
// ptOtherTarget = &ptTargetArray[j];
|
|
|
//
|
|
|
// //计算两个目标框间的最小距离
|
|
|
// nDist = IMGO_CalcDistOfTwoRect(ptCurrentTarget->mrnRect, ptOtherTarget->mrnRect);
|
|
|
//
|
|
|
// //距离大于阈值不合并
|
|
|
// if (nDist > nMinDistThres)
|
|
|
// {
|
|
|
// continue;
|
|
|
// }
|
|
|
// else
|
|
|
// {
|
|
|
// //更新多目标合并标志位
|
|
|
// g_GLB_bMultiObjMerge = true;
|
|
|
//
|
|
|
// //更新合并后的目标信息，包括目标矩形，中心点坐标，尺寸和像素点个数，【灰度值和目标类型暂未更新】
|
|
|
// ptCurrentTarget->mrnRect.minX = MIN(ptCurrentTarget->mrnRect.minX, ptOtherTarget->mrnRect.minX);
|
|
|
// ptCurrentTarget->mrnRect.minY = MIN(ptCurrentTarget->mrnRect.minY, ptOtherTarget->mrnRect.minY);
|
|
|
// ptCurrentTarget->mrnRect.maxX = MAX(ptCurrentTarget->mrnRect.maxX, ptOtherTarget->mrnRect.maxX);
|
|
|
// ptCurrentTarget->mrnRect.maxY = MAX(ptCurrentTarget->mrnRect.maxY, ptOtherTarget->mrnRect.maxY);
|
|
|
// ptCurrentTarget->pfCenPos.x = (FLOAT32)(ptCurrentTarget->mrnRect.minX + ptCurrentTarget->mrnRect.maxX) / 2.0f;
|
|
|
// ptCurrentTarget->pfCenPos.y = (FLOAT32)(ptCurrentTarget->mrnRect.minY + ptCurrentTarget->mrnRect.maxY) / 2.0f;
|
|
|
// ptCurrentTarget->snSize.w = ptCurrentTarget->mrnRect.maxX - ptCurrentTarget->mrnRect.minX + 1;
|
|
|
// ptCurrentTarget->snSize.h = ptCurrentTarget->mrnRect.maxY - ptCurrentTarget->mrnRect.minY + 1;
|
|
|
// ptCurrentTarget->snSize.s = ptCurrentTarget->snSize.w * ptCurrentTarget->snSize.h;
|
|
|
// ptCurrentTarget->unObjPxlsCnt = ptCurrentTarget->unObjPxlsCnt + ptOtherTarget->unObjPxlsCnt;
|
|
|
//
|
|
|
// //删除被合并的目标
|
|
|
// for (k = j + 1; k < nObjsCnt; k++)
|
|
|
// {
|
|
|
// ptTargetArray[k-1] = ptTargetArray[k];
|
|
|
// }
|
|
|
// memset(&ptTargetArray[nObjsCnt-1], 0, sizeof(TARGET_OBJECT));
|
|
|
// nObjsCnt--;
|
|
|
// i--;
|
|
|
// break;
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
//
|
|
|
// return nObjsCnt;
|
|
|
//}
|
|
|
//
|
|
|
|
|
|
/**********************************************************
|
|
|
* 函数名称：BKM_MultiObjMonitor()
|
|
|
* 功能描述：多目标监控，监控待跟踪目标周围是否存在相邻的目标
|
|
|
* 输入参数：BYTE8 bTargetIndex -- 目标编号
|
|
|
* TARGET_OBJECT *ptTargetArray-- 单帧目标数组
|
|
|
* SINT32 nObjsCnt -- 目标个数
|
|
|
* 输出参数：无
|
|
|
* 返 回 值：BBOOL bMultiObj -- 是否多目标（一个目标被分割成多个）
|
|
|
* 调用关系：无
|
|
|
* 其它说明：无
|
|
|
**********************************************************/
|
|
|
//BBOOL BKM_MultiObjMonitor(BYTE8 bTargetIndex, TARGET_OBJECT *ptTargetArray, SINT32 nObjsCnt)
|
|
|
//{
|
|
|
// BBOOL bMultiObj = false;
|
|
|
// SINT32 i = 0;
|
|
|
// SINT32 nNonNeighborObjCnt = 0; //不相邻目标计数器
|
|
|
// TARGET_OBJECT *ptOtherTarget = NULL;
|
|
|
// TARGET_OBJECT *ptPipeTarget = NULL;
|
|
|
// SINT16 nDist = 0; //两个目标框间的最小距离
|
|
|
// SINT16 nMinDistThres = 3; //合并的最小距离阈值
|
|
|
//
|
|
|
// //仅一个目标或者无最优管道目标直接返回
|
|
|
// if (nObjsCnt < 2 || -1 == bTargetIndex)
|
|
|
// {
|
|
|
// //清零帧数并返回
|
|
|
// g_GLB_nMultiObjCnt = 0;
|
|
|
// return bMultiObj;
|
|
|
// }
|
|
|
//
|
|
|
// //候选管道目标
|
|
|
// ptPipeTarget = &ptTargetArray[bTargetIndex];
|
|
|
//
|
|
|
// for (i = 0; i < nObjsCnt; i++)
|
|
|
// {
|
|
|
// //跳过候选目标
|
|
|
// if (i == bTargetIndex)
|
|
|
// {
|
|
|
// continue;
|
|
|
// }
|
|
|
//
|
|
|
// ptOtherTarget = &ptTargetArray[i];
|
|
|
//
|
|
|
// //计算两个目标框间的最小距离
|
|
|
// nDist = IMGO_CalcDistOfTwoRect(ptPipeTarget->mrnRect, ptOtherTarget->mrnRect);
|
|
|
//
|
|
|
// //距离大于阈值不合并
|
|
|
// if (nDist > nMinDistThres)
|
|
|
// {
|
|
|
// nNonNeighborObjCnt++;
|
|
|
// continue;
|
|
|
// }
|
|
|
// else
|
|
|
// {
|
|
|
// //20170302，累加多目标帧数，这里仅存在距离小于阈值的目标时认为是多目标
|
|
|
// g_GLB_nMultiObjCnt++;
|
|
|
// if (g_GLB_nMultiObjCnt > GLB_MULTI_OBJ_MAX_CNT)
|
|
|
// {
|
|
|
// bMultiObj = true;
|
|
|
// }
|
|
|
// break;
|
|
|
// }
|
|
|
// }
|
|
|
//
|
|
|
// //如果均为不相邻目标，则视为多目标为假，帧数清零
|
|
|
// if (nNonNeighborObjCnt == nObjsCnt - 1)
|
|
|
// {
|
|
|
// g_GLB_nMultiObjCnt = 0;
|
|
|
// }
|
|
|
//
|
|
|
// return bMultiObj;
|
|
|
//}
|
|
|
|
