wangchongwu
/
S3315_RK3588
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'a943686f67'
${ noResults }
S3315_RK3588/NeoTracker/src/Common/Arith_ImgOperate.cpp

3255 lines
99 KiB
Raw Normal View History Unescape

S3315板端测试后状态
11 months ago
/*********版权所有（C）2013，武汉高德红外股份有限公司***************
* 文件名称：Arith_ImgOperate.cpp
* 文件标识：图像处理
* 内容摘要：执行通用图像处理操作
* 其它说明："ImgOperate"的函数、全局变量、宏定义，统一前缀为简写"IMGO"。
* 当前版本：固化V2.0
* 创建作者：MSSu
* 创建日期：2015.03.16
*******************************************************************/
#include "Arith_ImgOperate.h"
#ifdef NEON
#include <arm_neon.h>
#endif
void GD_FRAME_pyrDownToY16(GD_VIDEO_FRAME_S img, UINT16* pDst, SINT32 nDSmpScale, RECT32S roi, MINMAXRECT& mRect)
{
UINT16* pLine = NULL;
FLOAT32 fDSmpScale2 = 1.0f / (nDSmpScale * nDSmpScale);
SINT32 nImageW = img.u32Width;
SINT32 nImageH = img.u32Height;
// 裁剪区边界保护
mRect.minX = MAX(0, MIN(roi.x, nImageW - 1));
mRect.minY = MAX(0, MIN(roi.y, nImageH - 1));
mRect.maxX = MIN(nImageW - 1, MAX(0, roi.x + roi.w));
mRect.maxY = MIN(nImageH - 1, MAX(0, roi.y + roi.h));
// 调整后的裁剪区域
roi.w = mRect.maxX - mRect.minX;
roi.h = mRect.maxY - mRect.minY;
roi.x = mRect.minX;
roi.y = mRect.minY;
// 降采样后的目标图像大小
SIZE32S SizeDst = { 0 };
SizeDst.w = roi.w / nDSmpScale;
SizeDst.h = roi.h / nDSmpScale;
// 后续处理不再考虑越界问题
if (nDSmpScale == 1)
{
// 按照不同的数据类型进行处理
switch (img.enPixelFormat)
{
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y16:
IMGO_GDSGetSubRect((UINT16*)img.u64VirAddr[0], pDst, img.u32Width, img.u32Height, &mRect, roi);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y8:
IMGO_GDSGetSubRectY8((UBYTE8*)img.u64VirAddr[0], pDst, img.u32Width, img.u32Height, &mRect, roi);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_RGB_PACKED:
IMGO_GDSGetSubRectRGB(img.u64VirAddr[0], pDst, img.u32Width, img.u32Height, &mRect, roi);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_NV12:
IMGO_GDSGetSubRectY8((UBYTE8*)img.u64VirAddr[0], pDst, img.u32Width, img.u32Height, &mRect, roi);
break;
default:
break;
}
}
else
{
// 按照不同的数据类型进行处理
switch (img.enPixelFormat)
{
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y16:
IMGO_GetSubImg((UINT16*)img.u64VirAddr[0], img.u32Width, img.u32Height, roi, pDst, SizeDst.w, SizeDst.h);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y8:
IMGO_GetSubImgY8((UBYTE8*)img.u64VirAddr[0], img.u32Width, img.u32Height, roi, pDst, SizeDst.w, SizeDst.h);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_RGB_PACKED:
IMGO_GetSubImgRGB((UBYTE8*)img.u64VirAddr[0], img.u32Width, img.u32Height, roi, pDst, SizeDst.w, SizeDst.h);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_NV12:
IMGO_GetSubImgY8((UBYTE8*)img.u64VirAddr[0], img.u32Width, img.u32Height, roi, pDst, SizeDst.w, SizeDst.h);
break;
default:
break;
}
}
}
void GD_FRAME_pyrDownToY8(GD_VIDEO_FRAME_S img, UBYTE8* pDst, SINT32 nDSmpScale, RECT32S roi, MINMAXRECT& mRect)
{
UINT16* pLine = NULL;
SINT32 nImageW = img.u32Width;
SINT32 nImageH = img.u32Height;
// 裁剪区边界保护
mRect.minX = MAX(0, MIN(roi.x, nImageW - 1));
mRect.minY = MAX(0, MIN(roi.y, nImageH - 1));
mRect.maxX = MIN(nImageW - 1, MAX(0, roi.x + roi.w));
mRect.maxY = MIN(nImageH - 1, MAX(0, roi.y + roi.h));
// 调整后的裁剪区域
roi.w = mRect.maxX - mRect.minX;
roi.h = mRect.maxY - mRect.minY;
roi.x = mRect.minX;
roi.y = mRect.minY;
// 降采样后的目标图像大小
SIZE32S SizeDst = { 0 };
SizeDst.w = roi.w / nDSmpScale;
SizeDst.h = roi.h / nDSmpScale;
// 后续处理不再考虑越界问题
if (nDSmpScale == 1)
{
// 按照不同的数据类型进行处理
switch (img.enPixelFormat)
{
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y8:
IMGO_GDSGetSubRectFromY8ToY8((UBYTE8*)img.u64VirAddr[0], pDst, img.u32Width, img.u32Height, &mRect, roi);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_RGB_PACKED:
IMGO_GDSGetSubRectRGBToY8((UBYTE8*)img.u64VirAddr[0], pDst, img.u32Width, img.u32Height, &mRect, roi);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_NV12:
IMGO_GDSGetSubRectFromY8ToY8((UBYTE8*)img.u64VirAddr[0], pDst, img.u32Width, img.u32Height, &mRect, roi);
break;
default:
break;
}
}
}
void GD_FRAME_pyrUpToY16(GD_VIDEO_FRAME_S img, UINT16* pDst, SINT32 nDSmpScale, RECT32S roi, MINMAXRECT& mRect)
{
UINT16* pLine = NULL;
FLOAT32 fDSmpScale2 = 1.0f / (nDSmpScale * nDSmpScale);
SINT32 nImageW = img.u32Width;
SINT32 nImageH = img.u32Height;
// 裁剪区边界保护
mRect.minX = MAX(0, MIN(roi.x, nImageW - 1));
mRect.minY = MAX(0, MIN(roi.y, nImageH - 1));
mRect.maxX = MIN(nImageW - 1, MAX(0, roi.x + roi.w));
mRect.maxY = MIN(nImageH - 1, MAX(0, roi.y + roi.h));
// 调整后的裁剪区域
roi.w = mRect.maxX - mRect.minX;
roi.h = mRect.maxY - mRect.minY;
roi.x = mRect.minX;
roi.y = mRect.minY;
// 上采样后的目标图像大小
SIZE32S SizeDst = { 0 };
SizeDst.w = roi.w * nDSmpScale;
SizeDst.h = roi.h * nDSmpScale;
// 后续处理不再考虑越界问题
if (nDSmpScale == 1)
{
// 按照不同的数据类型进行处理
switch (img.enPixelFormat)
{
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y16:
IMGO_GDSGetSubRect((UINT16*)img.u64VirAddr[0], pDst, img.u32Width, img.u32Height, &mRect, roi);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y8:
IMGO_GDSGetSubRectY8((UBYTE8*)img.u64VirAddr[0], pDst, img.u32Width, img.u32Height, &mRect, roi);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_RGB_PACKED:
IMGO_GDSGetSubRectRGB(img.u64VirAddr[0], pDst, img.u32Width, img.u32Height, &mRect, roi);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_NV12:
IMGO_GDSGetSubRectY8((UBYTE8*)img.u64VirAddr[0], pDst, img.u32Width, img.u32Height, &mRect, roi);
break;
default:
break;
}
}
else
{
// 按照不同的数据类型进行处理
switch (img.enPixelFormat)
{
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y16:
IMGO_GetSubImg((UINT16*)img.u64VirAddr[0], img.u32Width, img.u32Height, roi, pDst, SizeDst.w, SizeDst.h);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_GRAY_Y8:
IMGO_GetSubImgY8((UBYTE8*)img.u64VirAddr[0], img.u32Width, img.u32Height, roi, pDst, SizeDst.w, SizeDst.h);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_RGB_PACKED:
IMGO_GetSubImgRGB((UBYTE8*)img.u64VirAddr[0], img.u32Width, img.u32Height, roi, pDst, SizeDst.w, SizeDst.h);
break;
case GD_PIXEL_FORMAT_E::GD_PIXEL_FORMAT_NV12:
IMGO_GetSubImgY8((UBYTE8*)img.u64VirAddr[0], img.u32Width, img.u32Height, roi, pDst, SizeDst.w, SizeDst.h);
break;
default:
break;
}
}
}
#ifdef NEON
void Pyramid(unsigned short* imgIn, unsigned short* imgOut, int wid, int hei)
{
unsigned short* pIn0 = imgIn;
unsigned short* pIn1 = pIn0 + wid;
unsigned short* pOut = imgOut;
int widT = wid / 2;
uint16x8x2_t vIn0, vIn1;
if (wid >= 16)
{
for (int j = 0; j < hei - 1; j += 2)
{
for (int i = 0, s = 0; i < wid; i += 16, s += 8)
{
vIn0 = vld2q_u16((pIn0 + i));
vIn1 = vld2q_u16((pIn1 + i));
vst1q_u16((pOut + s), vhaddq_u16(vhaddq_u16(vIn0.val[0], vIn0.val[1]), vhaddq_u16(vIn1.val[0], vIn1.val[1])));
}
pIn0 = pIn1 + wid;
pIn1 = pIn0 + wid;
pOut = pOut + widT;
}
}
else
{
for (int j = 0; j < hei - 1; j += 2)
{
for (int i = 0, s = 0; i < wid; i += 2, s++)
{
pOut[s] = (pIn0[i] + pIn0[i + 1] + pIn1[i] + pIn1[i + 1]) >> 2;
}
pIn0 = pIn1 + wid;
pIn1 = pIn0 + wid;
pOut = pOut + widT;
}
}
}
#endif
#ifdef NEON
void Pyramid2(unsigned short* imgIn, unsigned short* imgOut, int wid, int hei, MINMAXRECT mRect)
{
unsigned short* pIn0 = imgIn + mRect.minY * wid + mRect.minX;
unsigned short* pIn1 = pIn0 + wid;
unsigned short* pOut = imgOut;
uint16x8x2_t vIn0, vIn1;
int h_sub = mRect.maxY - mRect.minY;
int w_sub = mRect.maxX - mRect.minX;
int widT = w_sub / 2;
for (int j = 0; j < h_sub - 1; j += 2)
{
for (int i = 0, s = 0; i < w_sub; i += 16, s += 8)
{
vIn0 = vld2q_u16((pIn0 + i));
vIn1 = vld2q_u16((pIn1 + i));
vst1q_u16((pOut + s), vhaddq_u16(vhaddq_u16(vIn0.val[0], vIn0.val[1]), vhaddq_u16(vIn1.val[0], vIn1.val[1])));
}
pIn0 = pIn1 + wid;
pIn1 = pIn0 + wid;
pOut = pOut + widT;
}
}
void Pyramid4(unsigned short* imgIn, unsigned short* imgOut, int wid, int hei, MINMAXRECT mRect)
{
unsigned short* pIn0 = imgIn + mRect.minY * wid + mRect.minX;
unsigned short* pIn1 = pIn0 + wid;
unsigned short* pIn2 = pIn1 + wid;
unsigned short* pIn3 = pIn2 + wid;
unsigned short* pOut = imgOut;
uint16x8x4_t vIn0, vIn1, vIn2, vIn3;
int h_sub = mRect.maxY - mRect.minY;
int w_sub = mRect.maxX - mRect.minX;
int widT = w_sub / 4;
for (int j = 0; j < h_sub - 3; j += 4)
{
for (int i = 0, s = 0; i < w_sub; i += 32, s += 8)
{
//vIn0 = vld2q_u16((pIn0 + i));
//vIn1 = vld2q_u16((pIn1 + i));
//vst1q_u16((pOut + s), vhaddq_u16(vhaddq_u16(vIn0.val[0], vIn0.val[1]), vhaddq_u16(vIn1.val[0], vIn1.val[1])));
vIn0 = vld4q_u16(pIn0 + i);
vIn1 = vld4q_u16((pIn1 + i));
vIn2 = vld4q_u16((pIn2 + i));
vIn3 = vld4q_u16((pIn3 + i));
uint16x8_t L1 = vhaddq_u16(vhaddq_u16(vIn0.val[0], vIn0.val[1]), vhaddq_u16(vIn0.val[2], vIn0.val[3]));
uint16x8_t L2 = vhaddq_u16(vhaddq_u16(vIn1.val[0], vIn1.val[1]), vhaddq_u16(vIn1.val[2], vIn1.val[3]));
uint16x8_t L3 = vhaddq_u16(vhaddq_u16(vIn2.val[0], vIn2.val[1]), vhaddq_u16(vIn2.val[2], vIn2.val[3]));
uint16x8_t L4 = vhaddq_u16(vhaddq_u16(vIn3.val[0], vIn3.val[1]), vhaddq_u16(vIn3.val[2], vIn3.val[3]));
uint16x8_t vsum = vhaddq_u16(vhaddq_u16(L1, L2), vhaddq_u16(L3, L4));
vst1q_u16((pOut + s), vsum);
}
pIn0 = pIn1 + wid;
pIn1 = pIn0 + wid;
pIn2 = pIn1 + wid;
pIn3 = pIn2 + wid;
pOut = pOut + widT;
}
}
#endif
////////////////////////////////////////////////////////////////////////////////
//--函数定义
////////////////////////////////////////////////////////////////////////////////
/****************************************************
* 函数名称：IMGO_Resize
* 功能描述：双线性插值
* 输入参数：UINT16 *pSrc -- 输入图像
SIZE32S szSrc -- 输入图像尺寸
SIZE32S szDst -- 输出图像尺寸
* 输出参数：UINT16 *pDst -- 插值后图像
* 返 回 值：
* 调用关系：
* 其它说明：
*****************************************************/
void IMGO_Resize(UINT16 *pSrc, SIZE32S szSrc, UINT16 *pDst, SIZE32S szDst)
{
SINT32 i, j;
SINT32 x0, y0, x1, y1;
FLOAT32 fZoomH, fZoomW; //缩放系数
FLOAT32 x, y, u, v;
fZoomH = szSrc.h / (FLOAT32)szDst.h;
fZoomW = szSrc.w / (FLOAT32)szDst.w;
for (i = 0; i < szDst.h; i++)
{
for (j = 0; j < szDst.w; j++)
{
x = fZoomW * j; //映射回原图坐标
y = fZoomH * i;
x = MIN(x, szSrc.w-2); //nWidth-1存在越界
y = MIN(y, szSrc.h-2);
x0 = (SINT32)x;
y0 = (SINT32)y;
x1 = x0+1;
y1 = y0+1;
u = x - x0;//权重
v = y - y0;
pDst[i*szDst.w + j] = UINT16(pSrc[szSrc.w * y0+ x0] * (1-u)*(1-v)
+ pSrc[szSrc.w * y0 + x1] * u * (1-v)
+ pSrc[szSrc.w * y1+ x0] * (1-u) * v
+ pSrc[szSrc.w * y1+ x1] * u * v);
}
}
return;
}
/**********************************************************
* 函数名称：IMGO_gcABCLin()
* 功能描述：线性自动亮度对比度
* 输入参数：UINT16 *pSrc -- 原始图像
* SINT32 nLen -- 图像尺寸
* 输出参数：UBYTE8 *pDst -- 处理后图像，调光后
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_gcABCLin(UINT16 *pSrc, UBYTE8 *pDst, SINT32 nLen)
{
SINT32 i;
//SINT32 nContrast;
//SINT32 nBright;
SINT32 nSigma;
SINT32 nSum;
SINT32 nMin;
SINT32 nMax;
SINT32 nMid;
SINT32 nValue;
FLOAT32 K;
FLOAT32 C;
//指向直方图的数据指针
SINT32 *pHist = new SINT32[65536];
memset((void*)pHist, 0, 65536 * sizeof(SINT32));
for (i = 0; i < nLen; i++)
{
pHist[pSrc[i]]++;
}
//求映射的最大最小值
nSigma = (SINT32)(0.03 * nLen); //设置高低端抛点数
nSum = 0;
nMin = 0;
nMax = 0;
for (i = 0; i < 65536; i++)
{
nSum += pHist[i];
if (nSum >= nSigma)
{
nMin = i;
break;
}
}
nSum = 0;
for (i = 65535; i >= 0; i--)
{
nSum += pHist[i];
if (nSum >= nSigma)
{
nMax = i;
break;
}
}
//计算对比度、亮度
//K = (FLOAT32)(256.0 / (nMax-nMin+1));
//C = (FLOAT32)(-K * nMin);
K = (FLOAT32)((226.0 - 30) / (nMax-nMin+1));
C = (FLOAT32)(128 - K * (nMin + nMax) / 2);
//设置对比度上限，若超出上限，重新计算亮度
if (K > 1.8)
{
K = (FLOAT32)1.8;
nSigma = (SINT32)(0.5 * nLen); //设置高低端抛点数
nSum = 0;
nMid = 0;
//求映射的中值
for (i = 0; i < 65536; i++)
{
nSum += pHist[i];
if (nSum >= nSigma)
{
nMid = i;
break;
}
}
C = (FLOAT32)(128 - K * nMid);
}
for (i = 0; i < nLen; i++)
{
nValue = (SINT32)(K * pSrc[i] + C);
if (nValue < 0)
{
pDst[i] = 0;
}
else if (nValue > 255)
{
pDst[i] = 255;
}
else
{
pDst[i] = (BYTE8)nValue;
}
}
delete []pHist;
}
/**********************************************************
* 函数名称：IMGO_gcABCLin()
* 功能描述：线性自动亮度对比度
* 输入参数：UINT16 *pSrc -- 原始图像
* SINT32 nLen -- 图像尺寸
* 输出参数：UBYTE8 *pDst -- 处理后图像，调光后
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_gcABCLinRoi(UINT16* pSrc, UBYTE8* pDst, SINT32 nLen)
{
SINT32 i;
//SINT32 nContrast;
//SINT32 nBright;
SINT32 nSigmaLow;
SINT32 nSigmaHigh;
SINT32 nSum;
SINT32 nMin;
SINT32 nMax;
SINT32 nMid;
SINT32 nValue;
FLOAT32 K;
FLOAT32 C;
//指向直方图的数据指针
SINT32* pHist = new SINT32[65536];
memset((void*)pHist, 0, 65536 * sizeof(SINT32));
for (i = 0; i < nLen; i++)
{
pHist[pSrc[i]]++;
}
//求映射的最大最小值
nSigmaLow = (SINT32)(0 * nLen); //设置低端抛点数
nSigmaHigh = (SINT32)(0.2 * nLen); //设置高端抛点数
nSum = 0;
nMin = 0;
nMax = 0;
for (i = 0; i < 65536; i++)
{
nSum += pHist[i];
if (nSum >= nSigmaLow)
{
nMin = i;
break;
}
}
nSum = 0;
for (i = 65535; i >= 0; i--)
{
nSum += pHist[i];
if (nSum >= nSigmaHigh)
{
nMax = i;
break;
}
}
//计算对比度、亮度
//K = (FLOAT32)(256.0 / (nMax-nMin+1));
//C = (FLOAT32)(-K * nMin);
K = (FLOAT32)((226.0 - 30) / (nMax - nMin + 1));
C = (FLOAT32)(128 - K * (nMin + nMax) / 2);
//设置对比度上限，若超出上限，重新计算亮度
if (K > 1.8)
{
K = (FLOAT32)1.8;
nSigmaLow = (SINT32)(0.5 * nLen); //设置高端抛点数
nSum = 0;
nMid = 0;
//求映射的中值
for (i = 0; i < 65536; i++)
{
nSum += pHist[i];
if (nSum >= nSigmaLow)
{
nMid = i;
break;
}
}
C = (FLOAT32)(128 - K * nMid);
}
for (i = 0; i < nLen; i++)
{
nValue = (SINT32)(K * pSrc[i] + C);
if (nValue < 0)
{
pDst[i] = 0;
}
else if (nValue > 255)
{
pDst[i] = 255;
}
else
{
pDst[i] = (BYTE8)nValue;
}
}
delete[]pHist;
}
/**********************************************************
* 函数名称：IMGO_CenRect16S2MMRect32S()
* 功能描述：转换矩形类型,从CENTERRECT中心型转换到MINMAXRECT32S左上角及右下角型
* 输入参数：CENTERRECT crnRect -- 中心型矩阵结构体（整型16位）
* 输出参数：MINMAXRECT32S *pmrnRect -- 四边型矩形结构体（整型32位）
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_CenRect16S2MMRect32S(CENTERRECT crnRect, MINMAXRECT32S *pmrnRect, SINT32 nWidth, SINT32 nHeight)
{
SINT16 nRadiusW = crnRect.w >> 1;
SINT16 nRadiusH = crnRect.h >> 1;
pmrnRect->minX =MAX(1, (SINT32)(crnRect.cx - nRadiusW));
pmrnRect->maxX = MIN((SINT32)(pmrnRect->minX + crnRect.w - 1), nWidth - 2);
pmrnRect->minY = MAX(1, (SINT32)(crnRect.cy - nRadiusH));
pmrnRect->maxY = MIN((SINT32)(pmrnRect->minY + crnRect.h - 1), nHeight - 2); //zy修改20170929
//pmrnRect->minX =(SINT32)(crnRect.cx - nRadiusW);
//pmrnRect->maxX = (SINT32)(pmrnRect->minX + crnRect.w - 1);
//pmrnRect->minY = (SINT32)(crnRect.cy - nRadiusH);
//pmrnRect->maxY = (SINT32)(pmrnRect->minY + crnRect.h - 1);
}
/**********************************************************
* 函数名称：IMGO_MMRect32S2CenRect16S()
* 功能描述：转换矩形类型,从MINMAXRECT32S左上角及右下角型到CENTERRECT中心型
* 输入参数：MINMAXRECT pmrnRect -- 四边型矩形结构体（整型16位）
* 输出参数：CENTERRECT32S *crnRect -- 中心型矩阵结构体（整型32位）
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_MMRect32S2CenRect16S(MINMAXRECT32S pmrnRect, CENTERRECT *crnRect)
{
crnRect->cx = (SINT16)((pmrnRect.minX + pmrnRect.maxX) >> 1);
crnRect->cy = (SINT16)((pmrnRect.minY + pmrnRect.maxY) >> 1);
crnRect->w = (SINT16)(pmrnRect.maxX - pmrnRect.minX + 1);
crnRect->h = (SINT16)(pmrnRect.maxY - pmrnRect.minY + 1);
crnRect->s = (SINT32)crnRect->w * (SINT32)crnRect->h;
}
/**********************************************************
* 函数名称：IMGO_GDSGetSubRect()
* 功能描述：从pSrc中提取一个矩形区域保存到pDst
* 输入参数：UINT16 *pSrc -- 输入原始图像
* SINT16 nWidth -- 输入图像宽度
* SINT16 nHeight -- 输入图像高度
* RECT16S rRect -- 矩形区域参数
* 输出参数：UINT16 *pDst -- 提取的矩形区域图像
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_GDSGetSubRect(UINT16 *pSrc, UINT16 *pDst, SINT16 nWidth, SINT16 nHeight, RECT16S rRect)
{
SINT16 i, j;
SINT32 nCounter; //SINT16 可能越界！！
UINT16 *pLine = NULL;
//边界限制
rRect.x = MAX(rRect.x, 0);
rRect.x = MIN(rRect.x, nWidth - 1);
rRect.y = MAX(rRect.y, 0);
rRect.y = MIN(rRect.y, nHeight - 1);
//区域提取
nCounter= 0;
pLine = (UINT16*)(pSrc + rRect.y * nWidth + rRect.x);//图像行指针
for (i = 0; i < rRect.h; i++)
{
for (j = 0; j < rRect.w; j++)
{
pDst[nCounter++] = pLine[j];
}
pLine += nWidth;
}
}
/**********************************************************
* 函数名称：IMGO_GDSGetSubRect()
* 功能描述：从pSrc中提取一个矩形区域保存到pDst
* 输入参数：UINT16 *pSrc -- 输入原始图像
* SINT16 nWidth -- 输入图像宽度
* SINT16 nHeight -- 输入图像高度
* RECT32S rRect -- 矩形区域参数
* 输出参数：UINT16 *pDst -- 提取的矩形区域图像
* 返 回 值：无
* 调用关系：无
* 其它说明：为了兼容NCC捕获版本，添加RECT32S
**********************************************************/
void IMGO_GDSGetSubRect(UINT16 *pSrc, UINT16 *pDst, SINT16 nWidth, SINT16 nHeight, RECT32S rRect)
{
SINT16 i, j;
SINT32 nCounter; //SINT16 可能越界！！
UINT16 *pLine = NULL;
//边界限制
rRect.x = MAX(rRect.x, 0);
rRect.x = MIN(rRect.x, nWidth - 1);
rRect.y = MAX(rRect.y, 0);
rRect.y = MIN(rRect.y, nHeight - 1);
//区域提取
nCounter= 0;
pLine = (UINT16*)(pSrc + rRect.y * nWidth + rRect.x);//图像行指针
for (i = 0; i < rRect.h; i++)
{
for (j = 0; j < rRect.w; j++)
{
pDst[nCounter++] = pLine[j];
}
pLine += nWidth;
}
}
/****************************************************
* 函数名称：IMGO_GetSubImg
* 功能描述：从图像中获取指定区域，并插值到指定尺寸
* 输入参数：
* 输出参数：UINT16 *pDst
* 返 回 值：
* 调用关系：
* 其它说明：双线性插值,边缘复制
*****************************************************/
void IMGO_GetSubImg(UINT16 *pSrc, SINT32 nWidth, SINT32 nHeight, RECT32S roi, UINT16 *pDst, SINT32 nDstW, SINT32 nDstH)
{
SINT32 i, j;
SINT32 x0, y0, x1, y1;
FLOAT32 fZoomH, fZoomW; //缩放系数
FLOAT32 x, y, u, v;
fZoomH = roi.h / (FLOAT32)nDstH;
fZoomW = roi.w / (FLOAT32)nDstW;
for (i = 0; i < nDstH; i++)
{
for (j = 0; j < nDstW; j++)
{
x = fZoomW * j; //映射回原矩形框
y = fZoomH * i;
x += roi.x; //映射到源图像
y += roi.y;
x = MINMAX_NUM(x, 0, nWidth-2); //nWidth-1存在越界
y = MINMAX_NUM(y, 0, nHeight-2);
x0 = (SINT32)x;
y0 = (SINT32)y;
x1 = x0+1;
y1 = y0+1;
u = x - x0;//权重
v = y - y0;
pDst[i*nDstW + j] = UINT16(pSrc[nWidth * y0+ x0] * (1-u)*(1-v)
+ pSrc[nWidth * y0+ x1] * u * (1-v)
+ pSrc[nWidth * y1+ x0] * (1-u) * v
+ pSrc[nWidth * y1+ x1] * u * v);
}
}
}
/****************************************************
* 函数名称：IMGO_GetSubImg
* 功能描述：从图像中获取指定区域，并插值到指定尺寸
* 输入参数：
* 输出参数：UINT16 *pDst
* 返 回 值：
* 调用关系：
* 其它说明：双线性插值,边缘复制
*****************************************************/
void IMGO_FromUINT16GetSubImgY16(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight, RECT32S roi, UINT16* pDst, SINT32 nDstW, SINT32 nDstH)
{
SINT32 i, j;
SINT32 x0, y0, x1, y1;
FLOAT32 fZoomH, fZoomW; //缩放系数
FLOAT32 x, y, u, v;
fZoomH = roi.h / (FLOAT32)nDstH;
fZoomW = roi.w / (FLOAT32)nDstW;
for (i = 0; i < nDstH; i++)
{
for (j = 0; j < nDstW; j++)
{
x = fZoomW * j; //映射回原矩形框
y = fZoomH * i;
x += roi.x; //映射到源图像
y += roi.y;
x = MINMAX_NUM(x, 0, nWidth - 2); //nWidth-1存在越界
y = MINMAX_NUM(y, 0, nHeight - 2);
x0 = (SINT32)x;
y0 = (SINT32)y;
x1 = x0 + 1;
y1 = y0 + 1;
u = x - x0;//权重
v = y - y0;
pDst[i * nDstW + j] = UINT16(img.u64VirAddr[0][nWidth * y0 + x0] * (1 - u) * (1 - v)
+ img.u64VirAddr[0][nWidth * y0 + x1] * u * (1 - v)
+ img.u64VirAddr[0][nWidth * y1 + x0] * (1 - u) * v
+ img.u64VirAddr[0][nWidth * y1 + x1] * u * v);
}
}
}
/****************************************************
* 函数名称：IMGO_GetSubImgY8
* 功能描述：从图像中获取指定区域，并插值到指定尺寸
* 输入参数：
* 输出参数：UINT16 *pDst
* 返 回 值：
* 调用关系：
* 其它说明：双线性插值,边缘复制
*****************************************************/
void IMGO_GetSubImgY8(UBYTE8* pSrc, SINT32 nWidth, SINT32 nHeight, RECT32S roi, UINT16* pDst, SINT32 nDstW, SINT32 nDstH)
{
SINT32 i, j;
SINT32 x0, y0, x1, y1;
FLOAT32 fZoomH, fZoomW; //缩放系数
FLOAT32 x, y, u, v;
fZoomH = roi.h / (FLOAT32)nDstH;
fZoomW = roi.w / (FLOAT32)nDstW;
for (i = 0; i < nDstH; i++)
{
for (j = 0; j < nDstW; j++)
{
x = fZoomW * j; //映射回原矩形框
y = fZoomH * i;
x += roi.x; //映射到源图像
y += roi.y;
x = MINMAX_NUM(x, 0, nWidth - 2); //nWidth-1存在越界
y = MINMAX_NUM(y, 0, nHeight - 2);
x0 = (SINT32)x;
y0 = (SINT32)y;
x1 = x0 + 1;
y1 = y0 + 1;
u = x - x0;//权重
v = y - y0;
pDst[i * nDstW + j] = UINT16(pSrc[nWidth * y0 + x0] * (1 - u) * (1 - v)
+ pSrc[nWidth * y0 + x1] * u * (1 - v)
+ pSrc[nWidth * y1 + x0] * (1 - u) * v
+ pSrc[nWidth * y1 + x1] * u * v);
}
}
}
/****************************************************
* 函数名称：IMGO_GetSubImgY8
* 功能描述：从图像中获取指定区域，并插值到指定尺寸
* 输入参数：
* 输出参数：UINT16 *pDst
* 返 回 值：
* 调用关系：
* 其它说明：双线性插值,边缘复制
*****************************************************/
void IMGO_GetSubImgYUV422(UBYTE8* pSrc, SINT32 nWidth, SINT32 nHeight, RECT32S roi, UINT16* pDst, SINT32 nDstW, SINT32 nDstH)
{
SINT32 i, j;
SINT32 x0, y0, x1, y1;
FLOAT32 fZoomH, fZoomW; //缩放系数
FLOAT32 x, y, u, v;
fZoomH = roi.h / (FLOAT32)nDstH;
fZoomW = roi.w / (FLOAT32)nDstW;
for (i = 0; i < nDstH; i++)
{
for (j = 0; j < nDstW; j++)
{
x = fZoomW * j; //映射回原矩形框
y = fZoomH * i;
x += roi.x; //映射到源图像
y += roi.y;
x = MINMAX_NUM(x, 0, nWidth - 2); //nWidth-1存在越界
y = MINMAX_NUM(y, 0, nHeight - 2);
x0 = (SINT32)x;
y0 = (SINT32)y;
x1 = x0 + 1;
y1 = y0 + 1;
u = x - x0;//权重
v = y - y0;
pDst[i * nDstW + j] = UINT16(pSrc[2 *(nWidth * y0 + x0) + 1] * (1 - u) * (1 - v)
+ pSrc[2 * (nWidth * y0 + x1) + 1] * u * (1 - v)
+ pSrc[2 * (nWidth * y1 + x0) + 1] * (1 - u) * v
+ pSrc[2 * (nWidth * y1 + x1) + 1] * u * v);
}
}
}
/****************************************************
* 函数名称：IMGO_GetSubImgRGB
* 功能描述：从图像中获取指定区域，并插值到指定尺寸
* 输入参数：
* 输出参数：UINT16 *pDst
* 返 回 值：
* 调用关系：
* 其它说明：双线性插值,边缘复制
*****************************************************/
void IMGO_GetSubImgRGB(UBYTE8* pSrc, SINT32 nWidth, SINT32 nHeight, RECT32S roi, UINT16* pDst, SINT32 nDstW, SINT32 nDstH)
{
SINT32 i, j;
SINT32 x0, y0, x1, y1;
FLOAT32 fZoomH, fZoomW; //缩放系数
FLOAT32 x, y, u, v;
UBYTE8 R[4] = {0};
UBYTE8 G[4] = { 0 };
UBYTE8 B[4] = { 0 };
fZoomH = roi.h / (FLOAT32)nDstH;
fZoomW = roi.w / (FLOAT32)nDstW;
for (i = 0; i < nDstH; i++)
{
for (j = 0; j < nDstW; j++)
{
x = fZoomW * j; //映射回原矩形框
y = fZoomH * i;
x += roi.x; //映射到源图像
y += roi.y;
x = MINMAX_NUM(x, 0, nWidth - 2); //nWidth-1存在越界
y = MINMAX_NUM(y, 0, nHeight - 2);
x0 = (SINT32)x;
y0 = (SINT32)y;
x1 = x0 + 1;
y1 = y0 + 1;
u = x - x0;//权重
v = y - y0;
R[0] = pSrc[3 * (nWidth * y0 + x0) + 0];
R[1] = pSrc[3 * (nWidth * y0 + x1) + 0];
R[2] = pSrc[3 * (nWidth * y1 + x0) + 0];
R[3] = pSrc[3 * (nWidth * y1 + x1) + 0];
G[0] = pSrc[3 * (nWidth * y0 + x0) + 1];
G[1] = pSrc[3 * (nWidth * y0 + x1) + 1];
G[2] = pSrc[3 * (nWidth * y1 + x0) + 1];
G[3] = pSrc[3 * (nWidth * y1 + x1) + 1];
B[0] = pSrc[3 * (nWidth * y0 + x0) + 2];
B[1] = pSrc[3 * (nWidth * y0 + x1) + 2];
B[2] = pSrc[3 * (nWidth * y1 + x0) + 2];
B[3] = pSrc[3 * (nWidth * y1 + x1) + 2];
pDst[i * nDstW + j] = UINT16((R[0] + G[0] + B[0]) / 3 * (1 - u) * (1 - v)
+ (R[1] + G[1] + B[1]) / 3 * u * (1 - v)
+ (R[2] + G[2] + B[2]) / 3 * (1 - u) * v
+ (R[3] + G[3] + B[3]) / 3 * u * v);
}
}
}
/****************************************************
* 函数名称：IMGO_GetRGBSubImg2RGB
* 功能描述：从图像中获取指定区域，并插值到指定尺寸
* 输入参数：
* 输出参数：UBYTE8 *pDst:三通道的局部图像
* 返 回 值：
* 调用关系：
* 其它说明：双线性插值,边缘复制
*****************************************************/
void IMGO_GetRGBSubImg2RGB(UBYTE8* pSrc, SINT32 nWidth, SINT32 nHeight, RECT32S roi, UBYTE8* pDst, SINT32 nDstW, SINT32 nDstH)
{
SINT32 i, j;
SINT32 x0, y0, x1, y1;
FLOAT32 fZoomH, fZoomW; //缩放系数
FLOAT32 x, y, u, v;
UBYTE8 R[4] = { 0 };
UBYTE8 G[4] = { 0 };
UBYTE8 B[4] = { 0 };
fZoomH = roi.h / (FLOAT32)nDstH;
fZoomW = roi.w / (FLOAT32)nDstW;
for (i = 0; i < nDstH; i++)
{
for (j = 0; j < nDstW; j++)
{
x = fZoomW * j; //映射回原矩形框
y = fZoomH * i;
x += roi.x; //映射到源图像
y += roi.y;
x = MINMAX_NUM(x, 0, nWidth - 2); //nWidth-1存在越界
y = MINMAX_NUM(y, 0, nHeight - 2);
x0 = (SINT32)x;
y0 = (SINT32)y;
x1 = x0 + 1;
y1 = y0 + 1;
u = x - x0;//权重
v = y - y0;
R[0] = pSrc[3 * (nWidth * y0 + x0) + 0];
R[1] = pSrc[3 * (nWidth * y0 + x1) + 0];
R[2] = pSrc[3 * (nWidth * y1 + x0) + 0];
R[3] = pSrc[3 * (nWidth * y1 + x1) + 0];
G[0] = pSrc[3 * (nWidth * y0 + x0) + 1];
G[1] = pSrc[3 * (nWidth * y0 + x1) + 1];
G[2] = pSrc[3 * (nWidth * y1 + x0) + 1];
G[3] = pSrc[3 * (nWidth * y1 + x1) + 1];
B[0] = pSrc[3 * (nWidth * y0 + x0) + 2];
B[1] = pSrc[3 * (nWidth * y0 + x1) + 2];
B[2] = pSrc[3 * (nWidth * y1 + x0) + 2];
B[3] = pSrc[3 * (nWidth * y1 + x1) + 2];
合入基线更新
6 months ago
pDst[3 * (i * nDstW + j) + 0] = UBYTE8(R[0] * (1 - u) * (1 - v) + R[1] * u * (1 - v)
+ R[2] * (1 - u) * v + R[3] * u * v);
pDst[3 * (i * nDstW + j) + 1] = UBYTE8(G[0] * (1 - u) * (1 - v) + G[1] * u * (1 - v)
+ G[2] * (1 - u) * v + G[3] * u * v);
pDst[3 * (i * nDstW + j) + 2] = UBYTE8(B[0] * (1 - u) * (1 - v) + B[1] * u * (1 - v)
+ B[2] * (1 - u) * v + B[3] * u * v);
S3315板端测试后状态
11 months ago
}
}
}
合入基线更新
6 months ago
void IMGO_GetNV12SubImg2RGB(UBYTE8* pSrcY, UBYTE8* pSrcUV, SINT32 nWidth, SINT32 nHeight, RECT32S roi, UBYTE8* pDst, SINT32 nDstW, SINT32 nDstH)
{
SINT32 i, j;
SINT32 x0, y0, x1, y1;
FLOAT32 fZoomH, fZoomW; //缩放系数
FLOAT32 x, y, u, v;
UINT16 R[4] = { 0 };
UINT16 G[4] = { 0 };
UINT16 B[4] = { 0 };
fZoomH = roi.h / (FLOAT32)nDstH;
fZoomW = roi.w / (FLOAT32)nDstW;
for (i = 0; i < nDstH; i++)
{
for (j = 0; j < nDstW; j++)
{
x = fZoomW * j; //映射回原矩形框
y = fZoomH * i;
x += roi.x; //映射到源图像
y += roi.y;
x = MINMAX_NUM(x, 0, nWidth - 2); //nWidth-1存在越界
y = MINMAX_NUM(y, 0, nHeight - 2);
x0 = (SINT32)x;
y0 = (SINT32)y;
x1 = x0 + 1;
y1 = y0 + 1;
u = x - x0;//权重
v = y - y0;
R[0] = pSrcY[nWidth * y0 + x0] + ((351 * (pSrcUV[nWidth * (y0 / 2) + (x0 / 2) * 2 + 1] - 128)) >> 8);
R[1] = pSrcY[nWidth * y0 + x1] + ((351 * (pSrcUV[nWidth * (y0 / 2) + (x1 / 2) * 2 + 1] - 128)) >> 8);
R[2] = pSrcY[nWidth * y1 + x0] + ((351 * (pSrcUV[nWidth * (y1 / 2) + (x0 / 2) * 2 + 1] - 128)) >> 8);
R[3] = pSrcY[nWidth * y1 + x1] + ((351 * (pSrcUV[nWidth * (y1 / 2) + (x1 / 2) * 2 + 1] - 128)) >> 8);
G[0] = pSrcY[nWidth * y0 + x0] - ((179 * (pSrcUV[nWidth * (y0 / 2) + (x0 / 2) * 2 + 1] - 128) + 86 * (pSrcUV[nWidth * (y0 / 2) + (x0 / 2) * 2] - 128)) >> 8);
G[1] = pSrcY[nWidth * y0 + x1] - ((179 * (pSrcUV[nWidth * (y0 / 2) + (x1 / 2) * 2 + 1] - 128) + 86 * (pSrcUV[nWidth * (y0 / 2) + (x1 / 2) * 2] - 128)) >> 8);
G[2] = pSrcY[nWidth * y1 + x0] - ((179 * (pSrcUV[nWidth * (y1 / 2) + (x0 / 2) * 2 + 1] - 128) + 86 * (pSrcUV[nWidth * (y1 / 2) + (x0 / 2) * 2] - 128)) >> 8);
G[3] = pSrcY[nWidth * y1 + x1] - ((179 * (pSrcUV[nWidth * (y1 / 2) + (x1 / 2) * 2 + 1] - 128) + 86 * (pSrcUV[nWidth * (y1 / 2) + (x1 / 2) * 2] - 128)) >> 8);
B[0] = pSrcY[nWidth * y0 + x0] + ((443 * (pSrcUV[nWidth * (y0 / 2) + (x0 / 2) * 2] - 128)) >> 8);
B[1] = pSrcY[nWidth * y0 + x1] + ((443 * (pSrcUV[nWidth * (y0 / 2) + (x1 / 2) * 2] - 128)) >> 8);
B[2] = pSrcY[nWidth * y1 + x0] + ((443 * (pSrcUV[nWidth * (y1 / 2) + (x0 / 2) * 2] - 128)) >> 8);
B[3] = pSrcY[nWidth * y1 + x1] + ((443 * (pSrcUV[nWidth * (y1 / 2) + (x1 / 2) * 2] - 128)) >> 8);
pDst[3 * (i * nDstW + j) + 0] = UBYTE8(R[0] * (1 - u) * (1 - v) + R[1] * u * (1 - v)
+ R[2] * (1 - u) * v + R[3] * u * v);
pDst[3 * (i * nDstW + j) + 1] = UBYTE8(G[0] * (1 - u) * (1 - v) + G[1] * u * (1 - v)
+ G[2] * (1 - u) * v + G[3] * u * v);
pDst[3 * (i * nDstW + j) + 2] = UBYTE8(B[0] * (1 - u) * (1 - v) + B[1] * u * (1 - v)
+ B[2] * (1 - u) * v + B[3] * u * v);
//剪裁到0-255范围
pDst[3 * (i * nDstW + j) + 0] = (pDst[3 * (i * nDstW + j) + 0] < 0) ? 0 : ((pDst[3 * (i * nDstW + j) + 0] > 255) ? 255 : pDst[3 * (i * nDstW + j) + 0]);
pDst[3 * (i * nDstW + j) + 1] = (pDst[3 * (i * nDstW + j) + 1] < 0) ? 0 : ((pDst[3 * (i * nDstW + j) + 1] > 255) ? 255 : pDst[3 * (i * nDstW + j) + 1]);
pDst[3 * (i * nDstW + j) + 2] = (pDst[3 * (i * nDstW + j) + 2] < 0) ? 0 : ((pDst[3 * (i * nDstW + j) + 2] > 255) ? 255 : pDst[3 * (i * nDstW + j) + 2]);
}
}
}
S3315板端测试后状态
11 months ago
void IMGO_GDSGetSubRect(UINT16* pSrc, UINT16* pDst, SINT16 nWidth, SINT16 nHeight, MINMAXRECT* mRect, RECT32S rRect)
{
SINT16 i, j;
UINT32 nCounter;
UINT16* pLine = NULL;
SINT32 nMinX, nMinY, nMaxX, nMaxY;
//边界限制
nMinX = MAX(0, MIN(rRect.x, nWidth - 1));
nMinY = MAX(0, MIN(rRect.y, nHeight - 1));
nMaxX = MIN(nWidth - 1, MAX(0, rRect.x + rRect.w));
nMaxY = MIN(nHeight - 1, MAX(0, rRect.y + rRect.h));
mRect->minX = nMinX;
mRect->minY = nMinY;
mRect->maxX = nMaxX;
mRect->maxY = nMaxY;
rRect.w = nMaxX - nMinX;
rRect.h = nMaxY - nMinY;
//区域提取
nCounter = 0;
//pLine = (PIXELTYPE*)(pSrc + (rRect.cy - rRect.h / 2) * nWidth + rRect.cx - rRect.w / 2);//图像行指针
pLine = (UINT16*)(pSrc + (nMinY * nWidth + nMinX));
for (i = 0; i < rRect.h; i++)
{
for (j = 0; j < rRect.w; j++)
{
pDst[nCounter++] = pLine[j];
}
pLine += nWidth;
}
}
void IMGO_GDSGetSubRectY8(UBYTE8* pSrc, UINT16* pDst, SINT16 nWidth, SINT16 nHeight, MINMAXRECT* mRect, RECT32S rRect)
{
SINT16 i, j;
UINT32 nCounter;
UBYTE8* pLine = NULL;
SINT32 nMinX, nMinY, nMaxX, nMaxY;
//边界限制
nMinX = MAX(0, MIN(rRect.x, nWidth - 1));
nMinY = MAX(0, MIN(rRect.y, nHeight - 1));
nMaxX = MIN(nWidth - 1, MAX(0, rRect.x + rRect.w));
nMaxY = MIN(nHeight - 1, MAX(0, rRect.y + rRect.h));
mRect->minX = nMinX;
mRect->minY = nMinY;
mRect->maxX = nMaxX;
mRect->maxY = nMaxY;
rRect.w = nMaxX - nMinX;
rRect.h = nMaxY - nMinY;
//区域提取
nCounter = 0;
//pLine = (PIXELTYPE*)(pSrc + (rRect.cy - rRect.h / 2) * nWidth + rRect.cx - rRect.w / 2);//图像行指针
pLine = (UBYTE8*)(pSrc + (nMinY * nWidth + nMinX));
for (i = 0; i < rRect.h; i++)
{
for (j = 0; j < rRect.w; j++)
{
pDst[nCounter++] = pLine[j];
}
pLine += nWidth;
}
}
void IMGO_GDSGetSubRectFromY8ToY8(UBYTE8* pSrc, UBYTE8* pDst, SINT16 nWidth, SINT16 nHeight, MINMAXRECT* mRect, RECT32S rRect)
{
SINT16 i, j;
UINT32 nCounter;
UBYTE8* pLine = NULL;
SINT32 nMinX, nMinY, nMaxX, nMaxY;
//边界限制
nMinX = MAX(0, MIN(rRect.x, nWidth - 1));
nMinY = MAX(0, MIN(rRect.y, nHeight - 1));
nMaxX = MIN(nWidth - 1, MAX(0, rRect.x + rRect.w));
nMaxY = MIN(nHeight - 1, MAX(0, rRect.y + rRect.h));
mRect->minX = nMinX;
mRect->minY = nMinY;
mRect->maxX = nMaxX;
mRect->maxY = nMaxY;
rRect.w = nMaxX - nMinX;
rRect.h = nMaxY - nMinY;
//区域提取
nCounter = 0;
//pLine = (PIXELTYPE*)(pSrc + (rRect.cy - rRect.h / 2) * nWidth + rRect.cx - rRect.w / 2);//图像行指针
pLine = (UBYTE8*)(pSrc + (nMinY * nWidth + nMinX));
for (i = 0; i < rRect.h; i++)
{
for (j = 0; j < rRect.w; j++)
{
pDst[nCounter++] = pLine[j];
}
pLine += nWidth;
}
}
/**********************************************************
* 函数名称：IMGO_GDSGetSubRect()
* 功能描述：从pSrc中提取一个矩形区域保存到pDst
* 输入参数：PIXELTYPE *pSrc -- 输入原始图像
* SINT16 nWidth -- 输入图像宽度
* SINT16 nHeight -- 输入图像高度
* RECT16S rRect -- 矩形区域参数
* 输出参数：PIXELTYPE *pDst -- 提取的矩形区域图像
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_GDSGetSubRectRGB(UBYTE8* pSrc, UINT16* pDst, SINT16 nWidth, SINT16 nHeight, MINMAXRECT* mRect, RECT32S rRect)
{
SINT16 i, j;
UINT32 nCounter;
UBYTE8* pLine = NULL;
SINT32 nMinX, nMinY, nMaxX, nMaxY;
//边界限制
nMinX = MAX(0, MIN(rRect.x, nWidth - 1));
nMinY = MAX(0, MIN(rRect.y , nHeight - 1));
nMaxX = MIN(nWidth - 1, MAX(0, rRect.x + rRect.w));
nMaxY = MIN(nHeight - 1, MAX(0, rRect.y + rRect.h));
mRect->minX = nMinX;
mRect->minY = nMinY;
mRect->maxX = nMaxX;
mRect->maxY = nMaxY;
rRect.w = nMaxX - nMinX;
rRect.h = nMaxY - nMinY;
//区域提取
nCounter = 0;
//pLine = (PIXELTYPE*)(pSrc + (rRect.cy - rRect.h / 2) * nWidth + rRect.cx - rRect.w / 2);//图像行指针
pLine = (UBYTE8*)(pSrc + 3 * (nMinY * nWidth + nMinX));
for (i = 0; i < rRect.h; i++)
{
for (j = 0; j < rRect.w; j++)
{
pDst[nCounter++] = (pLine[j * 3] + pLine[j * 3 + 1] + pLine[j * 3 + 2]) / 3;
}
pLine += nWidth * 3;
}
}
void IMGO_GDSGetSubRectRGBToY8(UBYTE8* pSrc, UBYTE8* pDst, SINT16 nWidth, SINT16 nHeight, MINMAXRECT* mRect, RECT32S rRect)
{
SINT16 i, j;
UINT32 nCounter;
UBYTE8* pLine = NULL;
SINT32 nMinX, nMinY, nMaxX, nMaxY;
//边界限制
nMinX = MAX(0, MIN(rRect.x, nWidth - 1));
nMinY = MAX(0, MIN(rRect.y, nHeight - 1));
nMaxX = MIN(nWidth - 1, MAX(0, rRect.x + rRect.w));
nMaxY = MIN(nHeight - 1, MAX(0, rRect.y + rRect.h));
mRect->minX = nMinX;
mRect->minY = nMinY;
mRect->maxX = nMaxX;
mRect->maxY = nMaxY;
rRect.w = nMaxX - nMinX;
rRect.h = nMaxY - nMinY;
//区域提取
nCounter = 0;
//pLine = (PIXELTYPE*)(pSrc + (rRect.cy - rRect.h / 2) * nWidth + rRect.cx - rRect.w / 2);//图像行指针
pLine = (UBYTE8*)(pSrc + 3 * (nMinY * nWidth + nMinX));
for (i = 0; i < rRect.h; i++)
{
for (j = 0; j < rRect.w; j++)
{
pDst[nCounter++] = (pLine[j * 3] + pLine[j * 3 + 1] + pLine[j * 3 + 2]) / 3;
}
pLine += nWidth * 3;
}
}
/**********************************************************
* 函数名称：IMGO_GDSGetSubMMRect()
* 功能描述：从pSrc中提取一个矩形区域保存到pDst
* 输入参数：UINT16 *pSrc -- 输入原始图像
* SINT16 nWidth -- 输入图像宽度
* SINT16 nHeight -- 输入图像高度
* MINMAXRECT mmrRect -- 矩形区域参数
* 输出参数：UINT16 *pDst -- 提取的矩形区域图像
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_GDSGetSubMMRect(UINT16 *pSrc, UINT16 *pDst, SINT16 nWidth,
SINT16 nHeight, MINMAXRECT mrnRect)
{
SINT16 i, j;
SINT32 nCounter; //=====20180419zy: SINT16修改为SINT32======
SINT32 nLine;
//边界限制
mrnRect.minY = MAX(0, MIN(mrnRect.minY, nHeight - 1));
mrnRect.maxY = MAX(0, MIN(mrnRect.maxY, nHeight - 1));
mrnRect.minX = MAX(0, MIN(mrnRect.minX, nWidth - 1));
mrnRect.maxX = MAX(0, MIN(mrnRect.maxX, nWidth - 1));
//区域提取
nCounter = 0;
nLine = mrnRect.minY * nWidth;
for (i = mrnRect.minY; i <= mrnRect.maxY; i++)
{
for (j = mrnRect.minX; j <= mrnRect.maxX; j++)
{
pDst[nCounter++] = pSrc[nLine + j];
}
nLine += nWidth;
}
}
/**********************************************************
* 函数名称：IMGO_GDSGetSubMMRect()
* 功能描述：从pSrc中提取一个矩形区域保存到pDst
* 输入参数：UINT16 *pSrc -- 输入原始图像
* SINT16 nWidth -- 输入图像宽度
* SINT16 nHeight -- 输入图像高度
* MINMAXRECT mmrRect -- 矩形区域参数
* 输出参数：UINT16 *pDst -- 提取的矩形区域图像
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_GDSGetSubMMRect(GD_VIDEO_FRAME_S img, UINT16* pDst, SINT16 nWidth,
SINT16 nHeight, MINMAXRECT mrnRect)
{
SINT16 i, j;
SINT32 nCounter; //=====20180419zy: SINT16修改为SINT32======
SINT32 nLine;
//边界限制
mrnRect.minY = MAX(0, MIN(mrnRect.minY, nHeight - 1));
mrnRect.maxY = MAX(0, MIN(mrnRect.maxY, nHeight - 1));
mrnRect.minX = MAX(0, MIN(mrnRect.minX, nWidth - 1));
mrnRect.maxX = MAX(0, MIN(mrnRect.maxX, nWidth - 1));
//区域提取
nCounter = 0;
nLine = mrnRect.minY * nWidth;
for (i = mrnRect.minY; i <= mrnRect.maxY; i++)
{
for (j = mrnRect.minX; j <= mrnRect.maxX; j++)
{
//pDst[nCounter++] = pSrc[nLine + j];
if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
{
pDst[nCounter++] = (UINT16)((UBYTE8*)img.u64VirAddr[0])[nLine + j];
}
else
{
pDst[nCounter++] = (UINT16)((UINT16*)img.u64VirAddr[0])[nLine + j];
}
}
nLine += nWidth;
}
}
/**********************************************************
* 函数名称：IMGO_GDSGetSubMMRect2DownSample()
* 功能描述：从pSrc中提取一个矩形区域，2倍降采样后保存到pDst
* 输入参数：UINT16 *pSrc -- 输入原始图像
* SINT32 nWidth -- 输入图像宽度
* SINT32 nHeight -- 输入图像高度
* MINMAXRECT32S mrnRect -- 矩形区域参数
* SINT32 nMode -- 降采样方式。1-2*2均值，0-抽点
* 输出参数：UINT16 *pDst -- 提取的矩形区域图像
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_GDSGetSubMMRect2DownSample(UINT16 *pSrc, SINT32 nWidth, SINT32 nHeight,
UINT16 *pDst, MINMAXRECT32S mrnRect,
SINT32 nDSmpMode)
{
SINT32 i, j;
SINT32 nCounter;
SINT32 nLine;
SINT32 nLineNext;
SINT32 nDSmpValue;
SINT32 nIndex;
SINT32 nIndexNext;
//边界限制
mrnRect.minY = MAX(0, MIN(mrnRect.minY, nHeight - 2));
mrnRect.maxY = MAX(0, MIN(mrnRect.maxY, nHeight - 2));
mrnRect.minX = MAX(0, MIN(mrnRect.minX, nWidth - 2));
mrnRect.maxX = MAX(0, MIN(mrnRect.maxX, nWidth - 2));
//降采样方式：2*2均值
if (1 == nDSmpMode)
{
nCounter = 0;
nLine = mrnRect.minY * nWidth;
nLineNext = nLine + nWidth;
for (i = mrnRect.minY; i <= mrnRect.maxY; i += 2)
{
for (j = mrnRect.minX; j <= mrnRect.maxX; j += 2)
{
nIndex = nLine + j;
nIndexNext = nLineNext + j;
nDSmpValue = pSrc[nIndex] + pSrc[nIndex + 1]
+ pSrc[nIndexNext] + pSrc[nIndexNext + 1];
pDst[nCounter++] = nDSmpValue >> 2;
}
nLine += (nWidth << 1);
nLineNext += (nWidth << 1);
}
}
//降采样方式：抽点
else
{
nCounter = 0;
nLine = mrnRect.minY * nWidth;
for (i = mrnRect.minY; i <= mrnRect.maxY; i += 2)
{
for (j = mrnRect.minX; j <= mrnRect.maxX; j += 2)
{
nIndex = nLine + j;
pDst[nCounter++] = pSrc[nIndex];
}
nLine += (nWidth << 1);
}
}
}
/**********************************************************
* 函数名称：IMGO_GDSGetSubMMRect2DownSample()
* 功能描述：从pSrc中提取一个矩形区域，2倍降采样后保存到pDst
* 输入参数：UINT16 *pSrc -- 输入原始图像
* SINT32 nWidth -- 输入图像宽度
* SINT32 nHeight -- 输入图像高度
* MINMAXRECT32S mrnRect -- 矩形区域参数
* SINT32 nMode -- 降采样方式。1-2*2均值，0-抽点
* 输出参数：UINT16 *pDst -- 提取的矩形区域图像
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_GDSGetSubMMRect2DownSample(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight,
UINT16* pDst, MINMAXRECT32S mrnRect,
SINT32 nDSmpMode)
{
SINT32 i, j;
SINT32 nCounter;
SINT32 nLine;
SINT32 nLineNext;
SINT32 nDSmpValue;
SINT32 nIndex;
SINT32 nIndexNext;
//边界限制
mrnRect.minY = MAX(0, MIN(mrnRect.minY, nHeight - 2));
mrnRect.maxY = MAX(0, MIN(mrnRect.maxY, nHeight - 2));
mrnRect.minX = MAX(0, MIN(mrnRect.minX, nWidth - 2));
mrnRect.maxX = MAX(0, MIN(mrnRect.maxX, nWidth - 2));
//降采样方式：2*2均值
if (1 == nDSmpMode)
{
nCounter = 0;
nLine = mrnRect.minY * nWidth;
nLineNext = nLine + nWidth;
for (i = mrnRect.minY; i <= mrnRect.maxY; i += 2)
{
for (j = mrnRect.minX; j <= mrnRect.maxX; j += 2)
{
nIndex = nLine + j;
nIndexNext = nLineNext + j;
//nDSmpValue = pSrc[nIndex] + pSrc[nIndex + 1]
// + pSrc[nIndexNext] + pSrc[nIndexNext + 1];
if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
{
nDSmpValue = (SINT32)((UBYTE8*)img.u64VirAddr[0])[nIndex] + ((UBYTE8*)img.u64VirAddr[0])[nIndex + 1]
+ ((UBYTE8*)img.u64VirAddr[0])[nIndexNext] + ((UBYTE8*)img.u64VirAddr[0])[nIndexNext + 1];
}
else
{
nDSmpValue = (SINT32)((UINT16*)img.u64VirAddr[0])[nIndex] + ((UINT16*)img.u64VirAddr[0])[nIndex + 1]
+ ((UINT16*)img.u64VirAddr[0])[nIndexNext] + ((UINT16*)img.u64VirAddr[0])[nIndexNext + 1];
}
pDst[nCounter++] = nDSmpValue >> 2;
}
nLine += (nWidth << 1);
nLineNext += (nWidth << 1);
}
}
//降采样方式：抽点
else
{
nCounter = 0;
nLine = mrnRect.minY * nWidth;
for (i = mrnRect.minY; i <= mrnRect.maxY; i += 2)
{
for (j = mrnRect.minX; j <= mrnRect.maxX; j += 2)
{
nIndex = nLine + j;
//pDst[nCounter++] = pSrc[nIndex];
if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
{
pDst[nCounter++] = (UINT16)((UBYTE8*)img.u64VirAddr[0])[nIndex];
}
else
{
pDst[nCounter++] = (UINT16)((UINT16*)img.u64VirAddr[0])[nIndex];
}
}
nLine += (nWidth << 1);
}
}
}
/**********************************************************
* 函数名称：IMGO_GDSGetSubMMRectDownSample()
* 功能描述：从pSrc中提取一个矩形区域，降采样后保存到pDst
* 输入参数：UINT16 *pSrc -- 输入原始图像
* SINT32 nWidth -- 输入图像宽度
* SINT32 nHeight -- 输入图像高度
* MINMAXRECT32S mrnRect -- 矩形区域参数
* 输出参数：UINT16 *pDst -- 提取的矩形区域图像
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_GDSGetSubMMRectDownSample(UINT16 *pSrc, SINT32 nWidth, SINT32 nHeight,
UINT16 *pDst, MINMAXRECT32S mrnRect, SINT32 nDSmpScale)
{
SINT32 i, j;
SINT32 nCounter;
SINT32 nLine;
//SINT32 nLineNext;
/* SINT32 nLineNextNext;*/
SINT32 nDSmpValue;
SINT32 nIndex;
/*SINT32 nIndexNext;*/
/*SINT32 nIndexNextNext;*/
FLOAT32 fDSmpScale2 = 1.0f / (nDSmpScale * nDSmpScale);
//边界限制
mrnRect.minY = MAX(0, MIN(mrnRect.minY, nHeight - 2));
mrnRect.maxY = MAX(0, MIN(mrnRect.maxY, nHeight -2));
mrnRect.minX = MAX(0, MIN(mrnRect.minX, nWidth - 2));
mrnRect.maxX = MAX(0, MIN(mrnRect.maxX, nWidth -2));
SINT32 k;
SINT32 p;
//区域提取
nCounter = 0;
nLine = mrnRect.minY * nWidth;
for (i = mrnRect.minY; i <= mrnRect.maxY - nDSmpScale + 1; i += nDSmpScale)
{
for (j = mrnRect.minX; j <= mrnRect.maxX -nDSmpScale + 1; j += nDSmpScale)
{
nIndex = nLine + j;
nDSmpValue = 0;
for (k = 0; k < nDSmpScale; k++)
{
for (p = 0; p < nDSmpScale; p++)
{
nDSmpValue += pSrc[nIndex + k*nWidth + p];
}
}
//pDst[nCounter++] = (UINT16)(nDSmpValue * fDSmpScale2);
pDst[nCounter++] = (UINT16)(nDSmpValue * fDSmpScale2); //20180118，图像定义成short型
}
nLine += (nWidth * nDSmpScale);
}
}
/**********************************************************
* 函数名称：IMGO_GDSGetSubMMRectDownSample()
* 功能描述：从pSrc中提取一个矩形区域，降采样后保存到pDst
* 输入参数：UINT16 *pSrc -- 输入原始图像
* SINT32 nWidth -- 输入图像宽度
* SINT32 nHeight -- 输入图像高度
* MINMAXRECT32S mrnRect -- 矩形区域参数
* 输出参数：UINT16 *pDst -- 提取的矩形区域图像
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_GDSGetSubMMRectDownSample(GD_VIDEO_FRAME_S img, SINT32 nWidth, SINT32 nHeight,
UINT16* pDst, MINMAXRECT32S mrnRect, SINT32 nDSmpScale)
{
SINT32 i, j;
SINT32 nCounter;
SINT32 nLine;
//SINT32 nLineNext;
/* SINT32 nLineNextNext;*/
SINT32 nDSmpValue;
SINT32 nIndex;
/*SINT32 nIndexNext;*/
/*SINT32 nIndexNextNext;*/
FLOAT32 fDSmpScale2 = 1.0f / (nDSmpScale * nDSmpScale);
//边界限制
mrnRect.minY = MAX(0, MIN(mrnRect.minY, nHeight - 2));
mrnRect.maxY = MAX(0, MIN(mrnRect.maxY, nHeight - 2));
mrnRect.minX = MAX(0, MIN(mrnRect.minX, nWidth - 2));
mrnRect.maxX = MAX(0, MIN(mrnRect.maxX, nWidth - 2));
SINT32 k;
SINT32 p;
//区域提取
nCounter = 0;
nLine = mrnRect.minY * nWidth;
for (i = mrnRect.minY; i <= mrnRect.maxY - nDSmpScale + 1; i += nDSmpScale)
{
for (j = mrnRect.minX; j <= mrnRect.maxX - nDSmpScale + 1; j += nDSmpScale)
{
nIndex = nLine + j;
nDSmpValue = 0;
for (k = 0; k < nDSmpScale; k++)
{
for (p = 0; p < nDSmpScale; p++)
{
//nDSmpValue += pSrc[nIndex + k * nWidth + p];
if (GD_PIXEL_FORMAT_GRAY_Y8 == img.enPixelFormat)
{
nDSmpValue += (SINT32)((UBYTE8*)img.u64VirAddr[0])[nIndex + k * nWidth + p];
}
else
{
nDSmpValue += (SINT32)((UINT16*)img.u64VirAddr[0])[nIndex + k * nWidth + p];
}
}
}
//pDst[nCounter++] = (UINT16)(nDSmpValue * fDSmpScale2);
pDst[nCounter++] = (UINT16)(nDSmpValue * fDSmpScale2); //20180118，图像定义成short型
}
nLine += (nWidth * nDSmpScale);
}
}
/**********************************************************
* 函数名称：IMGO_ProjectObject()
* 功能描述：投影法目标分割
* 输入参数：UINT16 *pSrc -- 输入图像
* SINT16 nWidth -- 输入图像宽度
* SINT16 nHeight -- 输入图像高度
* MINMAXRECT *pmrObjRect -- 分割出的目标上下左右边界
* 输出参数：无
* 返 回 值：目标大小
* 调用关系：无
* 其它说明：无
**********************************************************/
SINT32 IMGO_ProjectObject(UINT16 *pSrc, SINT16 nWidth, SINT16 nHeight, MINMAXRECT *pmrObjRect,
SINT16 *pnProjectHz, SINT16 *pnProjectVt)
{
SINT16 i;
SINT16 nPrjHzMax; //水平投影最大值
SINT16 nPrjVtMax; //垂直投影最大值
SINT16 nPrjHzThres; //水平投影分割阈值
SINT16 nPrjVtThres; //垂直投影分割阈值
SINT32 nCnt;
//SINT16 *pnProjectHz = (SINT16*)malloc(nWidth*sizeof(SINT16));
//SINT16 *pnProjectVt = (SINT16*)malloc(nHeight*sizeof(SINT16));
//初始化
pmrObjRect->minX = 0;
pmrObjRect->maxX = nWidth - 1;
pmrObjRect->minY = 0;
pmrObjRect->maxY = nHeight - 1;
memset(pnProjectHz, 0, nWidth*sizeof(SINT16));
memset(pnProjectVt, 0, nHeight*sizeof(SINT16));
//计算图像水平投影
IMGO_Project_Horizental(pSrc, nWidth, nHeight, pnProjectHz, &nPrjHzMax);
//计算目标左右边界分割阈值
nPrjHzThres = nPrjHzMax / 2;
//nPrjHzThres = nPrjHzMax / 3;
//根据水平投影统计目标左边界
for (i = 0; i < nWidth; i++)
{
//if (pnProjectHz[i] > nPrjHzThres)
if ((pnProjectHz[i] > nPrjHzThres) || (pnProjectHz[i] >= nPrjHzThres && nPrjHzThres != 0))
{
pmrObjRect->minX = i;
break;
}
}
//根据水平投影统计目标右边界
for (i = nWidth-1; i >= 0; i--)
{
//if (pnProjectHz[i] > nPrjHzThres)
if ((pnProjectHz[i] > nPrjHzThres) || (pnProjectHz[i] >= nPrjHzThres && nPrjHzThres != 0))
{
pmrObjRect->maxX = i;
break;
}
}
//对指定左、右边界区域进行垂直投影
IMGO_Project_Vertical(pSrc, nWidth, nHeight, pnProjectVt,
pmrObjRect->minX, pmrObjRect->maxX, &nPrjVtMax);
//计算目标上相边界分割阈值
nPrjVtThres = nPrjVtMax / 2;
//根据垂直投影统计目标上边界
for (i = 0; i < nHeight; i++)
{
//if (pnProjectVt[i] > nPrjVtThres)
if ((pnProjectVt[i] > nPrjVtThres) ||(pnProjectVt[i] >= nPrjVtThres && nPrjVtThres != 0))
{
pmrObjRect->minY = i;
break;
}
}
//根据垂直投影统计目标下边界
for (i = nHeight-1; i >= 0; i--)
{
//if (pnProjectVt[i] > nPrjVtThres)
if ((pnProjectVt[i] > nPrjVtThres) ||(pnProjectVt[i] >= nPrjVtThres && nPrjVtThres != 0))
{
pmrObjRect->maxY = i;
break;
}
}
//统计目标大小
nCnt = 0;
for (i = pmrObjRect->minY; i <= pmrObjRect->maxY; i++)
{
nCnt += pnProjectVt[i];
}
//释放内存
//free(pnProjectHz);
//free(pnProjectVt);
return nCnt;
}
/**********************************************************
* 函数名称：IMGO_Project_Horizental()
* 功能描述：水平投影（垂直向下投影），并统计投影最大值
* 输入参数：UINT16 *pSrc -- 输入图像
* SINT16 nWidth -- 输入图像宽度
* SINT16 nHeight -- 输入图像高度
* SINT16 *pnProject -- 输入图像每列数据的累加和
* SINT16 *pnPrjMax -- 输入图像每列数据累加的最大值
* 输出参数：无
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_Project_Horizental(UINT16 *pSrc, SINT16 nWidth, SINT16 nHeight,
SINT16 *pnProject, SINT16 *pnPrjMax)
{
SINT16 i, j;
SINT16 nSum;
//初始化
*pnPrjMax = 0;
memset(pnProject, 0, nWidth * sizeof(SINT16));
//计算每一列的投影
for (i = 0; i < nWidth; i++)
{
//初始化
nSum = 0;
//遍历第i列图像，进行像素值累加
for (j = 0; j < nHeight; j++)
{
pnProject[i] += pSrc[j*nWidth+i];
}
//统计水平投影最大值
*pnPrjMax = MAX(*pnPrjMax, pnProject[i]);
}
}
/**********************************************************
* 函数名称：IMGO_Project_Vertical()
* 功能描述：指定行区间的垂直投影（水平向右投影），并统计投影最大值
* 输入参数：UINT16 *pSrc -- 输入图像
* SINT16 nWidth -- 输入图像宽度
* SINT16 nHeight -- 输入图像宽度
* SINT16 nXStart -- 输入图像指定统计时起始列位置
* SINT16 nXEnd -- 输入图像指定统计时终止列位置
* 输出参数：SINT16 *pnProject -- 输入图像指定列区域内每行数据累加和
* SINT16 *pnPrjMax -- 输入图像指定列区域内每行数据累加的最大值
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_Project_Vertical(UINT16 *pSrc, SINT16 nWidth, SINT16 nHeight,
SINT16 *pnProject, SINT16 nXStart, SINT16 nXEnd, SINT16 *pnPrjMax)
{
SINT16 i, j;
SINT16 nLineStart;
SINT16 nSum;
//初始化
*pnPrjMax = 0;
memset(pnProject, 0, nHeight*sizeof(SINT16));
//预防出错
nXStart = MAX(0, MIN(nXStart, nWidth - 1));
nXEnd = MAX(0, MIN(nXEnd, nWidth - 1));
if (nXStart > nXEnd)
{
return;
}
//计算每一列的投影
for (i = 0; i < nHeight; i++)
{
//初始化
nSum = 0;
nLineStart = i * nWidth;
//遍历第i列图像，进行像素值累加
for (j = nXStart; j <= nXEnd; j++)
{
pnProject[i] += pSrc[nLineStart+j];
}
//统计垂直投影最大值
*pnPrjMax = MAX(*pnPrjMax, pnProject[i]);
}
}
/**********************************************************
* 函数名称：IMGO_CalcImgHistY16()
* 功能描述：统计直方图 - Y16图像
* 输入参数：UINT16 *pSrc -- 输入图像
* SINT32 nWidth -- 图像宽度
* SINT32 nHeight -- 图像高度
* SINT32 nMoveBit -- 移位位数
* 输出参数：SINT32 *pnHist -- 图像直方图
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_CalcImgHistY16(UINT16 *pSrc, SINT32 nWidth, SINT32 nHeight,
SINT32 nMoveBit, SINT32 *pnHist)
{
SINT32 i;
SINT32 nLen = nWidth * nHeight;
SINT32 nMoveBitAbs = ABS(nMoveBit);
//左移nMoveBit位
if (nMoveBit > 0)
{
for (i = 0; i < nLen; i++)
{
pnHist[pSrc[i] >> nMoveBitAbs]++;
}
}
//右移nMoveBit位
else if (nMoveBit > 0)
{
for (i = 0; i < nLen; i++)
{
pnHist[pSrc[i] << nMoveBitAbs]++;
}
}
//不移位
else
{
for (i = 0; i < nLen; i++)
{
pnHist[pSrc[i]]++;
}
}
}
/**********************************************************
* 函数名称：IMGO_CalcImgHistInRectY16()
* 功能描述：统计矩形区域内的直方图 - Y16图像
* 输入参数：UINT16 *pSrc -- 输入图像
* SINT32 nWidth -- 图像宽度
* SINT32 nHeight -- 图像高度
* MINMAXRECT32S *pmrnRect -- 矩形区域
* SINT32 nMoveBit -- 移位位数
* 输出参数：SINT32 *pnHist -- 图像直方图
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_CalcImgHistInRectY16(UINT16 *pSrc, SINT32 nWidth, SINT32 nHeight,
MINMAXRECT32S *pmrnRect, SINT32 nMoveBit, SINT32 *pnHist)
{
SINT32 i, j;
SINT32 nLine = pmrnRect->minY * nWidth;
SINT32 nMoveBitAbs = ABS(nMoveBit);
//右移nMoveBit位
if (nMoveBit > 0)
{
for (i = pmrnRect->minY; i <= pmrnRect->maxY; i++)
{
for (j = pmrnRect->minX; j <= pmrnRect->maxX; j++)
{
pnHist[pSrc[nLine + j] >> nMoveBitAbs]++;
}
nLine += nWidth;
}
}
//左移nMoveBit位
else if (nMoveBit < 0)
{
for (i = pmrnRect->minY; i <= pmrnRect->maxY; i++)
{
for (j = pmrnRect->minX; j <= pmrnRect->maxX; j++)
{
pnHist[pSrc[nLine + j] << nMoveBitAbs]++;
}
nLine += nWidth;
}
}
//不移位
else
{
for (i = pmrnRect->minY; i <= pmrnRect->maxY; i++)
{
for (j = pmrnRect->minX; j <= pmrnRect->maxX; j++)
{
pnHist[pSrc[nLine + j]]++;
}
nLine += nWidth;
}
}
}
/**********************************************************
* 函数名称：IMGO_IsPoint16SOutImg()
* 功能描述：判断坐标点是否超出图像边界 - POINT16S
* 输入参数：POINT16S ptPnt -- 坐标点
* SINT32 nWidth -- 图像宽度
* SINT32 nHeight -- 图像高度
* 输出参数：1-坐标点超出图像边界，0-未超出图像边界。
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
BBOOL IMGO_IsPoint16SOutImg(SINT32 nWidth, SINT32 nHeight, POINT16S ptPnt)
{
// 20171114zy：目标在图像边界时，则认为目标不在视场，作为情况管道的一种条件
SINT32 nBorderR = 10;
if ((ptPnt.x < nBorderR) || (nWidth - nBorderR <= ptPnt.x)
|| (ptPnt.y < nBorderR) || (nHeight - nBorderR <= ptPnt.y))
{
return TRUE;
}
else
{
return FALSE;
}
}
/**********************************************************
* 函数名称：IMGO_IsPoint32FOutImg()
* 功能描述：判断坐标点是否超出图像边界 - POINT32F
* 输入参数：POINT32F ptPnt -- 坐标点
* SINT32 nWidth -- 图像宽度
* SINT32 nHeight -- 图像高度
* 输出参数：1-坐标点超出图像边界，0-未超出图像边界。
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
BBOOL IMGO_IsPoint32FOutImg(SINT32 nWidth, SINT32 nHeight, POINT32F ptPnt)
{
if ((ptPnt.x < 0) || (nWidth <= ptPnt.x)
|| (ptPnt.y < 0) || (nHeight <= ptPnt.y))
{
return TRUE;
}
else
{
return FALSE;
}
}
/**********************************************************
* 函数名称：IMGO_IsMMRect32SOutImg()
* 功能描述：判断矩形是否超出图像边界 - MINMAXRECT32S
* 输入参数：SINT32 nWidth -- 图像宽度
* SINT32 nHeight -- 图像高度
* MINMAXRECT32S *pmrnRect -- 四边型矩形
* 输出参数：1-矩形超出图像边界，0-未超出图像边界。
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
BBOOL IMGO_IsMMRect32SOutImg(SINT32 nWidth, SINT32 nHeight, MINMAXRECT32S *pmrnRect)
{
if ((pmrnRect->minX < 0) || (nWidth <= pmrnRect->maxX)
|| (pmrnRect->minY < 0) || (nHeight <= pmrnRect->maxY))
{
return TRUE;
}
else
{
return FALSE;
}
}
/**********************************************************
* 函数名称：IMGO_CalcGradImg()
* 功能描述：计算输入图像的梯度幅值图
* 输入参数：UINT16 *pScrImg -- 输入的图像
* SINT32 nWidth -- 图像宽
* SINT32 nHeight -- 图像高
* 输出参数：UINT16 *pnMagImg -- 输出的梯度幅值矩阵
* 返 回 值：无
* 调用关系：GaussianFilterMag()
* 其它说明：使用sobel算子
* X方向: 1 0 -1 Y方向: 1 2 1
* 2 0 -2 0 0 0
* 1 0 -1 -1 -2 -1
**********************************************************/
void IMGO_CalcGradImg(UINT16 *pSrc, SINT32 nWidth, SINT32 nHeight, UINT16 *pnMagImg)
{
SINT32 i, j;
SINT32 nLen = nWidth * nHeight;
SINT32 nHStart, nHEnd; //参与梯度计算的起始行、终止行
SINT32 nWStart, nWEnd; //参与梯度计算的起始列、终止列
SINT32 nIndex; //当前像素的坐标
SINT32 nLine; //当前像素的行起始坐标
SINT32 nLinePre, nLineNext; //上侧、下侧像素的坐标
SINT32 nIndexPre, nIndexNext; //左侧、右侧像素的坐标
SINT32 nGradX, nGradY; //像素点在X、Y方向梯度
SINT32 nGradSum; //像素点的梯度方向
SINT32 nGradThresMax = 65534; //最大不超过16bit，由(UINT16 *pnMagImg)限制
SINT32 nGradThresMin = 30;
// SINT32 *pnGradX = (SINT32*)DSP_IMGO_pnGradX;
// SINT32 *pnGradY = (SINT32*)DSP_IMGO_pnGradY;
SINT32 pnGradX[2000] = {0};
SINT32 pnGradY[2000] = {0};
memset(pnGradX, 0, sizeof(SINT32) * nWidth);
memset(pnGradY, 0, sizeof(SINT32) * nWidth);
memset(pnMagImg, 0, nLen * sizeof(UINT16));
//参数设置
nHStart = 1; //序列标号,表示图像的第2行
nHEnd = nHeight - 2; //序列标号,表示图像的倒数第2行,20171110zy
nWStart = 1;
nWEnd = nWidth - 2;
//使用sobel滤波算子求梯度图像
nLine = nHStart * nWidth;
for (i = nHStart; i <= nHEnd; i++)
{
//一次性计算当前行像素所用到的X、Y方向梯度临时数据
for (j = 0; j < nWidth; j++) //20171110zy: 全图像的nWidth, 没有减2
{
//计算当前像素、上侧像素、下侧像素的坐标
nIndex = nLine + j;
nLinePre = nIndex - nWidth;
nLineNext = nIndex + nWidth;
//X方向梯度中间结果
pnGradX[j] = pSrc[nLinePre] + 2*pSrc[nIndex] + pSrc[nLineNext]; //上一行 + 2*当前行 + 下一行
pnGradY[j] = pSrc[nLinePre] - pSrc[nLineNext]; //上一行 - 下一行
}
//计算第(i,j)个像素的梯度幅值和方向
for (j = nWStart; j <= nWEnd; j++)
{
//计算当前像素、上侧像素、下侧像素的坐标
nIndex = nLine + j;
nIndexPre = j - 1;
nIndexNext = j + 1;
//计算X、Y方向梯度值
nGradX = pnGradX[nIndexPre] - pnGradX[nIndexNext]; //公式中的第1列 - 第3列
nGradY = pnGradY[nIndexPre] + 2*pnGradY[j] + pnGradY[nIndexNext]; //公式中的第1行 - 第3行
//计算梯度幅值
nGradSum = MIN(ABS(nGradX) + ABS(nGradY), nGradThresMax); //【处理16位数据时需调整】
//剔除弱梯度杂波
if (nGradSum < nGradThresMin)
{
pnMagImg[nIndex] = 0;
}
else
{
pnMagImg[nIndex] = (UINT16)(nGradSum); //取X、Y方向梯度绝对值和作为该点的梯度幅值
}
}
//更新下一行起始坐标
nLine += nWidth;
}//end of for (i = nHStart; i <= nHEnd; i++)...
}
/**********************************************************
* 函数名称：IMGO_CalcIntegralImg()
* 功能描述：计算积分图(integral image, 简写IntImg)
* 输入参数：UINT16 *pFrame -- 输入图像
* SIZE32S sImgSize -- 图像尺寸
* SIZE32S sIntImgSize -- 积分图尺寸
* 输出参数：SINT32 *pnIntImg -- 积分图
* 返 回 值：无
* 调用关系：无
* 其它说明：设输入图像f，积分图g（其中g比f的上侧、左侧分别多补1行和1列0）。
* g(i,j)的积分值，等于以f(0,0)、f(i,j)点所成矩形内像素值累加和。
* 其中：0 <= i <= sImgSize.h, 0 <= j <= sImgSize.w。
* 计算方式：
* 1）初始化第0行、第0列像素的积分值为0：
* g(0,j) = 0;
* g(i,0) = 0;
* 2）计算第i = (1 ~ sImgSize.h)行像素的积分值：
* A.先算当前行累加积分图：
* l(i,0) = f(i-1,0)。
* l(i,j) = l(i,j-1) + f(i-1,j)。
* B.再计算当前像素积分值：
* g(i,j) = g(i-1,j) + l(i,j)。
* 注：输入图像(i,j)点，对应于积分图像上的(i+1,j+1)点。
**********************************************************/
void IMGO_CalcIntegralImg(UINT16 *pFrame, SIZE32S sImgSize,
SINT32 *pnIntImg, SIZE32S sIntImgSize)
{
SINT32 i, j;
SINT32 nIntImgPxlSize = sIntImgSize.w * sIntImgSize.h;
SINT32 nLnSum = 0; //输入图像当前行的累加结果
UINT16 *pnPxl = NULL; //指向输入图像当前像素
SINT32 *pnIntPxl = NULL; //指向积分图当前像素
SINT32 *pnIntPxlUp = NULL; //指向积分图当前像素的上一行像素
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++
//初始化
//注：仅初始化第0行、第0列积分图，全图清零较耗时
memset(pnIntImg, 0, sizeof(SINT32) * sIntImgSize.w);
for (i = sIntImgSize.w; i < nIntImgPxlSize; i += sIntImgSize.w)
{
pnIntImg[i] = 0;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++
//计算第[0, sImgSize.h-1]行、第[0, sImgSize.h-1]列图像像素的积分值，
//分别存入第[1 ~ sImgSize.h]行、第[1, sImgSize.h]列积分图。
pnPxl = (UINT16*)pFrame;
pnIntPxl = (SINT32*)pnIntImg + sIntImgSize.w;
pnIntPxlUp = (SINT32*)pnIntImg;
for (i = 0; i < sImgSize.h; i++)
{
//初始化当前行累加结果
nLnSum = 0;
//跳过积分图第1列像素
pnIntPxl++;
pnIntPxlUp++;
//行内每个像素
for (j = 0; j < sImgSize.w; j++)
{
//对当前行图像像素值累加
nLnSum += (*pnPxl++);
//将"当前行图像累加值+上一行对应点的积分值"存入积分图
(*pnIntPxl++) = nLnSum + (*pnIntPxlUp++);
}
}
}
/**********************************************************
* 函数名称：IMGO_CalcIntegralImg()
* 功能描述：计算积分图内矩形像素和
* 输入参数：SINT32 *pnIntImg -- 积分图
* SIZE32S sIntImgSize -- 积分图尺寸
* MINMAXRECT32S mrnRect -- 四边型矩形
* 输出参数：SINT32 nRectSum -- 矩形内像素和
* 返 回 值：无
* 调用关系：无
* 其它说明：设输入图像f，积分图g（其中g比f的上侧、左侧分别多补1行和1列0）。
* g(i,j)的积分值，等于以f(0,0)、f(i,j)点所成矩形内像素值累加和。
* 1）输入图像(i,j)点，对应于积分图像上的(i+1,j+1)点。
* 因此：输入图像上的矩形ABCD，对应于积分图上的矩形abcd。
* - - - - - - - - -
* - - A - - B E - -
* - - - a - - b - -
* - - C - - D - - -
* - - F c - - d - -
* - - - - - - - - -
* 2）积分图上矩形abcd内的像素和如下计算：
* nSum = g(A) - g(E) - g(F) + g(d)
**********************************************************/
SINT32 IMGO_CalcIntegralInMMRect(SINT32 *pnIntImg, SIZE32S sIntImgSize, MINMAXRECT32S mrnRect)
{
SINT32 nRectSum = 0; //矩形内像素值累加和
MINMAXRECT32S mrnRectInt; //积分图内矩形
SINT32 nLineMin; //起始行坐标
SINT32 nLineMax; //结束行坐标
//将矩形坐标从原始图像映射到积分图上
mrnRectInt = mrnRect;
mrnRectInt.maxX += 1;
mrnRectInt.maxY += 1;
//统计矩形内像素和
nLineMin = mrnRectInt.minY * sIntImgSize.w;
nLineMax = mrnRectInt.maxY * sIntImgSize.w;
nRectSum = pnIntImg[nLineMin + mrnRectInt.minX]
- pnIntImg[nLineMin + mrnRectInt.maxX]
- pnIntImg[nLineMax + mrnRectInt.minX]
+ pnIntImg[nLineMax + mrnRectInt.maxX];
return nRectSum;
}
FLOAT32 IMGO_RectOverlap(RECT32S *prtA, RECT32S *prtB)
{
if (prtA->x > prtB->x+prtB->w) { return 0.0; }
if (prtA->y > prtB->y+prtB->h) { return 0.0; }
if (prtB->x > prtA->x+prtA->w) { return 0.0; }
if (prtB->y > prtA->y+prtA->h) { return 0.0; }
FLOAT32 colInt = MIN(prtA->x+prtA->w-1, prtB->x+prtB->w-1) - MAX(prtA->x, prtB->x) + 1.0f;
FLOAT32 rowInt = MIN(prtA->y+prtA->h-1, prtB->y+prtB->h-1) - MAX(prtA->y, prtB->y) + 1.0f;
FLOAT32 intersection = colInt * rowInt;
SINT32 area1 = prtA->w * prtA->h;
SINT32 area2 = prtB->w * prtB->h;
return intersection / (area1 + area2 - intersection);
}
/**********************************************************
* 函数名称：IMGO_CalculateMeanSquared()
* 功能描述：计算输入图像的均值、灰度和、灰度平方和
* 输入参数：UINT16 *pSrc -- 输入原始图像
* SINT32 nLen -- 图像尺寸
* 输出参数：FLOAT32 *Mean -- 图像均值
* FLOAT32 *Sum -- 图像灰度和
* FLOAT32 *SquaredSum -- 图像灰度平方和
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_CalculateMeanSquared(UINT16 *pSrc, SINT32 nLen, FLOAT32 *fMean,
FLOAT32 *fSum, DOUBLE64 *fSquaredSum)
{
double pixelvalue;
double dSum = 0.0;
double dSquaredSum = 0.0;
double dMean = 0.0;
SINT32 i;
for (i = 0; i < nLen; i++)
{
pixelvalue = (double)pSrc[i];
dSum += pixelvalue;
//dSquaredSum += pixelvalue*pixelvalue;
}
dMean = dSum / nLen;
*fMean = (FLOAT32)dMean;
*fSum = (FLOAT32)dSum;
for (i = 0; i < nLen; i++)
{
pixelvalue = (double)pSrc[i];
dSquaredSum += (pixelvalue ) * (pixelvalue);
}
*fSquaredSum= (FLOAT32)dSquaredSum;
}
SINT32 FindMinOfFour(SINT32 *pa)
{
SINT32 min1 = 0;
SINT32 min2 = 0;
SINT32 min = 0;
if (pa[0] < pa[1])
{
min1 = pa[0];
}
else
{
min1 = pa[1];
}
if (pa[2] < pa[3])
{
min2 = pa[2];
}
else
{
min2 = pa[3];
}
if (min1 < min2)
{
min = min1;
}
else
{
min = min2;
}
return min;
}
SINT32 FindMaxOfFour(SINT32 *pa)
{
SINT32 max1 = 0;
SINT32 max2 = 0;
SINT32 max = 0;
if (pa[0] > pa[1])
{
max1 = pa[0];
}
else
{
max1 = pa[1];
}
if (pa[2] > pa[3])
{
max2 = pa[2];
}
else
{
max2 = pa[3];
}
if (max1 > max2)
{
max = max1;
}
else
{
max = max2;
}
return max;
}
/**********************************************************
* 函数名称：IMGO_GcABCLin()
* 功能描述：线性自动亮度对比度
* 输入参数：UINT16 *pSrc -- 原始图像
* SINT32 nLen -- 图像尺寸
* 输出参数：UBYTE8 *pDst -- 处理后图像，调光后
* 返 回 值：无
* 调用关系：无
* 其它说明：无
**********************************************************/
void IMGO_GcABCLin(UINT16 *pSrc, UBYTE8 *pDst, SINT32 nLen)
{
SINT32 i;
//SINT32 nContrast;
//SINT32 nBright;
SINT32 nSigma;
SINT32 nSum;
SINT32 nMin;
SINT32 nMax;
SINT32 nMid;
SINT32 nValue;
FLOAT32 K;
FLOAT32 C;
SINT32 *pHist = new SINT32[65536];
UINT16 *pSrcUINT16 = new UINT16[nLen]; //20180122，注意pSrc更改为有符号型
//20180122
for (i = 0; i < nLen; i++)
{
pSrcUINT16[i] = (UINT16)(pSrc[i] + 32768);
}
//统计直方图
memset((void*)pHist, 0, 65536 * sizeof(SINT32));
for (i = 0; i < nLen; i++)
{
//pHist[pSrc[i]]++;
pHist[pSrcUINT16[i]]++;//20180122
}
//求映射的最大最小值
nSigma = (SINT32)(0.05 * nLen); //设置高低端抛点数
nSum = 0;
nMin = 0;
nMax = 0;
for (i = 0; i < 65536; i++)
{
nSum += pHist[i];
if (nSum >= nSigma)
{
nMin = i;
break;
}
}
nSum = 0;
for (i = 65535; i >= 0; i--)
{
nSum += pHist[i];
if (nSum >= nSigma)
{
nMax = i;
break;
}
}
//计算对比度、亮度
//K = (FLOAT32)(256.0 / (nMax-nMin+1));
//C = (FLOAT32)(-K * nMin);
//K = (FLOAT32)((226.0 - 30) / (nMax-nMin+1));
//C = (FLOAT32)(128 - K * (nMin + nMax) / 2);
SINT32 nBrightMean = 118;
SINT32 nB = 50;
K = (FLOAT32)(200.f / (nMax - nMin + nB));
C = (FLOAT32)(nBrightMean - K * (nMin + nMax) / 2);
//设置对比度上限，若超出上限，重新计算亮度
if (K > 1.8)
{
K = 1.8f;
nSigma = (SINT32)(0.5 * nLen); //设置高低端抛点数
nSum = 0;
nMid = 0;
//求映射的中值
for (i = 0; i < 65536; i++)
{
nSum += pHist[i];
if (nSum >= nSigma)
{
nMid = i;
break;
}
}
//C = (FLOAT32)(128 - K * nMid);
C = (FLOAT32)(nBrightMean - K * nMid);
}
for (i = 0; i < nLen; i++)
{
//nValue = (SINT32)(K * pSrc[i] + C);
nValue = (SINT32)(K * pSrcUINT16[i] + C);//20180122
if (nValue < 0)
{
pDst[i] = 0;
}
else if (nValue > 255)
{
pDst[i] = 255;
}
else
{
pDst[i] = (BYTE8)nValue;
}
}
delete []pHist;
delete []pSrcUINT16;
}
/****************************************************
* 函数名称：getAngleVectors
* 功能描述：计算两个向量的夹角
* 输入参数：ANGLE32F fAngleVector1, ANGLE32F fAngleVector2
* 输出参数：FLOAT32 fAngle
* 返 回 值：
* 调用关系：
* 其它说明：
*****************************************************/
FLOAT32 getAngleVectors(ANGLE32F fAngleVector1, ANGLE32F fAngleVector2)
{
FLOAT32 fAngle = 0.0;
//提前计算公式中的向量分量
FLOAT32 fVector1OffsetX = fAngleVector1.fAz;
FLOAT32 fVector1OffsetY = fAngleVector1.fPt;
FLOAT32 fVector2OffsetX = fAngleVector2.fAz;
FLOAT32 fVector2OffsetY = fAngleVector2.fPt;
FLOAT32 fVector1Offset1Sqr = fVector1OffsetX * fVector1OffsetX + fVector1OffsetY * fVector1OffsetY;
FLOAT32 fVector2Offset2Sqr = fVector2OffsetX * fVector2OffsetX + fVector2OffsetY * fVector2OffsetY;
if (fVector1Offset1Sqr < 1e-8 || fVector2Offset2Sqr < 1e-8)
{
return 0.0;
}
fAngle = FLOAT32((fVector1OffsetX * fVector2OffsetX + fVector1OffsetY * fVector2OffsetY)
/ sqrt(fVector1Offset1Sqr * fVector2Offset2Sqr));
return FLOAT32(acos(fAngle) * 57.2957795785f);
}
/****************************************************
* 函数名称：IMGO_RotateImg
* 功能描述：图像旋转并截取中心图像块
* 输入参数：UINT16 *pSrc -- 原始图像
SINT32 nWidth -- pSrc尺寸
FLOAT32 fAngle -- 图像旋转角度（dyt横滚）
SINT32 nDstW -- pDst尺寸
SINT32 nDstH
* 输出参数：UINT16 *pDst
* 返 回 值：无
* 调用关系：
* 其它说明：如果nDstW*nDstH 任意角度旋转都在
nWidth*nHeight包络内，不需要考虑边界；
比如300*300旋转一定在450*450范围内
*****************************************************/
void IMGO_RotateImg(UINT16 *pSrc, SINT32 nWidth, SINT32 nHeight, FLOAT32 fAngle,
UINT16 *pDst,SINT32 nDstW, SINT32 nDstH)
{
SINT32 i, j;
FLOAT32 cosa, sina;
FLOAT32 u, v;
SINT32 px0, py0, px1, py1;
cosa = FLOAT32(cos(fAngle/180*PI));
sina = FLOAT32(sin(fAngle/180*PI));
for (i = 0; i < nDstH; i++)
{
for (j = 0; j < nDstW; j++)
{
//水平坐标
float y = FLOAT32(nDstH/2 - i);
float x = FLOAT32(j - nDstW/2);
//旋转
float y1 = cosa * y - sina * x;
float x1 = cosa * x + sina * y;
//图像坐标
y1 = nHeight/2 - y1;
x1 += nWidth/2;
//越界处理
//y1 = MINMAX_NUM(y1, 0, nHeight-2);
//x1 = MINMAX_NUM(x1, 0, nWidth-2);
u = x1 - SINT32(x1);
v = y1 - SINT32(y1);
px0 = (SINT32)x1;
py0 = (SINT32)y1;
px1 = px0+1;
py1 = py0+1;
//对x1,y1进行双线性插值
pDst[i*nDstW + j] = UINT16(pSrc[nWidth * py0+ px0] * (1-u)*(1-v)
+ pSrc[nWidth * py0+ px1] * u * (1-v)
+ pSrc[nWidth * py1+ px0] * (1-u) * v
+ pSrc[nWidth * py1+ px1] * u * v);
}
}
}
// 截取图像块，越界部分复制填充
void IMGO_GDSGetSubRect_FILLIN(UINT16 *pSrc, UINT16 *pDst, SINT16 nWidth, SINT16 nHeight, RECT32S rRect)
{
SINT32 i, j, x, y;
SINT32 nCounter = 0;
//截取区完全位于图像内
if (rRect.x >= 0 && rRect.y >= 0 && (rRect.x + rRect.w) <= nWidth && (rRect.y + rRect.h)<= nHeight)
{
IMGO_GDSGetSubRect(pSrc, pDst, nWidth, nHeight, rRect);
return;
}
//边界限制，复制填充
for (i = 0; i < rRect.h; i++)
{
for (j = 0; j < rRect.w; j++)
{
x = MINMAX_NUM(j+rRect.x, 0, nWidth-1);
y = MINMAX_NUM(i+rRect.y, 0, nHeight-2);//？
pDst[nCounter++] = pSrc[y * nWidth+x];
}
}
}
/*****************************函数功能*****************************
计算目标的平均信息熵
------------------------输入参数------------------------
pSrc： 输入图像
detectedTarget： 检测目标点信息
inbox_size： 保护框内框大小
outbox_size： 保护框外框大小
-----------------------输出参数-------------------------
返回值
*********************************************************************/
#define SO_TGINBOXSIZE 10
#define DST_OBJ_EntropyHist 256
DOUBLE64 SO_CalcuTargetEntropy(UINT16* pSrc, TARGET_OBJECT* detectedTarget ,SINT32 nWidth, SINT32 nHeight,
SINT32 inbox_size, SINT32 outbox_size,DOUBLE64 K,DOUBLE64 C)// DETECTEDTARGET//检测到的目标结果
{
DOUBLE64 Sx = detectedTarget->pfCenPos.x;
DOUBLE64 Sy = detectedTarget->pfCenPos.y;
//20210820yy,边界保护
if (Sx < outbox_size/2 || ABS(nWidth - Sx) < outbox_size/2 ||
Sy < outbox_size/2 || ABS(nHeight - Sy) < outbox_size/2)
{
return 0;
}
SINT32 ROW = nHeight;
SINT32 COL = nWidth;
//----------------------对中心点进行3*3均值滤波，剔除坏点（坏点值对信息熵影响大）---------------------
SINT32 istart ,iend;
SINT32 jstart ,jend;
SINT32 centerX ,centerY;
SINT32 i,j;
istart = MAX(0, (SINT32)Sy - 1);
jstart = MAX(0, (SINT32)Sx - 1);
iend = MIN(nHeight - 1, (SINT32)Sy + 1);
jend = MIN(nWidth - 1, (SINT32)Sx + 1);
SINT16 len = (iend - istart + 1)*(jend - jstart + 1) - 1;
UINT32 Sum = 0;
for (i = istart; i<= iend; ++i)
{
for (j = jstart; j<=jend;++j)
{
Sum += pSrc[i*COL+j];
}
}
Sum -= pSrc[(SINT32)Sy*COL+(SINT32)Sx];
Sum = Sum / len;
pSrc[(SINT32)Sy*COL+(SINT32)Sx] = Sum;
istart =(SINT32)((Sy < outbox_size/2)? 0:Sy - outbox_size/2);
iend = (SINT32)((istart == 0)? outbox_size:Sy + outbox_size/2);
if (iend > ROW )
{
iend = ROW;
istart = ROW -outbox_size;
}
jstart = SINT32((Sx < outbox_size/2)? 0:Sx - outbox_size/2);
jend = SINT32((jstart == 0)? outbox_size:Sx + outbox_size/2);
if (jend > COL)
{
jend = COL;
jstart = COL - outbox_size;
}
centerX = (SINT32)(jstart + jend)/2;//检测框区域的中心点
centerY = (SINT32)(istart + iend)/2;
DOUBLE64 EntropyArray[SO_TGINBOXSIZE][SO_TGINBOXSIZE];//内框点的信息熵矩阵
for (i = 0 ;i < SO_TGINBOXSIZE; i++)
{
memset(EntropyArray[i] ,0 ,SO_TGINBOXSIZE*sizeof(DOUBLE64));//对二位数组初始化
}
//DOUBLE64 *EntropyArray = (DOUBLE64*)DSP_DST_EntropyArray;//滑窗区域的直方图矩阵
//memset(EntropyArray, 0, SO_TGINBOXSIZE*SO_TGINBOXSIZE * sizeof(DOUBLE64));//直方图初始化
SINT32 M = SINT32(floor((DOUBLE64)(outbox_size - inbox_size)/4));//尺寸数
SINT32 N = SINT32(floor((DOUBLE64)(outbox_size - inbox_size)/4));
//去除求信息熵区域灰度最大值和最小值，防止坏点影响信息熵计算20190310qxj
UINT16 tempMaxValue = 0;
POINT16S MaxValueIndex;
MaxValueIndex.x = 0;
MaxValueIndex.y = 0;
UINT16 tempMinValue = 65535;
POINT16S MinValueIndex;
MinValueIndex.x = 0;
MinValueIndex.y = 0;
for (i = centerY - inbox_size/2;i < centerY + inbox_size/2 ; i++)
{
for ( j = centerX - inbox_size/2;j < centerX + inbox_size/2 ; j++)
{
UINT16 tempValue = pSrc[i*COL+j];
if (tempValue > tempMaxValue)
{
tempMaxValue = tempValue;
MaxValueIndex.x = j;
MaxValueIndex.y = i;
}
if (tempValue < tempMinValue)
{
tempMinValue = tempValue;
MinValueIndex.x = j;
MinValueIndex.y = i;
}
}
}
if ((MaxValueIndex.x > 10)&&(MaxValueIndex.x < nWidth-10)
&&(MaxValueIndex.y > 10)&&(MaxValueIndex.y < nHeight-10))
{
pSrc[MaxValueIndex.y*COL+MaxValueIndex.x] = pSrc[MaxValueIndex.y*COL+MaxValueIndex.x + 1];
}
if ((MinValueIndex.x > 10)&&(MinValueIndex.x < nWidth-10)
&&(MinValueIndex.y > 10)&&(MinValueIndex.y < nHeight-10))
{
pSrc[MinValueIndex.y*COL + MinValueIndex.x] = pSrc[MinValueIndex.y*COL + MinValueIndex.x + 1];
}
//--------------------------------------------------------------------------------
DOUBLE64 PixelNum = (2*M+1)*(2*N+1);//滑窗内的像素个数计数
DOUBLE64 DSP_DST_TgEntropyHist[DST_OBJ_EntropyHist] = {0}; //DST: 目标信息熵
//DOUBLE64 DSP_DST_BgEntropyHist[DST_OBJ_EntropyHist] = {0}; //DST: 背景信息熵
DOUBLE64 *EntropyHist = (DOUBLE64*)DSP_DST_TgEntropyHist;//滑窗区域的直方图矩阵
SINT32 MaxValue = 0;
SINT32 MinValue = 255;
for (i = centerY - inbox_size/2;i < centerY + inbox_size/2 ; i++)
{
for ( j = centerX - inbox_size/2;j < centerX + inbox_size/2 ; j++)
{
//DOUBLE64 EntropyHist[256];//滑窗区域的直方图矩阵
//memset(EntropyHist ,0 ,256*sizeof(DOUBLE64));//直方图初始化
memset(EntropyHist, 0, DST_OBJ_EntropyHist * sizeof(DOUBLE64));//直方图初始化
MaxValue = 0;
MinValue = 255;
//计算以目标点为中心的局部M*N范围直方图
SINT32 p,q;
for (p = i - M ;p <=i + M; p++)
{
for (q = j - N;q <= j + N;q++)
{
SINT32 PixValue = (SINT32)(K*pSrc[p*COL+q] + C);// 调光??
if (PixValue < 0 )
{
PixValue = 0;
}
if (PixValue > 255)
{
PixValue = 255;
}
if (MaxValue < PixValue)
{
MaxValue = PixValue;
}
if (MinValue > PixValue)
{
MinValue = PixValue;
}
EntropyHist[PixValue] += 1;//直方图统计
//PixelNum++;
}
}
SINT32 g = i - ( centerY - inbox_size/2);
SINT32 h = j - ( centerX - inbox_size/2);
for (p = MinValue;p <=MaxValue; p++)
{
if (EntropyHist[p] != 0)
{
EntropyHist[p] = EntropyHist[p]/PixelNum;//不同灰度等级的概率密度（灰度级p的像素个数与区域总像素的比）
SINT32 CurrentPixValue = (SINT32)(K*pSrc[i*COL+j] + C);//调光
if (CurrentPixValue < 0 )
{
CurrentPixValue = 0;
}
if (CurrentPixValue > 255)
{
CurrentPixValue = 255;
}
EntropyArray[g][h] += pow((DOUBLE64)(p - CurrentPixValue) ,2) * EntropyHist[p] *log10((DOUBLE64)1/EntropyHist[p])/log10(2.0);
}
}
}
}
DOUBLE64 targetEntropy = 0; //所求目标点的信息熵
SINT32 entropyPixelNum = 0; //内框的像素总个数
for (i = 0;i < inbox_size ;i++)
{
for (j = 0;j < inbox_size ;j++)
{
if (EntropyArray[i][j] > 0.000001)//进度判断，求得的信息熵大于0.000001均视为有效，可参与计算
{
entropyPixelNum++;
}
targetEntropy += EntropyArray[i][j];//统计区域内所有点的信息熵和
}
}
targetEntropy = targetEntropy/(inbox_size * inbox_size);//将区域内所有点的信息熵求均值赋给当前点
targetEntropy = MAX(1.0,targetEntropy);
return targetEntropy;
}
/*****************************函数功能*****************************
计算背景的平均信息熵
------------------------输入参数------------------------
pSrc： 输入图像
diffImage： 输入差分图
inbox_size： 保护框内框大小
outbox_size： 保护框外框大小
-----------------------输出参数-------------------------
detectedTarget
*********************************************************************/
DOUBLE64 SO_CalcuBackGroundEntropy(UINT16* pSrc, TARGET_OBJECT* detectedTarget ,SINT32 nWidth, SINT32 nHeight,
SINT32 inbox_size, SINT32 outbox_size,DOUBLE64 K,DOUBLE64 C)
{
DOUBLE64 Sx = detectedTarget->pfCenPos.x;
DOUBLE64 Sy = detectedTarget->pfCenPos.y;
//20210820yy,边界保护
if (Sx < outbox_size/2 || ABS(nWidth - Sx) < outbox_size/2 ||
Sy < outbox_size/2 || ABS(nHeight - Sy) < outbox_size/2)
{
return 0;
}
SINT32 ROW = nHeight;
SINT32 COL = nWidth;
SINT32 istart ,iend;
SINT32 jstart ,jend;
SINT32 centerX ,centerY;
SINT32 i,j;
//DOUBLE64 EntropyHist[256];//直方图统计矩阵
//memset(EntropyHist,0,256*sizeof(DOUBLE64));
DOUBLE64 DSP_DST_BgEntropyHist[DST_OBJ_EntropyHist] = {0}; //DST: 背景信息熵
DOUBLE64 *EntropyHist = (DOUBLE64*)DSP_DST_BgEntropyHist;//滑窗区域的直方图矩阵
memset(EntropyHist, 0, DST_OBJ_EntropyHist * sizeof(DOUBLE64));//直方图初始化
SINT32 EntropyPixelNum = 0;//像素个数
DOUBLE64 backgroundEntropy = 0;
//确定外框的位置，防止出边界
istart = (SINT32)((Sy < outbox_size)? 0:Sy - outbox_size/2);
iend = (SINT32)((istart == 0)? outbox_size:Sy + outbox_size/2);
if (iend > ROW )
{
iend = ROW;
istart = ROW -outbox_size;
}
jstart = SINT32((Sx < outbox_size)? 0:Sx - outbox_size/2);
jend = SINT32((jstart == 0)? outbox_size:Sx + outbox_size/2);
if (jend > COL)
{
jend = COL;
jstart = COL - outbox_size;
}
centerX = (SINT32)(jstart + jend)/2;//检测框区域的中心点
centerY = (SINT32)(istart + iend)/2;
// FLOAT32 g_GLB_STH_coeffK = (FLOAT32)256 / (pixelValueMax - pixelValueMin + 1); //老版本调光
// FLOAT32 g_GLB_STH_coeffC = (FLOAT32)-Ratio_K1*pixelValueMin;
for (i = istart;i < iend ; i++)
{
for ( j = jstart;j < jend ; j++)
{
if ( i < centerY + inbox_size/2 && i > centerY - inbox_size/2 && j > centerX -inbox_size/2 && j < centerX + inbox_size/2)
{
continue;
}
SINT32 PixelValue = (SINT32)(K*pSrc[i*COL+j] + C);//2位图？16位图
if (PixelValue < 0)
{
PixelValue = 0;
}
if (PixelValue > 255)
{
PixelValue = 255;
}
EntropyHist[PixelValue] +=1;
EntropyPixelNum++;
}
}
for (i = 0;i < 256;i++)
{
EntropyHist[i] = EntropyHist[i]/EntropyPixelNum;//不同灰度等级的概率密度
if (EntropyHist[i] > 0.0001f)
{
backgroundEntropy += EntropyHist[i]*log10(1.0/EntropyHist[i])/log10(2.0);
}
}
backgroundEntropy = MAX(0.01, backgroundEntropy);
return backgroundEntropy;
}
bool Bicubic(unsigned short* src, int iSrcWidth, int iSrcHeight, unsigned short* dst, int iDstWidth, int iDstHeight)
{
int i = 0;
float scale_y = (float)iSrcHeight / iDstHeight;
float scale_x = (float)iSrcWidth / iDstWidth;
int dx, dy;
for (dy = 0; dy < iDstHeight; dy++)
{
for (dx = 0; dx < iDstWidth; dx++)
{
double sx, sy;//小数部分
int sxi, syi;//整数部分
sy = (dy)*scale_y;
syi = FLOOR(sy);//取整
sy -= syi; //小数部分
syi = MAX(1, syi);
syi = MIN((iSrcHeight - 3), syi);
// sy-=syi; //小数部分
sx = (dx)*scale_x;
sxi = FLOOR(sx);//取整
sx -= sxi; //小数部分
sxi = MAX(1, sxi);
sxi = MIN((iSrcWidth - 3), sxi);
//sx-= sxi; //小数部分
//16邻域模板
int temp[4][4] = { 0 };
temp[0][0] = src[(syi - 1) * iSrcWidth + sxi - 1];
temp[0][1] = src[(syi - 1) * iSrcWidth + sxi];
temp[0][2] = src[(syi - 1) * iSrcWidth + sxi + 1];
temp[0][3] = src[(syi - 1) * iSrcWidth + sxi + 2];
temp[1][0] = src[syi * iSrcWidth + sxi - 1];
temp[1][1] = src[syi * iSrcWidth + sxi];
temp[1][2] = src[syi * iSrcWidth + sxi + 1];
temp[1][3] = src[syi * iSrcWidth + sxi + 2];
temp[2][0] = src[(syi + 1) * iSrcWidth + sxi - 1];
temp[2][1] = src[(syi + 1) * iSrcWidth + sxi];
temp[2][2] = src[(syi + 1) * iSrcWidth + sxi + 1];
temp[2][3] = src[(syi + 1) * iSrcWidth + sxi + 2];
temp[3][0] = src[(syi + 2) * iSrcWidth + sxi - 1];
temp[3][1] = src[(syi + 2) * iSrcWidth + sxi];
temp[3][2] = src[(syi + 2) * iSrcWidth + sxi + 1];
temp[3][3] = src[(syi + 2) * iSrcWidth + sxi + 2];
double TA[4] = { 1.0,0.0,-1.0,-2.0 };
double TD[4] = { 1.0,0.0,-1.0,-2.0 };
double A[4] = { 0.0 };
double D[4] = { 0.0 };
//double temp(0.0);
for (i = 0; i < 4; i++)
{
A[i] = fabs((sy + TA[i]));
if (A[i] >= 0 && A[i] < 1)
{
A[i] = ICV_CUBIC_1(A[i]);//p3*A[i]*A[i]*A[i]+p2*A[i]*A[i]+p0;
}
else if (A[i] >= 1 && A[i] < 2)
{
/*temp = A[i];*/
A[i] = ICV_CUBIC_2(A[i]);//q3*A[i]*A[i]*A[i]+q2*A[i]*A[i]+q1*A[i]+q0;
}
else
A[i] = 0;
D[i] = fabs((sx + TD[i]));
if (D[i] >= 0 && D[i] < 1)
{
D[i] = ICV_CUBIC_1(D[i]);//p3*D[i]*D[i]*D[i]+p2*D[i]*D[i]+p0;
}
else if (D[i] >= 1 && D[i] < 2)
{
D[i] = ICV_CUBIC_2(D[i]);//q3*D[i]*D[i]*D[i]+q2*D[i]*D[i]+q1*D[i]+q0;
}
else
D[i] = 0;
}
double value[4] = { 0.0 };
int v = 0;
for (i = 0; i < 4; i++)
{
value[i] = A[0] * temp[0][i] + A[1] * temp[1][i] + A[2] * temp[2][i] + A[3] * temp[3][i];
}
v = (int)(value[0] * D[0] + value[1] * D[1] + value[2] * D[2] + value[3] * D[3] + 0.5);
if (v > 255)
{
dst[dy * iDstWidth + dx] = 255;
}
else if (v < 0)
{
dst[dy * iDstWidth + dx] = 0;
}
else
{
dst[dy * iDstWidth + dx] = v;
}
}
}
return 1;
}
/**********************************************************
* 函数名称：IMGO_CalcSqSumImg()
* 功能描述：计算积分图同时计算平方积分
* 输入参数：PIXELTYPE *pnFrame -- 输入图像
* SIZE32S snImgSize -- 图像尺寸
* 输出参数：SINT32 *pnIntImg -- 积分图
DOUBLE64 *pdSqImg -- 平方积分图
* 返 回 值：无
* 调用关系：无
* 其它说明：同IMGO_CalcIntegralImg
**********************************************************/
void IMGO_CalcSqSumImg(UINT16* pnFrame, SIZE32S snImgSize,
UINT32* pnIntImg, DOUBLE64* pdSqImg)
{
SINT32 i, j;
SIZE32S snIntImgSize;
snIntImgSize.h = snImgSize.h + 1;
snIntImgSize.w = snImgSize.w + 1;
SINT32 nIntImgPxlSize = snIntImgSize.w * snIntImgSize.h;
UINT32 nLnSum = 0; //输入图像当前行的累加结果
DOUBLE64 nLsqSum = 0; //当前行的平方累加结果
UINT16* pnPxl = NULL; //指向输入图像当前像素
UINT32* pnIntPxl = NULL; //指向积分图当前像素
UINT32* pnIntPxlUp = NULL; //指向积分图当前像素的上一行像素
DOUBLE64* pdSqPxl = NULL;
DOUBLE64* pdSqPxlUp = NULL;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++
//初始化
//注：仅初始化第0行、第0列积分图，全图清零较耗时
memset(pnIntImg, 0, sizeof(DOUBLE64) * snIntImgSize.w);
memset(pdSqImg, 0, sizeof(DOUBLE64) * snIntImgSize.w);
for (i = snIntImgSize.w; i < nIntImgPxlSize; i += snIntImgSize.w)
{
pnIntImg[i] = 0;
pdSqImg[i] = 0;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++
//计算第[0, snImgSize.h-1]行、第[0, snImgSize.h-1]列图像像素的积分值，
//分别存入第[1 ~ snImgSize.h]行、第[1, snImgSize.h]列积分图。
pnPxl = (UINT16*)pnFrame;
pnIntPxl = (UINT32*)pnIntImg + snIntImgSize.w;
pnIntPxlUp = (UINT32*)pnIntImg;
pdSqPxl = (DOUBLE64*)pdSqImg + snIntImgSize.w;
pdSqPxlUp = (DOUBLE64*)pdSqImg;
for (i = 0; i < snImgSize.h; i++)
{
//初始化当前行累加结果
nLnSum = 0;
nLsqSum = 0;
//跳过积分图第1列像素
pnIntPxl++;
pnIntPxlUp++;
pdSqPxl++;
pdSqPxlUp++;
//行内每个像素
for (j = 0; j < snImgSize.w; j++)
{
//对当前行图像像素值累加
nLsqSum += (double)(*pnPxl) * (*pnPxl);
nLnSum += (*pnPxl++);
//将"当前行图像累加值+上一行对应点的积分值"存入积分图
*pdSqPxl++ = nLsqSum + (*pdSqPxlUp++);
(*pnIntPxl++) = nLnSum + (*pnIntPxlUp++);
}
}
}
/****************************************************
* 函数名称：IMGO_MeanFilter
* 功能描述：均值滤波
* 输入参数：PIXELTYPE *pSrc -- 原始图像
SINT32 nWidth -- 宽
SINT32 nHeight -- 高
SINT32 *pIntImg -- 积分图像
SINT32 nRadius -- 滤波半径
* 输出参数：PIXELTYPE *pDst -- 滤波图像
* 返 回 值：无
* 调用关系：
* 其它说明：边缘部分是否需要考虑?TLD用不到暂不考虑
*****************************************************/
void IMGO_MeanFilter(UINT16* pSrc, SINT32 nWidth, SINT32 nHeight, UINT32* pIntImg, SINT32 nRadius, UINT16* pDst)
{
SINT32 i, j;
SINT32 nIntWidth, nIntHeight;
SINT32 nLeftTop, nLeftBotm, nRightTop, nRightBotm, nArea;
memcpy(pDst, pSrc, sizeof(UINT16) * nWidth * nHeight);
if (nRadius < 1)
{
return;
}
nIntHeight = nHeight + 1; //积分图大小
nIntWidth = nWidth + 1;
nArea = (nRadius * 2 + 1) * (nRadius * 2 + 1); //窗口面积
for (i = nRadius; i < nHeight - nRadius; i++)
{
for (j = nRadius; j < nWidth - nRadius; j++)
{
nLeftTop = pIntImg[(i - nRadius) * nIntWidth + j - nRadius];
nLeftBotm = pIntImg[(i + nRadius + 1) * nIntWidth + j - nRadius];
nRightTop = pIntImg[(i - nRadius) * nIntWidth + j + nRadius + 1];
nRightBotm = pIntImg[(i + nRadius + 1) * nIntWidth + j + nRadius + 1];
pDst[i * nWidth + j] = (nRightBotm + nLeftTop - nLeftBotm - nRightTop) / nArea;
}
}
return;
}
/****************************************************
* 函数名称：IMGO_GetVar
* 功能描述：计算图像给定区域的方差
* 输入参数：SINT32 *pIntImg -- 积分图
DOUBLE64 *pSqIntImg -- 平方积分图
SIZE32S snImgSize -- 积分图尺寸
RECT32S rsRect -- 矩形区
* 输出参数：
* 返 回 值：rsRect区域方差
* 调用关系：
* 其它说明：
*****************************************************/
DOUBLE64 IMGO_GetVar(UINT32* pIntImg, DOUBLE64* pSqIntImg, SIZE32S snImgSize, RECT32S rsRect)
{
SINT32 w = snImgSize.w; //积分图宽度
SINT32 s = (rsRect.w - 1) * (rsRect.h - 1); //面积
POINT32S tl, tr, bl, br; //积分区域四角
FLOAT32 fMean;
DOUBLE64 dSqMean;
tl.x = rsRect.x + 1; tl.y = rsRect.y + 1;
tr.x = rsRect.x + rsRect.w; tr.y = rsRect.y + 1;
bl.x = rsRect.x + 1; bl.y = rsRect.y + rsRect.h;
br.x = rsRect.x + rsRect.w; br.y = rsRect.y + rsRect.h;
fMean = (pIntImg[tl.y * w + tl.x] + pIntImg[br.y * w + br.x] - pIntImg[tr.y * w + tr.x] - pIntImg[bl.y * w + bl.x]) / (FLOAT32)s;
dSqMean = (pSqIntImg[tl.y * w + tl.x] + pSqIntImg[br.y * w + br.x] - pSqIntImg[tr.y * w + tr.x] - pSqIntImg[bl.y * w + bl.x]) / s;
return (dSqMean - fMean * fMean);
}
//求解两目标框之间的交并比
DOUBLE64 IMGO_CalcObjIou(MINMAXRECT bb_pre, MINMAXRECT bb_Obj)
{
SINT32 x1, y1, x2, y2;
SINT32 w, h, s;
DOUBLE64 iou;
x1 = MAX(bb_pre.minX, bb_Obj.minX);
x2 = MIN(bb_pre.maxX, bb_Obj.maxX);
y1 = MAX(bb_pre.minY, bb_Obj.minY);
y2 = MIN(bb_pre.maxY, bb_Obj.maxY);
w = MAX(0, x2 - x1);
h = MAX(0, y2 - y1);
s = w * h;
iou = (DOUBLE64)s / (DOUBLE64)((bb_pre.maxX - bb_pre.minX) * (bb_pre.maxY - bb_pre.minY) + (bb_Obj.maxX - bb_Obj.minX) * (bb_Obj.maxY - bb_Obj.minY) - s);
return iou;
合入基线更新
6 months ago
}
void calculateCentroid(GD_VIDEO_FRAME_S img, OBJECTSTATUS* ObjStatus, FLOAT32 fGray)
{
int i;
int j;
DOUBLE64 sumX = 0;
DOUBLE64 sumY = 0;
DOUBLE64 count = 0;
for (i = int(ObjStatus->ptPos.y - ObjStatus->sfSize.h / 2); i < int(ObjStatus->ptPos.y + ObjStatus->sfSize.h / 2); ++i)
{
for (j = int(ObjStatus->ptPos.x - ObjStatus->sfSize.w / 2); j < int(ObjStatus->ptPos.x + ObjStatus->sfSize.w / 2); ++j)
{ // 检查像素是否在图像范围内
if (i >= 0 && i < (int)img.u32Height && j >= 0 && j < (int)img.u32Width)
{
int pixelValue = 0;
if (GD_PIXEL_FORMAT_GRAY_Y16 == img.enPixelFormat)
{
pixelValue = ((UINT16*)img.u64VirAddr[0])[i * img.u32Width + j]; // 获取像素值
}
else
{
pixelValue = 255 - ((UBYTE8*)img.u64VirAddr[0])[i * img.u32Width + j]; // 获取像素值
//fGray = 255 - fGray;
fGray = 128;
}
if (pixelValue > fGray)
{ // 如果像素值非零，累加其坐标
sumX += (DOUBLE64)j * pixelValue;
sumY += (DOUBLE64)i * pixelValue;
count += pixelValue;
}
}
}
}
if (count < 0.1)
{
ObjStatus->ptCentroid.x = -1; // 如果没有有效像素，返回-1表示无效质心
ObjStatus->ptCentroid.y = -1;
}
else
{
ObjStatus->ptCentroid.x = (FLOAT32)(sumX / count);
ObjStatus->ptCentroid.y = (FLOAT32)(sumY / count);
}
return;
S3315板端测试后状态
11 months ago
}