otsu算法及程序 - 360文档中心

Otsu算法(大律法或最大类间方差法)

Otsu算法(大律法或最大类间方差法)一、Otsu最大类间方差法原理利用阈值将原图像分成前景，背景两个图象。

前景：用n1,csum,m1来表示在当前阈值下的前景的点数，质量矩，平均灰度后景：用n2, sum-csum,m2来表示在当前阈值下的背景的点数，质量矩，平均灰度当取最佳阈值时，背景应该与前景差别最大，关键在于如何选择衡量差别的标准，而在otsu算法中这个衡量差别的标准就是最大类间方差（英文简称otsu，这也就是这个算法名字的来源），在本程序中类间方差用sb表示，最大类间方差用fmax 关于最大类间方差法（otsu）的性能:类间方差法对噪音和目标大小十分敏感，它仅对类间方差为单峰的图像产生较好的分割效果。

当目标与背景的大小比例悬殊时，类间方差准则函数可能呈现双峰或多峰，此时效果不好，但是类间方差法是用时最少的。

最大类间方差法（otsu）的公式推导：记t为前景与背景的分割阈值，前景点数占图像比例为w0，平均灰度为u0；背景点数占图像比例为w1，平均灰度为u1。

则图像的总平均灰度为：u=w0*u0+w1*u1。

前景和背景图象的方差：g=w0*(u0-u)*(u0-u)+w1*(u1-u)*(u1-u)=w0*w1*(u0-u1)*(u0-u1),此公式为方差公式。

可参照概率论课本上面的g的公式也就是下面程序中的sb的表达式。

当方差g最大时，可以认为此时前景和背景差异最大，此时的灰度t是最佳阈值sb = w1*w2*(u1-u0)*(u0-u1)算法实现1：unsafe public int GetThreshValue(Bitmap image){BitmapData bd = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.WriteOnly, image.PixelFormat);byte* pt = (byte*)bd.Scan0;int[] pixelNum = new int[256]; //图象直方图，共256个点byte color;byte* pline;int n, n1, n2;int total; //total为总和，累计值double m1, m2, sum, csum, fmax, sb; //sb为类间方差，fmax存储最大方差值int k, t, q;int threshValue = 1; // 阈值int step = 1;switch (image.PixelFormat){case PixelFormat.Format24bppRgb:step = 3;break;case PixelFormat.Format32bppArgb:step = 4;break;case PixelFormat.Format8bppIndexed:step = 1;break;}//生成直方图for (int i = 0; i < image.Height; i++){pline = pt + i * bd.Stride;for (int j = 0; j < image.Width; j++){color = *(pline + j * step); //返回各个点的颜色，以RGB表示pixelNum[color]++; //相应的直方图加1}}//直方图平滑化for (k = 0; k <= 255; k++){total = 0;for (t = -2; t <= 2; t++) //与附近2个灰度做平滑化，t值应取较小的值{q = k + t;if (q < 0) //越界处理q = 0;if (q > 255)q = 255;total = total + pixelNum[q]; //total为总和，累计值}//平滑化，左边2个+中间1个+右边2个灰度，共5个，所以总和除以5，后面加0.5是用修正值pixelNum[k] = (int)((float)total / 5.0 + 0.5);}//求阈值sum = csum = 0.0;n = 0;//计算总的图象的点数和质量矩，为后面的计算做准备for (k = 0; k <= 255; k++){//x*f(x)质量矩，也就是每个灰度的值乘以其点数（归一化后为概率），sum为其总和sum += (double)k * (double)pixelNum[k];n += pixelNum[k]; //n为图象总的点数，归一化后就是累积概率}fmax = -1.0; //类间方差sb不可能为负，所以fmax初始值为-1不影响计算的进行n1 = 0;for (k = 0; k < 255; k++) //对每个灰度（从0到255）计算一次分割后的类间方差sb{n1 += pixelNum[k]; //n1为在当前阈值遍前景图象的点数if (n1 == 0) { continue; } //没有分出前景后景n2 = n - n1; //n2为背景图象的点数//n2为0表示全部都是后景图象，与n1=0情况类似，之后的遍历不可能使前景点数增加，所以此时可以退出循环if (n2 == 0) { break; }csum += (double)k * pixelNum[k]; //前景的“灰度的值*其点数”的总和m1 = csum / n1; //m1为前景的平均灰度m2 = (sum - csum) / n2; //m2为背景的平均灰度sb = (double)n1 * (double)n2 * (m1 - m2) * (m1 - m2); //sb为类间方差if (sb > fmax) //如果算出的类间方差大于前一次算出的类间方差{fmax = sb; //fmax始终为最大类间方差（otsu）threshValue = k; //取最大类间方差时对应的灰度的k就是最佳阈值}}image.UnlockBits(bd);image.Dispose();return threshValue;}算法实现2：Otsu算法步骤如下：设图象包含L个灰度级(0,1…,L-1)，灰度值为i的的象素点数为Ni ，图象总的象素点数为N=N0+N1+...+N(L-1)。

简述 otsu 算法的原理和步骤。

OStsu 算法是一种基于阈值分割的图像去噪算法,其基本原理是在原始图像上选取一个阈值,将像素值低于该阈值的像素设置为噪声,将像素值高于该阈值的像素设置为清晰的图像。

具体步骤如下:
1. 选取一个阈值 T = 255/n,其中 n 是像素值的范围。

2. 计算像素值差 U = (P - Q) / n,其中 P 和 Q 分别是清晰的图像和噪声的图像的像素值,n 是像素值的范围。

3. 将像素值 U 小于等于阈值 T 的像素设为噪声,即 N(T, U) = {(U, V)},其中 V 表示该像素值下的样本集合,V 的索引从 1 到 n。

4. 将像素值 U 大于阈值 T 的像素设置为清晰的图像,即 C(T, U) = {(X, Y)},其中 X 和 Y 表示该像素值下的样本集合,X 的索引从 1 到 n,Y 的索引从 1 到 n。

5. 将像素值 U 介于阈值 T 和 255/n 之间的像素设置为噪声,即 N(T, U) = {(U, V)},其中 V 表示该像素值下的样本集合,V 的索引从 1 到 n。

6. 重复步骤 3 到步骤 5,直到所有像素都被划分为清晰和噪声两部分。

7. 返回清晰和噪声的图像集合 C(T, U) 和 N(T, U)。

OStsu 算法的优点在于简单易用,能够快速地去掉大量的噪声,
同时保持图像的基本特征。

但是其缺点在于对于低光照环境下的图像可能会失效,并且在处理高分辨率图像时需要更多的计算资源。

otsu算法——图像分割

前景比例：
背景比例：
像素点总数：
前景和背景概率之和：
平均灰度值：
类间方差：
将公式（4）和（5）带入（6）可以得到等价公式：
核心代码：Histogram[data[i*srcimage.step + j]]++;//step指向每行的字节总量，date访问每个像素的值for (int i = 1; i < 255 ;i++)//从1开始遍历，寻找最合适的值{//每次遍历前需要初始化各变量w0 = 0; u0 = 0; w1 = 0; u1 = 0;for (int j = 0; j <= i; j++)//背景部分各值计算 { w0 += Histogram[j]; //背景部分像素点总数 u0 += j*Histogram[j]; //背景部分像素总灰度和 } u0 = u0 / w0; //背景像素平均灰度 w0 = w0 / number; //背景部分像素点所占比例}double varValueI = w1*w2*(u1 - u2)*(u1 - u2); //类间方差计算
算法过程：（1）设K(x,y)=f(x,y)/g(x,y)为像素点的斜率，其中f(x,y)为点(x,y)的灰度值， g(x,y)为点(x,y)周围点的平均值。（2）设阈值t1，t2将二维直方图分为A、B、 C三个区域。其中B区域代表前景和背景像素点部分，而A、C代表边界点和噪声点部分。
算法过程：（1）对于图像I(x,y),将前景与背景的分割阈值设为T。（2）将属于前景的像素点的个数占整个图像的比例设为w0，其平均灰度设为u0。（3）将属于背景的像素点的个数占整个图像的比例设为w1，其平均灰度设为u1。（4）图像的总平均灰度设为u，类间方差设为S。假设图片的大小为M*N，图像中像素灰度值小于阈值T的像素个数记为N0，像素灰度大于阈值T的像素个数记为N1。则它们之间的关系如下。

Otsu算法代码

Otsu算法代码：time=now; %取当前时间I=imread('lena256.bmp');%读取图像imshow(I);[N,M]=size(I);%用N,M分别存储图像数组的行数和列数length=N*M; %取得图像数组的像素点个数L=256;%设定图像的灰度为256count=0; %用来记录出现灰度值相同的个数for k=0:L-1for i=1:Nfor j=1:Mif I(i,j)==kcount=count+1; %个数加一endendend %求出每个像素出现的次数P(k+1)=count/length;%记录像素值为K出现的概率count=0; %再次赋予0进入下一个像素的个数记录endfor i=1:Lif P(i)~=0first=i;%找出第一个概率不连续为0的像素breakendendfor i=L:-1:1if P(i)~=0last=i;%找出最后一个出现概率不连续为0的像素breakendentropy1=0; %记录灰度图像的熵值for i=first:lastif (P(i)~=0)entropy1=entropy1+P(i)*log2(1/P(i)); %求取熵值的公式endendep=0;%用来记录每个灰度级的概率averF=0; %记录目标均值的叠加值averB=0; %记录背景均值的叠加值for t=0:Ly=t+1;%好做标记if (y>first)&&(y<last) %防止w0(y)和w1(y)取0的情况出现for k=1:yep=ep+P(k);%存储选取阈值为t时目标点的概率endw0(y)=ep;w1(y)=1-w0(y); %总概率为1for i=1:tep=averF+(i)*P(i)/w0(y); %求出目标均值endu0(y)=averF; %赋予目标均值for i=t:LaverB=averB+(i)*P(i)/w1(y);% 求出背景均值endu1(y)=averB;u=w0(y)*u0(y)+w1(y)*u1(y); %总均值arg(y)=w0(y)*(u0(y)-u)*(u0(y)-u)+w1(y)*(u1(y)-u)*(u1(y)-u); %算出每一个t对应的方差值endaverF=0;averB=0; %用完一次需赋0，以保证进入下一个t的计算的正确性endhigh=arg(1);for i=2:last-first-3 %因为first<t<last,所以t可取值的个数为last-first-2 if high<arg(i)high=arg(i); %把大值赋予max(x)x=i; %记录大值的下标endendt=x-1;%记录t是从下标1开始的,此时的t就是我们所求的阈值I0=0;I1=0;for i=1:Nfor j=1:Mif (I(i,j)>=t)y1(i,j)=255;I1=I1+1;%统计目标像素点的个数elsey1(i,j)=0;I0=I0+1;%统计背景像素点的个数endendendfigure,imshow(y1); %显示二值化图像entropy1; %求出二值化图像的熵值back=(I0/(N*M))*log2(N*M/I0); %求出背景像素的熵值fore=(I1/(N*M))*log2(N*M/I1); %求出目标像素的熵值entropy2=back+fore %求出二值化图像的熵值exetime=second(now-time) %求得程序运行所需时间，并转化成秒显示t %阈值显示最大方差比那个只要求写简单程序，五十行左右，谢谢帮助了！。

Otsu传统算法和快速算法的matlab实现

说明：每个%%都表示一个模块，每个模块可以单独执行，也可以将%%去掉整体执行。

将读入图像修改成自己机子上的，Otsu传统算法执行顺序如下：cell1-cell2-cell3,Otsu快速迭代算法执行顺序如下：cell1-cell2-cell4。

%%%%%%%%%%%%%%%%%%%%%%%%%%%% cell1 读入图像1I=imread('e:/photo/m/rice.png');%% cell2显示原图及其直方图subplot(2,2,1);imshow(I);xlabel('a,原图');subplot(2,2,2);imhist(I);%% cell3Otsu法传统算法的参数说明及步骤%参数说明：%M,N---图像大小%TT,T-----阈值,使得方差为最大的阈值%Ib,Ibav,Ibavm----背景图像,背景图像的灰度平均值,合适阈值时对应的背景图像的灰度平均值%If,Ifav,Ifavm----前景图像,前景图像的灰度平均值,合适阈值时对应的前景图像的灰度平均值%Iav----图像的平均灰度值（数学期望）%Ivar,Ivarm----方差,值最大的方差%%%%%%%%%%%步骤：%1.阈值T从图像的最小灰度值开始遍历，直到最大灰度值。

%2.划分前景和后景：所有I>=T的为背景Ib,得出背景所占比例pb与背景的平均灰度值Ibav;%2.划分前景和后景：所有I<T的为前景If,得出前景所占比例pf与前景的平均灰度值Ifav;%3.求出图像的平均灰度Iav和方差Ivar%4.遍历结束后，Tm即为所求，然后二值化分割。

%%%%%%%%%%%%%%%%%%%%%%[M,N]=size(I);Ivarm=0;T=0;Iav=mean(mean(I));tic;for TT=min(min(I)):max(max(I))%划分前景背景Ib=I(I>=TT);pb=length(Ib)/(M*N);Ibav=mean(Ib);If=I(I<TT);pf=length(If)/(M*N);Ifav=mean(If);%求类间方差，并找出最大方差Ivar=pb*pf*(Ibav-Ifav)^2 %lvar=pb*(Ibav-Iav)^2+pf*(Ifav-Iav)^2; if Ivar>IvarmIvarm=Ivar;T=TT;endendtoc;% 输出disp(strcat('大律法计算出的阈值: ',num2str(T)));Iotsu=im2bw(I,double(T)/255);subplot(2,2,2);imshow(Iotsu,[]);xlabel('b,大律法'); %%%%%%%%%%%%%%%%%%%%%%%%%% cel4 OTSU传统算法的快速实现----迭代%参数说明：%M,N---图像大小%T-----阈值(即使得方差为最大的阈值)%gmin,gmax---图像灰度级最小值和最大值%p---图像灰度级概率分布，一维数组长度gmin*gmax%Ibp,Ibav,Ibavm----背景图像灰度级概率,背景图像的灰度平均值,合适阈值时对应的背景图像的灰度平均值%Ifp,Ifav,Ifavm----前景图像灰度级概率,前景图像的灰度平均值,合适阈值时对应的前景图像的灰度平均值%Iav----图像的平均灰度值（数学期望）%Ivar,Ivarm----方差,值最大的方差%%%%%%%%%%%步骤：%1.先求解gmin,gmax,p,Iav,并令Ibp=0,Ibav=0,Ivarm=0;%2.i从gmin+1到gmax+1迭代搜索,(下面为方便说明，使用了序列)Ibp(i)=Ibp(i-1)+p(i),Ibav(i)=(Ibp(i-1)*Ibav(i-1)+i*p(i))/Ibp(i),Ivar(i)=(Ibp(i)*(Iav-Ibav(i))^2)/(1-Ibp(i));%2.判断Iavm是否大于Iav,若是,则i=i+1,重复第2步;若否,则Iavm=Iav,T=i,Ibavm=Ibav,Ifavm=Ifav,i=i+1,重复第2步;%3.迭代结束，T即为所求，二值化分割。

Ots算法(大律法或最大类间方差法)

Otsu算法(大律法或最大类间方差法)一、Otsu最大类间方差法原理利用阈值将原图像分成前景，背景两个图象。

前景：用n1,csum,m1来表示在当前阈值下的前景的点数，质量矩，平均灰度后景：用n2, sum-csum,m2来表示在当前阈值下的背景的点数，质量矩，平均灰度当取最佳阈值时，背景应该与前景差别最大，关键在于如何选择衡量差别的标准，而在otsu算法中这个衡量差别的标准就是最大类间方差（英文简称otsu，这也就是这个算法名字的来源），在本程序中类间方差用sb表示，最大类间方差用fmax 关于最大类间方差法（otsu）的性能:类间方差法对噪音和目标大小十分敏感，它仅对类间方差为单峰的图像产生较好的分割效果。

当目标与背景的大小比例悬殊时，类间方差准则函数可能呈现双峰或多峰，此时效果不好，但是类间方差法是用时最少的。

最大类间方差法（otsu）的公式推导：记t为前景与背景的分割阈值，前景点数占图像比例为w0，平均灰度为u0；背景点数占图像比例为w1，平均灰度为u1。

则图像的总平均灰度为：u=w0*u0+w1*u1。

前景和背景图象的方差：g=w0*(u0-u)*(u0-u)+w1*(u1-u)*(u1-u)=w0*w1*(u0-u1)*(u0-u1),此公式为方差公式。

可参照概率论课本上面的g的公式也就是下面程序中的sb的表达式。

当方差g最大时，可以认为此时前景和背景差异最大，此时的灰度t是最佳阈值sb = w1*w2*(u1-u0)*(u0-u1)算法实现1：unsafe public int GetThreshValue(Bitmap image){BitmapData bd = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.WriteOnly, image.PixelFormat);byte* pt = (byte*)bd.Scan0;int[] pixelNum = new int[256]; //图象直方图，共256个点byte color;byte* pline;int n, n1, n2;int total; //total为总和，累计值double m1, m2, sum, csum, fmax, sb; //sb为类间方差，fmax存储最大方差值int k, t, q;int threshValue = 1; // 阈值int step = 1;switch (image.PixelFormat){case PixelFormat.Format24bppRgb:step = 3;break;case PixelFormat.Format32bppArgb:step = 4;break;case PixelFormat.Format8bppIndexed:step = 1;break;}//生成直方图for (int i = 0; i < image.Height; i++){pline = pt + i * bd.Stride;for (int j = 0; j < image.Width; j++){color = *(pline + j * step); //返回各个点的颜色，以RGB表示pixelNum[color]++; //相应的直方图加1}}//直方图平滑化for (k = 0; k <= 255; k++){total = 0;for (t = -2; t <= 2; t++) //与附近2个灰度做平滑化，t值应取较小的值{q = k + t;if (q < 0) //越界处理q = 0;if (q > 255)q = 255;total = total + pixelNum[q]; //total为总和，累计值}//平滑化，左边2个+中间1个+右边2个灰度，共5个，所以总和除以5，后面加0.5是用修正值pixelNum[k] = (int)((float)total / 5.0 + 0.5);}//求阈值sum = csum = 0.0;n = 0;//计算总的图象的点数和质量矩，为后面的计算做准备for (k = 0; k <= 255; k++){//x*f(x)质量矩，也就是每个灰度的值乘以其点数（归一化后为概率），sum为其总和sum += (double)k * (double)pixelNum[k];n += pixelNum[k]; //n为图象总的点数，归一化后就是累积概率}fmax = -1.0; //类间方差sb不可能为负，所以fmax初始值为-1不影响计算的进行n1 = 0;for (k = 0; k < 255; k++) //对每个灰度（从0到255）计算一次分割后的类间方差sb{n1 += pixelNum[k]; //n1为在当前阈值遍前景图象的点数if (n1 == 0) { continue; } //没有分出前景后景n2 = n - n1; //n2为背景图象的点数//n2为0表示全部都是后景图象，与n1=0情况类似，之后的遍历不可能使前景点数增加，所以此时可以退出循环if (n2 == 0) { break; }csum += (double)k * pixelNum[k]; //前景的“灰度的值*其点数”的总和m1 = csum / n1; //m1为前景的平均灰度m2 = (sum - csum) / n2; //m2为背景的平均灰度sb = (double)n1 * (double)n2 * (m1 - m2) * (m1 - m2); //sb为类间方差if (sb > fmax) //如果算出的类间方差大于前一次算出的类间方差{fmax = sb; //fmax始终为最大类间方差（otsu）threshValue = k; //取最大类间方差时对应的灰度的k就是最佳阈值}}image.UnlockBits(bd);image.Dispose();return threshValue;}算法实现2：Otsu算法步骤如下：设图象包含L个灰度级(0,1…,L-1)，灰度值为i的的象素点数为Ni ，图象总的象素点数为N=N0+N1+...+N(L-1)。

otsu阈值最大类间方差法

Otsu阈值最大类间方差法是一种确定阈值的算法，通过将图像分成前景和背景两部分，以最大化这两部分之间的方差。

这种方法是在判决分析最小二乘法原理的基础上推导得出的。

具体来说，Otsu算法首先基于直方图得到每个分割特性值的发生概率，并以阈值变量将分割特征值分为两类。

然后，算法计算出每一类的类内方差及类间方差，选取使类间方差最大或类内方差最小的阈值T作为最佳阈值。

当目标与背景的大小比例悬殊时，类间方差准则函数可能呈现双峰或多峰，此时效果不好。

但总体来说，Otsu阈值最大类间方差法在图像分割、二值化等方面具有高效性，且该算法的稳定性能够得到保证。

OTSU 算法代码

OTSU 算法OTSU 算法以最佳门限将图像灰度直方图分割成两部分，使两部分类间方差取最大值，即分离性最大。

设图像灰度级 M ~1，第 i 级象素 i n 个,总象素∑==M i i n N 1，则第i 级灰度出现的概率为 N n P i i =。

设灰度门限值为 k ，则图像像素按灰度级被分为两类:{}k C ,,2,10 =，{}M k C ,,11 +=图像总平均灰度级：∑=⋅=M i iP i 1μ0C 类的平均灰度级为: ()∑=⋅=ki iP i k 1μ，像素数为: ∑==k i in N 101C 类的平均灰度级为: ()k μμ-, 像素数为: 0N N -两部分图像所占比例分别为:)(10k w P w k i i ==∑= ()k w w -=11对0C ，1C 均值作处理:()()k w k μμ=0 ()[]()[]k w k --=11μμμ图像总均值可化为: 1100μμμw w +=类间方差: ()()()()210102112002μμμμμμσ-=-+-=w w w w k化为:()()()[]()()[]{}k w k w k k w k -⋅-⋅=122μμσ k 从M ~1变化，使 ()k 2σ最大的 *k 即为所求之最佳门限。

()k 2σ称为目标选择函数。

My code：int i; //图像灰度级from 0－－255double n[256]; //第i级像素n[i]个double Pro[256]; //第i级灰度出现的概率double Tavegray = 0; //图像总平均灰度级double avegray0[256] ; //C0类的平均灰度级double avegray1[256] ; //C1类的平均灰度级int N = 0; //总像素int N0 = 0; //C0类的像素数int N1 = 0; //C1类的像素数double w0 = 0, w1 = 0; //分别为两部分图像所占比例double mean0 = 0, mean1 = 0, mean = 0; //对C0，C1 均值作处理，及图像总均值double var[256]; //类间方差int k = 0; //灰度门限值double w[256]; //w[k]当门限值为k时，C0类图像所占的比值int Threshold; //门限值//数组初始化for( i = 0; i < 256; i++ ){n[i] = 0;Pro[i] = 0;avegray0[i] = 0;avegray1[i] = 0;var[i] = 0;w[i] = 0;}int I;LPSTR lpDibHdr = (LPSTR)::GlobalLock(hDib);LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER)lpDibHdr; //得到指向位图的信息头结构的指针LPSTR lpDibBits = lpDibHdr - lpbmi->biSize; //得到指向位图数据的指针for( int y = 0; y < lpbmi->biHeight; y++ ){for( int x = 0; x < lpbmi->biWidth; x++ ){COLORREF c;BYTE* pDate = (BYTE*)lpDibBits + (lpbmi->biHeight-y) *getpiont( hDib )+ ( x ) * 3; //((lpbmi->biWidth*24+31)/32*4)c = RGB( pDate[2], pDate[1], pDate[0]);// COLORREF cNew;// BYTE* pDateNew = (BYTE*)lpNewDibBits + (lpNewbmi->biHeight -y) * getpiont(hDib) + ( x ) * 3; //((lpbmi->biWidth*24+31)/32*4)// cNew = RGB( pDateNew[2], pDateNew[1], pDateNew[0]);I = ( pDate[2] + pDate[1] + pDate[0] ) / 3;n[I]++;}}//总象素for( i = 0; i < 256; i++ ){N += n[i];}//第i级灰度出现的概率for( i = 0; i < 256; i++ ){Pro[i] = ( n[i] / N );}//图像总平均灰度级for( i = 1; i <= 256; i++ ){Tavegray += ( i * Pro[i - 1] );}for ( k = 0; k < 256; k++ ){for( i = 1; i < k+1 ; i++ ){avegray0[k] += i*Pro[i];//C0类的平均灰度级// N0 += n[i]; //C0类像素数w0 += Pro[i];}w[k] = w0;//C0部分图像所占比例// avegray1[k] = Tavegray - avegray0[k];//C1类的平均灰度级和像素数// N1 = N - N0; //C1类像素数w1 = 1 - w[k]; //C0部分图像所占比例if ( w[k] != 0 ) //对C0均值作处理{mean0 = avegray0[k]/ w[k];}else mean0 = 0;mean1 = ( Tavegray - avegray0[k] ) / ( 1 - w[k] );//对C1均值作处理mean = ( w0 * mean0 ) + ( w1 * mean1 );var[k] = (( ( mean * w[k] ) - avegray0[k]) * ( ( mean * w[k] ) - avegray0[k])) / ( w[k] * ( 1 - w[k]));}int temp = 0;for( k = 0; k < 256; k++ ){if ( var[k] > temp){temp = var[k];Threshold = k;}}OTSU 算法可以说是自适应计算单阈值（用来转换灰度图像为二值图像）的简单高效方法。

OTSU算法

根据OTSU算法,记t为前景与背景的分割阈值,前景点数占图像比例为W0,内积平均值为U0；背景点数占图像比例为W1, 内积平均值为U1.图像的内积平均值为：u=W0*U0 + W1*U1.从最小灰度值到最大灰度值便利t,当t使得值g=W0*(U0-u)2+W1*(U1-u)2最大时t即为分割的最佳阈值。

该式实际上就是类间方差值,阈值t分割出的前景和背景两部分构成整幅图像,而前景取值W1,概率为W0,背景取值U1,概率为W1,总均值为U,根据方差的定义既是该式。

因方差是内积值(色彩差异)分布均匀性的一种度量,方差值越大,说明构成图像的两部分差别越大,当部分目标错为背景或者部分背景分为目标都会导致两部分差别变小,因此使类间方差最大的分割意味着错分概率最小.
在实验中,内积值的变化范围在0-1之间,其精度取值0.0001,根据内积值的定义,我们可以作出如下化简计算,当内积值小于0.9000的时候,像素点颜色差异足够大,因此,将这些像素点值归为计为0.9000这个内积值的像素点.因此,我们可以得到1001个内积值,其范围0.9000-1.0000. 对这1001个内积值分别计算其类间方差,然后寻找使类间方差最大的内积值,即为我们的阈值.。

阈值分割公式

阈值分割公式阈值分割公式阈值分割是一种常用的图像处理技术，它可以将图像根据给定的阈值进行二值化处理，使得图像中的目标物体与背景色彩有所区分，便于后续的处理。

随着图像处理技术的不断发展，阈值分割也不断完善，其中最常用的就是基于阈值的分割公式。

一、常见阈值分割算法1. Otsu阈值法Otsu是一种基于直方图的阈值分割方法，它的基本思想是寻找一个最佳阈值，使得图像中目标物体与背景的差异最大化。

这种方法适用于灰度图像，具有较好的分割效果。

Otsu算法的计算公式如下：$$\sigma^2(w_0,w_1) =w_0(t)\sigma^2_0(t)+w_1(t)\sigma^2_1(t)$$2. 最大熵阈值法最大熵阈值法是一种基于信息熵的阈值分割方法，它通过最大化图像的熵值，来确定最佳阈值。

这种方法适用于处理具有复杂背景的图像，它的计算公式如下：$$\max H(T)= - \sum_{i=1}^{k}p_i\log_2(p_i)$$3. 基于聚类的阈值分割法基于聚类的阈值分割法是一种就是把原始图像分成若干个子集，使得每个子集都包含一部分图像的像素值，从而将图像进行分割。

它计算每个子集的灰度均值和方差来确定分割阈值，公式如下：$$\max \varepsilon(i)=\frac{(T*\mu_i-\mu)^2}{T*\sigma_i^2+(1-T)*\sigma_{i+1}^2}$$二、阈值分割的应用阈值分割在实际应用中广泛，例如人脸识别、车牌号识别等。

通过对图像二值化处理可以提高算法的精度，使得对目标物体的检测更加准确。

例如，在车牌号识别中，阈值分割可以先进行图像二值化处理，再进行腐蚀、膨胀等操作，从而将车牌号与背景进行分离，然后再进行字符识别等操作，提高了算法的效率和准确性。

三、总结阈值分割是图像处理中最为常见和实用的方法之一，其应用范围广泛，通过选择不同的阈值分割算法和参数，可以实现不同的图像处理任务。

自动阈值算法 -回复

自动阈值算法-回复什么是自动阈值算法？自动阈值算法是一种通过自动计算数据的特征分布来确定最佳阈值的方法。

在许多数据处理任务中，如图像处理、分割、二值化等，确定一个合适的阈值是非常重要的。

传统的方法往往需要通过试错的方式来确定阈值，效率低下且容易受到主观因素的影响。

而自动阈值算法通过分析数据的特点和分布，能够快速准确地找到最佳阈值。

自动阈值算法有许多种方法，常见的有Otsu算法、Entropy算法、Kapur 算法等。

这些算法都是根据不同的原理和数据特点设计而成的。

下面将具体介绍其中一种自动阈值算法——Otsu算法，来帮助读者更好地理解自动阈值算法的原理和应用。

Otsu算法是由日本学者大津展之提出的一种用于图像二值化的自动阈值选取算法，也是最早的一种自动阈值算法。

该算法的核心思想是：将图像的灰度级分为两部分，使得两部分的类间方差最大化（即最好地分割图像），以此作为图像的最佳阈值。

Otsu算法的具体实现步骤如下：首先，计算图像的直方图，统计每个灰度级的像素数量。

然后，计算各灰度级的类内方差，即在每个灰度级上将图像分成两部分后，两部分各自的方差之和。

接着，通过迭代计算，找到使类间方差最大的阈值。

具体的迭代计算方法是：遍历所有可能的阈值，并计算在该阈值下的类间方差，找到最大的类间方差对应的阈值。

最后，将图像根据最佳阈值进行二值化处理，即将灰度级大于阈值的像素设为一个值，小于阈值的像素设为另一个值。

使用Otsu算法可以有效地实现图像分割和二值化。

对于具有明显分割边界的图像，Otsu算法能够快速找到最佳阈值，将图像分割为前景和背景。

而对于不明显或者复杂的图像，Otsu算法也能够通过自动计算找到最佳阈值。

这使得图像处理任务变得更加自动化、高效和准确。

除了图像处理，自动阈值算法还可以应用于其他领域，如信号处理、数据分析等。

通过自动计算找到合适的阈值，能够更好地提取数据的特征信息，从而辅助解决实际问题。

总结起来，自动阈值算法是一种通过自动计算数据的特征分布来确定最佳阈值的方法。

【转】七种常见阈值分割代码（Otsu、最大熵、迭代法、自适应阀值、手动、迭代法、基本全局阈值法）

【转】七种常见阈值分割代码（Otsu、最⼤熵、迭代法、⾃适应阀值、⼿动、迭代法、基本全局阈值法）⼀、⼯具：VC+OpenCV⼆、语⾔：C++三、原理otsu法（最⼤类间⽅差法，有时也称之为⼤津算法）使⽤的是聚类的思想，把图像的灰度数按灰度级分成2个部分，使得两个部分之间的灰度值差异最⼤，每个部分之间的灰度差异最⼩，通过⽅差的计算来寻找⼀个合适的灰度级别来划分。

所以可以在⼆值化的时候采⽤otsu 算法来⾃动选取阈值进⾏⼆值化。

otsu算法被认为是图像分割中阈值选取的最佳算法，计算简单，不受图像亮度和对⽐度的影响。

因此,使类间⽅差最⼤的分割意味着错分概率最⼩。

设t为设定的阈值。

wo：分开后前景像素点数占图像的⽐例uo：分开后前景像素点的平均灰度w1：分开后被景像素点数占图像的⽐例u1：分开后被景像素点的平均灰度u=w0*u0 + w1*u1 :图像总平均灰度从L个灰度级遍历t，使得t为某个值的时候，前景和背景的⽅差最⼤，则这个 t 值便是我们要求得的阈值。

其中，⽅差的计算公式如下：g=wo * (uo - u) * (uo - u) + w1 * (u1 - u) * (u1 - u)[ 此公式计算量较⼤，可以采⽤： g = wo * w1 * (uo - u1) * (uo - u1) ]由于otsu算法是对图像的灰度级进⾏聚类，so 在执⾏otsu算法之前，需要计算该图像的灰度直⽅图。

迭代法原理：迭代选择法是⾸先猜测⼀个初始阈值，然后再通过对图像的多趟计算对阈值进⾏改进的过程。

重复地对图像进⾏阈值操作，将图像分割为对象类和背景类，然后来利⽤每⼀个类中的灰阶级别对阈值进⾏改进。

图像阈值分割---迭代算法1 .处理流程：1.为全局阈值选择⼀个初始估计值T(图像的平均灰度)。

2.⽤T分割图像。

产⽣两组像素：G1有灰度值⼤于T的像素组成，G2有⼩于等于T像素组成。

3.计算G1和G2像素的平均灰度值m1和m2；4.计算⼀个新的阈值:T = (m1 + m2) / 2;5.重复步骤2和4,直到连续迭代中的T值间的差⼩于⼀个预定义参数为⽌。

自动单阈值分割OTSU算法的C语言实现

自动单阈值分割OTSU算法的C语言实现（文章来源：/post/print?bid=6&id=393020）OTSU的算法，很好用，好不容易才找到的。

/*OTSU 算法可以说是自适应计算单阈值（用来转换灰度图像为二值图像）的简单高效方法。

下面的代码最早由Ryan Dibble提供，此后经过多人Joerg.Schulenburg, R.Z.Liu 等修改，补正。

算法对输入的灰度图像的直方图进行分析，将直方图分成两个部分，使得两部分之间的距离最大。

划分点就是求得的阈值。

parameter: *image --- buffer for imagerows, cols --- size of imagex0, y0, dx, dy --- region of vector used for computing thresholdvvv --- debug option, is 0, no debug information outputed*//*==================================================================== ==*//* OTSU global thresholding routine *//* takes a 2D unsigned char array pointer, number of rows, and *//* number of cols in the array. returns the value of the threshold *//*==================================================================== ==*/int otsu (unsigned char *image, int rows, int cols, int x0, int y0, int dx, int dy, int vvv){unsigned char *np; // 图像指针int thresholdV alue=1; // 阈值int ihist[256]; // 图像直方图，256个点int i, j, k; // various countersint n, n1, n2, gmin, gmax;double m1, m2, sum, csum, fmax, sb;// 对直方图置零...memset(ihist, 0, sizeof(ihist));gmin=255; gmax=0;// 生成直方图for (i = y0 + 1; i < y0 + dy - 1; i++) {np = &image[i*cols+x0+1];for (j = x0 + 1; j < x0 + dx - 1; j++) {ihist[*np]++;if(*np > gmax) gmax=*np;if(*np < gmin) gmin=*np;np++; /* next pixel */}}// set up everythingsum = csum = 0.0;n = 0;for (k = 0; k <= 255; k++) {sum += (double) k * (double) ihist[k]; /* x*f(x) 质量矩*/ n += ihist[k]; /* f(x) 质量*/}if (!n) {// if n has no value, there is problems...fprintf (stderr, "NOT NORMAL thresholdV alue = 160\n"); return (160);}// do the otsu global thresholding methodfmax = -1.0;n1 = 0;for (k = 0; k < 255; k++) {n1 += ihist[k];if (!n1) { continue; }n2 = n - n1;if (n2 == 0) { break; }csum += (double) k *ihist[k];m1 = csum / n1;m2 = (sum - csum) / n2;sb = (double) n1 *(double) n2 *(m1 - m2) * (m1 - m2);/* bbg: note: can be optimized. */if (sb > fmax) {fmax = sb;thresholdV alue = k;}}// at this point we have our thresholding value// debug code to display thresholding valuesif ( vvv & 1 )fprintf(stderr,"# OTSU: thresholdV alue = %d gmin=%d gmax=%d\n",thresholdV alue, gmin, gmax);return(thresholdV alue);}关于倒数第十句，得从OTSU算法说起了，呵呵：大津法由大津于1979年提出，对图像Image，记t为前景与背景的分割阈值，前景点数占图像比例为w0，平均灰度为u0；背景点数占图像比例为w1，平均灰度为u1。

otsu阈值分割算法介绍

otsu阈值分割算法介绍Otsu阈值分割算法是一种常用的图像分割算法，可以将图像分为目标和背景两部分。

该算法是由日本学者大津展之于1979年提出的，因此得名。

Otsu阈值分割算法的核心思想是寻找图像的最佳阈值，使得目标和背景之间的类间方差最大化。

在图像分割中，阈值是一个重要的参数，用于将图像中的像素分为两个部分。

Otsu阈值分割算法通过统计图像的灰度值分布来确定最佳阈值。

具体而言，算法首先计算图像的灰度直方图，然后根据直方图计算不同阈值下的类内方差和类间方差。

类内方差反映了同一类别内的像素灰度值的差异程度，类间方差反映了不同类别之间的差异程度。

最佳阈值即使得类间方差最大化的阈值。

Otsu阈值分割算法的具体步骤如下：1. 计算图像的灰度直方图，统计各个灰度级别下像素的数量；2. 根据灰度直方图，计算图像的归一化直方图，即将各个灰度级别下像素的数量除以总像素数，得到每个灰度级别的概率；3. 初始化类内方差和类间方差为0；4. 遍历所有可能的阈值T（从0到255），对于每个阈值，将图像分为两部分：小于等于阈值的像素为一部分，大于阈值的像素为另一部分；5. 分别计算两部分像素的概率和均值，然后根据这些值计算类内方差和类间方差；6. 根据类间方差的值更新最佳阈值和最大类间方差；7. 遍历完所有可能的阈值后，得到最佳阈值，即类间方差最大化的阈值；8. 将图像根据最佳阈值进行分割。

Otsu阈值分割算法的优点是简单而有效，不需要事先对图像进行预处理，适用于各种类型的图像。

然而，该算法也存在一些限制。

首先，该算法假设目标和背景之间的灰度分布是双峰的，如果图像中存在多个目标或灰度分布不符合该假设，则效果可能不理想。

其次，该算法只能得到一个全局阈值，对于具有复杂纹理或光照变化的图像，可能需要使用其他方法进行分割。

总结而言，Otsu阈值分割算法是一种简单而有效的图像分割算法，通过最大化类间方差来确定最佳阈值。

它在实际应用中被广泛使用，可以用于目标检测、图像分析等领域。

Otsu多阈值快速求解算法精品文档4页

Otsu多阈值快速求解算法?フ? 要:最大类间方差(Otsu)方法计算简单，分割效果良好，广泛应用于图像的单阈值分割。

为了使Otsu方法能够适应于更加复杂的图像，很多学者对其进行了多阈值的推广，但存在计算量大、效率低的问题。

针对此不足，对Otsu方法也进行了多阈值的推广，首先划分直方图区间，然后采用快速二分法求取区间中的阈值以实现Otsu方法的多阈值扩展，使其在保持良好分割效果的基础上大大节省了时间。

实验说明了该算法的有效性。

?ス丶?词:图像分割；直方图区间；局部阈值；最大类间方差法；多阈值Abstract: Otsu has been widely used because of its simplicity in calculation and good segmentation result. And many scholars have put forward multithreshold Otsu method to make it more useful in more complex pictures. But this multithreshold Otsu method is of low efficiency and time consuming. Concerning this shortage, this paper made histogram intervals first, and then the rapid dichotomy was used to seek for the threshold in the interval. The improvement in this paper can maintain good segmentation result and save lots of time. The experiments show that the algorithm is effective.0 引言图像分割是将图像划分成若干个互不相交的小区域的过程，常见的图像分割方法有很多，比如：基于阈值的图像分割、模糊方法、边缘检测的方法、特征空间聚类的方法等［1］。

otsu's二值化算法

otsu's二值化算法Otsu's 二值化算法二值化是在图像处理中常用的一种技术，它可以将一幅灰度图像转化成只有两个颜色的图像，通常是黑白图像。

在很多应用中，一个图像可能包含了丰富的信息，而我们只对其中的某些特定信息感兴趣。

通过将图像二值化，我们可以将不相关的信息去除，从而更加准确地提取出我们所需的信息。

Otsu's 二值化算法是用于自动寻找最优阈值的一种二值化方法。

它是由日本学者大津展之在1979年提出的，至今仍然被广泛应用于图像处理领域。

Otsu's 二值化算法基于灰度直方图的分布特性，通过最大化类间方差来找到最佳阈值。

下面，我们将一步一步地回答有关Otsu's 二值化算法的问题，以帮助您更好地理解这个算法的原理和应用。

1. 什么是Otsu's 二值化算法？Otsu's 二值化算法是一种自动寻找最优阈值的二值化方法。

它通过最大化图像的类间方差来选择最佳阈值，从而能够更好地将图像分割成背景和前景两部分。

2. Otsu's 二值化算法的原理是什么？Otsu's 二值化算法的核心原理是基于类间方差最大化的思想。

在图像二值化的过程中，我们需要选择一个合适的阈值来将像素分为背景和前景两部分。

而Otsu's 二值化算法通过迭代计算灰度级的类间方差，找到一个阈值，使得类间方差最大化。

当类间方差最大化时，背景和前景之间的差异最明显，二值化效果最好。

3. Otsu's 二值化算法的具体步骤是什么？（1）计算图像的灰度直方图：统计图像中每个灰度级别的像素个数。

（2）对每个灰度级别进行归一化：将每个灰度级别的像素个数除以总像素数，得到各个灰度级别的像素占比。

（3）计算每个灰度级别的累积概率：对每个灰度级别的像素占比进行累积求和，得到累积概率。

（4）计算全局平均灰度值：通过累积概率来计算全局平均灰度值。

（5）计算类内方差：根据全局平均灰度值，计算每个灰度级别的类内方差。

otsu

C Otsu 自动阈值法分类:3S2007.1.14 19:39 作者：東風耐候| 评论：0 | 阅读：207Otsu(大津法)由大津于1979年提出，对图像Image，记t为前景与背景的分割阈值，前景点数占图像比例为w0，平均灰度为u0；背景点数占图像比例为w1，平均灰度为u1。

图像的总平均灰度为：u=w0*u0+w1*u1。

从最小灰度值到最大灰度值遍历t，当t使得值g=w0*(u0-u)^2+w1*(u1-u)^2 最大时t即为分割的最佳阈值。

对大津法可作如下理解：该式实际上就是类间方差值，阈值t分割出的前景和背景两部分构成了整幅图像，而前景取值u0，概率为w0，背景取值u1，概率为w1，总均值为u，根据方差的定义即得该式。

因方差是灰度分布均匀性的一种度量,方差值越大,说明构成图像的两部分差别越大, 当部分目标错分为背景或部分背景错分为目标都会导致两部分差别变小，因此使类间方差最大的分割意味着错分概率最小。

直接应用大津法计算量较大，因此我们在实现时采用了等价的公式g=w0*w1*(u0-u1)^2。

C++程序设计如下：//Otsu求阈值//输入为图像数据，有可能是数组，也有可能直接就是图像文件里出来的数据，考虑到每行的字节数，和行顺序不一致，所以特意加了一个参数Pitch，用来表示每行数据的字节数int Otsu(BYTE *Data,int Width,int Height,int Pitch){long His[256];double dHis[256];double Fangcha[256];int PXD=0;double Total=Width*Height;int i,j;//循环变量//获取直方图memset(Fangcha,0,256*sizeof(double));memset(His,0,256*sizeof(long) );for(i=0;i<Height;i++)for(j=0;j<Width;j++){His[ *(Data+i*Pitch+j) ] ++;}for(i=0;i<256;i++){dHis[i]=His[i]/Total;}//循环取阈值double w0,w1;//小于阈值的像素在图像中所占的百分比，和大于阈值的像素在图像中所占的百分比double g0,g1;//小于阈值像素的平均值,和大于阈值像素的平均值for(PXD=0;PXD<255;PXD++){g0=0;g1=0;w0=0;w1=0;for(i=0;i<=PXD;i++){g0 +=i*dHis[i];w0 +=dHis[i];}for(i=PXD+1;i<256;i++){g1 +=i*dHis[i];w1 +=dHis[i];}// double u=w0*g0 + w1*g1;//Fangcha[PXD]=w0*(g0-u)*(g0-u) + w1*(g1-u)*(g1-u); //使用等价公式Fangcha[PXD]=w0*w1*(g0-g1)*(g0-g1);}//for(PXD)//寻找最大方差值PXD=0;for(i=0;i<256;i++){if(Fangcha[PXD]<Fangcha[i]){PXD=i;}}return PXD;//返回Otsu阈值}2．另一种二值化ucMaxGrayValue = 0;ucMinGrayValue = 255;for (j = 0; j < pCurPage->pSrcImage->usHeight; j++){jOffset = j * pCurPage->pSrcImage->usRowBytes;for(i = 0; i < pCurPage->pSrcImage->usWidth; i++){bPixel = pCurPage->pSrcImage->lpImage[i+jOffset];plHistogram[bPixel]++;if (ucMinGrayValue > bPixel){ucMinGrayValue = bPixel;}if (ucMaxGrayValue < bPixel){ucMaxGrayValue = bPixel;}}}ucNewThreshold = (ucMinGrayValue + ucMaxGrayValue)/2;ucThreshold = 0;for(usIterationTimes = 0; (ucNewThreshold != ucThreshold) && (usIterationTimes < 100); usIterationTimes++){ucThreshold = ucNewThreshold;lP1 =0;lP2 =0;lS1 = 0;lS2 = 0;for (i = ucMinGrayValue; i < ucThreshold; i++){lP1 += plHistogram[i] * i;lS1 += plHistogram[i];}ucMean1GrayValue = (UCHAR)(lP1 / lS1);for (i = ucThreshold+1; i < ucMaxGrayValue; i++){lP2 += plHistogram[i] * i;lS2 += plHistogram[i];}ucMean2GrayValue = (UCHAR)(lP2 / lS2);ucNewThreshold = (ucMean1GrayValue + ucMean2GrayValue)/2;}2.otsuUCHAR ImageThresholdBlockOtsu(P_PALM_IMAGE pCurrentImage, int beginX, int beginY, int step){for (li = beginX; li < beginX + step && li < pCurrentImage->usWidth ; li++) {//for(lj = beginY;lj < beginY+step&&lj<2400;lj++)for(lj = beginY; lj < beginY + step && lj < pCurrentImage->usHeight; lj++){pucOnePoint = (PUCHAR)pCurrentImage->lpImage + lLineBytes * lj + li;ucpixel = (UCHAR)*pucOnePoint;ihist[ucpixel]++;}}// set up everythingsum = csum = 0.0;n = 0;for (k = 0; k <= 255; k++){sum += (DOUBLE) k * (DOUBLE) ihist[k]; /* x*f(x) 质量矩*/ n += ihist[k]; /* f(x) 质量*/}if (!n){// if n has no value, there is problems...return 0;}// do the otsu global thresholding methodfmax = -1.0;n1 = 0;for (k = 0; k < 255; k++){n1 += ihist[k];if (!n1){continue;}n2 = n - n1;if (n2 == 0){break;}csum += (double) k *ihist[k];m1 = csum / n1;m2 = (sum - csum) / n2;sb = (double) n1 *(double) n2 *(m1 - m2) * (m1 - m2);/* bbg: note: can be optimized. */if (sb > fmax){fmax = sb;thresholdValue = k;}}return thresholdValue;}OTSU 算法可以说是自适应计算单阈值（用来转换灰度图像为二值图像）的简单高效方法。