数字图像处理——图像的空间域增强OpenCV 实验二基于一阶或二阶微分的锐化滤波器

最新推荐文章于 2023-10-21 22:12:36 发布
最新推荐文章于 2023-10-21 22:12:36 发布
阅读量1.3k 收藏 16
点赞数 3
分类专栏： 图像处理 文章标签： opencv 计算机视觉 边缘检测
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44394801/article/details/116132496
版权

图象锐化

建议先查看图像平滑

 

锐化处理的主要目的是突出图像中的细节或者增强被模糊了的细节，这种模糊不是由于错误操作，就是特殊图像获取方法的固有影响。图像均值滤波器可以使图像变模糊，是因为均值处理与积分相类似，因此可以对其进行逆运算（如微分运算）就可以使图像变得清晰。
常常采用基于一阶或二阶微分的锐化滤波器实现图像的锐化处理。

一阶微分

一阶微分是通过梯度法来实现的。对于图像f(i,j)，它在点(i,j)处的梯度是一个矢量，定义为：
在这里插入图片描述

利用差分法近似上述公式，得到：
在这里插入图片描述

为了便于编程和提高运算，可进一步简化为：
在这里插入图片描述

利用差分运算时，图像的第一行和第一列的像素的梯度无法求得，一般用后一行或后一列的梯度值近似代替。微分运算可以增强图像高频分量（边缘等细节），但是仅仅微分处理后的图像非常暗，因此既要增强图像边缘，又要保持目标物体的内部灰度不变，常采用给边缘规定一个特定的灰度级的方法来完成梯度锐化处理。公式为：
在这里插入图片描述

La为一指定的灰度值，它将边界的灰度值统一化，这样可以使其边界更加清晰明显。该方法基本上不破坏图像的背景，又可找到边缘，并根据需要增强边缘。

基于二阶微分的锐化滤波器

基于二阶微分的锐化滤波器，即拉普拉斯增强算子。一个二元图像函数f(x, y)的拉普拉斯变换定义为：
在这里插入图片描述

由于拉普拉斯是一种微分算子，它的应用强调图像中灰度的突变及降低灰度慢变化的区域，这将产生一幅把图像中的浅灰色边线和突变点叠加到暗背景中的图像。将原始图像和拉普拉斯图像叠加在一起的简单方法可以保护拉普拉斯锐化处理的效果，同时又能复原背景信息。这种方法可表示为：
在这里插入图片描述
 

OpenCV实现

对去噪后的图像进行锐化，分别采用一阶微分和二阶微分，比较锐化效果。

在这里插入图片描述

一阶微分

罗伯特交叉算子

// 梯度锐化函数
//         -1   1
//  -1
//   1
Mat GradientSharpening(const Mat& src, Mat& dst) {
	if (!src.data) return src;
	for (int i = 0; i < src.rows; ++i)
		for (int j = 0; j < src.cols; ++j) {
			int a, b, c;
			if (i < src.rows - 1 && j < src.cols - 1) {
				
				//罗伯特交叉算子
				a = abs(src.at<Vec3b>(i + 1, j )[0] - src.at<Vec3b>(i, j)[0]) + abs(src.at<Vec3b>(i , j + 1)[0] - src.at<Vec3b>(i, j)[0]);
				b = abs(src.at<Vec3b>(i + 1, j )[1] - src.at<Vec3b>(i, j)[1]) + abs(src.at<Vec3b>(i , j + 1)[1] - src.at<Vec3b>(i, j)[1]);
				c = abs(src.at<Vec3b>(i + 1, j )[2] - src.at<Vec3b>(i, j)[2]) + abs(src.at<Vec3b>(i , j + 1)[2] - src.at<Vec3b>(i, j)[2]);

				//加上原来的颜色值，实现锐化增强
				a = a + src.at<Vec3b>(i, j)[0];
				b = b + src.at<Vec3b>(i, j)[1];
				c = c + src.at<Vec3b>(i, j)[2];
			}
			else {
				//无法处理的直接赋值原来的颜色值
				a = src.at<Vec3b>(i, j)[0];
				b = src.at<Vec3b>(i, j)[1];
				c = src.at<Vec3b>(i, j)[2];
			}
			//颜色值 超过255，为255
			if (a > 255 || b > 255 || b > 255) {
				
				dst.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i, j)[0];
				dst.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i, j)[1];
				dst.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i, j)[2];
			}
			else {
				dst.at<Vec3b>(i, j)[0] = a;
				dst.at<Vec3b>(i, j)[1] = b;
				dst.at<Vec3b>(i, j)[2] = c;
			}
		}
	return dst;
}

二阶微分

// 拉普拉斯锐化函数
// 0  -1  0
// -1  4  -1
// 0  -1  0
Mat LaplacianSharpening(const Mat& src, Mat& dst) {
	if (!src.data) return src;
	Mat img(src.size(), src.type());
	for (int i = 0; i < src.rows; ++i)
		for (int j = 0; j < src.cols; ++j) {
			int a, b, c;
			if (i > 1 && j > 1 && i < src.rows - 1  && j < src.cols - 1) {
				//5 是因为直接加上了原来的颜色值
				a = abs(4 * src.at<Vec3b>(i, j)[0] - src.at<Vec3b>(i - 1, j)[0] - src.at<Vec3b>(i + 1, j)[0] - src.at<Vec3b>(i, j - 1)[0] - src.at<Vec3b>(i, j + 1)[0] );
				b = abs(4 * src.at<Vec3b>(i, j)[1] - src.at<Vec3b>(i - 1, j)[1] - src.at<Vec3b>(i + 1, j)[1] - src.at<Vec3b>(i, j - 1)[1] - src.at<Vec3b>(i, j + 1)[1] );
				c = abs(4 * src.at<Vec3b>(i, j)[2] - src.at<Vec3b>(i - 1, j)[2] - src.at<Vec3b>(i + 1, j)[2] - src.at<Vec3b>(i, j - 1)[2] - src.at<Vec3b>(i, j + 1)[2] );
			
				a += src.at<Vec3b>(i, j)[0];
				b += src.at<Vec3b>(i, j)[1];
				c += src.at<Vec3b>(i, j)[2];
			}
			else {
				a = src.at<Vec3b>(i, j)[0];
				b = src.at<Vec3b>(i, j)[1];
				c = src.at<Vec3b>(i, j)[2];
			}
			if (a > 255 || b > 255 || b > 255 ) {
				dst.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i, j)[0];
				dst.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i, j)[1];
				dst.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i, j)[2];
			}
			else {
				dst.at<Vec3b>(i, j)[0] = a;
				dst.at<Vec3b>(i, j)[1] = b;
				dst.at<Vec3b>(i, j)[2] = c;
			}
		}
	return dst;
}

所有代码

包含了前一篇的代码

#include<opencv2\opencv.hpp>
#include<iostream>

using namespace cv;
using namespace std;

//2021.4.25
//Solye



//求均值
uchar getAverage(Mat src,int i, int j,int way) {
	uchar newData;
	newData = (
		src.at<Vec3b>(i-1, j)[way] + src.at<Vec3b>(i - 1, j)[way] + src.at<Vec3b>(i - 1, j+1)[way] + 
		src.at<Vec3b>(i, j - 1)[way] +src.at<Vec3b>(i , j)[way] + src.at<Vec3b>(i, j + 1)[way] + 
		src.at<Vec3b>(i + 1, j - 1)[way] + src.at<Vec3b>(i+1, j )[way] + src.at<Vec3b>(i + 1, j+1)[way]
		) / 9;

	return newData;
}


//均值滤波
Mat AverageFilter(const Mat& src, Mat& dst) {
	if (!src.data) return src;
	
	for (int i = 0; i < src.rows; ++i)
		for (int j = 0; j < src.cols; ++j) {

			if (i >= 1 && j >= 1 && i < src.rows - 1 && j < src.cols - 1) {
				dst.at<Vec3b>(i, j)[0] = getAverage(src, i, j, 0);
				dst.at<Vec3b>(i, j)[1] = getAverage(src, i, j, 1);
				dst.at<Vec3b>(i, j)[2] = getAverage(src, i, j, 2);
			}
			else {

				dst.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i, j)[0];
				dst.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i, j)[1];
				dst.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i, j)[2];
			}
		}
	return dst;
}
//求中值
uchar getMedian(Mat src, int a, int b, int way) {
	uchar newArray[9];
	newArray[0] = src.at<Vec3b>(a - 1, b - 1)[way];
	newArray[1] = src.at<Vec3b>(a - 1, b )[way];
	newArray[2] = src.at<Vec3b>(a - 1, b + 1)[way];
	newArray[3] = src.at<Vec3b>(a , b -1)[way];
	newArray[4] = src.at<Vec3b>(a , b )[way];
	newArray[5] = src.at<Vec3b>(a , b + 1)[way];
	newArray[6] = src.at<Vec3b>(a + 1, b -1)[way];
	newArray[7] = src.at<Vec3b>(a + 1, b)[way];
	newArray[8] = src.at<Vec3b>(a + 1, b+1)[way];
	int len = (int)sizeof(newArray) / sizeof(uchar);
	uchar temp;
	for (int i = 0; i < len - 1; i++)
		for (int j = 0; j < len - 1 - i; j++)
			if (newArray[j] > newArray[j + 1])
			{
				temp = newArray[j];
				newArray[j] = newArray[j + 1];
				newArray[j + 1] = temp;
			}
	

	return  newArray[4];
}

//中值滤波
Mat MedianFilter(const Mat& src, Mat& dst) {
	if (!src.data) return src;
	for (int i = 0; i < src.rows; ++i) {
		for (int j = 0; j < src.cols; ++j) {
			if (i >= 1 && j >= 1 && i < src.rows - 1 && j < src.cols - 1) {
				dst.at<Vec3b>(i, j)[0] = getMedian(src, i, j, 0);
				dst.at<Vec3b>(i, j)[1] = getMedian(src, i, j, 1);
				dst.at<Vec3b>(i, j)[2] = getMedian(src, i, j, 2);
			}
			else {
				dst.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i, j)[0];
				dst.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i, j)[1];
				dst.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i, j)[2];
			}
		}
	}
	return dst;
}





// 梯度锐化函数
Mat GradientSharpening(const Mat& src, Mat& dst) {
	if (!src.data) return src;
	for (int i = 0; i < src.rows; ++i)
		for (int j = 0; j < src.cols; ++j) {
			int a, b, c;
			if (i < src.rows - 1 && j < src.cols - 1) {
				
				//罗伯特交叉算子
				a = abs(src.at<Vec3b>(i + 1, j )[0] - src.at<Vec3b>(i, j)[0]) + abs(src.at<Vec3b>(i , j + 1)[0] - src.at<Vec3b>(i, j)[0]);
				b = abs(src.at<Vec3b>(i + 1, j )[1] - src.at<Vec3b>(i, j)[1]) + abs(src.at<Vec3b>(i , j + 1)[1] - src.at<Vec3b>(i, j)[1]);
				c = abs(src.at<Vec3b>(i + 1, j )[2] - src.at<Vec3b>(i, j)[2]) + abs(src.at<Vec3b>(i , j + 1)[2] - src.at<Vec3b>(i, j)[2]);

				//加上原来的颜色值，实现锐化增强
				a = a + src.at<Vec3b>(i, j)[0];
				b = b + src.at<Vec3b>(i, j)[1];
				c = c + src.at<Vec3b>(i, j)[2];
			}
			else {
				//无法处理的直接赋值原来的颜色值
				a = src.at<Vec3b>(i, j)[0];
				b = src.at<Vec3b>(i, j)[1];
				c = src.at<Vec3b>(i, j)[2];
			}
			//颜色值 超过255，为255
			if (a > 255 || b > 255 || b > 255) {
				
				dst.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i, j)[0];
				dst.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i, j)[1];
				dst.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i, j)[2];
			}
			else {
				dst.at<Vec3b>(i, j)[0] = a;
				dst.at<Vec3b>(i, j)[1] = b;
				dst.at<Vec3b>(i, j)[2] = c;
			}
		}
	return dst;
}

// 拉普拉斯锐化函数
// 0  -1  0
// -1  4  -1
// 0  -1  0
Mat LaplacianSharpening(const Mat& src, Mat& dst) {
	if (!src.data) return src;
	Mat img(src.size(), src.type());
	for (int i = 0; i < src.rows; ++i)
		for (int j = 0; j < src.cols; ++j) {
			int a, b, c;
			if (i > 1 && j > 1 && i < src.rows - 1  && j < src.cols - 1) {
				//5 是因为直接加上了原来的颜色值
				a = abs(4 * src.at<Vec3b>(i, j)[0] - src.at<Vec3b>(i - 1, j)[0] - src.at<Vec3b>(i + 1, j)[0] - src.at<Vec3b>(i, j - 1)[0] - src.at<Vec3b>(i, j + 1)[0] );
				b = abs(4 * src.at<Vec3b>(i, j)[1] - src.at<Vec3b>(i - 1, j)[1] - src.at<Vec3b>(i + 1, j)[1] - src.at<Vec3b>(i, j - 1)[1] - src.at<Vec3b>(i, j + 1)[1] );
				c = abs(4 * src.at<Vec3b>(i, j)[2] - src.at<Vec3b>(i - 1, j)[2] - src.at<Vec3b>(i + 1, j)[2] - src.at<Vec3b>(i, j - 1)[2] - src.at<Vec3b>(i, j + 1)[2] );
			
				a += src.at<Vec3b>(i, j)[0];
				b += src.at<Vec3b>(i, j)[1];
				c += src.at<Vec3b>(i, j)[2];
			}
			else {
				a = src.at<Vec3b>(i, j)[0];
				b = src.at<Vec3b>(i, j)[1];
				c = src.at<Vec3b>(i, j)[2];
			}
			if (a > 255 || b > 255 || b > 255 ) {
				dst.at<Vec3b>(i, j)[0] = src.at<Vec3b>(i, j)[0];
				dst.at<Vec3b>(i, j)[1] = src.at<Vec3b>(i, j)[1];
				dst.at<Vec3b>(i, j)[2] = src.at<Vec3b>(i, j)[2];
			}
			else {
				dst.at<Vec3b>(i, j)[0] = a;
				dst.at<Vec3b>(i, j)[1] = b;
				dst.at<Vec3b>(i, j)[2] = c;
			}
		}
	return dst;
}

int main()
{
	Mat src = imread("F:/雪野Solye/所有课程/大三下课程/数字图像与艺术分析/img/噪声图像.bmp");
	Mat averageFilter;
	Mat medianFilter;
	Mat gradientSharpening;
	Mat laplacianSharpening;

	averageFilter.create(src.rows, src.cols, src.type());
	medianFilter.create(src.rows, src.cols, src.type());
	gradientSharpening.create(src.rows, src.cols, src.type());
	laplacianSharpening.create(src.rows, src.cols, src.type());

	imshow("原图", src);
	imshow("均值滤波", AverageFilter(src, averageFilter));
	imshow("中值滤波", MedianFilter(src,medianFilter));
	imshow("梯度锐化", GradientSharpening(medianFilter, gradientSharpening));
	imshow("拉普拉斯增强算子锐化", LaplacianSharpening(medianFilter, laplacianSharpening));
	
	return waitKey(0);

}
雪野Solye
关注
专栏目录
图像增强——空间域滤波
。
10-10 2241
文章目录
《数字图像处理》复习提纲
weixin_37545024的博客
06-08 4771
本文在撰写过程中参考了由何东健教授主编、西安电子科技大学出版社出版的《数字图像处理》（第三版），一切著作权归原书作者和出版社所有。特别感谢长安大学软件系老师的认真负责的教导。 第1章 概论 1.1 数字图像处理及其特点 1、数字图像与图像处理 区分模拟图像与数字图像。 数字图像处理：利用计算机对图像进行去噪、增强、复原、分割、特征提取、识别等的理论、方法和技术。 2、数字图像处理的特点： 处理...
一阶与二阶微分锐化滤波器
06-19
运用梯度算法、Roberts 梯度算子法、Sobel算子法（加权平均差分法）、拉普拉斯算子对一阶与二阶锐化滤波器性能研究
数字图像的一阶微分和二阶微分
yb1254844976的博客
09-23 1万+
数字图像的微分也就是数字函数的微分有很多不用的定义，但是任何定义都必须保证一下几点： 一阶微分：（1）在恒定灰度区域的微分值为零；                   （2）在灰度台阶或斜坡处微分值非零；                   （3）沿着斜坡的微分值非零； 二阶微分：（1）在恒定灰度区域的微分值为零；                   （2）在灰度台阶或斜坡起点处微分值非...
图像增强中一阶微分和二阶微分的区别
kayv啊kayv
04-08 6728
1，斜坡面上，一阶微分一直不为0 ；二阶微分只有终点和起点不为02，一阶微分产生较粗的边缘，二阶微分则细得多3，一阶微分处理一般对灰度阶梯有较强的响应；二阶微分处理细节有较强的响应
图像处理总结2、图像增强
qq_43543515的博客
08-06 2673
图像增强 空域指像素位置所在的空间，也称图像空间，一般看作图像的原始空间 1空域增强：点操作 图像是对三维实际景物的平面投影。为了观测需要，常常需要进行各种不同的坐标变换。 注意一点，实际上坐标变换不改变像素值，而是改变像素所在的位置。 图像的坐标变换包括: 图像的空间平移、比例缩放、旋转、仿射变换和图像插值。 图像坐标变换的实质: 改变像素的空间位置，估算新空间位置上的像素值 坐标变换也叫几何变换：包括图像的平移，旋转，镜象变换，转置，放缩等。 一、平移(translation) 将图像沿水平或垂直方向移
技术干货 | 提速40%，MindSpore 二阶优化器技术解密！
Kenji_Shinji的博客
08-22 576
THOR还测试了在不同batchsize下ResNet50+ImageNet的收敛结果，结果见下表，当batchsize为8192，使用256块Ascend 910时，只需2.7分钟精度即可收敛到75.9%，该结果在业界也是非常有竞争力的。因此，在训练过程中逐步增大 矩阵的更新间隔，可以在不影响收敛速度的情况下，减少训练时间。图中的THOR，THOR_stop，THOR_NT分表表示 ，从图中可以看到THOR收敛所需迭代数大约是一阶的一半，且单step的时间与一阶相差也不大。
数字图像处理基础
lx_xin的博客
09-22 660
文章目录数字图像处理数字图像基础图像内插 数字图像处理 数字图像基础 图像内插 用于图像放大、缩小、旋转、几何校正等任务。首先确定变换前后的坐标对应关系，用src表示转换前的图像尺寸，dst表示转换后的图像尺寸，src’表示转换后图像对应于原图像的坐标。对于图像缩放，缩放系数t=src/dstt=src/dstt=src/dst，则dst对应在src中的坐标为src′=dst∗tsrc&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;a
c++gdal如何在大图像中截取小图像并获取其图像信息_OpenCV 图像处理大纲
weixin_39735005的博客
10-21 376
图像的取样和量化取样就是取像素点，量化把灰度值量化到256个灰度级数字图像的表示图像定义为二位函数f(x, y)，x,y是空间坐标f(x, y)是点的幅值数字图像的质量灰度级：表明像素明暗程度整数量空间分辨率：图像的尺寸层次：表明图像实际拥有的灰度级的数量，图像的实际层次越多，图像的质量就越好对比度：指图像中灰度反差的大小，对比度=最大亮度/最小亮度对比度较小，图像就会比较模糊；一般来说，对比度大...
图像处理总结概念
热门推荐
今天比昨天进步一点点
05-08 3万+
1.直方图：一幅图像由不同灰度值的像素组成，图像中灰度的分布情况是该图像的一个重要特征。图像的灰度直方图就描述了图像中灰度分布情况，能够很直观的展示出图像中各个灰度级所占的多少。图像的灰度直方图是灰度级的函数，描述的是图像中具有该灰度级的像素的个数：其中，横坐标是灰度级，纵坐标是该灰度级出现的频率。数字图像在范围[0，G]内总共有L个灰度级，直方图为h(rK)=nkrK是去见[0，G]内的第K级亮...
python opencv 锐化_Python-OpenCV中的filter2D()函数
weixin_39852953的博客
12-10 1147
使用自定义内核对图像进行卷积。该功能将任意线性滤波器应用于图像。支持就地操作。当光圈部分位于图像外部时，该功能会根据指定的边框模式插入异常像素值。语法函数原型：dst=cv.filter2D(src, ddepth, kernel[, dst[, anchor[, delta[, borderType]]]])参数：参数描述src原图像dst目标图像，与原图像尺寸和通过数相同ddepth目标图像的...
数字图像处理学习笔记4：图像增强之空间滤波2（一阶微分锐化滤波（梯度），二阶微分锐化（拉普拉斯），非锐化掩蔽）
刘燚的博客
10-27 4762
文章目录前言一、一阶微分和二阶微分的定义二、一阶微分锐化滤波：梯度1.梯度2.sobel算子及MATLAB代码二、二阶微分锐化滤波：拉普拉斯算子1.拉普拉斯算子2.拉普拉斯算子MATLAB代码三、非锐化掩蔽 和 高提升滤波1.非锐化掩蔽 和 高提升滤波2.MATLAB代码总结 前言 锐化滤波的主要目的是突出灰度的过渡部分，比如图像中物体的边缘。 一、一阶微分和二阶微分的定义 一阶微分： （1）在恒定灰度值得区域一阶微分值为零； （2）在灰度变化的台阶以及斜坡处一阶微分值非零； （3）沿着斜坡的一阶微分.
不同图像锐化算子提取的图像信息有哪些不同_数字图像处理：Spatial Filtering and Median Filtering...
weixin_39831567的博客
10-21 265
【欢迎关注、点赞、收藏、私信、交流】共同学习进步摘 要：本实验主要是对图像的加、减、乘、除运算以及各种空域滤波进行程序设计和编写，通过实验结果对比验证几种图像运算处理方法的优缺点及适用范围。从而对图像的代数运算、空域滤波、平滑滤波、拉普拉斯算子等有更深一步的认识和了解。其中平滑滤波用于模糊处理、减小噪声；拉普拉斯用于强调图像中灰度的突变及降低灰度慢变化的区域；中值滤波对于像椒盐噪声一定类型的随...
数字图像的均值滤波，中值滤波，高斯滤波，双边滤波
jinyu3d的博客
07-18 389
数字图像滤波介绍
数字图像处理-空间域处理-空间滤波-锐化空间滤波器
weixin_30478923的博客
04-09 319
参考自：数字图像处理第三版-冈萨勒斯 锐化处理的主要目的是突出灰度的过渡部分。增强边缘和其他突变（噪声），削弱灰度变化缓慢的区域。 注意：垂直方向是x，水平方向是y 基础 图像模糊可用均值平滑实现。因均值处理与积分类似，在逻辑上，我们可以得出锐化处理可由空间微分来实现。微分算子的响应强度与图像的突变程度成正比，这样，图像微分增强边缘和其他突变，而削弱灰度变化缓慢的区域。...
积分图快速均值滤波
最新发布
m0_73188795的博客
10-21 225
均值滤波是一种很简单的线性滤波，具体操作就是将窗口内的所有像素值累加起来取平均值然后赋值给中心像素。比如在如下图像中，要计算第三行第四列的像素做3x3均值滤波后的像素值，应该将以该像素为中心的3x3窗口内的9个像素累加，然后取平均。即I′3491​i2∑4​j3∑5​Iij163442221442865826/937.78。
二阶滤波器原理及算法程序
weixin_34409822的博客
05-11 5814
滤波器的作用是允许某些频率的正弦信号基本无衰减的通过（增益为 1，频域 0dB），同时对另外某些频率的正弦信号起到衰减作用（增益在 0.707 以下，频域-3dB 以下）。 当然，滤波器对通过的正弦信号会产生一定的相移作用。1.二阶通用滤波器二阶滤波器表示的是滤波器时域表达式中最高含有二阶微分，或者说传递函数分母的s最高次数为2。滤波器对直流分量的增益为1。据此可...
opencv-python——图像增强（拉普拉斯锐化，直方图均衡，双边滤波）
qq_51687050的博客
07-01 7051
然后我们在滤波后的图像上应用拉普拉斯滤波器，将处理后的结果与原始图像相加，从而强化图像中的轮廓和细节信息，提高图像的清晰度和锐度。直方图均衡（Histogram equalization）是一种常见的图像增强方法，它可以将图像的直方图进行变换，使得图像的灰度级数分布更加均匀，从而增强图像的对比度和显示效果。通过这个过程，直方图均衡能够扩展图像的动态范围，减少图像中像素强度值的方差，并增强图像的对比度，从而提高图像的视觉质量。将产生的图像与原始图像相减，得到一个得到一个用于增强图像细节的高通滤波图像。
数字图像处理----基于拉普拉斯的图像增强
qianjq3的博客
02-28 4014
Tool： MATLAB； Technique： Using Laplacian to enhance Image Coding （Matlab编程） % img = imread('Fig0340.tif'); subplot(2, 3, 1); imshow(img); title('原图'); % 默认的拉普拉斯 h = fspec...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

雪野Solye

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值