自适应阈值分割（vc实现）

最新推荐文章于 2023-10-04 14:44:14 发布
最新推荐文章于 2023-10-04 14:44:14 发布
阅读量792 收藏
点赞数
分类专栏： 图像处理

1.以8×8邻域

划分太细，整体效果像铅笔素描。

[cpp] view plain copy print ?
  1. void CISLSView::OnThresholdAdaptive88()  
  2.     {  
  3. //程序编制：李立宗   
  4. //lilizong@gmail.com   
  5. //2012-8-14   
  6.         if(myImage1.IsNull())  
  7.             OnOpenResourceFile();  
  8.         if(!myImage2.IsNull())  
  9.             myImage2.Destroy();  
  10.         if(myImage2.IsNull()){  
  11.             myImage2.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);  
  12.         }  
  13.                 if(myImage3.IsNull()){  
  14.             myImage3.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);  
  15.         }  
  16.         //COLORREF pixel;    
  17.         int maxY = myImage1.GetHeight();  
  18.         int maxX=myImage1.GetWidth();  
  19.         byte* pRealData;  
  20.         byte* pRealData2;  
  21.         byte* pRealData3;  
  22.         pRealData=(byte*)myImage1.GetBits();  
  23.         pRealData2=(byte*)myImage2.GetBits();  
  24.         pRealData3=(byte*)myImage3.GetBits();  
  25.         int pit=myImage1.GetPitch();  
  26.         int pit2=myImage2.GetPitch();  
  27.         int pit3=myImage3.GetPitch();  
  28.         //需要注意,pit和pit2的值并不一样,所以如果使用一个值,会导致不同的结果出现  
  29.         //CString str;   
  30.         //str.Format(TEXT("%d"),pit);   
  31.         //MessageBox(str);   
  32.         //str.Format(TEXT("%d"),pit2);   
  33.         //MessageBox(str);   
  34.         int bitCount=myImage1.GetBPP()/8;  
  35.         int bitCount2=myImage2.GetBPP()/8;  
  36.         int bitCount3=myImage3.GetBPP()/8;  
  37.         int tempR,tempG,tempB;  
  38.         //float temp,tempX,tempY;   
  39.         int temp;  
  40.         int T=128;  
  41.         //int pixel[4];   
  42.         float u0,u1;   //均值  
  43.         float w0,w1;   //概率  
  44.         float sum0,sum1;  //像素和  
  45.         int optIndex,optT;   //最优阈值，及其所在像素的值  
  46.         float fVaria,fMaxVaria=0;   //临时方差,最大方差  
  47.         int i;        //循环变量  
  48.         //int pixelR[256],pixelG[256],pixelB[256];  
  49.         int pixel[256]={0};   //不要忘记初始化  
  50.         //灰度化   
  51.         for (int y=0; y<maxY; y++) {  
  52.             for (int x=0; x<maxX; x++) {  
  53.                 temp=*(pRealData+pit*(y)+(x)*bitCount);  
  54.                 if(bitCount==3)  
  55.                 {  
  56.                     tempR=*(pRealData+pit*(y)+(x)*bitCount);  
  57.                     tempG=*(pRealData+pit*(y)+(x)*bitCount+1);  
  58.                     tempB=*(pRealData+pit*(y)+(x)*bitCount+2);  
  59.                     temp=(int)(tempR*0.49+tempG*0.31+tempB*0.2);  
  60.                     //temp=(int)((tempR+tempG+tempB)/3);  
  61.                 }  
  62.                 *(pRealData3+pit3*(y)+(x)*bitCount3)=temp;  
  63.                 *(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;  
  64.                 *(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;  
  65.   
  66.             }  
  67.         }  
  68.         //计算除边界外的点   
  69.         for (int y=1; y<maxY-1; y++) {  
  70.             for (int x=1; x<maxX-1; x++) {  
  71.                 temp=*(pRealData3+pit3*(y)+(x)*bitCount3);  
  72.                 T=*(pRealData3+pit3*(y-1)+(x-1)*bitCount3)+*(pRealData3+pit3*(y-1)+(x)*bitCount3)+*(pRealData3+pit3*(y-1)+(x+1)*bitCount3)  
  73.                 +*(pRealData3+pit3*(y)+(x-1)*bitCount3)+*(pRealData3+pit3*(y)+(x)*bitCount3)+*(pRealData3+pit3*(y)+(x+1)*bitCount3)+  
  74.                 *(pRealData3+pit3*(y+1)+(x-1)*bitCount3)+*(pRealData3+pit3*(y+1)+(x)*bitCount3)+*(pRealData3+pit3*(y+1)+(x+1)*bitCount3);  
  75.                 T=(int)(T/9.0);  
  76.         //              CString str;   
  77.         //str.Format(TEXT("%d"),T);  
  78.         //MessageBox(str);   
  79.                 if(temp>T)  
  80.                     temp=255;  
  81.                 else  
  82.                 temp=0;  
  83.   
  84.                 *(pRealData2+pit2*(y)+(x)*bitCount2)=temp;  
  85.                 *(pRealData2+pit2*(y)+(x)*bitCount2+1)=temp;  
  86.                 *(pRealData2+pit2*(y)+(x)*bitCount2+2)=temp;  
  87.             }  
  88.         }  
  89.         Invalidate();  
  90.     }  
void CISLSView::OnThresholdAdaptive88()
	{
//程序编制：李立宗
//lilizong@gmail.com
//2012-8-14
		if(myImage1.IsNull())
			OnOpenResourceFile();
		if(!myImage2.IsNull())
			myImage2.Destroy();
		if(myImage2.IsNull()){
			myImage2.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);
		}
				if(myImage3.IsNull()){
			myImage3.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);
		}
		//COLORREF pixel; 
		int maxY = myImage1.GetHeight();
		int maxX=myImage1.GetWidth();
		byte* pRealData;
		byte* pRealData2;
		byte* pRealData3;
		pRealData=(byte*)myImage1.GetBits();
		pRealData2=(byte*)myImage2.GetBits();
		pRealData3=(byte*)myImage3.GetBits();
		int pit=myImage1.GetPitch();
		int pit2=myImage2.GetPitch();
		int pit3=myImage3.GetPitch();
		//需要注意,pit和pit2的值并不一样,所以如果使用一个值,会导致不同的结果出现
		//CString str;
		//str.Format(TEXT("%d"),pit);
		//MessageBox(str);
		//str.Format(TEXT("%d"),pit2);
		//MessageBox(str);
		int bitCount=myImage1.GetBPP()/8;
		int bitCount2=myImage2.GetBPP()/8;
		int bitCount3=myImage3.GetBPP()/8;
		int tempR,tempG,tempB;
		//float temp,tempX,tempY;
		int temp;
		int T=128;
		//int pixel[4];
		float u0,u1;   //均值
		float w0,w1;   //概率
		float sum0,sum1;  //像素和
		int optIndex,optT;   //最优阈值，及其所在像素的值
		float fVaria,fMaxVaria=0;   //临时方差,最大方差
		int i;        //循环变量
		//int pixelR[256],pixelG[256],pixelB[256];
		int pixel[256]={0};   //不要忘记初始化
		//灰度化
		for (int y=0; y<maxY; y++) {
			for (int x=0; x<maxX; x++) {
				temp=*(pRealData+pit*(y)+(x)*bitCount);
				if(bitCount==3)
				{
					tempR=*(pRealData+pit*(y)+(x)*bitCount);
					tempG=*(pRealData+pit*(y)+(x)*bitCount+1);
					tempB=*(pRealData+pit*(y)+(x)*bitCount+2);
					temp=(int)(tempR*0.49+tempG*0.31+tempB*0.2);
					//temp=(int)((tempR+tempG+tempB)/3);
				}
				*(pRealData3+pit3*(y)+(x)*bitCount3)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;
				*(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;

			}
		}
		//计算除边界外的点
		for (int y=1; y<maxY-1; y++) {
			for (int x=1; x<maxX-1; x++) {
				temp=*(pRealData3+pit3*(y)+(x)*bitCount3);
				T=*(pRealData3+pit3*(y-1)+(x-1)*bitCount3)+*(pRealData3+pit3*(y-1)+(x)*bitCount3)+*(pRealData3+pit3*(y-1)+(x+1)*bitCount3)
				+*(pRealData3+pit3*(y)+(x-1)*bitCount3)+*(pRealData3+pit3*(y)+(x)*bitCount3)+*(pRealData3+pit3*(y)+(x+1)*bitCount3)+
				*(pRealData3+pit3*(y+1)+(x-1)*bitCount3)+*(pRealData3+pit3*(y+1)+(x)*bitCount3)+*(pRealData3+pit3*(y+1)+(x+1)*bitCount3);
				T=(int)(T/9.0);
		//				CString str;
		//str.Format(TEXT("%d"),T);
		//MessageBox(str);
				if(temp>T)
					temp=255;
				else
				temp=0;

				*(pRealData2+pit2*(y)+(x)*bitCount2)=temp;
				*(pRealData2+pit2*(y)+(x)*bitCount2+1)=temp;
				*(pRealData2+pit2*(y)+(x)*bitCount2+2)=temp;
			}
		}
		Invalidate();
	}

2.将图像划分为四个区域计算

该模式缺点，可以看到四个区域之间具有明显的边界。

[cpp] view plain copy print ?
  1. void CISLSView::OnThresholdAdaptive41()  
  2.     {  
  3. //程序编制：李立宗 lilizong@gmail.com   
  4. //2012-8-14   
  5.         if(myImage1.IsNull())  
  6.             OnOpenResourceFile();  
  7.         if(!myImage2.IsNull())  
  8.             myImage2.Destroy();  
  9.         if(myImage2.IsNull()){  
  10.             myImage2.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);  
  11.         }  
  12.                 if(myImage3.IsNull()){  
  13.             myImage3.Create(myImage1.GetWidth(),myImage1.GetHeight(),24,0);  
  14.         }  
  15.         //COLORREF pixel;    
  16.         int maxY = myImage1.GetHeight();  
  17.         int maxX=myImage1.GetWidth();  
  18.         byte* pRealData;  
  19.         byte* pRealData2;  
  20.         byte* pRealData3;  
  21.         pRealData=(byte*)myImage1.GetBits();  
  22.         pRealData2=(byte*)myImage2.GetBits();  
  23.         pRealData3=(byte*)myImage3.GetBits();  
  24.         int pit=myImage1.GetPitch();  
  25.         int pit2=myImage2.GetPitch();  
  26.         int pit3=myImage3.GetPitch();  
  27.         //需要注意,pit和pit2的值并不一样,所以如果使用一个值,会导致不同的结果出现  
  28.         //CString str;   
  29.         //str.Format(TEXT("%d"),pit);  
  30.         //MessageBox(str);   
  31.         //str.Format(TEXT("%d"),pit2);  
  32.         //MessageBox(str);   
  33.         int bitCount=myImage1.GetBPP()/8;  
  34.         int bitCount2=myImage2.GetBPP()/8;  
  35.         int bitCount3=myImage3.GetBPP()/8;  
  36.         int tempR,tempG,tempB;  
  37.         //float temp,tempX,tempY;  
  38.         int temp;  
  39.         int T=128;  
  40.         //int pixel[4];   
  41.         float u0,u1;   //均值  
  42.         float w0,w1;   //概率  
  43.         float sum0,sum1;  //像素和  
  44.         int optIndex,optT;   //最优阈值，及其所在像素的值  
  45.         float fVaria,fMaxVaria=0;   //临时方差,最大方差  
  46.         int i;        //循环变量  
  47.         //int pixelR[256],pixelG[256],pixelB[256];  
  48.         int pixel[256]={0};   //不要忘记初始化  
  49.         int sum=0,avg;  
  50.         //灰度化   
  51.         for (int y=0; y<maxY; y++) {  
  52.             for (int x=0; x<maxX; x++) {  
  53.                 temp=*(pRealData+pit*(y)+(x)*bitCount);  
  54.                 if(bitCount==3)  
  55.                 {  
  56.                     tempR=*(pRealData+pit*(y)+(x)*bitCount);  
  57.                     tempG=*(pRealData+pit*(y)+(x)*bitCount+1);  
  58.                     tempB=*(pRealData+pit*(y)+(x)*bitCount+2);  
  59.                     temp=(int)(tempR*0.49+tempG*0.31+tempB*0.2);  
  60.                     //temp=(int)((tempR+tempG+tempB)/3);  
  61.                 }  
  62.                 *(pRealData3+pit3*(y)+(x)*bitCount3)=temp;  
  63.                 *(pRealData3+pit3*(y)+(x)*bitCount3+1)=temp;  
  64.                 *(pRealData3+pit3*(y)+(x)*bitCount3+2)=temp;  
  65.   
  66.             }  
  67.         }  
  68.         //计算左上角阈值   
  69.         for (int y=0; y<maxY/2; y++) {  
  70.             for (int x=0; x<maxX/2; x++) {  
  71.                 sum+=*(pRealData3+pit3*(y)+(x)*bitCount3);                
  72.             }  
  73.         }         
  74.         avg=(int)(sum/(maxY/2*(maxX/2)));  
  75.         //处理左上角   
  76.         for (int y=0; y<maxY/2; y++) {  
  77.             for (int x=0; x<maxX/2; x++) {  
  78.                 temp=*(pRealData3+pit3*(y)+(x)*bitCount3);    
  79.                 if(temp>avg)  
  80.                     temp=255;  
  81.                 else  
  82.                 temp=0;  
  83.   
  84.                 *(pRealData2+pit2*(y)+(x)*bitCount2)=temp;  
  85.                 *(pRealData2+pit2*(y)+(x)*bitCount2+1)=temp;  
  86.                 *(pRealData2+pit2*(y)+(x)*bitCount2+2)=temp;  
  87.             }  
  88.         }  
  89.         //右上角   
  90.         sum=0;  
  91.         for (int y=0; y<maxY/2; y++) {  
  92.             for (int x=maxX/2; x<maxX; x++) {  
  93.                 sum+=*(pRealData3+pit3*(y)+(x)*bitCount3);                
  94.             }  
  95.         }         
  96.         avg=(int)(sum/(maxY/2*(maxX/2)));  
  97.         for (int y=0; y<maxY/2; y++) {  
  98.             for (int x=maxX/2; x<maxX; x++) {  
  99.                 temp=*(pRealData3+pit3*(y)+(x)*bitCount3);    
  100.                 if(temp>avg)  
  101.                     temp=255;  
  102.                 else  
  103.                 temp=0;  
  104.   
  105.                 *(pRealData2+pit2*(y)+(x)*bitCount2)=temp;  
  106.                 *(pRealData2+pit2*(y)+(x)*bitCount2+1)=temp;  
  107.                 *(pRealData2+pit2*(y)+(x)*bitCount2+2)=temp;  
  108.             }  
  109.         }  
  110.         //左下角   
  111.         sum=0;  
  112.                 for (int y=maxY/2; y<maxY; y++) {  
  113.             for (int x=0; x<maxX/2; x++) {  
  114.                 sum+=*(pRealData3+pit3*(y)+(x)*bitCount3);                
  115.             }  
  116.         }         
  117.         avg=(int)(sum/(maxY/2*(maxX/2)));  
  118.         for (int y=maxY/2; y<maxY; y++) {  
  119.             for (int x=0; x<maxX/2; x++) {  
  120.                 temp=*(pRealData3+pit3*(y)+(x)*bitCount3);    
  121.                 if(temp>avg)  
  122.                     temp=255;  
  123.                 else  
  124.                 temp=0;  
  125.   
  126.                 *(pRealData2+pit2*(y)+(x)*bitCount2)=temp;  
  127.                 *(pRealData2+pit2*(y)+(x)*bitCount2+1)=temp;  
  128.                 *(pRealData2+pit2*(y)+(x)*bitCount2+2)=temp;  
  129.             }  
  130.         }  
  131.         //右下角   
  132.         sum=0;  
  133.                 for (int y=maxY/2; y<maxY; y++) {  
  134.             for (int x=maxX/2; x<maxX; x++) {  
  135.                 sum+=*(pRealData3+pit3*(y)+(x)*bitCount3);                
  136.             }  
  137.         }         
  138.         avg=(int)(sum/(maxY/2*(maxX/2)));  
  139.         for (int y=maxY/2; y<maxY; y++) {  
  140.             for (int x=maxX/2; x<maxX; x++) {  
  141.                 temp=*(pRealData3+pit3*(y)+(x)*bitCount3);    
  142.                 if(temp>avg)  
  143.                     temp=255;  
  144.                 else  
  145.                 temp=0;  
  146.   
  147.                 *(pRealData2+pit2*(y)+(x)*bitCount2)=temp;  
  148.                 *(pRealData2+pit2*(y)+(x)*bitCount2+1)=temp;  
  149.                 *(pRealData2+pit2*(y)+(x)*bitCount2+2)=temp;  
  150.             }  
  151.         }  
  152.   
  153.   
  154.         Invalidate();  
  155.     }  
wujinting007
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数字图像处理（入门篇）十二 自适应阈值分割
静谧、淡雅
12-10 2434
数字图像处理（入门篇）十二 自适应阈值分割
计算机视觉基础：自适应阈值分割（Computer Vision Fundamentals: Adaptive Threshold Segmentation）
newxuyangcao
03-24 3990
阈值分割方法虽然简单，但是如果场景简单，还是可以尝试使用的，因为其消耗的时间较少。同时，阈值分割也可以作为一个baseline来验证提出的新算法是否有效。本文主要介绍了OpenCV中介绍的两种自适应阈值分割算法，在实际工程中较常使用。
10.9 图像分割
qq_40066957的博客
05-12 1988
3.9 图像分割 学习目标 了解图像分割的类型 知道阈值分割的内容：全阈值分割，自适应阈值分割，熟悉大津法 知道分水岭算法的原理 了解GrabCut算法 1 图像分割 所谓图像分割指的是根据灰度、颜色、纹理和形状等特征把图像划分成若干互不交迭的区域，并使这些特征在同一区域内呈现出相似性，而在不同区域间呈现出明显的差异性。我们先对目前主要的图像分割方法做个概述，后面再对个别方法做详细的了解和学习。 1、基于阈值的分割方法 阈值法的基本思想是基于图像的灰度特征来计
图像处理与计算机视觉--第五章-图像分割-自适应阈值分割
最新发布
m0_71819746的博客
10-04 4806
图像处理与计算机视觉--第五章-图像分割-自适应阈值分割
OpenCV_12 图像分割：全阈值分割+自适应阈值分割+Otsu 阈值（大津法）+分水岭算法+GraphCut+GrabCut
justin18chan的博客
11-25 2784
图像分割方法基于阈值的，基于边缘的，基于区域的，基于图论的等阈值分割全阈值分割：指将灰度值大于thresh(阈值)的像素设为一种颜色，小于或等于阈值的像素设为另外一种颜色自适应阈值分割：根据像素的邻域块的像素值分布来确定该像素位置上的阈值大津法：遍历不同的阈值，计算不同阈值下对应的背景和前景之间的类内方差，当类内方差取得极大值时，此时对应的阈值就是大津法分水岭算法。
【图像分割】自适应阈值图像分割方法（最大类间差法与最大熵法）
EnjoyTheChange的博客
04-18 5539
文章目录前言一、最大类间方差法原理二、使用步骤1.引入库2.读入数据总结 前言 最大类间方差法是由日本学者大津(Nobuyuki Otsu)于1979年提出的,是一种自适合于双峰情况的自动求取阈值的方法,又叫大津法,简称Otsu。它是按图像的灰度特性,将图像分成背景和目标2部分。背景和目标之间的类间方差越大,说明构成图像的2部分的差别越大,当部分目标错分为背景或部分背景错分为目标都会导致2部分差别变小。因此,使类间方差最大的分割意味着错分概率最小。 提示：以下是本篇文章正文内容，下面案例可供参考 一、最
基于模糊的自适应阈值分割
03-24
【基于模糊的自适应阈值分割】 在计算机视觉和图像处理领域，图像分割是一项至关重要的技术，它将图像划分为不同的区域或对象，以便于分析和理解。基于模糊的自适应阈值分割方法是一种常见的图像分割策略，尤其适用...
yuzhifenge.zip_半阈值分割_自适应_自适应阈值_自适应阈值 c_阈值
09-21
本主题主要关注四种阈值分割方法：半阈值分割、自适应阈值分割以及它们在C语言中的实现。 1. **半阈值分割**： 半阈值分割是基于局部像素信息的一种分割方法。它的基本思想是，如果一个像素的强度大于其邻域内的...
用vc实现图像阈值分割.docx
07-03
在实际应用中，阈值分割可能涉及更复杂的策略，如全局阈值、局部阈值、自适应阈值等，以适应不同场景的需求。此外，为了提高程序的可读性和可维护性，一般会将图像处理算法封装成独立的函数或类，便于复用和调试。在...
最大熵阈值算法的VC实现带代码
03-05
为了提高分割效果，可以考虑结合其他方法，如自适应阈值、Otsu阈值等，或者使用更复杂的图像分割算法如水平集、区域生长等。同时，优化算法的效率也很重要，特别是在处理大尺寸图像时。 总之，最大熵阈值算法是一种...
数字图像处理VC实现
09-23
这可能使用了阈值分割、区域生长、边缘检测（如Canny、Sobel、Prewitt算子）或者更复杂的分水岭算法、水平集方法等。图像分割在医学影像、机器视觉等领域有广泛应用。 4. **VC++环境**：使用VC++作为开发工具，意味...
自适应阈值分割代码
08-22
一个基于opencv的自适应阈值分割代码 可以使用滑动条来调节分割阈值
阈值分割（OTSU）的C代码实现
05-23
压缩包包含了图片读取、算法计算、图像输出，下载后可以直接执行
自适应阈值（adaptiveThreshold）分割原理及实现
热门推荐
小武的博客
05-14 8万+
背景介绍及原理 前面介绍了OTSU算法和最大熵算法，但这两种算法都属于全局阈值法，所以对于某些光照不均的图像，这种全局阈值分割的方法会显得苍白无力，如下图： 显然，这样的阈值处理结果不是我们想要的，那么就需要一种方法来应对这样的情况。 这种办法就是自适应阈值法(adaptiveThreshold)，它的思想不是计算全局图像的阈值，而是根据图像不同区域亮...
R329-opencv阈值分割算法——自适应阈值
ice_q_001810的博客
01-18 4228
R329-opencv阈值分割算法——自适应阈值 在不均匀照明或者灰度值分布不均的情况下，如果使用全局阈值分割，那么得到的分割效果往往会很不理想，这个时候就要你用到自适应阈值算法了。OpenCV提供了自适应的二值化函数，通过该函数可以对图像的不同区域动态计算并应用不同的阈值进行二值化。官方文档：https://docs.opencv.org/3.4.2/d7/d1b/group__imgproc__misc.html#ga72b913f352e4a1b1b397736707afcde3 dst = cv2.
【C++ OpenCV】阈值二值化、阈值反二值化、截断、阈值取零、阈值反取零、自适应阈值使用方法以及时机
dagengen12138的博客
06-13 5694
阈值：简单来说就是一把分割图像像素的标尺，在二值化处理中有固定阈值和自适应阈值两种形式。那么什么时候用固定阈值，什么时候使用自适应阈值呢？答：当图像，且目标和背景容易区分时，可以采用固定阈值当图像，且有，虽然使用大津法和三角形法也可以自己寻找阈值，但整个图像阈值都是相同，所以最终分割效果较差。所以，可以用，或者将整个图像成几行几列，对每个部分运用大津法或者三角形法，最后将图形整合，这样每一部分的阈值就不相同，分割效果也会更好。
图像处理———大津法和自适应阈值图像分割介绍及实现
weixin_44494462的博客
04-29 5972
该部分的学习内容是对经典的阈值分割算法进行回顾，图像阈值化分割是一种传统的最常用的图像分割方法，因其实现简单、计算量小、性能较稳定而成为图像分割中最基本和应用最广泛的分割技术。它特别适用于目标和背景占据不同灰度级范围的图像。它不仅可以极大的压缩数据量，而且也大大简化了分析和处理步骤，因此在很多情况下，是进行图像分析、特征提取与模式识别之前的必要的图像预处理过程。图像阈值化的目的是要按照灰度级，对像...
自适应阈值分割
August的博客
03-07 8591
1.原理        最简单的阈值分割即为手动设置阈值对图像进行二值化，大于设定的阈值像素值设置为255，小于设定阈值则为0.这种方法一般称为全局阈值分割，接下来想介绍的是一种局部阈值分割算法，其原理很简单，通俗地讲就是图片的每个局部都会通过处理得到一个阈值，这个区域就用这个阈值来进行分割，同理，每个区域都有不同的阈值来处理，...
【千律】OpenCV基础：图像阈值分割 -- 自适应阈值分割
weixin_42704093的博客
03-26 5184
环境：Python3.8 和 OpenCV 内容：自适应阈值分割 算法思想：局部二值化，全局二值化容易受阴影影响。 具体算法步骤如下： （1）对某个像素值，原来为S，取其周围的n×n的区域，求取区域均值或高斯加权值，记为T。 （2）对8位图像，如果S>T，则该像素点二值化为255，否则为0。 优化： （1）在实际操作中，通过均值模糊或高斯模糊实现区域均值或高斯加权值。 （2）增加超参数C，当S>T-C时，将像素值设置为255。 （3）设置范围在0-1的超参数a，当S>(1-a)T时，将
自适应阈值分割matlab实现
04-06
以下是一个简单的自适应阈值分割matlab实现的示例代码： ```matlab % 读取图像 img = imread('example.jpg'); % 将图像转换为灰度图像 gray_img = rgb2gray(img); % 定义块大小和常数C block_size = 15; C = 5; %...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值