6.4双边滤波

weixin_45794330

于 2024-09-09 02:45:00 发布

阅读量359

点赞数 3

分类专栏： Opencv 文章标签： opencv

本文链接：https://blog.csdn.net/weixin_45794330/article/details/141905358

版权

Opencv 专栏收录该内容

69 篇文章 0 订阅

订阅专栏

实验原理

双边滤波（Bilateral Filtering）是一种非线性滤波技术，用于图像处理中去除噪声，同时保留边缘和细节。这种滤波器结合了空间邻近性和像素值相似性的双重加权，从而能够在去噪(平滑图像)的同时保留图像的边缘细节。双边滤波器能够在的同时，保持边缘清晰，因此非常适合用于去除噪声和保持图像特征。在OpenCV中，可以使用bilateralFilter()函数来实现双边滤波。

函数原型

在OpenCV中，用于实现双边滤波的函数是cv::bilateralFilter。
其原型如下：
void bilateralFilter(InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT );


参数说明
•src：输入图像。
•dst：输出图像，与输入图像具有相同的大小和类型。
•d：直径，即滤波器的直径（即卷积核的直径）。如果设置为负数（例如-1），则根据sigmaSpace计算直径。
•sigmaColor：颜色空间的标准差，用于控制像素值的相似程度。较大的sigmaColor值会使得距离较远的像素也被考虑进来。
        （在颜色空间中的变化量，较大的值意味着更大的颜色差异也能被包括进来）。
•sigmaSpace：空间域的标准差，用于控制距离中心像素的距离。较大的sigmaSpace值会使得更大的邻域像素被考虑进来。
        （在空间域中的变化量，较大的值意味着远处的像素也会影响当前像素的值）。
•borderType：边界处理类型，默认为BORDER_DEFAULT，可以选择不同的边界处理方式，如BORDER_CONSTANT、BORDER_REFLECT等。

边界处理borderType参数决定了如何处理图像边缘的像素。
常见的边界处理方式包括：
•BORDER_CONSTANT：用指定的常数值填充边界。
•BORDER_REPLICATE：边界像素值向外扩展。
•BORDER_REFLECT：反射边界，如12345反射为45454。
•BORDER_WRAP：循环边界，如12345循环为34512。

工作原理

双边滤波器在每个像素点上应用一个卷积核（Kernel），该核根据两个因素来确定每个邻域像素的权重：

1. 颜色相似性：越接近的颜色，权重越高。

2. 空间距离：越接近的像素，权重越高。双边滤波器通过结合这两个因素来计算每个像素的新值，从而达到既能平滑图像又能保持边缘的效果。

优点

1. 去噪能力强：特别适合去除随机噪声。

2. 边缘保持：由于双边滤波是非线性滤波，它在平滑图像的同时能较好地保持图像的边缘和细节。

不足

1. 计算复杂度较高：相比于简单的线性滤波器（如均值滤波或高斯滤波），双边滤波涉及更多的计算量。

2. 参数选择：需要仔细调整d、sigmaColor和sigmaSpace参数以获得最佳效果。

示例代码1

#include "pch.h"
#include <opencv2/opencv.hpp>
#include <iostream>

int main(int argc, char** argv)
{

	// 读取图像
	cv::Mat src = cv::imread("010.png", cv::IMREAD_COLOR);
	if (!src.data)
	{
		std::cout << "Error loading image" << std::endl;
		return -1;
	}

	// 定义输出图像
	cv::Mat dst;

	// 设置双边滤波参数
	int diameter = 9; // 直径大小
	double sigmaColor = 75; // 颜色空间标准差
	double sigmaSpace = 75; // 坐标空间标准差

	// 应用双边滤波
	cv::bilateralFilter(src, dst, diameter, sigmaColor, sigmaSpace);

	// 显示原始图像和滤波后的图像
	cv::namedWindow("Original Image", cv::WINDOW_NORMAL);
	cv::imshow("Original Image", src);

	cv::namedWindow("Bilateral Filtered Image", cv::WINDOW_NORMAL);
	cv::imshow("Bilateral Filtered Image", dst);

	// 等待按键
	cv::waitKey(0);

	return 0;
}

//在这个例子中，我们加载了一张图片，并对其应用了双边滤波。
//你可以根据需要调整diameter, sigmaColor, 和 sigmaSpace 参数来获得不同的滤波效果。
代码解释
1. 读取图像：使用cv::imread读取输入图像，并确保它是彩色图像。
2. 创建输出图像：创建一个新的cv::Mat对象来存储滤波后的结果。
3. 定义双边滤波参数：定义滤波器直径、颜色空间的标准差和空间域的标准差。
4. 应用双边滤波：使用cv::bilateralFilter函数对图像进行双边滤波。
5. 显示结果：使用cv::imshow函数显示原始图像和双边模糊后的图像，并等待用户按键退出。

运行结果1

图片中模糊椒盐点会消失

参数调整

•d：直径（Diameter）参数决定了滤波器的大小。较大的直径可以产生更强烈的平滑效果，但可能会丢失更多的细节；较小的直径则可以保留更多细节，但平滑效果较弱。

•sigmaColor：颜色空间的标准差，用于控制像素值的相似程度。较大的sigmaColor值会使得距离较远的像素也被考虑进来。

•sigmaSpace：空间域的标准差，用于控制距离中心像素的距离。较大的sigmaSpace值会使得更大的邻域像素被考虑进来。

总结

双边滤波是一种有效的图像平滑技术，通过结合颜色相似性和空间距离来选择权重，从而既能去除噪声又能保持边缘和细节。通过调整直径、颜色空间的标准差和空间域的标准差，可以控制滤波器的效果。cv::bilateralFilter函数提供了方便的接口来实现双边滤波，并且允许用户指定边界处理方式。

实验代码2

// test.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
using namespace std;
using namespace cv;
//#pragma comment(lib, "opencv_world450d.lib")  //引用引入库 
int DELAY_CAPTION = 1500;
int DELAY_BLUR = 100;
int MAX_KERNEL_LENGTH = 31;
Mat src; Mat dst;
char window_name[] = "Smoothing Demo";
int display_caption(const char* caption);
int display_dst(int delay);
int main(int argc, char ** argv)
{
	namedWindow(window_name, WINDOW_NORMAL);
	//const char* filename = argc >= 2 ? argv[1] : "lena.png";
	//src = imread(samples::findFile(filename), IMREAD_COLOR);
	//
	src = imread("00.jpeg", IMREAD_COLOR);
	if (src.empty())
	{
		printf(" Error opening image\n");
		printf(" Usage:\n %s [image_name-- default lena.jpg] \n", argv[0]);
		return EXIT_FAILURE;
	}
	if (display_caption("Original Image") != 0)
	{
		return 0;
	}
	dst = src.clone();
	if (display_dst(DELAY_CAPTION) != 0)
	{
		return 0;
	}
	if (display_caption("Homogeneous Blur") != 0)
	{
		return 0;
	}
	for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2)
	{
		blur(src, dst, Size(i, i), Point(-1, -1));
		if (display_dst(DELAY_BLUR) != 0)
		{
			return 0;
		}
	}
	if (display_caption("Gaussian Blur") != 0)
	{
		return 0;
	}
	for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2)
	{
		GaussianBlur(src, dst, Size(i, i), 0, 0);
		if (display_dst(DELAY_BLUR) != 0)
		{
			return 0;
		}
	}
	if (display_caption("Median Blur") != 0)
	{
		return 0;
	}
	for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2)
	{
		medianBlur(src, dst, i);
		if (display_dst(DELAY_BLUR) != 0)
		{
			return 0;
		}
	}
	if (display_caption("Bilateral Blur") != 0)
	{
		return 0;
	}
	for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2)
	{
		bilateralFilter(src, dst, i, i * 2, i / 2);
		if (display_dst(DELAY_BLUR) != 0)
		{
			return 0;
		}
	}
	display_caption("Done!");
	return 0;
}
int display_caption(const char* caption)
{
	dst = Mat::zeros(src.size(), src.type());
	putText(dst, caption,Point(src.cols / 4, src.rows / 2),FONT_HERSHEY_COMPLEX, 1,
 Scalar(255, 255, 255));
	return display_dst(DELAY_CAPTION);
}
int display_dst(int delay)
{
		imshow(window_name, dst);
		int c = waitKey(delay);
		if (c >= 0) { return -1; }
		return 0;
}