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

目录

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

上一教程： 使用 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(" 错误：无法打开图像\n");
printf(" 程序参数: [图像名称 -- 默认 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("错误：无法打开图像！");
System.out.println("程序参数: [图像名称 -- 默认 ../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)
 
    # Check if image is loaded fine
    if src is None
        print ('错误：无法打开图像！')
        print ('用法: filter2D.py [图像名称 -- 默认 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(" 错误：无法打开图像\n");
printf(" 程序参数: [图像名称 -- 默认 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("错误：无法打开图像！");
System.out.println("程序参数: [图像名称 -- 默认 ../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)
 
    # Check if image is loaded fine
    if src is None
        print ('错误：无法打开图像！')
        print ('用法: filter2D.py [图像名称 -- 默认 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 秒，核大小都会改变，如下面的系列快照所示。