#include "Arith_EOController.h" #include "Arith_CoordModule.h" #include "Arith_Common.hpp" #include "Arith_ImgOperate.h" #include "Arith_AI_Tracker.h" #include "opencv2/opencv.hpp" Arith_EOController::Arith_EOController() { g_GLB_bInitialize = FALSE; //上电初始化 memset(&g_GLB_stPara, 0, sizeof(GLB_PARAMETERS)); // 算法控制参数 memset(&g_GLB_stInput, 0, sizeof(GLB_INPUT)); //参数行中的输入信息，包含帧编号/伺服等 memset(&g_GLB_stCommand, 0, sizeof(GLB_PCCOMMAND));//跟踪舱上位机软件到PC算法控制命令 memset(&g_GLB_stCommand_Pre, 0, sizeof(GLB_PCCOMMAND)); memset(&g_GLB_stOutput, 0, sizeof(GLB_OUTPUT));//算法输出结果 } Arith_EOController::~Arith_EOController() { // 待补充资源释放过程 } /********************************************************** * 函数名称：Arith_Controller() * 功能描述：系统主控制函数 * 输入参数：SINT32 nWidth -- 图像宽度 * SINT32 nHeight -- 图像高度 * 输出参数：无 * 返 回 值：无 * 调用关系：无 * 其它说明：无 **********************************************************/ BBOOL Arith_EOController::Arith_Controller(GD_VIDEO_FRAME_S img) { BBOOL ubSuccessFlag = FALSE; //XLOG_DEBUG("XLOGGER IS RUNNIG!"); //获取并响应任务机指令 CMD_GetCommand(); //响应算法控制命令 CMD_RespondCommand(); //删除坏点 //if (g_GLB_stPara.bEnableBPJudgDetect) //{ // BP_BPReplace(pSrc, nWidth, nHeight); //} //else //{ // BP_CleanUpBPList(); //} //处理系统工作模式逻辑 //switch (g_GLB_stPara.nSysMode) //{ // // 直接透传 //} // 处理跟踪器工作状态逻辑 switch (g_GLB_stPara.nStatus) { // 扇扫搜索状态 case GLB_STATUS_FSCAN: Arith_Status_FSCAN(img, g_GLB_stInput, g_GLB_stPara); break; // 周扫搜索状态 case GLB_STATUS_SCAN: Arith_Status_SCAN(img, g_GLB_stInput, g_GLB_stPara); break; //凝视搜索状态 case GLB_STATUS_SEARCH: Arith_Status_SEARCH(img, g_GLB_stInput, g_GLB_stPara); break; //单目标随动跟踪状态 case GLB_STATUS_TRACK: Arith_Status_TRACK(img, g_GLB_stInput, g_GLB_stPara, g_GLB_stArithPara); break; // 待命模式 case GLB_STATUS_WAIT: Arith_Status_WAIT(img, g_GLB_stInput, g_GLB_stPara); break; // 丢失重捕模式 case GLB_STATUS_LOST: Arith_Status_LOST(img, g_GLB_stInput, g_GLB_stPara); break; // 未知状态 case GLB_STATUS_UNKOWN: break; // 多目标随动跟踪状态 case GLB_STATUS_MOTRACK: Arith_Status_MOTRACK(img, g_GLB_stInput, g_GLB_stPara, g_GLB_stArithPara); break; default: break; } return true; } /************************************* * Method: Arith_ImportExternTargets() * Function Description: 导入外部目标列表 * CreateData: 2024/10/11 * Input Param: TARGET_OBJECT * pTargetList:输入目标列表 * Input Param: SINT32 nNum:输入个数 * Output Param: * Return: SINT32:实际导入的目标个数 * Call Relation: * Other Description: *************************************/ SINT32 Arith_EOController::Arith_ImportExternTargets() { // 导入策略根据需求修改 // 1. 先合并外部目标 memcpy(g_pFrameTargetArray, g_pExternTargetArray, sizeof(TARGET_OBJECT) * g_nExternTargetNum); // 2.剩余空间合并传统检测算法的目标队列 SINT32 nRemain = MIN(MAX(0, INPUT_OBJ_NUM - g_nExternTargetNum), g_GLB_Detectors->m_FrmObjsCnt); memcpy(&g_pFrameTargetArray[g_nExternTargetNum], g_GLB_Detectors->GetTargetArray(),sizeof(TARGET_OBJECT) * nRemain); g_TotalTargetNum = g_nExternTargetNum + nRemain; return g_TotalTargetNum; } void Arith_EOController::Arith_CleanTargetArray() { // 严格按照目标个数取，避免初始化大段内存 g_TotalTargetNum = 0; g_nExternTargetNum = 0; } /********************************************************** * 函数名称：Arith_SystemInit() * 功能描述：系统初始化函数 * 输入参数：SINT32 nWidth -- 图像宽度 * SINT32 nHeight -- 图像高度 * GLB_SYS_MODE nSysMode -- 系统工作模式 * GLB_SCEN_MODE nScenMode -- 场景模式 * 输出参数：无 * 返 回 值：无 * 调用关系：无 * 其它说明：无 **********************************************************/ void Arith_EOController::Arith_SystemInit(SINT32 nWidth, SINT32 nHeight, GLB_SYS_MODE nSysMode, GLB_SCEN_MODE nScenMode) { //初始化算法输入参数 GLB_InitInputs(nWidth, nHeight); //初始化算法控制命令 CMD_CleanUpPCCommand(); //初始化系统参数 GLB_InitSysParameters(nWidth, nHeight, nSysMode, nScenMode); //初始化算法参数 GLB_InitArithParameters(); //初始化图像算法资源 GLB_InitArithModule(nWidth, nHeight); //标记初始化完成 g_GLB_bInitialize = TRUE; } //////////////////////////////////////////////////////////////////////////////// //--函数定义 //////////////////////////////////////////////////////////////////////////////// /********************************************************** * 函数名称：GLB_InitInputs() * 功能描述：系统初始化-算法输入参数 * 输入参数：SINT32 nWidth -- 图像宽度 * SINT32 nHeight -- 图像高度 * 输出参数：无 * 返 回 值：无 * 调用关系：无 * 其它说明：无 **********************************************************/ void Arith_EOController::GLB_InitInputs(SINT32 nWidth, SINT32 nHeight) { //参数行 memset(&g_GLB_stInput, 0, sizeof(GLB_INPUT)); //图像尺寸 g_GLB_stInput.nImageWidth = nWidth; g_GLB_stInput.nImageHeight = nHeight; } /********************************************************** * 函数名称：GLB_InitParameters() * 功能描述：系统初始化-算法控制参数 * 输入参数：无 * 输出参数：无 * 返 回 值：无 * 调用关系：无 * 其它说明：无 **********************************************************/ void Arith_EOController::GLB_InitSysParameters(SINT32 nWidth, SINT32 nHeight, GLB_SYS_MODE nSysMode, GLB_SCEN_MODE nScenMode) { // 初始化工作模式 g_GLB_stPara.nSysMode = nSysMode; // 初始化场景模式 g_GLB_stPara.nWorkScene = nScenMode; // 默认算法状态 if(nSysMode == GLB_SYS_MODE::GLB_SYS_STARE) { g_GLB_stPara.nStatus = GLB_STATUS_SEARCH; } else if(nSysMode == GLB_SYS_MODE::GLB_SYS_FSCAN) { g_GLB_stPara.nStatus = GLB_STATUS_FSCAN; } else if(nSysMode == GLB_SYS_MODE::GLB_SYS_SCAN) { g_GLB_stPara.nStatus = GLB_STATUS_SCAN; } // 管道数量 g_GLB_stPara.nPipeMaxNum = 500; // 告警数量 g_GLB_stPara.nAlarmMaxNum = 99; //雷达导引 g_GLB_stPara.bEnRadarGuide = false; g_GLB_stPara.nGuideTargetNumber = 0; // 锁定参数初始化 g_GLB_stPara.ptLockPos.x = nWidth / 2.0f; g_GLB_stPara.ptLockPos.y = nHeight / 2.0f; g_GLB_stPara.snLockBoxSize.w = 40; g_GLB_stPara.snLockBoxSize.h = 40; // qw 雷达导引区域大小 g_GLB_stPara.nDetectRegionX = (SINT32)GLB_RADARGUIDE_RECT / 2; g_GLB_stPara.nDetectRegionY = (SINT32)GLB_RADARGUIDE_RECT / 2; // 初始化为人工锁定方式 g_GLB_stPara.bSelectObjManual = true; } void Arith_EOController::GLB_InitArithParameters() { // 初始化跟踪参数模板 memset(&g_GLB_TKPara_Template,0,sizeof(Tracker_Param)); //对空参数下发 g_GLB_TKPara_Template.skyParam.Sky_nTrackMemFrmNum = 1000; g_GLB_TKPara_Template.skyParam.Sky_bEnableFullImgDet = false; g_GLB_TKPara_Template.skyParam.Sky_bEnableTrackSA = true; g_GLB_TKPara_Template.skyParam.Sky_bEnableKCF = true; g_GLB_TKPara_Template.skyParam.Sky_bEnableMatcher = false; g_GLB_TKPara_Template.skyParam.nSmallObjSizeMax = 32; g_GLB_TKPara_Template.skyParam.Sky_bSelectObjManual = 1; g_GLB_TKPara_Template.skyParam.Sky_bUseAIDet = 0; g_GLB_TKPara_Template.skyParam.prmTSkyDet.bEnableDetcetAreaTarget = true; g_GLB_TKPara_Template.skyParam.prmTSkyDet.bEnableDetcetDimTarget = false; g_GLB_TKPara_Template.skyParam.prmTSkyDet.fSmallDetectGDK = 5; g_GLB_TKPara_Template.skyParam.prmTSkyDet.nGrayThresMinBright = 20; g_GLB_TKPara_Template.skyParam.prmTSkyDet.nGrayThresMinDark = 10; g_GLB_TKPara_Template.skyParam.prmTSkyDet.fAreaDetectGradDiffThre = 20; g_GLB_TKPara_Template.skyParam.prmTSkyDet.nDetectGrayType = 1; g_GLB_TKPara_Template.skyParam.prmTSkyDet.nDSmpScale = 4; //对地参数下发 g_GLB_TKPara_Template.grdParam.bEnableAccuracyTrack = true; g_GLB_TKPara_Template.grdParam.bUseServePredict = false; g_GLB_TKPara_Template.grdParam.bEnableLKCorrect = true; g_GLB_TKPara_Template.grdParam.bEnableKCF = true; g_GLB_TKPara_Template.grdParam.nKcfUpdataStep = 2; g_GLB_TKPara_Template.grdParam.bKCFMutiScales = true; g_GLB_TKPara_Template.grdParam.fArrestKCFMinThre = 0.38; g_GLB_TKPara_Template.grdParam.fArrestKCFMaxThre = 0.68; g_GLB_TKPara_Template.grdParam.fKCFResthre = 0.23; g_GLB_TKPara_Template.grdParam.bTLDOccJudge = true; g_GLB_TKPara_Template.grdParam.bEnableDaSiamRPN = false; g_GLB_TKPara_Template.grdParam.bEnableAIOccJudge = true; g_GLB_TKPara_Template.grdParam.fAIOccThre = 0.85; g_GLB_TKPara_Template.grdParam.bEnableAIDetect = true; g_GLB_TKPara_Template.grdParam.bEnableArrestCorr = false; g_GLB_TKPara_Template.grdParam.bEnableArrestAngle = false; g_GLB_TKPara_Template.grdParam.bEnableAreestEsay = false; g_GLB_TKPara_Template.grdParam.nArrestEsayCnt = 250; } void Arith_EOController::GLB_InitArithModule(SINT32 nWidth, SINT32 nHeight) { // 创建内部队列 g_pFrameTargetArray = new TARGET_OBJECT[INPUT_OBJ_NUM]; memset(g_pFrameTargetArray, 0, sizeof(TARGET_OBJECT) * INPUT_OBJ_NUM); g_TotalTargetNum = 0; // 创建外部目标队列 g_pExternTargetArray = new TARGET_OBJECT[INPUT_OBJ_NUM]; memset(g_pExternTargetArray, 0, sizeof(TARGET_OBJECT) * INPUT_OBJ_NUM); g_nExternTargetNum = 0; // 创建检测器 g_GLB_Detectors = new Detectors(nWidth, nHeight); // 创建管道模块 g_GLB_PipeProc = API_MOT_PIPE::Create(g_GLB_stPara.nPipeMaxNum,g_GLB_stPara.nAlarmMaxNum); // 创建与管道配合的跟踪器指针数组 g_GLB_Trackers = new Tracker_Ptr[g_GLB_stPara.nPipeMaxNum]; for (size_t i = 0; i < g_GLB_stPara.nPipeMaxNum; i++) { g_GLB_Trackers[i] = NULL; } //memset(g_GLB_Trackers, 0, sizeof(Tracker_Ptr) * g_GLB_stPara.nPipeMaxNum);//多目标跟踪器模块 // 初始化AI跟踪结果接收 memset(&g_GLB_AITrackerInfo,0,sizeof(AIT_OUTPUT)); // g_pGrdTracker = new Tracker(nWidth,nHeight,GLB_SCEN_GROUND,g_GLB_TKPara_Template); g_pSkyTracker = new Tracker(nWidth,nHeight,GLB_SCEN_SKY,g_GLB_TKPara_Template); m_SceneType = GLB_SCEN_MODE::GLB_SCEN_SKY; // 默认全场景的类型为对空 //g_pSkyTracker = NULL; } /********************************************************** * 函数名称：GLB_InitOutputs() * 功能描述：系统初始化-算法输出结果 * 输入参数：无 * 输出参数：无 * 返 回 值：无 * 调用关系：无 * 其它说明：无 **********************************************************/ void Arith_EOController::GLB_InitOutputs(void) { // //清空目标检测结果 g_GLB_Detectors->ClearTargetsArray(); // // 清空管道及告警队列 g_GLB_PipeProc->ClearAllPipesAndAlarms(); // //清空目标跟踪结果 GLB_Release_Trackers(g_GLB_stPara.nPipeMaxNum); //初始化算法结果 memset(&g_GLB_stOutput, 0, sizeof(GLB_OUTPUT)); } void Arith_EOController::Arith_CMD_Lock(CENTERRECT32S LockBox) { // 视场内锁定 g_GLB_stCommand.unSetLockPosX = LockBox.cx; g_GLB_stCommand.unSetLockPosY = LockBox.cy; g_GLB_stCommand.unSetLockBoxW = LockBox.w; g_GLB_stCommand.unSetLockBoxH = LockBox.h; // 发送点选或者框选 if (LockBox.w == 0 || LockBox.h == 0) { g_GLB_stCommand.ubCmd = LockMode::LOCK_POINT; } else { g_GLB_stCommand.ubCmd = LockMode::LOCK_RECT; } } PIPE* Arith_EOController::Arith_CMD_LockIDAndInit(GD_VIDEO_FRAME_S img, SINT32 nID) { // 遍历当前告警队列，查找满足ID的目标 PIPE* pLockPipe = g_GLB_PipeProc->getPipeByAlarmID(nID); if (pLockPipe == NULL) { return pLockPipe; } // 模拟点选跟踪 g_GLB_stPara.stLockCtrl = LockMode::LOCK_POINT; g_GLB_stPara.ubLockID = -1; //实际锁定点坐标（实际锁定点X坐标、实际锁定点Y坐标） g_GLB_stPara.ptLockPos.x = pLockPipe->ptStopPnt.x; g_GLB_stPara.ptLockPos.y = pLockPipe->ptStopPnt.y; //锁定波门尺寸（宽度、高度） g_GLB_stPara.snLockBoxSize.w = 0; g_GLB_stPara.snLockBoxSize.h = 0; g_GLB_stPara.snLockBoxSize.s = 0; if (g_GLB_stPara.nStatus == GLB_STATUS_SEARCH) { Proc_SearchLock(img, g_GLB_stInput, g_GLB_stPara); } else if(g_GLB_stPara.nStatus == GLB_STATUS_TRACK) { // 等同于跟踪时点选，需要换批号 Proc_SOTLock_NoRemainID(img, g_GLB_stInput, g_GLB_stPara); } return pLockPipe; } PIPE* Arith_EOController::Arith_CMD_LockAndInit(GD_VIDEO_FRAME_S img, CENTERRECT32S LockBox) { // 视场内锁定 if (LockBox.w == 0 || LockBox.h == 0) { g_GLB_stPara.stLockCtrl = (LockMode::LOCK_POINT); } else { g_GLB_stPara.stLockCtrl = (LockMode::LOCK_RECT); } g_GLB_stPara.ubLockID = -1; //实际锁定点坐标（实际锁定点X坐标、实际锁定点Y坐标） g_GLB_stPara.ptLockPos.x = LockBox.cx; g_GLB_stPara.ptLockPos.y = LockBox.cy; //锁定波门尺寸（宽度、高度） g_GLB_stPara.snLockBoxSize.w = LockBox.w; g_GLB_stPara.snLockBoxSize.h = LockBox.h; g_GLB_stPara.snLockBoxSize.s = LockBox.w * LockBox.h; if (g_GLB_stPara.nStatus == GLB_STATUS_SEARCH) { Proc_SearchLock(img, g_GLB_stInput, g_GLB_stPara); } else if(g_GLB_stPara.nStatus == GLB_STATUS_TRACK) { // 跟踪时框选，更接近重新锁定目标意图，用老批号 if(g_GLB_stPara.stLockCtrl == LockMode::LOCK_RECT) { Proc_SOTLock(img, g_GLB_stInput, g_GLB_stPara); } // 跟踪时点选，接近新目标锁定，用新批号 else if(g_GLB_stPara.stLockCtrl == LockMode::LOCK_POINT) { Proc_SOTLock_NoRemainID(img, g_GLB_stInput, g_GLB_stPara); } } // PIPE* pLockPipe = NULL; if (g_GLB_stPara.nLockPipeInd > -1) { pLockPipe = &g_GLB_PipeProc->getPipeArray()[g_GLB_stPara.nLockPipeInd]; } return pLockPipe; } void Arith_EOController::Arith_CMD_AdjustSOTRect(int dx, int dy, int dw, int dh) { // 在单目标跟踪流程下，重新下发框选跟踪即可实现 // 仅SOT模式下有效 if (g_GLB_stPara.nStatus != GLB_STATUS_TRACK) { return; } // 获取当前跟踪位置 if (g_GLB_stPara.nLockPipeInd > -1) { PIPE* pLockPipe = &g_GLB_PipeProc->getPipeArray()[g_GLB_stPara.nLockPipeInd]; TARGET_OBJECT* pTarget = &pLockPipe->objHistoryList[pLockPipe->ubEnd]; // 发送框选 g_GLB_stCommand.ubCmd = LockMode::LOCK_RECT; g_GLB_stCommand.unSetLockPosX = pLockPipe->ptCurrentPnt.x + dx; g_GLB_stCommand.unSetLockPosY = pLockPipe->ptCurrentPnt.y + dy; g_GLB_stCommand.unSetLockBoxW = pTarget->snSize.w + dw; g_GLB_stCommand.unSetLockBoxH = pTarget->snSize.h + dh; } else { LOG_ERROR("NO TRACKING PIPE!"); } } SINT32 Arith_EOController::Arith_CMD_LockMultiTarget(TargetGuide* target, int num) { memcpy(g_GLB_stCommand.target, target, num * sizeof(TargetGuide)); g_GLB_stPara.bEnRadarGuide = true; g_GLB_stCommand.bGuideUpDate = true; return num; } void Arith_EOController::Arith_CMD_CancleLock() { g_GLB_stCommand.ubCmd = LockMode::LOCK_UNLOCK; } void Arith_EOController::Arith_CMD_SetScenMode(GLB_SCEN_MODE nScenMode) { g_GLB_stCommand.ubScenCmd = nScenMode; } void Arith_EOController::Arith_CMD_SetSysMode(GLB_SYS_MODE nSysMode) { g_GLB_stCommand.ubSysStatusCmd = nSysMode; } void Arith_EOController::Arith_SetRunTimeParam(ARIDLL_PARMA config) { //1.获取当前参数，2.仅修改给定部分参数 // 设置检测器实例参数 Param_SkyDetect para = g_GLB_Detectors->GetParam(); para.bEnableDetcetSmallTarget = config.PrmSkyDetect.bEnableDetcetSmallTarget; para.bEnableDetcetAreaTarget = config.PrmSkyDetect.bEnableDetcetAreaTarget; para.bEnableDetcetDimTarget = config.PrmSkyDetect.bEnableDetcetDimTarget; para.fSmallDetectGDK = config.PrmSkyDetect.fSmallDetectGDK; para.fAreaDetectGradDiffThre = config.PrmSkyDetect.fAreaDetectGradDiffThre; para.nGrayThresMinBright = config.PrmSkyDetect.nGrayThresMinBright; para.nGrayThresMinDark = config.PrmSkyDetect.nGrayThresMinDark; para.nDetectGrayType = config.PrmSkyDetect.nDetectGrayType; para.nDSmpScale = config.PrmSkyDetect.nDSmpScale; g_GLB_Detectors->SetParam(para);//设置参数 // 全局检测器参数共享给局部检测器参数 //memcpy(&config.stSkyParam.prmTSkyDet, &config.PrmSkyDetect, sizeof(Param_SkyDetect)); // 设置管道实例参数 PIPE_PARAMETERS pipePara = g_GLB_PipeProc->GetParam(); pipePara.nPipeRadiusSearch= config.nPipeRadiusSearch; //管道搜索范围直径 -- 搜索 pipePara.nPipeRadiusLock = config.nPipeRadiusLock; //管道搜索范围直径 -- 锁定 pipePara.nPipeRadiusTrack= config.nPipeRadiusTrack; //管道搜索范围直径 -- 跟踪 pipePara.nPipeRadiusLost = config.nPipeRadiusLost; //管道搜索范围直径 -- 跟踪丢失 pipePara.nAwsFrmNumScan = config.nAwsFrmNumScan; //管道目标的确认帧数- 扫描模式 4 pipePara.nAwsFrmNumStare = config.nAwsFrmNumStare; //管道目标的确认帧数- 凝视模式 4 pipePara.nPipeDelMinScan = config.nPipeDelMinScan; //管道最少延迟删除帧数- 扫描模式 4 pipePara.nPipeDelMinStare= config.nPipeDelMinStare; //管道最少延迟删除帧数- 凝视/跟踪模式 4 pipePara.bCloseBadPointPipe = config.bCloseBadPointPipe;//关闭坏点管道 pipePara.fFilterA = config.fA; pipePara.fFilterB = config.fB; g_GLB_PipeProc->SetParam(pipePara); g_GLB_stPara.snLockBoxSize.w = config.nLockPointW <= 0? g_GLB_stPara.snLockBoxSize.w: config.nLockPointW; g_GLB_stPara.snLockBoxSize.h = config.nLockPointH <= 0? g_GLB_stPara.snLockBoxSize.h: config.nLockPointH; //LOG_DEBUG("{0}, {1}, {2}", __FILE__, __FUNCTION__, __LINE__); // 设置跟踪器参数模板 Param_SkyTracker* pSkyParam = &g_GLB_TKPara_Template.skyParam;//对空 Param_GroundTracker* pGrdParam = &g_GLB_TKPara_Template.grdParam;//对地 memcpy(pGrdParam, &config.stGrdParam,sizeof(Param_GroundTracker)); memcpy(pSkyParam, &config.stSkyParam,sizeof(Param_SkyTracker)); //LOG_DEBUG("{0}, {1}, {2}", __FILE__, __FUNCTION__, __LINE__); //LOG_DEBUG("{0}, {1}, {2}, {3}", __FILE__, __FUNCTION__, __LINE__, config.nLogLevel); memcpy(&g_GLB_stArithPara.stGrdParam, &config.stGrdParam, sizeof(Param_GroundTracker)); memcpy(&g_GLB_stArithPara.stSkyParam, &config.stSkyParam, sizeof(Param_SkyTracker)); // 非文件设置状态，设置日志输出级别 if (false == LOG_GETFILESTATE()) { LOG_SETLEVEL(config.nLogLevel); LOG_SETLEVEL_IN(config.nLogLevel); LOG_SETLEVEL_OUT(config.nLogLevel); } g_pGrdTracker->pGroundTracker->SetParam(g_GLB_TKPara_Template.grdParam); } // 读取运行时跟踪参数 void Arith_EOController::Arith_GetRunTimeParam(ARIDLL_PARMA* config) { Param_SkyDetect para = g_GLB_Detectors->GetParam(); config->PrmSkyDetect.bEnableDetcetAreaTarget = para.bEnableDetcetAreaTarget; config->PrmSkyDetect.bEnableDetcetDimTarget = para.bEnableDetcetDimTarget; config->PrmSkyDetect.bEnableDetcetSmallTarget = para.bEnableDetcetSmallTarget; config->PrmSkyDetect.fSmallDetectGDK = para.fSmallDetectGDK; config->PrmSkyDetect.fAreaDetectGradDiffThre = para.fAreaDetectGradDiffThre; config->PrmSkyDetect.nGrayThresMinBright = para.nGrayThresMinBright; config->PrmSkyDetect.nGrayThresMinDark = para.nGrayThresMinDark; config->PrmSkyDetect.nDetectGrayType = para.nDetectGrayType; config->PrmSkyDetect.nDSmpScale = para.nDSmpScale; PIPE_PARAMETERS pipePara = g_GLB_PipeProc->GetParam(); config->nPipeRadiusSearch = pipePara.nPipeRadiusSearch; config->nPipeRadiusLock = pipePara.nPipeRadiusLock; config->nPipeRadiusTrack = pipePara.nPipeRadiusTrack; config->nPipeRadiusLost = pipePara.nPipeRadiusLost; config->nAwsFrmNumScan = pipePara.nAwsFrmNumScan; config->nAwsFrmNumStare = pipePara.nAwsFrmNumStare; config->nPipeDelMinScan = pipePara.nPipeDelMinScan; config->nPipeDelMinStare = pipePara.nPipeDelMinStare; // 返回当前跟踪参数 config->stGrdParam = g_GLB_TKPara_Template.grdParam; config->stSkyParam = g_GLB_TKPara_Template.skyParam; } /************************************* * Method: getStructFromFS() * Function Description: 从cv文件流解析json字段进行参数赋值 * CreateData: 2024/10/30 * Input Param: cv::FileStorage fs * Output Param: * Return: ARIDLL_PARMA * Call Relation: * Other Description:win平台无对应参数默认返回为0，linux平台无对应参数对导致崩溃，需要在调用时加参数存在性检查 *************************************/ ARIDLL_PARMA getStructFromFS(cv::FileStorage fs) { ARIDLL_PARMA config = { 0 }; //LOG_DEBUG("{0}, {1}, {2}", __FILE__, __FUNCTION__, __LINE__); assert(!fs["bEnableDetcetAreaTarget"].empty()); fs["bEnableDetcetAreaTarget"] >> config.PrmSkyDetect.bEnableDetcetAreaTarget; assert(!fs["bEnableDetcetSmallTarget"].empty());fs["bEnableDetcetSmallTarget"] >> config.PrmSkyDetect.bEnableDetcetSmallTarget; assert(!fs["bEnableDetcetDimTarget"].empty()); fs["bEnableDetcetDimTarget"] >> config.PrmSkyDetect.bEnableDetcetDimTarget; assert(!fs["fSmallDetectGDK"].empty()); fs["fSmallDetectGDK"] >> config.PrmSkyDetect.fSmallDetectGDK; assert(!fs["fAreaDetectGradDiffThre"].empty()); fs["fAreaDetectGradDiffThre"] >> config.PrmSkyDetect.fAreaDetectGradDiffThre; assert(!fs["nGrayThresMinBright"].empty()); fs["nGrayThresMinBright"] >> config.PrmSkyDetect.nGrayThresMinBright; assert(!fs["nGrayThresMinDark"].empty()); fs["nGrayThresMinDark"] >> config.PrmSkyDetect.nGrayThresMinDark; assert(!fs["nDetectGrayType"].empty()); fs["nDetectGrayType"] >> config.PrmSkyDetect.nDetectGrayType; assert(!fs["nDSmpScale"].empty()); fs["nDSmpScale"] >> config.PrmSkyDetect.nDSmpScale; // 跟踪过程的局部检测控制参数 fs["bEnableDetcetAreaTarget"] >> config.stSkyParam.prmTSkyDet.bEnableDetcetAreaTarget; fs["bEnableDetcetSmallTarget"] >> config.stSkyParam.prmTSkyDet.bEnableDetcetSmallTarget; fs["bEnableDetcetDimTarget"] >> config.stSkyParam.prmTSkyDet.bEnableDetcetDimTarget; fs["fSmallDetectGDK"] >> config.stSkyParam.prmTSkyDet.fSmallDetectGDK; fs["fAreaDetectGradDiffThre"] >> config.stSkyParam.prmTSkyDet.fAreaDetectGradDiffThre; fs["nGrayThresMinBright"] >> config.stSkyParam.prmTSkyDet.nGrayThresMinBright; fs["nGrayThresMinDark"] >> config.stSkyParam.prmTSkyDet.nGrayThresMinDark; fs["nDetectGrayType"] >> config.stSkyParam.prmTSkyDet.nDetectGrayType; fs["nDSmpScale"] >> config.stSkyParam.prmTSkyDet.nDSmpScale; assert(!fs["Sky_bEnableFullImgDet"].empty()); fs["Sky_bEnableFullImgDet"] >> config.stSkyParam.Sky_bEnableFullImgDet; assert(!fs["Sky_bEnableTrackSA"].empty()); fs["Sky_bEnableTrackSA"] >> config.stSkyParam.Sky_bEnableTrackSA; assert(!fs["Sky_bEnableKCF"].empty()); fs["Sky_bEnableKCF"] >> config.stSkyParam.Sky_bEnableKCF; assert(!fs["Sky_bEnableMatcher"].empty()); fs["Sky_bEnableMatcher"] >> config.stSkyParam.Sky_bEnableMatcher; assert(!fs["Sky_bSelectObjManual"].empty()); fs["Sky_bSelectObjManual"] >> config.stSkyParam.Sky_bSelectObjManual; assert(!fs["Sky_bUseAIDet"].empty()); fs["Sky_bUseAIDet"] >> config.stSkyParam.Sky_bUseAIDet; assert(!fs["Sky_nTrackMemFrmNum"].empty()); fs["Sky_nTrackMemFrmNum"] >> config.stSkyParam.Sky_nTrackMemFrmNum; assert(!fs["nSmallObjSizeMax"].empty()); fs["nSmallObjSizeMax"] >> config.stSkyParam.nSmallObjSizeMax; assert(!fs["nPipeRadiusSearch"].empty()); fs["nPipeRadiusSearch"] >> config.nPipeRadiusSearch; assert(!fs["nPipeRadiusLock"].empty()); fs["nPipeRadiusLock" ] >> config.nPipeRadiusLock; assert(!fs["nPipeRadiusTrack"].empty()); fs["nPipeRadiusTrack"] >>config.nPipeRadiusTrack; assert(!fs["nPipeRadiusLost"].empty()); fs["nPipeRadiusLost" ] >>config.nPipeRadiusLost; assert(!fs["nAwsFrmNumScan"].empty()); fs["nAwsFrmNumScan"] >>config.nAwsFrmNumScan; assert(!fs["nAwsFrmNumStare"].empty()); fs["nAwsFrmNumStare"] >>config.nAwsFrmNumStare; assert(!fs["nPipeDelMinScan"].empty()); fs["nPipeDelMinScan"] >>config.nPipeDelMinScan; assert(!fs["nPipeDelMinStare"].empty()); fs["nPipeDelMinStare"] >>config.nPipeDelMinStare; assert(!fs["ABF_a"].empty()); fs["ABF_a"] >>config.fA; assert(!fs["ABF_b"].empty()); fs["ABF_b"] >>config.fB; assert(!fs["nLockPointW"].empty()); fs["nLockPointW"] >>config.nLockPointW; assert(!fs["nLockPointH"].empty()); fs["nLockPointH"] >>config.nLockPointH; assert(!fs["bCloseBadPointPipe"].empty()); fs["bCloseBadPointPipe"] >>config.bCloseBadPointPipe; assert(!fs["Grd_bEnableAccuracyTrack"].empty());fs["Grd_bEnableAccuracyTrack"] >> config.stGrdParam.bEnableAccuracyTrack; assert(!fs["Grd_bUseServePredict"].empty()); fs["Grd_bUseServePredict"] >> config.stGrdParam.bUseServePredict; assert(!fs["Grd_bEnableLKCorrect"].empty()); fs["Grd_bEnableLKCorrect"] >> config.stGrdParam.bEnableLKCorrect; assert(!fs["Grd_bEnableKCF"].empty()); fs["Grd_bEnableKCF"] >> config.stGrdParam.bEnableKCF; assert(!fs["Grd_nKcfUpdataStep"].empty()); fs["Grd_nKcfUpdataStep"] >> config.stGrdParam.nKcfUpdataStep; assert(!fs["Grd_bKCFMutiScales"].empty()); fs["Grd_bKCFMutiScales"] >> config.stGrdParam.bKCFMutiScales; assert(!fs["Grd_fArrestKCFMinThre"].empty()); fs["Grd_fArrestKCFMinThre"] >> config.stGrdParam.fArrestKCFMinThre; assert(!fs["Grd_fArrestKCFMaxThre"].empty()); fs["Grd_fArrestKCFMaxThre"] >> config.stGrdParam.fArrestKCFMaxThre; assert(!fs["Grd_fKCFResthre"].empty()); fs["Grd_fKCFResthre"] >> config.stGrdParam.fKCFResthre; assert(!fs["Grd_bTLDOccJudge"].empty()); fs["Grd_bTLDOccJudge"] >> config.stGrdParam.bTLDOccJudge; assert(!fs["Grd_bEnableDaSiamRPN"].empty()); fs["Grd_bEnableDaSiamRPN"] >> config.stGrdParam.bEnableDaSiamRPN; assert(!fs["Grd_bEnableAIOccJudge"].empty()); fs["Grd_bEnableAIOccJudge"] >> config.stGrdParam.bEnableAIOccJudge; assert(!fs["Grd_fAIOccThre"].empty()); fs["Grd_fAIOccThre"] >> config.stGrdParam.fAIOccThre; assert(!fs["Grd_bEnableAIDetect"].empty()); fs["Grd_bEnableAIDetect"] >> config.stGrdParam.bEnableAIDetect; assert(!fs["Grd_bEnableArrestCorr"].empty()); fs["Grd_bEnableArrestCorr"] >> config.stGrdParam.bEnableArrestCorr; assert(!fs["Grd_bEnableArrestAngle"].empty()); fs["Grd_bEnableArrestAngle"] >> config.stGrdParam.bEnableArrestAngle; assert(!fs["Grd_bEnableAreestEsay"].empty()); fs["Grd_bEnableAreestEsay"] >> config.stGrdParam.bEnableAreestEsay; assert(!fs["Grd_nArrestEsayCnt"].empty()); fs["Grd_nArrestEsayCnt"] >> config.stGrdParam.nArrestEsayCnt; assert(!fs["EnableLogLevel"].empty()); fs["EnableLogLevel"] >> config.nLogLevel; return config; } void Arith_EOController::Arith_ReadParaFile(const char* path) { cv::FileStorage fs(path, cv::FileStorage::READ); if (!fs.isOpened()) { return; } ARIDLL_PARMA config = getStructFromFS(fs); Arith_SetRunTimeParam(config); } void Arith_EOController::Arith_ExportParaFile(const char* path) { cv::FileStorage fs(path, cv::FileStorage::WRITE); fs << "bEnableDetcetSmallTarget" << true; fs << "bEnableDetcetAreaTarget" << true; fs << "bEnableDetcetDimTarget" << false; fs << "fSmallDetectGDK" << 5.0f; fs << "fAreaDetectGradDiffThre" << 40; fs << "nGrayThresMinBright" << 20; fs << "nGrayThresMinDark" << 10; fs << "nDetectGrayType" << 1; fs << "nDSmpScale" << 4; fs << "Sky_bEnableFullImgDet" << false; // 对空跟踪过程中是否开启全图小面 fs << "Sky_bEnableTrackSA" << true; fs << "Sky_bEnableKCF" << true; fs << "Sky_bEnableMatcher" << false; fs << "Sky_bSelectObjManual" << true; fs << "Sky_bUseAIDet" << true; fs << "Sky_nTrackMemFrmNum" << 1000; fs << "nSmallObjSizeMax" << 36; fs << "nPipeRadiusSearch" << 40;//管道搜索范围直径 -- 搜索 fs << "nPipeRadiusLock" << 80;//管道搜索范围直径 -- 锁定 fs << "nPipeRadiusTrack" << 30; //管道搜索范围直径 -- 跟踪 fs << "nPipeRadiusLost" << 100;//管道搜索范围直径 -- 跟踪丢失 fs << "nAwsFrmNumScan" << 3;//管道目标的确认帧数- 扫描模式 4 fs << "nAwsFrmNumStare" << 6;//管道目标的确认帧数- 凝视模式 4 fs << "nPipeDelMinScan" << 3;//管道最少延迟删除帧数- 扫描模式 4 fs << "nPipeDelMinStare" << 3;//管道最少延迟删除帧数- 凝视/跟踪模式 4 fs << "ABF_a" << 0.2f;// 轨迹滤波器AB参数 fs << "ABF_b" << 0.04f;// 轨迹滤波器AB参数 fs << "nLockPointW" << 40; //点选锁定目标宽度 fs << "nLockPointH" << 40; //点选锁定目标高度 fs << "bCloseBadPointPipe" << false; //关闭坏点管道 fs << "Grd_bEnableAccuracyTrack" << true; fs << "Grd_bUseServePredict" << false; fs << "Grd_bEnableLKCorrect" << true; fs << "Grd_bEnableKCF" << true; fs << "Grd_nKcfUpdataStep" << 2; fs << "Grd_bKCFMutiScales" << 1; fs << "Grd_fArrestKCFMinThre" << 0.38; fs << "Grd_fArrestKCFMaxThre" << 0.68; fs << "Grd_fKCFResthre" << 0.2; fs << "Grd_bTLDOccJudge" << true; fs << "Grd_bEnableDaSiamRPN" << false; fs << "Grd_bEnableAIOccJudge" << true; fs << "Grd_fAIOccThre" << 0.85; fs << "Grd_bEnableAIDetect" << true; fs << "Grd_bEnableArrestCorr" << false; fs << "Grd_bEnableArrestAngle" << false; fs << "Grd_bEnableAreestEsay" << false; fs << "Grd_nArrestEsayCnt" << 250; fs << "EnableLogLevel" << 2; // 6/off fs.release(); } void Arith_EOController::Arith_ReadJsonStream(const char* str) { cv::FileStorage fs(str, cv::FileStorage::MEMORY); ARIDLL_PARMA config = getStructFromFS(fs); Arith_SetRunTimeParam(config); } SINT32 Arith_EOController::Arith_ExportDebugJson(char* str, SINT32 size, GLB_SCEN_MODE nWorkScene) { memset(str, 0, size); std::string strTmp; cv::FileStorage fs(strTmp.data(), cv::FileStorage::FORMAT_JSON | cv::FileStorage::WRITE | cv::FileStorage::MEMORY); // 写入数据到 FileStorage //fs << "timestamp" << 1010; //fs << "version" << "V1.00"; //fs << "XYZ" << 1; if (GLB_SCEN_MODE::GLB_SCEN_SKY == nWorkScene) { fs << "DownRatio" << g_GLB_stOutput.sky_TrkDownRatio; fs << "TrkType" << g_GLB_stOutput.sky_nObjTypeSrc; fs << "TrkMem" << g_GLB_stOutput.sky_TrkMemFrm; fs << "W" << g_GLB_stOutput.sky_nTrkW; fs << "H" << g_GLB_stOutput.sky_nTrkH; fs << "PxlsCnt" << g_GLB_stOutput.sky_nTrkPxlsCnt; fs << "ClsType" << g_GLB_stOutput.sky_nClsType; fs << "ClsSrc" << g_GLB_stOutput.sky_nClassSource; //fs << "Conf" << std::to_string(g_GLB_stOutput.sky_fTrkConf); } else if (GLB_SCEN_MODE::GLB_SCEN_GROUND == nWorkScene) { fs << "fKCFRes" << std::to_string(g_GLB_stOutput.fKCFRes); fs << "nLearnCnt" << g_GLB_stOutput.nLearnCnt; fs << "nTLDNum" << g_GLB_stOutput.nTLDNum; fs << "fMaxNNConf" << std::to_string(g_GLB_stOutput.fMaxNNConf); fs << "nAIJamCnt" << g_GLB_stOutput.nAIJamCnt; fs << "nAIChangCnt" << g_GLB_stOutput.nAIChangCnt; fs << "fLargeResTH" << std::to_string(g_GLB_stOutput.fLargeResTH); fs << "fArrKCFRes" << std::to_string(g_GLB_stOutput.fArrKCFRes); } else if (GLB_SCEN_MODE::GLB_SCEN_SEA == nWorkScene) { } memcpy(str, fs.releaseAndGetString().c_str(), size); return 0; } void Arith_EOController::Arith_SOT_RunTLDTracker(GD_VIDEO_FRAME_S img) { // 管道队列 PIPE* pPipeArray = g_GLB_PipeProc->getPipeArray(); SINT32 nPipeArrayLen = g_GLB_stPara.nPipeMaxNum; if (g_GLB_stPara.nLockPipeInd == -1) { return; } // 寻找被锁定的单目标管道 PIPE* pTrackPipe = &pPipeArray[g_GLB_stPara.nLockPipeInd]; Tracker_Ptr sotracker = g_GLB_Trackers[g_GLB_stPara.nLockPipeInd]; if (sotracker == NULL) { return; } API_TLD* pTLDMod = sotracker->GetpTLDTracker(); // TLD 初始化和解锁在框架内部完成，这里只跑最耗时的检测和学习过程。 if (pTLDMod != NULL) { // 执行TLD流程 pTLDMod->TLD_Run(img, &sotracker->ObjStatus,TrackEvent()); } return; } OBJECTSTATUS Arith_EOController::Arith_SOT_GetTrackerStatus() { OBJECTSTATUS obj = {0}; // 对空和对地模式分别返回 if (GLB_SCEN_SKY == m_SceneType) { return g_pSkyTracker->pSkyTracker->ObjStatus; } if (GLB_SCEN_GROUND == m_SceneType) { return g_pGrdTracker->pGroundTracker->ObjStatus; } return obj; } void Arith_CalcTargetSysInfo(TARGET_OBJECT* pTargetObj, SINT32 nFrmNum, GLB_INPUT g_Input) { // 补全目标信息，如帧编号、角度、检测时间等. for (int i = 0; i < nFrmNum; i++) { TARGET_OBJECT* tTarget = &pTargetObj[i]; // 帧编号 tTarget->unFrmID = g_Input.unFrmId; //// 转惯性系 Pole polenue = getStablePoleFromImagePos(tTarget->pfCenPos, g_Input.stCamera, g_Input.servoInfo, g_Input.afPlatformRPY, g_Input.setupErr); // 目标角度赋值为大地坐标系 tTarget->afAngle.fAz = DEGLIM360((FLOAT32)polenue.beta); tTarget->afAngle.fPt = (FLOAT32)polenue.alpha; // 下视场景目标3d坐标计算，非下视返回空 tTarget->pos3d = getXYZFromPole_withHeight(polenue,g_Input.nElevationDiff); } } void Arith_EOController::GLB_Release_Trackers(SINT32 nPipeNum) { // 单目标跟踪时，由于使用了 if (GLB_STATUS_TRACK == g_GLB_stPara.nStatus) { if (g_pSkyTracker && g_pSkyTracker->m_LockingPipe) { g_pSkyTracker->Cancle(); } if (g_pGrdTracker && g_pGrdTracker->m_LockingPipe) { g_pGrdTracker->Cancle(); } /*if (g_pSkyTracker) { g_pSkyTracker->Cancle(); } if (g_pGrdTracker) { g_pGrdTracker->Cancle(); }*/ PIPE* pTrackPipe = &g_GLB_PipeProc->getPipeArray()[g_GLB_stPara.nLockPipeInd]; g_GLB_PipeProc->DelPipe(pTrackPipe); } if (GLB_STATUS_MOTRACK == g_GLB_stPara.nStatus) { // 依次解锁 for (size_t i = 0; i < nPipeNum; i++) { if (g_GLB_Trackers[i] != NULL) { g_GLB_Trackers[i]->Cancle(); delete g_GLB_Trackers[i]; g_GLB_Trackers[i] = NULL; // 删除跟踪管道 PIPE* pTrackPipe = &g_GLB_PipeProc->getPipeArray()[i]; g_GLB_PipeProc->DelPipe(pTrackPipe); } } } }