Niblack快速实现与分块大津

最新推荐文章于 2024-04-19 08:29:31 发布
最新推荐文章于 2024-04-19 08:29:31 发布
阅读量871 收藏 16
点赞数 7
分类专栏： 智能车fw日记 文章标签： 计算机视觉 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43981425/article/details/106406001
版权

目录

Niblack

Niblack是局部二值化算法里思路简单，同时效果稳定的算法了。中心思想是T = m + s*k，T为以像素点为中心的一个w * w区域内所有像素点灰度值的平均值，s为矫正系数，k为w * w个像素点灰度的标准差
这里省略后面运算标准差的计算（K66算不过来），单用平均值作为单个像素的阈值，效果也很不错。

同时。，为了减少代码运算量，运用积分图法计算全局像素的灰度和，从而大大减少代码的重复运算量，K66终于不掉帧了（积分图法自行百度，百度讲得很清楚）

uint32 temp[70][186];
uint16 T[70][186];

int max(int a,int b)
{
	return a >= b ? a : b;
}

int min(int a,int b)
{
	return a <= b ? a : b;
}

void Niblack()
{
		uint8_t *p_image = &image[30][1];
		uint8_t *p_Pixels = &P_Pixel[0][0];
		uint16	*p_T = &T[0][0];
		uint8_t  w =  60;
		int m = 70;
		int n = 186;
		int j = 0;
		float sum = 0;
		float average = 0;
//创建积分图
		temp[0][0] = image[30][1];

		for (j = 1;j < n;j++)
				 temp[0][j] = image[30][1 + j] + temp[0][j - 1];

		for (i = 1;i < m;i++)
				 temp[i][0] = image[30 + i][1] + temp[i - 1][0];

		for (i = 1;i < m;i++)
		{
				for (j = 1;j < n;j++)
				{
						temp[i][j] = image[30 + i][1 + j] + temp[i][j - 1] + temp[i - 1][j] - temp[i - 1][j - 1];
				}
		}
		//开始计算阈值
		for (i = 0;i < m;i++)
		{
			 for (j = 0;j < n;j++)
			 {
						int a1 = max(i - w - 1,0);
						int a2 = min(i + w - 1,m - 1);
						int b1 = max(j - w - 1,0);
						int b2 = min(j + w - 1,n - 1);
						sum = temp[a1][b1] - temp[a1][b2] - temp[a2][b1] + temp[a2][b2];
						average = sum /((a2 - a1)*(b2 - b1));
						*p_T = (uint16)average;
						p_T++;
				}
		}
		
		p_T = &T[0][0];
		for (i =  0;i<m;i++)   
		{
				for (j = 0;j<n;j++)  
				{	
						if (*p_image > (uint8_t)((*p_T) * 0.95f))
						{
								*p_Pixels = white;
						}
						else
						{
								*p_Pixels = black;
						}
						p_Pixels++;
						p_image++;
						p_T++;
				}
				p_image+=2;
		}
}

最后二值化时，增加一个小于1的系数，能对平滑局域产生的为噪点很好的抑制，对大津无法处理的环内黑线有良好的处理效果

I = imread('图像路径');
I = rgb2gray(I);
figure(1);
imshow(I);
w =  60;
[m,n] = size(I);
T = zeros(m,n);
temp = zeros(m,n);
back = zeros(m,n);
%创建积分图
temp(1,1) = I(1,1);

for j = 2:n
     temp(1,j) = double(I(1,j)) + temp(1,j - 1);
end

for i = 2:m
     temp(i,1) = double(I(i,1)) + temp(i - 1,1);
end

for i = 2:m
    for j = 2:n
        temp(i,j) = double(I(i,j)) + temp(i,j - 1) + temp(i - 1,j) - temp(i - 1,j - 1);
    end
end

for i = 1:m
    for j = 1:n
        a1 = max(i - w,1);
        a2 = min(i + w,m);
        b1 = max(j - w,1);
        b2 = min(j + w,n);
        sum = temp(a1,b1) - temp(a1,b2) - temp(a2,b1) + temp(a2,b2);
        average = double(sum) /((a2 - a1)*(b2 - b1));
%         s = 0;
%         for k = a1:a2
%             for l = b1:b2
%                 s = s + (uint32(I(k,l)) - average)*(uint32(I(k,l)) - average);
%             end
%         end
%         s= sqrt(double(s)/((a2 - a1)*(b2 - b1)));
        T(i,j) = average + 0;
    end
end

for i =  1:m   
    for j = 1:n   
        if I(i,j) > T(i,j)*0.95
            back(i,j) = uint8(255);
        else    
            back(i,j) = uint8(0);
        end
    end
end
figure(2);
imshow(back);

左大津，右Niblack（还有两个参数可以调参，一个是w，还有一个是最后阈值时T乘的小于1的数）
在这里插入图片描述
在k66上运算大津一次大约为2.3ms，Niblack。。算了吧。

尝试改进大津

由于Niblack的运算时序还是使k66爆炸（同时TC264方面虽然是双核，但传图处理再赛道识别是一套连续的操作，实际上还是单核在处理，然后264单个核比不过K66。。。），于是转换一下思路，能不能把大津改了？就试了一下，效果还挺好
首先中心思路是赛道图像中间比较亮（一般大津不出问题）两边边缘部分较暗，在赛道部分灰度比中间部分小10左右（有时更多），于是大津边缘糊的便是由于全局阈值，有部分边缘赛道被划入到背景中，同理赛道的反光是由于蓝布上光线太亮，部分区域灰度值过大，被划入目标（赛道）中。基于此，分块大津将赛道图像分成三份（左，中，右），分别处理三份光线条件不同的图像（同时大津的时序也并没有增加多少，仅是多判断了两次类间方差），用三个阈值处理一份图像，可以比较有效抑制模糊和反光问题。
（左边赛道糊的部分减少，右上方反光部分得到抑制）
在这里插入图片描述
可惜分块阈值的先天缺陷是一旦某快阈值出现问题，将出现图像上的分块
（这里是由于右边分块时白色赛道太少，于是。。大津方差算出来阈值误差较大。）
在这里插入图片描述
为了解决这部分阈值错误的bug，便利用大津算出来的部分图像信息，灰度和以及背景像素点占比来判断这种错误阈值问题，思路是统计学。。。。灰度和与像素点比例之间存在一定的关系，即比例越大，灰度和会越小，而反常情况时，灰度和与比例之间会有很大的误差（与正常情况相比）
（图中右块灰度和17左右时，比例正常应在0.9左右）
然后这种bug一般发生在灰度和很小或者很大时（相对于正常目标和背景像素点比较平均时），因为这时候目标和背景像素点极有可能某个部分占有很大比例，使得大津的二值化变成一种强制化的操作，类似于鸡蛋里挑骨头。于是判断条件的一个比较好的思路便是先判断灰度和过大或过小，再进行比例和阈值差（与中间图像）的判断
在这里插入图片描述
判出错误情况后，再将中间部分的阈值（中间一般情况下没有差错，除了坡道）减去一个常数后， 再进行阈值分割，便可以较好得处理赛道图像

float bin_float[256];     //灰度比例直方图
int size = 70 * 186;
float u = 0;                //全图平均灰度
float w0 = 0;
float u0 = 0;               //前景灰度
byte Bin_Array[256];
int i;
float gray_hh = 0;//前景灰度和
float var = 0;//方差
float maxvar = 0;//最大方差
float maxgray = 0;//最大灰度占比
float maxbin = 0;

struct size_point
{
		int x0;
		int y0;
		int x1;
		int y1;
};

struct size_point ostu_point[3]={
{0,0,40,69},
{41,0,135,69},
{136,0,185,69},
};

void Ostu(int x,int y)//大津
{
	int j, k;
	uint8_t (*p_image)[188] = &image[17];
	for (k = 0; k < 3; k++)
	{
		maxvar = 0;
		w0 = 0;
		u = 0;
		gray_hh = 0;
		var = 0;
		Thresholds[k] = 0;
		for (i = 0; i < 256; i++)
		{ bin_float[i] = 0; }
		for (i = ostu_point[k].y0; i <= ostu_point[k].y1; i++)
		{
				for (j = ostu_point[k].x0; j <= ostu_point[k].x1; j++)
				{
						++bin_float[*(*(p_image + i) + j)];
				}
		}
		size = (ostu_point[k].y1 - ostu_point[k].y0 + 1) * (ostu_point[k].x1 - ostu_point[k].x0 + 1);
		for (i = 0; i < 256; i++)
		{
				bin_float[i] = bin_float[i] / size;
				u += i * bin_float[i];
		}
		//创建比例灰度直方图
		for (i = 0; i < 256; i++)
		{
				w0 += bin_float[i];
				gray_hh += i * bin_float[i];             //灰度和
				u0 = gray_hh / w0;
				var = (u0 - u) * (u0 - u) * w0 / (1 - w0);
				if (var > maxvar)
				{
						maxgray = gray_hh;
						maxbin = w0;
						maxvar = var;
						Thresholds[k] = (byte)i;
				}
		}
		if (k == 0)
		{
				if (gray_hh > 15 && gray_hh <= 33)
				{
						if (maxbin < 0.9f)
						{
								Thresholds[k] = (byte)(Thresholds[1] - 3);
						}
				}
				else if (gray_hh > 41 && gray_hh <= 47)
				{
						if (maxbin < 0.64f || maxbin > 0.76f)
						{
								Thresholds[k] = (byte)(Thresholds[1] - 3);
						}
				}
				else if (gray_hh > 50 && gray_hh <= 60)
				{
						if (maxbin < 0.42f || maxbin > 0.58f)
						{
								Thresholds[k] = (byte)(Thresholds[1] - 3);
						}
				}
				//SetText("右边var:" + maxvar + " 阈值:" + Thresholds[k] + " 比例:" + maxbin + " 灰度和" + gray_hh);
		}
		else if (k == 1)
		{
				if(gray_hh > 69 && gray_hh < 80)
				{
						if (maxbin > 0.15f)
						{
								Thresholds[k] = (byte)(Thresholds[0] + 3);
						}
				}
				//SetText("中间var:" + maxvar + " 阈值:" + Thresholds[k] + " 比例:" + maxbin + " 灰度和" + gray_hh);
		}
		else if (k == 2)
		{
				if (maxbin < 0.85f && gray_hh < 28)
				{
						Thresholds[k] = (byte)(Thresholds[1] - 3);
				}
				else if(gray_hh > 69 && gray_hh < 79)
				{
						if (maxbin < 0.5f || maxbin > 0.15f)
						{
								Thresholds[k] = (byte)(Thresholds[1] - 3);
						}
				}
				//SetText("左边var:" + maxvar + " 阈值:" + Thresholds[k] + " 比例:" + maxbin + " 灰度和" + gray_hh);
		}
		for (i = 0; i < Thresholds[k]; i++)
		{
				Bin_Array[i] = black;
		}
		for (i = Thresholds[k]; i < 256; i++)
		{
				Bin_Array[i] = white;
		}
		for (i = ostu_point[k].y0; i <= ostu_point[k].y1; i++)
		{
				for (j = ostu_point[k].x0; j <= ostu_point[k].x1; j++)
				{
						P_Pixel[i][j] = Bin_Array[*(*(p_image + i) + j)];
				}
		}
	}
}

之后还有一些无法处理的问题，之后再想想有什么方法解决吧，或许还可以有更好的办法改大津。

无法处理的情况：坡道部分开到天上去了，上面灯光太亮白色的天灰板都变黑了。。
处理不好的情况：当整幅图灰度直方图是比较标准的双峰时，强行分块会产生反效果
在这里插入图片描述

抽一半改进大津

最近发现，对于186*70的灰度图，遍历所有的点和只用一半的点（隔行取点）算出来的大津几乎没有差别（最多差2），基于此，那我们便可以用多出来的时序做点其他的事啦。
由于在分块大津中，我们很难找到一个标准值去修正强行二值化时错误的阈值，所以我们先算一遍一半大津，再分三块进行一半大津，在一半整体大津的基础上，与算出来的三块大津值进行一个互补，这样做虽然效果不会有单用三块大津值明显，但是稳定性拉满，只要大津不出错，修正后的大津阈值也不会出错；而且有了标准值后，出现强行二值化情况也可以很好得到避免（即与标准值相差一定值以上时）

if (My_Abs(Thresholds - Thresholds[k]) >= 45)//相差太大直接用标准值
{
    Thresholds[k] = Thresholds;
}
else
{
    Thresholds[k] = (uint8_t)(Thresholds[k] + 0.5f * (Thresholds - Thresholds[k]));//这里是取了平均，可以通过调整占比适应不同的光照条件
}

这应该是最后的一版改大津，快比赛了（混队友的，我很久没调过车了，孙哥nb），我也没有什么想法，代码写得很烂，很多都没法在k66上使用，也没办法很好解决问题，等比赛结束再写感想吧。

参考：改进Niblack算法及其在不均匀光照条件下的应用_贾坤昊
https://kns.cnki.net/KCMS/detail/detail.aspx?dbcode=CJFQ&dbname=CJFDLAST2019&filename=RJDK201904020&v=MTMwMDRSN3FmWXVSbkZ5L2tXcnpLTnlmUFpiRzRIOWpNcTQ5SFpJUjhlWDFMdXhZUzdEaDFUM3FUcldNMUZyQ1U=

钱钱、
关注
  • 7
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
MATLAB小技巧（4）niblack二值化分割算法
sinat_34897952的博客
04-21 2790
MATLAB小技巧（4）niblack二值化分割算法前言一. MATLAB仿真二. 仿真结果三. 小结 前言 MATLAB进行图像处理相关的学习是非常友好的，可以从零开始，对基础的图像处理都已经有了封装好的许多可直接调用的函数，这个系列文章的话主要就是介绍一些大家在MATLAB中常用一些概念函数进行例程演示！ Niblack二值化算法是比较简单的局部阈值方法，阈值的计算公式是T = m + kv，其中m为以该像素点为中心的区域的平均灰度值，v是该区域的标准差，k是一个系数。这个区域就可以自己根据实际情况进
【Matlab】Niblack算法和Otsu算法
GQ
04-03 9328
图像的二值化根据阈值确定方法的不同，可以分为局部阈值法和全局阈值法。Niblack算法属于局部阈值法。Otsu算法属于全局阈值法。 一、Niblack算法 Niblack算法是通过某一像素点及其邻域内像素点灰度值的均值和标准差计算得到二值化阈值的。在计算图像点(x,y)二值化阈值时，首先计算以(x,y)为中心的n*n大小的区域内像素点的灰度均值m和标准差s。灰度均值m和...
OpenCV——Niblack局部阈值二值化方法
最新发布
点云侠的博客
04-19 1357
Niblack 算法是一种典型的局部阈值二值化方法，图像每个像素点与通过局部邻域计算得到的阈值相比较进行二值化。
NiBlack算法的原理及matlab代码
Mr-pig的博客
03-20 6500
二值化算法---Niblack算法在二值化的操作中，用的比较多的就是全局阈值话OTSU（大津法）和局部阈值NiBlack，Niblack方法是一种简单有效的动态阈值分割方法，修改得到最佳参数之后的效果比大津法要好，因为大津法是根据整个图像来确定一个阈值，而Niblack则是在不同的R*R区域会有不同的阈值。Niblack的基本思想是：对于图像的每一个像素点，在rxr领域空问里，计算该像素点领域方位...
Niblack算法和OTSU算法的实现
yanHa007的专栏
08-14 3175
1、OTSU算法是设阈值将图像分割成俩组，一组灰度对应目标，另一组灰度对应背景，则这俩组灰度值的类内方差最小，俩组的类间方差最大。相关公式：                                                             g = w0 *(u0 - u)*(u0 - u) + w1*(u1 - u)*(u1 - u) = w0 * w1 *(u0 - u1
【图像处理】Niblack
weixin_42331647的博客
02-07 791
Niblack方法就是局部方法中的一种，它根据以像素点为中心的邻域内的点的情况为此像素计算阈值。
Niblack算法
10-21
Niblack算法实现matlab源代码
niblack算法实现
04-04
可以快速实现niblack二值化算法，效果优于其他算法，特别是适用与红外静脉图像的分割
binarization_Algorithm_niblack算法_
09-28
niblack 算法图像二值化111111111111111111
MATLAB用niblack算法实现二值化
07-06
MATLAB编的niblack二值化的代码，修改图片路径即可使用。
二值化_niblack_binarization_
10-01
图像中常常会出现亮度不均匀的情况，对于处理这些图像，一般的算法没有办法解决，这里提供一种niblack的算法，可以处理这个问题
二值化算法：Otsu算法、Bernsen算法、Niblack算法、循环阈值算法、迭代二值化算法等matlab代码
10-19
二值化算法：Otsu算法、Bernsen算法、Niblack算法、循环阈值算法、迭代二值化算法等matlab代码,入门级
Niblack二值化opencv2下的实现
04-08
Niblack二值化算法在opencv2下的实现。参考文献：http://www.cnblogs.com/nani/archive/2012/12/12/2814324.html http://blog.csdn.net/lucayhaozi/article/details/9967963 仅供参考。欢迎宝贵意见。
图像分割——阈值分割二值化算法汇总
E_vens
06-14 4252
图像分割——阈值分割二值化算法汇总
基于opencv的Niblack二值化算法
地狱，乃是天堂必经之路！
05-23 3809
Niblack算法是比较出名的二值化算法，网上很多Niblack代码是基于Matlab的，本人觉得其速度比较慢，所以便基于OpenCV改写了其算法，具体参考的博客链接已经忘记了，希望博主原谅。如果缺少某些函数，比如最大值最小值函数，可以参考本人其他博客，里面会提供。废话不多说，直接上代码： /** @brief 计算单通道灰度图像的平均值 @param src 单通道灰度图 */ static...
局部二值化算法Niblack OpenCV实现
fabulousli的博客
08-14 8215
Niblack 算法的应用于文本图像二值化领域较多，算是比较经典的局部二值化处理方法，其局部二值化方法的提出也很有借鉴意义，包括后来的一些对其改进方法，Sauvola 算法、Nick 算法，核心思想是：根据图像像素点的邻域内的平均灰度和标准偏差来构造一个阈值曲面进行二值化处理。其阈值计算如下： point 1：计算窗口内像素均值； point 2：计算窗口内像素标准差。 这两个点
opencv Niblack
08-16
如果你需要使用Niblack算法进行文本图像二值化，你可以自己编写代码来实现该算法并与OpenCV库一起使用。这样，你就能够在OpenCV库的基础上实现Niblack算法来进行文本图像的二值化处理。<span class="em">1 #### 引用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值