图像的一阶微分算子

最新推荐文章于 2024-01-03 09:05:38 发布
最新推荐文章于 2024-01-03 09:05:38 发布
阅读量1.8k 收藏 5
点赞数
文章标签： matlab 人工智能

概述

二元函数f(x,y)的一阶微分为fx=ʚf/ʚx或fx=ʚf/ʚy，图像的坐标表示如下：

假设一张图片的各像素为：

3 33333

355553

3 5 9 9 5 3

3 5 9 9 5 3

355553

3 33333

在往下进行介绍之前，先给出两个读图片和写图片的函数

算法源代码1（读图片和写图片）

/**
	 * 读取图片
	 * @param srcPath 图片的存储位置
	 * @return 返回图片的BufferedImage对象
	 */
	public static BufferedImage readImg(String srcPath) {
		BufferedImage img = null;
		try {
			img = ImageIO.read(new File(srcPath));			
		} catch (IOException e) {
			e.printStackTrace();
		}
		return img;
	}
	/**
	 * 将图片写入磁盘
	 * @param img 图像的BufferedImage对象
	 * @param formatName 存储的文件格式
	 * @param distPath 图像要保存的存储位置
	 */
	public static void writeImg(BufferedImage img, String formatName, String distPath) {
		OutputStream out = null;
		try {
			//int imgType = img.getType();			
			//System.out.println("w:" + img.getWidth() + "  h:" + img.getHeight());
			out = new FileOutputStream(distPath);			
			ImageIO.write(img, formatName, out);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if(out != null) {
					out.close();
				}				
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}


水平微分算子

水平方向的微分算子是要获得图像在水平方向上的变化率。

定义

G=f(x-1,y-1)+2f(x,y-1)+f(x+1,y-1)–f(x-1,y+1)–2f(x,y+1)–f(x+1,y+1)

权系数矩阵模板


水平方向的微分算子处理结果：

0 0 0 0 0 0

0 -10 -20 -20 -10 0

0 -4 -12 -12 -4 0

0 4 12 12 4 0

0 10 20 20 10 0

0 0 0 0 0 0

为了能够正常显示处理后结果，将每个像素加上最小值的绝对值（如上面的|-20|），结果如下：

20 20 20 20 20 20

20 10 0 0 10 20

20 16 8 8 16 20

20 24 32 32 24 20

20 30 40 40 30 20

20 20 20 20 20 20

算法源代码2

/**
	 * 水平微分算子
	* @param srcPath 图片的存储位置
	 * @param distPath 图像要保存的存储位置
	 * @param formatName 图像要保存的存储位置
	 */
	public static void firstMomentX(String srcPath, String distPath, String formatName) {
		BufferedImage img = readImg(srcPath);		
		int w = img.getWidth();
		int h = img.getHeight();
		int pix[] = new int[w*h];
		        pix= img.getRGB(0, 0, w, h, pix, 0, w);
		pix = firstMomentX(pix, w, h);
		img.setRGB(0, 0, w, h, pix, 0, w);
		writeImg(img, formatName, distPath);
	}
	/**
	 * 水平微分算子
	 * @param pix 像素矩阵数组
	 * @param w 矩阵的宽
	 * @param h 矩阵的高
	 * @return 处理后的数组
	 */
	public static int[] firstMomentX(int[] pix, int w, int h) {
		int[] newpix = new int[w*h];
		ColorModel cm = ColorModel.getRGBdefault();
		int r, g, b;
		for(int y=0; y<h; y++) {
			for(int x=0; x<w; x++) {
				if(x!=0 && x!=w-1 && y!=0 && y!=h-1){
					//G=f(x-1,y-1) + 2f(x,y-1) + f(x+1,y-1) – f(x-1,y+1) – 2f(x,y+1) – f(x+1,y+1)
					r = cm.getRed(pix[x-1+(y-1)*w]) + 2* cm.getRed(pix[x+(y-1)*w]) +  cm.getRed(pix[x+1+(y-1)*w]) 
					              -  cm.getRed(pix[x-1+(y+1)*w]) - 2* cm.getRed(pix[x+(y+1)*w]) -  cm.getRed(pix[x+1+(y+1)*w]);
					 newpix[x+y*w] = 255<<24 | r<<16 | r<<8 | r;
				}					
			}
		}
		int temp = findMinInt(newpix);
		for(int i=0; i<newpix.length; i++) {
			newpix[i] = newpix[i] + temp;
		}
		return newpix;
	}


垂直微分算子

水平方向的微分算子是要获得图像在水平方向上的变化率。

定义

G=f(x-1,y-1)+2f(x-1,y)+f(x-1,y+1)-f(x+1,y-1)-2f(x+1,y)-f(x+1,y+1)

权系数矩阵模板


垂直方向的微分算子处理结果：

20 20 20 20 20 20

20 10 16 24 30 20

20 0 8 32 40 20

20 0 8 32 40 20

20 10 16 24 30 20

20 20 20 20 20 20

算法源代码3

/**
	 * 垂直微分算子
	* @param srcPath 图片的存储位置
	 * @param distPath 图像要保存的存储位置
	 * @param formatName 图像要保存的存储位置
	 */
	public static void firstMomentY(String srcPath, String distPath, String formatName) {
		BufferedImage img = readImg(srcPath);		
		int w = img.getWidth();
		int h = img.getHeight();
		int pix[] = new int[w*h];
		        pix= img.getRGB(0, 0, w, h, pix, 0, w);
		pix = firstMomentY(pix, w, h);
		img.setRGB(0, 0, w, h, pix, 0, w);
		writeImg(img, formatName, distPath);
	}
	/**
	 * 垂直微分算子
	* @param pix 像素矩阵数组
	 * @param w 矩阵的宽
	 * @param h 矩阵的高
	 * @return 处理后的数组
	 */
	public static int[] firstMomentY(int[] pix, int w, int h) {
		int[] newpix = new int[w*h];
		ColorModel cm = ColorModel.getRGBdefault();
		int r;
		for(int y=0; y<h; y++) {
			for(int x=0; x<w; x++) {
				if(x!=0 && x!=w-1 && y!=0 && y!=h-1) {
					//G=f(x-1,y-1) + 2f(x-1,y) + f(x-1,y+1) - f(x+1,y-1) - 2f(x+1,y) - f(x+1, y+1)
					/*newpix[x+y*w] = pix[x-1+(y-1)*w] + 2*pix[x-1+(y)*w] + pix[x-1+(y+1)*w]
					              - pix[x+1+(y-1)*w] - 2*pix[x+1+(y)*w] - pix[x+1+( y+1)*w];*/
					r = cm.getRed(pix[x-1+(y-1)*w]) + 2*cm.getRed(pix[x-1+(y)*w]) + cm.getRed(pix[x-1+(y+1)*w])
					                - cm.getRed(pix[x+1+(y-1)*w]) - 2*cm.getRed(pix[x+1+(y)*w]) - cm.getRed(pix[x+1+( y+1)*w]);
					newpix[x+y*w] = 255<<24 | r<<16 | r<<8 | r;
				}
			}
		}
		int temp = findMinInt(newpix);
		for(int i=0; i<newpix.length; i++) {
			newpix[i] = newpix[i] + temp;
		}
		return newpix;
	}


实验效果：

原图：


水平方向的微分算子的效果


垂直方向的微分算子的效果

Roberts交叉微分算子

水平微分算子和垂直微分算子只求出了特定方向上的细节信息，但是对于大多数图像来说，求出细节轮廓是一全非常重要的信息，而往往遇到的大部分景物的细节是不规则的，所以在二维图像的两个方向上来考虑锐化微分是很有必要的。Roberts叉微分算子的作用模板如下：


定义：

G=|f(x+1,y+1)-f(x,y)|+|f(x,y+1)-f(x+1,y)|

权系数矩阵模板


F1’=D1(f(x,y)),F2’=D2(f(x,y))

G=|F1’|+|F2’|

算法源代码4

/**
	 * Roberts交叉微分算子
	 * @param srcPath 图片的存储位置
	 * @param distPath 图像要保存的存储位置
	 * @param formatName 图像要保存的存储位置
	 */
	public static void roberts(String srcPath, String distPath, String formatName) {
		BufferedImage img = readImg(srcPath);		
		int w = img.getWidth();
		int h = img.getHeight();
		int pix[] = new int[w*h];
		        pix= img.getRGB(0, 0, w, h, pix, 0, w);
		pix = roberts(pix, w, h);
		img.setRGB(0, 0, w, h, pix, 0, w);
		writeImg(img, formatName, distPath);
	}
	/**
	 * Roberts交叉微分算子
	 * @param pix 像素矩阵数组
	 * @param w 矩阵的宽
	 * @param h 矩阵的高
	 * @return 处理后的像素矩阵
	 */
	public static int[] roberts(int pix[], int w, int h) {
		ColorModel cm = ColorModel.getRGBdefault();
		int r;
		int[] newpix = new int[w*h];
		for(int y=0; y<h; y++) {
			for(int x=0; x<w; x++) {
				if(x!=w-1 && y!=h-1){
					//G=|f(x+1,y+1) - f(x,y)| + |f(x,y+1)-f(x+1,y)|
					r=Math.abs(cm.getRed(pix[x+1+(y+1)*w]) - cm.getRed(pix[x+y*w])) +
					  Math.abs(cm.getRed(pix[x+(y+1)*w]) - cm.getRed(pix[x+1+y*w]));
					newpix[x+y*w] = 255<<24 | r<<16 | r <<8 | r;
				} else {
					if(x == w-1) {
						newpix[x+y*w] = pix[x-1+y*w];
					}
					if(y == h-1) {
						newpix[x+y*w] = pix[x+(y-1)*w];
					}
				}
			}
		}		
		return newpix;
	}


效果：


Sobel微分算子

前面介绍的Roberts微分算子可以获得景物的细节轮廓，且模板小，计算量小；但由于模板的尺寸是偶数，待处理的像素不能放在模板中心。Sobel微分算子是一种奇数大小（3*3）模板下的全方向微分算子。

定义:

D1=f(x-1,y-1)+2f(x,y-1)+f(x+1,y-1)–f(x-1,y+1)–2f(x,y+1)–f(x+1,y+1)

D2=f(x-1,y-1)+2f(x-1,y)+f(x-1,y+1)–f(x+1,y-1)–2f(x+1,y)–f(x+1,y+1)

G=sqrt(D1^2+D2^2)

算法源代码5

/**
	 * Sobel微分算子
	 * @param srcPath 图片的存储位置
	 * @param distPath 图像要保存的存储位置
	 * @param formatName 图像要保存的存储位置
	 */
	public static void sobel(String srcPath, String distPath, String formatName) {
		BufferedImage img = readImg(srcPath);		
		int w = img.getWidth();
		int h = img.getHeight();
		int pix[] = new int[w*h];
		        pix= img.getRGB(0, 0, w, h, pix, 0, w);
		pix = sobel(pix, w, h);
		img.setRGB(0, 0, w, h, pix, 0, w);
		writeImg(img, formatName, distPath);
	}
	/**
	 * Sobel微分算子
	 * @param pix 像素矩阵数组
	 * @param w 矩阵的宽
	 * @param h 矩阵的高
	 * @return 处理后的像素矩阵
	 */
	public static int[] sobel(int pix[], int w, int h) {
		ColorModel cm = ColorModel.getRGBdefault();
		int g1, g2, r;
		int[] newpix = new int[w*h];
		for(int y=0; y<h; y++) {
			for(int x=0; x<w; x++) {
				if(x!=0 && x!=w-1 && y!=0 && y!=h-1){
					//G
					g1 = cm.getRed(pix[x-1+(y-1)*w]) + 2* cm.getRed(pix[x+(y-1)*w]) +  cm.getRed(pix[x+1+(y-1)*w]) 
		                 - cm.getRed(pix[x-1+(y+1)*w]) - 2* cm.getRed(pix[x+(y+1)*w]) -  cm.getRed(pix[x+1+(y+1)*w]);
					g2 = cm.getRed(pix[x-1+(y-1)*w]) + 2*cm.getRed(pix[x-1+(y)*w]) + cm.getRed(pix[x-1+(y+1)*w])
	                     - cm.getRed(pix[x+1+(y-1)*w]) - 2*cm.getRed(pix[x+1+(y)*w]) - cm.getRed(pix[x+1+( y+1)*w]);
					r=(int) Math.round(Math.sqrt(g1*g1 + g2*g2));
					newpix[x+y*w] = 255<<24 | r<<16 | r <<8 | r;
				} else {
					if(x == w-1) {
						newpix[x+y*w] = pix[x-1+y*w];
					}
					if(y == h-1) {
						newpix[x+y*w] = pix[x+(y-1)*w];
					}
				}
			}
		}		
		return newpix;
	}


效果：

Priwitt微分算子

Priwitt微分算子与Sobel微分算子类似，是一个奇数大小（3*3）的模板中定义其微分算子。只是模板系数不同。

D1=f(x-1,y-1)+2f(x,y-1)+f(x+1,y-1)–f(x-1,y+1)–2f(x,y+1)–f(x+1,y+1)

D2=f(x-1,y-1)+2f(x-1,y)+f(x-1,y+1)–f(x+1,y-1)–2f(x+1,y)–f(x+1,y+1)

G=sqrt(D1^2+D2^2)

算法源代码6

/**
	 * priwitt微分算子
	 * @param srcPath 图片的存储位置
	 * @param distPath 图像要保存的存储位置
	 * @param formatName 图像要保存的存储位置
	 */
	public static void priwitt(String srcPath, String distPath, String formatName) {
		BufferedImage img = readImg(srcPath);		
		int w = img.getWidth();
		int h = img.getHeight();
		int pix[] = new int[w*h];
		        pix= img.getRGB(0, 0, w, h, pix, 0, w);
		pix = priwitt(pix, w, h);
		img.setRGB(0, 0, w, h, pix, 0, w);
		writeImg(img, formatName, distPath);
	}
	/**
	 * priwitt微分算子
	 * @param pix 像素矩阵数组
	 * @param w 矩阵的宽
	 * @param h 矩阵的高
	 * @return 处理后的像素矩阵
	 */
	public static int[] priwitt(int pix[], int w, int h) {
		ColorModel cm = ColorModel.getRGBdefault();
		int g1, g2, r;
		int[] newpix = new int[w*h];
		for(int y=0; y<h; y++) {
			for(int x=0; x<w; x++) {
				if(x!=0 && x!=w-1 && y!=0 && y!=h-1){
					//G
					g1 = cm.getRed(pix[x-1+(y-1)*w]) + cm.getRed(pix[x+(y-1)*w]) +  cm.getRed(pix[x+1+(y-1)*w]) 
		                 - cm.getRed(pix[x-1+(y+1)*w]) - cm.getRed(pix[x+(y+1)*w]) -  cm.getRed(pix[x+1+(y+1)*w]);
					g2 = cm.getRed(pix[x-1+(y-1)*w]) + cm.getRed(pix[x-1+(y)*w]) + cm.getRed(pix[x-1+(y+1)*w])
	                     - cm.getRed(pix[x+1+(y-1)*w]) - cm.getRed(pix[x+1+(y)*w]) - cm.getRed(pix[x+1+( y+1)*w]);
					r=(int) Math.round(Math.sqrt(g1*g1 + g2*g2));
					newpix[x+y*w] = 255<<24 | r<<16 | r <<8 | r;
				} else {
					if(x == w-1) {
						newpix[x+y*w] = pix[x-1+y*w];
					}
					if(y == h-1) {
						newpix[x+y*w] = pix[x+(y-1)*w];
					}
				}
			}
		}		
		return newpix;
	}

效果：


iteye_15075
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数字图像处理：（3）一阶微分算子在图像处理中的应用
m0_37957160的博客
07-30 4174
1、数学基础 函数一阶导数对应的微分称为一阶微分; 一阶微分的微分称为二阶微分; 二阶微分及以上的微分称为高阶微分； 首先，图像是离散的数据，若求其导数就要用差分的方法，常用的差分方法是前向差分（forward differencing）与中心差分（central differencing）。一阶导本质上求的是斜率，二阶导求的是拐点。 2、图像微分知识： 一阶导数： 图像梯度： 二阶导数： 3、滤波器 平滑滤波器（低通滤波器），是用来平滑图像和抑制噪声的；而锐化空间滤...
图像边缘检测——一阶微分算子 Roberts、Sobel、Prewitt、Kirsch、Robinson（Matlab实现）
热门推荐
ChuanjieZhu
10-25 5万+
图像边缘一般指图像的灰度变化率最大的位置。成因主要如下： 1.图像灰度在表面法向变化不连续
图像处理之一阶微分应用 .
henreash的专栏
10-25 1854
转自：http://blog.csdn.net/jia20003/article/details/7562092 图像处理之一阶微分应用 一：数学背景 首先看一下一维的微分公式Δf = f(x+1) – f(x), 对于一幅二维的数字图像f(x,y)而言，需要完 成XY两个方向上的微分，所以有如下的公式： 分别对X,Y两个方向上求出它们的偏微分，最终得到梯度Delta F. 对于离
图像处理中的微分算子
q15516221118的博客
02-01 3350
微分算子在图像处理中的作用主要是用在图像的边缘检测，而图像边缘检测必须满足两个条件：一能有效的抑制噪声，二能必须尽量精确定位边缘位置。现在常用的微分算子主要有：Sobel算子，Robert算子，Prewitt算子，拉氏算子，Canny算子，下面通过这两个必须满足的条件对这几种算子的性能进行分析。
一阶微分图像锐化（梯度幅值）.pdf
03-20
该文档说明了一阶微分图像锐化的原理。通过阅读冈萨雷斯的数字图像处理第三版中的相关章节，总结了一阶微分图像锐化的原理。
作业5程永鑫21934169_数字图像处理matlab_一阶微分锐化_
09-29
例如，对于一阶微分锐化，可以使用`fspecial`函数创建拉普拉斯算子模板，然后应用到图像上。对于高斯平滑，同样可以使用`fspecial`创建高斯核，再进行滤波。中值滤波则可使用`medfilt2`函数直接实现。 非锐化掩蔽...
CV笔记6：图像边缘检测之一阶微分算子、二阶微分算子、Canny边缘检测(基于python-opencv实现)_卷积之图像边缘检测 一阶微分-CSDN博客.webarchive
最新发布
05-08
CV笔记6：图像边缘检测之一阶微分算子、二阶微分算子、Canny边缘检测(基于python-opencv实现)_卷积之图像边缘检测 一阶微分-CSDN博客.webarchive
数字图像处理｜Matlab-图像分割与边缘检测实验-使用一阶和二阶检测算子（导数）进行图像的边缘检测
12-15
问题1：编写程序实现一阶Sobel算子，进行图像的边缘提取； 问题2：编写程序实现一阶Prewitt算子，进行图像的边缘提取； 问题3：编写程序实现一阶Roberts算子，进行图像的边缘提取； 问题4：编写程序实现二阶...
基于MATLAB的数字图像处理-图像进行灰度化.zip
06-12
本项目对低照度图像进⾏灰度化，计算并显⽰以上低照度图像的灰度直⽅图和离散傅⾥叶变换频谱幅度图；对低照度图像分别进⾏直⽅图均衡化和同态滤波操作，并对两种算法的最终结果进⾏对⽐。 详细介绍参考：...
图像处理中的各种微分算子
weixin_30349597的博客
02-17 670
微分算子在图像处理中扮演重要的角色，其算法实现简单，而且边缘检测的效果又较好，因此这些基本的微分算子是学习图像处理过程中的必备方法，下面着重讨论几种常见的微分算子。 1.Sobel 其主要用于边缘检测，在技术上它是以离散型的差分算子，用来运算图像亮度函数的梯度的近似值，缺点是Sobel算子并没有将图像的主题与背景严格地区分开来，换言之就是Sobel算子并没...
数字图像的一阶微分和二阶微分
yb1254844976的博客
09-23 1万+
数字图像的微分也就是数字函数的微分有很多不用的定义，但是任何定义都必须保证一下几点： 一阶微分：（1）在恒定灰度区域的微分值为零；                   （2）在灰度台阶或斜坡处微分值非零；                   （3）沿着斜坡的微分值非零； 二阶微分：（1）在恒定灰度区域的微分值为零；                   （2）在灰度台阶或斜坡起点处微分值非...
图像处理－线性滤波－图像微分（1、2阶导数和拉普拉斯算子）
yyytucj的博客
01-03 163
更复杂些的滤波算子一般是先利用高斯滤波来平滑，然后计算其1阶和2阶微分。由于它们滤除高频和低频，因此称为带通滤波器（band-pass filters）。在介绍具体的带通滤波器前，先介绍必备的图像微分知识。
【数字图像处理】2021期末复习考试重点大纲
Rose J 的博客
06-30 1万+
本文目录数字图像处理期末复习1.填空（每空2分，共20分）1.均值滤波计算2.中值滤波计算3.水平方向一阶锐化计算4.位图文件存储所需要的数据量计算2.问答（每题10分，共10分）1、什么是采样，简述采样间隔与图像的关系。2、什么是量化，简述量化等级与图像关系。3、简述中值滤波器对不同类型的噪声抑制效果。4、对于一张灰度图像，其梯度是如何定义的？图像梯度的物理意义是什么？3.计算（每题15分，共60分）1、已知灰度图，对该图像进行线性对比度展宽，得到新图像2、直方图均衡化算法的计算3、基于像素采样的图像缩小
边缘检测一 一阶微分算子
zwq940103的博客
04-11 4129
目录 一、综述 二、Roberts算子 三、Prewitt算子 四、Sobel算子 一、综述 一阶微分算子一般借助空域微分算子通过卷集完成，但实际上数字图像中求导是利用差分近似微分来进行的。 梯度对应一阶导数，梯度算子是一阶导数算子。对一个连续函数f(x,y)，它在位置(x,y)梯度可表示为一个矢量： ​ 对于数字图像，导数可以用差分来近...
CV笔记6：图像边缘检测之一阶微分算子、二阶微分算子、Canny边缘检测(基于python-opencv实现)
my_kun的博客
05-07 1万+
目录 一、边缘简介 1.1 何为边缘 1.2 产生原因 二、边缘检测方法 2.1 一阶微分算子计算原理 2.2 噪声对一阶微分算子的影响及解决方案 2.3 常见的一阶微分算子 2.3.1 Roberts算子 2.3.2 Prewitt算子 2.3.3 Sobel算子 2.4 二阶微分算子计算原理 2.5 常见的二阶微分算子 2.5.1 拉普拉斯(Laplace)算子 2...
图像处理-微分算子
weixin_51487248的博客
05-28 545
在图像处理中，微分算子是一种常用的边缘检测方法，用于提取图像中的边缘信息。微分算子通过计算图像中像素值的梯度或导数来确定边缘的位置和方向。按照Laplacian算子的计算规则，我们将模板应用于图像中的每个像素点，计算出对应的二阶导数值。下面是一个示例，展示如何使用二阶微分算子（Laplacian算子）计算图像的二阶导数。在二阶微分中的前后符号有变 化的过0点处，为图像轮廓。计算完毕后，得到的结果即为图像的二阶导数值。灰度变化率无改变的地方，二 阶微分为0。灰度无变化的平坦段，一阶微分为0；
图像边缘检测——一阶微分算子 Roberts、Sobel、Prewitt、Kirsch、Robinson
sinat_31608641的博客
11-14 6828
图像为什么会有边缘？ 图像边缘一般指图像的灰度变化率最大的位置。成因主要如下： 1.图像灰度在表面方向变化不连续； 2.图像中物体在空间上的深度不一致； 3.在光滑的表面上颜色不一致； 4.图像中物体的光影 所以边缘检测指的是从图像中检测边缘点和边缘段，并且描述边缘方向的过程。图像可以看成二元函数f（x,y），（x，y）是pixel的位置，f(x,y)是该处的灰度值，这样图像就可以想象...
一阶微分算子锐化图像_【动手学计算机视觉】第二讲：图像预处理之图像分割...
weixin_39533795的博客
11-20 532
感兴趣的记得关注公众号"平凡而诗意"，会定期分享科技、AI相关知识，此外，回复关键字可以获取相应"福利"。图像分割是一种把图像分成若干个独立子区域的技术和过程。在图像的研究和应用中，很多时候我们关注的仅是图像中的目标或前景(其他部分称为背景)，它们对应图像中特定的、具有独特性质的区域。为了分割目标，需要将这些区域分离提取出来，在此基础上才有可能进一步利用，如进行特征提取、目标识别。因此，图像分割是...
一阶微分算子锐化图像c++
05-30
一阶微分算子锐化图像可以使用Sobel算子或Prewitt算子来实现。 以Sobel算子为例，Sobel算子分为水平和垂直方向的两个卷积核，分别对图像进行卷积运算后再取它们的平方和再开方即可得到锐化后的图像。 具体实现步骤如下： 1. 定义Sobel算子的两个卷积核，分别表示水平和垂直方向的微分算子。 ```c++ int sobel_x[3][3] = { {-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1} }; int sobel_y[3][3] = { {-1, -2, -1}, {0, 0, 0}, {1, 2, 1} }; ``` 2. 对图像进行卷积运算。 ```c++ int width = img_width - 2; int height = img_height - 2; for (int x = 1; x < width; x++) { for (int y = 1; y < height; y++) { int gx = 0, gy = 0; for (int i = -1; i <= 1; i++) { for (int j = -1; j <= 1; j++) { int pixel = get_pixel_gray(img, img_width, x + i, y + j); gx += sobel_x[i + 1][j + 1] * pixel; gy += sobel_y[i + 1][j + 1] * pixel; } } int val = sqrt(gx * gx + gy * gy); set_pixel_gray(result, img_width, x, y, val); } } ``` 3. 对卷积运算后的结果进行阈值处理。 ```c++ for (int i = 0; i < img_width * img_height; i++) { if (result[i] < threshold) { result[i] = 0; } else { result[i] = 255; } } ``` 完整代码如下： ```c++ #include <iostream> #include <cmath> using namespace std; int get_pixel_gray(unsigned char *img, int width, int x, int y) { return img[y * width + x]; } void set_pixel_gray(unsigned char *img, int width, int x, int y, int val) { img[y * width + x] = val; } void sobel(unsigned char *img, unsigned char *result, int img_width, int img_height, int threshold) { int sobel_x[3][3] = { {-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1} }; int sobel_y[3][3] = { {-1, -2, -1}, {0, 0, 0}, {1, 2, 1} }; int width = img_width - 2; int height = img_height - 2; for (int x = 1; x < width; x++) { for (int y = 1; y < height; y++) { int gx = 0, gy = 0; for (int i = -1; i <= 1; i++) { for (int j = -1; j <= 1; j++) { int pixel = get_pixel_gray(img, img_width, x + i, y + j); gx += sobel_x[i + 1][j + 1] * pixel; gy += sobel_y[i + 1][j + 1] * pixel; } } int val = sqrt(gx * gx + gy * gy); set_pixel_gray(result, img_width, x, y, val); } } for (int i = 0; i < img_width * img_height; i++) { if (result[i] < threshold) { result[i] = 0; } else { result[i] = 255; } } } int main() { // 读入图像 FILE *f = fopen("lena.raw", "rb"); unsigned char img[512 * 512]; fread(img, 1, 512 * 512, f); fclose(f); // Sobel锐化 unsigned char result[512 * 512]; sobel(img, result, 512, 512, 128); // 保存结果 f = fopen("lena_sobel.raw", "wb"); fwrite(result, 1, 512 * 512, f); fclose(f); return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值