图像处理 最大熵阈值法_最大熵阈值法 - CSDN
  • 最大熵阈值分割

    2017-03-20 22:45:51
    给定一个大小为M*N的图像I,直方图中所有矩形框所代表的数值之和,即为图像中的像素数量,即:  相对应的归一化直方图表示为:  0i所出现的概率。i的累积概率值为1,即概率分布p必须满足以下关系:  与累积概率...

    1.频率和概率

        直方图每个矩形框的数值描述的是图像中相应灰度值的频率。因此,可以说直方图是一种离散的频率分布。给定一个大小为M*N的图像I,直方图中所有矩形框所代表的数值之和,即为图像中的像素数量,即:

        相对应的归一化直方图表示为:

       0<=i<K 通常被解释为一个随机过程的概率分布或概率密度函数,表示的是图像中像素灰度值为i所出现的概率。i的累积概率值为1,即概率分布p必须满足以下关系:

        与累积概率所所对应的累积直方图H是一个离散的分布函数P(),(通常也称为累积分布函数或cdf):

    2.最大熵阈值分割

        熵是信息理论中一个重要的概念,这种方法常用于数据压缩领域。熵是一种统计测量方法,用以确定随机数据源中所包含的信息数量。例如,包含有N个像素的图像I,可以解释为包含有N个符号的信息,每一个符号的值都独立获取于有限范围K(e.g.,256)中的不同灰度值。

       将数字图像建模为一种随机信号处理,意味着必须知道图像灰度中每一个灰度g所发生的概率,即:

      因为所有概率应该事先知道,所以这些概率也称为先验概率。对于K个不同灰度值g=0,…,K-1的概率向量可以表示为:

     上述概率向量也称为概率分布或称为概率密度函数(pdf)。实际数字图像处理应用当中,先验的概率通常是不知道的,但是这些概率可以通过在一幅图像或多幅图像中观察对应灰度值所发生的频率,从而估算出其概率。图像概率密度函数p(g)可以通过归一化其对应的直方图获得其概率,即:

    3.最大熵

        数字图像中给定一个估算的概率密度函数p(g),数字图像中的熵定义为:

    4.用图像熵进行图像分割

        利用图像熵为准则进行图像分割有一定历史了,学者们提出了许多以图像熵为基础进行图像分割的方法。我们介绍一种由Kapuret al提出来,现在仍然使用较广的一种图像熵分割方法。

    给定一个特定的阈值q(0<=q<K-1),对于该阈值所分割的两个图像区域C0,C1,其估算的概率密度函数可表示为:


     同样的,背景熵可以改写为:





    5.代码实现及结果

    int MakeTable(double *S1,double *S2,double *NormalizeHist,int HistSize)
    {	int i;
    
    	double s0 = 0,s1;
    	for (i=0;i < HistSize;i++)
    	{
    		if (NormalizeHist[i]>0)
    		{
    			 s0 = s0+NormalizeHist[i]*log(NormalizeHist[i]);
    		}
    		S1[i] = s0;
    	}
    
    	s1 = 0;
    	for (i = HistSize-1;i >= 0;i--)
    	{
    		S2[i] = s1;
    		if (NormalizeHist[i]>0)
    		{
    			s1 = s1+NormalizeHist[i]*log(NormalizeHist[i]);
    		}
    	}
    	return 0;
    }
    
    int Get_Max_Entropy_Threshold(T_U32 *Hist,DWORD width,DWORD height)
    {
    	int i,q,HistSize = 256,qMax = -1;
    	double NormalizeHist[256] = {0},H01 = 0,H0 = 0,H1 = 0,P1 = 0,P0 = 0, Hmax = -9999 ;
    	double S1[256] = {0},S2[256] = {0};
    
    	for (i = 0;i < HistSize;i++)
    		NormalizeHist[i] = Hist[i]/(double)(width*height);
    
    	MakeTable(S1,S2,NormalizeHist,HistSize);
    
    	for (q = 0; q < HistSize-1;q++)
    	{
    		P0 += NormalizeHist[q];
    		P1 = 1 - P0;
    
    		if(P0 > 0)
    			H0 = -(1*S1[q])/P0+log(P0);
    		else
    			P0 = 0;
    
    		if(P1 > 0)
    			H1 = -(1*S2[q])/P1+log(P1);
    		else
    			H1 = 0;
    
    		H01 = H0+H1;
    
    		if (H01 > Hmax)
    		{
    			Hmax = H01;
    			qMax = q;
    		}
    
    	}
    	return qMax;
    }
    int Max_Entropy_Threshold(IMAGE_TYPE *BMP8_img)
    {
    	DWORD width,height,i,j,bfsize;
    	WORD  biBitCount;
    	T_U8 *dst,*bmp,k;
    	T_U32 line_byte,Threshold,index,Hist[256] = {0};
    	
    	BITMAPFILEHEADER bf;
    	BITMAPINFOHEADER bi;
    	
    	FILE *Max_Entropy_ThresholdBMP_fp = fopen("Max_Entropy_Threshold.bmp","wb");
    	
    	if(NULL == Max_Entropy_ThresholdBMP_fp)
    	{
    		printf("Can't open IsoData_Threshold.bmp\n");
    		return -1;
    	}
    	bmp = BMP8_img;
    	memset(&bf, 0, sizeof(bf));
    	memset(&bi, 0, sizeof(bi));
    	memcpy(&bf,bmp,14);
    	memcpy(&bi,&bmp[14],40);
    	
    	height = bi.biHeight;
    	width  = bi.biWidth;
    	bfsize = bf.bfSize;
    	biBitCount = bi.biBitCount;
    	line_byte = (width * 8 / 8 + 3) / 4 * 4; 
    	dst = BMP8_img+54+1024;
    
    	for (i = 0; i < height;i++)
    	{
    		for (j = 0;j < width;j++)
    		{
    			Hist[dst[i*line_byte+j]]++;
    		}
    	}
    	
    
    	dst = BMP8_img+54+1024;
    	Threshold = Get_Max_Entropy_Threshold(Hist,width,height);
    	for(i = 0;i < height;i++)
    	{
    		for(j = 0;j < width;j++)
    		{
    
    			index = i*line_byte+j;
    			k = dst[index];
    			
    			if(k >= Threshold)
    				dst[index] = 255;
    			else
    				dst[index] = 0;
    			
    		}
    	}
    	
    	fwrite(BMP8_img,bfsize,1,Max_Entropy_ThresholdBMP_fp);
    	fclose(Max_Entropy_ThresholdBMP_fp);
    	Max_Entropy_ThresholdBMP_fp = NULL;
    	
    	return 0;
    
    }

    结果:










    展开全文
  • 图像最大熵阈值分割的原理:使选择的阈值分割图像目标区域、背景区域两部分灰度统计的信息量为最大。  具体描述: 1. 根据信息熵定义,计算原始图像的信息熵H0,选择最大、最小灰度灰度的均值为初始阈值T0; 2. ...

        图像最大熵阈值分割的原理:使选择的阈值分割图像目标区域、背景区域两部分灰度统计的信息量为最大。

        具体描述:

    1. 根据信息熵定义,计算原始图像的信息熵H0,选择最大、最小灰度灰度的均值为初始阈值T0;

    2. 根据T0将图像分割为G1和G2两个区域,均值分别为M1和M2,更新阈值为T2=0.5*(M1+M2);

    3. 计算G1和G2的信息熵Hd和Hb,比较Hd+Hb与H0的大小,如果相等或在规定的范围内,或者达到最大迭代次数,则将T2最为最终阈值输出,否则T0=T2,H0=Hd+Hb,重复第2步直到满足条件。

    function ThreshValue = My_MaxEntropy(Imag)
    % 最大熵计算阈值
    % 输入:
    %    Imag:二维数组,数值表示灰度;
    % 输出:
    %    ThreshValue:阈值
    [X, Y] = size(Imag);
    V_max = max(max(Imag));
    V_min = min(min(Imag));
    T0 = (V_max + V_min) / 2;      % 初始分割阈值
    h = My_imhist(Imag);              % 计算图像的直方图
    grayp = h/(X*Y);                      % 求图像像素概率
    % 计算初始熵
    H0 = 0;
    for i = 1 : 256
        if grayp(i) > 0
            H0 = H0 - grayp(i)*log(grayp(i));
        end
    end
    % 开始迭代计算
    cout = 100;                            % 设置最大迭代次数
    while cout > 0
        Tmax = 0;          % 初始化
        T1 = T0;   
        A1 = 0;              % 分割区域G1的点数
        A2 = 0;              % 分割区域G2的点数
        B1 = 0;              % 分割区域G1的灰度总和
        B2 = 0;              % 分割区域G2灰度总和
        for i = 1 : X        % 计算灰度平均值
            for j = 1 : Y
                if(Imag(i, j) <= T1)
                    A1 = A1 + 1;
                    B1 = B1 + Imag(i, j);
                else
                    A2 = A2 + 1;
                    B2 = B2 + Imag(i, j);
                end
            end
        end
        M1 = B1 / A1;              % 分割区域G1的平均灰度
        M2 = B2 / A2;              % 分割区域G2的平均灰度
        T2 = (M1 + M2) / 2;     % 更新阈值
        TT = floor(T2);
        grayPd = sum(grayp(1 : TT));    % 计算分割区域G1的概率和
        if grayPd == 0
            grayPd = eps;
        end
        grayPb = 1 - grayPd;
        if grayPb == 0
            grayPb = eps;
        end
        % 计算分割后区域G1和G2的信息熵
        Hd = 0;
        Hb = 0;
        for i = 1 : 256
            if i <= TT
                if grayp(i) > 0
                    Hd = Hd - grayp(i)/grayPd*log(grayp(i)/grayPd);
                end
            else
                if grayp(i) > 0
                    Hb = Hb - grayp(i)/grayPb*log(grayp(i)/grayPb);
                end
            end
        end
        H1 = Hd + Hb;      % 总的熵
        % 退出条件
        if abs(H0 - H1) < 0.0001 
            Tmax = T2;
            break;
        else 
            T0 = T2;
            H0 = H1;
        end
        cout = cout - 1;
    end
    % 返回阈值
    ThreshValue = floor(Tmax);
    end
    
    % 灰度直方图
    function h = My_imhist(Imag)
    h = zeros(256, 1);
    for k = 1 : 256
        h(k) = 0;
        for i = 1 : size(Imag, 2)
            for j = 1 : size(Imag, 2)
                if Imag(i, j) == k - 1
                    h(k) = h(k) + 1;
                end
            end
        end
    end
    end

     

    展开全文
  • 图像处理最大熵阈值分割
  • 最大熵阈值分割和OTSU算法类似,假设将图像分为背景和前景两个部分。熵代表信息量,图像信息量越大,熵就越大,最大熵算法就是找出一个最佳阈值使得背景与前景两个部分熵之和最大。 原理 由于和OTSU算法类似,...

    写在前面

    前面介绍了OTSU算法,对于阈值分割法,不得不介绍另外一种较为突出的算法——最大熵阈值分割法(KSW熵算法)。

    最大熵阈值分割法和OTSU算法类似,假设将图像分为背景和前景两个部分。熵代表信息量,图像信息量越大,熵就越大,最大熵算法就是找出一个最佳阈值使得背景与前景两个部分熵之和最大。

     

    原理

    由于和OTSU算法类似,所以原理上就不再赘述和推导,言简意赅。

             熵的公式:

                                                                 

     

     

    基于OpenCV实现 

    #include <iostream>
    #include <opencv2/core.hpp>
    #include <opencv2/highgui.hpp>
    #include <opencv2/imgproc.hpp>
    
    int Max_Entropy(cv::Mat& src, cv::Mat& dst, int thresh, int p){
    	const int Grayscale = 256;
    	int Graynum[Grayscale] = { 0 };
    	int r = src.rows;
    	int c = src.cols;
    	for (int i = 0; i < r; ++i){
    		const uchar* ptr = src.ptr<uchar>(i);   
    		for (int j = 0; j < c; ++j){   
    			if (ptr[j] == 0)				//排除掉黑色的像素点
    				continue;
    			Graynum[ptr[j]]++;
    		}
    	}
    
    	float probability = 0.0; //概率
    	float max_Entropy = 0.0; //最大熵
    	int totalpix = r*c;
    	for (int i = 0; i < Grayscale; ++i){
    
    		float HO = 0.0; //前景熵
    		float HB = 0.0; //背景熵
    
    	    //计算前景像素数
    		int frontpix = 0;
    		for (int j = 0; j < i; ++j){
    			frontpix += Graynum[j];
    		}
    		//计算前景熵
    		for (int j = 0; j < i; ++j){
    			if (Graynum[j] != 0){
    				probability = (float)Graynum[j] / frontpix;
    				HO = HO + probability*log(1/probability);
    			}
    		}
    
    		//计算背景熵
    		for (int k = i; k < Grayscale; ++k){
    			if (Graynum[k] != 0){
    				probability = (float)Graynum[k] / (totalpix - frontpix);
    				HB = HB + probability*log(1/probability);
    			}
    		}
    
    		//计算最大熵
    		if(HO + HB > max_Entropy){
    			max_Entropy = HO + HB;
    			thresh = i + p;
    		}
    	}
    
    	//阈值处理
    	src.copyTo(dst);
    	for (int i = 0; i < r; ++i){
    		uchar* ptr = dst.ptr<uchar>(i);
    		for (int j = 0; j < c; ++j){
    			if (ptr[j]> thresh)
    				ptr[j] = 255;
    			else
    				ptr[j] = 0;
    		}
    	}
    	return thresh;
    }
    
    
    int main(){
    	cv::Mat src = cv::imread("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Img\\tttt.png");
    	if (src.empty()){
    		return -1;
    	}
    	if (src.channels() > 1)
    		cv::cvtColor(src, src, CV_RGB2GRAY);
    
    	cv::Mat dst, dst2;
    	int thresh = 0;
    	double t2 = (double)cv::getTickCount();
    	thresh = Max_Entropy(src, dst, thresh,10); //Max_Entropy
    	std::cout << "Mythresh=" << thresh << std::endl;
    	t2 = (double)cv::getTickCount() - t2;
    	double time2 = (t2 *1000.) / ((double)cv::getTickFrequency());
    	std::cout << "my_process=" << time2 << " ms. " << std::endl << std::endl;
    
    	double  Otsu = 0;
    	Otsu = cv::threshold(src, dst2, Otsu, 255, CV_THRESH_OTSU + CV_THRESH_BINARY);
    	std::cout << "Otsuthresh=" << Otsu << std::endl;
    	
    
    	cv::namedWindow("src", CV_WINDOW_NORMAL);
    	cv::imshow("src", src);
    	cv::namedWindow("dst", CV_WINDOW_NORMAL);
    	cv::imshow("dst", dst);
    	cv::namedWindow("dst2", CV_WINDOW_NORMAL);
    	cv::imshow("dst2", dst2);
    	//cv::imwrite("I:\\Learning-and-Practice\\2019Change\\Image process algorithm\\Image Filtering\\MeanFilter\\TXT.jpg",dst);
    	cv::waitKey(0);
    }

     

    效果

                                   原图                                                            最大熵法                                                            Otsu

    阈值及效率

     

    发现最大熵法 的阈值会偏高,我在代码中加了一个偏置矫正因子p,可以适当调节。

     

    参考:

    https://blog.csdn.net/bendanban/article/details/47058355

    https://blog.csdn.net/lz0499/article/details/64164477

    展开全文
  •  近期在做图像处理灰阶分割的研究,发现网上有很多将一维最大熵阈值分割的文章与程序代码,但是二维最大熵的资源相对较小。故本博客的目的就在于此,在学习的过程中记录相关笔记,以便帮助后面的研究者少走些弯路。...

    二维最大熵原理

      近期在做图像处理灰阶分割的研究,发现网上有很多将一维最大熵阈值分割的文章与程序代码,但是二维最大熵的资源相对较小。故本博客的目的就在于此,在学习的过程中记录相关笔记,以便帮助后面的研究者少走些弯路。希望与大家一起进步,共同提高。

    1、 基于二维最大熵阈值分割

    阈值化是图像分割中一种重要的技术。现有大多数方法都通过图像的一维灰度直方图选择阈值。但是, 当图像的信噪比递减时, 采用这些方法将产生很多的分割错误。近年来, 出现了一些方法开始利用图像的二 维 灰 度 直 方 图———像 素 的 灰 度 值分布及其邻域的平均灰度值分布所构成的直方图 来 进 行 阈 值分割。这些方法由于利用了图像的灰度信息和邻域的空间相关信息, 其效果较传统方法有明显改善

    1.1  二维直方图

    通常, 图像可看作一个二维灰度函数, 其中包含 N×N 个象素点, G={0, 2, ⋯, L- 1}为灰度取值范围, 这里 L=256。定义位于
    坐标( x, y) 象素的灰度值为 f( x, y) 。设 T∈G 为一分割阈值, 则对 图 像 函 数 f( x, y) 以 灰 度 值 T 阈 值 化 的 结 果 即 为 二 值 函 数fT( x, y) :
    fT( x, y) =
    b0 f( x, y) ≤T
    b1 f( x, y) > # T
    ( 1)
    其中: 0≤b0, T, b1≤L- 1。二维阈值化方法同时考虑象素的灰度值 及 其 邻 域 平 均 灰度值。象素( x, y) 处的 n×n 邻域平均灰度值为:
     
    其中: n≤N, n 一般取奇数, [n2]表示取整, 本文取 n=3。通过对原图进行邻域平均得到另一“平滑图像”, 由原图像和平滑图像构造出一个二维直方图。因为图像像素与其邻域像素的相关性是相当大的, 所以物体和背景的分布在二维直方图中就会比在一维直方图中更容易区分。一般地, 二维直方图呈双峰或多峰特性。如以灰度、邻域平均灰度值对[f( x, y) , g( x, y) ]来表示图像,并以二维矢量( S, T) 来分割图像, 这里, 0≤S, T≤L- 1。则二维阈值化函数可定义为
    则{pij}就是图像的二维灰度直方图, 如图所示。其起始点在左上方, 灰度值从左至右增加, 邻域平均灰度值自上 而 下
    增加。二维直方图上共有 L2个点, 每一点的函数值即为 rij。若图像的分割阈值矢量为( S, T) , 则直方图被分成 4 块, 根据同态
    性, 在目标和背景处, 象素的灰度值和邻域平均灰度值接近, 在目标和背景的分界邻域, 象素的灰度值与邻域平均灰度值差异较大。因此目标和背景中的象素将出现在对角线周围, 故方块0 和 1 包含了目标类和背景类的分布; 远离对角线的方块 2 和3, 对应边缘和噪声。

    基本思想:利用点灰度和区域灰度均值的二维直方图,根据熵最大原则寻找最佳阈值。

    做法:首先以原始灰度图像(L个灰度级)中各象素及其4邻域组为一个区域,计算出区域灰度均值图像(L个灰度级),这样原始图像中的每个象素都对应一个点灰度-区域灰度均值对,这样的数据对存在L×L种可能的取值。

    ni,j为图像中点灰度为i及其区域灰度均值为j的象素点数,pi,j为点灰度-区域灰度均值对(i,j)发生的概率,则


    则{pi,j,i,j=0,1,……L-1}就是该图像关于点灰度-区域灰度均值的二维直方图

    结论:

    1.在强噪声干扰下,一维直方图是单峰的二维直方图利用了图像邻域的相关信息,目标和背景的双峰仍然明显;

    2. 点灰度-区域灰度均值的概率高峰主要出现在XOY平面的对角线附近,并且在总体上呈现双峰和一谷的状态;

    这是由于图像的所有象素中,目标点和背景点所占比例最大,而目标区域和背景区域内部象素灰度级比较均匀,点灰度及其区域灰度均值相差不大,所以都集中在对角线附近,两个峰分别对应于目标和背景;远离XOY平面对角线的坐标处,峰的高度急剧下降,这部分所反映的是图像中的噪声点、边缘点和杂散点。

    3. 应该在A区和B区上用点灰度-区域灰度均值二维最大熵法确定最佳阈值,使真正代表目标和背景的信息量最大。

    这是由于图像的所有象素中,目标点和背景点所占比例最大,而目标区域和背景区域内部象素灰度级比较均匀,点灰度及其区域灰度均值相差不大,所以都集中在对角线附近,两个峰分别对应于目标和背景;远离XOY平面对角线的坐标处,峰的高度急剧下降,这部分所反映的是图像中的噪声点、边缘点和杂散点。


    展开全文
  • 详细的数学原理目前我也没搞明白,所以只说下原理概要: 图像进行二值化的过程中,显然是需要一个阈值的,这...这篇博文要求解的阈值具有这样的特点:图像用此阈值进行二值化后,整幅图像的熵值是最大的,所谓熵值...

    详细的数学原理目前我也没搞明白,所以只说下原理概要

    图像进行二值化的过程中,显然是需要一个阈值的,这个阈值取多少?前面已经有一种通过像素领域动态确定每个像点点阈值的方法 详情可见我的博文http://blog.csdn.net/wenhao_ir/article/details/51565517 

    这篇博文要求解的阈值具有这样的特点:图像用此阈值进行二值化后,整幅图像的熵值是最大的,所谓熵值最大,就是图像所包含的信息量是最大的!这就是所谓的“最大熵阈值分割”法!

    此方的原理概要如下

    通过对原图进行邻域平均得到另一“平滑图像”, 由原图像和平滑图像构造出一个二维直方图。

    基本思想:利用上面得到的二维直方图,根据熵最大原则寻找最佳阈值。

    在强噪声干扰下,一维直方图是单峰的,二维直方图利用了图像邻域的相关信息,目标和背景的双峰仍然明显;(这句话目前我是看不懂的,不过可以用来装B)

    如果要研究详细的原理,可以参考博文 http://blog.csdn.net/xw20084898/article/details/22760169 或者在CSDN或百度上搜相关内容!

    下面给出OpenCV下的实现源码(源码中用到的图像下载链接 http://pan.baidu.com/s/1slilbPF)

    图像处理开发资料、图像处理开发需求、图像处理接私活挣零花钱,可以搜索公众号"qxsf321",并关注!

    //OpenCV版本2.4.9  
    //图像处理开发资料、图像处理开发需求、图像处理接私活挣零花钱,可以搜索公众号"qxsf321",并关注!
    
    
    #include <opencv2/imgproc/imgproc.hpp>  
    #include <opencv2/core/core.hpp>        
    #include <opencv2/highgui/highgui.hpp> 
    #include <iostream> 
    using namespace std;
    using namespace cv;
    // 计算当前的位置的能量熵
    float caculateCurrentEntropy(cv::Mat hist, int threshold)
    {
        float BackgroundSum = 0, targetSum = 0;
    	const float* pDataHist = (float*) hist.ptr<float>(0);
    	for (int i = 0; i < 256; i++)
    	{
    		// 累计背景值
    		if( i < threshold )
    		{
    			BackgroundSum += pDataHist[i];
    		}else // 累计目标值
    	    {
                targetSum += pDataHist[i];
    	    }
    	}
    	//std::cout << BackgroundSum << " "<< targetSum << std::endl;
        float BackgroundEntropy = 0, targetEntropy = 0;
    	for (int i = 0; i < 256; i++)
    	{
    		// 计算背景熵
    		if( i < threshold )
            {
            	if( pDataHist[i] == 0 )
    				continue;
    			float ratio1 = pDataHist[i] / BackgroundSum;
    			// 计算当前能量熵
    			BackgroundEntropy += - ratio1 * logf(ratio1); 
            }else // 计算目标熵
            {
             	if( pDataHist[i] == 0 )
    			 	continue;
    			float ratio2 = pDataHist[i] / targetSum;
    			targetEntropy += -ratio2 * logf(ratio2); 
            }
    	}
    	return ( targetEntropy + BackgroundEntropy );
    }
    // 寻找最大熵阈值并分割
    cv::Mat maxEntropySegMentation(cv::Mat inputImage)
    {
        // 初始化直方图参数
        const int channels[1]={0};
        const int histSize[1]={256};
    	float pranges[2]={0, 256};
    	const float* ranges[1]={pranges};
    	cv::MatND hist;
    	// 计算直方图
    	cv::calcHist(&inputImage,1,channels,
    		cv::Mat(),hist,1,histSize,ranges);
    	float maxentropy = 0;
    	int    max_index  = 0;
    	cv::Mat result; 
    	// 遍历得到最大熵阈值分割的最佳阈值
    	for(int i = 0; i < 256; i++)	
    	{
    		float cur_entropy = 
    			caculateCurrentEntropy(hist,i);
    		// 计算当前最大值的位置
    		if(cur_entropy > maxentropy)
    		{
    			maxentropy = cur_entropy;
    			max_index = i;
    		}
    	}
    	//  二值化分割
    	threshold(inputImage, result, max_index, 255,
               CV_THRESH_BINARY); //max_index就是利用最大熵阈值分割法求出来的最佳阈值
    	return result;
    }
    int main()
    {
    	//cv::Mat srcImage=cv::imread("hand1.jpg");
    	cv::Mat srcImage=cv::imread("coins.png");
    	if(!srcImage.data)
    		return 0;
    	cv::Mat grayImage;
    	cv::cvtColor(srcImage, grayImage, CV_BGR2GRAY); 
        // 最大熵阈值分割实现    
        cv::Mat result = maxEntropySegMentation(grayImage);
        cv::imshow("grayImage", grayImage);
        cv::imshow("result" , result);
        cv::waitKey(0);
    	return 0;
    }

     

    运行结果如下图所示:

    大家可以将结果与自适应阈值法作个对比,自适应阈值法的结果在博文http://blog.csdn.net/wenhao_ir/article/details/51565517中有!可见,这两种方法在将来运用的过程中应该都会用到,不存在哪个优劣的问题,只是侧重点不一样而已!

    展开全文
  • 图像进行二值化的过程中,显然是需要一个阈值的,这个阈值取多少?前面已经有一种通过像素领域动态确定每个像点点阈值的方法 。 OpenCV中提供了自适应阈值化函数adaptiveThreshold来实现自适应阈值处理。 函数...
  • 1.最大熵原理 原理自己还是不是很清楚,-p*log(p)当p增大的时候log(p)减小,那么随着阈值的增加,前景(或者背景)的熵值的变化应该不是单调的(没有证明,只是自己感觉)。但我试着求出随着阈值变化的背
  • 最大熵阈值分割
  • 最大熵阈值分割

    2017-12-28 10:58:25
    现在主要用的熵算法有 P 氏熵算法,KSW 熵算法、JM 熵算法下面以经典的 KSW 熵算法为例介绍其原理和...设分割阈值为设分割阈值为t,   T为{0,1,2,...t}的灰度分布,B为{t+1,t+2,...L-1}的灰度分布,则概率分布为:
  • Python实现图像最大熵分割 工具: Python opencv-python def segment(img): &amp;quot;&amp;quot;&amp;quot; 最大熵分割 :param tfr: :return: &amp;quot;&amp;quot;&amp...
  • 转载于:https://www.cnblogs.com/mjk961/p/7275865.html
  • 利用图像熵为准则进行图像分割有一定历史了,学者们提出了许多以图像熵为基础进行图像分割的方法。我们介绍一种由Kapuret al提出来,现在仍然使用较广的一种图像熵分割方法。 给定一个特定的阈值q(0&lt;=q&...
  • 3、 最大熵阈值分割 4、 迭代阈值分割  5、测验   1、Otsu阈值分割  Otsu(大津或最大类间方差)使用的是聚类的思想,把图像的灰度数按灰度级分成2个部分,使得两个部分之间的灰度值差异最大,每个...
  • 最大熵阈值分割原始经典英文论文,值得仔细阅读,图像处理经典论文
  • 基本概念 图像阈值分割是图像处理中最基本也是最常用的方法之一,主要用于将图像中的像素点划分为两个或者多个类别,从而得到便于处理的目标对象。 ...
  • 这就是所谓的“最大熵阈值分割”! //@note 计算当前熵 //@param hist 直方图计算输出矩阵 //@param threshold 阈值 float CalEntropy(const Mat& hist, const int& threshold) { float Backgroun....
  •  (1) otsu(最大类间方差,有时也称之为大津算法)使用的是聚类的思想,把图像的灰度数按灰度级分成2个部分,使得两个部分之间的灰度值差异最大,每个部分之间的灰度差异最小,通过方差的计算来寻找一个合适...
  • matlab基于遗传算法的最大熵值的双阈值图像分割图像处理
1 2 3 4 5 ... 20
收藏数 778
精华内容 311
关键字:

图像处理 最大熵阈值法