Open CV 七种常见阈值分割

整理摘录 skyseraph 代码所得

出处：http://www.cnblogs.com/skyseraph/

复制The All 可直接运行

#include <windows.h>
#include "cv.h"
#include "highgui.h"
#include <stdio.h>
#include <math.h>
#include <iostream>
#include <ctime>

using namespace std;
/*===============================核心程序===========================================*/
int main(int argc,char** argv)
{
    IplImage *src,*grayImg;
    src=cvLoadImage("Lena.jpg",1);
    grayImg=cvCreateImage(cvGetSize(src),src->depth,1);
    cvCvtColor(src,grayImg,CV_BGR2GRAY);
    
    /*===============================图像分割=====================================*/
    
    /*手动设置阈值*/
    IplImage* binaryImg = cvCreateImage(cvGetSize(src),IPL_DEPTH_8U, 1);
    cvThreshold(grayImg,binaryImg,71,255,CV_THRESH_BINARY); 
    cvNamedWindow("cvThreshold", CV_WINDOW_AUTOSIZE );
    cvShowImage( "cvThreshold", binaryImg );
    const char* path1;
    path1="Threshold.bmp";
    cvSaveImage(path1, binaryImg);
    

    /*---------------------------------------------------------------------------*/
    /*自适应阀值  //计算像域邻域的平均灰度，来决定二值化的值*/

    IplImage* adThresImg = cvCreateImage(cvGetSize(src),IPL_DEPTH_8U, 1);
    double max_value=255;
    int adpative_method=CV_ADAPTIVE_THRESH_GAUSSIAN_C;//CV_ADAPTIVE_THRESH_MEAN_C
    int threshold_type=CV_THRESH_BINARY;
    int block_size=3;//阈值的象素邻域大小
    int offset=5;//窗口尺寸
    cvAdaptiveThreshold(grayImg,adThresImg,max_value,adpative_method,threshold_type,block_size,offset);
    cvNamedWindow("cvAdaptiveThreshold", CV_WINDOW_AUTOSIZE );
    cvShowImage( "cvAdaptiveThreshold", adThresImg );
    const char* path2;
    path2="AdaptiveThreshold.bmp";
    cvSaveImage(path2, adThresImg);
    /*---------------------------------------------------------------------------*/
    
    
    /*最大熵阀值分割法*/
    
    IplImage* imgMaxEntropy = cvCreateImage(cvGetSize(src),IPL_DEPTH_8U,1);
    MaxEntropy(grayImg,imgMaxEntropy);
    cvNamedWindow("MaxEntroyThreshold", CV_WINDOW_AUTOSIZE );
    cvShowImage( "MaxEntroyThreshold", imgMaxEntropy );//显示图像
    const char* path3;
    path3="MaxEntropy.bmp";
    cvSaveImage(path3, imgMaxEntropy);
    
    /*-----------------------------------------------------------------------------*/
    
    /*基本全局阀值法*/
  
    IplImage* imgBasicGlobalThreshold = cvCreateImage(cvGetSize(grayImg),IPL_DEPTH_8U,1);
    imgBasicGlobalThreshold=cvCloneImage(grayImg);
    int  pg[256],i,thre;    
    for (i=0;i<256;i++) pg[i]=0;
    for (i=0;i<imgBasicGlobalThreshold->imageSize;i++)      //  直方图统计
        pg[(byte)imgBasicGlobalThreshold->imageData[i]]++;    
    thre = BasicGlobalThreshold(pg,0,256);    //  确定阈值
    cout<<"The Threshold of this Image in BasicGlobalThreshold is:"<<thre<<endl;//输出显示阀值
    cvThreshold(imgBasicGlobalThreshold,imgBasicGlobalThreshold,thre,255,CV_THRESH_BINARY);  //  二值化    
    cvNamedWindow("BasicGlobalThreshold", CV_WINDOW_AUTOSIZE );
    cvShowImage( "BasicGlobalThreshold", imgBasicGlobalThreshold);//显示图像
    const char* path4;
    path4="BasicGlobalThreshold.bmp";
    cvSaveImage(path4, imgBasicGlobalThreshold);
    
/*----------------------------------------------------------------------------------------*/

   /*OTSU*/

    IplImage* imgOtsu = cvCreateImage(cvGetSize(grayImg),IPL_DEPTH_8U,1);
    imgOtsu=cvCloneImage(grayImg);
    int thre2;
    thre2 = otsu(imgOtsu);
    cout<<"The Threshold of this Image in Otsu is:"<<thre2<<endl;//输出显示阀值
    cvThreshold(imgOtsu,imgOtsu,thre2,255,CV_THRESH_BINARY);  //  二值化    
    cvNamedWindow("imgOtsu", CV_WINDOW_AUTOSIZE );
    cvShowImage( "imgOtsu", imgOtsu);//显示图像
    const char* path5;
    path5="Otsu.bmp";
    cvSaveImage(path5, imgOtsu);

/*-------------------------------------------------------------------------------------------*/
    /*上下阀值法：利用正态分布求可信区间*/
    IplImage* imgTopDown = cvCreateImage( cvGetSize(grayImg), IPL_DEPTH_8U, 1 );
    imgTopDown=cvCloneImage(grayImg);
    CvScalar mean ,std_dev;//平均值、 标准差
    double u_threshold,d_threshold;
    cvAvgSdv(imgTopDown,&mean,&std_dev,NULL);    
    u_threshold = mean.val[0] +2.5* std_dev.val[0];//上阀值
    d_threshold = mean.val[0] -2.5* std_dev.val[0];//下阀值
    cout<<"The TopThreshold of this Image in TopDown is:"<<d_threshold<<endl;//输出显示阀值
    cout<<"The DownThreshold of this Image in TopDown is:"<<u_threshold<<endl;
    cvThreshold(imgTopDown,imgTopDown,d_threshold,u_threshold,CV_THRESH_BINARY_INV);//上下阀值
    cvNamedWindow("imgTopDown", CV_WINDOW_AUTOSIZE );
    cvShowImage( "imgTopDown", imgTopDown);//显示图像 
    const char* path6;
    path6="TopDown.bmp";
    cvSaveImage(path6, imgTopDown);
    
    /*---------------------------------------------------------------------------*/
    /*迭代法*/
    IplImage* imgIteration = cvCreateImage( cvGetSize(grayImg), IPL_DEPTH_8U, 1 );
    imgIteration=cvCloneImage(grayImg);
    int thre3,nDiffRec;
    thre3 =DetectThreshold(imgIteration, 100, nDiffRec);
    cout<<"The Threshold of this Image in imgIteration is:"<<thre3<<endl;//输出显示阀值
    cvThreshold(imgIteration,imgIteration,thre3,255,CV_THRESH_BINARY_INV);//上下阀值
    cvNamedWindow("imgIteration", CV_WINDOW_AUTOSIZE );
    cvShowImage( "imgIteration", imgIteration);
    const char* path7;
    path7="Iteration.bmp";
    cvSaveImage(path7, imgIteration);
    
    
    
    
    /*---------------------------------------------------------------------------*/
    /*释放内存空间*/
    cvReleaseImage(&imgIteration);
    cvReleaseImage(&imgTopDown);
    cvReleaseImage(&imgOtsu);
    cvReleaseImage(&imgBasicGlobalThreshold);
    cvReleaseImage(&imgMaxEntropy );
    cvReleaseImage(&adThresImg);
    cvReleaseImage(&binaryImg);
    cvWaitKey(0);return 0;
}

/*============================================================================
=  代码内容：最大熵阈值分割                                      
=  修改日期:2009-3-3                                                                                                         
=  作者:crond123 
=  博客:http://blog.csdn.net/crond123/
=  E_Mail:crond123@163.com                                                      
===============================================================================*/
// 计算当前位置的能量熵
int HistogramBins = 256;
float HistogramRange1[2] = {0,255};
float *HistogramRange[1] = {&HistogramRange1[0]};
typedef enum {back,object} entropy_state;
double caculateCurrentEntropy(CvHistogram * Histogram1,int cur_threshold,entropy_state state)
{
int start,end;
int  total =0;
double cur_entropy =0.0;
if(state == back)    
    {
        start =0;
        end = cur_threshold;    
    }
else    
    {
        start = cur_threshold;
        end =256;    
    }    
for(int i=start;i<end;i++)    
    {
        total += (int)cvQueryHistValue_1D(Histogram1,i);//查询直方块的值 P304
    }
for(int j=start;j<end;j++)
    {
if((int)cvQueryHistValue_1D(Histogram1,j)==0)
continue;
double percentage = cvQueryHistValue_1D(Histogram1,j)/total;
/*熵的定义公式*/
        cur_entropy +=-percentage*logf(percentage);
/*根据泰勒展式去掉高次项得到的熵的近似计算公式
        cur_entropy += percentage*percentage;*/        
    }
return cur_entropy;
//    return (1-cur_entropy);
}

//寻找最大熵阈值并分割
void  MaxEntropy(IplImage *src,IplImage *dst)
{
    assert(src != NULL);
    assert(src->depth ==8&& dst->depth ==8);
    assert(src->nChannels ==1);
    CvHistogram * hist  = cvCreateHist(1,&HistogramBins,CV_HIST_ARRAY,HistogramRange);//创建一个指定尺寸的直方图
//参数含义：直方图包含的维数、直方图维数尺寸的数组、直方图的表示格式、方块范围数组、归一化标志
    cvCalcHist(&src,hist);//计算直方图
double maxentropy =-1.0;
int max_index =-1;
// 循环测试每个分割点，寻找到最大的阈值分割点
for(int i=0;i<HistogramBins;i++)    
    {
double cur_entropy = caculateCurrentEntropy(hist,i,object)+caculateCurrentEntropy(hist,i,back);
if(cur_entropy>maxentropy)
        {
            maxentropy = cur_entropy;
            max_index = i;
        }
    }
    cout<<"The Threshold of this Image in MaxEntropy is:"<<max_index<<endl;
    cvThreshold(src, dst, (double)max_index,255, CV_THRESH_BINARY);
    cvReleaseHist(&hist);
}


   /*============================================================================
    =  代码内容：基本全局阈值法                              
    ==============================================================================*/
    int BasicGlobalThreshold(int*pg,int start,int end)
{                                           //  基本全局阈值法
    int  i,t,t1,t2,k1,k2;
    double u,u1,u2;    
    t=0;     
    u=0;
    for (i=start;i<end;i++) 
    {
        t+=pg[i];        
        u+=i*pg[i];
    }
    k2=(int) (u/t);                          //  计算此范围灰度的平均值    
    do 
    {
        k1=k2;
        t1=0;    
        u1=0;
        for (i=start;i<=k1;i++) 
        {             //  计算低灰度组的累加和
            t1+=pg[i];    
            u1+=i*pg[i];
        }
        t2=t-t1;
        u2=u-u1;
        if (t1) 
            u1=u1/t1;                     //  计算低灰度组的平均值
        else 
            u1=0;
        if (t2) 
            u2=u2/t2;                     //  计算高灰度组的平均值
        else 
            u2=0;
        k2=(int) ((u1+u2)/2);                 //  得到新的阈值估计值
    }
    while(k1!=k2);                           //  数据未稳定，继续
    //cout<<"The Threshold of this Image in BasicGlobalThreshold is:"<<k1<<endl;
    return(k1);                              //  返回阈值
}

    /*======================================================================*/
    /* OTSU global thresholding routine */
    /*======================================================================*/
    int otsu (IplImage *image)
    {
        int w = image->width;
        int h = image->height;

        unsigned char*np; // 图像指针
        unsigned char pixel;
        int thresholdValue=1; // 阈值
        int ihist[256]; // 图像直方图，256个点

        int i, j, k; // various counters
        int n, n1, n2, gmin, gmax;
        double m1, m2, sum, csum, fmax, sb;

        // 对直方图置零...
        memset(ihist, 0, sizeof(ihist));

        gmin=255; gmax=0;
        // 生成直方图
        for (i =0; i < h; i++) 
        {
            np = (unsigned char*)(image->imageData + image->widthStep*i);
            for (j =0; j < w; j++) 
            {
                pixel = np[j];
                ihist[ pixel]++;
                if(pixel > gmax) gmax= pixel;
                if(pixel < gmin) gmin= pixel;
            }
        }

        // set up everything
        sum = csum =0.0;
        n =0;

        for (k =0; k <=255; k++) 
        {
            sum += k * ihist[k]; /* x*f(x) 质量矩*/
            n += ihist[k]; /* f(x) 质量 */
        }

        if (!n) 
        {
            // if n has no value, there is problems...
            //fprintf (stderr, "NOT NORMAL thresholdValue = 160
");
            thresholdValue =160;
            goto L;
        }

        // do the otsu global thresholding method
        fmax =-1.0;
        n1 =0;
        for (k =0; k <255; k++) 
        {
            n1 += ihist[k];
            if (!n1) { continue; }
            n2 = n - n1;
            if (n2 ==0) { break; }
            csum += k *ihist[k];
            m1 = csum / n1;
            m2 = (sum - csum) / n2;
            sb = n1 * n2 *(m1 - m2) * (m1 - m2);
            /* bbg: note: can be optimized. */
            if (sb > fmax)
            {
                fmax = sb;
                thresholdValue = k;
            }
        }

L:
        for (i =0; i < h; i++) 
        {
            np = (unsigned char*)(image->imageData + image->widthStep*i);
            for (j =0; j < w; j++) 
            {
                if(np[j] >= thresholdValue)
                    np[j] =255;
                else np[j] =0;
            }
        }

        //cout<<"The Threshold of this Image in Otsu is:"<<thresholdValue<<endl;
        return(thresholdValue);
    }

    /*======================================================================*/
    /* 迭代法*/
    /*======================================================================*/
    // nMaxIter：最大迭代次数；nDiffRec：使用给定阀值确定的亮区与暗区平均灰度差异值
    int DetectThreshold(IplImage*img, int nMaxIter, int& iDiffRec)  //阀值分割：迭代法
    {
        //图像信息
        int height = img->height;
        int width = img->width;
        int step = img->widthStep/sizeof(uchar);
        uchar *data = (uchar*)img->imageData;

        iDiffRec =0;
        int F[256]={ 0 }; //直方图数组
        int iTotalGray=0;//灰度值和
        int iTotalPixel =0;//像素数和
        byte bt;//某点的像素值

        uchar iThrehold,iNewThrehold;//阀值、新阀值
        uchar iMaxGrayValue=0,iMinGrayValue=255;//原图像中的最大灰度值和最小灰度值
        uchar iMeanGrayValue1,iMeanGrayValue2;

        //获取(i,j)的值，存于直方图数组F
        for(int i=0;i<width;i++)
        {
            for(int j=0;j<height;j++)
            {
                bt = data[i*step+j];
                if(bt<iMinGrayValue)
                    iMinGrayValue = bt;
                if(bt>iMaxGrayValue)
                    iMaxGrayValue = bt;
                F[bt]++;
            }
        }

        iThrehold =0;//
        iNewThrehold = (iMinGrayValue+iMaxGrayValue)/2;//初始阀值
        iDiffRec = iMaxGrayValue - iMinGrayValue;

        for(int a=0;(abs(iThrehold-iNewThrehold)>0.5)&&a<nMaxIter;a++)//迭代中止条件
        {
            iThrehold = iNewThrehold;
            //小于当前阀值部分的平均灰度值
            for(int i=iMinGrayValue;i<iThrehold;i++)
            {
                iTotalGray += F[i]*i;//F[]存储图像信息
                iTotalPixel += F[i];
            }
            iMeanGrayValue1 = (uchar)(iTotalGray/iTotalPixel);
            //大于当前阀值部分的平均灰度值
            iTotalPixel =0;
            iTotalGray =0;
            for(int j=iThrehold+1;j<iMaxGrayValue;j++)
            {
                iTotalGray += F[j]*j;//F[]存储图像信息
                iTotalPixel += F[j];    
            }
            iMeanGrayValue2 = (uchar)(iTotalGray/iTotalPixel);

            iNewThrehold = (iMeanGrayValue2+iMeanGrayValue1)/2;        //新阀值
            iDiffRec = abs(iMeanGrayValue2 - iMeanGrayValue1);
        }

        //cout<<"The Threshold of this Image in imgIteration is:"<<iThrehold<<endl;
        return iThrehold;
    }

#include <windows.h>
#include "cv.h"
#include "highgui.h"
#include <stdio.h>
#include <math.h>
#include <iostream>
#include <ctime>

using namespace std;

/*============================================================================
=  代码内容：最大熵阈值分割                                      
=  修改日期:2009-3-3                                                                                                         
=  作者:crond123 
=  博客:http://blog.csdn.net/crond123/
=  E_Mail:crond123@163.com                                                      
===============================================================================*/
// 计算当前位置的能量熵
int HistogramBins = 256;
float HistogramRange1[2] = {0,255};
float *HistogramRange[1] = {&HistogramRange1[0]};
typedef enum {back,object} entropy_state;
double caculateCurrentEntropy(CvHistogram * Histogram1,int cur_threshold,entropy_state state)
{
int start,end;
int  total =0;
double cur_entropy =0.0;
if(state == back)    
    {
        start =0;
        end = cur_threshold;    
    }
else    
    {
        start = cur_threshold;
        end =256;    
    }    
for(int i=start;i<end;i++)    
    {
        total += (int)cvQueryHistValue_1D(Histogram1,i);//查询直方块的值 P304
    }
for(int j=start;j<end;j++)
    {
if((int)cvQueryHistValue_1D(Histogram1,j)==0)
continue;
double percentage = cvQueryHistValue_1D(Histogram1,j)/total;
/*熵的定义公式*/
        cur_entropy +=-percentage*logf(percentage);
/*根据泰勒展式去掉高次项得到的熵的近似计算公式
        cur_entropy += percentage*percentage;*/        
    }
return cur_entropy;
//    return (1-cur_entropy);
}

//寻找最大熵阈值并分割
void  MaxEntropy(IplImage *src,IplImage *dst)
{
    assert(src != NULL);
    assert(src->depth ==8&& dst->depth ==8);
    assert(src->nChannels ==1);
    CvHistogram * hist  = cvCreateHist(1,&HistogramBins,CV_HIST_ARRAY,HistogramRange);//创建一个指定尺寸的直方图
//参数含义：直方图包含的维数、直方图维数尺寸的数组、直方图的表示格式、方块范围数组、归一化标志
    cvCalcHist(&src,hist);//计算直方图
double maxentropy =-1.0;
int max_index =-1;
// 循环测试每个分割点，寻找到最大的阈值分割点
for(int i=0;i<HistogramBins;i++)    
    {
double cur_entropy = caculateCurrentEntropy(hist,i,object)+caculateCurrentEntropy(hist,i,back);
if(cur_entropy>maxentropy)
        {
            maxentropy = cur_entropy;
            max_index = i;
        }
    }
    cout<<"The Threshold of this Image in MaxEntropy is:"<<max_index<<endl;
    cvThreshold(src, dst, (double)max_index,255, CV_THRESH_BINARY);
    cvReleaseHist(&hist);
}


   /*============================================================================
    =  代码内容：基本全局阈值法                              
    ==============================================================================*/
    int BasicGlobalThreshold(int*pg,int start,int end)
{                                           //  基本全局阈值法
    int  i,t,t1,t2,k1,k2;
    double u,u1,u2;    
    t=0;     
    u=0;
    for (i=start;i<end;i++) 
    {
        t+=pg[i];        
        u+=i*pg[i];
    }
    k2=(int) (u/t);                          //  计算此范围灰度的平均值    
    do 
    {
        k1=k2;
        t1=0;    
        u1=0;
        for (i=start;i<=k1;i++) 
        {             //  计算低灰度组的累加和
            t1+=pg[i];    
            u1+=i*pg[i];
        }
        t2=t-t1;
        u2=u-u1;
        if (t1) 
            u1=u1/t1;                     //  计算低灰度组的平均值
        else 
            u1=0;
        if (t2) 
            u2=u2/t2;                     //  计算高灰度组的平均值
        else 
            u2=0;
        k2=(int) ((u1+u2)/2);                 //  得到新的阈值估计值
    }
    while(k1!=k2);                           //  数据未稳定，继续
    //cout<<"The Threshold of this Image in BasicGlobalThreshold is:"<<k1<<endl;
    return(k1);                              //  返回阈值
}

    /*======================================================================*/
    /* OTSU global thresholding routine */
    /*======================================================================*/
    int otsu (IplImage *image)
    {
        int w = image->width;
        int h = image->height;

        unsigned char*np; // 图像指针
        unsigned char pixel;
        int thresholdValue=1; // 阈值
        int ihist[256]; // 图像直方图，256个点

        int i, j, k; // various counters
        int n, n1, n2, gmin, gmax;
        double m1, m2, sum, csum, fmax, sb;

        // 对直方图置零...
        memset(ihist, 0, sizeof(ihist));

        gmin=255; gmax=0;
        // 生成直方图
        for (i =0; i < h; i++) 
        {
            np = (unsigned char*)(image->imageData + image->widthStep*i);
            for (j =0; j < w; j++) 
            {
                pixel = np[j];
                ihist[ pixel]++;
                if(pixel > gmax) gmax= pixel;
                if(pixel < gmin) gmin= pixel;
            }
        }

        // set up everything
        sum = csum =0.0;
        n =0;

        for (k =0; k <=255; k++) 
        {
            sum += k * ihist[k]; /* x*f(x) 质量矩*/
            n += ihist[k]; /* f(x) 质量 */
        }

        if (!n) 
        {
            // if n has no value, there is problems...
            //fprintf (stderr, "NOT NORMAL thresholdValue = 160
");
            thresholdValue =160;
            goto L;
        }

        // do the otsu global thresholding method
        fmax =-1.0;
        n1 =0;
        for (k =0; k <255; k++) 
        {
            n1 += ihist[k];
            if (!n1) { continue; }
            n2 = n - n1;
            if (n2 ==0) { break; }
            csum += k *ihist[k];
            m1 = csum / n1;
            m2 = (sum - csum) / n2;
            sb = n1 * n2 *(m1 - m2) * (m1 - m2);
            /* bbg: note: can be optimized. */
            if (sb > fmax)
            {
                fmax = sb;
                thresholdValue = k;
            }
        }

L:
        for (i =0; i < h; i++) 
        {
            np = (unsigned char*)(image->imageData + image->widthStep*i);
            for (j =0; j < w; j++) 
            {
                if(np[j] >= thresholdValue)
                    np[j] =255;
                else np[j] =0;
            }
        }

        //cout<<"The Threshold of this Image in Otsu is:"<<thresholdValue<<endl;
        return(thresholdValue);
    }

    /*======================================================================*/
    /* 迭代法*/
    /*======================================================================*/
    // nMaxIter：最大迭代次数；nDiffRec：使用给定阀值确定的亮区与暗区平均灰度差异值
    int DetectThreshold(IplImage*img, int nMaxIter, int& iDiffRec)  //阀值分割：迭代法
    {
        //图像信息
        int height = img->height;
        int width = img->width;
        int step = img->widthStep/sizeof(uchar);
        uchar *data = (uchar*)img->imageData;

        iDiffRec =0;
        int F[256]={ 0 }; //直方图数组
        int iTotalGray=0;//灰度值和
        int iTotalPixel =0;//像素数和
        byte bt;//某点的像素值

        uchar iThrehold,iNewThrehold;//阀值、新阀值
        uchar iMaxGrayValue=0,iMinGrayValue=255;//原图像中的最大灰度值和最小灰度值
        uchar iMeanGrayValue1,iMeanGrayValue2;

        //获取(i,j)的值，存于直方图数组F
        for(int i=0;i<width;i++)
        {
            for(int j=0;j<height;j++)
            {
                bt = data[i*step+j];
                if(bt<iMinGrayValue)
                    iMinGrayValue = bt;
                if(bt>iMaxGrayValue)
                    iMaxGrayValue = bt;
                F[bt]++;
            }
        }

        iThrehold =0;//
        iNewThrehold = (iMinGrayValue+iMaxGrayValue)/2;//初始阀值
        iDiffRec = iMaxGrayValue - iMinGrayValue;

        for(int a=0;(abs(iThrehold-iNewThrehold)>0.5)&&a<nMaxIter;a++)//迭代中止条件
        {
            iThrehold = iNewThrehold;
            //小于当前阀值部分的平均灰度值
            for(int i=iMinGrayValue;i<iThrehold;i++)
            {
                iTotalGray += F[i]*i;//F[]存储图像信息
                iTotalPixel += F[i];
            }
            iMeanGrayValue1 = (uchar)(iTotalGray/iTotalPixel);
            //大于当前阀值部分的平均灰度值
            iTotalPixel =0;
            iTotalGray =0;
            for(int j=iThrehold+1;j<iMaxGrayValue;j++)
            {
                iTotalGray += F[j]*j;//F[]存储图像信息
                iTotalPixel += F[j];    
            }
            iMeanGrayValue2 = (uchar)(iTotalGray/iTotalPixel);

            iNewThrehold = (iMeanGrayValue2+iMeanGrayValue1)/2;        //新阀值
            iDiffRec = abs(iMeanGrayValue2 - iMeanGrayValue1);
        }

        //cout<<"The Threshold of this Image in imgIteration is:"<<iThrehold<<endl;
        return iThrehold;
    }

    
/*===============================核心程序===========================================*/
int main(int argc,char** argv)
{
    IplImage *src,*grayImg;
    src=cvLoadImage("Lena.jpg",1);
    grayImg=cvCreateImage(cvGetSize(src),src->depth,1);
    cvCvtColor(src,grayImg,CV_BGR2GRAY);
    
    /*===============================图像分割=====================================*/
    
    /*手动设置阈值*/
    IplImage* binaryImg = cvCreateImage(cvGetSize(src),IPL_DEPTH_8U, 1);
    cvThreshold(grayImg,binaryImg,71,255,CV_THRESH_BINARY); 
    cvNamedWindow("cvThreshold", CV_WINDOW_AUTOSIZE );
    cvShowImage( "cvThreshold", binaryImg );
    const char* path1;
    path1="Threshold.bmp";
    cvSaveImage(path1, binaryImg);
    

    /*---------------------------------------------------------------------------*/
    /*自适应阀值  //计算像域邻域的平均灰度，来决定二值化的值*/

    IplImage* adThresImg = cvCreateImage(cvGetSize(src),IPL_DEPTH_8U, 1);
    double max_value=255;
    int adpative_method=CV_ADAPTIVE_THRESH_GAUSSIAN_C;//CV_ADAPTIVE_THRESH_MEAN_C
    int threshold_type=CV_THRESH_BINARY;
    int block_size=3;//阈值的象素邻域大小
    int offset=5;//窗口尺寸
    cvAdaptiveThreshold(grayImg,adThresImg,max_value,adpative_method,threshold_type,block_size,offset);
    cvNamedWindow("cvAdaptiveThreshold", CV_WINDOW_AUTOSIZE );
    cvShowImage( "cvAdaptiveThreshold", adThresImg );
    const char* path2;
    path2="AdaptiveThreshold.bmp";
    cvSaveImage(path2, adThresImg);
    /*---------------------------------------------------------------------------*/
    
    
    /*最大熵阀值分割法*/
    
    IplImage* imgMaxEntropy = cvCreateImage(cvGetSize(src),IPL_DEPTH_8U,1);
    MaxEntropy(grayImg,imgMaxEntropy);
    cvNamedWindow("MaxEntroyThreshold", CV_WINDOW_AUTOSIZE );
    cvShowImage( "MaxEntroyThreshold", imgMaxEntropy );//显示图像
    const char* path3;
    path3="MaxEntropy.bmp";
    cvSaveImage(path3, imgMaxEntropy);
    
    /*-----------------------------------------------------------------------------*/
    
    /*基本全局阀值法*/
  
    IplImage* imgBasicGlobalThreshold = cvCreateImage(cvGetSize(grayImg),IPL_DEPTH_8U,1);
    imgBasicGlobalThreshold=cvCloneImage(grayImg);
    int  pg[256],i,thre;    
    for (i=0;i<256;i++) pg[i]=0;
    for (i=0;i<imgBasicGlobalThreshold->imageSize;i++)      //  直方图统计
        pg[(byte)imgBasicGlobalThreshold->imageData[i]]++;    
    thre = BasicGlobalThreshold(pg,0,256);    //  确定阈值
    cout<<"The Threshold of this Image in BasicGlobalThreshold is:"<<thre<<endl;//输出显示阀值
    cvThreshold(imgBasicGlobalThreshold,imgBasicGlobalThreshold,thre,255,CV_THRESH_BINARY);  //  二值化    
    cvNamedWindow("BasicGlobalThreshold", CV_WINDOW_AUTOSIZE );
    cvShowImage( "BasicGlobalThreshold", imgBasicGlobalThreshold);//显示图像
    const char* path4;
    path4="BasicGlobalThreshold.bmp";
    cvSaveImage(path4, imgBasicGlobalThreshold);
    
/*----------------------------------------------------------------------------------------*/

   /*OTSU*/

    IplImage* imgOtsu = cvCreateImage(cvGetSize(grayImg),IPL_DEPTH_8U,1);
    imgOtsu=cvCloneImage(grayImg);
    int thre2;
    thre2 = otsu(imgOtsu);
    cout<<"The Threshold of this Image in Otsu is:"<<thre2<<endl;//输出显示阀值
    cvThreshold(imgOtsu,imgOtsu,thre2,255,CV_THRESH_BINARY);  //  二值化    
    cvNamedWindow("imgOtsu", CV_WINDOW_AUTOSIZE );
    cvShowImage( "imgOtsu", imgOtsu);//显示图像
    const char* path5;
    path5="Otsu.bmp";
    cvSaveImage(path5, imgOtsu);

/*-------------------------------------------------------------------------------------------*/
    /*上下阀值法：利用正态分布求可信区间*/
    IplImage* imgTopDown = cvCreateImage( cvGetSize(grayImg), IPL_DEPTH_8U, 1 );
    imgTopDown=cvCloneImage(grayImg);
    CvScalar mean ,std_dev;//平均值、 标准差
    double u_threshold,d_threshold;
    cvAvgSdv(imgTopDown,&mean,&std_dev,NULL);    
    u_threshold = mean.val[0] +2.5* std_dev.val[0];//上阀值
    d_threshold = mean.val[0] -2.5* std_dev.val[0];//下阀值
    cout<<"The TopThreshold of this Image in TopDown is:"<<d_threshold<<endl;//输出显示阀值
    cout<<"The DownThreshold of this Image in TopDown is:"<<u_threshold<<endl;
    cvThreshold(imgTopDown,imgTopDown,d_threshold,u_threshold,CV_THRESH_BINARY_INV);//上下阀值
    cvNamedWindow("imgTopDown", CV_WINDOW_AUTOSIZE );
    cvShowImage( "imgTopDown", imgTopDown);//显示图像 
    const char* path6;
    path6="TopDown.bmp";
    cvSaveImage(path6, imgTopDown);
    
    /*---------------------------------------------------------------------------*/
    /*迭代法*/
    IplImage* imgIteration = cvCreateImage( cvGetSize(grayImg), IPL_DEPTH_8U, 1 );
    imgIteration=cvCloneImage(grayImg);
    int thre3,nDiffRec;
    thre3 =DetectThreshold(imgIteration, 100, nDiffRec);
    cout<<"The Threshold of this Image in imgIteration is:"<<thre3<<endl;//输出显示阀值
    cvThreshold(imgIteration,imgIteration,thre3,255,CV_THRESH_BINARY_INV);//上下阀值
    cvNamedWindow("imgIteration", CV_WINDOW_AUTOSIZE );
    cvShowImage( "imgIteration", imgIteration);
    const char* path7;
    path7="Iteration.bmp";
    cvSaveImage(path7, imgIteration);
    
    
    
    
    /*---------------------------------------------------------------------------*/
    /*释放内存空间*/
    cvReleaseImage(&imgIteration);
    cvReleaseImage(&imgTopDown);
    cvReleaseImage(&imgOtsu);
    cvReleaseImage(&imgBasicGlobalThreshold);
    cvReleaseImage(&imgMaxEntropy );
    cvReleaseImage(&adThresImg);
    cvReleaseImage(&binaryImg);
    cvWaitKey(0);return 0;
}

运行结果：

                  

       Orignal Img                                                      Threshold Img                                    AdaptiveThreshold Img  

                  

         BasicGlobalThreshold                                      MaxEntropy                                                  Otsu

         

               TopDown                                                 Iteration                           

                                                                                                                                                                                                                   Hai

                                                                                                                                                                                                                  0730