Matlab图像处理问题---大津法。

Posted 2023-03-31

请问用Matlab实现大津法的步骤是什么？我的Matlab水平比菜鸟还菜，但是我要写大津法的流程图，却对大津法一无所知啊。。请给位好心人给我说说步骤吧。。。谢谢了。

最大类间方差法是由日本学者大津于1979年提出的,是一种自适应的阈值确定的方法,又叫大津
法,简称OTSU。它是按图像的灰度特性,将图像分成背景和目标2部分。背景和目标之间的类间方差
越大,说明构成图像的2部分的差别越大,当部分目标错分为背景或部分背景错分为目标都会导致2部
分差别变小。因此,使类间方差最大的分割意味着错分概率最小。
对于图像I(x,y),前景(即目标)和背景的分割阈值记作T,属于前景的像素点数占整幅图像的比
例记为ω0,其平均灰度μ0;背景像素点数占整幅图像的比例为ω1,其平均灰度为μ1。图像的总平均
灰度记为μ,类间方差记为g。
假设图像的背景较暗,并且图像的大小为M×N,
图像中像素的灰度值小于阈值T的像素个数记作N0,像素灰度大于阈值T的像素个数记作N1,则有:
ω0=N0/ M×N (1)
ω1=N1/ M×N (2)
N0+N1=M×N (3)
ω0+ω1=1 (4)
μ=ω0*μ0+ω1*μ1 (5)
g=ω0(μ0-μ)^2+ω1(μ1-μ)^2 (6)
将式(5)代入式(6),得到等价公式:
g=ω0ω1(μ0-μ1)^2 (7)
采用遍历的方法得到使类间方差最大的阈值
T,即为所求。
int Otsu(long *pg,long *pg1) // 大津法取阈值

int i,j,p;
double A,B,An,Bn,u,v,qqq[256],max,min;
An=Bn=0;
for (i=0;i<256;i++)

An+=pg; Bn+=pg*(i+1);

for (j=0;j<256;j++)

A=B=0;
for (i=0;i<=j;i++)

A+=pg;
B+=pg*(i+1);

if (A) u=B/A;
else u=0;
if (An-A) v=(Bn-B)/(An-A);
else v=0;
qqq[j]=A*(An-A)*(u-v)*(u-v); // 计算类间方差

max=min=qqq[0]; p=0;
for (i=1;i<256;i++)
// 寻找判别函数最大值
if (qqq>max)

max=qqq;
p=i;

else if (qqq<min) min=qqq;

if (pg1!=0)

for (i=0;i<256;i++)

pg1=(long) (120*(qqq-min)/(max-min));


return(p); // 取判别函数最大值的灰度为其阈值
参考技术A 　　转载：
　　function y1=OTSU(image,th_set)

　　%a2=imread('color1.bmp');
　　gray=rgb2gray(image);%原图像的灰度图
　　low_high=stretchlim(gray);%增强图像，似乎也不是一定需要
　　gray=imadjust(gray,low_high,[]);
　　% subplot(224);imshow(gray);title('after adjust');

　　count=imhist(gray);
　　[r,t]=size(gray);
　　n=r*t;
　　l=256;
　　count=count/n;%各级灰度出现的概率
　　for i=2:l
　　if count(i)~=0
　　st=i-1;
　　break
　　end
　　end
　　%以上循环语句实现寻找出现概率不为0的最小灰度值
　　for i=l:-1:1
　　if count(i)~=0;
　　nd=i-1;
　　break
　　end
　　end
　　%实现找出出现概率不为0的最大灰度值
　　f=count(st+1:nd+1);
　　p=st;q=nd-st;%p和分别是灰度的起始和结束值
　　u=0;
　　for i=1:q;
　　u=u+f(i)*(p+i-1);
　　ua(i)=u;
　　end
　　%计算图像的平均灰度值
　　for i=1:q;
　　w(i)=sum(f(1:i));
　　end
　　%计算出选择不同k的时候，A区域的概率
　　d=(u*w-ua).^2./(w.*(1-w));%求出不同k值时类间方差
　　[y,tp]=max(d);%求出最大方差对应的灰度级
　　th=tp+p;
　　if th<th_set
　　th=tp+p;
　　else
　　th=th_set; %根据具体情况适当修正门限
　　end
　　y1=zeros(r,t);
　　for i=1:r
　　for j=1:t
　　x1(i,j)=double(gray(i,j));
　　end
　　end
　　for i=1:r
　　for j=1:t
　　if (x1(i,j)>th)
　　y1(i,j)=x1(i,j);
　　else
　　y1(i,j)=0;
　　end
　　end
　　end
　　%上面一段代码实现分割
　　% figure,imshow(y1);
　　% title('灰度门限分割的图像');追问

请问正门限的取值范围是多少啊？谢谢您

追答

门限就是阈值，大津法是用最大类间方差来自适应选取阈值的，这个取值范围就不好说了，根据具体图像吧。

本回答被提问者采纳 参考技术B 最好去玩玩老师之类的

大津法---OTSU算法

简介：

大津法（OTSU）是一种确定图像二值化分割阈值的算法，由日本学者大津于1979年提出。从大津法的原理上来讲，该方法又称作最大类间方差法，因为按照大津法求得的阈值进行图像二值化分割后，前景与背景图像的类间方差最大（何为类间方差？原理中有介绍）。

OTSU算法

OTSU算法也称最大类间差法，有时也称之为大津算法，由大津于1979年提出，被认为是图像分割中阈值选取的最佳算法，计算简单，不受图像亮度和对比度的影响，因此在数字图像处理上得到了广泛的应用。它是按图像的灰度特性,将图像分成背景和前景两部分。因方差是灰度分布均匀性的一种度量,背景和前景之间的类间方差越大,说明构成图像的两部分的差别越大,当部分前景错分为背景或部分背景错分为前景都会导致两部分差别变小。因此,使类间方差最大的分割意味着错分概率最小。

原理：

对于图像I(x,y)，前景(即目标)和背景的分割阈值记作T，属于前景的像素点数占整幅图像的比例记为ω0，其平均灰度μ0；背景像素点数占整幅图像的比例为ω1，其平均灰度为μ1。图像的总平均灰度记为μ，类间方差记为g。

假设图像的背景较暗，并且图像的大小为M×N，图像中像素的灰度值小于阈值T的像素个数记作N0，像素灰度大于阈值T的像素个数记作N1，则有：
　　　　　　ω0=N0/ M×N (1)
　　　　　　ω1=N1/ M×N (2)
　　　　　　N0+N1=M×N (3)
　　　　　　ω0+ω1=1　　　 (4)
　　　　　　μ=ω0*μ0+ω1*μ1 (5)
　　　　　　g=ω0(μ0-μ)^2+ω1(μ1-μ)^2 (6)
将式(5)代入式(6),得到等价公式:
　　　　　　g=ω0ω1(μ0-μ1)^2 　　 (7)　这就是类间方差
采用遍历的方法得到使类间方差g最大的阈值T,即为所求。

matlab函数：

matlab中函数graythresh既是使用大津法求得分割阈值Ｔ。用法如下：

　　　　　　T = graythresh(img);

　　　　　　BW = im2bw(img,T);

大津法的形象理解：

对于直方图有两个峰值的图像，大津法求得的Ｔ近似等于两个峰值之间的低谷。

　　　　　　imhist(img);

T = graythresh(img);

如下图为图像的直方图，使大津法求得的Ｔ＝0.5294，转换在［0,255］之间为134.9970，只好是两个峰值之间低谷的位置。

OpenCV的二值化操作中，有一种“大津阈值处理”的方法，使用函数cvThreshold(image,image2,0,255,CV_THRESH_OTSU) 实现，该函数就会使用大律法OTSU得到的全局自适应阈值来进行二值化图片，而参数中的threshold不再起作用。

以下是一段在OpenCV中实现的C语言程序，即一个使用OTSU算法提取图像阈值的函数，输入参数为一个图像指针，返回分割该图像的最佳阈值。

其中的变量说明：当分割的阈值为t时

w0为背景像素点占整幅图像的比例

u0为w0平均灰度

w1为前景像素点占整幅图像的比例

u1为w1平均灰度

u为整幅图像的平均灰度

公式:g = w0*pow((u-u0),2) + w1*pow((u-u1),2)

int MyAutoFocusDll::otsuThreshold(IplImage *frame)
{
    const int GrayScale = 256;
    int width = frame->width;
    int height = frame->height;
    int pixelCount[GrayScale];
    float pixelPro[GrayScale];
    int i, j, pixelSum = width * height, threshold = 0;
    uchar* data = (uchar*)frame->imageData;  //指向像素数据的指针
    for (i = 0; i < GrayScale; i++)
    {
        pixelCount[i] = 0;
        pixelPro[i] = 0;
    }

    //统计灰度级中每个像素在整幅图像中的个数  
    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++)
        {
            pixelCount[(int)data[i * width + j]]++;  //将像素值作为计数数组的下标
        }
    }

    //计算每个像素在整幅图像中的比例  
    float maxPro = 0.0;
    int kk = 0;
    for (i = 0; i < GrayScale; i++)
    {
        pixelPro[i] = (float)pixelCount[i] / pixelSum;
        if (pixelPro[i] > maxPro)
        {
            maxPro = pixelPro[i];
            kk = i;
        }
    }

    //遍历灰度级[0,255]  
    float w0, w1, u0tmp, u1tmp, u0, u1, u, deltaTmp, deltaMax = 0;
    for (i = 0; i < GrayScale; i++)     // i作为阈值
    {
        w0 = w1 = u0tmp = u1tmp = u0 = u1 = u = deltaTmp = 0;
        for (j = 0; j < GrayScale; j++)
        {
            if (j <= i)   //背景部分  
            {
                w0 += pixelPro[j];
                u0tmp += j * pixelPro[j];
            }
            else   //前景部分  
            {
                w1 += pixelPro[j];
                u1tmp += j * pixelPro[j];
            }
        }
        u0 = u0tmp / w0;
        u1 = u1tmp / w1;
        u = u0tmp + u1tmp;
        deltaTmp = w0 * pow((u0 - u), 2) + w1 * pow((u1 - u), 2);
        if (deltaTmp > deltaMax)
        {
            deltaMax = deltaTmp;
            threshold = i;
        }
    }

    return threshold;
}