创建你自己的线性滤波器！

目录

• 目标
• 理论
  • 相关性
  • 什么是核？
  • 核的相关性是如何工作的？
  • 这个程序做什么？
• 代码
• 解释
  • 加载图像
  • 初始化参数
  • 循环
• 结果

上一教程： 使用 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

您也可以从 这里 下载。

 
import org.opencv.core.*;
import org.opencv.core.Point;
import org.opencv.highgui.HighGui;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;
 
class Filter2D_DemoRun {
 
    public void run(String[] args) {
        // 声明变量
Mat src, dst = new Mat();
 
Mat kernel = new 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);
 
        // 检查图像是否加载正常
        if( src.empty() ) {
System.out.println("Error opening image!");
System.out.println("Program Arguments: [image_name -- default ../data/lena.jpg] \n");
System.exit(-1);
        }
 
        // 初始化滤波器参数
anchor = new 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, new Scalar(1/(double)(kernel_size*kernel_size)), kernel);
 
            // 应用滤波器
Imgproc.filter2D(src, dst, ddepth , kernel, anchor, delta, Core.BORDER_DEFAULT );
HighGui.imshow( window_name, dst );
 
            int c = HighGui.waitKey(500);
            // 按下 'ESC' 退出程序
            if( c == 27 )
{ break; }
 
ind++;
        }
 
System.exit(0);
    }
}
 
public class Filter2D_Demo {
    public static void main(String[] args) {
        // 加载原生库。
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
        new Filter2D_DemoRun().run(args);
    }
}

Python

您也可以从 这里 下载

"""
@file filter2D.py
@brief 示例代码，展示如何使用 filter2D 函数实现自己的线性滤波器
"""
import sys
import cv2 as cv
import numpy as np
 
 
def main(argv)
window_name = 'filter2D Demo'
 
    
imageName = argv[0] if len(argv) > 0 else 'lena.jpg'
 
    # 加载图像
src = cv.imread(cv.samples.findFile(imageName), cv.IMREAD_COLOR)
 
    # 检查图像是否加载成功
    if src is None
        print ('Error opening image!')
        print ('Usage: filter2D.py [image_name -- default lena.jpg] \n')
        return -1
    
ddepth = -1
    
ind = 0
    while True
        
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)
        if c == 27
            break
 
ind += 1
 
    return 0
 
 
if __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);
 
        // 检查图像是否加载正常
        if( src.empty() ) {
System.out.println("Error opening image!");
System.out.println("Program Arguments: [image_name -- default ../data/lena.jpg] \n");
System.exit(-1);
        }

Python

imageName = argv[0] if len(argv) > 0 else 'lena.jpg'
 
    # 加载图像
src = cv.imread(cv.samples.findFile(imageName), cv.IMREAD_COLOR)
 
    # 检查图像是否加载成功
    if src is None
        print ('Error opening image!')
        print ('Usage: filter2D.py [image_name -- default lena.jpg] \n')
        return -1

初始化参数

C++

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

Java

        // 初始化滤波器参数
anchor = new Point( -1, -1);
delta = 0.0;
ddepth = -1;

Python

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, new 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的矩阵并将其除以元素个数进行归一化来构建卷积核。

• 设置好卷积核后，我们可以使用函数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秒，卷积核大小应该改变，如下面的系列快照所示