OpenCV4.9处理平滑图像(38)

已于 2024-04-30 22:46:10 修改
阅读量2.4k 收藏 32
点赞数 88
分类专栏： C/C++ 人工智能 OpenCV 文章标签： c++ 计算机视觉 视觉检测 opencv 人工智能
于 2024-04-07 16:58:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78348935/article/details/137467136
版权
人工智能 同时被 3 个专栏收录
86 篇文章 1 订阅
订阅专栏
OpenCV
79 篇文章 0 订阅
订阅专栏
C/C++
78 篇文章 0 订阅
订阅专栏

返回：OpenCV系列文章目录（持续更新中......）

上一篇：使用OpenCV4.9的随机生成器和文本(37)

下一篇:OpenCV4.9侵蚀和扩张(39)

目标

在本教程中，您将学习如何使用 OpenCV 函数将不同的线性滤波器应用于平滑图像，例如：

  • blur()
  • GaussianBlur()
  • medianBlur()
  • bilateralFilter()

相关理论

注意

下面的解释属于 Richard Szeliski 的《计算机视觉：算法和应用》一书和 LearningOpenCV

  • 平滑，也称为模糊，是一种简单且常用的图像处理操作。
  • 平滑的原因有很多。在本教程中，我们将重点介绍平滑处理以减少噪声（其他用途将在以下教程中看到）。

  • 它有助于将滤镜可视化为在图像上滑动的系数窗口。

  • 过滤器有很多种，这里我们提一下最常用的：

归一化盒过滤器

  • 这个过滤器是最简单的！每个输出像素都是其内核邻居的平均值（所有像素的权重相等）
  • 内核如下：

高斯滤波器

  • 可能是最有用的过滤器（虽然不是最快的）。高斯滤波是通过用高斯核对输入数组中的每个点进行卷积，然后将它们相加以生成输出数组来完成的。
  • 为了让图片更清晰，还记得一维高斯核的样子吗？

假设图像是 1D 的，您可以注意到位于中间的像素将具有最大的权重。其相邻像素的权重随着它们与中心像素之间的空间距离的增加而减小。

注意

请记住，二维高斯可以表示为：

中值滤波器

中值滤波器贯穿信号的每个元素（在本例中为图像），并将每个像素替换为其相邻像素的中位数（位于评估像素周围的方形邻域中）。

双边过滤器

  • 到目前为止，我们已经解释了一些过滤器，其主要目标是平滑输入图像。然而，有时滤波器不仅可以溶解噪声，还可以消除边缘。为了避免这种情况（至少在一定程度上），我们可以使用双边过滤器。
  • 与高斯滤波器类似，双边滤波器也会考虑相邻像素，并为每个像素分配权重。这些权重有两个组成部分，第一个分量与高斯滤波器使用的权重相同。第二个组件考虑了相邻像素和评估像素之间的强度差异。
  • 有关更详细的说明，您可以查看此链接

代码：

  • 这个程序是做什么的？
    • 加载图像
    • 应用 4 种不同类型的滤镜（在理论中解释）并按顺序显示滤波后的图像
  • 可下载代码： 点击这里
  • 代码一览：

C++： 

 
#include <iostream>
#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
 
using namespace std;
using namespace cv;
 
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_AUTOSIZE );
 
 const char* filename = argc >=2 ? argv[1] : "lena.jpg";
 
 src = imread( samples::findFile( filename ), 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;
}

Java：

import org.opencv.core.*;
import org.opencv.highgui.HighGui;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
 
class SmoothingRun {
 
 int DELAY_CAPTION = 1500;
 int DELAY_BLUR = 100;
 int MAX_KERNEL_LENGTH = 31;
 
 Mat src = new Mat(), dst = new Mat();
 String windowName = "Filter Demo 1";
 
 public void run(String[] args) {
 
 String filename = ((args.length > 0) ? args[0] : "../data/lena.jpg");
 
 src = Imgcodecs.imread(filename, Imgcodecs.IMREAD_COLOR);
 if( src.empty() ) {
 System.out.println("Error opening image");
 System.out.println("Usage: ./Smoothing [image_name -- default ../data/lena.jpg] \n");
 System.exit(-1);
 }
 
 if( displayCaption( "Original Image" ) != 0 ) { System.exit(0); }
 
 dst = src.clone();
 if( displayDst( DELAY_CAPTION ) != 0 ) { System.exit(0); }
 
 if( displayCaption( "Homogeneous Blur" ) != 0 ) { System.exit(0); }
 
 for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
 Imgproc.blur(src, dst, new Size(i, i), new Point(-1, -1));
 displayDst(DELAY_BLUR);
 }
 
 if( displayCaption( "Gaussian Blur" ) != 0 ) { System.exit(0); }
 
 for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
 Imgproc.GaussianBlur(src, dst, new Size(i, i), 0, 0);
 displayDst(DELAY_BLUR);
 }
 
 if( displayCaption( "Median Blur" ) != 0 ) { System.exit(0); }
 
 for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
 Imgproc.medianBlur(src, dst, i);
 displayDst(DELAY_BLUR);
 }
 
 if( displayCaption( "Bilateral Blur" ) != 0 ) { System.exit(0); }
 
 for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
 Imgproc.bilateralFilter(src, dst, i, i * 2, i / 2);
 displayDst(DELAY_BLUR);
 }
 
 displayCaption( "Done!" );
 
 System.exit(0);
 }
 
 int displayCaption(String caption) {
 dst = Mat.zeros(src.size(), src.type());
 Imgproc.putText(dst, caption,
 new Point(src.cols() / 4, src.rows() / 2),
 Imgproc.FONT_HERSHEY_COMPLEX, 1, new Scalar(255, 255, 255));
 
 return displayDst(DELAY_CAPTION);
 }
 
 int displayDst(int delay) {
 HighGui.imshow( windowName, dst );
 int c = HighGui.waitKey( delay );
 if (c >= 0) { return -1; }
 return 0;
 }
}
 
public class Smoothing {
 public static void main(String[] args) {
 // Load the native library.
 System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
 new SmoothingRun().run(args);
 }
}

Python：

import sys
import cv2 as cv
import numpy as np
 
# Global Variables
 
DELAY_CAPTION = 1500
DELAY_BLUR = 100
MAX_KERNEL_LENGTH = 31
 
src = None
dst = None
window_name = 'Smoothing Demo' 
 
def main(argv):
 cv.namedWindow(window_name, cv.WINDOW_AUTOSIZE)
 
 # Load the source image
 imageName = argv[0] if len(argv) > 0 else 'lena.jpg'
 
 global src
 src = cv.imread(cv.samples.findFile(imageName))
 if src is None:
 print ('Error opening image')
 print ('Usage: smoothing.py [image_name -- default ../data/lena.jpg] \n')
 return -1
 
 if display_caption('Original Image') != 0:
 return 0
 
 global dst
 dst = np.copy(src)
 if display_dst(DELAY_CAPTION) != 0:
 return 0
 
 # Applying Homogeneous blur
 if display_caption('Homogeneous Blur') != 0:
 return 0 
 
 for i in range(1, MAX_KERNEL_LENGTH, 2):
 dst = cv.blur(src, (i, i))
 if display_dst(DELAY_BLUR) != 0:
 return 0 
 
 # Applying Gaussian blur
 if display_caption('Gaussian Blur') != 0:
 return 0 
 
 for i in range(1, MAX_KERNEL_LENGTH, 2):
 dst = cv.GaussianBlur(src, (i, i), 0)
 if display_dst(DELAY_BLUR) != 0:
 return 0 
 
 # Applying Median blur
 if display_caption('Median Blur') != 0:
 return 0 
 
 for i in range(1, MAX_KERNEL_LENGTH, 2):
 dst = cv.medianBlur(src, i)
 if display_dst(DELAY_BLUR) != 0:
 return 0 
 
 # Applying Bilateral Filter
 if display_caption('Bilateral Blur') != 0:
 return 0 
 
 for i in range(1, MAX_KERNEL_LENGTH, 2):
 dst = cv.bilateralFilter(src, i, i * 2, i / 2)
 if display_dst(DELAY_BLUR) != 0:
 return 0 
 
 # Done
 display_caption('Done!')
 
 return 0 
 
def display_caption(caption):
 global dst
 dst = np.zeros(src.shape, src.dtype)
 rows, cols, _ch = src.shape
 cv.putText(dst, caption,
 (int(cols / 4), int(rows / 2)),
 cv.FONT_HERSHEY_COMPLEX, 1, (255, 255, 255))
 
 return display_dst(DELAY_CAPTION) 
 
def display_dst(delay):
 cv.imshow(window_name, dst)
 c = cv.waitKey(delay)
 if c >= 0 : return -1
 return 0 
 
if __name__ == "__main__":
 main(sys.argv[1:])

解释

让我们检查一下仅涉及平滑过程的 OpenCV 函数，因为其余的现在已经知道了。

归一化块滤波器：

  • OpenCV 提供了函数 blur（） 来使用此过滤器执行平滑处理。我们指定 4 个参数（更多详细信息，请查看参考）：
    • src：源图片
    • dst：目标图像
    • Size（ w， h ）：定义要使用的内核的大小（宽度 w 像素和高度 h 像素）
    • Point（-1， -1）：指示锚点（评估的像素）相对于邻域的位置。如果存在负值，则将内核的中心视为锚点。
    • C++：
 for i in range(1, MAX_KERNEL_LENGTH, 2):
 dst = cv.blur(src, (i, i))
 if display_dst(DELAY_BLUR) != 0:
 return 0

 Java：

 for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
 Imgproc.blur(src, dst, new Size(i, i), new Point(-1, -1));
 displayDst(DELAY_BLUR);
 }

Python： 

 for i in range(1, MAX_KERNEL_LENGTH, 2):
 dst = cv.blur(src, (i, i))
 if display_dst(DELAY_BLUR) != 0:
 return 0

Gaussian Filter:

  • 它由函数 GaussianBlur（） 执行： 这里我们使用 4 个参数（更多细节，请查看 OpenCV 参考）：

C++：

 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;
 }
 }

Java：

 for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
 Imgproc.blur(src, dst, new Size(i, i), new Point(-1, -1));
 displayDst(DELAY_BLUR);
 }

python：

 for i in range(1, MAX_KERNEL_LENGTH, 2):
 dst = cv.GaussianBlur(src, (i, i), 0)
 if display_dst(DELAY_BLUR) != 0:
 return 0

中值过滤器：

  • 此过滤器由 medianBlur()函数提供： 我们使用三个参数：
    • src：源图片
    • dst：目标镜像，必须与 src 类型相同
    • i：内核的大小（只有一个，因为我们使用方形窗口）。一定是奇怪的。

C++：

 for ( int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2 )
 {
 medianBlur ( src, dst, i );
 if( display_dst( DELAY_BLUR ) != 0 )
 {
 return 0;
 }
 }

Java：

 for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
 Imgproc.medianBlur(src, dst, i);
 displayDst(DELAY_BLUR);
 }

Python： 

 for i in range(1, MAX_KERNEL_LENGTH, 2):
 dst = cv.medianBlur(src, i)
 if display_dst(DELAY_BLUR) != 0:
 return 0

双边过滤器

  • 由 OpenCV 函数 bilateralFilter（） 提供 我们使用 5 个参数:
    • src：源图片
    • dst：目标图像
    • d：每个像素邻域的直径。

C++：

 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;
 }
 }

Java：

 for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
 Imgproc.bilateralFilter(src, dst, i, i * 2, i / 2);
 displayDst(DELAY_BLUR);
 }

Python：

 # Remember, bilateral is a bit slow, so as value go higher, it takes long time
 for i in range(1, MAX_KERNEL_LENGTH, 2):
 dst = cv.bilateralFilter(src, i, i * 2, i / 2)
 if display_dst(DELAY_BLUR) != 0:
 return 0

结果

  • 该代码打开一个图像（在本例中为 lena.jpg），并在解释的 4 个过滤器的影响下显示它。
  • 以下是使用 medianBlur 平滑处理的图像快照：

参考文献：

1、《Smoothing Images》--------Ana Huamán

愚梦者
关注
  • 88
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
数字图像处理（实践篇）四十三 OpenCV-Python 使用SURF算法检测图像上的特征点的实践
静谧、淡雅
02-04 360
数字图像处理（实践篇）四十三 OpenCV-Python 使用SURF算法检测图像上的特征点的实践
opencv4.9版本报错
03-10 1560
解决办法更换4.6版。
快速上手Opencv：HighGUI图形用户界面
m0_50127633的博客
06-13 3035
Opencv3编程入门
【OpenCV学习】之图像平滑处理
醉逍遥的博客
03-10 413
目标 本教程教您怎样使用各种线性滤波器对图像进行平滑处理，相关OpenCV函数如下: blur GaussianBlur medianBlur bilateralFilter 原理 平滑也称模糊, 是一项简单且使用频率很高的图像处理方法。 平滑处理的用途有很多， 但是在本教程中我们仅仅关注它减少噪声的功用 (其他用途在以后的教程中会接触到)。 平滑处理时需要用到一个滤波器。...
【Python--openCV图像处理】Python学习-OpenCV图像处理基础超详细的学习笔记（黑马程序员课程-B站有视频）
m0_67844671的博客
06-01 1170
【Python--openCV图像处理】Python学习-OpenCV图像处理基础超详细的学习笔记（黑马程序员课程-B站有视频）
基于C++的OpenCV（八）图像处理
yang_jianfeng的博客
05-21 1659
三种线性滤波：方框滤波、均值滤波、高斯滤波 两种非线性滤波：中值滤波、双边滤波 七种图像处理形态学：腐蚀、膨胀、开运算、闭运算、形态学梯度、顶帽、黑帽 漫水填充 图像缩放 图像金字塔 阈值化 平滑处理（smoothing）也称为模糊处理（bluring），是一种简单且使用频率很高的图像处理方法。平滑处理的用途有很多，最常见的是用来减少图像上的噪点或者失真。 图像滤波指在尽量保留图像细节特征的条件下对目标图像的噪声进行抑制，是图像预处理中不可缺少的操作，其处理效果的好坏直接影响到后续图像处理和分析的有效性和可
OpenCV4.9更多形态转换(40)
2301_78348935的博客
04-11 827
OpenCV是一个开源的计算机视觉库，由英特尔公司开发并开源的一组跨平台的C++函数和少量的C函数组成，用于实时图像处理、计算机视觉和机器学习等应用领域。OpenCV可以在包括Windows、Linux、macOS等各种操作系统平台上使用，具有开放的编程接口，可用于各种应用开发。OpenCV的主要特点是易于使用，高效、学习资源和社区活跃。OpenCV可以计算相机标定、物体识别、动作跟踪、人脸识别、手写数字识别等任务，并可集成到摄像头、网络摄像头和机器人等系统中。
OpenCV4.9侵蚀和扩张(39)
2301_78348935的博客
04-10 1068
OpenCV是一个开源的计算机视觉库，由英特尔公司开发并开源的一组跨平台的C++函数和少量的C函数组成，用于实时图像处理、计算机视觉和机器学习等应用领域。OpenCV可以在包括Windows、Linux、macOS等各种操作系统平台上使用，具有开放的编程接口，可用于各种应用开发。OpenCV的主要特点是易于使用，高效、学习资源和社区活跃。OpenCV可以计算相机标定、物体识别、动作跟踪、人脸识别、手写数字识别等任务，并可集成到摄像头、网络摄像头和机器人等系统中。
opencv4.9 .cache cmake编译
05-31
OpenCV（开源计算机视觉库）是一个广泛用于图像处理和计算机视觉任务的库，它支持C++、Python等多种编程语言。在开发过程中，我们有时需要对OpenCV进行编译以适应特定的系统配置或添加自定义模块。在这个场景中，...
平滑处理.cpp.zip_OpenCV 平滑_opencv 图像处理
07-15
使用C语言，调用OpenCV的库，来对图像进行平滑处理。
opencv opencv 图像处理
12-14
OpenCV 图像处理 OpenCV 是一个基于 BSD 许可的开源计算机视觉库，提供了大量的图像处理函数库，可以实现图像处理、特征检测、目标识别、对象跟踪、3D 建模等多种计算机视觉任务。OpenCV 中的图像处理功能非常强大...
opencv4.9-mingw编译后库包
04-26
总之，这个"opencv4.9-mingw编译后库包"是一个专为GoCV设计的OpenCV版本，经过了MinGW编译器的处理，便于在Windows环境下进行图像处理和计算机视觉的开发。正确配置环境变量和库路径后，用户可以直接在Go项目中导入...
OpenCV 2.4.3 C++ 平滑处理分析
09-05
在图像处理领域，平滑处理，也常被称为模糊处理，是一种常见的预处理技术，用于减少图像中的噪声或增强某些特征。OpenCV库提供了多种平滑处理的方法，特别在OpenCV 2.4版本中，C++接口使得这些操作更加便捷。本文...
在C++里使字符数组变成字符串（2）
最新发布
LiXinLong_LXL_13的博客
07-29 150
在C++中，‌将字符数组转换为字符串可以通过几种方法实现
嵌入式C++、ROS 、OpenCV、SLAM 算法和路径规划算法：自主导航的移动机器人流程设计（代码示例）
嵌入式极客小张
07-25 1383
在科技迅速发展的背景下，嵌入式自主移动机器人作为一个具有广泛应用前景的研究领域，吸引了众多开发者的关注。本文详细介绍了一个嵌入式自主移动机器人项目，重点阐述了其硬件与软件系统设计及代码实现。硬件部分采用ESP32、Raspberry Pi和Arduino作为嵌入式控制器，结合激光雷达、超声波传感器和摄像头等多种传感器，实现环境感知和数据采集。软件系统基于Raspberry Pi OS，主要使用Python进行高层逻辑控制，C/C++用于实时任务处理，并利用ROS框架支持机器人开发。
背单词工具(C++)
zeyeqianli的博客
07-24 3801
【代码】背单词工具(C++)
C++的STL简介（一）
2302_81171591的博客
07-23 1483
STL（standarf template libaray-标准模板库）：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
C++红黑树
杀意感知的博客
07-25 917
AVL树：严格平衡（左右子树高度差不超过 1），所以 AVL 树的查找、插入、删除效率高：O(logN)，但在插入和删除节点后，要维持树的平衡状态，做的旋转处理还是很多的。红黑树：近似平衡（控制最长路径不超过最短路径的2倍），变了一种方式来控制树的平衡，相较于 AVL 树而言，没有那么严格。红黑树更多是一种折中的选择，它舍弃平衡二叉树的严格平衡，换取节点插入时尽可能少的调整。因为红黑树的旋转情况少于 AVL 树，使得红黑树整体性能略优于。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

愚梦者

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

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

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

打赏作者

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

抵扣说明：

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

余额充值