S3315_RK3588/NeoTracker/src/Arith_EOController.cpp

#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;
    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);

    // 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 << "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;
    }
}