数字图像处理（九）图像分割之canny边缘检测

最新推荐文章于 2024-01-17 23:14:57 发布
最新推荐文章于 2024-01-17 23:14:57 发布
阅读量5.3k 收藏 21
点赞数 2
分类专栏： 个人笔记|数字图像处理(c++)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjxu2016/article/details/80745766
版权

本篇所有代码都是基于24位BMP图像。

且本篇代码只能算canny边缘检测的思路，可能离标准的canny边缘检测还差点。

1)        以低的错误率检测边缘，也即意味着需要尽可能准确的捕获图像中尽可能多的边缘。

2)        检测到的边缘应精确定位在真实边缘的中心。

3)        图像中给定的边缘应只被标记一次，并且在可能的情况下，图像的噪声不应产生假的边缘。

算法步骤

一、用一个高斯滤波器，平滑图像，去除噪声；

二、计算梯度幅值以及梯度角度（也叫方向），即计算图像每个点的强度和方向。这

边需要开一个内存缓冲区，用来保存角度；

三、对梯度幅值使用非最大抑制，以消除边缘检测带来的杂散响应。这边可以看做精

确定位真实边缘的中心；

四、双阈值处理以及连接分析来检测并连接边缘。

基于MFC代码

首先，建立menu类向导，然后代码开始时

void CImageProcessingView::OnXtxFs()  
{  
    // TODO: 在此添加命令处理程序代码  
    if (numPicture == 0)  
    {  
        AfxMessageBox("请输入一张图像", MB_OK, 0);  
        return;  
    }  
  
    if (m_nBitCount != 24)  
    {  
        AfxMessageBox("输入图片不是24位", MB_OK, 0);  
        return;  
    }  
    AfxMessageBox("图像分割，canny！", MB_OK, 0);  

    int num;//记录每一行需要填充的字节  
    if (m_nWidth * 3 % 4 != 0)  
    {  
        num = 4 - m_nWidth * 3 % 4;  
    }  
    else  
    {  
        num = 0;  
    }

一. 高斯滤波器

 关于高斯滤波器，可以看这篇对高斯滤波器的介绍。https://blog.csdn.net/hjxu2016/article/details/80745115

本文的滤波器设置的很简单。设置为


滤波代码如下

float H1[3][3] = {
		{ 1.0 / 16,2.0 / 16,1.0 / 16 }, //模板二:系数1/16  高斯滤波器 
		{ 2.0 / 16,4.0 / 16,2.0 / 16 },
		{ 1.0 / 16,2.0 / 16,1.0 / 16 } };
	int HWS = 3;
	FILE *fpo = fopen(BmpName, "rb");
	FILE *fpw = fopen(BmpNameLin, "wb+");
	fread(&bfh, sizeof(BITMAPFILEHEADER), 1, fpo);
	fread(&bih, sizeof(BITMAPINFOHEADER), 1, fpo);
	fwrite(&bfh, sizeof(BITMAPFILEHEADER), 1, fpw);
	fwrite(&bih, sizeof(BITMAPINFOHEADER), 1, fpw);
	fread(m_pImage, m_nImage, 1, fpo);

	unsigned char *ImageSize;
	ImageSize = new unsigned char[m_nImage];//new可以有效的内存释放  
	float red, green, blue;
	int x = 0, y = 0;//代表宽和高的位置  
	int LR, LG, LB;//记录实际的位置  
	int xx, yy;
	int num;//记录需要填充的字节  
	if (m_nWidth * 3 % 4 != 0)
	{
		num = 4 - m_nWidth * 3 % 4;
	}
	else if (m_nWidth * 3 % 4 == 0)
	{
		num = 0;
	}

	//高斯平滑，去除噪声，这里我选择最简单的高斯滤波器
	for (x = HWS / 2; x < m_nWidth - HWS / 2; x++)
	{
		for (y = HWS / 2; y < m_nHeight - HWS / 2; y++)
		{
			red = green = blue = 0;

			LR = (x + y*m_nWidth) * 3 + y*num;
			//LG = (x + y*m_nWidth) * 3 + 1;  
			//LB = (x + y*m_nWidth) * 3 + 2;  

			for (int j = 0; j < HWS; j++)//第几行  
			{
				yy = y + j - 1;
				for (int i = 0; i < HWS; i++)//第几列  
				{
					xx = x + i - 1;
					red += H1[j][i] * (float)(m_pImage[(xx + yy*m_nWidth) * 3 + yy * num]);
					green += H1[j][i] * (float)(m_pImage[(xx + yy*m_nWidth) * 3 + 1 + yy * num]);
					blue += H1[j][i] * (float)(m_pImage[(xx + yy*m_nWidth) * 3 + 2 + yy * num]);
				}
			}

			ImageSize[LR] = (unsigned char)(red);
			ImageSize[LR + 1] = (unsigned char)(green);
			ImageSize[LR + 2] = (unsigned char)(blue);
		}
	}

二. 计算梯度强度和方向

图像中的边缘可以指向各个方向，因此Canny算法使用四个算子来检测图像中的水平、垂直和对角边缘。边缘检测的算子（如Roberts，Prewitt，Sobel等）返回水平Gx和垂直Gy方向的一阶导数值，由此便可以确定像素点的梯度G和方向theta 。

其中G为梯度强度， theta表示梯度方向，arctan为反正切函数。下面以Sobel算子为例讲述如何计算梯度强度和方向。

梯度角度θ范围从弧度-PI/2到pi/2，我把角度加了PI/2然后把它近似到四个方向，分别代表水平，垂直和两个对角线方向（0°,45°,90°,135°）。我尽量把角度归到四个方向，PI/（PI/4）=（0，1，2，3），落在每个区域的梯度角给一个特定值，代表四个方向之一。

我采用sobel计算梯度和方向，注意，要再申请个缓冲区保存方向

若图像中一个3x3的窗口为A，要计算梯度的像素点为e，则和Sobel算子进行卷积之后，像素点e在x和y方向的梯度值分别为： 

 


代码如下

//计算梯度幅值和角度方向，我申请了一个和ImageSize一样大的空间存放角度，这里我采用sobel边缘检测算子
	//且在计算方向时，我尽量把角度归到四个方向，0，45，90，135.  PI/（PI/4）=（0，1，2，3），这样可以看成是
	//一个八领域，其实更精确的计算是算出双线性插值，为了代码简单，就直接比较像素了，不插值了, 
	//sobel算子
	unsigned char *ImageSizeSobel;//梯度
	ImageSizeSobel = new unsigned char[m_nImage];

	unsigned char *ImageSizeSobelDirection;//方向即角度
	ImageSizeSobelDirection = new unsigned char[m_nImage];

	int HX[3][3] = { { -1,-2,-1 },{ 0,0,0, },{ 1,2,1 } };
	int HY[3][3] = { { -1,0,1 },{ -2,0,2 },{ -1,0,1 } };
	int redX, greenX, blueX;
	int redY, greenY, blueY;
	int R, G, B;
	int a;//方向(0.1.2.3)
	for (y = HWS / 2; y < m_nHeight - HWS / 2; y++)
	{
		for (x = HWS / 2; x < m_nWidth - HWS / 2; x++)
		{

			redX = greenX = blueX = 0;
			redY = greenY = blueY = 0;
			LR = (y*m_nWidth + x) * 3 + y*num;

			for (int j = 0; j < HWS; j++)//第几行这两个求sobel的dx和dy
			{
				yy = y + j - 1;
				for (int i = 0; i < HWS; i++)//第几列  
				{
					xx = x + i - 1;
					redX += HX[j][i] * (ImageSize[(xx + yy*m_nWidth) * 3 + yy*num]);
					greenX += HX[j][i] * (ImageSize[(xx + yy*m_nWidth) * 3 + 1 + yy*num]);
					blueX += HX[j][i] * (ImageSize[(xx + yy*m_nWidth) * 3 + 2 + yy*num]);

					redY += HY[j][i] * (ImageSize[(xx + yy*m_nWidth) * 3 + yy*num]);
					greenY += HY[j][i] * (ImageSize[(xx + yy*m_nWidth) * 3 + 1 + yy*num]);
					blueY += HY[j][i] * (ImageSize[(xx + yy*m_nWidth) * 3 + 2 + yy*num]);

				}
			}
			double PI = asin(0.5) * 6;
			R = (int)sqrt(redX*redX*1.0 + redY*redY*1.0);
			G = (int)sqrt(greenX*greenX*1.0 + greenY*greenY*1.0);
			B = (int)sqrt(blueX*blueX*1.0 + blueY*blueY*1.0);

			a = int((atan(1.0*redX / redY)+PI/2)/(PI/4));
			ImageSizeSobelDirection[LR] = unsigned char(a);

			if (R > 255) R = 255;
			ImageSizeSobel[LR] = unsigned char(R);
			if (G > 255)G = 255;
			ImageSizeSobel[LR + 1] = unsigned char(G);
			if (B > 255)B = 255;
			ImageSizeSobel[LR + 2] = unsigned char(B);
		}
	}

三. 非极大值抑制

非最大值抑制是一种边缘细化方法。通常得出来的梯度边缘不止一个像素宽，而是多个像素宽。就像我们所说Sobel算子得出来的边缘粗大而明亮，从上面Lena图的Sobel结果可以看得出来。因此这样的梯度图还是很“模糊”。而准则3要求，边缘只有一个精确的点宽度。非最大值抑制能帮助保留局部最大梯度而抑制所有其他梯度值。这意味着只保留了梯度变化中最锐利的位置。算法如下：

  1. 比较当前点的梯度强度和正负梯度方向点的梯度强度。
  2. 如果当前点的梯度强度和同方向的其他点的梯度强度相比较是最大，保留其值。否则抑制，即设为0。比如当前点的方向指向正上方90°方向，那它需要和垂直方向，它的正上方和正下方的像素比较。

注意，方向的正负是不起作用的，比如东南方向和西北方向是一样的，都认为是对角线的一个方向。前面我们把梯度方向近似到水平，垂直和两个对角线四个方向，所以每个像素根据自身方向在这四个方向之一进行比较，决定是否保留。这一部分的代码也很简单，列出如下。pModule，pDirection分别记录了上一步梯度模值和梯度方向。


//非最大值抑制，直接对ImageSizeSobel处理
	int LRO, LR1, LR2, LR3, LR4, LR5, LR6, LR7;//逆时针开始八个方向的坐标

	for (y = HWS / 2; y < m_nHeight - HWS / 2; y++)
	{
		for (x = HWS / 2; x < m_nWidth - HWS / 2; x++)
		{

			LR = (y*m_nWidth + x) * 3 + y*num;
			LRO = (y*m_nWidth + x + 1) * 3 + y*num;
			LR1 = ((y + 1)*m_nWidth + x + 1) * 3 + (y + 1)*num;
			LR2 = ((y + 1)*m_nWidth + x) * 3 + (y + 1)*num;
			LR3 = ((y + 1)*m_nWidth + x - 1) * 3 + (y + 1)*num;
			LR4 = ((y)*m_nWidth + x - 1) * 3 + (y)*num;
			LR5 = ((y - 1)*m_nWidth + x - 1) * 3 + (y - 1)*num;
			LR6 = ((y - 1)*m_nWidth + x) * 3 + (y - 1)*num;
			LR6 = ((y - 1)*m_nWidth + x + 1) * 3 + (y - 1)*num;

			switch (ImageSizeSobelDirection[LR])//这里面的值是0.1.2.3，对应着四个角度
			{
			case 0:
				if (ImageSizeSobel[LR] <= ImageSizeSobel[LRO] || ImageSizeSobel[LR] <= ImageSizeSobel[LR4])
				{
					ImageSizeSobel[LR] = 0;
					ImageSizeSobel[LR+1] = 0;
					ImageSizeSobel[LR + 2] = 0;
					break;
				}
			case 1:
				if (ImageSizeSobel[LR] <= ImageSizeSobel[LR1] || ImageSizeSobel[LR] <= ImageSizeSobel[LR5])
				{
					ImageSizeSobel[LR] = 0;
					ImageSizeSobel[LR + 1] = 0;
					ImageSizeSobel[LR + 2] = 0;
					break;
				}

			case 2:
				if (ImageSizeSobel[LR] <= ImageSizeSobel[LR2] || ImageSizeSobel[LR] <= ImageSizeSobel[LR6])
				{
					ImageSizeSobel[LR] = 0;
					ImageSizeSobel[LR + 1] = 0;
					ImageSizeSobel[LR + 2] = 0;
					break;
				}
			case 3:
				if (ImageSizeSobel[LR] <= ImageSizeSobel[LR3] || ImageSizeSobel[LR] <= ImageSizeSobel[LR7])
				{
					ImageSizeSobel[LR] = 0;
					ImageSizeSobel[LR + 1] = 0;
					ImageSizeSobel[LR + 2] = 0;
					break;
				}
			}
		}
	}

四. 双阈值处理

一个高阈值和低阈值，高于高阈值的为255，低于低阈值的为0，一般取阈值为图像整体灰度的70%，这里我直接偷懒，分别设为100和30

	//双阈值处理，一个高阈值，一个低阈值，通常高阈值是低阈值的1.5-2倍。高于高阈值的为255，低于低阈值的为0，这里我们设置阈值为100和30.
	int H0 = 100, L0 = 30;
	for (y = HWS / 2; y < m_nHeight - HWS / 2; y++)
	{
		for (x = HWS / 2; x < m_nWidth - HWS / 2; x++)
		{

			LR = (y*m_nWidth + x) * 3 + y*num;
			if (ImageSizeSobel[LR] > H0)
			{
				ImageSizeSobel[LR] = 255;
				ImageSizeSobel[LR + 1] = 255;
				ImageSizeSobel[LR + 2] = 255;
			}
			if (ImageSizeSobel[LR] < L0)
			{
				ImageSizeSobel[LR] = 0;
				ImageSizeSobel[LR + 1] = 0;
				ImageSizeSobel[LR + 2] = 0;
			}
		}
	}

五、连接处理（孤立点抑制和连接）

灰度在低阈值和高阈值之间的，需要考察该点临近的8像素是否有灰度值为255的，如果没有，表示这是一个孤立的局部极大值点，可以排除了，赋值为0；如果只要有一个点是255，那么这个点是和其他边缘有连接的点，不能排除，赋值为255。

//链接处理，灰度在低阈值和高阈值之间的，考察改点临近的灰度值是否有255的，如果没有，赋值0，如果右，赋值255

	for (x = HWS / 2; x < m_nWidth - HWS / 2; x++)
	{
		for (y = HWS / 2; y < m_nHeight - HWS / 2; y++)
		{
			LR = (x + y*m_nWidth) * 3 + y*num;
			if (ImageSizeSobel[LR] >= L0 && ImageSizeSobel[LR] <= H0)//判断像素是不是在阈值区间
			{
				int temp = 0;
				for (int j = 0; j < HWS; j++)//第几行  
				{
					yy = y + j - 1;
					for (int i = 0; i < HWS; i++)//第几列  
					{
						xx = x + i - 1;
						if (ImageSizeSobel[(xx + yy*m_nWidth) * 3 + yy * num] == 255)

						{
							temp = 255;
							break;
						}

					}
					if (temp == 255) break;
				}

				ImageSizeSobel[LR] = (unsigned char)(temp);
				ImageSizeSobel[LR + 1] = (unsigned char)(temp);
				ImageSizeSobel[LR + 2] = (unsigned char)(temp);
			}
		}
	}


	fwrite(ImageSizeSobel, m_nImage, 1, fpw);
	fclose(fpo);
	fclose(fpw);
	numPicture = 2;
	level = 400;
	Invalidate();
}

完整版代码如下

void CImageProcessingView::OnTxfgCanny()
{
	// TODO: 在此添加命令处理程序代码
	if (numPicture == 0)
	{
		AfxMessageBox("请输入一张图片", MB_OK, 0);
		return;
	}
	if (m_nBitCount != 24)
	{
		AfxMessageBox("输入图片不是24位", MB_OK, 0);
		return;
	}
	AfxMessageBox("图像分割，canny边缘检测", MB_OK, 0);
	float H1[3][3] = {
		{ 1.0 / 16,2.0 / 16,1.0 / 16 }, //模板二:系数1/16  高斯滤波器 
		{ 2.0 / 16,4.0 / 16,2.0 / 16 },
		{ 1.0 / 16,2.0 / 16,1.0 / 16 } };
	int HWS = 3;
	FILE *fpo = fopen(BmpName, "rb");
	FILE *fpw = fopen(BmpNameLin, "wb+");
	fread(&bfh, sizeof(BITMAPFILEHEADER), 1, fpo);
	fread(&bih, sizeof(BITMAPINFOHEADER), 1, fpo);
	fwrite(&bfh, sizeof(BITMAPFILEHEADER), 1, fpw);
	fwrite(&bih, sizeof(BITMAPINFOHEADER), 1, fpw);
	fread(m_pImage, m_nImage, 1, fpo);

	unsigned char *ImageSize;
	ImageSize = new unsigned char[m_nImage];//new可以有效的内存释放  
	float red, green, blue;
	int x = 0, y = 0;//代表宽和高的位置  
	int LR, LG, LB;//记录实际的位置  
	int xx, yy;
	int num;//记录需要填充的字节  
	if (m_nWidth * 3 % 4 != 0)
	{
		num = 4 - m_nWidth * 3 % 4;
	}
	else if (m_nWidth * 3 % 4 == 0)
	{
		num = 0;
	}

	//高斯平滑，去除噪声，这里我选择最简单的高斯滤波器
	for (x = HWS / 2; x < m_nWidth - HWS / 2; x++)
	{
		for (y = HWS / 2; y < m_nHeight - HWS / 2; y++)
		{
			red = green = blue = 0;

			LR = (x + y*m_nWidth) * 3 + y*num;
			//LG = (x + y*m_nWidth) * 3 + 1;  
			//LB = (x + y*m_nWidth) * 3 + 2;  

			for (int j = 0; j < HWS; j++)//第几行  
			{
				yy = y + j - 1;
				for (int i = 0; i < HWS; i++)//第几列  
				{
					xx = x + i - 1;
					red += H1[j][i] * (float)(m_pImage[(xx + yy*m_nWidth) * 3 + yy * num]);
					green += H1[j][i] * (float)(m_pImage[(xx + yy*m_nWidth) * 3 + 1 + yy * num]);
					blue += H1[j][i] * (float)(m_pImage[(xx + yy*m_nWidth) * 3 + 2 + yy * num]);
				}
			}

			ImageSize[LR] = (unsigned char)(red);
			ImageSize[LR + 1] = (unsigned char)(green);
			ImageSize[LR + 2] = (unsigned char)(blue);
		}
	}

	//计算梯度幅值和角度方向，我申请了一个和ImageSize一样大的空间存放角度，这里我采用sobel边缘检测算子
	//且在计算方向时，我尽量把角度归到四个方向，0，45，90，135.  PI/（PI/4）=（0，1，2，3），这样可以看成是
	//一个八领域，其实更精确的计算是算出双线性插值，为了代码简单，就直接比较像素了，不插值了, 
	//sobel算子
	unsigned char *ImageSizeSobel;
	ImageSizeSobel = new unsigned char[m_nImage];

	unsigned char *ImageSizeSobelDirection;
	ImageSizeSobelDirection = new unsigned char[m_nImage];

	int HX[3][3] = { { -1,-2,-1 },{ 0,0,0, },{ 1,2,1 } };
	int HY[3][3] = { { -1,0,1 },{ -2,0,2 },{ -1,0,1 } };
	int redX, greenX, blueX;
	int redY, greenY, blueY;
	int R, G, B;
	int a;//方向(0.1.2.3)
	for (y = HWS / 2; y < m_nHeight - HWS / 2; y++)
	{
		for (x = HWS / 2; x < m_nWidth - HWS / 2; x++)
		{

			redX = greenX = blueX = 0;
			redY = greenY = blueY = 0;
			LR = (y*m_nWidth + x) * 3 + y*num;

			for (int j = 0; j < HWS; j++)//第几行这两个循环是求权重后的均值  
			{
				yy = y + j - 1;
				for (int i = 0; i < HWS; i++)//第几列  
				{
					xx = x + i - 1;
					redX += HX[j][i] * (ImageSize[(xx + yy*m_nWidth) * 3 + yy*num]);
					greenX += HX[j][i] * (ImageSize[(xx + yy*m_nWidth) * 3 + 1 + yy*num]);
					blueX += HX[j][i] * (ImageSize[(xx + yy*m_nWidth) * 3 + 2 + yy*num]);

					redY += HY[j][i] * (ImageSize[(xx + yy*m_nWidth) * 3 + yy*num]);
					greenY += HY[j][i] * (ImageSize[(xx + yy*m_nWidth) * 3 + 1 + yy*num]);
					blueY += HY[j][i] * (ImageSize[(xx + yy*m_nWidth) * 3 + 2 + yy*num]);

				}
			}
			double PI = asin(0.5) * 6;
			R = (int)sqrt(redX*redX*1.0 + redY*redY*1.0);
			G = (int)sqrt(greenX*greenX*1.0 + greenY*greenY*1.0);
			B = (int)sqrt(blueX*blueX*1.0 + blueY*blueY*1.0);

			a = int((atan(1.0*redX / redY)+PI/2)/(PI/4));
			ImageSizeSobelDirection[LR] = unsigned char(a);

			if (R > 255) R = 255;
			ImageSizeSobel[LR] = unsigned char(R);
			if (G > 255)G = 255;
			ImageSizeSobel[LR + 1] = unsigned char(G);
			if (B > 255)B = 255;
			ImageSizeSobel[LR + 2] = unsigned char(B);
		}
	}

	//非最大值抑制，直接对ImageSizeSobel处理
	int LRO, LR1, LR2, LR3, LR4, LR5, LR6, LR7;//八个方向

	for (y = HWS / 2; y < m_nHeight - HWS / 2; y++)
	{
		for (x = HWS / 2; x < m_nWidth - HWS / 2; x++)
		{

			LR = (y*m_nWidth + x) * 3 + y*num;
			LRO = (y*m_nWidth + x + 1) * 3 + y*num;
			LR1 = ((y + 1)*m_nWidth + x + 1) * 3 + (y + 1)*num;
			LR2 = ((y + 1)*m_nWidth + x) * 3 + (y + 1)*num;
			LR3 = ((y + 1)*m_nWidth + x - 1) * 3 + (y + 1)*num;
			LR4 = ((y)*m_nWidth + x - 1) * 3 + (y)*num;
			LR5 = ((y - 1)*m_nWidth + x - 1) * 3 + (y - 1)*num;
			LR6 = ((y - 1)*m_nWidth + x) * 3 + (y - 1)*num;
			LR6 = ((y - 1)*m_nWidth + x + 1) * 3 + (y - 1)*num;

			switch (ImageSizeSobelDirection[LR])
			{
			case 0:
				if (ImageSizeSobel[LR] <= ImageSizeSobel[LRO] || ImageSizeSobel[LR] <= ImageSizeSobel[LR4])
				{
					ImageSizeSobel[LR] = 0;
					ImageSizeSobel[LR+1] = 0;
					ImageSizeSobel[LR + 2] = 0;
					break;
				}
			case 1:
				if (ImageSizeSobel[LR] <= ImageSizeSobel[LR1] || ImageSizeSobel[LR] <= ImageSizeSobel[LR5])
				{
					ImageSizeSobel[LR] = 0;
					ImageSizeSobel[LR + 1] = 0;
					ImageSizeSobel[LR + 2] = 0;
					break;
				}

			case 2:
				if (ImageSizeSobel[LR] <= ImageSizeSobel[LR2] || ImageSizeSobel[LR] <= ImageSizeSobel[LR6])
				{
					ImageSizeSobel[LR] = 0;
					ImageSizeSobel[LR + 1] = 0;
					ImageSizeSobel[LR + 2] = 0;
					break;
				}
			case 3:
				if (ImageSizeSobel[LR] <= ImageSizeSobel[LR3] || ImageSizeSobel[LR] <= ImageSizeSobel[LR7])
				{
					ImageSizeSobel[LR] = 0;
					ImageSizeSobel[LR + 1] = 0;
					ImageSizeSobel[LR + 2] = 0;
					break;
				}
			}
		}
	}

	//双阈值处理，一个高阈值，一个低阈值，通常高阈值是低阈值的1.5-2倍。高于高阈值的为255，低于低阈值的为0，这里我们设置阈值为100和30.
	int H0 = 100, L0 = 30;
	for (y = HWS / 2; y < m_nHeight - HWS / 2; y++)
	{
		for (x = HWS / 2; x < m_nWidth - HWS / 2; x++)
		{

			LR = (y*m_nWidth + x) * 3 + y*num;
			if (ImageSizeSobel[LR] > H0)
			{
				ImageSizeSobel[LR] = 255;
				ImageSizeSobel[LR + 1] = 255;
				ImageSizeSobel[LR + 2] = 255;
			}
			if (ImageSizeSobel[LR] < L0)
			{
				ImageSizeSobel[LR] = 0;
				ImageSizeSobel[LR + 1] = 0;
				ImageSizeSobel[LR + 2] = 0;
			}
		}
	}

	//链接处理，灰度在低阈值和高阈值之间的，考察改点临近的灰度值是否有255的，如果没有，赋值0，如果右，赋值255

	for (x = HWS / 2; x < m_nWidth - HWS / 2; x++)
	{
		for (y = HWS / 2; y < m_nHeight - HWS / 2; y++)
		{
			LR = (x + y*m_nWidth) * 3 + y*num;
			if (ImageSizeSobel[LR] >= L0 && ImageSizeSobel[LR] <= H0)//判断像素是不是在阈值区间
			{
				int temp = 0;
				for (int j = 0; j < HWS; j++)//第几行  
				{
					yy = y + j - 1;
					for (int i = 0; i < HWS; i++)//第几列  
					{
						xx = x + i - 1;
						if (ImageSizeSobel[(xx + yy*m_nWidth) * 3 + yy * num] == 255)

						{
							temp = 255;
							break;
						}

					}
					if (temp == 255) break;
				}

				ImageSizeSobel[LR] = (unsigned char)(temp);
				ImageSizeSobel[LR + 1] = (unsigned char)(temp);
				ImageSizeSobel[LR + 2] = (unsigned char)(temp);
			}
		}
	}


	fwrite(ImageSizeSobel, m_nImage, 1, fpw);
	fclose(fpo);
	fclose(fpw);
	numPicture = 2;
	level = 400;
	Invalidate();
}

滤波器选择以及方向选择比较随意，所以结果不是很准，就大体了解一下算法的内容，结果如下





hjxu2016
关注
  • 2
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图像分割 - Canny边缘检测
Henry的博客
11-08 1072
Canny 边缘检测基于以下三个目标：低错误率。所有边缘都应该被找到，不应该有虚假响应边缘点应该更好的被定位。检测到的边缘和真实边缘之间的距离应该最小单个边缘点响应。对于真实的边缘点，检测子应该只返回一个点，Canny边缘检测算法的步骤：Canny 是基于一阶微分的首先用高斯滤波平滑图像。计算梯度幅值图像和方向角度图像对梯度图像应用非极大值抑制使用双阈值处理和连通性分析来检测连接边缘首先，检测边缘前要平滑图像减少噪声的影响。
canny算法对图像分割，很好的文献
02-27
应用canny算法进行图像分割，里面具有详细的设计流程及部分代码实现是对canny算法很好的应用，是参考的好资料，大家不要错过哦。
python数字图像处理基础（五）——Canny边缘检测、图像金字塔、图像分割
最新发布
SavEMyselF1的博客
01-17 1407
该函数还可返回一个可选的hiararchy结果，这是一个ndarray，其中的元素个数和轮廓个数相同，每个轮廓contours[i]对应4个hierarchy元素hierarchy[i] [0] ~hierarchy[i] [3]，分别表示后一个轮廓、前一个轮廓、父轮廓、内嵌轮廓的索引编号，如果没有对应项，则该值为负数。基于聚类的算法是基于事物之间的相似性作为类划分的标准，即根据样本集的内部结构将其划分为若干子类，以使相同类型的类尽可能相似、不同的类型的类尽可能不相似。3）图像中的对象区域用部分像素标记。
图像分割 2 边缘检测算子canny算法原理。
yuyangyg的博客
03-01 2277
canny边缘检测，prewitt算子 sobel算子 高斯拉普拉斯算子
基于图片分割的Canny边缘检测算法优化方案（可重构计算大作业）
Weng Shihao's blog
01-21 1262
基于图片分割的Canny边缘检测算法优化方案 摘要
算法应用三：【图像分割】+【边缘检测】canny边缘检测--冈萨雷斯--《数字图像处理》
发现问题，解决问题。
12-11 6685
  canny主要工作：推导了最优边缘检测算子。       图像的边缘检测是：图像最基本特征，边缘点指的是图像中周围像素灰度有阶跃变化或屋顶变化的那些像素点，即：灰度值导数极大的地方。       边缘检测的目的是：标识数字图像中亮度变化的明显的点。之前介绍过增强边缘的图像锐化的方法，本节文章主要介绍一种专门用于边缘检测的canny算子。 PPT下载：https://download....
opencv基础44- Canny边缘检测详解-cv.Canny()
小海聊智造
08-07 6306
Canny边缘检测是一种经典的边缘检测算法，由John F.Canny在1986年提出。它被广泛应用于计算机视觉和图像处理领域，是一种多阶段的边缘检测算法，能够有效地检测图像中的边缘并抑制噪声。Canny边缘检测的主要步骤如下：噪声抑制：首先，通过使用高斯滤波器对图像进行平滑处理，以去除图像中的噪声。高斯滤波器可以有效地平滑图像，同时保持边缘的细节。计算梯度幅值和方向：使用Sobel算子计算图像中每个像素点的水平和垂直方向的梯度值。然后，根据梯度值计算每个像素点的梯度幅值和方向。
计算机视觉 || Canny算子实现边缘分割并进一步处理
perry0528的博客
10-19 2372
Ex2：用 CImg 重写、封装给定的 Canny 代码，并测试 附件有三个Canny相关的Code以及测试数据若干(测试数据自己转化成BMP图 像)； 同学按照各自学号最末尾的数字除 3 取余数，余数为 0 的改写 Code0，余数为 1 的改写 Code1，余数为 2 的改写 Code2； 封装要求：(1)所有的图像读写、数据处理只能用 CImg 库(整个工程文件不允许 使用 Opencv ...
基于边缘检测的图像分割算法！
小白学视觉
05-10 904
点击上方“小白学视觉”，选择加"星标"或“置顶” 重磅干货，第一时间送达Author：louwillMachine Learning Lab从本文开始，笔者计划花一些时间对传统的图像分割算法进行一个系统的梳理，叙述方式仍然是以原理阐述和代码实现为主。谈到图像分割算法，现在基本上言必称深度学习。这也无可厚非，毕竟大环境和研究趋势如此。但回过头来，我们有必要对传统的图像处理算法有一个基本的了解。本文的...
基于边缘的图像分割
百年孤独百年的博客
05-15 2894
基于边缘的图像分割是数字图像处理中常用的一种方法，它通过检测图像中的边缘信息来实现图像的分割。边缘通常代表着图像中不同区域之间的边界或目标的轮廓，因此基于边缘的图像分割方法能够较好地提取出图像中不同对象的边界信息。本文将介绍基于边缘的图像分割的基本原理、常用的算法和实现步骤。
c语言图像canny边缘,数字图像处理__Canny边缘检测.doc
weixin_42515822的博客
05-23 181
数字图像处理__Canny边缘检测摘 要边缘检测是数字图像处理中的重要内容，边缘是图像最基本的特性。在图像边缘检测中，微分算子可以提取出图像的细节信息，景物边缘是细节信息中最具有描述景物特征的部分,也是图像分析中的一个不可或缺的部分。本文详细地分析了目前常用的几种算法，即：Roberts交叉微分算子、Sobel微分算子、Priwitt微分算子和Laplacian微分算子以及Canny算子，用C语...
《图像分割--canny算子》超详细PPT，适合讲义！
12-13
https://blog.csdn.net/weixin_42346564/article/details/84950981 步骤1：用高斯滤波器平滑处理原图像； 步骤2：用一阶偏导的有限差分进行计算梯度的幅值和方向； 步骤3：对梯度幅值进行非极大值抑制； 步骤4：用双阈值算法检测和连接边缘。
图像的区域生长，Canny算子，并行区域分割，串行边界分割，图像分割等算法
06-28
图像的区域生长，Canny算子，并行区域分割，串行边界分割，图像分割等
数字图像处理大作业( 图像分割、人脸检测、边缘检测 ）
05-25
数字图像处理大作业 内容 Canny 边缘检测 OTSU 图像分割方法 OpenCV + Python 实现人脸检测
数字图像处理——图像的分割实验 matlab
05-10
我数字图像处理的作业，内有实验报告、m文件、图像文件 包括的实验为： 1.Roberts算子、Sobel算子、Prewitt算子、拉普拉斯算子、LoG算子和Canny算子等进行边缘检测 2.手动阈值分割 3.迭代阈值和OTSU算法对图像进行二...
基于QT（C++）实现数字图像处理-Canny边缘检测【100010172】
12-16
已经对图像分割的相关理论知识已经有了全面的了解，知道了许多图像分割的算法及算子，了解到不同的算子算法有着不同的优缺点，为了更好更直观地对图像分割进行深入理解，达到理论联系实际的目的，现实现Canny算子。
基于matlab开发的车牌检测与字符分割项目完整源码+项目说明+课设报告(数字图像处理课设).zip
01-14
基于matlab开发的车牌检测与字符分割项目完整源码+项目说明+课设报告(数字图像处理课设).zip 【项目实现功能】 车牌定位：输入车辆图片后，输出mask图以及定位到的车牌图片； 字符分割：根据获得的车牌图片进行字符...
位、字节、字之间的关系
热门推荐
hjxu2016的博客
05-19 4万+
位："位(bit)"是电子计算机中最小的数据单位。每一位的状态只能是0或1。　　字节：8个二进制位构成1个"字节(Byte)"，它是存储空间的基本计量单位。1个字节可以储存1个英文字母或者半个汉字，换句话说，1个汉字占据2个字节的存储空间。　　字："字"由若干个字节构成，字的位数叫做字长，不同档次的机器有不同的字长。例如一台8位机，它的1个字就等于1个字节，字长为8位。如果是一台16位机，那么，它...
数字图像处理（四）图像增强之普通平滑、高斯平滑、laplacian、sobelprewitt锐化
hjxu2016的博客
06-05 2万+
本文参考https://blog.csdn.net/eastmount/article/details/46378783做的一些笔记，解决扫描行填充不为4的整数字节，出现白色斜线的问题，修补了一些bug，注意，文字算法部分为直接复制粘贴的，代码部分有所该进。  图像平滑是一种区域增强的算法，平滑算法有邻域平均法、中指滤波、边界保持类滤波等。在图像产生、传输和复制过程中，常常会因为多方面原因而被噪声...
【数字图像处理】边缘检测与图像分割
05-23
数字图像处理中的边缘检测和图像分割是两个非常重要的技术。 边缘检测的目的是找到图像中的物体边缘或轮廓，它是许多图像处理、计算机视觉和图形学应用的基础。在边缘检测中，我们通常会使用一些算子（如Sobel算子、Canny算子等）来寻找像素值变化比较剧烈的地方，从而找到物体的轮廓。 图像分割则是将一个图像划分为若干个不同的区域，每个区域具有类似的特征或属性。图像分割可以用于目标检测、图像识别、医学图像分析等应用中。在图像分割中，我们通常会使用一些聚类算法（如K-means算法、Mean-shift算法等）或分水岭算法来将图像中的像素进行分组。 边缘检测和图像分割通常是互相配合使用的，比如在图像分割中，我们可以先进行边缘检测，然后将图像分割成若干个区域。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值