#include "Arith_EOController.h" #include "Arith_CoordModule.h" #include "Arith_Common.hpp" #include "Arith_ImgOperate.h" #include "opencv2/opencv.hpp" #define SAFE_CONFIG_GET(fs, key, target) \ if (!fs[key].empty()) { fs[key] >> target; } Arith_EOController::Arith_EOController() { g_GLB_bInitialize = FALSE; //上电初始化 g_pFrameTargetArray = NULL; g_pExternTargetArray = NULL; g_GLB_Detectors = NULL; g_GLB_PipeProc = NULL; g_GLB_Trackers = NULL; g_pGrdTracker = NULL; g_pSkyTracker = NULL; g_pAitTracker = NULL; g_pCustomTracker = NULL; memset(&g_GLB_stArithPara, 0, sizeof(ARIDLL_PARMA)); // 算法控制参数 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));//算法输出结果 nEOControlerFrmNum = 0; //算法处理帧计数 } Arith_EOController::~Arith_EOController() { // 待补充资源释放过程 if (g_pFrameTargetArray) { delete[] g_pFrameTargetArray; g_pFrameTargetArray = NULL; } if (g_pExternTargetArray) { #ifdef ENABLE_AI_CUDA_ReID for (int i = 0; i < INPUT_OBJ_NUM; ++i) { delete[] g_pExternTargetArray[i].ReIDfeature; g_pExternTargetArray[i].ReIDfeature = NULL; } #endif delete[] g_pExternTargetArray; g_pExternTargetArray = NULL; } if (g_GLB_Detectors) { delete g_GLB_Detectors; g_GLB_Detectors = NULL; } if (g_GLB_PipeProc) { MOT_Pipe::Destroy(g_GLB_PipeProc); g_GLB_PipeProc = NULL; } if (g_GLB_Trackers) { delete[] g_GLB_Trackers; g_GLB_Trackers = NULL; } if (g_pGrdTracker) { delete g_pGrdTracker; g_pGrdTracker = NULL; } if (g_pSkyTracker) { delete g_pSkyTracker; g_pSkyTracker = NULL; } if (g_pAitTracker) { delete g_pAitTracker; g_pAitTracker = NULL; } if (g_pCustomTracker) { delete g_pCustomTracker; g_pCustomTracker = NULL; } } /********************************************************** * 函数名称：Arith_Controller() * 功能描述：系统主控制函数 * 输入参数：SINT32 nWidth -- 图像宽度 * SINT32 nHeight -- 图像高度 * 输出参数：无 * 返 回 值：无 * 调用关系：无 * 其它说明：无 **********************************************************/ BBOOL Arith_EOController::Arith_Controller(GD_VIDEO_FRAME_S img) { BBOOL ubSuccessFlag = FALSE; //XLOG_DEBUG("XLOGGER IS RUNNIG!"); LOG_DEBUG("Arith_Controller!:g_GLB_stPara.nStatus:{},g_GLB_stCommand.ubCmd:{}", g_GLB_stPara.nStatus, g_GLB_stCommand.ubCmd); //获取并响应任务机指令 CMD_GetCommand(); //响应算法控制命令 CMD_RespondCommand(); // 处理跟踪器工作状态逻辑 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; LOG_DEBUG("ImportExternTargets:g_nExternTargetNum:{},nRemain:{}, g_TotalTargetNum:{}",g_nExternTargetNum, nRemain, g_TotalTargetNum); 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; LOG_DEBUG("Arith_SystemInit _ nSysMode:{},nScenMode:{}", nSysMode, nScenMode); } //////////////////////////////////////////////////////////////////////////////// //--函数定义 //////////////////////////////////////////////////////////////////////////////// /********************************************************** * 函数名称：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 = 60; g_GLB_stPara.snLockBoxSize.h = 60; g_GLB_stPara.snLockBoxSizeDefaut.w = 60; g_GLB_stPara.snLockBoxSizeDefaut.h = 60; //// qw 雷达导引区域大小 //g_GLB_stPara.nDetectRegionX = (SINT32)GLB_RADARGUIDE_RECT / 2; //g_GLB_stPara.nDetectRegionY = (SINT32)GLB_RADARGUIDE_RECT / 2; // 初始化为人工锁定方式 g_GLB_stPara.bSelectObjManual = true; g_GLB_stPara.stLockCtrl = LOCK_NONE; g_GLB_stPara.bEnForceGuide = false; // 初始化为多目标跟踪 g_GLB_stPara.bMutiTrack = true; //初始化使用捕获标记 g_GLB_stPara.bUseServeArrest = true; //初始化工作场景 m_SceneType = nScenMode; } void Arith_EOController::GLB_InitArithParameters() { //对空默认参数 g_GLB_stArithPara.stSkyParam.Sky_nTrackMemFrmNum = 1000; g_GLB_stArithPara.stSkyParam.Sky_bEnableFullImgDet = false; g_GLB_stArithPara.stSkyParam.Sky_bEnableTrackSA = true; g_GLB_stArithPara.stSkyParam.Sky_bEnableKCF = true; g_GLB_stArithPara.stSkyParam.Sky_bEnableMatcher = false; g_GLB_stArithPara.stSkyParam.nSmallObjSizeMax = 32; g_GLB_stArithPara.stSkyParam.Sky_bSelectObjManual = 1; g_GLB_stArithPara.stSkyParam.Sky_bUseAIDet = true; g_GLB_stArithPara.stSkyParam.Sky_nUseAIDetFeq = 1; g_GLB_stArithPara.stSkyParam.Sky_fLastMoveR = 4.0; g_GLB_stArithPara.stSkyParam.Sky_fPredMoveR = 2.0; g_GLB_stArithPara.stSkyParam.prmTSkyDet.bEnableDetcetAreaTarget = true; g_GLB_stArithPara.stSkyParam.prmTSkyDet.bEnableDetcetDimTarget = false; g_GLB_stArithPara.stSkyParam.prmTSkyDet.fSmallDetectGDK = 5; g_GLB_stArithPara.stSkyParam.prmTSkyDet.nGrayThresMinBright = 20; g_GLB_stArithPara.stSkyParam.prmTSkyDet.nGrayThresMinDark = 10; g_GLB_stArithPara.stSkyParam.prmTSkyDet.fAreaDetectGradDiffThre = 50; g_GLB_stArithPara.stSkyParam.prmTSkyDet.nDetectGrayType = 1; g_GLB_stArithPara.stSkyParam.prmTSkyDet.nDSmpScale = 4; // 对地默认参数 g_GLB_stArithPara.stGrdParam.bEnableAccuracyTrack = true; g_GLB_stArithPara.stGrdParam.bUseServePredict = false; g_GLB_stArithPara.stGrdParam.ubSetTrackMode = 0; g_GLB_stArithPara.stGrdParam.bEnableLKCorrect = true; g_GLB_stArithPara.stGrdParam.bEnableKCF = true; g_GLB_stArithPara.stGrdParam.nKcfUpdataStep = 2; g_GLB_stArithPara.stGrdParam.bKCFMutiScales = true; g_GLB_stArithPara.stGrdParam.fArrestKCFMinThre = 0.38f; g_GLB_stArithPara.stGrdParam.fArrestKCFMaxThre = 0.68f; g_GLB_stArithPara.stGrdParam.fKCFResthre = 0.23f; g_GLB_stArithPara.stGrdParam.bTLDOccJudge = true; g_GLB_stArithPara.stGrdParam.bEnableDaSiamRPN = false; g_GLB_stArithPara.stGrdParam.bEnableAIOccJudge = true; g_GLB_stArithPara.stGrdParam.fAIOccThre = 0.85f; g_GLB_stArithPara.stGrdParam.bEnableAIDetect = true; g_GLB_stArithPara.stGrdParam.bEnableArrestCorr = false; g_GLB_stArithPara.stGrdParam.bEnableArrestAngle = false; g_GLB_stArithPara.stGrdParam.bEnableAreestEsay = false; g_GLB_stArithPara.stGrdParam.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; #ifdef ENABLE_AI_CUDA_ReID for (int i = 0; i < INPUT_OBJ_NUM; ++i) { g_pExternTargetArray[i].nReIDFeaDim = GLB_REID_FEATURE_DIMS; g_pExternTargetArray[i].ReIDfeature = new FLOAT32[GLB_REID_FEATURE_DIMS]; memset(g_pExternTargetArray[i].ReIDfeature, 0, sizeof(FLOAT32) * GLB_REID_FEATURE_DIMS); g_pFrameTargetArray[i].nReIDFeaDim = GLB_REID_FEATURE_DIMS; g_pFrameTargetArray[i].ReIDfeature = g_pExternTargetArray[i].ReIDfeature; } #endif // 创建检测器 g_GLB_Detectors = new Detectors(&g_GLB_stInput, 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_stArithPara); g_pSkyTracker = new Tracker(nWidth,nHeight,GLB_SCEN_SKY, &g_GLB_stArithPara); g_pCustomTracker = new Tracker(nWidth, nHeight, GLB_SCEN_CUSTOM, &g_GLB_stArithPara); g_TrackCurrentID = 2; //辅跟踪目标默认从2开始 //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; g_GLB_stCommand.ubCmd = LockMode::LOCK_POINT; // 发送点选或者框选 /*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 = 40; g_GLB_stPara.snLockBoxSize.h = 40; g_GLB_stPara.snLockBoxSize.s = g_GLB_stPara.snLockBoxSize.w * g_GLB_stPara.snLockBoxSize.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) { // 等同于跟踪时点选，需要换批号 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); //复用锁定波门参数作为截获波门 LockBox.w = g_GLB_stPara.snLockBoxSize.w; LockBox.h = g_GLB_stPara.snLockBoxSize.h; } else { g_GLB_stPara.stLockCtrl = (LockMode::LOCK_RECT); } SINT32 nLockPipeInd = -1; g_GLB_stPara.ubLockID = -1; //g_GLB_stPara.nLockPipeInd = -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) { nLockPipeInd = 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 (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(POINT32S unLockBox, int CancleMode) { g_GLB_stCommand.ubCmd = LockMode::LOCK_UNLOCK; // 视场内解锁 g_GLB_stCommand.unSetCanclePosX = unLockBox.x; g_GLB_stCommand.unSetCanclePosY = unLockBox.y; g_GLB_stCommand.unSetCancleMode = CancleMode; } void Arith_EOController::Arith_CMD_SetScenMode(GLB_SCEN_MODE nScenMode) { g_GLB_stCommand.ubScenCmd = nScenMode; } void Arith_EOController::Arith_CMD_SetTrackMode(BYTE8 ubTrackMode) { g_GLB_stCommand.ubMutiTrack = ubTrackMode; } 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; para.nObjSizeMin = config.PrmSkyDetect.nObjSizeMin; 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; pipePara.bOutMainPipeShadow = config.bOutMainPipeShadow;//传递主跟踪背景管道显示开关 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; g_GLB_stPara.bGuideCanLockSAPipe = config.bGuideCanLockSAPipe; g_GLB_stPara.bEnLowSkylieSADet = config.PrmSkyDetect.bEnLowSkylieSADet; //LOG_DEBUG("{0}, {1}, {2}", __FILE__, __FUNCTION__, __LINE__); // 设置跟踪器参数模板 //Param_SkyTracker* pSkyParam = &g_GLB_TKPara_Template.skyParam;//对空 //Param_GroundTracker* pGrdParam = &g_GLB_stArithPara.stGrdParam;//对地 //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); } } // 读取运行时跟踪参数 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_stArithPara.stGrdParam; config->stSkyParam = g_GLB_stArithPara.stSkyParam; } /************************************* * 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 Arith_EOController::getStructFromFS(cv::FileStorage fs) { ARIDLL_PARMA config = { 0 }; // 读取默认配置 Arith_GetRunTimeParam(&config); // PrmSkyDetect parameters SAFE_CONFIG_GET(fs, "bEnableDetcetAreaTarget", config.PrmSkyDetect.bEnableDetcetAreaTarget); SAFE_CONFIG_GET(fs, "bEnableDetcetSmallTarget", config.PrmSkyDetect.bEnableDetcetSmallTarget); SAFE_CONFIG_GET(fs, "bEnableDetcetDimTarget", config.PrmSkyDetect.bEnableDetcetDimTarget); SAFE_CONFIG_GET(fs, "fSmallDetectGDK", config.PrmSkyDetect.fSmallDetectGDK); SAFE_CONFIG_GET(fs, "fAreaDetectGradDiffThre", config.PrmSkyDetect.fAreaDetectGradDiffThre); SAFE_CONFIG_GET(fs, "nGrayThresMinBright", config.PrmSkyDetect.nGrayThresMinBright); SAFE_CONFIG_GET(fs, "nGrayThresMinDark", config.PrmSkyDetect.nGrayThresMinDark); SAFE_CONFIG_GET(fs, "nDetectGrayType", config.PrmSkyDetect.nDetectGrayType); SAFE_CONFIG_GET(fs, "nDSmpScale", config.PrmSkyDetect.nDSmpScale); SAFE_CONFIG_GET(fs, "bEnLowSkylieSADet", config.PrmSkyDetect.bEnLowSkylieSADet); SAFE_CONFIG_GET(fs, "nObjSizeMin", config.PrmSkyDetect.nObjSizeMin); // stSkyParam.prmTSkyDet parameters SAFE_CONFIG_GET(fs, "bEnableDetcetAreaTarget", config.stSkyParam.prmTSkyDet.bEnableDetcetAreaTarget); SAFE_CONFIG_GET(fs, "bEnableDetcetSmallTarget", config.stSkyParam.prmTSkyDet.bEnableDetcetSmallTarget); SAFE_CONFIG_GET(fs, "bEnableDetcetDimTarget", config.stSkyParam.prmTSkyDet.bEnableDetcetDimTarget); SAFE_CONFIG_GET(fs, "fSmallDetectGDK", config.stSkyParam.prmTSkyDet.fSmallDetectGDK); SAFE_CONFIG_GET(fs, "fAreaDetectGradDiffThre", config.stSkyParam.prmTSkyDet.fAreaDetectGradDiffThre); SAFE_CONFIG_GET(fs, "nGrayThresMinBright", config.stSkyParam.prmTSkyDet.nGrayThresMinBright); SAFE_CONFIG_GET(fs, "nGrayThresMinDark", config.stSkyParam.prmTSkyDet.nGrayThresMinDark); SAFE_CONFIG_GET(fs, "nDetectGrayType", config.stSkyParam.prmTSkyDet.nDetectGrayType); SAFE_CONFIG_GET(fs, "nDSmpScale", config.stSkyParam.prmTSkyDet.nDSmpScale); SAFE_CONFIG_GET(fs, "bEnLowSkylieSADet", config.stSkyParam.prmTSkyDet.bEnLowSkylieSADet); // stSkyParam parameters SAFE_CONFIG_GET(fs, "Sky_bEnableFullImgDet", config.stSkyParam.Sky_bEnableFullImgDet); SAFE_CONFIG_GET(fs, "Sky_bEnableTrackSA", config.stSkyParam.Sky_bEnableTrackSA); SAFE_CONFIG_GET(fs, "Sky_bEnableKCF", config.stSkyParam.Sky_bEnableKCF); SAFE_CONFIG_GET(fs, "Sky_bEnableMatcher", config.stSkyParam.Sky_bEnableMatcher); SAFE_CONFIG_GET(fs, "Sky_bSelectObjManual", config.stSkyParam.Sky_bSelectObjManual); SAFE_CONFIG_GET(fs, "Sky_bUseAIDet", config.stSkyParam.Sky_bUseAIDet); SAFE_CONFIG_GET(fs, "Sky_nUseAIDetFeq", config.stSkyParam.Sky_nUseAIDetFeq); SAFE_CONFIG_GET(fs, "Sky_nTrackMemFrmNum", config.stSkyParam.Sky_nTrackMemFrmNum); SAFE_CONFIG_GET(fs, "nSmallObjSizeMax", config.stSkyParam.nSmallObjSizeMax); // Global config parameters SAFE_CONFIG_GET(fs, "nPipeRadiusSearch", config.nPipeRadiusSearch); SAFE_CONFIG_GET(fs, "nPipeRadiusLock", config.nPipeRadiusLock); SAFE_CONFIG_GET(fs, "nPipeRadiusTrack", config.nPipeRadiusTrack); SAFE_CONFIG_GET(fs, "nPipeRadiusLost", config.nPipeRadiusLost); SAFE_CONFIG_GET(fs, "nAwsFrmNumScan", config.nAwsFrmNumScan); SAFE_CONFIG_GET(fs, "nAwsFrmNumStare", config.nAwsFrmNumStare); SAFE_CONFIG_GET(fs, "nPipeDelMinScan", config.nPipeDelMinScan); SAFE_CONFIG_GET(fs, "nPipeDelMinStare", config.nPipeDelMinStare); SAFE_CONFIG_GET(fs, "ABF_a", config.fA); SAFE_CONFIG_GET(fs, "ABF_b", config.fB); SAFE_CONFIG_GET(fs, "nLockPointW", config.nLockPointW); SAFE_CONFIG_GET(fs, "nLockPointH", config.nLockPointH); SAFE_CONFIG_GET(fs, "bGuideCanLockSAPipe", config.bGuideCanLockSAPipe); SAFE_CONFIG_GET(fs, "bCloseBadPointPipe", config.bCloseBadPointPipe); SAFE_CONFIG_GET(fs, "bOutMainPipeShadow", config.bOutMainPipeShadow); // stGrdParam parameters SAFE_CONFIG_GET(fs, "Grd_bEnableAccuracyTrack", config.stGrdParam.bEnableAccuracyTrack); SAFE_CONFIG_GET(fs, "Grd_bUseServePredict", config.stGrdParam.bUseServePredict); SAFE_CONFIG_GET(fs, "Grd_ubSetTrackMode", config.stGrdParam.ubSetTrackMode); SAFE_CONFIG_GET(fs, "Grd_bEnableLKCorrect", config.stGrdParam.bEnableLKCorrect); SAFE_CONFIG_GET(fs, "Grd_bEnableKCF", config.stGrdParam.bEnableKCF); SAFE_CONFIG_GET(fs, "Grd_nKcfUpdataStep", config.stGrdParam.nKcfUpdataStep); SAFE_CONFIG_GET(fs, "Grd_bKCFMutiScales", config.stGrdParam.bKCFMutiScales); SAFE_CONFIG_GET(fs, "Grd_fArrestKCFMinThre", config.stGrdParam.fArrestKCFMinThre); SAFE_CONFIG_GET(fs, "Grd_fArrestKCFMaxThre", config.stGrdParam.fArrestKCFMaxThre); SAFE_CONFIG_GET(fs, "Grd_fKCFResthre", config.stGrdParam.fKCFResthre); SAFE_CONFIG_GET(fs, "Grd_bTLDOccJudge", config.stGrdParam.bTLDOccJudge); SAFE_CONFIG_GET(fs, "Grd_bEnableDaSiamRPN", config.stGrdParam.bEnableDaSiamRPN); SAFE_CONFIG_GET(fs, "Grd_bEnableAIOccJudge", config.stGrdParam.bEnableAIOccJudge); SAFE_CONFIG_GET(fs, "Grd_fAIOccThre", config.stGrdParam.fAIOccThre); SAFE_CONFIG_GET(fs, "Grd_bEnableAIDetect", config.stGrdParam.bEnableAIDetect); SAFE_CONFIG_GET(fs, "Grd_bEnableArrestCorr", config.stGrdParam.bEnableArrestCorr); SAFE_CONFIG_GET(fs, "Grd_bEnableArrestAngle", config.stGrdParam.bEnableArrestAngle); SAFE_CONFIG_GET(fs, "Grd_bEnableAreestEsay", config.stGrdParam.bEnableAreestEsay); SAFE_CONFIG_GET(fs, "Grd_nArrestEsayCnt", config.stGrdParam.nArrestEsayCnt); // Logging parameter SAFE_CONFIG_GET(fs, "EnableLogLevel", config.nLogLevel); return config; } bool Arith_EOController::Arith_ReadParaFile(const char* path) { cv::FileStorage fs(path, cv::FileStorage::READ); LOG_DEBUG("**************config path is:{}", path); if (!fs.isOpened()) { LOG_DEBUG("fs.isOpened() is FALSE!!!!!!!!!!!!!"); return false; } ARIDLL_PARMA config = getStructFromFS(fs); Arith_SetRunTimeParam(config); return true; } 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" << 50; // 梯度最小阈值 fs << "nGrayThresMinBright" << 20; // 亮目标灰度最小阈值 fs << "nGrayThresMinDark" << 10; // 暗目标灰度最小阈值 fs << "nDetectGrayType" << 1; // 默认检测亮暗目标类型 fs << "nDSmpScale" << 4; // 默认降采样倍数 fs << "Sky_bEnableFullImgDet" << true; // 对空跟踪过程中是否开启全图小面 fs << "Sky_bEnableTrackSA" << true; // 是否打开质心跟踪 fs << "Sky_bEnableKCF" << true; // 是否打开KCF跟踪 fs << "Sky_bEnableMatcher" << false; // 是否允许金字塔模板匹配 fs << "Sky_bSelectObjManual" << true; // 是否手动选择目标转跟踪 fs << "Sky_bUseAIDet" << true; // 是否使用AI检测信息的标志 fs << "Sky_nUseAIDetFeq" << 1; // 使用AI识别管道的频率(默认每帧用一次) fs << "Sky_nTrackMemFrmNum" << 1000; // 最大记忆帧数 fs << "bEnLowSkylieSADet" << true; // 允许低于天地线小面检测输出，默认允许 fs << "nSmallObjSizeMax" << 36; // 小目标最大像素数 fs << "nObjSizeMin" << 1; 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 << "bGuideCanLockSAPipe" << true; // 导引允许锁定小面检测创建管道 fs << "bCloseBadPointPipe" << false; // 关闭坏点管道 fs << "bOutMainPipeShadow" << false; // 主跟踪目标背景管道送显(默认关闭) fs << "Grd_bEnableAccuracyTrack" << true; fs << "Grd_bUseServePredict" << false; fs << "Grd_ubSetTrackMode" << 0; 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 = "DebugJson.xml"; cv::FileStorage fs(strTmp, 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 << "FindSAI" << g_GLB_stOutput.sky_emFindState; fs << "TUFlag" << g_GLB_stOutput.sky_emTUFlag; //fs << "Conf" << std::to_string(g_GLB_stOutput.sky_fTrkConf); fs << "BOS" << std::to_string(g_GLB_stOutput.sky_bComplexEnv) + std::to_string(g_GLB_stOutput.sky_bInterferenceMem) + std::to_string(g_GLB_stOutput.sky_bSimIntercept); } 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) { } std::string ss = fs.releaseAndGetString(); memcpy(str, ss.c_str(), MIN(ss.size(), 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 (GLB_STATUS_MOTRACK == g_GLB_stPara.nStatus || GLB_STATUS_TRACK == g_GLB_stPara.nStatus) { g_TrackCurrentID = 2; //重置辅跟踪目标ID，辅跟踪目标默认从2开始 if (g_pSkyTracker && g_pSkyTracker->m_LockingPipe) { g_pSkyTracker->Cancle(); } if (g_pGrdTracker && g_pGrdTracker->m_LockingPipe) { g_pGrdTracker->Cancle(); } // 依次解锁 for (size_t i = 0; i < nPipeNum; i++) { PIPE* pPipe = &g_GLB_PipeProc->getPipeArray()[i]; if (pPipe->bTracking) { pPipe->bTracking = FALSE; pPipe->nDelCntThres = GLB_PIPE_DEL_MIN_STARE; } if (pPipe->bTrackingPipe) { pPipe->bTrackingPipe = FALSE; pPipe->nDelCntThres = GLB_PIPE_DEL_MIN_STARE; } pPipe->nShowPipeID = 0;//清空外部显示批号 } } } void Arith_EOController::GLB_Cancle_Point(SINT32 nPipeNum,POINT32S ptCanclePos) { SINT32 nSelecID = -1; SINT32 nNearstDis = 999999; // 便历距离最近的跟踪器 for (int i = 0; i < nPipeNum; i++) { PIPE* pPipe = &g_GLB_PipeProc->getPipeArray()[i]; if (!pPipe->bTracking || pPipe->bTrackingPipe) //1号目标或非辅跟踪目标跳过 { continue; } SINT32 disX = ABS(pPipe->ptCurrentPnt.x - ptCanclePos.x); SINT32 disY = ABS(pPipe->ptCurrentPnt.y - ptCanclePos.y); SINT32 nDis2 = disX * disX + disY * disY; if (nDis2 < nNearstDis) { nNearstDis = nDis2; nSelecID = i; } } if (-1 != nSelecID) { PIPE* pPipe = &g_GLB_PipeProc->getPipeArray()[nSelecID]; pPipe->bTracking = FALSE; pPipe->nDelCntThres = GLB_PIPE_DEL_MIN_STARE; } }