图像分割-阈值处理详解(迭代法、Otsu法、平滑改善法、边缘改进法、分块处理法、局部特性法、移动平均法)

已于 2022-07-03 21:59:08 修改
阅读量1w 收藏 149
点赞数 25
分类专栏： 图像处理原理 文章标签： 计算机视觉 人工智能 python
于 2020-02-17 20:19:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42604176/article/details/104341126
版权

博主联系方式：
QQ:1540984562
QQ交流群：892023501
群里会有往届的smarters和电赛选手，群里也会不时分享一些有用的资料，有问题可以在群里多问问。

阈值处理详解

基础：

首先将灰度图转化成灰度直方图，横坐标是灰度值（0-255），纵坐标是像素个数。（归一化之后表征的是像素出现的概率）
如下图所示：
灰度直方图性质：
灰度直方图性质
两幅灰度直方图两幅灰度直方图
如图，从图A可以看出，直方图有两个明显的波峰和一个明显的波谷，表明灰度普遍分为两个密集区域。此时将门限设置在两者之间的波谷，则可以很好地分割出背景和物体。
同理，观察图B，有三个明显的波峰和两个明显的波谷，此时可以设置双门限，将图像分割为三类，如下图冰山就是很好的例子，分割为暗背景、冰山的明亮区域和阴影区域。
冰山
然而并不是所有图像的直方图都是有明显的多个波峰和波谷的。
单峰型：
单峰型

无明显波谷型
无明显波谷型

灰度趋于一致型（被噪声污染过）
灰度趋于一致型

灰度阈值取决于波谷的宽度和深度，影响波谷特性的关键因素有：
1、波峰的间隔（波峰离得越远，分离这些模式机会越好）
2、图像中的噪声内容（模式随噪声的增加而展宽）
3、物体和背景的相对尺寸
4、光源的均匀性
5、图像反射的均匀性

接下来的所有的阈值处理方法，其目的都是：将灰度直方图变得好处理 并 找到分割背景和物体的门限灰度值。

基于全局的阈值处理

1迭代算法（最小概率误判）

公式推导：
1
2
3
4
算法步骤：
分割前提基于全局的迭代算法
代码实现：

void Iteration(Mat* srcImage, Mat* dstImage, float delta_T)
{
	//【1】求最大灰度和最小灰度
	byte max_his = 0;
	byte min_his = 255;
	int height = (*srcImage).rows;
	int width = (*srcImage).cols;
	for (int j = 0;j < height;j++)
	{
		for (int i = 0;i < width;i++)
		{
			if ((*srcImage).at<uchar>(j, i) > max_his)
			{
				max_his = (*srcImage).at<uchar>(j, i);
			}
			if ((*srcImage).at<uchar>(j, i) < min_his)
			{
				min_his = (*srcImage).at<uchar>(j, i);
			}
		}
	}
	float T = 0.5 * (max_his+ min_his);
	float m1 = 255;		//当m1 m2都取0时，会有错误
	float m2 = 0;
	float old_T = T;
	float new_T = 0.5 * (m1 + m2);
	int times = 10;
	//while (times--)
	while (abs(new_T - old_T) > delta_T)
	{
		int G1 = 0;
		int G2 = 0;
		int timer_G1 = 0;
		int timer_G2 = 0;
		for (int j = 0;j < height;j++)
		{
			for (int i = 0;i < width;i++)
			{
				if ((*srcImage).at<uchar>(j, i) > old_T)
				{
					G1 += (*srcImage).at<uchar>(j, i);
					timer_G1++;
				}
				else
				{
					G2 += (*srcImage).at<uchar>(j, i);
					timer_G2++;
				}
			}
		}
		m1 = G1 * 1.0f / timer_G1;
		m2 = G2 * 1.0f / timer_G2;
		old_T = new_T;
		new_T = 0.5 * (m1 + m2);
	}
	cout << "迭代方法阈值为：" << new_T << endl;	
	//根据得出的阈值二值化图像
	for (int j = 0;j < height;j++)
	{
		for (int i = 0;i < width;i++)
		{
			if ((*srcImage).at<uchar>(j, i) > new_T)
			{
				(*dstImage).at<uchar>(j, i) = 255;

			}
			else
			{
				(*dstImage).at<uchar>(j, i) = 0;

			}
		}
	}
}
int main()
{
		Mat srcImage = imread("D:\\opencv_picture_test\\新垣结衣\\test2.jpg", 0);	//读入的时候转化为灰度图
		namedWindow("原始图", WINDOW_NORMAL);//WINDOW_NORMAL允许用户自由伸缩窗口
		imshow("原始图", srcImage);
	
		Mat dstImage;
		dstImage.create(srcImage.rows, srcImage.cols, CV_8UC1);
		double time0 = static_cast<double>(getTickCount());	//记录起始时间
		//阈值处理+二值化
		//My_P_tile(&srcImage,&dstImage,20);			//设P为20
		Iteration(&srcImage, &dstImage,0.02);
		//一系列处理之后
		time0 = ((double)getTickCount() - time0) / getTickFrequency();
		//cout << "此方法运行时间为：" << time0 << "秒" << endl;	//输出运行时间
		namedWindow("效果图", WINDOW_NORMAL);//WINDOW_NORMAL允许用户自由伸缩窗口
		imshow("效果图", dstImage);
		dstImage = My_Rraw_histogram(&srcImage);
		namedWindow("一维直方图", WINDOW_NORMAL);//WINDOW_NORMAL允许用户自由伸缩窗口
		imshow("一维直方图", dstImage);
		waitKey(0);
		return 0;
}

当直方图存在比较明显的波谷时，这种方法是比较好的。δT控制迭代次数，下面是代码实现效果
原图
二值图
一维直方图
阈值

2基于Otsu最佳全局阈值方法（非常有效）

大津法又叫最大类间方差法、最大类间阈值法（OTSU）。
它的基本思想是，用一个阈值将图像中的数据分为两类，
一类中图像的像素点的灰度均小于这个阈值，另一类中的图像的像素点的灰度均大于或者等于该阈值。 //一般来说使用遍历的方法来求
如果这两个类中像素点的灰度的方差越大，说明获取到的阈值就是最佳的阈值
（方差是灰度分布均匀性的一种度量,背景和前景之间的类间方差越大,说明构成图像的两部分的差别越大,当部分前景错分为背景或部分背景错分为前景都会导致两部分差别变小。因此,使类间方差最大的分割意味着错分概率最小。）。
则利用该阈值可以将图像分为前景和背景两个部分。
而我们所感兴趣的部分一般为前景。
对于灰度分布直方图有两个峰值的图像，大津法求得的Ｔ近似等于两个峰值之间的低谷。
(这段阐述转自这里https://www.jianshu.com/p/56b140f9535a)
公式推导
1
2
3
从一篇博客截来的图，罗列了我们要计算的变量。https://blog.csdn.net/u012198575/article/details/81128799
需要计算的变量

代码实现

void My_Ostu(Mat* srcImage, Mat* dstImage)
{
	int height = (*srcImage).rows;
	int width = (*srcImage).cols;
	int Ostu_Threshold = 0; //大津阈值
	int size = height * width;
	float variance;   //类间方差
	float maxVariance = 0, w1 = 0, w2 = 0, avgValue = 0;
	float u0 = 0, u1 = 0, u2 = 0;
	//生成灰度直方图
	int pixels[256];
	float histgram[256];
	for (int i = 0; i < 256; i++)
	{
		pixels[i] = 0;
	}
	for (int j = 0; j < height; j++)
	{
		for (int i = 0; i < width; i++) 
		{
			pixels[(*srcImage).at<uchar>(j, i)]++;
		}
	}
	for (int i = 0; i < 256; i++)
	{
		histgram[i] = pixels[i] * 1.0f / size;
	}
	//遍历找出类间方差最大（maxVariance）的阈值（Ostu_Threshold）
	for (int i = 0;i <= 255;i++)
	{
		w1 = 0;
		w2 = 0;
		u1 = 0;
		u2 = 0;
		//计算背景像素占比,平均灰度
		for (int j = 0;j <= i;j++)
		{
			w1 += histgram[j];
			u1 += histgram[j] * j;
		}
		u1 = u1 / w1;
		//计算前景像素占比,平均灰度
		w2 = 1 - w1;
		if (i == 255)
		{
			u2 = 0;
		}
		else
		{
			for (int j = i + 1;j <= 255;j++)
			{
				u2 += histgram[j] * j;
			}
		}
		u2 = u2 / w2;
		//计算类间方差
		variance = w1 * w2 * (u1 - u2) * (u1 - u2);
		if (variance > maxVariance)
		{ //找到使灰度差最大的值
			maxVariance = variance;
			Ostu_Threshold = i;            //那个值就是阈值
		}
	}
	cout << "大津法阈值为：" << Ostu_Threshold << endl;
	//【3】二值化
	for (int j = 0; j < height; j++)
	{
		for (int i = 0; i < width; i++)
		{
			if ((*srcImage).at<uchar>(j, i) >= Ostu_Threshold)
			{
				(*dstImage).at<uchar>(j, i) = 255;
			}
			else
			{
				(*dstImage).at<uchar>(j, i) = 0;
			}

		}
	}
}
int main()
{
		Mat srcImage = imread("D:\\opencv_picture_test\\新垣结衣\\test2.jpg", 0);	//读入的时候转化为灰度图
		namedWindow("原始图", WINDOW_NORMAL);//WINDOW_NORMAL允许用户自由伸缩窗口
		imshow("原始图", srcImage);
	
		Mat dstImage;
		dstImage.create(srcImage.rows, srcImage.cols, CV_8UC1);
		double time0 = static_cast<double>(getTickCount());	//记录起始时间
		//阈值处理+二值化
		//My_P_tile(&srcImage,&dstImage,20);			//设P为20
		//My_Iteration(&srcImage, &dstImage,0.02);
		My_Ostu(&srcImage, &dstImage);
		//一系列处理之后
		time0 = ((double)getTickCount() - time0) / getTickFrequency();
		cout << "此方法运行时间为：" << time0 << "秒" << endl;	//输出运行时间
		namedWindow("效果图", WINDOW_NORMAL);//WINDOW_NORMAL允许用户自由伸缩窗口
		imshow("效果图", dstImage);
		dstImage = My_Rraw_histogram(&srcImage);
		namedWindow("一维直方图", WINDOW_NORMAL);//WINDOW_NORMAL允许用户自由伸缩窗口
		imshow("一维直方图", dstImage);
		waitKey(0);
		return 0;
}

效果：
1
2

3用图像平滑改善全局阈值处理

总的来说就是在二值化之前先用33或者55之类的均值模板将整个图像处理一下。
不过这样的坏处是使物体与背景的边界变得有些模糊。侵蚀越多，边界误差越大。
在某些极端情况下，这种方法效果并不好。

4利用边缘改进全局阈值处理

这种方法将关注聚焦于物体与背景的边缘像素，在边缘的灰度跳动非常明显，由此得到的灰度直方图将会得到很大的改善。
在这里我们求得边缘的方法主要是梯度算子和拉普拉斯算子。
算法步骤：
算法步骤
一般来说我们确定阈值T是根据，梯度最大值或者拉普拉斯最大值的某百分比来确定的。当有不同需求时，采用不同的占比。

基于局部的阈值处理

这种阈值处理的目的是为了解决光照和反射带来的问题。

1图像分块可变阈值处理

其实就是把一个图片分割为多块，分别使用大津阈值。分块处理
分块处理后的子图像直方图
子图像直方图
上面的是书上的样例，我把原图截下来，试了试自己写的代码，效果并不是很好。
代码实现：

void My_local_adaptive(Mat* srcImage, Mat* dstImage, int areas_of_H, int areas_of_W)		//局部自适应法   基于大津阈值areas_of_H：竖直方向分割的个数  areas_of_W：横坐标方向分割的个数
{
	int height = (*srcImage).rows/ areas_of_H;			//每一小块的height
	int width = (*srcImage).cols/ areas_of_W;			//每一小块的width
	int Ostu_Threshold = 0; //大津阈值
	int size = height * width/ areas_of_H/ areas_of_W;		//每一小块的size
	//一行一行地来
	for (int y = 0; y < areas_of_H; y++)	
	{
		for (int x = 0; x < areas_of_W; x++)
		{
			float variance = 0;   //类间方差
			float maxVariance = 0, w1 = 0, w2 = 0, avgValue = 0;
			float u0 = 0, u1 = 0, u2 = 0;
			//生成areas_of_W*areas_of_H个局部灰度直方图
			int pixels[256];
			float histgram[256];
			for (int i = 0; i < 256; i++)
			{
				pixels[i] = 0;
			}
			//【处理每个小区域并且二值化】
			//【计算直方图】
			for (int j = y* height; j < ((y + 1 == areas_of_H) ? (*srcImage).rows : (y + 1) * height); j++) //? : 是一个三目运算符，也是唯一的一个三目运算符。？前面表逻辑条件，：前面也就是？后面表示条件成立时的值，：后面表条件不成立时的值。例如，当a > b时，x = 1否则x = 0，可以写成x = a > b ? 1 : 0。
			{
				for (int i = x * width; i < ((x + 1 == areas_of_W) ? (*srcImage).cols : (x + 1) * width); i++)
				{
					pixels[(*srcImage).at<uchar>(j, i)]++;
				}
			}
			//【直方图归一化】
			for (int i = 0; i < 256; i++)
			{
				histgram[i] = pixels[i] * 1.0f / size;
			}
			//遍历找出类间方差最大（maxVariance）的阈值（Ostu_Threshold）
			for (int i = 0;i <= 255;i++)
			{
				w1 = 0;
				w2 = 0;
				u1 = 0;
				u2 = 0;
				//计算背景像素占比,平均灰度
				for (int j = 0;j <= i;j++)
				{
					w1 += histgram[j];
					u1 += histgram[j] * j;
				}
				u1=u1/w1;
				//计算前景像素占比,平均灰度
				w2 = 1 - w1;
				if (i == 255)
				{
					u2 = 0;
				}
				else
				{
					for (int j = i + 1;j <= 255;j++)
					{
						u2 += histgram[j] * j;
					}
				}
				u2=u2/w2;
				//计算类间方差
				variance = w1 * w2 * (u1 - u2) * (u1 - u2);
				if (variance > maxVariance)
				{ //找到使灰度差最大的值
					maxVariance = variance;
					Ostu_Threshold = i;            //那个值就是阈值
				}
			}
			cout << "大津法阈值为：" << Ostu_Threshold << endl;
			//【3】二值化
			for (int j = y * height; j < ((y + 1 == areas_of_H) ? (*srcImage).rows : (y + 1) * height); j++) //? : 是一个三目运算符，也是唯一的一个三目运算符。？前面表逻辑条件，：前面也就是？后面表示条件成立时的值，：后面表条件不成立时的值。例如，当a > b时，x = 1否则x = 0，可以写成x = a > b ? 1 : 0。
			{
				for (int i = x * width; i < ((x + 1 == areas_of_W) ? (*srcImage).cols : (x + 1) * width); i++)
				{
					if ((*srcImage).at<uchar>(j, i) >= Ostu_Threshold)
					{
						(*dstImage).at<uchar>(j, i) = 255;
					}
					else
					{
						(*dstImage).at<uchar>(j, i) = 0;
					}
				}
			}
		}
	}
}
int main()
{
		//Mat srcImage = imread("D:\\opencv_picture_test\\新垣结衣\\test2.jpg", 0);	//读入的时候转化为灰度图
		//Mat srcImage = imread("D:\\opencv_picture_test\\miku\\miku2.jpg", 0);	//读入的时候转化为灰度图
		Mat srcImage = imread("D:\\opencv_picture_test\\阈值处理\\带噪声阴影的图.png", 0);	//读入的时候转化为灰度图
		namedWindow("原始图", WINDOW_NORMAL);//WINDOW_NORMAL允许用户自由伸缩窗口
		imshow("原始图", srcImage);
	
		Mat dstImage;
		dstImage.create(srcImage.rows, srcImage.cols, CV_8UC1);
		double time0 = static_cast<double>(getTickCount());	//记录起始时间
		//阈值处理+二值化
		//My_P_tile(&srcImage,&dstImage,20);			//设P为20
		//My_Iteration(&srcImage, &dstImage,0.01);
		//My_Ostu(&srcImage, &dstImage);
		My_local_adaptive(&srcImage, &dstImage, 1, 2);
		//一系列处理之后
		time0 = ((double)getTickCount() - time0) / getTickFrequency();
		cout << "此方法运行时间为：" << time0 << "秒" << endl;	//输出运行时间
		namedWindow("效果图", WINDOW_NORMAL);//WINDOW_NORMAL允许用户自由伸缩窗口
		imshow("效果图", dstImage);
		dstImage = My_Rraw_histogram(&srcImage);
		namedWindow("一维直方图", WINDOW_NORMAL);//WINDOW_NORMAL允许用户自由伸缩窗口
		imshow("一维直方图", dstImage);
		waitKey(0);
		return 0;
}

全局大津阈值效果
all black
2
局部阈值法：1*2分割
2
![2](https://img-blog.csdnimg.cn/202003
迭代阈值法：
1
2
看来仍然需要改进

2基于局部图像特性的可变阈值处理

算法步骤：
1、计算以某一像素为中心的邻域的灰度标准差和均值
计算所需变量
2、设定可变阈值算法步骤
3、观察是否满足阈值条件算法步骤
4、二值化
阈值处理

其中a和b都是需要人工整定。
效果图：
效果图

3基于移动平均法的可变阈值

算法描述
有关的链接：（这个算法我还没有理解，等我理解了再来补充）
https://blog.csdn.net/qq_34510308/article/details/93162142

拾牙慧者
关注
  • 25
    点赞
  • 踩
  • 149
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
常见图像阈值化方法
10-28
C++写的opencv代码，内含固定阈值、自适应(OTSU)二值化、局部自适应二值化方法，可以通过混动条调整参数，直观看阈值化效果
分块阈值matlab代码（光照不均匀图像分割技巧）
01-30
对一副图像进行分块阈值，可解决光照不均分割不足的问题。通过判断类间灰度差以排除纯背景或纯物体的干扰，详细原理见文章：https://blog.csdn.net/kk55guang2/article/details/78475414
DIP大作业图像分割大津法OTSU算法Python代码
01-11
DIP大作业图像分割大津法OTSU算法Python代码
（9-4）图像分割：基于区域的分割
最新发布
码农三叔
03-26 803
最后，我们将分割后的像素重新排列为图像形状，并显示原始图像和分割后的图像。在region_growing()函数中，首先获取图像的高度和宽度，创建一个与图像大小相同的空白图像(segmented)和一个标记图像(visited)，用于记录已访问过的像素。基于区域的图像分割方法是一种常见的图像分割技术，它基于图像中不同区域的特征来进行分割。它将图像表示为图的形式，其中像素作为图的顶点，像素之间的关系作为图的边。基于聚类的分割算法将图像中的像素聚类到不同的区域，根据像素之间的相似性或差异性来进行分割。
OpenCV_12 图像分割：全阈值分割+自适应阈值分割+Otsu 阈值（大津法）+分水岭算法+GraphCut+GrabCut
justin18chan的博客
11-25 2572
图像分割方法基于阈值的，基于边缘的，基于区域的，基于图论的等阈值分割全阈值分割：指将灰度值大于thresh(阈值)的像素设为一种颜色，小于或等于阈值的像素设为另外一种颜色自适应阈值分割：根据像素的邻域块的像素值分布来确定该像素位置上的阈值大津法：遍历不同的阈值，计算不同阈值下对应的背景和前景之间的类内方差，当类内方差取得极大值时，此时对应的阈值就是大津法分水岭算法。
基于大津法OTSU和图像分块的阈值分割算法
weixin_44650358的博客
04-29 1607
一、 算法目的及原理 （1） 目的： 阈值分割可以把图像中的前景目标和背景分割开，它特别适用于目标和背景占据不同灰度级范围的图像。它不仅可以极大的压缩图像的数据信息，而且也大大简化了分析和处理步骤，因此在很多情况下，是进行图像分析、特征提取与模式识别之前的必要的图像预处理过程，常用于机器视觉产品的检测。 （2） 原理： 通过统计灰度直方图，在峰与峰的灰度级之间设定阈值，把图像分割成n类。基于OTSU的阈值分割是根据计算双峰直方图的最大类间方差，从而确定把前景目标和背景区分的最佳阈值，通过阈值把原图像分割成一
基于梯度调整的矩不变自动阈值图像分割算法
深之JohnChen的专栏
03-16 5945
基于梯度调整的矩不变自动阈值图像分割算法来源：电子技术应用  作者：罗诗途 罗飞路 张王已 王艳玲摘要：提出了一种改进的矩不变自动阈值算法。该算法针对矩不变自动阈值法忽略图像细节的缺点，在矩不变自动阈值的基础上增加了基于目标边缘像素的梯度调整，从而使分割效果兼顾图像的整体和细节。该算法无须迭代或搜索，运算速度快，可以满足实时性的要求。仿真结果表明，该算法能有效地对目标图像进行分割。
迭代法进行图像分割
04-24
使用迭代法进行图像分割。Matlab源代码。可根据图像中物体的灰度分布情况，选取一个近似阈值作为初始阈值，然后通过分割图像和修改阈值的迭代过程获得认可的最佳阈值。
光照不均匀图像分割技巧1——分块阈值
热门推荐
技术改变世界
11-08 2万+
在数字图像处理中，图像分割是很关键的一步，当图像质量较好，光照很均匀的时候只需用全局阈值的方法就能很完美地完成图像分割任务，但是有些时候会遇到光照不均匀的现象，这个时候就需要用一些技巧才能达...
【youcans 的 OpenCV 例程200篇】167.基于移动平均的可变阈值处理
youcans的博客
04-30 1565
移动平均法是一种简单高效的局部阈值方法。 灰度遮蔽着点照明（如闪光灯）图像中十分常见。图中被斑点灰度模式遮蔽的手写文本图像，如果使用 OTSU 全局阈值处理，不能克服灰度变化的影响。在不均匀的光照场中，阈值分割的效果不好。使用移动平均的局部阈值，则能很好地进行处理。
数字图像处理（十）图像分割之全局阈值处理、otsu阈值处理、多阈值处理、可变阈值处理、多变量阈值处理
hjxu2016的博客
06-21 1万+
本篇所有代码都是基于24位BMP图像一. 基本的全局阈值处理当图像的前景和背景相关的只方图之间存在一个相当清晰的波谷时，这个算法效果很好。这部分算法比较简单，由于时间关系，并没有写相关代码算法步骤：一、为全局阈值T选择一个初始的估计值（一般选平均灰度）二、用T分割该图像产生的像素组，G1为灰度值大于T的所有像素组成，G2为灰度值小于T的所有像素组成三、对G1和G2分别计算平均灰度值m1和m2，计算...
图像的阈值处理
JaxonChan的博客
07-31 3347
一般情况下，一张图片分为前景和背景，我们感兴趣的一般的是前景部分，所以我们一般使用阈值将前景和背景分割开来，使我们感兴趣的图像的像素值为1，不感兴趣的我0，有时一张图我们会有几个不同的感兴趣区域（不在同一个灰度区域），这时我们可以用多个阈值进行分割，这就是阈值处理。 单个阈值： 两个阈值： 示意图如下： 1.基本全局阈值处理 一般选取阈值就是图像直方图的视觉检测。将区分度大的两个灰度级部分之间进行划分，取T为阈值来分开它们。在此基础上学习一种自动地选择阈值的算法，方法如下：
迭代阈值法
11-21
使用迭代阈值法进行图像分割*******************************************
基于迭代法的图像分割
05-21
基于迭代法的图像分割，可以实现水下目标的检测
迭代法实现图像阈值分割
09-25
代码的功能是通过迭代法实现阈值的分割，阈值分割思想和原理若图像中目标和背景具有不同的灰度集合：目标灰度集合与背景灰度集合，且两个灰度集合可用一个灰度级阈值T进行分割。这样就可以用阈值分割灰度级的方法在图像中分割出目标区域与背景区域，这种方法称为灰度阈值分割方法。
图像分割迭代法求阈值
05-19
图像分割 迭代法，求最佳阈值 %迭代法求阈值的原理： %基于逼近的思想，步骤如下： %1． 求出图象的最大灰度值和最小灰度值，分别记为ZMAX和ZMIN，令初始阈值T0=(ZMAX+ZMIN)/2； %2． 根据阈值TK将图象分割为前景和背景，分别求出两者的平均灰度值ZO和ZB %3． 求出新阈值TK+1=(ZO+ZB)/2； %4． 若TK=TK+1，则所得即为阈值；否则转2，迭代计算。
imagesegment.rar_OTSU_otsu matlab_大津法_大津阈值法_迭代法分割
07-14
压缩包包括大津法和迭代法阈值分割，大津法是使得类间方差最大，得到目标的阈值。
基于Python的图像阈值化分割(迭代法)
01-21
1.阈值化分割原理 通过对图像的灰度直方图进行数学统计，选择一个或多个阈值将像素划分为若干类。...经阈值化处理后的图像g(x,y)定义为： 其中f(x,y)为原图像，T为灰度阈值，g(x,y)为分割后产生的二
MATLAB实现OTSU法图像分割程序.zip
04-24
适用对象：灰度图像（8 bit） 参照论文：《A Tlreshold Selection Method from Gray-Level Histograms》 使用说明：直接运行脚本文件testOtsuThresholding.m即可，具体见注释
matlab迭代阈值分割
10-10
迭代阈值分割是一种图像处理方法，通过不断迭代计算像素点的阈值来实现图像的分割。在MATLAB中，可以使用以下步骤进行迭代阈值分割： 1. 选择初始的阈值T。 2. 将图像根据阈值T分为两个区域：一个是低于阈值的区域，另一个是高于阈值的区域。 3. 分别计算两个区域的平均灰度值：mu1和mu2。 4. 更新阈值T为(mu1 + mu2) / 2。 5. 重复步骤2到步骤4，直到阈值收敛或达到预设的迭代次数。 以下是一个示例代码： ```matlab function segmented_img = iterative_threshold_segmentation(img, max_iter) T = mean(img(:)); % 初始化阈值为图像的平均灰度值 for i = 1:max_iter region1 = img < T; region2 = img >= T; mu1 = mean(img(region1)); mu2 = mean(img(region2)); new_T = (mu1 + mu2) / 2; if abs(new_T - T) < 0.5 % 判断阈值是否收敛 break; end T = new_T; end segmented_img = img >= T; end ``` 这个函数`iterative_threshold_segmentation`接受两个参数：`img`为输入图像，`max_iter`为最大迭代次数。函数返回一个二值化的图像，其中像素值大于等于阈值T的部分为前景，小于阈值T的部分为背景。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

拾牙慧者

欢迎请作者喝奶茶

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值