#include "Arith_DetectSmallObj.h"
#include "Arith_ImgOperate.h"
#include <vector>


API_DetectSmallObj * API_DetectSmallObj::Create(SINT32 nWidth, SINT32 nHeight)
{
    return new DetectSmallObj(nWidth,nHeight);
}

API_DetectSmallObj * API_DetectSmallObj::Create(SINT32 nWidth, SINT32 nHeight, CENTERRECT mmCenterRect)
{
    return new DetectSmallObj(nWidth,nHeight,mmCenterRect);
}

void API_DetectSmallObj::Destroy(API_DetectSmallObj * obj)
{
    delete obj;
}


//小目标检测模板1
SINT32 g_DST_nFilter_9_13[DST_KERNAL_SIZE_9_13] =
{
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};

//小目标检测模板2
SINT32 g_DST_nFilter_5_9[DST_KERNAL_SIZE_5_9] =
{
    1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 0, 0, 0, 0, 0, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1
};



DetectSmallObj::DetectSmallObj(SINT32 nWidth, SINT32 nHeight)
{
    CENTERRECT mmCenterRect;
    mmCenterRect.cx = nWidth / 2;
    mmCenterRect.cy = nHeight / 2;
    mmCenterRect.w = nWidth;
    mmCenterRect.h = nHeight;
    mmCenterRect.s = nWidth * nHeight;

    DST_pBlkMaxPoint = NULL;
    DST_pBlkPtBeTargetFlag = NULL;
    DST_pBlkMaxPntFlag = NULL;
    m_FrmObjsCnt = 0;
    Init(nWidth, nHeight, mmCenterRect);
}

DetectSmallObj::DetectSmallObj(SINT32 nWidth, SINT32 nHeight, CENTERRECT mmCenterRect)
{
    DST_pBlkMaxPoint = NULL;
    DST_pBlkPtBeTargetFlag = NULL;
    DST_pBlkMaxPntFlag = NULL;
    m_FrmObjsCnt = 0;
    Init(nWidth, nHeight, mmCenterRect);
}

DetectSmallObj::~DetectSmallObj()
{
    DST_ReleaseMemory();
}

bool DetectSmallObj::Init(SINT32 nWidth, SINT32 nHeight, CENTERRECT mmCenterRect)
{
    DST_Initialization(nWidth,nHeight, mmCenterRect);
    m_FrmObjsCnt = 0;
    bEnableSmallDet = true;

    return true;
}

int DetectSmallObj::Detect(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight, CENTERRECT mmCenterRect, GLB_STATUS nStatus)
{
    if (!bEnableSmallDet)
    {
        m_FrmObjsCnt = 0;
        return ERR_UNInit;
    }

    m_DST_stInput.crCenterRect = mmCenterRect;
    m_FrmObjsCnt = DST_DetectSmallTarget(img, nWidth, nHeight, nStatus);
    return m_FrmObjsCnt;
}

void DetectSmallObj::SetSearchBLK(DST_INPUT inputBLK)
{
    m_DST_stInput = inputBLK;
}

void DetectSmallObj::SetCombinDist(SINT32 ndistance)
{
    m_DST_stPara.nObjCombineDist = ndistance;
}

TARGET_OBJECT* DetectSmallObj::GetTargetArray()
{
    return DST_Target;
}

SINT32 DetectSmallObj::GetTargetNum()
{
    return m_FrmObjsCnt;
}

void DetectSmallObj::SetTargetNum(SINT32 num)
{
    m_FrmObjsCnt = num;
}

DST_PARAMETERS* DetectSmallObj::GetDstParm()
{
    return &m_DST_stPara;
}

void DetectSmallObj::setDstParm(Param_SkyDetect* param)
{
    m_DST_stPara.fgdk = param->fSmallDetectGDK;
    m_DST_stPara.nDetectGrayType = param->nDetectGrayType;
}

BBOOL DetectSmallObj::getDstDetState()
{
    return bEnableSmallDet;
}

void DetectSmallObj::setDstDetState(BBOOL bEnableState)
{
    bEnableSmallDet = bEnableState;
}



////////////////////////////////////////////////////////////////////////////////
//--函数定义
////////////////////////////////////////////////////////////////////////////////
/**********************************************************
* 函数名称：DST_DetectSmallTarget()
* 功能描述：基于分块极值的小目标检测
* 输入参数：UINT16 *pSrc --  原始图像
*           SINT32 nWidth   --  图像宽度
*           SINT32 nHeight  --  图像高度
* 输出参数：无
* 返 回 值：小目标检测个数
* 调用关系：
* 其它说明：无
**********************************************************/
SINT32 DetectSmallObj::DST_DetectSmallTarget(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight, GLB_STATUS nStatus)
{
    //指向DSP数据空间
    POINT16S* pBlkMaxPnt = (POINT16S*)DST_pBlkMaxPoint;
    TARGET_OBJECT* ptTargetArray = (TARGET_OBJECT*)DST_Target;
    SINT32* pBlkPtBeTargetFlag = (SINT32*)DST_pBlkPtBeTargetFlag;
    BYTE8* pbBlkMaxPntFlag = (BYTE8*)DST_pBlkMaxPntFlag;	//20161130，极值点最大/最小标志

    // 未初始化报错
    if (!m_DST_bInitialize)
    {
        return ERR_UNInit;
    }

    //局部变量
    SINT32 nObjsCnt = 0;

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //初始化算法输出结果
    DST_CleanUpFrameDetectOutput();

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //获取检测区域边界
    m_DST_stInput.mmCenterRect.minX = m_DST_stInput.crCenterRect.cx - (m_DST_stInput.crCenterRect.w >> 1);
    m_DST_stInput.mmCenterRect.minY = m_DST_stInput.crCenterRect.cy - (m_DST_stInput.crCenterRect.h >> 1);
    m_DST_stInput.mmCenterRect.maxX = m_DST_stInput.crCenterRect.cx + (m_DST_stInput.crCenterRect.w >> 1);
    m_DST_stInput.mmCenterRect.maxY = m_DST_stInput.crCenterRect.cy + (m_DST_stInput.crCenterRect.h >> 1);

    //限制检测区域边界
    m_DST_stInput.mmCenterRect.minX = MAX(0, MIN(m_DST_stInput.mmCenterRect.minX, nWidth - 1));
    m_DST_stInput.mmCenterRect.maxX = MAX(0, MIN(m_DST_stInput.mmCenterRect.maxX, nWidth - 1));
    m_DST_stInput.mmCenterRect.minY = MAX(0, MIN(m_DST_stInput.mmCenterRect.minY, nHeight - 1));
    m_DST_stInput.mmCenterRect.maxY = MAX(0, MIN(m_DST_stInput.mmCenterRect.maxY, nHeight - 1));

    //更新检测区域中心矩形
    m_DST_stInput.crCenterRect.cx = (m_DST_stInput.mmCenterRect.minX + m_DST_stInput.mmCenterRect.maxX) >> 1;
    m_DST_stInput.crCenterRect.cy = (m_DST_stInput.mmCenterRect.minY + m_DST_stInput.mmCenterRect.maxY) >> 1;
    m_DST_stInput.crCenterRect.h = m_DST_stInput.mmCenterRect.maxY - m_DST_stInput.mmCenterRect.minY + 1;
    m_DST_stInput.crCenterRect.w = m_DST_stInput.mmCenterRect.maxX - m_DST_stInput.mmCenterRect.minX + 1;
    m_DST_stInput.crCenterRect.s = (SINT32)(m_DST_stInput.crCenterRect.h * m_DST_stInput.crCenterRect.w);

    // 分块方案不存在，返回0
    if(m_DST_stInput.nBlkWidth == 0 || m_DST_stInput.nBlkHeight == 0)
    {
        return 0;
    }

    //调整分块大小和分块区域
    m_DST_stInput.nBlkNumW = m_DST_stInput.crCenterRect.w / m_DST_stInput.nBlkWidth;
    m_DST_stInput.nBlkNumH = m_DST_stInput.crCenterRect.h / m_DST_stInput.nBlkHeight;
    m_DST_stInput.nBlkNum = m_DST_stInput.nBlkNumW * m_DST_stInput.nBlkNumH;
    if ((m_DST_stInput.nBlkNumW <= 0) || (m_DST_stInput.nBlkNumH <= 0))
    {
        return 0;
    }

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //图像分块并返回块极值点
    if (nStatus == GLB_STATUS_TRACK)
    {
        DST_FindExtremum(img, nWidth, nHeight, pBlkMaxPnt, pbBlkMaxPntFlag,
            m_DST_stInput.mmCenterRect.minY, m_DST_stInput.mmCenterRect.minX,
            m_DST_stInput.nBlkWidth, m_DST_stInput.nBlkHeight,
            m_DST_stInput.nBlkNumW, m_DST_stInput.nBlkNumH);
    }
    else
    {// 搜索阶段螺旋输出极值点
        DST_FindExtremumSpiral(img, nWidth, nHeight, pBlkMaxPnt, pbBlkMaxPntFlag,
            m_DST_stInput.mmCenterRect.minY, m_DST_stInput.mmCenterRect.minX,
            m_DST_stInput.nBlkWidth, m_DST_stInput.nBlkHeight,
            m_DST_stInput.nBlkNumW, m_DST_stInput.nBlkNumH);
    }

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //判断极值点是否为目标
    // wcw04046 面目标空间留出来
    nObjsCnt = DST_DetectFrameTarget(img, nWidth, nHeight,
        ptTargetArray, DST_MAX_NUM, pBlkMaxPnt,
        m_DST_stInput.nBlkNumW, m_DST_stInput.nBlkNumH, pBlkPtBeTargetFlag);

    // 显式输出目标个数
    m_DST_stOutput.nFrmObjsCnt = nObjsCnt;

    return nObjsCnt;
}

/**********************************************************
* 函数名称：DST_Initialization()
* 功能描述：算法初始化
* 输入参数：无
* 输出参数：无
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void DetectSmallObj::DST_Initialization(SINT32 nWidth, SINT32 nHeight, CENTERRECT mmCenterRect)
{
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //初始化算法输入
    //搜索区域
    m_DST_stInput.crCenterRect.cx = (SINT16)(mmCenterRect.cx);
    m_DST_stInput.crCenterRect.cy = (SINT16)(mmCenterRect.cy);
    m_DST_stInput.crCenterRect.w = mmCenterRect.w;
    m_DST_stInput.crCenterRect.h = mmCenterRect.h;
    m_DST_stInput.crCenterRect.s = m_DST_stInput.crCenterRect.w * m_DST_stInput.crCenterRect.h;
    m_DST_stInput.mmCenterRect.minX = m_DST_stInput.crCenterRect.cx - (m_DST_stInput.crCenterRect.w >> 1);
    m_DST_stInput.mmCenterRect.minY = m_DST_stInput.crCenterRect.cy - (m_DST_stInput.crCenterRect.h >> 1);
    m_DST_stInput.mmCenterRect.maxX = m_DST_stInput.crCenterRect.cx + (m_DST_stInput.crCenterRect.w >> 1);
    m_DST_stInput.mmCenterRect.maxY = m_DST_stInput.crCenterRect.cy + (m_DST_stInput.crCenterRect.h >> 1);

    //弱小目标强制搜索
    m_DST_stInput.crnSemiSrRect.cx = m_DST_stInput.crCenterRect.cx;
    m_DST_stInput.crnSemiSrRect.cy = m_DST_stInput.crCenterRect.cy;
    m_DST_stInput.crnSemiSrRect.w = DST_DIMOBJ_SR_RGN_W;
    m_DST_stInput.crnSemiSrRect.h = DST_DIMOBJ_SR_RGN_H;
    m_DST_stInput.crnSemiSrRect.s = m_DST_stInput.crnSemiSrRect.w * m_DST_stInput.crnSemiSrRect.h;
    m_DST_stInput.mmnSemiSrRect.minX = m_DST_stInput.crnSemiSrRect.cx - (m_DST_stInput.crnSemiSrRect.w >> 1);
    m_DST_stInput.mmnSemiSrRect.minY = m_DST_stInput.crnSemiSrRect.cy - (m_DST_stInput.crnSemiSrRect.h >> 1);
    m_DST_stInput.mmnSemiSrRect.maxX = m_DST_stInput.crnSemiSrRect.cx + (m_DST_stInput.crnSemiSrRect.w >> 1);
    m_DST_stInput.mmnSemiSrRect.maxY = m_DST_stInput.crnSemiSrRect.cy + (m_DST_stInput.crnSemiSrRect.h >> 1);

    //分块大小
    m_DST_stInput.nBlkHeight = 16;
    m_DST_stInput.nBlkWidth = 16;

    //搜索区域内分块个数
    m_DST_stInput.nBlkNumH = m_DST_stInput.crCenterRect.w / m_DST_stInput.nBlkWidth;
    m_DST_stInput.nBlkNumW = m_DST_stInput.crCenterRect.h / m_DST_stInput.nBlkHeight;
    m_DST_stInput.nBlkNum = m_DST_stInput.nBlkNumH * m_DST_stInput.nBlkNumW;

    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //初始化算法参数
    //算法状态控制（上位机软件界面可调）
    //小目标检测参数（上位机软件界面可调）
    m_DST_stPara.nObjCombineDist = 9;
    m_DST_stPara.fgdk = DST_OBJ_SNR_MIN;
    m_DST_stPara.fKernalBGStdMin = DST_Bm_STD_LIMIT_MIN;
    m_DST_stPara.fKernalBGStdMax = DST_Bm_STD_LIMIT_MAX;
    m_DST_stPara.nObjSizeMin = DST_OBJ_SIZE_MIN;
    m_DST_stPara.nObjSizeMax = DST_KERNAL_SIZE_TG * DST_KERNAL_SIZE_TG;
    m_DST_stPara.nObjWHRatioMethod = DST_OBJ_WHRATIO_LINEWH;
    m_DST_stPara.fObjWHRatioMin = 0.2f;
    m_DST_stPara.fObjWHRatioMax = 5.0f;
    m_DST_stPara.fObjRectRatioMin = 0.2f;
    m_DST_stPara.nBGObjNumThres = 2;
    m_DST_stPara.nBTGrayMinThres = 10;

    m_DST_stPara.bDimDetecting = false;
    m_DST_stPara.bEnableDimDetect = false;
    m_DST_stPara.bEnableSecDetect = false;

    m_DST_stPara.bSecDetecting = FALSE;

    //小目标检测去虚警开关（上位机软件界面可调）
    m_DST_stPara.bUseDeFA_VarMin = 1;
    m_DST_stPara.bUseDeFA_VarMax = 0;
    m_DST_stPara.bUseDeFA_Size = 1;
    m_DST_stPara.bUseDeFA_WHRatio = 0;// 
    m_DST_stPara.bUseDeFA_RectRatio = 0;
    m_DST_stPara.bUseDeFA_BGFACnt = 0;
    m_DST_stPara.bUseDeFA_BTGrayMin = 1;
    m_DST_stPara.bUseDeFA_CenFlag = 0;
    m_DST_stPara.bUseDeFA_XYPrj = 0;

    //目标检测类型
    m_DST_stPara.nDetectGrayType = GLB_OBJ_GRAY_BRIGHT;

    // 模板参数
    m_DST_stPara.pnFilter = g_DST_nFilter_9_13;
    m_DST_stPara.nFilterBGW = DST_KERNAL_SIZE_Bm_13;
    m_DST_stPara.nFilterTGW = DST_KERNAL_SIZE_Tm_9;


    // 申请内存
    DST_MallocMemory(nWidth, nHeight, mmCenterRect);

    // 初始化算法输出结果
    DST_CleanUpFrameDetectOutput();

    // 初始化弱小目标检测结果
    DST_CleanUpFrameDimDetectOutput();

    m_DST_bInitialize = true;
}




/**********************************************************
* 函数名称：DST_CleanUpFrameDetectOutput()
* 功能描述：初始化单帧检测算法输出结果
* 输入参数：无
* 输出参数：无
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void DetectSmallObj::DST_CleanUpFrameDetectOutput(void)
{
    //小目标检测结果
    m_DST_stOutput.nFrmObjsCnt = 0;
    m_DST_stOutput.nDimFrmsCnt = 0;

    //初始化数据空间
    POINT16S* pBlkMaxPnt = (POINT16S*)DST_pBlkMaxPoint;
    TARGET_OBJECT* ptTargetArray = (TARGET_OBJECT*)DST_Target;
    SINT32* pBlkPtBeTargetFlag = (SINT32*)DST_pBlkPtBeTargetFlag;
    BYTE8* pBlkMaxPntFlag = (BYTE8*)DST_pBlkMaxPntFlag;

    memset(pBlkMaxPnt, 0, m_DST_stInput.nBlkNum * sizeof(POINT16S) * 2);
    memset(ptTargetArray, 0, DST_MAX_NUM * sizeof(TARGET_OBJECT));
    memset(pBlkPtBeTargetFlag, 0, m_DST_stInput.nBlkNum * sizeof(SINT32) * 2);
    memset(pBlkMaxPntFlag, 0, m_DST_stInput.nBlkNum * sizeof(BYTE8) * 2);

}
/**********************************************************
* 函数名称：DST_CleanUpFrameDimDetectOutput()
* 功能描述：初始化单帧弱小目标检测算法输出结果
* 输入参数：无
* 输出参数：无
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void DetectSmallObj::DST_CleanUpFrameDimDetectOutput(void)
{
    //弱小目标强制搜索
    if (m_DST_stOutput.nDimFrmsCnt <= 0)
    {
        m_DST_stOutput.pxSrImg = (UINT16*)DST_pxDimSrImg;
        memset(m_DST_stOutput.pxSrImg, 0, DST_DIMOBJ_SR_RGN_S * sizeof(UINT16));
    }
    m_DST_stOutput.snDimSrImgSize.w = m_DST_stInput.crnSemiSrRect.w;
    m_DST_stOutput.snDimSrImgSize.h = m_DST_stInput.crnSemiSrRect.h;
    m_DST_stOutput.snDimSrImgSize.s = m_DST_stOutput.snDimSrImgSize.w * m_DST_stOutput.snDimSrImgSize.h;
    m_DST_stOutput.nDimPriorObjId = -1;
    m_DST_stOutput.nFrmDimObjsCnt = 0;
    m_DST_stOutput.nDimSmpScale = 1;

    //清空弱小目标数组
    TARGET_OBJECT* ptDimTarget = (TARGET_OBJECT*)DST_DimTarget;
    memset(ptDimTarget, 0, DST_DIMOBJ_BLK_NUM * sizeof(TARGET_OBJECT));

    //清空弱小目标检测极值点
    POINT16S* pDimBlkMaxPnt = (POINT16S*)DST_pDimBlkMaxPoint;
    memset(pDimBlkMaxPnt, 0, DST_DIMOBJ_BLK_NUM * sizeof(POINT16S));

    //搜索区域双边滤波
    SINT16* pDimBFHighImg = (SINT16*)DST_pDimBFHighImg;
    UINT16* pDimBFLowImg = (UINT16*)DST_pDimBFLowImg;
    memset(pDimBFHighImg, 0, DST_DIMOBJ_SR_RGN_S * sizeof(SINT16));
    memset(pDimBFLowImg, 0, DST_DIMOBJ_SR_RGN_S * sizeof(UINT16));
}

/**********************************************************
* 函数名称：DST_FindBlkExtremum()
* 功能描述：查找块内极值点
* 输入参数：UINT16 *pFrame   --  原始图像
*           SINT32 nWidth       --  图像宽度
*           SINT32 nHeight      --  图像高度
*           SINT32 pBlkStart    --  该分块在原始图像上的起始坐标
*           SINT32 nBlkWidth    --  分块宽度
*           SINT32 nBlkHeight   --  分块高度
* 输出参数：无
* 返 回 值：POINT16S pPnt       --  块内极值点坐标
* 调用关系：无
* 其它说明：MSSu, 20111115: 函数修改，增加查找块内极小值的功能，
*           对于每个块的极大值和极小值，选两者中与块均值偏差较大的作为返回点。
**********************************************************/
POINT16S DetectSmallObj::DST_FindBlkExtremum(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight,
    SINT32 pBlkStart, SINT32 nBlkWidth, SINT32 nBlkHeight, BYTE8* pbMaxFlag,POINT16S * pSecondMax)
{
    SINT32      i, j;
    SINT32      nLen = nBlkWidth * nBlkHeight;
    UINT16   pGray = 0;

    UINT16   pMax = 0;
    UINT16   pMax2    = 0;//次极大值

    UINT16   pMin = 65535;
    UINT16   pMin2 = 65535;//次极小值


    SINT32      pMean = 0;
    POINT16S    pPntMax = { 0 };
    POINT16S    pPntMax2    = {0};//次极大值点坐标
    POINT16S    pPntMin = { 0 };
    POINT16S    pPnt = { 0 };
    SINT32      nMaxIndex = 0;
    SINT32      nMinIndex = 0;
    SINT32      nMaxIndex2 = 0;
    SINT32      nMinIndex2 = 0;

    SINT32      nIndex = 0;
    FLOAT32	  	fPntMaxBkgMean = 0.0;	//20170405，极大值点9*13模板邻域均值
    FLOAT32	  	fPntMinBkgMean = 0.0; //20170405，极小值点9*13模板邻域均值
    SINT32      nMaxI      = 0;
    SINT32      nMaxJ      = 0;

    UINT16   	pDiffThres = m_DST_stPara.nBTGrayMinThres;

    //查找块内极值点
    for (i = 0; i < nBlkHeight; i++)
    {
        for (j = 0; j < nBlkWidth; j++)
        {
            //获取块内每个像素点灰度
            nIndex = pBlkStart + j;
            if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
            {
                pGray = ((UBYTE8*)img.u64VirAddr[0])[nIndex];
            }
            else
            {
                pGray = ((UINT16*)img.u64VirAddr[0])[nIndex];
            }

            int x = nIndex % nWidth;
            int y = nIndex / nWidth;


            //if(x == 275 && y == 327)
            //{
            //    int a = 0;
            //}

            //查找极大值
            if (pGray >= pMax)
            {
                pMax = pGray;
                nMaxIndex = nIndex;
                nMaxI       = i;
                nMaxJ       = j;
            }
            //查找极小值
            if (pGray <= pMin)
            {
                pMin = pGray;
                nMinIndex = nIndex;
            }

            //统计块内灰度和
            pMean += pGray;
        }
        //更新下一行的起始坐标
        pBlkStart += nWidth;
    }


    pBlkStart -= nBlkHeight * nWidth;
    //查找块内次极值点（除去极大值周边）
    for (i = 0; i < nBlkHeight; i++)
    {
        for (j = 0; j < nBlkWidth; j++)
        {
            //获取块内每个像素点灰度
            nIndex  = pBlkStart + j;
            if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
            {
                pGray = ((UBYTE8*)img.u64VirAddr[0])[nIndex];
            }
            else
            {
                pGray = ((UINT16*)img.u64VirAddr[0])[nIndex];
            }

            int x = nIndex % nWidth;
            int y = nIndex / nWidth;


            //if(x == 275 && y == 327)
            //{
            //    int a = 0;
            //}


            ////跳过极大值区域
      //      if (nIndex > (nMaxIndex - nWidth * g_DST_stPara.nObjCombineDist - nWidth / 2) &&
      //          nIndex < (nMaxIndex + nWidth * g_DST_stPara.nObjCombineDist + nWidth / 2))

            //跳过极大值区域
            //if (nIndex >= (nMaxIndex - nWidth * g_DST_stPara.nObjCombineDist - g_DST_stPara.nObjCombineDist / 2) &&
            //    nIndex <= (nMaxIndex + nWidth * g_DST_stPara.nObjCombineDist + g_DST_stPara.nObjCombineDist / 2))
            // 
            //跳过极大值区域，寻找次极大值
            if( (i - nMaxI ) * (i - nMaxI ) + (j - nMaxJ) * (j - nMaxJ ) <m_DST_stPara.nObjCombineDist * m_DST_stPara.nObjCombineDist )
            {
                continue;
            }


            //查找次极大值
            if (pGray > pMax2)
            {
                pMax2		= pGray;
                nMaxIndex2  = nIndex;
            }

        }
        //更新下一行的其实坐标
        pBlkStart += nWidth;
    }


    //计算块内灰度均值，抛掉极大值
    if (nLen <= 1)
    {
        pMean = pMean;
    }
    else if (nLen == 2)
    {
        pMean /= 2;
    }
    else
    {
        //pMean -= pMax;
        //pMean /= (nLen - 1);
        pMean -= (pMax + pMin);
        pMean /= (nLen - 2);
    }

    //抛掉与块均值灰度差异较小的点
    //if (ABS(pMax - pMean) < pDiffThres)
    //{
    //    pPnt.x = DST_BLK_MAX_PNT_DELETE_FLAG;
    //    pPnt.y = DST_BLK_MAX_PNT_DELETE_FLAG;
    //}
    //else    

    //MSSu, 20160122: 抛掉平坦块
    if ((pMax - pMin) < 2)
    {
        pPnt.x = DST_BLK_MAX_PNT_DELETE_FLAG;
        pPnt.y = DST_BLK_MAX_PNT_DELETE_FLAG;
        return pPnt;
    }

    // 极值点坐标
    pPntMax.x = nMaxIndex % nWidth;
    pPntMax.y = nMaxIndex / nWidth;
    pPntMin.x = nMinIndex % nWidth;
    pPntMin.y = nMinIndex / nWidth;

    // 次极值点坐标
    pPntMax2.x = nMaxIndex2 % nWidth;
    pPntMax2.y = nMaxIndex2 / nWidth;

    if (GLB_OBJ_GRAY_DARK == m_DST_stPara.nDetectGrayType)
    {
        pPnt = pPntMin;
        *pbMaxFlag = DST_BLK_MIN_PNT;
    }
    else if (GLB_OBJ_GRAY_BRIGHT == m_DST_stPara.nDetectGrayType)
    {
        pPnt = pPntMax;
        *pbMaxFlag = DST_BLK_MAX_PNT;
        if(pPntMax.x == pPntMax2.x && pPntMax.y == pPntMax2.y)
        {
            pSecondMax->x = -1;
            pSecondMax->y = -1;
        }
        else
        {
            *pSecondMax = pPntMax2;
        }
    }
    else if (GLB_OBJ_GRAY_ALL == m_DST_stPara.nDetectGrayType)
    {

        //20170405，分别计算极大值点与极小值点的邻域均值//原先做法是直接与分块均值比较
        fPntMaxBkgMean = DST_CalObjBkgMean_UINT16(img, nWidth, nHeight, pPntMax);
        fPntMinBkgMean = DST_CalObjBkgMean_UINT16(img, nWidth, nHeight, pPntMin);

        //20170405，若邻域范围超出图像边界即均值为负，则直接取分块均值
        if (fPntMaxBkgMean < 0 || fPntMinBkgMean < 0)
        {
            fPntMaxBkgMean = (FLOAT32)pMean;
            fPntMinBkgMean = (FLOAT32)pMean;
        }

        //20170810，wsa，抛掉与块均值灰度差异较小的点
        if (ABS(pMax - (UINT16)fPntMaxBkgMean) < pDiffThres && ABS(pMin - (UINT16)fPntMinBkgMean) < pDiffThres)
        {
            pPnt.x = DST_BLK_MAX_PNT_DELETE_FLAG;
            pPnt.y = DST_BLK_MAX_PNT_DELETE_FLAG;
            return pPnt;
        }

        if (ABS(pMax - (UINT16)fPntMaxBkgMean) >= ABS(pMin - (UINT16)fPntMinBkgMean))
        {
            pPnt = pPntMax;
            *pbMaxFlag = DST_BLK_MAX_PNT;
        }
        else
        {
            pPnt = pPntMin;
            *pbMaxFlag = DST_BLK_MIN_PNT;
        }

    }

    return pPnt;
}


void DetectSmallObj::DST_MallocMemory(SINT32 nWidth, SINT32 nHeight, CENTERRECT mmCenterRect)
{
    DST_ReleaseMemory();

    SINT32 DST_BLK_NUM = m_DST_stInput.nBlkNum;

    DST_pBlkMaxPoint = new POINT16S[DST_BLK_NUM * 2];//同时处理次极值点

    DST_pBlkPtBeTargetFlag = new SINT32[DST_BLK_NUM * 2];

    DST_pBlkMaxPntFlag = new BYTE8[DST_BLK_NUM * 2];

}

void DetectSmallObj::DST_ReleaseMemory()
{
    if (DST_pBlkMaxPoint)
    {
        delete[] DST_pBlkMaxPoint;
        DST_pBlkMaxPoint = NULL;
    }

    if (DST_pBlkPtBeTargetFlag)
    {
        delete[] DST_pBlkPtBeTargetFlag;
        DST_pBlkPtBeTargetFlag = NULL;
    }

    if (DST_pBlkMaxPntFlag)
    {
        delete[] DST_pBlkMaxPntFlag;
        DST_pBlkMaxPntFlag = NULL;
    }
}

/**********************************************************
* 函数名称：DST_FindExtremum()
* 功能描述：查找图像中的极值点
* 输入参数：UINT16 *pFrame   --  原始图像
*           SINT32 nWidth       --  图像宽度
*           SINT32 nHeight      --  图像高度
*           SINT32 nSearchAreaT --  检测区域左上角Y坐标
*           SINT32 nSearchAreaL --  检测区域左上角X坐标
*           SINT32 nBlkWidth    --  分块宽度
*           SINT32 nBlkHeight   --  分块高度
*           SINT32 nBlkNumW     --  行方向分块个数
*           SINT32 nBlkNumH     --  列方向分块个数
* 输出参数：POINT16S *pBlkMaxPnt--  指向分块极值点坐标存储空间地址，BYTE8 *pbBlkMaxPntFlag --极值点类型标记数组
* 返 回 值：无
* 调用关系：DST_FindBlkExtremum(), DST_MergeBlkMaxPoint()
* 其它说明：无
**********************************************************/
void DetectSmallObj::DST_FindExtremum(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight,
    POINT16S* pBlkMaxPnt, BYTE8* pbBlkMaxPntFlag, SINT32 nSearchAreaT, SINT32 nSearchAreaL,
    SINT32 nBlkWidth, SINT32 nBlkHeight,
    SINT32 nBlkNumW, SINT32 nBlkNumH)
{
    SINT32  i, j;
    SINT32  pCenterStart, pBlkStart;
    SINT32  nRowBlkLine;
    SINT32  nRowBlkHSkip;
    SINT32  nLine, nIndex;
    SINT32  nBlkCnt;
    BYTE8   bMaxPntFalg = DST_BLK_MAX_PNT;	//20161130，标记极大/极小
    POINT16S pBlkSecondMaxPnt = {0};//次极大值
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    pCenterStart = nSearchAreaT * nWidth + nSearchAreaL;
    nRowBlkLine = pCenterStart;
    nRowBlkHSkip = nBlkHeight * nWidth;
    pBlkStart = nRowBlkLine;
    nLine = 0;
    nIndex = 0;
    nBlkCnt = 0;

    for (i = 0; i < nBlkNumH; i++)  //DSP移植优化：主频432Mhz 2.4ms
    {
        for (j = 0; j < nBlkNumW; j++)
        {
            //计算当前块的坐标
            nIndex = 2 * (nLine + j);

            //查找块内灰度极大值
            pBlkMaxPnt[nIndex] = DST_FindBlkExtremum(img, nWidth, nHeight,
                pBlkStart, nBlkWidth, nBlkHeight, &bMaxPntFalg, &pBlkSecondMaxPnt);

            // 次极值点
            pBlkMaxPnt[nIndex + 1] = pBlkSecondMaxPnt;

            //20161130，标记极大/极小
            pbBlkMaxPntFlag[nIndex] = bMaxPntFalg;

            //更新下一个块的起始坐标
            pBlkStart += nBlkWidth;

            //防止出错
            nBlkCnt++;
            if (nBlkCnt >= m_DST_stInput.nBlkNum)
            {
                break;
            }
        }

        //更新下一行块的行起始坐标
        nRowBlkLine += nRowBlkHSkip;
        pBlkStart = nRowBlkLine;

        //更新下一行块的起始坐标
        nLine += nBlkNumW;

        //防止出错
        if (nBlkCnt >= m_DST_stInput.nBlkNum)
        {
            break;
        }
    }

    //+++++++++++++++++++++++++++++++++++++++++++++++++
    //合并临近的极值点
    //MSSu, 20111115: 若m_DST_nDectectMinPnt==TRUE，则为合并临近的极大或极小值
    DST_MergeBlkMaxPoint(img, nWidth, nHeight, pBlkMaxPnt, nBlkNumH, nBlkNumW,
        m_DST_stPara.nObjCombineDist, pbBlkMaxPntFlag);
}

/**********************************************************
* 函数名称：DST_FindExtremum()
* 功能描述：螺旋查找图像中的极值点
* 输入参数：UINT16 *pFrame   --  原始图像
*           SINT32 nWidth       --  图像宽度
*           SINT32 nHeight      --  图像高度
*           SINT32 nSearchAreaT --  检测区域左上角Y坐标
*           SINT32 nSearchAreaL --  检测区域左上角X坐标
*           SINT32 nBlkWidth    --  分块宽度
*           SINT32 nBlkHeight   --  分块高度
*           SINT32 nBlkNumW     --  行方向分块个数
*           SINT32 nBlkNumH     --  列方向分块个数
* 输出参数：POINT16S *pBlkMaxPnt--  指向分块极值点坐标存储空间地址，BYTE8 *pbBlkMaxPntFlag --极值点类型标记数组
* 返 回 值：无
* 调用关系：DST_FindBlkExtremum(), DST_MergeBlkMaxPoint()
* 其它说明：无
**********************************************************/
void DetectSmallObj::DST_FindExtremumSpiral(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight,
    POINT16S* pBlkMaxPnt, BYTE8* pbBlkMaxPntFlag, SINT32 nSearchAreaT, SINT32 nSearchAreaL,
    SINT32 nBlkWidth, SINT32 nBlkHeight,
    SINT32 nBlkNumW, SINT32 nBlkNumH)
{
    SINT32  i, j;
    SINT32  pCenterStart, pBlkStart;
    SINT32  nRowBlkLine;
    SINT32  nRowBlkHSkip;
    SINT32  nLine, nIndex;
    SINT32  nBlkCnt;
    BYTE8   bMaxPntFalg = DST_BLK_MAX_PNT;	//20161130，标记极大/极小
    POINT16S pBlkSecondMaxPnt = { 0 };//次极大值
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    nRowBlkLine = nSearchAreaT * nWidth + nSearchAreaL;
    nRowBlkHSkip = nBlkHeight * nWidth;
    pBlkStart = nRowBlkLine;
    nLine = 0;
    nIndex = 0;
    nBlkCnt = 0;


    SINT32 r0 = nBlkNumH / 2;
    SINT32 c0 = nBlkNumW / 2;
    SINT32 R = nBlkNumH;
    SINT32 C = nBlkNumW;
    std::vector<std::pair<SINT32, SINT32>> around = { { 0, 1 },{ 1, 0 },{ 0, -1 },{ -1, 0 } };  //顺时针方向
    SINT32 x = r0, y = c0, num = 1, dir = 0;  //{x, y}为当前位置，num为当前查找的数字，dir为当前的方向
    SINT32 Left = c0 - 1, Right = c0 + 1, Upper = r0 - 1, Bottom = r0 + 1;  //四个方向的边界
    while (num <= R * C) 
    {
        if (x >= 0 && x < R && y >= 0 && y < C) 
        {  //{x， y}位置在矩阵中
            //printf("x=%d, y=%d\n", x, y);
            //计算当前块的坐标
            nIndex = 2 * nBlkCnt;

            //查找块内灰度极大值
            POINT16S point = DST_FindBlkExtremum(img, nWidth, nHeight,
                pBlkStart, nBlkWidth, nBlkHeight, &bMaxPntFalg, &pBlkSecondMaxPnt);

            //if (point.x > 0 && point.y > 0)
            {
                pBlkMaxPnt[nIndex] = point;
                // 次极值点
                pBlkMaxPnt[nIndex + 1] = pBlkSecondMaxPnt;

                //20161130，标记极大/极小
                pbBlkMaxPntFlag[nIndex] = bMaxPntFalg;

                //更新下一个块的起始坐标
                pBlkStart = nBlkWidth * y + x * nRowBlkHSkip;

                //防止出错
                nBlkCnt++;
                if (nBlkCnt >= m_DST_stInput.nBlkNum)
                {
                    break;
                }
            }
            num += 1;
        }
        if (dir == 0 && y == Right) 
        {  //向右到右边界
            dir += 1;  //调转方向向下
            Right += 1;  //右边界右移
        }
        else if (dir == 1 && x == Bottom) 
        {  //向下到底边界
            dir += 1;
            Bottom += 1;  //底边界下移
        }
        else if (dir == 2 && y == Left) 
        {  //向左到左边界
            dir += 1;
            Left--;  //左边界左移
        }
        else if (dir == 3 && x == Upper) 
        {  //向上到上边界
            dir = 0;
            Upper--;  //上边界上移
        }
        x += around[dir].first;   //下一个节点
        y += around[dir].second;
    }

    //for (i = 0; i < nBlkNumH; i++)  //DSP移植优化：主频432Mhz 2.4ms
    //{
    //    for (j = 0; j < nBlkNumW; j++)
    //    {
    //        //计算当前块的坐标
    //        nIndex = 2 * (nBlkNumW * i + j);

    //        //查找块内灰度极大值
    //        pBlkMaxPnt[nIndex] = DST_FindBlkExtremum(img, nWidth, nHeight,
    //            pBlkStart, nBlkWidth, nBlkHeight, &bMaxPntFalg, &pBlkSecondMaxPnt);

    //        // 次极值点
    //        pBlkMaxPnt[nIndex + 1] = pBlkSecondMaxPnt;

    //        //20161130，标记极大/极小
    //        pbBlkMaxPntFlag[nIndex] = bMaxPntFalg;

    //        //更新下一个块的起始坐标
    //        pBlkStart = nBlkWidth * j + i * nRowBlkHSkip;

    //        //防止出错
    //        nBlkCnt++;
    //        if (nBlkCnt >= m_DST_stInput.nBlkNum)
    //        {
    //            break;
    //        }
    //    }

    //    ////更新下一行块的起始坐标
    //    //nLine += nBlkNumW;

    //    ////防止出错
    //    //if (nBlkCnt >= m_DST_stInput.nBlkNum)
    //    //{
    //    //    break;
    //    //}
    //}



    //+++++++++++++++++++++++++++++++++++++++++++++++++
    //合并临近的极值点
    //MSSu, 20111115: 若m_DST_nDectectMinPnt==TRUE，则为合并临近的极大或极小值
    DST_MergeBlkMaxPoint(img, nWidth, nHeight, pBlkMaxPnt, nBlkNumH, nBlkNumW,
        m_DST_stPara.nObjCombineDist, pbBlkMaxPntFlag);
}


/**********************************************************
* 函数名称：DST_MergeBlkMaxPoint()
* 功能描述：合并临近的极值点
* 输入参数：UINT16 *pFrame   --  输入图像
*           SINT32 nWidth       --  图像宽度
*           SINT32 nHeight      --  图像高度
*           POINT16S *pBlkPnt   --  分块极大值点坐标数组
*           SINT32 nPntNumH     --  在列方向上的分块数
*           SINT32 nPntNumW     --  在行方向上的分块数
*           SINT32 nDist        --  相邻极值点合并的阈值
* 输出参数：无
* 返 回 值：无
* 调用关系：无
* 其它说明：MSSu, 20150608: 增加亮目标、暗目标、亮+暗目标3种情况处理。
**********************************************************/
void DetectSmallObj::DST_MergeBlkMaxPoint(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight,
    POINT16S* pBlkPnt, SINT32 nPntNumH, SINT32 nPntNumW,
    SINT32 nDist, BYTE8* pbBlkMaxPntFlag)
{
    static SINT32 nX[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
    static SINT32 nY[8] = { -1, -1, -1, 0, 0, 1, 1, 1 };

    SINT32  i, k;
    POINT16S* pPntA, * pPntB;
    UINT16 pPntAValue, pPntBValue;
    SINT32  nDistAB;
    SINT32  nDistThres;
    SINT32  nNearIndex;
    SINT32  nPntNum;
    SINT32  nMeanAB, nCntAB;

    //参数计算
    nDistThres = nDist * nDist;
    nPntNum = nPntNumH * nPntNumW * 2;
    nMeanAB = 0;
    nCntAB = 0;

    for (i = 0; i < nPntNum; i++)
    {
        //获取当前极值点A的坐标
        pPntA = &pBlkPnt[i];

        //若当前极值点A已被删除，则跳过该点，不进行后续处理
        if (DST_BLK_MAX_PNT_DELETE_FLAG == pPntA->x
            && DST_BLK_MAX_PNT_DELETE_FLAG == pPntA->y)
        {
            continue;
        }

        //遍历周围8个极值点
        for (k = 0; k < 8; k++)
        {
            for (int s = 0; s < 2; s++)
            {
                //计算临近点B下标
                nNearIndex = i + 2 *(nY[k] * nPntNumW  + nX[k]) + s;

                //防止临近点越界
                if ((nNearIndex < 0) || (nNearIndex >= nPntNum)
                    || (nNearIndex == i)) //MSSu, 20160409: 宽方向仅1个分块时，邻域点会计算回A点本身，导致A点被删除
                {
                    continue;
                }

                //// A点可能会在合并中被删掉，需要再判断一次，一个存在很久的bug？          by wcw04046 @ 2020/02/20
                if (DST_BLK_MAX_PNT_DELETE_FLAG == pPntA->x
                    && DST_BLK_MAX_PNT_DELETE_FLAG == pPntA->y)
                {
                    continue;
                }


                //获取临近点B的坐标
                pPntB = &pBlkPnt[nNearIndex];

                //若临近点B已被删除，则跳过该点，不进行后续处理
                if (DST_BLK_MAX_PNT_DELETE_FLAG == pPntB->x
                    && DST_BLK_MAX_PNT_DELETE_FLAG == pPntB->y)
                {
                    continue;
                }

                //计算A、B点距离
                nDistAB = (pPntA->x - pPntB->x) * (pPntA->x - pPntB->x);
                nDistAB += (pPntA->y - pPntB->y) * (pPntA->y - pPntB->y);

                //若A、B点距离小于阈值，则合并
                //MSSu, 20111115: 若m_DST_nDectectMinPnt==TRUE，则两个相邻的极值点中，优先选择极大值点
                if (nDistAB < nDistThres && nDistAB != 0)
                {
                    //获取A、B点的亮度
                    //pPntAValue = pFrame[pPntA->y * nWidth + pPntA->x];
                    //pPntBValue = pFrame[pPntB->y * nWidth + pPntB->x];
                    if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
                    {
                        pPntAValue = ((UBYTE8*)img.u64VirAddr[0])[pPntA->y * nWidth + pPntA->x];
                        pPntBValue = ((UBYTE8*)img.u64VirAddr[0])[pPntB->y * nWidth + pPntB->x];
                    }
                    else
                    {
                        pPntAValue = ((UINT16*)img.u64VirAddr[0])[pPntA->y * nWidth + pPntA->x];
                        pPntBValue = ((UINT16*)img.u64VirAddr[0])[pPntB->y * nWidth + pPntB->x];
                    }

                    //检测亮目标
                    if (GLB_OBJ_GRAY_BRIGHT == m_DST_stPara.nDetectGrayType)
                    {
                        if (pPntAValue > pPntBValue)
                        {
                            pPntB->x = DST_BLK_MAX_PNT_DELETE_FLAG;
                            pPntB->y = DST_BLK_MAX_PNT_DELETE_FLAG;
                        }
                        else
                        {
                            pPntA->x = DST_BLK_MAX_PNT_DELETE_FLAG;
                            pPntA->y = DST_BLK_MAX_PNT_DELETE_FLAG;
                        }
                    }
                    //检测暗目标
                    else if (GLB_OBJ_GRAY_DARK == m_DST_stPara.nDetectGrayType)
                    {
                        if (pPntAValue < pPntBValue)
                        {
                            pPntB->x = DST_BLK_MAX_PNT_DELETE_FLAG;
                            pPntB->y = DST_BLK_MAX_PNT_DELETE_FLAG;
                        }
                        else
                        {
                            pPntA->x = DST_BLK_MAX_PNT_DELETE_FLAG;
                            pPntA->y = DST_BLK_MAX_PNT_DELETE_FLAG;
                        }
                    }
                    //亮暗都检测
                    else if (GLB_OBJ_GRAY_ALL == m_DST_stPara.nDetectGrayType)
                    {
                        //20161130，按大大/大小/小小三种情况处理
                        if (DST_BLK_MAX_PNT == pbBlkMaxPntFlag[i] && DST_BLK_MAX_PNT == pbBlkMaxPntFlag[nNearIndex])
                        {
                            if (pPntAValue >= pPntBValue)
                            {
                                pPntB->x = DST_BLK_MAX_PNT_DELETE_FLAG;
                                pPntB->y = DST_BLK_MAX_PNT_DELETE_FLAG;
                            }
                            else
                            {
                                pPntA->x = DST_BLK_MAX_PNT_DELETE_FLAG;
                                pPntA->y = DST_BLK_MAX_PNT_DELETE_FLAG;
                            }
                        }
                        else if (DST_BLK_MIN_PNT == pbBlkMaxPntFlag[i] && DST_BLK_MIN_PNT == pbBlkMaxPntFlag[nNearIndex])
                        {
                            if (pPntAValue <= pPntBValue)
                            {
                                pPntB->x = DST_BLK_MAX_PNT_DELETE_FLAG;
                                pPntB->y = DST_BLK_MAX_PNT_DELETE_FLAG;
                            }
                            else
                            {
                                pPntA->x = DST_BLK_MAX_PNT_DELETE_FLAG;
                                pPntA->y = DST_BLK_MAX_PNT_DELETE_FLAG;
                            }
                        }
                        else
                        {
                            //20170330，极大值点和极小值点不做合并处理
                        }

                    }
                }
            }
        }
    }
}

/**********************************************************
* 函数名称：DST_DetectExtremumTarget()
* 功能描述：判断当前帧极值点是否为目标
* 输入参数：UINT16 *pFrame           --  原始图像
*           SINT32 nWidth               --  图像宽度
*           SINT32 nHeight              --  图像高度
*           SINT32 nTargetNumMax        --  单帧检测目标的最大个数
*           POINT16S *pBlkMaxPnt        --  当前帧极值点数组
*           SINT32 nBlkNumW             --  行方向分块个数
*           SINT32 nBlkNumH             --  列方向分块个数
*           SINT32 *pBlkPtBeTargetFlag  --  极大值点是否为目标的标记
* 输出参数：TARGET_OBJECT *ptTargetArray--  当前帧目标检测结果数组
* 返 回 值：SINT32 nTargetCnt           --  当前帧检测到的目标个数
* 调用关系：
* 其它说明：无
**********************************************************/
SINT32 DetectSmallObj::DST_DetectFrameTarget(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight,
    TARGET_OBJECT* ptTargetArray, SINT32 nTargetNumMax,
    POINT16S* pBlkMaxPnt, SINT32 nBlkNumW, SINT32 nBlkNumH,
    SINT32* pBlkPtBeTargetFlag)
{
    SINT32  i;
    SINT32  nBlkNumCnt;
    SINT32  nTargetCnt;
    BBOOL   bFindTarget;
    POINT16S pPnt;
    TARGET_OBJECT tTarget;

    //初始化
    nTargetCnt = 0;

    //参数计算
    nBlkNumCnt = MIN(nBlkNumW * nBlkNumH, m_DST_stInput.nBlkNum);

    //判断极值点是否为目标
    for (i = 0; i < nBlkNumCnt * 2; i++)
    {
        //获取第i个极值点
        pPnt = pBlkMaxPnt[i];

        //跳过被删除的极值点
        if ((DST_BLK_MAX_PNT_DELETE_FLAG == pPnt.x) && (DST_BLK_MAX_PNT_DELETE_FLAG == pPnt.y))
        {
            continue;
        }


        //查看此极值点，前面（上面和左边）4个极值点是否已被判断为目标，
        //若当前点落在该目标的上下左右边界之内，或者与该目标距离小于阈值，则将当前点删除不处理
        //UINT16 pxPntGray = pFrame[pPnt.y * nWidth + pPnt.x];//from S332 
        UINT16 pxPntGray = 0;//from S332 
        if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
        {
            pxPntGray = ((UBYTE8*)img.u64VirAddr[0])[pPnt.y * nWidth + pPnt.x];
        }
        else
        {
            pxPntGray = ((UINT16*)img.u64VirAddr[0])[pPnt.y * nWidth + pPnt.x];
        }
        if (DST_JudgeIfBlkPntBelongToTarget(i, nBlkNumH, nBlkNumW, pBlkMaxPnt,
            pBlkPtBeTargetFlag, ptTargetArray, m_DST_stPara.nObjCombineDist, pxPntGray))
        {
            continue;
        }

        //初始化
        memset(&tTarget, 0, sizeof(TARGET_OBJECT));
        bFindTarget = false;


        //以极值点为中心查找目标
        bFindTarget = DST_BlkMaxTargetDetect(img, nWidth, nHeight, pPnt,
            m_DST_stPara.pnFilter, m_DST_stPara.nFilterBGW, m_DST_stPara.nFilterTGW,
            &tTarget, m_DST_stPara.fgdk);

        //若该极值点为目标，则加入当前帧目标数组
        if (bFindTarget)
        {
            //标记为目标，加入当前帧目标数组
            tTarget.bObject = true;
            //			tTarget.unFrmID = m_GLB_stInput.stParaLn.unFrmId;
                        // 适应目标识别算法的加入，传统检测无法获取目标类型，此处约定目标类别ID置为DT_TARGET_CLS_ID，置信度为1
            tTarget.unClsType = DT_TARGET_CLS_ID;
            tTarget.fDetConf = 1.0;
            tTarget.nObjTypeSrc = ObjSrc::Arith_DST;

            ptTargetArray[nTargetCnt] = tTarget;

            //标记该极值点处是目标
            //Flag大于0，表明该点是目标，且其(Flag-1)表示该目标的编号
            pBlkPtBeTargetFlag[i] = nTargetCnt + 1;

            //更新当帧目标个数统计
            nTargetCnt++;

            //若目标个数超过上限，则跳出查找
            if (nTargetCnt >= nTargetNumMax)
                break;
        }
    }

    return nTargetCnt;
}

#if 0
/**********************************************************
* 函数名称：DST_BlkMaxTargetDetect()
* 功能描述：判断极大值区域是否为目标
* 输入参数：UINT16 *pFrame       --  原始图像
*           SINT32 nWidth           --  图像宽度
*           SINT32 nHeight          --  图像高度
*           POINT16S pPnt           --  极值点坐标
*           SINT32 *pnFilter        --  目标背景模板
*           SINT32 nFilterBGW       --  目标背景模板 - 背景宽度
*           SINT32 nFilterTGW       --  目标背景模板 - 目标宽度
*           FLOAT32 fgdk            --  目标SNR阈值
* 输出参数：TARGET_OBJECT *tTarget  --  当前目标结构体
* 返 回 值：1-该极值点是目标，0-该极值点不是目标。
* 调用关系：无
* 其它说明：无
**********************************************************/
BBOOL DetectSmallObj::DST_BlkMaxTargetDetect1(UINT16* pFrame, SINT32 nWidth, SINT32 nHeight, POINT16S pPnt,
    SINT32* pnFilter, SINT32 nFilterBGW, SINT32 nFilterTGW,
    TARGET_OBJECT* ptTarget, FLOAT32 fgdk)
{
    SINT32* pnBlkTargetFlag = (SINT32*)DST_pnBlkTargetFlag;
    SINT32  i, j;
    BBOOL   bIsTarget;              //标记该极值点是否为目标
    SINT32  nBGRadius, nTGRadius;   //背景模板半径、目标模板半径
    MINMAXRECT mmTGRect, mmBGRect;  //目标、背景窗口边界
    SINT32  nBGIndex, nBGFlter;     //背景模板下标、背景模板系数
    SINT32  nImgIndex;              //背景点/邻域点对应的原始图像坐标
    SINT32  nBGValue, nBGCnt;       //背景点灰度、背景点计数
    double  dBGMean, dBGStd;        //背景均值、方差
    double  dObjStd, dObjMean;		//目标均值、方差
    SINT32  nCenterValue;           //中心点pPnt的灰度
    SINT32  nPntValue;              //目标模板内像素的灰度值
    FLOAT32 fBGStdOutput;           //背景方差 -- 用于显示，没有经过下限限制

    BBOOL   bTargetPixel;           //标记某像素点是否属于目标。用于统计目标大小。
    FLOAT32 fgdkCoeff;              //gdk下降系数。用于统计目标大小。

    SINT32  nObjWH_LineW;           //目标宽高比统计 - 每行宽度
    SINT32  nObjWH_LineWMax;        //目标宽高比统计 - 行宽度的最大值

    FLOAT32 fPntgdk;                //各点的gdk系数
    SINT32  nTGValue;               //目标点灰度
    SINT32  nCenterValueSumX;       //目标点灰度-X坐标乘积累加、目标点灰度-Y坐标乘积累加
    SINT32  nCenterValueSumY;       //目标点灰度-X坐标乘积累加、目标点灰度-Y坐标乘积累加

    SINT32  nValueDiff;             //背景点与中心点的灰度差值
    SINT32  nValueDiffMin;          //背景点与中心点的灰度差的最小值
    FLOAT32 fWHRatio;               //目标宽高比
    FLOAT32 fRectRatio;             //目标矩形度
    SINT32  nObjCenX, nObjCenY;     //目标形心X、Y坐标

    FLOAT32 fKernalBGVarMin2;       //背景方差下限阈值（可调参数-标准差下限的平方）
    FLOAT32 fKernalBGVarMax2;       //背景方差上限阈值（可调参数-标准差上限的平方）

    SINT32  nBGCntArray[4] = { 0 };	//20180115，记录上下左右邻域背景点个数
    DOUBLE64  dBGMeanArray[4] = { 0.0f };	//20180115，记录上下左右邻域背景均值
    DOUBLE64  dBGStdArray[4] = { 0.0f };	//20180115，记录上下左右邻域背景标准差
    SINT32	nBGOuterRadius = 0;		//20180115，回字形的外半径
    SINT32	nMaxStdIndex = 0;		//20180115，std最大的背景块下标
    DOUBLE64  bBGStdMax = -1.0f;	//20180115，方差最大的块

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //初始化
    bIsTarget = false;
    nValueDiffMin = (SINT32)1e6;
    memset(ptTarget, 0, sizeof(TARGET_OBJECT));

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //参数设置
    fgdkCoeff = 0.7f;
    fKernalBGVarMin2 = m_DST_stPara.fKernalBGStdMin * m_DST_stPara.fKernalBGStdMin;
    fKernalBGVarMax2 = m_DST_stPara.fKernalBGStdMax * m_DST_stPara.fKernalBGStdMax;
    nBGRadius = (SINT32)(nFilterBGW >> 1);
    nTGRadius = (SINT32)(nFilterTGW >> 1);
    nBGOuterRadius = nBGRadius - nTGRadius;	//20180115，回字形的外半径

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //获取中心点灰度值
    nCenterValue = pFrame[pPnt.y * nWidth + pPnt.x];

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //统计背景均值、方差
    //计算背景窗口边界
    mmBGRect.minX = pPnt.x - nBGRadius;
    mmBGRect.maxX = pPnt.x + nBGRadius;
    mmBGRect.minY = pPnt.y - nBGRadius;
    mmBGRect.maxY = pPnt.y + nBGRadius;

    //防止越界
    if (mmBGRect.minX<0 || mmBGRect.maxX>nWidth - 1 || mmBGRect.minY<0 || mmBGRect.maxY>nHeight - 1)
    {
        return false;
    }

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //统计背景均值、方差
    nBGCnt = 0;
    dBGMean = 0;
    dBGStd = 0;
    dObjStd = 0;
    dObjMean = 0;
    SINT32  nBGLine = 0;
    SINT32  nImgLine = mmBGRect.minY * nWidth + mmBGRect.minX;

    //for (i = 0; i < nFilterBGW; i++)
    //{
    //	for (j = 0; j < nFilterBGW; j++)
    //	{
    //		nBGIndex = nBGLine + j;
    //		nImgIndex= nImgLine + j;
    //		nBGFlter = pnFilter[nBGIndex];
    //		nBGValue = pFrame[nImgIndex];

    //		if (1 == nBGFlter)
    //		{
    //			//背景灰度及灰度平方累加
    //			nBGCnt++;
    //			dBGMean += (double)nBGValue;
    //			dBGStd  += (double)nBGValue * nBGValue;

    //			//查找背景中与中心点灰度差异最小的点的灰度
    //			nValueDiff = ABS(nBGValue - nCenterValue);
    //			if (nValueDiff < nValueDiffMin)
    //			{
    //				nValueDiffMin = nValueDiff;
    //			}
    //		}
    //	}

    //	//更新行起始坐标
    //	nBGLine += nFilterBGW;
    //	nImgLine += nWidth;
    //}

    for (i = 0; i < nFilterBGW; i++)
    {
        for (j = 0; j < nFilterBGW; j++)
        {
            nBGIndex = nBGLine + j;
            nImgIndex = nImgLine + j;
            nBGFlter = pnFilter[nBGIndex];
            nBGValue = pFrame[nImgIndex];

            if (1 == nBGFlter)
            {
                //背景灰度及灰度平方累加
                //20180115，【屏蔽】采用取4邻域方差最小值的方式，防止背景混入目标点
                //按上下左右顺序存邻域背景参数
                if (j < nBGOuterRadius)
                {
                    nBGCntArray[0]++;
                    dBGMeanArray[0] += (double)nBGValue;
                    dBGStdArray[0] += (double)nBGValue * nBGValue;
                }
                else if (j >= nFilterTGW + nBGOuterRadius)
                {
                    nBGCntArray[1]++;
                    dBGMeanArray[1] += (double)nBGValue;
                    dBGStdArray[1] += (double)nBGValue * nBGValue;
                }
                else
                {
                    //左邻域
                    if (i < nBGOuterRadius)
                    {
                        nBGCntArray[2]++;
                        dBGMeanArray[2] += (double)nBGValue;
                        dBGStdArray[2] += (double)nBGValue * nBGValue;
                    }
                    else
                    {
                        nBGCntArray[3]++;
                        dBGMeanArray[3] += (double)nBGValue;
                        dBGStdArray[3] += (double)nBGValue * nBGValue;
                    }
                }

                //查找背景中与中心点灰度差异最小的点的灰度
                nValueDiff = ABS(nBGValue - nCenterValue);
                if (nValueDiff < nValueDiffMin)
                {
                    nValueDiffMin = nValueDiff;
                }
            }
        }

        //更新行起始坐标
        nBGLine += nFilterBGW;
        nImgLine += nWidth;
    }

    //20180115，【屏蔽】采用取4邻域方差最小值的方式，防止背景混入目标点
    //计算4邻域的均值与方差
    for (i = 0; i < 4; i++)
    {
        nBGCnt += nBGCntArray[i];
        dBGMean += dBGMeanArray[i];
        dBGStd += dBGStdArray[i];

        dBGMeanArray[i] /= nBGCntArray[i];
        dBGStdArray[i] /= nBGCntArray[i];
        dBGStdArray[i] -= dBGMeanArray[i] * dBGMeanArray[i];

        //找到方差最大的块
        if (dBGStdArray[i] > bBGStdMax)
        {
            bBGStdMax = dBGStdArray[i];
            nMaxStdIndex = i;
        }
    }

    //抛掉方差最大的块
    nBGCnt -= nBGCntArray[nMaxStdIndex];
    dBGMean -= (dBGMeanArray[nMaxStdIndex] * nBGCntArray[nMaxStdIndex]);
    dBGStd -= (nBGCntArray[nMaxStdIndex] * (dBGStdArray[nMaxStdIndex] + dBGMeanArray[nMaxStdIndex] * dBGMeanArray[nMaxStdIndex]));

    dBGMean /= nBGCnt;
    dBGStd /= nBGCnt;
    dBGStd -= dBGMean * dBGMean;

    //保存计算的背景均值及方差
    fBGStdOutput = (FLOAT32)dBGStd;

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //抛掉方差过大的块
    if (m_DST_stPara.bUseDeFA_VarMax    //去虚警策略“邻域方差上限限制”的开关
        && dBGStd > fKernalBGVarMax2)   //判断邻域方差是否大于上限限制。
        return false;

    //设置背景方差下限
    if (m_DST_stPara.bUseDeFA_VarMin                //去虚警策略“邻域方差下限限制”的开关
        && dBGStd < m_DST_stPara.fKernalBGStdMin)   //判断邻域方差是否小于下限限制。
    {
        dBGStd = (double)fKernalBGVarMin2;
    }

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //gdk不做自适应调节，直接赋给PC机传入的可调参数m_DST_stPara.fgdk
    fPntgdk = fgdk;

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //目标检测初始化
    //计算目标核边界
    mmTGRect.minX = pPnt.x - nTGRadius;
    mmTGRect.maxX = pPnt.x + nTGRadius;
    mmTGRect.minY = pPnt.y - nTGRadius;
    mmTGRect.maxY = pPnt.y + nTGRadius;

    //初始化
    ptTarget->mrnRect.minY = mmTGRect.maxY;
    ptTarget->mrnRect.maxY = mmTGRect.minY;
    ptTarget->mrnRect.minX = mmTGRect.maxX;
    ptTarget->mrnRect.maxX = mmTGRect.minX;
    nCenterValueSumX = 0;
    nCenterValueSumY = 0;
    nTGValue = 0;

    //记录目标的类型
    ptTarget->nObjTypeGray = (nCenterValue > (SINT32)dBGMean) ? GLB_OBJ_GRAY_BRIGHT : GLB_OBJ_GRAY_DARK;

    //MSSu, 20120304：根据系统所要检测的目标类型进行区分
    if (GLB_OBJ_GRAY_DARK == m_DST_stPara.nDetectGrayType) //只检测暗目标
    {
        //MSSu, 20120229: 剔除亮目标。根据夜晚试验气球为暗目标的特性，做出目标类型的限制。
        if (GLB_OBJ_GRAY_BRIGHT == ptTarget->nObjTypeGray)
            return FALSE;
    }
    else if (GLB_OBJ_GRAY_BRIGHT == m_DST_stPara.nDetectGrayType) //只检测亮目标
    {
        //跳过暗目标
        if (GLB_OBJ_GRAY_DARK == ptTarget->nObjTypeGray)
            return FALSE;
    }
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //提前计算参数，简化计算
    double fPntgdkByStd = fPntgdk * fPntgdk * dBGStd;

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //目标检测：基于目标信噪比的检测方法
    //首先判断极值点是否为目标
    //MSSu, 20111115: 若m_DST_nDectectMinPnt==TRUE，则为判断极大值点或极小值点是否为目标
    //若极值点不满足SNR条件，则判断该点是否满足灰度阈值判断的条件
    if ((nCenterValue - dBGMean) * (nCenterValue - dBGMean) <= fPntgdkByStd)
    {
        //标记该点不是目标，直接返回
        return false;
    }
    //若极值点是目标，则统计目标的大小
    else
    {
        //标记该点为目标
        bIsTarget = true;

        //去虚警：抛掉方差过大的块
        if (m_DST_stPara.bUseDeFA_VarMax
            && dBGStd > m_DST_stPara.fKernalBGStdMax)
        {
            bIsTarget = false;
        }

        //去虚警：抛掉极值点与背景最小灰度差小于阈值的块
        if (m_DST_stPara.bUseDeFA_BTGrayMin
            && nValueDiffMin < m_DST_stPara.nBTGrayMinThres)
        {
            bIsTarget = false;
        }

        //若该点不是目标，则跳过剩余计算
        if (!bIsTarget)
        {
            return false;
        }

        //降低gdk阈值统计目标大小
        fPntgdk *= fgdkCoeff;
        fPntgdk = MAX(fPntgdk, 4.0f);

        //提前计算参数，简化计算
        double fPntgdkByStdNew = fPntgdk * fPntgdk * dBGStd;

        //搜索目标边界
        nObjWH_LineWMax = 0;
        SINT32 nLine = (pPnt.y - nTGRadius) * nWidth + pPnt.x - nTGRadius;
        //SINT32 nIndex       = 0;
        SINT32 nFlagLine = 0;
        SINT32 nFlagIndex = 0;
        for (i = 0; i < nFilterTGW; i++)
        {
            //初始化每行宽度
            nObjWH_LineW = 0;

            for (j = 0; j < nFilterTGW; j++)
            {
                //获取目标区域各点的图像坐标
                nImgIndex = nLine + j;

                //获取目标区域各点灰度值
                nPntValue = pFrame[nImgIndex];

                //提前计算参数，简化计算
                double dValueDiff = nPntValue - dBGMean;
                double dValueDiffSquare = dValueDiff * dValueDiff;

                //判断该点是否属于目标点（采用SNR判断方法）
                bTargetPixel = false;
                if ((i == j && i == nTGRadius)
                    || (GLB_OBJ_GRAY_BRIGHT == m_DST_stPara.nDetectGrayType && nPntValue > dBGMean && dValueDiffSquare > fPntgdkByStdNew)
                    || (GLB_OBJ_GRAY_DARK == m_DST_stPara.nDetectGrayType && nPntValue < dBGMean && dValueDiffSquare > fPntgdkByStdNew)
                    || (GLB_OBJ_GRAY_ALL == m_DST_stPara.nDetectGrayType && dValueDiffSquare > fPntgdkByStdNew))
                {
                    bTargetPixel = true;
                }

                //查找目标边界，并统计大小
                if (bTargetPixel)
                {
                    dObjMean += nPntValue;
                    dObjStd += nPntValue * nPntValue;

                    //统计行宽
                    nObjWH_LineW++;

                    //查找目标边界
                    SINT32 nImgX = j + mmTGRect.minX;
                    SINT32 nImgY = i + mmTGRect.minY;
                    ptTarget->mrnRect.minY = MIN(ptTarget->mrnRect.minY, nImgY);
                    ptTarget->mrnRect.maxY = MAX(ptTarget->mrnRect.maxY, nImgY);
                    ptTarget->mrnRect.minX = MIN(ptTarget->mrnRect.minX, nImgX);
                    ptTarget->mrnRect.maxX = MAX(ptTarget->mrnRect.maxX, nImgX);

                    //统计目标质心. MSSu, 20110524
                    nCenterValueSumX += nImgX * nPntValue;
                    nCenterValueSumY += nImgY * nPntValue;
                    nTGValue += nPntValue;

                    //统计目标大小
                    ptTarget->unObjPxlsCnt++;

                    //标记目标区域内目标点
                    nFlagIndex = nFlagLine + j;
                    pnBlkTargetFlag[nFlagIndex] = 1;

                    // 目标极值
                    ptTarget->pxObjMaxGray = MAX(ptTarget->pxObjMaxGray, nPntValue);

                }
            }

            //查找最大行宽
            nObjWH_LineWMax = MAX(nObjWH_LineWMax, nObjWH_LineW);

            //更新下一行起始坐标
            nLine += nWidth;
            nFlagLine += nFilterTGW;
        }//end of for (j = 0; j < nKernelSize_TG; j++)...
    }//end of else...

    if (ptTarget->unObjPxlsCnt > 0)
    {
        dObjMean /= ptTarget->unObjPxlsCnt;
        dObjStd /= ptTarget->unObjPxlsCnt;
        dObjStd -= dObjMean * dObjMean;
    }
    else
    {
        dObjStd = 0.0;
    }

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //统计目标信息
    if (bIsTarget)
    {
        //计算统计目标质心
        if (0 == nTGValue)  //防止出错，例如当阈值设置不恰当时，连目标的极大值点都未统计到目标的大小中
        {
            ptTarget->pfCenPos.x = (FLOAT32)pPnt.x;
            ptTarget->pfCenPos.y = (FLOAT32)pPnt.y;
        }
        else
        {
            ptTarget->pfCenPos.x = (FLOAT32)nCenterValueSumX / nTGValue;
            ptTarget->pfCenPos.y = (FLOAT32)nCenterValueSumY / nTGValue;
        }

        //统计目标的灰度(极大值灰度)
        ptTarget->pxObjGray = nCenterValue;

        //记录目标极大值点坐标
        ptTarget->pnMaxPos = pPnt;

        //计算目标宽、高、面积
        ptTarget->snSize.h = ptTarget->mrnRect.maxY - ptTarget->mrnRect.minY + 1;
        ptTarget->snSize.w = ptTarget->mrnRect.maxX - ptTarget->mrnRect.minX + 1;
        ptTarget->snSize.s = ptTarget->snSize.h * ptTarget->snSize.w;

        //记录背景均值、背景方差、目标背景信噪比
        ptTarget->fBGMean = (FLOAT32)dBGMean;
        ptTarget->fBGStd = (FLOAT32)sqrt(fBGStdOutput);
        ptTarget->fSNR = (FLOAT32)(nCenterValue - dBGMean) / (ptTarget->fBGStd + 0.01f);

        //计算目标的伺服方位角、俯仰角
// 		ptTarget->afAngle.fAz   = SERVO_CalcObjAzimuth (pPnt.x, nWidth,  m_SERVO_stInput.fAzimuth,  m_SERVO_stInput.fResolAz);
// 		ptTarget->afAngle.fPt   = SERVO_CalcObjPitching(pPnt.y, nHeight, m_SERVO_stInput.fPitching, m_SERVO_stInput.fResolPt);

        //标记目标类型
        ptTarget->nObjTypeSize = GLB_OBJ_SIZE_SMALL;

        //标记为目标
        bIsTarget = true;

        //去虚警：抛掉大小不符合要求的目标
        if (m_DST_stPara.bUseDeFA_Size  //去虚警策略“目标大小限制”的开关
            && (ptTarget->unObjPxlsCnt < (UINT32)m_DST_stPara.nObjSizeMin
                || ptTarget->unObjPxlsCnt >(UINT32)m_DST_stPara.nObjSizeMax))
        {
            bIsTarget = false;
        }

        //去虚警：抛掉长宽比不符合要求的目标
        //目标宽高比计算方式2 - 最大行宽度/总高度
        if (DST_OBJ_WHRATIO_LINEWH == m_DST_stPara.nObjWHRatioMethod)
        {
            fWHRatio = (FLOAT32)nObjWH_LineWMax / ptTarget->snSize.h;
        }
        //目标宽高比计算方式1 - 总宽度/总高度
        else
        {
            fWHRatio = (FLOAT32)(ptTarget->snSize.w) / ptTarget->snSize.h;
        }

        if (m_DST_stPara.bUseDeFA_WHRatio  //去虚警策略“目标宽高比限制”的开关
            && ((fWHRatio < 1 && fWHRatio < m_DST_stPara.fObjWHRatioMin)
                || (fWHRatio > 1 && fWHRatio > m_DST_stPara.fObjWHRatioMax)))
        {
            bIsTarget = false;
        }

        //去虚警：抛掉矩形度不符合要求的目标
        fRectRatio = (FLOAT32)ptTarget->unObjPxlsCnt / ptTarget->snSize.s;
        if (m_DST_stPara.bUseDeFA_RectRatio  //去虚警策略“目标矩形度限制”的开关
            && fRectRatio < m_DST_stPara.fObjRectRatioMin)
        {
            bIsTarget = false;
        }

        //去虚警：抛掉形心不是目标标记点的目标（形状不规则）
        //nObjCenX = (SINT32)((tTarget->mrnRect.minX + tTarget->mrnRect.maxX) / 2.0 + 0.5);
        //nObjCenY = (SINT32)((tTarget->mrnRect.minY + tTarget->mrnRect.maxY) / 2.0 + 0.5);
        nObjCenX = (ptTarget->mrnRect.minX + ptTarget->mrnRect.maxX) >> 1;
        nObjCenY = (ptTarget->mrnRect.minY + ptTarget->mrnRect.maxY) >> 1;
        if (m_DST_stPara.bUseDeFA_CenFlag  //去虚警策略“形心为目标点”的开关
            && !pnBlkTargetFlag[(nObjCenY - mmTGRect.minY) * nFilterTGW + nObjCenX - mmTGRect.minX])
        {
            if ((nObjCenX - ptTarget->pfCenPos.x) * (nObjCenX - ptTarget->pfCenPos.x) +
                (nObjCenY - ptTarget->pfCenPos.y) * (nObjCenY - ptTarget->pfCenPos.y) > 2.0f)
            {
                bIsTarget = false;
            }
        }
    }

    return bIsTarget;
}
#endif

/**********************************************************
* 函数名称：DST_JudgeIfBlkPntBelongToTarget()
* 功能描述：判断当前极值点是否落在前面已检测到的目标上，或与前面的目标邻近
* 输入参数：SINT32 nPntIndex            --  极值点在数组中的序号
*           SINT32 nBlkNumW             --  行方向分块个数
*           SINT32 nBlkNumH             --  列方向分块个数
*           POINT16S *pBlkMaxPnt        --  当前帧极值点数组
*           SINT32 *pBlkPtBeTargetFlag  --  极大值点是否为目标的标记
*           TARGET_OBJECT *ptTargetArray--  当前帧目标检测结果数组
*           SINT32 nDistThres           --  极值点合并的距离阈值
* 输出参数：无
* 返 回 值：1-当前极值点被合并，0-当前极值点未被合并
* 调用关系：无
* 其它说明：无
**********************************************************/
BBOOL DetectSmallObj::DST_JudgeIfBlkPntBelongToTarget(SINT32 nPntIndex, SINT32 nBlkNumH, SINT32 nBlkNumW,
    POINT16S* pBlkMaxPnt, SINT32* pBlkPtBeTargetFlag,
    TARGET_OBJECT* ptTargetArray, SINT32 nDistThres,
    UINT16 pxPntGray)
{
    SINT32  nX[4] = { -1,  0,  1, -1 };
    SINT32  nY[4] = { -1, -1, -1,  0 };

    SINT32  k = 0;
    POINT16S* pPntA = NULL;
    POINT16S* pPntB = NULL;
    SINT32  nDistAB = 0;
    SINT32  nNearIndex = 0;
    SINT32  nDistThres2 = 0;
    TARGET_OBJECT* ptTarget = NULL;

    //计算参数
    nDistThres2 = nDistThres * nDistThres;

    //获取当前极值点A的坐标
    pPntA = &pBlkMaxPnt[nPntIndex];

    for (k = 0; k <= 3; k++)
    {
        //计算临近点B下标
        nNearIndex = nPntIndex + nY[k] * nBlkNumW + nX[k];

        //防止临近点越界
        if (nNearIndex < 0 || nNearIndex >= nBlkNumH * nBlkNumW)
        {
            continue;
        }

        //若该邻域极值点不是目标，则跳过
        if (pBlkPtBeTargetFlag[nNearIndex] <= 0)
        {
            continue;
        }

        //ptTarget指向该目标信息
        ptTarget = &ptTargetArray[pBlkPtBeTargetFlag[nNearIndex] - 1];

        //若当前点位于邻域极值目标上，删除该点，返回真
        if (pPntA->x >= ptTarget->mrnRect.minX && pPntA->x <= ptTarget->mrnRect.maxX
            && pPntA->y >= ptTarget->mrnRect.minY && pPntA->y <= ptTarget->mrnRect.maxY)
        {
            if (GLB_OBJ_GRAY_BRIGHT == ptTarget->nObjTypeGray)
            {
                if (ptTarget->pxObjGray > pxPntGray)
                {
                    pPntA->x = DST_BLK_MAX_PNT_DELETE_FLAG;
                    pPntA->y = DST_BLK_MAX_PNT_DELETE_FLAG;
                    return true;
                }
            }
            else
            {
                if (ptTarget->pxObjGray < pxPntGray)
                {
                    pPntA->x = DST_BLK_MAX_PNT_DELETE_FLAG;
                    pPntA->y = DST_BLK_MAX_PNT_DELETE_FLAG;
                    return true;
                }
            }
        }

        //获取邻域极值目标的坐标
        pPntB = &ptTarget->pnMaxPos;

        //计算该点与目标的距离
        nDistAB = (pPntA->x - pPntB->x) * (pPntA->x - pPntB->x);
        nDistAB += (pPntA->y - pPntB->y) * (pPntA->y - pPntB->y);

        //若当前点不在邻域极值目标上，但两者距离小于阈值，也删除该点，返回真
        if (nDistAB < nDistThres2)
        {
            pPntA->x = DST_BLK_MAX_PNT_DELETE_FLAG;
            pPntA->y = DST_BLK_MAX_PNT_DELETE_FLAG;
            return true;
        }
    }

    return false;
}

/**********************************************************
* 函数名称：DST_CalObjBkgMean_UINT16()
* 功能描述：计算目标背景均值
* 输入参数：UINT16 *pFrame   --  原始图像
*           SINT32 nWidth       --  图像宽度
*           SINT32 nHeight      --  图像高度
*           POINT16S pPnt       --  目标坐标
* 输出参数：FLOAT32 dBGMean   --  目标背景均值信息
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
FLOAT32 DetectSmallObj::DST_CalObjBkgMean_UINT16(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight,
    POINT16S pPnt)
{
    SINT32  i, j;
    SINT32  nFilterBGW;                         //极大值滤波窗口 - 背景核区域大小，目标核区域大小
    SINT32  nBGRadius, nTGRadius;               //背景模板半径、目标模板半径
    SINT32  nBGIndex, nBGFlter;                 //背景模板下标、背景模板系数
    SINT32  nImgIndex;                          //背景点/邻域点对应的原始图像坐标
    SINT32  nBGValue, nBGCnt;                   //背景点灰度、背景点计数
    FLOAT32  dBGMean;							//背景均值、方差
    SINT32* pnFilter = (SINT32*)g_DST_nFilter_9_13;//目标背景模板
    MINMAXRECT mmBGRect;						//目标、背景窗口边界

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    nFilterBGW = DST_KERNAL_SIZE_Bm_13;
    nBGRadius = (SINT32)(nFilterBGW >> 1);
    nTGRadius = (SINT32)(DST_KERNAL_SIZE_Tm_9 >> 1);

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //统计背景均值、方差
    //计算背景窗口边界
    mmBGRect.minX = pPnt.x - nBGRadius;
    mmBGRect.maxX = pPnt.x + nBGRadius;
    mmBGRect.minY = pPnt.y - nBGRadius;
    mmBGRect.maxY = pPnt.y + nBGRadius;

    //防止越界
    if (mmBGRect.minX<0 || mmBGRect.maxX>nWidth - 1 || mmBGRect.minY<0 || mmBGRect.maxY>nHeight - 1)
    {
        return -1.0;
    }

    //统计背景均值、方差
    nBGCnt = 0;
    dBGMean = 0;

    //小目标检测：在原图上计算背景均值、背景标准差
    SINT32  nBGLine = 0;
    SINT32  nImgLine = mmBGRect.minY * nWidth + mmBGRect.minX;
    for (i = 0; i < nFilterBGW; i++)
    {
        for (j = 0; j < nFilterBGW; j++)
        {
            nBGIndex = nBGLine + j;
            nImgIndex = nImgLine + j;
            nBGFlter = pnFilter[nBGIndex];
            if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
            {
                nBGValue = ((UBYTE8*)img.u64VirAddr[0])[nImgIndex];
            }
            else
            {
                nBGValue = ((UINT16*)img.u64VirAddr[0])[nImgIndex];
            }
            if (1 == nBGFlter)
            {
                //背景灰度及灰度平方累加
                nBGCnt++;
                dBGMean += (FLOAT32)nBGValue;
            }
        }

        //更新行起始坐标
        nBGLine += nFilterBGW;
        nImgLine += nWidth;
    }
    dBGMean /= nBGCnt;

    //保存计算的背景均值及方差
    return dBGMean;
}

/**********************************************************
* 函数名称：DST_PipeTargetReDetect()
* 功能描述：管道目标二次搜索
* 输入参数：UINT16 *pSrc             --  原始图像
*           SINT32 nWidth               --  图像宽度
*           SINT32 nHeight              --  图像高度
*           POINT32F ptPipeCenPos       --  管道目标在当前帧的中心坐标
*           SPEED32F sfPipeSpeed        --  管道目标速度
*           MINMAXRECT mrnSrRect        --  搜索区域边界
*           FLOAT32 fgdk                --  SNR阈值
*           TARGET_OBJECT *ptTargetArray--  当前帧目标检测结果数组
*           PIPE *pPipeArray            --  管道数组
*           SINT32 *pnFrmObjsCnt        --  单帧检测目标个数
* 输出参数：TARGET_OBJECT *ptTarget     --  二次检测到的目标
*           SINT32 *bPipeTargetIndex    --  管道在当前帧查找到的目标
*           TARGET_OBJECT *ptTargetArray--  当前帧目标检测结果数组
*           SINT32 *pnFrmObjsCnt        --  单帧检测目标个数
* 返 回 值：1-二次检测找到目标，0-未检测到目标。
* 调用关系：
* 其它说明：在前一帧管道中心区域，重新查找极大或极小值点。
**********************************************************/
BBOOL DetectSmallObj::DST_PipeTargetReDetect(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight,
    POINT32F ptPipeCenPos, SPEED32F sfPipeSpeed,
    MINMAXRECT mrnSrRect, 
    TARGET_OBJECT* ptTarget,
    TARGET_OBJECT* ptTargetArray, SINT32* pnFrmObjsCnt)
{
    BBOOL   bRefoundTarget;     //标记管道目标二次搜索是否成功
    SINT32  nBlkStart;          //管道目标二次搜索时，中心区域的左上角起始坐标
    POINT16S pnPipeSearchPoint; //管道目标二次搜索时，中心区域的极值点坐标
    SINT32  nFrmObjsCnt;        //当前帧目标个数
    SINT32  nSrRadiusW;         //宽方向搜索半径
    SINT32  nSrRadiusH;         //高方向搜索半径

    //初始化
    bRefoundTarget = false;
    nFrmObjsCnt = (*pnFrmObjsCnt);
    nSrRadiusW = MAX(2, MIN((SINT32)(sfPipeSpeed.vx * 2.0f), DST_PIPE_CENTER_BLK_W / 2));
    nSrRadiusH = MAX(2, MIN((SINT32)(sfPipeSpeed.vy * 2.0f), DST_PIPE_CENTER_BLK_H / 2));
    POINT16S pBlkSecondMaxPnt = {0};//次极大值
    //MSSu, 20150609: 防止越界
    MINMAXRECT32S mrnRect;
    mrnRect.minX = ptPipeCenPos.x - nSrRadiusW;
    mrnRect.maxX = ptPipeCenPos.x + nSrRadiusW;
    mrnRect.minY = ptPipeCenPos.y - nSrRadiusH;
    mrnRect.maxY = ptPipeCenPos.y + nSrRadiusH;
    if ((mrnRect.minX < 0) || (mrnRect.maxX >= nWidth)
        || (mrnRect.minY < 0) || (mrnRect.maxY >= nHeight))
    {
        return bRefoundTarget;
    }

    //获取管道中心区域图像起始位置
    nBlkStart = mrnRect.minY * nWidth + mrnRect.minX;

    //查找块内极值：极大值或极小值
    //MSSu, 20111115: 若m_DST_nDectectMinPnt==TRUE，则为查找块内极大或极小值
    BYTE8    bMaxPntFalg = DST_BLK_MAX_PNT;	//20161130，标记极大/极小
    pnPipeSearchPoint = DST_FindBlkExtremum(img, nWidth, nHeight,
        nBlkStart, nSrRadiusW * 2 + 1, nSrRadiusH * 2 + 1, &bMaxPntFalg,&pBlkSecondMaxPnt);

    //二次检测前，关闭部分去虚警开关（需先保存关闭前的状态）
    SINT32 bUseDeFA_VarMax = m_DST_stPara.bUseDeFA_VarMax;
    SINT32 bUseDeFA_Size = m_DST_stPara.bUseDeFA_Size;
    SINT32 bUseDeFA_BGFACnt = m_DST_stPara.bUseDeFA_BGFACnt;
    SINT32 bUseDeFA_BTGrayMin = m_DST_stPara.bUseDeFA_BTGrayMin;
    SINT32 bUseDeFA_CenFlag = m_DST_stPara.bUseDeFA_CenFlag;
    SINT32 bUseDeFA_XYPrj = m_DST_stPara.bUseDeFA_XYPrj;
    m_DST_stPara.bUseDeFA_VarMax = FALSE;
    m_DST_stPara.bUseDeFA_Size = FALSE;
    m_DST_stPara.bUseDeFA_BGFACnt = FALSE;
    m_DST_stPara.bUseDeFA_BTGrayMin = FALSE;
    m_DST_stPara.bUseDeFA_CenFlag = FALSE;
    m_DST_stPara.bUseDeFA_XYPrj = FALSE;

    FLOAT32 fgdk = MAX(m_DST_stPara.fgdk / 2.0f,2.0f);

    //若目标超出搜索区域，则不降低阈值再查找，让管道消失
    //if (mrnSrRect.minX < pnPipeSearchPoint.x
    //    && pnPipeSearchPoint.x < mrnSrRect.maxX
    //    && mrnSrRect.minY < pnPipeSearchPoint.y
    //    && pnPipeSearchPoint.y < mrnSrRect.maxY)
    if (mrnRect.minX < pnPipeSearchPoint.x
        && pnPipeSearchPoint.x < mrnRect.maxX
       && mrnRect.minY < pnPipeSearchPoint.y
       && pnPipeSearchPoint.y < mrnRect.maxY)
    {
        //若检测到目标，则重置管道待删除标记pPipe->bLost清零
        memset(ptTarget, 0, sizeof(TARGET_OBJECT));
        bRefoundTarget = DST_BlkMaxTargetDetect(img, nWidth, nHeight, pnPipeSearchPoint,
            m_DST_stPara.pnFilter, m_DST_stPara.nFilterBGW, m_DST_stPara.nFilterTGW, ptTarget, fgdk);
        ptTarget->nObjTypeSize = GLB_OBJ_SIZE_DIMSMALL;

        ptTarget->nObjTypeSrc = ObjSrc::Arith_DIM;//标记为弱目标
    }

    //if (bRefoundTarget && (ABS(ptTarget->pfCenPos.x - m_GLB_stOutput.crnObjPrediRtLong.cx) > 10
    //		|| ABS(ptTarget->pfCenPos.y - m_GLB_stOutput.crnObjPrediRtLong.cy) > 10))
    //{
    //	bRefoundTarget = false;
    //}

    //将二次检测到的目标，加入单帧目标数组
    if (bRefoundTarget)
    {
        //标记为目标，加入当前帧目标数组
        ptTarget->bObject = true;
        //		ptTarget->unFrmID = m_GLB_stInput.stParaLn.unFrmId;
        //(*bPipeTargetIndex) = nFrmObjsCnt;
        memcpy(&ptTargetArray[nFrmObjsCnt], ptTarget, sizeof(TARGET_OBJECT));
        nFrmObjsCnt++;

        //更新当帧目标个数统计
        (*pnFrmObjsCnt) = nFrmObjsCnt;
    }

    //二次检测后，还原去虚警开关（需先保存关闭前的状态）
    m_DST_stPara.bUseDeFA_VarMax = bUseDeFA_VarMax;
    m_DST_stPara.bUseDeFA_Size = bUseDeFA_Size;
    m_DST_stPara.bUseDeFA_BGFACnt = bUseDeFA_BGFACnt;
    m_DST_stPara.bUseDeFA_BTGrayMin = bUseDeFA_BTGrayMin;
    m_DST_stPara.bUseDeFA_CenFlag = bUseDeFA_CenFlag;
    m_DST_stPara.bUseDeFA_XYPrj = bUseDeFA_XYPrj;

    return bRefoundTarget;
}

    /**********************************************************
    * 函数名称：DST_FindBlkExtremum()
    * 功能描述：查找块内极值点
    * 输入参数：PIXELTYPE *pFrame   --  原始图像
    *           SINT32 nWidth       --  图像宽度
    *           SINT32 nHeight      --  图像高度
    *           SINT32 pBlkStart    --  该分块在原始图像上的起始坐标
    *           SINT32 nBlkWidth    --  分块宽度
    *           SINT32 nBlkHeight   --  分块高度
    * 输出参数：无
    * 返 回 值：POINT16S pPnt       --  块内极值点坐标
    * 调用关系：无
    * 其它说明：MSSu, 20111115: 函数修改，增加查找块内极小值的功能，
    *           对于每个块的极大值和极小值，选两者中与块均值偏差较大的作为返回点。
    **********************************************************/
    POINT16S DetectSmallObj::DST_FindBlk4Neighbor(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight,
        SINT32 pBlkStart, SINT32 nBlkWidth, SINT32 nBlkHeight, POINT16S* pSecondMax)
    {
        SINT32      i, j;
        SINT32      nLen = nBlkWidth * nBlkHeight;
        UINT16      pGrayGap = 0;
        UINT16      pMax = 20;               // 起始灰度差阈值，并记录最大的pGrayGap，低于该阈值不作为候选目标

        UINT16      pMax2 = 0;
        UINT16      pMin = 65535;
        SINT32  	pMean = 0;
        POINT16S    pPntMax = { 0 };
        POINT16S    pPntMax2 = { 0 };
        POINT16S    pPntMin = { 0 };
        POINT16S	pPnt = { 0 };
        SINT32      nMaxIndex = 0;
        SINT32      nMaxIndex2 = 0;
        SINT32		nMinIndex = 0;
        SINT32      nIndex = 0;
        SINT32      nMaxI = 0;
        SINT32      nMaxJ = 0;

        //查找块内极值点
        for (i = 0; i < nBlkHeight; i++)
        {
            for (j = 0; j < nBlkWidth; j++)
            {
                //获取块内每个像素点灰度
                nIndex = pBlkStart + j;
                int nnIndex_left = nIndex - 1;
                int nnIndex_right = nIndex + 1;
                int nnIndex_top = nIndex - nWidth;
                int nnIndex_bottom = nIndex + nWidth;

                if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
                {
                    UBYTE8 * pFrame = ((UBYTE8*)img.u64VirAddr[0]);
                    pGrayGap = (pFrame[nIndex] - pFrame[nnIndex_left]) > 0 ? (pFrame[nIndex] - pFrame[nnIndex_left]) : 0 +
                        (pFrame[nIndex] - pFrame[nnIndex_right]) > 0 ? (pFrame[nIndex] - pFrame[nnIndex_right]) : 0 +
                        (pFrame[nIndex] - pFrame[nnIndex_top]) > 0 ? (pFrame[nIndex] - pFrame[nnIndex_top]) : 0 +
                        (pFrame[nIndex] - pFrame[nnIndex_bottom]) > 0 ? (pFrame[nIndex] - pFrame[nnIndex_bottom]) : 0;
                }
                else
                {
                    UINT16* pFrame = ((UINT16*)img.u64VirAddr[0]);
                    pGrayGap = (pFrame[nIndex] - pFrame[nnIndex_left]) > 0 ? (pFrame[nIndex] - pFrame[nnIndex_left]) : 0 +
                        (pFrame[nIndex] - pFrame[nnIndex_right]) > 0 ? (pFrame[nIndex] - pFrame[nnIndex_right]) : 0 +
                        (pFrame[nIndex] - pFrame[nnIndex_top]) > 0 ? (pFrame[nIndex] - pFrame[nnIndex_top]) : 0 +
                        (pFrame[nIndex] - pFrame[nnIndex_bottom]) > 0 ? (pFrame[nIndex] - pFrame[nnIndex_bottom]) : 0;
                }
                //查找极大值
                if (pGrayGap > pMax)
                {
                    pMax = pGrayGap;
                    nMaxIndex = nIndex;
                    nMaxI = i;
                    nMaxJ = j;
                }
            }
            //更新下一行的其实坐标
            pBlkStart += nWidth;
        }


        //计算块内灰度均值，抛掉极大值
        if (nLen <= 1)
        {
            pMean = pMean;
        }
        else if (nLen == 2)
        {
            pMean /= 2;
        }
        else
        {
            //pMean -= pMax;
            //pMean /= (nLen - 1);
            pMean -= (pMax + pMin);
            pMean /= (nLen - 2);
        }

        //抛掉与块均值灰度差异较小的点
        //if (ABS(pMax - pMean) < pDiffThres)
        //{
        //    pPnt.x = DST_BLK_MAX_PNT_DELETE_FLAG;
        //    pPnt.y = DST_BLK_MAX_PNT_DELETE_FLAG;
        //}
        //else    

        pPntMax.x = nMaxIndex % nWidth;
        pPntMax.y = nMaxIndex / nWidth;
        pPntMax2.x = nMaxIndex2 % nWidth;
        pPntMax2.y = nMaxIndex2 / nWidth;
        pPntMin.x = nMinIndex % nWidth;
        pPntMin.y = nMinIndex / nWidth;

        if (GLB_OBJ_GRAY_DARK == m_DST_stPara.nDetectGrayType)
        {
            pPnt = pPntMin;
        }
        else if (DST_DETECT_OBJ_TYPE_BRIGHT == m_DST_stPara.nDetectGrayType)
        {
            pPnt = pPntMax;
            if (pPntMax.x == pPntMax2.x && pPntMax.y == pPntMax2.y)
            {
                pSecondMax->x = -1;
                pSecondMax->y = -1;
            }
            else
            {
                *pSecondMax = pPntMax2;
            }
        }
        else if (DST_DETECT_OBJ_TYPE_ALL == m_DST_stPara.nDetectGrayType)
        {
            if (ABS(pMax - pMean) >= ABS(pMin - pMean))
                pPnt = pPntMax;
            else
                pPnt = pPntMin;
        }

        return pPnt;
    }

    /**********************************************************
* 函数名称：DST_PipeTargetReDetect()
* 功能描述：管道目标二次搜索
* 输入参数：UINT16 *pSrc             --  原始图像
*           SINT32 nWidth               --  图像宽度
*           SINT32 nHeight              --  图像高度
*           POINT32F ptPipeCenPos       --  管道目标在当前帧的中心坐标
*           SPEED32F sfPipeSpeed        --  管道目标速度
*           MINMAXRECT mrnSrRect        --  搜索区域边界
*           FLOAT32 fgdk                --  SNR阈值
*           TARGET_OBJECT *ptTargetArray--  当前帧目标检测结果数组
*           PIPE *pPipeArray            --  管道数组
*           SINT32 *pnFrmObjsCnt        --  单帧检测目标个数
* 输出参数：TARGET_OBJECT *ptTarget     --  二次检测到的目标
*           SINT32 *bPipeTargetIndex    --  管道在当前帧查找到的目标
*           TARGET_OBJECT *ptTargetArray--  当前帧目标检测结果数组
*           SINT32 *pnFrmObjsCnt        --  单帧检测目标个数
* 返 回 值：1-二次检测找到目标，0-未检测到目标。
* 调用关系：
* 其它说明：在前一帧管道中心区域，重新查找极大或极小值点。
**********************************************************/
BBOOL DetectSmallObj::DST_PipeTargetRReDetect(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight,
    POINT32F ptPipeCenPos, SPEED32F sfPipeSpeed,
    MINMAXRECT mrnSrRect, 
    TARGET_OBJECT* ptTarget,
    TARGET_OBJECT* ptTargetArray, SINT32* pnFrmObjsCnt)
{
    BBOOL   bRefoundTarget;     //标记管道目标二次搜索是否成功
    SINT32  nBlkStart;          //管道目标二次搜索时，中心区域的左上角起始坐标
    POINT16S pnPipeSearchPoint; //管道目标二次搜索时，中心区域的极值点坐标
    SINT32  nFrmObjsCnt;        //当前帧目标个数
    SINT32  nSrRadiusW;         //宽方向搜索半径
    SINT32  nSrRadiusH;         //高方向搜索半径
    SINT32  nSrWidth;			//宽方向搜索直径
    SINT32  nSrHeight;			//高方向搜索直径
    //初始化
    bRefoundTarget = false;
    nFrmObjsCnt = (*pnFrmObjsCnt);
    nSrRadiusW = mrnSrRect.maxX - mrnSrRect.minX;
    nSrRadiusH = mrnSrRect.maxY - mrnSrRect.minY;
    POINT16S pBlkSecondMaxPnt = {0};//次极大值
    //MSSu, 20150609: 防止越界
    MINMAXRECT32S mrnRect;
    mrnRect.minX = ptPipeCenPos.x - nSrRadiusW;
    mrnRect.maxX = ptPipeCenPos.x + nSrRadiusW;
    mrnRect.minY = ptPipeCenPos.y - nSrRadiusH;
    mrnRect.maxY = ptPipeCenPos.y + nSrRadiusH;
    if ((mrnRect.minX < 0) || (mrnRect.maxX >= nWidth)
        || (mrnRect.minY < 0) || (mrnRect.maxY >= nHeight))
    {
        return bRefoundTarget;
    }

    //获取管道中心区域图像起始位置
    nBlkStart = mrnRect.minY * nWidth + mrnRect.minX;
    nSrWidth = (nSrRadiusW << 1) + 1;
    nSrHeight = (nSrRadiusH << 1) + 1;
    //查找块内极值：极大值或极小值
    //MSSu, 20111115: 若m_DST_nDectectMinPnt==TRUE，则为查找块内极大或极小值
    BYTE8    bMaxPntFalg = DST_BLK_MAX_PNT;	//20161130，标记极大/极小
    //pnPipeSearchPoint = DST_FindBlkExtremum(img, nWidth, nHeight,
    //    nBlkStart, nSrRadiusW * 2 + 1, nSrRadiusH * 2 + 1, &bMaxPntFalg,&pBlkSecondMaxPnt);
    POINT16S pSecondMax;
    pnPipeSearchPoint = DST_FindBlk4Neighbor(img, nWidth, nHeight, nBlkStart, nSrWidth, nSrHeight, &pSecondMax);

    //三次检测前，关闭部分去虚警开关（需先保存关闭前的状态）
    SINT32 bUseDeFA_VarMax = m_DST_stPara.bUseDeFA_VarMax;
    SINT32 bUseDeFA_Size = m_DST_stPara.bUseDeFA_Size;
    SINT32 bUseDeFA_BGFACnt = m_DST_stPara.bUseDeFA_BGFACnt;
    SINT32 bUseDeFA_BTGrayMin = m_DST_stPara.bUseDeFA_BTGrayMin;
    SINT32 bUseDeFA_CenFlag = m_DST_stPara.bUseDeFA_CenFlag;
    SINT32 bUseDeFA_XYPrj = m_DST_stPara.bUseDeFA_XYPrj;
    m_DST_stPara.bUseDeFA_VarMax = FALSE;
    m_DST_stPara.bUseDeFA_Size = FALSE;
    m_DST_stPara.bUseDeFA_BGFACnt = FALSE;
    m_DST_stPara.bUseDeFA_BTGrayMin = FALSE;
    m_DST_stPara.bUseDeFA_CenFlag = FALSE;
    m_DST_stPara.bUseDeFA_XYPrj = FALSE;

    FLOAT32 fgdk = MIN(m_DST_stPara.fgdk / 2.0f, 2.0f);

    //若目标超出搜索区域，则不降低阈值再查找，让管道消失
    if (mrnRect.minX < pnPipeSearchPoint.x
        && pnPipeSearchPoint.x < mrnRect.maxX
        && mrnRect.minY < pnPipeSearchPoint.y
        && pnPipeSearchPoint.y < mrnRect.maxY)
    {
        //若检测到目标，则重置管道待删除标记pPipe->bLost清零
        memset(ptTarget, 0, sizeof(TARGET_OBJECT));
        bRefoundTarget = DST_BlkMaxTargetDetect(img, nWidth, nHeight, pnPipeSearchPoint,
            m_DST_stPara.pnFilter, m_DST_stPara.nFilterBGW, m_DST_stPara.nFilterTGW, ptTarget, fgdk);
        ptTarget->nObjTypeSize = GLB_OBJ_SIZE_DIMSMALL;

        ptTarget->nObjTypeSrc = ObjSrc::Arith_DIM;//标记为弱目标
    }

    //if (bRefoundTarget && (ABS(ptTarget->pfCenPos.x - m_GLB_stOutput.crnObjPrediRtLong.cx) > 10
    //		|| ABS(ptTarget->pfCenPos.y - m_GLB_stOutput.crnObjPrediRtLong.cy) > 10))
    //{
    //	bRefoundTarget = false;
    //}

    //将三次检测到的目标，加入单帧目标数组
    if (bRefoundTarget)
    {
        //标记为目标，加入当前帧目标数组
        ptTarget->bObject = true;
        //		ptTarget->unFrmID = m_GLB_stInput.stParaLn.unFrmId;
        memcpy(&ptTargetArray[nFrmObjsCnt], ptTarget, sizeof(TARGET_OBJECT));
        nFrmObjsCnt++;

        //更新当帧目标个数统计
        (*pnFrmObjsCnt) = nFrmObjsCnt;
    }

    //三次检测后，还原去虚警开关（需先保存关闭前的状态）
    m_DST_stPara.bUseDeFA_VarMax = bUseDeFA_VarMax;
    m_DST_stPara.bUseDeFA_Size = bUseDeFA_Size;
    m_DST_stPara.bUseDeFA_BGFACnt = bUseDeFA_BGFACnt;
    m_DST_stPara.bUseDeFA_BTGrayMin = bUseDeFA_BTGrayMin;
    m_DST_stPara.bUseDeFA_CenFlag = bUseDeFA_CenFlag;
    m_DST_stPara.bUseDeFA_XYPrj = bUseDeFA_XYPrj;

    return bRefoundTarget;
}



POINT16S * DetectSmallObj::getMaxPoint()
{
    return DST_pBlkMaxPoint;
}


/**********************************************************
* 函数名称：DST_CalObjSNR_UINT16()
* 功能描述：计算目标SNR
* 输入参数：UINT16 *pFrame   --  原始图像
*           SINT32 nWidth       --  图像宽度
*           SINT32 nHeight      --  图像高度
*           POINT16S pPnt       --  目标坐标
* 输出参数：OBJECTSNR *objSNR   --  目标SNR信息
* 返 回 值：无
* 调用关系：无
* 其它说明：DSP不移植
**********************************************************/
void DetectSmallObj::DST_CalObjSNR_UINT16(UINT16* pFrame, SINT32 nWidth, SINT32 nHeight,
    POINT16S pPnt, OBJECTSNR* objSNR)
{
    SINT32  i, j;
    SINT32  nFilterBGW;                         //极大值滤波窗口 - 背景核区域大小，目标核区域大小
    SINT32  nBGRadius, nTGRadius;               //背景模板半径、目标模板半径
    SINT32  nBGIndex, nBGFlter;                 //背景模板下标、背景模板系数
    SINT32  nImgIndex;                          //背景点/邻域点对应的原始图像坐标
    SINT32  nBGValue, nBGCnt;                   //背景点灰度、背景点计数
    double  dBGMean, dBGStd;                    //背景均值、方差
    SINT32  nCenterValue;                       //中心点pPnt的灰度
    FLOAT32 fBGStdOutput;                       //背景方差 -- 用于显示，没有经过下限限制
    SINT32* pnFilter = (SINT32*)m_DST_stPara.pnFilter;
    MINMAXRECT mmBGRect;          //目标、背景窗口边界

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //参数设置
    nFilterBGW = m_DST_stPara.nFilterBGW;
    nBGRadius = (SINT32)(nFilterBGW >> 1);
    nTGRadius = (SINT32)(DST_KERNAL_SIZE_Tm_9 >> 1);

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //获取中心点灰度值
    nCenterValue = pFrame[pPnt.y * nWidth + pPnt.x];

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //统计背景均值、方差
    //计算背景窗口边界
    mmBGRect.minX = pPnt.x - nBGRadius;
    mmBGRect.maxX = pPnt.x + nBGRadius;
    mmBGRect.minY = pPnt.y - nBGRadius;
    mmBGRect.maxY = pPnt.y + nBGRadius;

    //防止越界
    if (mmBGRect.minX<0 || mmBGRect.maxX>nWidth - 1 || mmBGRect.minY<0 || mmBGRect.maxY>nHeight - 1)
    {
        memset(objSNR, 0, sizeof(OBJECTSNR));
        return;
    }

    //统计背景均值、方差
    nBGCnt = 0;
    dBGMean = 0;
    dBGStd = 0;
    //小目标检测：在原图上计算背景均值、背景标准差
    SINT32  nBGLine = 0;
    SINT32  nImgLine = mmBGRect.minY * nWidth + mmBGRect.minX;
    for (i = 0; i < nFilterBGW; i++)
    {
        for (j = 0; j < nFilterBGW; j++)
        {
            nBGIndex = nBGLine + j;
            nImgIndex = nImgLine + j;
            nBGFlter = pnFilter[nBGIndex];
            nBGValue = pFrame[nImgIndex];

            if (1 == nBGFlter)
            {
                //背景灰度及灰度平方累加
                nBGCnt++;
                dBGMean += (double)nBGValue;
                dBGStd += (double)nBGValue * nBGValue;
            }
        }

        //更新行起始坐标
        nBGLine += nFilterBGW;
        nImgLine += nWidth;
    }
    dBGMean /= nBGCnt;
    dBGStd /= nBGCnt;
    dBGStd -= dBGMean * dBGMean;

    //保存计算的背景均值及方差
    fBGStdOutput = (FLOAT32)dBGStd;

    //设置背景方差下限
    if (m_DST_stPara.bUseDeFA_VarMin                //去虚警策略“邻域方差下限限制”的开关
        && dBGStd < m_DST_stPara.fKernalBGStdMin)   //判断邻域方差是否小于下限限制。
    {
        dBGStd = (double)m_DST_stPara.fKernalBGStdMin * m_DST_stPara.fKernalBGStdMin;
    }

    //保存目标SNR信息
    objSNR->Pnt = pPnt;
    objSNR->nTGR = (SINT16)(nTGRadius);
    objSNR->nBGR = (SINT16)(nBGRadius);
    objSNR->ObjGray = (FLOAT32)nCenterValue;
    objSNR->BGMean = (FLOAT32)dBGMean;
    objSNR->BGStd = (FLOAT32)sqrt(dBGStd);
    objSNR->fSNR = (dBGStd < 0.01) ? 1e6f : (FLOAT32)((nCenterValue - dBGMean) / sqrt(dBGStd));
}


/**********************************************************
* 函数名称：DST_DetectDimTarget_BFilter()
* 功能描述：基于分块极值的弱小目标检测（基于双边滤波的方法）
* 输入参数：UINT16 *pSrc --  原始图像
*           SINT32 nWidth   --  图像宽度
*           SINT32 nHeight  --  图像高度
* 输出参数：无
* 返 回 值：ubSuccessFlag跟踪成功标志位
* 调用关系：
* 其它说明：在低频图上计算背景均值，在高频图上计算噪声标准差。
**********************************************************/
UBYTE8 DetectSmallObj::DST_DetectDimTarget_BF(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight)
{
    //指向DSP数据空间
    UINT16* pxSrImg = (UINT16*)m_DST_stOutput.pxSrImg;
    TARGET_OBJECT* ptDimTargets = (TARGET_OBJECT*)DST_DimTarget;
    POINT16S* pDimBlkMaxPnt = (POINT16S*)DST_pDimBlkMaxPoint;
    SINT32* pBlkPtBeTargetFlag = (SINT32*)DST_pBlkPtBeTargetFlag;
    SINT16* pDimBFHighImg = (SINT16*)DST_pDimBFHighImg;     		//搜索区域双边滤波高频
    UINT16* pDimBFLowImg = (UINT16*)DST_pDimBFLowImg;      	//搜索区域双边滤波低频
    BYTE8* pbBlkMaxPntFlag = (BYTE8*)DST_pBlkMaxPntFlag;			//20161130

    //局部变量
    UBYTE8 ubObjsCnt = 0;   			//截获区域目标个数
    SINT32 nSrRadiusW, nSrRadiusH;   	//截获区域半径
    SIZE32S snImgSize;      			//截获区域图像尺寸
    CENTERRECT crnSrRect;   			//半自动截获搜索区域中心矩形
    MINMAXRECT mmnSrRect;   			//半自动截获搜索区域边界矩形
    SINT32 nBlkWidth, nBlkHeight;   	//分块宽度、高度
    SINT32 nBlkNumW, nBlkNumH;      	//宽、高方向分块个数
    SINT32 nBlkWidthMin;            	//最小分块宽度
    SINT32 nSmpScale = 1;   			//降采样倍数
    MINMAXRECT32S mmnSrSmpRect;   		//搜索区域边界矩形，MINMAXRECT32S格式
    SIZE32S snSmpImgSize;      			//降采样图像尺寸

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //初始化算法输出结果
    DST_CleanUpFrameDimDetectOutput();
    m_DST_stPara.bDimDetecting = true;

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //获取弱小目标搜索区域
    //以锁定点位置为中心
    crnSrRect.cx = m_DST_stInput.crnSemiSrRect.cx;
    crnSrRect.cy = m_DST_stInput.crnSemiSrRect.cy;

    //根据参考区域大小调整降采样倍数和大小
    if ((m_DST_stInput.crnSemiSrRect.w >> 1) < 33)
    {
        nSmpScale = 1;
    }
    else
    {
        nSmpScale = 2;
    }
    m_DST_stOutput.nDimSmpScale = nSmpScale;

    //以所设置的锁定波门宽高设定半径，并设定上下限
    nSrRadiusW = MIN(m_DST_stInput.crnSemiSrRect.w >> 1, DST_DIMOBJ_RADIUS_MAX);
    nSrRadiusW = MIN(MAX(nSrRadiusW, DST_DIMOBJ_RADIUS_MIN), DST_DIMOBJ_RADIUS_MAX);
    nSrRadiusH = MIN(m_DST_stInput.crnSemiSrRect.h >> 1, DST_DIMOBJ_RADIUS_MAX);
    nSrRadiusH = MIN(MAX(nSrRadiusH, DST_DIMOBJ_RADIUS_MIN), DST_DIMOBJ_RADIUS_MAX);
    crnSrRect.w = (nSrRadiusW << 1) + 1;
    crnSrRect.h = (nSrRadiusH << 1) + 1;
    crnSrRect.s = crnSrRect.w * crnSrRect.h;

    //计算获取弱小目标搜索区域边界矩形：防越界。
    mmnSrRect.minX = MAX(0, MIN(crnSrRect.cx - nSrRadiusW, nWidth - 1));
    mmnSrRect.minY = MAX(0, MIN(crnSrRect.cy - nSrRadiusH, nHeight - 1));
    mmnSrRect.maxX = MAX(0, MIN(crnSrRect.cx + nSrRadiusW, nWidth - 1));
    mmnSrRect.maxY = MAX(0, MIN(crnSrRect.cy + nSrRadiusH, nHeight - 1));
    m_DST_stInput.mmnSemiSrRect = mmnSrRect;
    mmnSrSmpRect.minX = mmnSrRect.minX;
    mmnSrSmpRect.maxX = mmnSrRect.maxX;
    mmnSrSmpRect.minY = mmnSrRect.minY;
    mmnSrSmpRect.maxY = mmnSrRect.maxY;

    //边界限制后，重新更新搜索区域中心矩形
    crnSrRect.cx = (mmnSrRect.minX + mmnSrRect.maxX) >> 1;
    crnSrRect.cy = (mmnSrRect.minY + mmnSrRect.maxY) >> 1;
    crnSrRect.w = mmnSrRect.maxX - mmnSrRect.minX + 1;
    crnSrRect.h = mmnSrRect.maxY - mmnSrRect.minY + 1;
    crnSrRect.s = crnSrRect.w * crnSrRect.h;
    m_DST_stInput.crnSemiSrRect = crnSrRect;

    //计算搜索区域图像尺寸
    snImgSize.w = crnSrRect.w;
    snImgSize.h = crnSrRect.h;
    snImgSize.s = snImgSize.w * snImgSize.h;
    m_DST_stOutput.snDimSrImgSize = snImgSize;

    //计算降采样图像尺寸
    if (2 == nSmpScale)
    {
        snSmpImgSize.w = (crnSrRect.w + 1) / nSmpScale;
        snSmpImgSize.h = (crnSrRect.h + 1) / nSmpScale;
        snSmpImgSize.s = snSmpImgSize.w * snSmpImgSize.h;
    }
    else
    {
        snSmpImgSize.w = crnSrRect.w;
        snSmpImgSize.h = crnSrRect.h;
        snSmpImgSize.s = snSmpImgSize.w * snSmpImgSize.h;
    }
    m_DST_stOutput.snDimSrSmpImgSize = snSmpImgSize;

    //设置分块大小及分块个数：因强制检测针对的是弱小目标，故分块大小默认设置为4
    //20170314,：弱目标检测不调高降采样后的分块大小，以免未被判为极值点
    nBlkWidthMin = MAX((SINT32)(sqrt((double)(snImgSize.s) / DST_DIMOBJ_BLK_NUM) + 0.5), 1);
    nBlkWidth = MAX(8, nBlkWidthMin);
    nBlkWidth = MIN(nBlkWidth, 16);
    nBlkHeight = nBlkWidth;

    //降采样图像的分块宽高调整为16
    if (2 == nSmpScale)
    {
        nBlkWidth = 16;
        nBlkHeight = 16;
    }
    nBlkNumW = snImgSize.w / nBlkWidth;
    nBlkNumH = snImgSize.h / nBlkHeight;

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //获取弱小目标检测区域图像或降采样图像
    if (2 == nSmpScale)
    {
        IMGO_GDSGetSubMMRect2DownSample(img, nWidth, nHeight, pxSrImg, mmnSrSmpRect, 0);
    }
    else
    {
        IMGO_GDSGetSubMMRect(img, pxSrImg, (SINT16)nWidth, (SINT16)nHeight, mmnSrRect);
    }
    m_DST_stOutput.nDimFrmsCnt++;

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    ////弱小目标检测算法未开启，则不执行后面的分块检测
    //if (!m_GLB_bEanbleDimDetect)
    //{
    //	//20170311：清空正在检测弱小目标的标记，防错
    //	m_DST_stPara.bDimDetecting = false;

    //	return ubObjsCnt;
    //}

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //计算弱小目标检测区域低频图、高频图--双边滤波
    DST_BilateralFilterInt(pxSrImg, snSmpImgSize.w, snSmpImgSize.h, pDimBFLowImg, pDimBFHighImg);

    //小目标检测
    DST_FindExtremum(img, nWidth, nHeight, pDimBlkMaxPnt, pbBlkMaxPntFlag,
        mmnSrRect.minY, mmnSrRect.minX, nBlkWidth, nBlkHeight,
        nBlkNumW, nBlkNumH);

    //判断极大值点是否为目标
    ubObjsCnt = DST_DetectFrameTarget(img, nWidth, nHeight,
        ptDimTargets, DST_DIMOBJ_BLK_NUM, pDimBlkMaxPnt,
        nBlkNumW, nBlkNumH, pBlkPtBeTargetFlag);

    //弱小目标检测时，采用恒虚警处理
    ubObjsCnt = DST_FixedFADetect(ptDimTargets, ubObjsCnt, DST_DIMOBJ_BLK_NUM);

    //更新弱小目标个数
    m_DST_stOutput.nFrmDimObjsCnt = ubObjsCnt;

    //关闭弱小目标检测
    m_DST_stPara.bDimDetecting = false;

    return ubObjsCnt;
}


/**********************************************************
* 函数名称：DST_BilateralFilterInt()
* 功能描述：恒虚警算法
* 输入参数：ptTargetArray       --  目标数组
* 输出参数：无
* 返 回 值：ubObjsCnt			--  目标个数
* 调用关系：无
* 其它说明：无
**********************************************************/
SINT32 DetectSmallObj::DST_FixedFADetect(TARGET_OBJECT* ptTargetArray, SINT32 ubObjsCnt, SINT32 nTargetNumMax)
{
    SINT32 i;
    SINT32 NumSNRMax = 0;		//信噪比超过15的目标计数
    SINT32 NumSNRLarger = 0;	//信噪比超过5且小于15的目标计数
    SINT32 NumSNRSmaller = 0;	//信噪比不足5的目标计数

    //SO_BubbleSort_TargetSNR(ptTargetArray, ubObjsCnt);

    for (i = 0; i < ubObjsCnt; i++)
    {
        TARGET_OBJECT target = ptTargetArray[i];
        if (target.bObject && target.fSNR >= 10)
        {
            NumSNRMax++;
        }
        else if (target.bObject && target.fSNR >= 5)
        {
            NumSNRLarger++;
        }
        else if (target.bObject)
        {
            NumSNRSmaller++;
        }
        else
        {
            //不处理；
        }
    }

    //若SNR≥5的目标个数大于阈值，关闭恒虚警检测
    if ((NumSNRLarger >= 2) || (NumSNRMax >= 1))
    {
        //m_GLB_stPara.nNoTargetFrameCnt = 0;

        //20171013，强制提取时
        if ((NumSNRLarger + NumSNRMax) > DST_FA_GUIDE_TARGET_NUM)
        {
            ubObjsCnt = DST_FA_GUIDE_TARGET_NUM;
        }
        else
        {
            ubObjsCnt = NumSNRLarger + NumSNRMax;
        }
    }
    else if ((NumSNRLarger + NumSNRSmaller) >= DST_FA_GUIDE_TARGET_NUM)
    {
        ubObjsCnt = DST_FA_GUIDE_TARGET_NUM;
    }
    else
    {
        ubObjsCnt = NumSNRSmaller + NumSNRLarger;
    }

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //恒虚警算法关闭条件
    if (!m_DST_stPara.bDimDetecting)
    {
        if ((NumSNRLarger >= 1) || (NumSNRMax >= 1))
        {
            //退出恒虚警帧计数器累加
            //m_GLB_nExitFixedFA++;
            m_DST_stOutput.nExitFixedFA++;

            m_DST_stOutput.nExitFixedFA = MIN(m_DST_stOutput.nExitFixedFA, 65535);	//防止数据溢出
        }
        else
        {
            //清空退出恒虚警帧计数器
            m_DST_stOutput.nExitFixedFA = 0;
        }

        //20170524，连续5帧满足条件，关闭恒虚警开关
        if (m_DST_stOutput.nExitFixedFA >= 5)
        {
            m_DST_stOutput.nExitFixedFA = 0;
            //m_GLB_stPara.bEnableFixedFADetect = false;
            //m_GLB_bEanbleDimDetect = false;
        }
    }

    //memset(&ptTargetArray[ubObjsCnt], 0, sizeof(TARGET_OBJECT) * (nTargetNumMax - ubObjsCnt));

    return ubObjsCnt;
}


/**********************************************************
* 函数名称：DST_BlkMaxTargetDetect()
* 功能描述：判断极大值区域是否为目标
* 输入参数：UINT16 *pFrame       --  原始图像
*           SINT32 nWidth           --  图像宽度
*           SINT32 nHeight          --  图像高度
*           POINT16S pPnt           --  极值点坐标
*           SINT32 *pnFilter        --  目标背景模板
*           SINT32 nFilterBGW       --  目标背景模板 - 背景宽度
*           SINT32 nFilterTGW       --  目标背景模板 - 目标宽度
*           FLOAT32 fgdk            --  目标SNR阈值
* 输出参数：TARGET_OBJECT *tTarget  --  当前目标结构体
* 返 回 值：1-该极值点是目标，0-该极值点不是目标。
* 调用关系：无
* 其它说明：无
**********************************************************/
BBOOL DetectSmallObj::DST_BlkMaxTargetDetect(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight, POINT16S pPnt,
    SINT32* pnFilter, SINT32 nFilterBGW, SINT32 nFilterTGW,
    TARGET_OBJECT* ptTarget, FLOAT32 fgdk)
{
    //指向数据空间: 标记检测到的目标像素点。0-非目标点，1-目标点。
    SINT32* pnBlkTargetFlag = (SINT32*)DST_pnBlkTargetFlag;

    SINT32  i, j;
    BBOOL   bIsTarget = false;      //标记该极值点是否为目标
    SINT32  nBGRadius = 0;			//背景模板半径
    SINT32  nTGRadius = 0;			//目标模板半径
    MINMAXRECT mmTGRect = { 0 };		//目标窗口边界
    MINMAXRECT mmBGRect = { 0 };		//背景窗口边界
    SINT32  nBGIndex = 0;			//背景模板下标
    SINT32  nBGFlter = 0;			//背景模板系数
    SINT32  nImgIndex = 0;          //背景点/邻域点对应的原始图像坐标
    SINT32  nBGValue = 0;			//背景点灰度
    SINT32  nBGCnt = 0;				//背景点计数
    double  dBGMean = 0.0f;         //背景均值
    double  dBGStd = 0.0f;          //背景方差
    SINT32  nCenterValue = 0;       //中心点pPnt的灰度
    SINT32  nPntValue = 0;          //目标模板内像素的灰度值
    FLOAT32 fBGStdOutput = 0.0f;    //背景方差 -- 用于显示，没有经过下限限制

    BBOOL   bTargetPixel = false;   //标记某像素点是否属于目标。用于统计目标大小。
    FLOAT32 fgdkCoeff = 0.0f;       //gdk下降系数。用于统计目标大小。

    SINT32  nObjWH_LineW = 0;       //目标宽高比统计 - 每行宽度
    SINT32  nObjWH_LineWMax = 0;    //目标宽高比统计 - 行宽度的最大值

    FLOAT32 fPntgdk = 0.0f;         //各点的gdk系数
    SINT32  nTGValue = 0;           //目标点灰度
    SINT32  nCenterValueSumX = 0;   //目标点灰度-X坐标乘积累加、目标点灰度-Y坐标乘积累加
    SINT32  nCenterValueSumY = 0;   //目标点灰度-X坐标乘积累加、目标点灰度-Y坐标乘积累加

    SINT32  nValueDiff = 0;         //背景点与中心点的灰度差值
    SINT32  nValueDiffMin = 0;      //背景点与中心点的灰度差的最小值
    FLOAT32 fWHRatio = 0.0f;        //目标宽高比
    FLOAT32 fRectRatio = 0.0f;      //目标矩形度
    SINT32  nObjCenX = 0;			//目标形心X、Y坐标
    SINT32  nObjCenY = 0;			//目标形心X、Y坐标

    FLOAT32 fKernalBGVarMin2 = 0.0f;    //背景方差下限阈值（可调参数-标准差下限的平方）
    FLOAT32 fKernalBGVarMax2 = 0.0f;    //背景方差上限阈值（可调参数-标准差上限的平方）

    SINT32  nDimSmpScale = 1;         	//弱小检测搜索区域降采样倍数
    SIZE32S snDimSrSmpImgSize = { 0 };  	//弱小检测搜索区域尺寸：未降采样维持原尺寸，否则为降采样后尺寸

    SINT32  nBGCntArray[4] = { 0 };		//20180115，记录上下左右邻域背景点个数
    DOUBLE64  dBGMeanArray[4] = { 0.0f };	//20180115，记录上下左右邻域背景均值
    DOUBLE64  dBGStdArray[4] = { 0.0f };	//20180115，记录上下左右邻域背景标准差
    SINT32	nBGOuterRadius = 0;			//20180115，回字形的外半径
    SINT32	nMaxStdIndex = 0;			//20180115，std最大的背景块下标
    DOUBLE64  bBGStdMax = -1.0f;		//20180115，方差最大的块

    POINT16S pMaxPnt = pPnt;			//20180918，极值点坐标

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //初始化
    bIsTarget = false;
    nValueDiffMin = (SINT32)1e6;
    memset(ptTarget, 0, sizeof(TARGET_OBJECT));

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //参数设置
    fgdkCoeff = 0.7f;
    fKernalBGVarMin2 = m_DST_stPara.fKernalBGStdMin * m_DST_stPara.fKernalBGStdMin;
    fKernalBGVarMax2 = m_DST_stPara.fKernalBGStdMax * m_DST_stPara.fKernalBGStdMax;
    nBGRadius = (SINT32)(nFilterBGW >> 1);
    nTGRadius = (SINT32)(nFilterTGW >> 1);
    nBGOuterRadius = nBGRadius - nTGRadius;	//20180115，回字形的外半径
    nDimSmpScale = m_DST_stOutput.nDimSmpScale;
    snDimSrSmpImgSize.w = (2 == nDimSmpScale) ? (m_DST_stOutput.snDimSrImgSize.w / nDimSmpScale + 1) : m_DST_stOutput.snDimSrImgSize.w;
    snDimSrSmpImgSize.h = (2 == nDimSmpScale) ? (m_DST_stOutput.snDimSrImgSize.h / nDimSmpScale + 1) : m_DST_stOutput.snDimSrImgSize.h;
    snDimSrSmpImgSize.s = snDimSrSmpImgSize.w * snDimSrSmpImgSize.h;

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //获取中心点灰度值
    //nCenterValue = pFrame[pPnt.y * nWidth + pPnt.x];
    if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
    {
        nCenterValue = ((UBYTE8*)img.u64VirAddr[0])[pPnt.y * nWidth + pPnt.x];
    }
    else
    {
        nCenterValue = ((UINT16*)img.u64VirAddr[0])[pPnt.y * nWidth + pPnt.x];
    }

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //统计背景均值、方差
    //计算背景窗口边界
    if (m_DST_stPara.bDimDetecting && (m_DST_stOutput.nDimSmpScale > 1))
    {
        SINT32 nBGRadiusRaw = nBGRadius * m_DST_stOutput.nDimSmpScale;
        mmBGRect.minX = pPnt.x - nBGRadiusRaw;
        mmBGRect.maxX = pPnt.x + nBGRadiusRaw;
        mmBGRect.minY = pPnt.y - nBGRadiusRaw;
        mmBGRect.maxY = pPnt.y + nBGRadiusRaw;
    }
    else
    {
        mmBGRect.minX = pPnt.x - nBGRadius;
        mmBGRect.maxX = pPnt.x + nBGRadius;
        mmBGRect.minY = pPnt.y - nBGRadius;
        mmBGRect.maxY = pPnt.y + nBGRadius;
    }

    //防止越界
    if (mmBGRect.minX<0 || mmBGRect.maxX>nWidth - 1 || mmBGRect.minY<0 || mmBGRect.maxY>nHeight - 1)
    {
        return false;
    }

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //统计背景均值、方差
    nBGCnt = 0;
    dBGMean = 0;
    dBGStd = 0;
    SINT32 nDiffMinBkgCnt = 0;
    //基于双边滤波的弱目标检测：在低频图上计算背景均值，在高频图上计算背景标准差
    if (!m_DST_stPara.bDimDetecting /*|| m_GLB_stPara.bEnableFixedFADetect*/)
    {
        SINT32  nBGLine = 0;
        SINT32  nImgLine = mmBGRect.minY * nWidth + mmBGRect.minX;
        for (i = 0; i < nFilterBGW; i++)
        {
            for (j = 0; j < nFilterBGW; j++)
            {
                nBGIndex = nBGLine + j;
                nImgIndex = nImgLine + j;
                nBGFlter = pnFilter[nBGIndex];
                //nBGValue = pFrame[nImgIndex];
                if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
                {
                    nBGValue = ((UBYTE8*)img.u64VirAddr[0])[nImgIndex];
                }
                else
                {
                    nBGValue = ((UINT16*)img.u64VirAddr[0])[nImgIndex];
                }
                if (1 == nBGFlter)
                {
                    //按上下左右顺序存邻域背景参数
                    if (j < nBGOuterRadius)
                    {
                        nBGCntArray[0]++;
                        dBGMeanArray[0] += (double)nBGValue;
                        dBGStdArray[0] += (double)nBGValue * nBGValue;
                    }
                    else if (j >= nFilterTGW + nBGOuterRadius)
                    {
                        nBGCntArray[1]++;
                        dBGMeanArray[1] += (double)nBGValue;
                        dBGStdArray[1] += (double)nBGValue * nBGValue;
                    }
                    else
                    {
                        //左邻域
                        if (i < nBGOuterRadius)
                        {
                            nBGCntArray[2]++;
                            dBGMeanArray[2] += (double)nBGValue;
                            dBGStdArray[2] += (double)nBGValue * nBGValue;
                        }
                        else
                        {
                            nBGCntArray[3]++;
                            dBGMeanArray[3] += (double)nBGValue;
                            dBGStdArray[3] += (double)nBGValue * nBGValue;
                        }
                    }

                    //查找背景中与中心点灰度差异最小的点的灰度
                    nValueDiff = ABS(nBGValue - nCenterValue);
                    if (nValueDiff < nValueDiffMin)
                    {
                        nValueDiffMin = nValueDiff;
                    }
                }
            }

            //更新行起始坐标
            nBGLine += nFilterBGW;
            nImgLine += nWidth;
        }

        //计算4邻域的均值与方差
        for (i = 0; i < 4; i++)
        {
            nBGCnt += nBGCntArray[i];
            dBGMean += dBGMeanArray[i];
            dBGStd += dBGStdArray[i];

            dBGMeanArray[i] /= nBGCntArray[i];
            dBGStdArray[i] /= nBGCntArray[i];
            dBGStdArray[i] -= dBGMeanArray[i] * dBGMeanArray[i];

            //找到方差最大的块
            if (dBGStdArray[i] > bBGStdMax)
            {
                bBGStdMax = dBGStdArray[i];
                nMaxStdIndex = i;
            }
        }

        //抛掉方差最大的块
        nBGCnt -= nBGCntArray[nMaxStdIndex];
        dBGMean -= (dBGMeanArray[nMaxStdIndex] * nBGCntArray[nMaxStdIndex]);
        dBGStd -= (nBGCntArray[nMaxStdIndex] * (dBGStdArray[nMaxStdIndex] + dBGMeanArray[nMaxStdIndex] * dBGMeanArray[nMaxStdIndex]));

        dBGMean /= nBGCnt;
        dBGStd /= nBGCnt;
        dBGStd -= dBGMean * dBGMean;
    }
    else
    {
        //防止越界
        if ((mmBGRect.minX < m_DST_stInput.mmnSemiSrRect.minX)
            || (mmBGRect.maxX > m_DST_stInput.mmnSemiSrRect.maxX)
            || (mmBGRect.minY < m_DST_stInput.mmnSemiSrRect.minY)
            || (mmBGRect.maxY > m_DST_stInput.mmnSemiSrRect.maxY))
        {
            return false;
        }

        SINT32  nBGLine = 0;
        SINT32  nImgLine = ((mmBGRect.minY - m_DST_stInput.mmnSemiSrRect.minY) / nDimSmpScale) * snDimSrSmpImgSize.w
            + (mmBGRect.minX - m_DST_stInput.mmnSemiSrRect.minX) / nDimSmpScale;
        SINT32  nBGValueLow = 0;
        double  dBGMeanLow = 0;
        double  dBGStdLow = 0;
        SINT32  nBGValueHigh = 0;
        double  dBGMeanHigh = 0;
        double  dBGStdHigh = 0;
        UINT16* pDimBFLowImg = (UINT16*)DST_pDimBFLowImg; //搜索区域双边滤波低频
        SINT16* pDimBFHighImg = (SINT16*)DST_pDimBFHighImg; //搜索区域双边滤波高频
        for (i = 0; i < nFilterBGW; i++)
        {
            for (j = 0; j < nFilterBGW; j++)
            {
                nBGIndex = nBGLine + j;
                nImgIndex = nImgLine + j;
                nBGFlter = pnFilter[nBGIndex];
                nBGValueLow = pDimBFLowImg[nImgIndex];
                nBGValueHigh = pDimBFHighImg[nImgIndex];

                if (1 == nBGFlter)
                {
                    //背景灰度及灰度平方累加
                    nBGCnt++;
                    dBGMeanLow += (double)nBGValueLow;
                    dBGStdLow += (double)nBGValueLow * nBGValueLow;
                    dBGMeanHigh += (double)nBGValueHigh;
                    dBGStdHigh += (double)nBGValueHigh * nBGValueHigh;

                    //查找背景中与中心点灰度差异最小的点的灰度
                    nValueDiff = ABS(nBGValueLow - nCenterValue);
                    // add 新增统计灰度差小于阈值的背景点数
                    if (nValueDiff < m_DST_stPara.nBTGrayMinThres)
                    {
                        nDiffMinBkgCnt++;
                    }
                    if (nValueDiff < nValueDiffMin)
                    {
                        nValueDiffMin = nValueDiff;
                    }
                }
            }

            //更新行起始坐标
            nBGLine += nFilterBGW;
            nImgLine += snDimSrSmpImgSize.w;
        }

        //低频均值、方差
        dBGMeanLow /= nBGCnt;
        dBGStdLow /= nBGCnt;
        dBGStdLow -= dBGMeanLow * dBGMeanLow;

        //高频均值、方差
        dBGMeanHigh /= nBGCnt;
        dBGStdHigh /= nBGCnt;
        dBGStdHigh -= dBGMeanHigh * dBGMeanHigh;

        //背景均值、方差
        dBGMean = dBGMeanLow;
        dBGStd = dBGStdHigh;
    }

    //保存计算的背景均值及方差
    fBGStdOutput = (FLOAT32)dBGStd;

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //抛掉方差过大的块
    if (m_DST_stPara.bUseDeFA_VarMax    //去虚警策略“邻域方差上限限制”的开关
        && dBGStd > fKernalBGVarMax2)   //判断邻域方差是否大于上限限制。
        return false;

    //设置背景方差下限
    if (m_DST_stPara.bUseDeFA_VarMin                //去虚警策略“邻域方差下限限制”的开关
        && !m_DST_stPara.bDimDetecting
        && !m_DST_stPara.bSecDetecting
        && dBGStd < fKernalBGVarMin2)    //背景方差下限修改，20190508
    {
        dBGStd = (double)fKernalBGVarMin2;
    }

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //gdk不做自适应调节，直接赋给PC机传入的可调参数m_DST_stPara.fgdk
    fPntgdk = fgdk;

    //20160409: 基于双边滤波的弱目标检测，提高阈值
    //20170311: 针对阿拉善试验对S-200探测距离不足，降低弱目标检测阈值。
    if (m_DST_stPara.bDimDetecting)
    {
        fPntgdk = MAX(2.0f, fgdk - 2.0f);
    }
    //else if (m_GLB_stPara.bEnableFixedFADetect)
    //{
    //	fPntgdk = MAX(2.0f, fgdk - 5.0f);
    //}
    else
    {
        //不处理
    }

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //目标检测初始化
    //计算目标核边界
    if (m_DST_stPara.bDimDetecting && (m_DST_stOutput.nDimSmpScale > 1))
    {
        SINT32 nTGRadiusRaw = nTGRadius * m_DST_stOutput.nDimSmpScale;
        mmTGRect.minX = pPnt.x - nTGRadiusRaw;
        mmTGRect.maxX = pPnt.x + nTGRadiusRaw;
        mmTGRect.minY = pPnt.y - nTGRadiusRaw;
        mmTGRect.maxY = pPnt.y + nTGRadiusRaw;
        nTGRadius = nTGRadius * m_DST_stOutput.nDimSmpScale;
        nFilterTGW = (nTGRadius << 1) + 1;
    }
    else
    {
        mmTGRect.minX = pPnt.x - nTGRadius;
        mmTGRect.maxX = pPnt.x + nTGRadius;
        mmTGRect.minY = pPnt.y - nTGRadius;
        mmTGRect.maxY = pPnt.y + nTGRadius;
    }

    //初始化
    ptTarget->mrnRect.minY = mmTGRect.maxY;
    ptTarget->mrnRect.maxY = mmTGRect.minY;
    ptTarget->mrnRect.minX = mmTGRect.maxX;
    ptTarget->mrnRect.maxX = mmTGRect.minX;
    nCenterValueSumX = 0;
    nCenterValueSumY = 0;
    nTGValue = 0;

    //记录目标的类型
    ptTarget->nObjTypeGray = (nCenterValue < (SINT32)dBGMean) ? GLB_OBJ_GRAY_DARK : GLB_OBJ_GRAY_BRIGHT;

    //20120304：根据系统所要检测的目标类型进行区分
    if (DST_DETECT_OBJ_TYPE_DARK == m_DST_stPara.nDetectGrayType) //只检测暗目标
    {
        //20120229: 剔除亮目标。根据夜晚试验气球为暗目标的特性，做出目标类型的限制。
        if (GLB_OBJ_GRAY_BRIGHT == ptTarget->nObjTypeGray)
            return FALSE;
    }
    else if (DST_DETECT_OBJ_TYPE_BRIGHT == m_DST_stPara.nDetectGrayType) //只检测亮目标
    {
        //跳过暗目标
        if (GLB_OBJ_GRAY_DARK == ptTarget->nObjTypeGray)
            return FALSE;
    }
    else
    {
        //不处理
    }
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //提前计算参数，简化计算
    double fPntgdkByStd = fPntgdk * fPntgdk * dBGStd;

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //目标检测：基于目标信噪比的检测方法
    //首先判断极值点是否为目标
    //20111115: 若m_DST_nDectectMinPnt==TRUE，则为判断极大值点或极小值点是否为目标
    //若极值点不满足SNR条件，则判断该点是否满足灰度阈值判断的条件
    if ((nCenterValue - dBGMean) * (nCenterValue - dBGMean) <= fPntgdkByStd)
    {
        //标记该点不是目标，直接返回
        return false;
    }
    //若极值点是目标，则统计目标的大小
    else
    {
        //标记该点为目标
        bIsTarget = true;

        //去虚警：抛掉方差过大的块
        if (m_DST_stPara.bUseDeFA_VarMax
            && dBGStd > m_DST_stPara.fKernalBGStdMax)
        {
            bIsTarget = false;
        }

        //去虚警：抛掉极值点与背景最小灰度差小于阈值的块
        SINT32 nBTGrayMinThres = m_DST_stPara.nBTGrayMinThres;

        if (m_DST_stPara.bDimDetecting)
        {
            nBTGrayMinThres = 3;
            m_DST_stPara.bUseDeFA_BTGrayMin = false;
        }


        if (m_DST_stPara.bUseDeFA_BTGrayMin
            && nValueDiffMin < nBTGrayMinThres
            && nDiffMinBkgCnt > nBGCnt * 0.3)
        {
            bIsTarget = false;
        }

        //若该点不是目标，则跳过剩余计算
        if (!bIsTarget)
        {
            return false;
        }

        //降低gdk阈值统计目标大小
        fPntgdk *= fgdkCoeff;
        fPntgdk = MAX(fPntgdk, 4.0f);

        //20170313，二次检测降低阈值
        if (m_DST_stPara.bSecDetecting && m_DST_stPara.bEnableSecDetect)
        {
            fPntgdk = MAX(fPntgdk, 2.0f);
        }

        //20160409: 基于双边滤波的弱目标检测，提高阈值
        if (m_DST_stPara.bDimDetecting)
        {
            fPntgdk = (float)(sqrt((nCenterValue - dBGMean) * (nCenterValue - dBGMean) / MAX(dBGStd, 0.01)));
            fPntgdk = MAX(5.0f, fPntgdk * 0.9f);
        }

        //提前计算参数，简化计算
        double fPntgdkByStdNew = fPntgdk * fPntgdk * dBGStd;

        //搜索目标边界
        nObjWH_LineWMax = 0;
        SINT32 nLine = (pPnt.y - nTGRadius) * nWidth + pPnt.x - nTGRadius;
        SINT32 nFlagLine = 0;
        SINT32 nFlagIndex = 0;
        for (i = 0; i < nFilterTGW; i++)
        {
            //初始化每行宽度
            nObjWH_LineW = 0;

            for (j = 0; j < nFilterTGW; j++)
            {
                //获取目标区域各点的图像坐标
                nImgIndex = nLine + j;

                //获取目标区域各点灰度值
                //nPntValue = pFrame[nImgIndex];
                if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
                {
                    nPntValue = ((UBYTE8*)img.u64VirAddr[0])[nImgIndex];
                }
                else
                {
                    nPntValue = ((UINT16*)img.u64VirAddr[0])[nImgIndex];
                }
                //提前计算参数，简化计算
                double dValueDiff = nPntValue - dBGMean;
                double dValueDiffSquare = dValueDiff * dValueDiff;

                //判断该点是否属于目标点（采用SNR判断方法）
                //20180918，应根据当前点的目标灰度类型判别
                bTargetPixel = false;
                if ((i == j && i == nTGRadius)
                    || (DST_DETECT_OBJ_TYPE_BRIGHT == ptTarget->nObjTypeGray && nPntValue > dBGMean && dValueDiffSquare > fPntgdkByStdNew)
                    || (DST_DETECT_OBJ_TYPE_DARK == ptTarget->nObjTypeGray && nPntValue < dBGMean && dValueDiffSquare > fPntgdkByStdNew))
                {
                    bTargetPixel = true;

                    //20170330，对于弱小目标认为是孤立点，不再遍历邻域区域
                    if ((m_DST_stPara.bSecDetecting || m_DST_stPara.bDimDetecting)
                        && !(i == j && i == nTGRadius))
                    {
                        bTargetPixel = false;
                    }
                }

                //查找目标边界，并统计大小
                if (bTargetPixel)
                {
                    //统计行宽
                    nObjWH_LineW++;

                    //查找目标边界
                    SINT32 nImgX = j + mmTGRect.minX;
                    SINT32 nImgY = i + mmTGRect.minY;
                    ptTarget->mrnRect.minY = MIN(ptTarget->mrnRect.minY, nImgY);
                    ptTarget->mrnRect.maxY = MAX(ptTarget->mrnRect.maxY, nImgY);
                    ptTarget->mrnRect.minX = MIN(ptTarget->mrnRect.minX, nImgX);
                    ptTarget->mrnRect.maxX = MAX(ptTarget->mrnRect.maxX, nImgX);

                    //统计目标质心. 20110524
                    nCenterValueSumX += nImgX * nPntValue;
                    nCenterValueSumY += nImgY * nPntValue;
                    nTGValue += nPntValue;

                    //统计目标大小
                    ptTarget->unObjPxlsCnt++;

                    //标记目标区域内目标点
                    nFlagIndex = nFlagLine + j;
                    pnBlkTargetFlag[nFlagIndex] = 1;
                    //20180918，更新极值点坐标和值
                    if (GLB_OBJ_GRAY_BRIGHT == ptTarget->nObjTypeGray)
                    {
                        //若当前点灰度大于极值点，更新极值点
                        if (nPntValue > nCenterValue)
                        {
                            nCenterValue = nPntValue;
                            pMaxPnt.x = pPnt.x - nTGRadius + j;
                            pMaxPnt.y = pPnt.y - nTGRadius + i;
                        }
                    }
                    else
                    {
                        //若当前点灰度小于极值点，更新极值点
                        if (nPntValue < nCenterValue)
                        {
                            nCenterValue = nPntValue;
                            pMaxPnt.x = pPnt.x - nTGRadius + j;
                            pMaxPnt.y = pPnt.y - nTGRadius + i;
                        }
                    }
                }
            }

            //查找最大行宽
            nObjWH_LineWMax = MAX(nObjWH_LineWMax, nObjWH_LineW);

            //更新下一行起始坐标
            nLine += nWidth;
            nFlagLine += nFilterTGW;
        }//end of for (j = 0; j < nKernelSize_TG; j++)...
    }//end of else...

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //统计目标信息
    if (bIsTarget)
    {
        //计算统计目标质心
        if (0 == nTGValue)  //防止出错，例如当阈值设置不恰当时，连目标的极大值点都未统计到目标的大小中
        {
            //ptTarget->pfCenPos.x = (FLOAT32)pPnt.x;
            //ptTarget->pfCenPos.y = (FLOAT32)pPnt.y;
            ptTarget->pfCenPos.x = (FLOAT32)pMaxPnt.x;
            ptTarget->pfCenPos.y = (FLOAT32)pMaxPnt.y;
        }
        else
        {
            ptTarget->pfCenPos.x = (FLOAT32)nCenterValueSumX / nTGValue;
            ptTarget->pfCenPos.y = (FLOAT32)nCenterValueSumY / nTGValue;
        }

        //统计目标的灰度(极大值灰度)
        //20180918，取极大值灰度
        //ptTarget->pxObjGray = (UINT16)((pFrame[pPnt.y * nWidth + pPnt.x] + pFrame[(pPnt.y + 1) * nWidth + pPnt.x]  + pFrame[(pPnt.y ) * nWidth + pPnt.x + 1] 
        //                                            + pFrame[(pPnt.y - 1) * nWidth + pPnt.x] + pFrame[pPnt.y  * nWidth + pPnt.x - 1] ) / 5);
        //ptTarget->pxObjGray = (UINT16)(pFrame[pMaxPnt.y * nWidth + pMaxPnt.x]);
        //ptTarget->pxObjMaxGray = (UINT16)(pFrame[pMaxPnt.y * nWidth + pMaxPnt.x]);	//20200511
        if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
        {
            ptTarget->pxObjGray = (((UBYTE8*)img.u64VirAddr[0])[pMaxPnt.y * nWidth + pMaxPnt.x]);
            ptTarget->pxObjMaxGray = (((UBYTE8*)img.u64VirAddr[0])[pMaxPnt.y * nWidth + pMaxPnt.x]);	//20200511

            ptTarget->fGrayNeighbor[0] = (((UBYTE8*)img.u64VirAddr[0])[(pMaxPnt.y - 1) * nWidth + pMaxPnt.x]);
            ptTarget->fGrayNeighbor[1] = (((UBYTE8*)img.u64VirAddr[0])[pMaxPnt.y * nWidth + pMaxPnt.x + 1]);
            ptTarget->fGrayNeighbor[2] = (((UBYTE8*)img.u64VirAddr[0])[(pMaxPnt.y + 1) * nWidth + pMaxPnt.x]);
            ptTarget->fGrayNeighbor[3] = (((UBYTE8*)img.u64VirAddr[0])[pMaxPnt.y * nWidth + pMaxPnt.x - 1]);
        }
        else
        {
            ptTarget->pxObjGray = (((UINT16*)img.u64VirAddr[0])[pMaxPnt.y * nWidth + pMaxPnt.x]);
            ptTarget->pxObjMaxGray = (((UINT16*)img.u64VirAddr[0])[pMaxPnt.y * nWidth + pMaxPnt.x]);	//20200511

            ptTarget->fGrayNeighbor[0] = (((UINT16*)img.u64VirAddr[0])[(pMaxPnt.y - 1) * nWidth + pMaxPnt.x]);
            ptTarget->fGrayNeighbor[1] = (((UINT16*)img.u64VirAddr[0])[pMaxPnt.y * nWidth + pMaxPnt.x + 1]);
            ptTarget->fGrayNeighbor[2] = (((UINT16*)img.u64VirAddr[0])[(pMaxPnt.y + 1) * nWidth + pMaxPnt.x]);
            ptTarget->fGrayNeighbor[3] = (((UINT16*)img.u64VirAddr[0])[pMaxPnt.y * nWidth + pMaxPnt.x - 1]);
        }
        //记录目标极大值点坐标
        //ptTarget->pnMaxPos = pPnt;
        ptTarget->pnMaxPos = pMaxPnt;

        //计算目标宽、高、面积
        ptTarget->snSize.h = ptTarget->mrnRect.maxY - ptTarget->mrnRect.minY + 1;
        ptTarget->snSize.w = ptTarget->mrnRect.maxX - ptTarget->mrnRect.minX + 1;
        ptTarget->snSize.s = ptTarget->snSize.h * ptTarget->snSize.w;

        //记录背景均值、背景方差、目标背景信噪比
        ptTarget->fBGMean = (FLOAT32)dBGMean;
        ptTarget->fBGStd = (FLOAT32)sqrt(fBGStdOutput);
        ptTarget->fSNR = (FLOAT32)(nCenterValue - dBGMean) / (ptTarget->fBGStd + 0.01f);
        // 适应目标识别算法的加入，传统检测无法获取目标类型，此处约定目标类别ID置为DT_TARGET_CLS_ID，置信度为1
        ptTarget->unClsType = DT_TARGET_CLS_ID;
        ptTarget->fDetConf = 1.0;
        ptTarget->nObjTypeSrc = ObjSrc::Arith_DST;
        //标记目标类型
        ptTarget->nObjTypeSize = GLB_OBJ_SIZE_SMALL;

        //20160409: 标记弱目标
        if (m_DST_stPara.bDimDetecting)
        {
            ptTarget->nObjTypeSize = GLB_OBJ_SIZE_DIMSMALL;
        }

        //20170311：若当前为弱小目标检测，则抛掉尺寸过大的目标
        if (m_DST_stPara.bDimDetecting &&
            (ptTarget->unObjPxlsCnt > 4 || ptTarget->snSize.w > 3 || ptTarget->snSize.h > 3))
        {
            bIsTarget = false;
        }

        //20210323wl 屏蔽掉不适合本项目
        ////20170313，对像素点个数小于2的暗目标不检测
        ////20171223，检测阶段
        //if (ptTarget->nObjTypeGray == DST_OBJ_TYPE_DARK 
        //	&& ptTarget->unObjPxlsCnt < 4
        //	/*&& GLB_STATUS_TRACK != m_GLB_stPara.nStatus*/)
        //{
        //	bIsTarget = false;
        //}

        //去虚警：抛掉大小不符合要求的目标
        if (m_DST_stPara.bUseDeFA_Size  //去虚警策略“目标大小限制”的开关
            && !m_DST_stPara.bDimDetecting
            && !m_DST_stPara.bSecDetecting
            && (ptTarget->unObjPxlsCnt < (UINT32)m_DST_stPara.nObjSizeMin
                || ptTarget->unObjPxlsCnt >(UINT32)m_DST_stPara.nObjSizeMax))
        {
            bIsTarget = false;
        }

        //去虚警：抛掉长宽比不符合要求的目标
        //目标宽高比计算方式2 - 最大行宽度/总高度
        //if (GLB_STATUS_TRACK == m_GLB_stPara.nStatus)
        //{
        //	m_DST_stPara.nObjWHRatioMethod = DST_OBJ_WHRATIO_TOTALWH;
        //}
        //else
        //{
        //	m_DST_stPara.nObjWHRatioMethod = DST_OBJ_WHRATIO_LINEWH;
        //}
        if (DST_OBJ_WHRATIO_LINEWH == m_DST_stPara.nObjWHRatioMethod)
        {
            fWHRatio = (FLOAT32)nObjWH_LineWMax / ptTarget->snSize.h;
        }
        //目标宽高比计算方式1 - 总宽度/总高度
        else
        {
            fWHRatio = (FLOAT32)(ptTarget->snSize.w) / ptTarget->snSize.h;
        }

        if (m_DST_stPara.bUseDeFA_WHRatio  //去虚警策略“目标宽高比限制”的开关
            && ((fWHRatio < 1 && fWHRatio < m_DST_stPara.fObjWHRatioMin)
                || (fWHRatio > 1 && fWHRatio > m_DST_stPara.fObjWHRatioMax)))
        {
            bIsTarget = false;
        }

        //去虚警：抛掉矩形度不符合要求的目标
        fRectRatio = (FLOAT32)ptTarget->unObjPxlsCnt / ptTarget->snSize.s;
        if (m_DST_stPara.bUseDeFA_RectRatio  //去虚警策略“目标矩形度限制”的开关
            && fRectRatio < m_DST_stPara.fObjRectRatioMin)
        {
            bIsTarget = false;
        }

        //去虚警：抛掉形心不是目标标记点的目标（形状不规则）
        nObjCenX = (ptTarget->mrnRect.minX + ptTarget->mrnRect.maxX) >> 1;
        nObjCenY = (ptTarget->mrnRect.minY + ptTarget->mrnRect.maxY) >> 1;
        if (m_DST_stPara.bUseDeFA_CenFlag  //去虚警策略“形心为目标点”的开关
            && !pnBlkTargetFlag[(nObjCenY - mmTGRect.minY) * nFilterTGW + nObjCenX - mmTGRect.minX])
        {
            if (ABS(nObjCenX - ptTarget->pfCenPos.x) > 1 || ABS(nObjCenY - ptTarget->pfCenPos.y) > 1)
            {
                bIsTarget = false;
            }
        }
    }

    return bIsTarget;
}


/**********************************************************
* 函数名称：CalGuassGrayWeightTable()
* 功能描述：计算双边滤波灰度权重表
* 输入参数：UINT16 *pnGrayWeightTable--  灰度权重表指针
*           SINT32 nLen                 --  灰度权重表长度
*           SINT32 nStd                 --  标准差
* 输出参数：UINT16 *pnGrayWeightTable--  灰度权重表指针
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void DetectSmallObj::DST_CalGuassGrayWeightTable(UINT16* pnGrayWeightTable, SINT32 nLen, SINT32 nStd)
{
    SINT32 i;
    double dArg = 0.0;
    for (i = 0; i < nLen; i++)
    {
        dArg = -(i * i * 1.0) / (2 * nStd * nStd);
        pnGrayWeightTable[i] = (UINT16)(exp(dArg) * 4096 + 0.5);
    }
}


/**********************************************************
* 函数名称：DST_GetGuassGrayWeightFromTable()
* 功能描述：查表得到局部窗口像素对应的权重值
* 输入参数：UINT16 *pFrame       --  原始图像
*           UINT16 *pnTable      --  权重表
*           UINT16 *pnGrayWeight --  局部权重表
*           SINT32 nTableLen        --  权重表长度
*           SINT32 nWidth           --  图像宽度
*           SINT32 nHeight          --  图像高度
* 输出参数：UINT16 *pnGrayWeight --  局部权重表
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void DetectSmallObj::DST_GetGuassGrayWeightFromTable(UINT16* pFrame, UINT16* pnTable,
    UINT16* pnGrayWeight, SINT32 nTableLen,
    SINT32 nWidth, SINT32 nHeight)
{
    SINT32 i;
    SINT32 nLen = nWidth * nHeight;
    SINT32 nCenterY = (nHeight - 1) / 2;
    SINT32 nCenterX = (nWidth - 1) / 2;
    SINT32 fCen_data = pFrame[nCenterY * nWidth + nCenterX];
    SINT32 nIndex;

    for (i = 0; i < nLen; i++)
    {
        nIndex = abs(pFrame[i] - fCen_data);
        nIndex = MIN(nIndex, nTableLen - 1);
        pnGrayWeight[i] = (UINT16)(pnTable[nIndex]);
    }
}


/**********************************************************
* 函数名称：DST_BilateralFilterInt()
* 功能描述：二维双边滤波（整型）
* 输入参数：UINT16 *pFrame   --  原始图像
*           SINT32 nWidth       --  图像宽度
*           SINT32 nHeight      --  图像高度
* 输出参数：UINT16 *pnLowImg --  低频图
*           SINT16 *pnHighImg   --  高频图
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void DetectSmallObj::DST_BilateralFilterInt(UINT16* pFrame, SINT32 nWidth, SINT32 nHeight,
    UINT16* pnLowImg, SINT16* pnHighImg)
{
    UINT16* pGrayWeightTable = (UINT16*)DST_pDimBFGrayWeightTable;

    SINT32  i, j, m, n;
    SINT32  nLen = nWidth * nHeight;
    SINT32  nFilterWidth = 3;    //滤波窗口宽度
    SINT32  nFilterHeight = 3;    //滤波窗口高度
    SINT32  nFilterHalfW = (SINT32)(nFilterWidth / 2);  //滤波窗口半径-宽度
    SINT32  nFilterHalfH = (SINT32)(nFilterHeight / 2); //滤波窗口半径-高度
    SINT32  nFilterSize = nFilterWidth * nFilterHeight; //滤波窗口总像素个数
    SINT32  nGrayStd = 20;   //灰度标准差
    double dWeight = 0.0;  //注意数据位宽
    double dSum = 0.0;  //注意数据位宽,不能用long

    //滤波数据临时空间
    UINT16 pnNearGrayWeight[9] = { 0 }; //滤波窗口灰度权重表
    UINT16 pnNearImg[9] = { 0 }; //滤波数据临时空间

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++        
    //计算灰度高斯权值映射表	
    DST_CalGuassGrayWeightTable(pGrayWeightTable, DST_DIM_BFGWEIGHT_LEN, nGrayStd);

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++        
    //计算低频图：对每个点进行双边滤波
    for (i = 0; i < nHeight; i++)
    {
        for (j = 0; j < nWidth; j++)
        {
            SINT32 nCnt = 0;
            SINT32 posX = 0;
            SINT32 posY = 0;

            //遍历该点邻域
            for (m = -nFilterHalfH; m <= nFilterHalfH; m++)
            {
                for (n = -nFilterHalfW; n <= nFilterHalfW; n++)
                {
                    //防止越界
                    if (m + i < 0 || m + i >= nHeight)
                        posY = i;
                    else
                        posY = m + i;
                    if (n + j < 0 || n + j >= nWidth)
                        posX = j;
                    else
                        posX = j + n;

                    //获取邻域像素
                    pnNearImg[nCnt] = pFrame[posY * nWidth + posX];
                    nCnt++;
                }
            }

            //查表得到当前的灰度高斯加权系数
            DST_GetGuassGrayWeightFromTable(pnNearImg, pGrayWeightTable, pnNearGrayWeight,
                DST_DIM_BFGWEIGHT_LEN, nFilterWidth, nFilterHeight);

            //计算去噪窗口滤波结果及权重值
            dWeight = 0.0;
            dSum = 0.0;
            for (m = 0; m < nFilterSize; m++)
            {
                dSum += pnNearImg[m] * pnNearGrayWeight[m];
                dWeight += pnNearGrayWeight[m];
            }
            pnLowImg[i * nWidth + j] = (UINT16)(dSum / dWeight);
        }
    }

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++        
    //计算高频图
    for (i = 0; i < nLen; i++)
    {
        pnHighImg[i] = pFrame[i] - pnLowImg[i];

        if (pnHighImg[i] > 200)
        {
            int a = 0;
        }
    }
}