📄 edgecontour.cpp
字号:
// 初始化新分配的内存，设定初始值为255
lpDst = (char *)lpNewDIBBits;
memset(lpDst, (BYTE)255, lWidth * lHeight);
//计算变换域的尺寸
//最大距离
iMaxDist = (int) sqrt(lWidth*lWidth + lHeight*lHeight);
//角度从0－180，每格2度
iMaxAngleNumber = 90;
//为变换域分配内存
hTransArea = LocalAlloc(LHND, lWidth * lHeight * sizeof(int));
if (hNewDIBBits == NULL)
{
// 分配内存失败
return FALSE;
}
// 锁定内存
lpTransArea = (char * )LocalLock(hTransArea);
// 初始化新分配的内存，设定初始值为0
lpTrans = (char *)lpTransArea;
memset(lpTrans, 0, lWidth * lHeight * sizeof(int));
// 计算图像每行的字节数
lLineBytes = WIDTHBYTES(lWidth * 8);
for(j = 0; j <lHeight; j++)
{
for(i = 0;i <lWidth; i++)
{
// 指向源图像倒数第j行，第i个象素的指针
lpSrc = (char *)lpDIBBits + lLineBytes * j + i;
//取得当前指针处的像素值，注意要转换为unsigned char型
pixel = (unsigned char)*lpSrc;
//目标图像中含有0和255外的其它灰度值
if(pixel != 255 && *lpSrc != 0)
return FALSE;
//如果是黑点，则在变换域的对应各点上加1
if(pixel == 0)
{
//注意步长是2度
for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)
{
tempiDist = (int) (i*cos(iAngleNumber*2*pi/180.0) + \
j*sin(iAngleNumber*2*pi/180.0));
iDist = (int) fabs(i*cos(iAngleNumber*2*pi/180.0) + \
j*sin(iAngleNumber*2*pi/180.0));
//变换域的对应点上加1
*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber) = \
*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber) +1;
}
}
}
}
//找到变换域中的两个最大值点
MaxValue1.Value=0;
MaxValue2.Value=0;
//找到第一个最大值点
for (iDist=0; iDist<iMaxDist;iDist++)
{
for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)
{
if((int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber)>MaxValue1.Value)
{
MaxValue1.Value = (int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber);
MaxValue1.Dist = iDist;
MaxValue1.AngleNumber = iAngleNumber;
}
}
}
//将第一个最大值点附近清零
for (iDist = -9;iDist < 10;iDist++)
{
for(iAngleNumber=-1; iAngleNumber<2; iAngleNumber++)
{
if(iDist+MaxValue1.Dist>=0 && iDist+MaxValue1.Dist<iMaxDist \
&& iAngleNumber+MaxValue1.AngleNumber>=0 && iAngleNumber+MaxValue1.AngleNumber<=iMaxAngleNumber)
{
*(lpTransArea+(iDist+MaxValue1.Dist)*iMaxAngleNumber+\
(iAngleNumber+MaxValue1.AngleNumber))=0;
}
}
}
//找到第二个最大值点
for (iDist=0; iDist<iMaxDist;iDist++)
{
for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)
{
if((int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber)>MaxValue2.Value)
{
MaxValue2.Value = (int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber);
MaxValue2.Dist = iDist;
MaxValue2.AngleNumber = iAngleNumber;
}
}
}
CString strreal,strtem;
if (MaxValue1.AngleNumber*2*pi/180.0>0)
{
strreal.Format("rou=%d theta=%d\n",MaxValue1.Dist,180+2*MaxValue1.AngleNumber);
strtem.Format ("a=%f b=%f\n",tan(MaxValue1.AngleNumber*2*pi/180.0+pi/2),MaxValue1.Dist/sin((-1)*MaxValue1.AngleNumber*2*pi/180.0));
}
else
{
strreal.Format("rou=%d theta=%d\n",MaxValue1.Dist,2*MaxValue1.AngleNumber);
strtem.Format ("a=%f b=%f\n",tan(pi/2-MaxValue1.AngleNumber*2*pi/180.0),MaxValue1.Dist/sin(MaxValue1.AngleNumber*2*pi/180.0));
}
AfxMessageBox(strreal+strtem);
if (MaxValue2.AngleNumber*2*pi/180.0>0)
{
strreal.Format("rou=%d theta=%d\n",MaxValue2.Dist,2*MaxValue2.AngleNumber);
strtem.Format ("a=%f b=%f\n",tan(MaxValue2.AngleNumber*2*pi/180.0+pi/2),MaxValue2.Dist/sin(MaxValue2.AngleNumber*2*pi/180.0));
}
else
{
strreal.Format("rou=%d theta=%d\n",MaxValue2.Dist,2*MaxValue2.AngleNumber);
strtem.Format ("a=%f b=%f\n",tan(pi/2-MaxValue2.AngleNumber*2*pi/180.0),MaxValue2.Dist/sin(MaxValue2.AngleNumber*2*pi/180.0));
}
AfxMessageBox(strreal+strtem);
for(j = 0; j <lHeight; j++)
{
for(i = 0;i <lWidth; i++)
{
// 指向缓存图像倒数第j行，第i个象素的指针
lpDst = (char *)lpNewDIBBits + lLineBytes * j + i;
//如果该点在某一条直线上，则在缓存图像上将该点赋为黑
//在第一条直线上
onedist = (int) fabs(i*cos(MaxValue1.AngleNumber*2*pi/180.0) + \
j*sin(MaxValue1.AngleNumber*2*pi/180.0));
tempdist=i*cos(MaxValue1.AngleNumber*2*pi/180.0) + j*sin(MaxValue1.AngleNumber*2*pi/180.0);
if (onedist == MaxValue1.Dist)
*lpDst = (unsigned char)0;
//在第二条直线上
twodist = (int) fabs(i*cos(MaxValue2.AngleNumber*2*pi/180.0) + \
j*sin(MaxValue2.AngleNumber*2*pi/180.0));
subtempdist=i*cos(MaxValue2.AngleNumber*2*pi/180.0) + j*sin(MaxValue2.AngleNumber*2*pi/180.0);
if (twodist == MaxValue2.Dist)
*lpDst = (unsigned char)0;
}
}
// 复制腐蚀后的图像
memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
// 释放内存
LocalUnlock(hNewDIBBits);
LocalFree(hNewDIBBits);
// 释放内存
LocalUnlock(hTransArea);
LocalFree(hTransArea);
// 返回
return TRUE;
}
/*************************************************************************
*
* 函数名称：
* ThresholdDIB()
*
* 参数:
* LPSTR lpDIBBits - 指向源DIB图像指针
* LONG lWidth - 源图像宽度（象素数）
* LONG lHeight - 源图像高度（象素数）
*
* 返回值:
* BOOL - 运算成功返回TRUE，否则返回FALSE。
*
* 说明:
* 该函数用于对图像进行阈值分割运算。
*
************************************************************************/
BOOL WINAPI ThresholdDIB(LPSTR lpDIBBits,LONG lWidth, LONG lHeight)
{
// 指向源图像的指针
LPSTR lpSrc;
// 指向缓存图像的指针
LPSTR lpDst;
// 指向缓存DIB图像的指针
LPSTR lpNewDIBBits;
HLOCAL hNewDIBBits;
//循环变量
long i;
long j;
//像素值
unsigned char pixel;
//直方图数组
long lHistogram[256];
//阈值，最大灰度值与最小灰度值，两个区域的平均灰度值
unsigned char iThreshold,iNewThreshold,iMaxGrayValue,iMinGrayValue,iMean1GrayValue,iMean2GrayValue;
//用于计算区域灰度平均值的中间变量
long lP1,lP2,lS1,lS2;
//迭代次数
int iIterationTimes;
// 图像每行的字节数
LONG lLineBytes;
// 暂时分配内存，以保存新图像
hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);
if (hNewDIBBits == NULL)
{
// 分配内存失败
return FALSE;
}
// 锁定内存
lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
// 初始化新分配的内存，设定初始值为255
lpDst = (char *)lpNewDIBBits;
memset(lpDst, (BYTE)255, lWidth * lHeight);
// 计算图像每行的字节数
lLineBytes = WIDTHBYTES(lWidth * 8);
for (i = 0; i < 256;i++)
{
lHistogram[i]=0;
}
//获得直方图
iMaxGrayValue = 0;
iMinGrayValue = 255;
for (i = 0;i < lWidth ;i++)
{
for(j = 0;j < lHeight ;j++)
{
// 指向源图像倒数第j行，第i个象素的指针
lpSrc = (char *)lpDIBBits + lLineBytes * j + i;
pixel = (unsigned char)*lpSrc;
lHistogram[pixel]++;
//修改最大，最小灰度值
if(iMinGrayValue > pixel)
{
iMinGrayValue = pixel;
}
if(iMaxGrayValue < pixel)
{
iMaxGrayValue = pixel;
}
}
}
//迭代求最佳阈值
iNewThreshold = (iMinGrayValue + iMaxGrayValue)/2;
iThreshold = 0;
for(iIterationTimes = 0; iThreshold != iNewThreshold && iIterationTimes < 100;iIterationTimes ++)
{
iThreshold = iNewThreshold;
lP1 =0;
lP2 =0;
lS1 = 0;
lS2 = 0;
//求两个区域的灰度平均值
for (i = iMinGrayValue;i < iThreshold;i++)
{
lP1 += lHistogram[i]*i;
lS1 += lHistogram[i];
}
iMean1GrayValue = (unsigned char)(lP1 / lS1);
for (i = iThreshold+1;i < iMaxGrayValue;i++)
{
lP2 += lHistogram[i]*i;
lS2 += lHistogram[i];
}
iMean2GrayValue = (unsigned char)(lP2 / lS2);
iNewThreshold = (iMean1GrayValue + iMean2GrayValue)/2;
}
//根据阈值将图像二值化
for (i = 0;i < lWidth ;i++)
{
for(j = 0;j < lHeight ;j++)
{
// 指向源图像倒数第j行，第i个象素的指针
lpSrc = (char *)lpDIBBits + lLineBytes * j + i;
// 指向目标图像倒数第j行，第i个象素的指针
lpDst = (char *)lpNewDIBBits + lLineBytes * j + i;
pixel = (unsigned char)*lpSrc;
if(pixel <= iThreshold)
{
*lpDst = (unsigned char)0;
}
else
{
*lpDst = (unsigned char)255;
}
}
}
// 复制图像
memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
// 释放内存
LocalUnlock(hNewDIBBits);
LocalFree(hNewDIBBits);
// 返回
return TRUE;
}
/*************************************************************************
*
* 函数名称：
* GetCorDIB()
*
* 参数:
* LPSTR lpDIBBits - 指向源DIB图像指针
* LONG lWidth - 源图像宽度（象素数）
* LONG lHeight - 源图像高度（象素数）
*
* 返回值:
* BOOL - 运算成功返回TRUE，否则返回FALSE。
*
* 说明:
* 该函数用于对图像进行框标点中心点坐标运算。
*
************************************************************************/
BOOL WINAPI GetCorDIB(LPSTR lpDIBBits,LONG lWidth, LONG lHeight)
{
unsigned char* lpSrc;
// 循环变量
LONG i;
LONG j;
// 图像每行的字节数
LONG lLineBytes;
// 计算图像每行的字节数
lLineBytes = WIDTHBYTES(lWidth * 8);
float xf=0,yf=0;
long n=0;
CString s;
for(i=0;i<lHeight;i++)
{
for(j=0;j<lWidth;j++)
{
lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
if(*lpSrc==255)
{
xf+=j;
yf+=(lHeight-i);
n++;
}
}
}
xf=xf/n;
yf=yf/n;
s.Format("框标点的坐标：\n X=%f Y=%f",xf,yf);
AfxMessageBox(s);
// 返回
return TRUE;
}
/*************************************************************************
*
* 函数名称：
* ContourDIB()
*
* 参数:
* LPSTR lpDIBBits - 指向源DIB图像指针
* LONG lWidth - 源图像宽度（象素数，必须是4的倍数）
* LONG lHeight - 源图像高度（象素数）
* 返回值:
* BOOL - 运算成功返回TRUE，否则返回FALSE。
*
* 说明:
* 该函数用于对图像进行轮廓提取运算。
*
* 要求目标图像为只有0和255两个灰度值的灰度图像。
************************************************************************/
BOOL WINAPI ContourDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
{
// 指向源图像的指针
LPSTR lpSrc;
// 指向缓存图像的指针
LPSTR lpDst;
// 指向缓存DIB图像的指针
LPSTR lpNewDIBBits;
HLOCAL hNewDIBBits;
//循环变量
long i;
long j;
unsigned char n,e,s,w,ne,se,nw,sw;
//像素值
unsigned char pixel;
// 暂时分配内存，以保存新图像
hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);
if (hNewDIBBits == NULL)
{
// 分配内存失败
return FALSE;
}
// 锁定内存
lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
// 初始化新分配的内存，设定初始值为255
lpDst = (char *)lpNewDIBBits;
memset(lpDst, (BYTE)255, lWidth * lHeight);
for(j = 1; j <lHeight-1; j++)
{
for(i = 1;i <lWidth-1; i++)
{
// 指向源图像倒数第j行，第i个象素的指针
lpSrc = (char *)lpDIBBits + lWidth * j + i;
// 指向目标图像倒数第j行，第i个象素的指针
lpDst = (char *)lpNewDIBBits + lWidth * j + i;
//取得当前指针处的像素值，注意要转换为unsigned char型
pixel = (unsigned char)*lpSrc;
//目标图像中含有0和255外的其它灰度值
// if(pixel != 255 && pixel != 0)
// return FALSE;
if(pixel == 0)
{
*lpDst = (unsigned char)0;
nw = (unsigned char)*(lpSrc + lWidth -1);
n = (unsigned char)*(lpSrc + lWidth );
ne = (unsigned char)*(lpSrc + lWidth +1);
w = (unsigned char)*(lpSrc -1);
e = (unsigned char)*(lpSrc +1);
sw = (unsigned char)*(lpSrc - lWidth -1);
s = (unsigned char)*(lpSrc - lWidth );
se = (unsigned char)*(lpSrc - lWidth +1);
//如果相邻的八个点都是黑点
if(nw+n+ne+w+e+sw+s+se==0)
{
*lpDst = (unsigned char)255;
}
}
}
}
// 复制腐蚀后的图像
memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
// 释放内存
LocalUnlock(hNewDIBBits);
LocalFree(hNewDIBBits);
// 返回
return TRUE;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -