出处：http://blog.csdn.net/WuHaibing_CVer
       OTSU算法是由日本学者OTSU于1979年提出的一种对图像进行二值化的高效算法。
       1. OTSU算法原理简介
       对于一幅图像，设当前景与背景的分割阈值为t时，前景点占图像比例为w0，均值为u0，背景点占图像比例为w1，均值为u1。则整个图像的均值为u = w0*u0+w1*u1。建立目标函数g(t)=w0*(u0-u)^2+w1*(u1-u)^2，g(t)就是当分割阈值为t时的类间方差表达式。OTSU算法使得g(t)取得全局最大值，当g(t)为最大时所对应的t称为最佳阈值。OTSU算法又称为最大类间方差法。
       2.OTSU算法例程
下面是OSTU算法的C语言代码及其测试，代码基于opencv。
[cpp] view plain copy
 
#include <cv.h>  
#include <highgui.h>  
  
int otsu(IplImage *image)  
{  
    assert(NULL != image);  
  
    int width = image->width;  
    int height = image->height;  
    int x=0,y=0;  
    int pixelCount[256];  
    float pixelPro[256];  
    int i, j, pixelSum = width * height, threshold = 0;  
  
    uchar* data = (uchar*)image->imageData;  
  
    //初始化  
    for(i = 0; i < 256; i++)  
    {  
        pixelCount[i] = 0;  
        pixelPro[i] = 0;  
    }  
  
    //统计灰度级中每个像素在整幅图像中的个数  
    for(i = y; i < height; i++)  
    {  
        for(j = x;j <width;j++)  
        {  
            pixelCount[data[i * image->widthStep + j]]++;  
        }  
    }  
  
  
    //计算每个像素在整幅图像中的比例  
    for(i = 0; i < 256; i++)  
    {  
        pixelPro[i] = (float)(pixelCount[i]) / (float)(pixelSum);  
    }  
  
    //经典ostu算法,得到前景和背景的分割  
    //遍历灰度级[0,255],计算出方差最大的灰度值,为最佳阈值  
    float w0, w1, u0tmp, u1tmp, u0, u1, u,deltaTmp, deltaMax = 0;  
    for(i = 0; i < 256; i++)  
    {  
        w0 = w1 = u0tmp = u1tmp = u0 = u1 = u = deltaTmp = 0;  
  
        for(j = 0; j < 256; j++)  
        {  
            if(j <= i) //背景部分  
            {  
                //以i为阈值分类，第一类总的概率  
                w0 += pixelPro[j];        
                u0tmp += j * pixelPro[j];  
            }  
            else       //前景部分  
            {  
                //以i为阈值分类，第二类总的概率  
                w1 += pixelPro[j];        
                u1tmp += j * pixelPro[j];  
            }  
        }  
  
        u0 = u0tmp / w0;        //第一类的平均灰度  
        u1 = u1tmp / w1;        //第二类的平均灰度  
        u = u0tmp + u1tmp;      //整幅图像的平均灰度  
        //计算类间方差  
        deltaTmp = w0 * (u0 - u)*(u0 - u) + w1 * (u1 - u)*(u1 - u);  
        //找出最大类间方差以及对应的阈值  
        if(deltaTmp > deltaMax)  
        {     
            deltaMax = deltaTmp;  
            threshold = i;  
        }  
    }  
    //返回最佳阈值;  
    return threshold;  
}  
  
int main(int argc, char* argv[])  
{  
    IplImage* srcImage = cvLoadImage("D:\\technology\\CV\\Database\\image\\rice.png",0);  
    assert(NULL != srcImage);  
  
    cvNamedWindow("src");  
    cvShowImage("src",srcImage);  
  
    IplImage* biImage = cvCreateImage(cvGetSize(srcImage),8,1);  
  
    //计算最佳阈值  
    int threshold = otsu(srcImage);  
    //对图像二值化  
    cvThreshold(srcImage,biImage,threshold,255,CV_THRESH_BINARY);  
  
    cvNamedWindow("binary");  
    cvShowImage("binary",biImage);  
      
    cvWaitKey(0);  
  
    cvReleaseImage(&srcImage);  
    cvReleaseImage(&biImage);  
    cvDestroyWindow("src");  
    cvDestroyWindow("binary");  
  
    return 0;  
}  
下面是上述代码的运行结果图片。其中左边为原图像，右边为使用OTSU算法进行二值化后的图像。

    
OTSU算法
（1）原理：
对于图像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,即为所求。
将公式（5）带入（6）即可得到公式（7）。
（2）matlab函数：
matlab中函数graythresh既是使用大津法求得分割阈值Ｔ。用法如下：
　　　　　　T = graythresh(img);
　　　　　　BW = im2bw(img,T);
链接：https://zhuanlan.zhihu.com/p/34112446
 推导：

 
 
另一个参考链接：https://blog.csdn.net/liyuanbhu/article/details/49387483
 

转载于:https://www.cnblogs.com/yibeimingyue/p/10888246.html

OTSU算法是图像处理里面一个常用的方法，它主要用来自动的选择一个阈值，以此来对图片进行分割，更好的区别前景区域和背景区域。OTSU方法的思路比较简单，大体如下：
1.  将图像定义为两个部分，前景和背景；

a. 前景(foreground)，缩写为fg，其像素个数所占图像的比例为
，其像素的颜色的均值为
；
b. 背景(background)，缩写为bg，其像素个数所占图像的比例为
，其像素的颜色的均值为
；
整体图像的均值为   ；



2.  建立目标函数



求取最佳阈值t，满足g(t)取得全局最大值，此表达式称为类间方差表达式。




下面给出OTSU算法的代码：

int otsu(const IplImage *src_image)
{
	double sum = 0.0;
	double w0 = 0.0;
	double w1 = 0.0;
	double u0_temp = 0.0;
	double u1_temp = 0.0;
	double u0 = 0.0;
	double u1 = 0.0;
	double u = 0.0;
	double delta_temp = 0.0;
	double delta_max = 0.0;

	int pixel_count[256]={0};	//256个灰度级
	float pixel_pro[256]={0};	//每个灰度级出现的概率
	int threshold = 0;			//所求的最佳临界阈值

	uchar* data = (uchar*)src_image->imageData;
	//统计每个灰度级中像素的个数
	for(int i = 0; i < src_image->height; i++)
	{
		for(int j = 0;j < src_image->width;j++)
		{
			pixel_count[(int)data[i * src_image->width + j]]++;
			sum += (int)data[i * src_image->width + j];
		}
	}

    u = sum / ( src_image->height * src_image->width );

	//计算每个灰度级的像素数目占整幅图像的比例
	for(int i = 0; i < 256; i++)
	{
		pixel_pro[i] = (float)pixel_count[i] / ( src_image->height * src_image->width );
	}

	//遍历灰度级[0,255],寻找合适的threshold
	for(int i = 0; i < 256; i++)
	{
		w0 = w1 = u0_temp = u1_temp = u0 = u1 = delta_temp = 0;
		for(int j = 0; j < 256; j++)
		{
			//i值为当前暂定的阈值,小于i为背景，大于i为前景
			if(j <= i)   //背景部分
			{
				w0 += pixel_pro[j];
				u0_temp += j * pixel_pro[j];
			}
			else   //前景部分
			{
				w1 += pixel_pro[j];
				u1_temp += j * pixel_pro[j];
			}
		}
		u0 = u0_temp / w0;
		u1 = u1_temp / w1;
		u = u0_temp + u1_temp;
		delta_temp = w0 * pow((u0 - u), 2) + w1 * pow((u0 - u), 2);

		if(delta_temp > delta_max)
		{
			delta_max = delta_temp;
			threshold = i;
		}
	}
	return threshold;
}
下面是用OSTU算法的效果，三幅图依次是原图，掩码图，和提取的灰度图







otsu算法网上都是，原理就不细说了，下面给出一个基于opencv的图像二值化算法。opencv2.0已经包含了这个算法，如果装opencv2.0的话就不用自己写了，cvThreshold的最后一个参数可以选择是否是用otsu自动阈值
frame为输入图像，dst为二值化后的图像
void otsuThreshold(IplImage *frame,IplImage* dst)
{
 int width = frame->width;
 int height = frame->height;
 
 int i, j, pixelSum = width * height, threshold = 0;
 int pixelCount[255]={0};
 float pixelPro[255]={0};
 //uchar* data = (uchar*)frame->imageData;
 
 for(i = 0; i < GrayScale; i++)
 {
  pixelCount[i] = 0;
  pixelPro[i] = 0;
 }
 int dd=0;
 //统计灰度级中每个像素在整幅图像中的个数
 for(j = 0; j < height; j++)
 {
  for(i = 0;i < width;i++)
  {
   //pixelCount[(int)data[i * width + j]]++;
    dd=S(frame,i,j);
   pixelCount[S(frame,i,j)]++;
   if(dd!=255)
   {
    int kk=12;
   }
  }
 }
 
 //计算每个像素在整幅图像中的比例
 for(i = 0; i < GrayScale; i++)
 {
  pixelPro[i] = (float)pixelCount[i] / pixelSum;
 }
 
 //遍历灰度级[0,255]
 float w0, w1, u0tmp, u1tmp, u0, u1, u, 
  deltaTmp, deltaMax = 0;
 for(i = 0; i < GrayScale; 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 * (float)pow((u0 - u), 2) + w1 * (float)pow((u1 - u), 2);
  if(deltaTmp > deltaMax)
  {
   deltaMax = deltaTmp;
   threshold = i;
  }
 }
 cvThreshold(frame,dst,threshold,255,CV_THRESH_BINARY);
}