制作您自己的线性滤波器！

目录

• 目标
• 理论
  • 相关性
  • 什么是核
  • 与核的关联如何运作？
  • 此程序的作用是什么？
• 代码
• 说明
  • 加载图像
  • 初始化参数
  • 循环
• 结果

上一教程： 使用 inRange 进行阈值操作
下一教程： 为您的图像添加边框

原始作者	Ana Huamán
兼容性	OpenCV >= 3.0

目标

在本教程中，您将学习如何

• 使用 OpenCV 函数 filter2D() 创建您自己的线性滤波器。

理论

注意

以下说明出自 Bradski 和 Kaehler 所著的 Learning OpenCV 一书。

相关性

从一个非常概括的角度来说，相关性是一个图像的每个部分与一个运算符（核）之间的运算。

什么是核

一个核本质上是一个大小固定的数值系数阵列，以及该阵列中的一个锚点，这个锚点通常位于中心。

与核的关联如何运作？

假设您想了解图像中特定位置的结果值。这个关联的值可以用以下方式计算

1. 将核锚放置在一个确定的像素之上，同时核的其余部分覆盖图像中相应的局部像素。
2. 将核系数乘以相应的图像像素值并对结果求和。
3. 将结果放置在输入图像锚点的位置。
4. 通过在整个图像上扫描这个核，对所有像素重复这个过程。

用方程式表达上述过程，我们得到

\[H(x,y) = \sum_{i=0}^{M_{i} - 1} \sum_{j=0}^{M_{j}-1} I(x+i - a_{i}, y + j - a_{j})K(i,j)\]

幸运的是，OpenCV 向您提供了 filter2D() 函数，因此您不必编写所有这些运算。

此程序的作用是什么？

• 加载图像
• 执行一个归一化框滤波。例如，对于大小为 \(size = 3\) 的核，这个核将是

\[K = \dfrac{1}{3 \cdot 3} \begin{bmatrix} 1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1 \end{bmatrix}\]

这个程序将用大小为 3、5、7、9 和 11 的核执行滤波运算。

• 滤波输出（每个卷积核）会在 500 毫秒内显示

代码

教程代码在下方的行中显示。

C++

你还可以从 此处下载

 
#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui.hpp"
 
using namespace cv;
 
int main ( int argc, char** argv )
{
    // 声明变量
    Mat src, dst;
 
    Mat kernel;
    Point anchor;
    double delta;
    int ddepth;
    int kernel_size;
    const char* window_name = "filter2D Demo";
 
    const char* imageName = argc >=2 ? argv[1] : "lena.jpg";
 
    // 加载图像
src = imread( samples::findFile( imageName ), IMREAD_COLOR ); // 加载图像
 
    if( src.empty() )
    {
printf(" Error opening image\n");
printf(" Program Arguments: [image_name -- default lena.jpg] \n");
        return EXIT_FAILURE;
    }
 
    // 初始化用于滤波的参数
anchor = Point( -1, -1 );
delta = 0;
ddepth = -1;
 
    // 循环 - 以每个 0.5 秒不同的卷积核大小滤波图像
    int ind = 0;
    for(;;)
    {
        // 更新用于归一化框滤波的卷积核大小
kernel_size = 3 + 2*( ind%5 );
kernel = Mat::ones( kernel_size, kernel_size, CV_32F )/ (float)(kernel_size*kernel_size);
 
        // 应用滤波
filter2D(src, dst, ddepth , kernel, anchor, delta, BORDER_DEFAULT );
imshow( window_name, dst );
 
        char c = (char)waitKey(500);
        // 按下 'ESC' 退出程序
        if( c == 27 )
{ break; }
 
ind++;
    }
 
    return EXIT_SUCCESS;
}

Java

你还可以从这里下载

 
导入org.opencv.core.*;
导入org.opencv.core.Point;
导入org.opencv.highgui.HighGui;
导入org.opencv.imgcodecs.Imgcodecs;
导入org.opencv.imgproc.Imgproc;
 
类Filter2D_DemoRun {
 
    publicvoidrun(String[] args) {
        // 声明变量
Mat src, dst = 新Mat();
 
Mat kernel = 新Mat();
Point anchor;
        double delta;
        int ddepth;
        int kernel_size;
String window_name = "filter2D Demo";
 
String imageName = ((args.length > 0) ? args[0] : "../data/lena.jpg");
 
        // 加载图像
src = Imgcodecs.imread(imageName, Imgcodecs.IMREAD_COLOR);
 
        // 检查图像是否加载正常
        如果( src.empty() ) {
System.out.println("打开图像出错！");
System.out.println("程序参数： [图像名称 -- 默认 ../data/lena.jpg] \n");
System.exit(-1);
        }
 
        // 初始化用于滤波的参数
anchor = 新Point( -1, -1);
delta = 0.0;
ddepth = -1;
 
        // 循环 - 以每个 0.5 秒不同的卷积核大小滤波图像
        int ind = 0;
        while( true )
        {
            // 更新用于归一化框滤波的卷积核大小
kernel_size = 3 + 2*( ind%5 );
Mat ones = Mat.ones( kernel_size, kernel_size, CvType.CV_32F );
Core.multiply(ones, 新Scalar(1/(double)(kernel_size*kernel_size)), kernel);
 
            // 应用滤波
Imgproc.filter2D(src, dst, ddepth , kernel, anchor, delta, Core.BORDER_DEFAULT );
HighGui.imshow( window_name, dst );
 
            intc = HighGui.waitKey(500);
            // 按下 'ESC' 退出程序
            if( c == 27 )
{ break; }
 
ind++;
        }
 
System.exit(0);
    }
}
 
public类Filter2D_Demo {
    public静态voidmain(String[] args) {
        // 加载本地库。
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
        新Filter2D_DemoRun().run(args);
    }
}

Python

你还可以从这里下载

"""
@file filter2D.py
@brief 示例代码，展示了如何使用 filter2D 函数实现自己的线性滤波器
"""
导入sys
导入cv2 作为cv
导入numpy 作为np
 
 
函数main(argv)
window_name = 'filter2D Demo'
 
    
imageName = argv[0] 如果 len(argv) > 0 否则 'lena.jpg'
 
    # 加载图片
src = cv.imread(cv.samples.findFile(imageName), cv.IMREAD_COLOR)
 
    # 检查图片是否加载成功
    如果 src 是 None
        打印 ('打开图片时出错！')
        打印 ('用法：filter2D.py [图片名称 -- 默认 lena.jpg] \n')
        返回 -1
    
ddepth = -1
    
ind = 0
    当 真
        
kernel_size = 3 + 2 * (ind % 5)
kernel = np.ones((kernel_size, kernel_size), dtype=np.float32)
kernel /= (kernel_size * kernel_size)
        
dst = cv.filter2D(src, ddepth, kernel)
        
        cv.imshow(window_name, dst)
 
c = cv.waitKey(500)
        如果 c == 27
            退出
 
ind += 1
 
    返回 0
 
 
如果 __name__ == "__main__"
    main(sys.argv[1:])

解释

加载图像

C++

    const char* imageName = argc >=2 ? argv[1] : "lena.jpg";
 
    // 加载图像
src = imread( samples::findFile( imageName ), IMREAD_COLOR ); // 加载图像
 
    if( src.empty() )
    {
printf(" Error opening image\n");
printf(" Program Arguments: [image_name -- default lena.jpg] \n");
        return EXIT_FAILURE;
    }

Java

String imageName = ((args.length > 0) ? args[0] : "../data/lena.jpg");
 
        // 加载图像
src = Imgcodecs.imread(imageName, Imgcodecs.IMREAD_COLOR);
 
        // 检查图像是否加载正常
        如果( src.empty() ) {
System.out.println("打开图像出错！");
System.out.println("程序参数： [图像名称 -- 默认 ../data/lena.jpg] \n");
System.exit(-1);
        }

Python

imageName = argv[0] 如果 len(argv) > 0 否则 'lena.jpg'
 
    # 加载图片
src = cv.imread(cv.samples.findFile(imageName), cv.IMREAD_COLOR)
 
    # 检查图片是否加载成功
    如果 src 是 None
        打印 ('打开图片时出错！')
        打印 ('用法：filter2D.py [图片名称 -- 默认 lena.jpg] \n')
        返回 -1

初始化自变量

C++

    // 初始化用于滤波的参数
anchor = Point( -1, -1 );
delta = 0;
ddepth = -1;

Java

        // 初始化用于滤波的参数
anchor = 新Point( -1, -1);
delta = 0.0;
ddepth = -1;

Python

    # 初始化滤波器的 ddepth 自变量
ddepth = -1

循环

执行一个无限循环，更新内核大小，并将线性滤波器应用于输入图像。让我们更详细地分析一下

• 首先，我们定义了滤波器要使用的内核。如下所示

C++

        // 更新用于归一化框滤波的卷积核大小
kernel_size = 3 + 2*( ind%5 );
kernel = Mat::ones( kernel_size, kernel_size, CV_32F )/ (float)(kernel_size*kernel_size);

Java

            // 更新用于归一化框滤波的卷积核大小
kernel_size = 3 + 2*( ind%5 );
Mat ones = Mat.ones( kernel_size, kernel_size, CvType.CV_32F );
Core.multiply(ones, 新Scalar(1/(double)(kernel_size*kernel_size)), kernel);

Python

        # 更新归一化方框滤波的内核大小
kernel_size = 3 + 2 * (ind % 5)
kernel = np.ones((kernel_size, kernel_size), dtype=np.float32)
kernel /= (kernel_size * kernel_size)

第一行是将 kernel_size 更新为范围 [3,11] 内的奇数值。第二行通过将内核值设置为填充有\(1's\)的矩阵，并将其除以元素数量来构建内核。

• 设置内核后，我们可以用filter2D() 函数来生成滤波器

C++

        // 应用滤波
filter2D(src, dst, ddepth , kernel, anchor, delta, BORDER_DEFAULT );

Java

            // 应用滤波
Imgproc.filter2D(src, dst, ddepth , kernel, anchor, delta, Core.BORDER_DEFAULT );

Python

        # 应用滤波器
dst = cv.filter2D(src, ddepth, kernel)

• 参数说明
  • src：源图像
  • dst：目标图像
  • ddepth：dst 的深度。负值（如 \(-1\)) 表示深度和源图像相同。
  • kernel：在图像中扫描的内核
  • anchor：锚相对于内核的位置。默认情况下，位置 Point(-1, -1) 表示中心。
  • delta：在相关性过程中要添加到每个像素中的值。默认值为 \(0\)
  • BORDER_DEFAULT：我们让这个值成为默认值（详情请见以下教程）
• 我们的程序将执行一个 while 循环，每隔 500 毫秒滤波器的内核大小都会在指定的范围内进行更新。

结果

1. 编译完上面的代码后，您可以执行它并把图像的路径作为参数。结果应该是一个窗口，显示一张经过标准化滤波器模糊处理的图像。每隔 0.5 秒，内核大小应该改变，如下面的一系列快照所示