【opencv】大津法二值化

大津法代码

int otsuThreshold(IplImage* img)
{

    int T = 0;//阈值
    int height = img->height;
    int width  = img->width;
    int step      = img->widthStep;
    int channels  = img->nChannels;
    uchar* data  = (uchar*)img->imageData;
    double gSum0;//第一类灰度总值
    double gSum1;//第二类灰度总值
    double N0 = 0;//前景像素数
    double N1 = 0;//背景像素数
    double u0 = 0;//前景像素平均灰度
    double u1 = 0;//背景像素平均灰度
    double w0 = 0;//前景像素点数占整幅图像的比例为ω0
    double w1 = 0;//背景像素点数占整幅图像的比例为ω1
    double u = 0;//总平均灰度
    double tempg = -1;//临时类间方差
    double g = -1;//类间方差
    double Histogram[256]={0};// = new double[256];//灰度直方图
    double N = width*height;//总像素数
    for(int i=0;i<height;i++)
    {//计算直方图
        for(int j=0;j<width;j++)
        {
            double temp =data[i*step + j * 3] * 0.114 + data[i*step + j * 3+1] * 0.587 + data[i*step + j * 3+2] * 0.299;
            temp = temp<0? 0:temp;
            temp = temp>255? 255:temp;
            Histogram[(int)temp]++;
        } 
    }
    //计算阈值
    for (int i = 0;i<256;i++)
    {
        gSum0 = 0;
        gSum1 = 0;
        N0 += Histogram[i];         
        N1 = N-N0;
        if(0==N1)break;//当出现前景无像素点时，跳出循环
        w0 = N0/N;
        w1 = 1-w0;
        for (int j = 0;j<=i;j++)
        {
            gSum0 += j*Histogram[j];
        }
        u0 = gSum0/N0;
        for(int k = i+1;k<256;k++)
        {
            gSum1 += k*Histogram[k];
        }
        u1 = gSum1/N1;
        //u = w0*u0 + w1*u1;
        g = w0*w1*(u0-u1)*(u0-u1);
        if (tempg<g)
        {
            tempg = g;
            T = i;
        }
    }
    return T; 
}

int otsu(Mat image)
{
    int width = image.cols;
    int height = image.rows;
    int x = 0, y = 0;
    long int pixelCount[256];
    float pixelPro[256];
    int i, j, pixelSum = width * height, threshold = 0, threshold1;

    uchar* data = (uchar*)image.data;

    //初始化    
    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.step + 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,deltaMax1;
    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)
        {
            deltaMax1 = deltaMax;
            deltaMax = deltaTmp;
            threshold1= threshold;
            threshold = i;
        }
    }
    //返回最佳阈值;    
    return threshold1;
}