图像二值化得相关算法

[kobefly]

图像二值化得相关算法

最好有代码

朋友做毕业设计，我对图像处理也不了解

还请各位xdjm多多帮忙

指个路也行
谢谢

[zerg_chn]

同志，图象二值化并没有一个通用的最优算法，要结合具体问题来决定采用哪种算法啊。你朋友的毕业设计项目是什么？

[sboom]

嘴简单的，阈值二值化吧，10行代码左右。

好一点的，直方图吧，在直方图中找2个波峰之间的波谷作为阈值。

[kobefly]

zerg_chn() ( )
谢谢
毕业设计名字好像是图像得边缘检测什么得

sboom(+-LingCh-+)(怪你过分美丽) ( )
谢谢
不知道哪里有相关代码

[xuelong_zl]

数字图像的边缘检测是图像分割、目标区域的识别、区域形状提取等图像分析领域十分重要的基础，图像理解和分析的第一步往往就是边缘检测，目前它以成为机器视觉研究领域最活跃的课题之一，在工程应用中占有十分重要的地位。本文向读者简单介绍一下这个技术，并给出了在Visual C++环境下实现的代码。

　　所谓边缘就是指图像局部亮度变化最显著的部分，它是检测图像局部变化显著变化的最基本的运算。对于数字图像，图像灰度灰度值的显著变化可以用梯度来表示，以边缘检测Sobel算子为例来讲述数字图像处理中边缘检测的实现：

　　对于数字图像，可以用一阶差分代替一阶微分；

　　△xf(x,y)=f(x,y)-f(x-1,y);

　　△yf(x,y)=f(x,y)-f(x,y-1)

　　求梯度时对于平方和运算及开方运算，可以用两个分量的绝对值之和表示，即：

　　G[f(x,y)]={[△xf(x,y)] +[△yf(x,y)] } |△xf(x,y)|+|△yf(x,y)|;

　　Sobel梯度算子是先做成加权平均，再微分，然后求梯度，即：

　　△xf(x,y)= f(x-1,y+1) + 2f(x,y+1) + f(x+1,y+1)- f(x-1,y-1) - 2f(x,y-1) - f(x+1,y-1);

　　△yf(x,y)= f(x-1,y-1) + 2f(x-1,y) + f(x-1,y+1)- f(x+1,y-1) - 2f(x+1,y) - f(x+1,y+1);

　　G[f(x,y)]=|△xf(x,y)|+|△yf(x,y)|;

　　上述各式中的像素之间的关系见图

f(x-1,y-1) f(x,y-1) f(x+1,y-1)
f(x-1,y) f(x,y) f(x+1,y)
f(x-1,y+1) f(x,y+1) f(x+1,y+1)




我在视图类中定义了响应菜单命令的边缘检测Sobel算子实现灰度图像边缘检测的函数：

void CDibView::OnMENUSobel()
//灰度图像数据的获得参见天极网9.10日发表的拙作//VC数字图像处理一文
{
　HANDLE data1handle;
　LPBITMAPINFOHEADER lpBi;
　CDibDoc *pDoc=GetDocument();
　HDIB hdib;
　unsigned char *hData;
　unsigned char *data;

　hdib=pDoc->m_hDIB;
　BeginWaitCursor();
　lpBi=(LPBITMAPINFOHEADER)GlobalLock((HGLOBAL)hdib);
　hData= lpbi +* (LPDWORD)lpbi + 256*sizeof(RGBQUAD);
　//得到指向位图像素值的指针
　pDoc->SetModifiedFlag(TRUE);//设修改标志为"TRUE"
　data1handle=GlobalAlloc(GMEM_SHARE,WIDTHBYTES(lpBi->biWidth*8)*lpBi->biHeight);
　//申请存放处理后的像素值的缓冲区
　data=(unsigned char*)GlobalLock((HGLOBAL)data1handle);
　AfxGetApp()->BeginWaitCursor();
　int i,j,buf,buf1,buf2;
　for( j=0; jbiHeight; j++)//以下循环求(x,y)位置的灰度值
　　for( i=0; ibiWidth; i++)
　　{
　　　if(((i-1)>=0)&&((i+1)biWidth)&&((j-1)>=0)&&((j+1)biHeight))
　　　{//对于图像四周边界处的向素点不处理
　　　　buf1=(int)*(hData+(i+1)*WIDTHBYTES(lpBi->biWidth*8)+(j-1))
　　　　　　　+2*(int)*(hData+(i+1)*WIDTHBYTES(lpBi->biWidth*8)+(j))
　　　　　　　+(int)(int)*(hData+(i+1)*WIDTHBYTES(lpBi->biWidth*8)+(j+1));
　　　　buf1=buf1-(int)(int)*(hData+(i-1)*WIDTHBYTES(lpBi->biWidth*8)+(j-1))
　　　　　　　-2*(int)(int)*(hData+(i-1)*WIDTHBYTES(lpBi->biWidth*8)+(j))
　　　　　　　-(int)(int)*(hData+(i-1)*WIDTHBYTES(lpBi->biWidth*8)+(j+1));
　　　　//x方向加权微分
　　　　buf2=(int)(int)*(hData+(i-1)*WIDTHBYTES(lpBi->biWidth*8)+(j+1))
　　　　　　　+2*(int)(int)*(hData+(i)*WIDTHBYTES(lpBi->biWidth*8)+(j+1))
　　　　　　　+(int)(int)*(hData+(i+1)*WIDTHBYTES(lpBi->biWidth*8)+(j+1));
　　　　buf2=buf2-(int)(int)*(hData+(i-1)*WIDTHBYTES(lpBi->biWidth*8)+(j-1))
　　　　　　　-2*(int)(int)*(hData+(i)*WIDTHBYTES(lpBi->biWidth*8)+(j-1))
　　　　　　　-(int)(int)*(hData+(i+1)*WIDTHBYTES(lpBi->biWidth*8)+(j-1));
　　　　//y方向加权微分
　　　　buf=abs(buf1)+abs(buf2);//求梯度
　　　　if(buf>255) buf=255;
　　　　　if(buf<0){buf=0;
　　　　　　　*(data+i*WIDTHBYTES(lpBi->biWidth*8)+j)=(BYTE)buf;
　　　　　}

　　　　else *(data+i*lpBi->biWidth+j)=(BYTE)0;
　　　　}
　　　　for( j=0; jbiHeight; j++)
　　　　　for( i=0; ibiWidth; i++)
　　　　　　*(hData+i*WIDTHBYTES(lpBi->biWidth*8)+j)=*(data+i*WIDTHBYTES(lpBi->biWidth*8)+j);
　　　　　 //处理后的数据写回原缓冲区
　　　　　　AfxGetApp()->EndWaitCursor();
　　　　　　GlobalUnlock((HGLOBAL)hdib);
　　　　　　GlobalUnlock(data1handle);
　　　　　　GlobalFree(date1handle);
　　　　　　EndWaitCursor();
　　　　　　Invalidate(TRUE);
　}

　　上述的数学分析读者可能看起来有些吃力，不过不要紧，对与边缘检测，大家只要知道有若干个检测模板（既边缘检测矩阵）可以直接实现检测功能就行了，现在将常用的检测实现公式列出如下：

　　Roberts算子：G[i,i]=|f[i,j]-f[i+1,j+1]|+|f[i+1,j]-f[i,j+1]|;

　　Sobe算子：G[i,i]=|f[i-1,j+1]+2f[i,j+1]+f[i+1,j+1]-f[i-1,j-1]-2f[i,j-1]-f[i+1,j-1]|
　　　　　　　　　　　+|f[i-1,j-1]+2f[i-1,j]+f[i-1,j+1]-f[i+1,j-1]-2f[i+1,j]-f[i+1,j+1]|;

　　拉普拉斯算子：G[I,j]=|f[i+1,j]+f[i-1,j]+f(i,j+1)+f[i,j-1]-4f[i,j]|;

　　其中G[i,j]表示处理后(i,j)点的灰度值，f[i,j]表示处理前该点的灰度值。

　　笔者开发的该图像处理程序在Windows2000环境下编译通过，下面图2给出了依据图像处理算法得到的图像二值化、高通滤波、Sobel边缘算子的处理结果，读者需要注意的是我在进行Sobel算子进行处理后，又对它进行了二值化处理，这才得到C图。关于如何实现二值化图像，我会后续撰文对相关知识进行介绍。



帖子的链接为http://www.chinaai.org/Article_Show.asp?ArticleID=244

看看先^_^

[xuelong_zl]

不过他写的数学过程和程序上都有一些错误，程序上的我想你看看能理解

数学方面的推导还是要看书的，只要用的是隐函数求导一类的，算法上不是很难的！！

兄弟只能帮这些了，如果还有什么我就得现查书了

[xuelong_zl]

没事做，再up一下！！

对了，不要给我分，我不想在这个版玩的

只要让我灌水就可以了

[kobefly]

哦，还真谢谢你了，兄弟

不过怎么没人来帮我呢
呵呵
还是兄弟够意思

[kobefly]

我是想知道具体的二值化有哪些算法，
阈值二值化我知道的，还有其他的什么算法吗？
谢谢了

[xuelong_zl]

你up不了了,我给你up吧,嘿嘿

[kobefly]

自己顶！！！

[kobefly]

顶！

[ok_aaron]

你的邮箱我发给你一些相关的阈值分割的论文。还有几个全局阈值选取得源代码，一个是迭代法，一个是大津法。局部阈值的比较复杂，我也在这方面找呢。
/***************************************************************************
* 函数名称
* OSTUThreshold()
* 参数
* LPSTR lpDIBBits - 指向源DIB图像指针
* LONG lWidth - 源图像宽度(像素数)
* LONG lHeight - 源图像高度(像素数)
* 返回值
* BOOL - 运算成功 返回TRUE , 否则 返回FALSE。
* 说明
* 该函数采用大津法进行阈值分割 二值化
***************************************************************************/
BOOL WINAPI OSTUThreshold(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
{
// 指向源图像像素指针
LPSTR lpSrc;

// 指向缓存图像指针
LPSTR lpDst;

// 指向缓存图像像素指针
LPSTR lpNewDIBBits;
HLOCAL hNewDIBBits;

// 循环变量
int i, j, t;

// 用于计算两个区域的中间变量
long lP1, lS1, lP2, lS2;

// 像素值
unsigned char pixel;

// 灰度直方图数组
long lHistogram[256];

// 阈值, 最大灰度值和最小灰度值, 两个区域的平均灰度值
unsigned char iThreshold, iNewThreshold, iMaxGrayValue, iMinGrayValue, iMean1GrayValue, iMean2GrayValue;

// 前景点数占图像比例, 背景点数占图像比例
double w0,w1;

// 方差
double G, tempG;

// 图像每行占字节数
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++)
{
lpSrc = (char *) lpDIBBits + lLineBytes * j + i;
pixel = (unsigned char) *lpSrc;
lHistogram[pixel]++;

// 修改最大灰度值和最小灰度值
if (iMinGrayValue > pixel)
{
iMinGrayValue = pixel;
}
if (iMaxGrayValue < pixel)
{
iMaxGrayValue = pixel;
}
}
}

// 遍历t, 选取最佳阈值
for(t = iMinGrayValue; t < iMaxGrayValue ; t++)
{
iNewThreshold = t;
lP1 = 0;
lS1 = 0;
lP2 = 0;
lS2 = 0;

// 求前景,背景两个区域的平均灰度值, 点数所占比例
for(i = iMinGrayValue; i <= iNewThreshold; i++)
{
lP1 += lHistogram[i] * i;
lS1 += lHistogram[i];
}
iMean1GrayValue = (unsigned char) (lP1/lS1);
w0 = (double) (lS1) / (lWidth * lHeight);
for(i = iNewThreshold + 1; i <= iMaxGrayValue; i++)
{
lP2 += lHistogram[i] * i;
lS2 += lHistogram[i];
}
iMean2GrayValue = (unsigned char) (lP2/lS2);
w1 = 1 - w0;

// 计算类间方差
G = (double) w0 * w1
* (iMean1GrayValue - iMean2GrayValue) * (iMean1GrayValue - iMean2GrayValue);
if (G > tempG)
{
tempG = G;
iThreshold = iNewThreshold;
}
}

// 根据阈值将图像二值化
for(i = 0; i < lWidth; i++)
{
for(j = 0; j < lHeight; j++)
{
lpSrc = (char *) lpDIBBits + lLineBytes * 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;
}

[ok_aaron]

// 迭代法
BOOL WINAPI MeanThreshold(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; iIterationTimes < 100 && iThreshold != iNewThreshold; iIterationTimes++)
{
iThreshold = iNewThreshold;
lP1 = 0;
lS1 = 0;
lP2 = 0;
lS2 = 0;

// 求以iNewThresHold分割的两个区域的灰度平均值
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++)
{
lpSrc = (char *) lpDIBBits + lLineBytes * 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;
}

[kobefly]

非常感谢楼上得兄弟！！1

我得邮箱是
[e-mail]

再次感谢你