Explain the opencv function filter2d() in detail and remind you that the operation it does is not convolution but correlation operation

Convolution and correlation are two basic linear operations in our image processing , so to speak , Most algorithms in image processing , Especially, the algorithms related to filtering are based on these two operations .

About images ( matrix ) Detailed knowledge of convolution and related operations , You can refer to the blog post https://blog.csdn.net/wenhao_ir/article/details/124109222

MATLAB Provides functions imfilter() Implement support for these two operations , The syntax is as follows ：

B = imfilter(A,h)
B = imfilter(A,h,options,...)

options The optional values of are as follows ：

So when we need to do convolution, we can write as follows ：

imfilter(A,h,'conv')

When we need to do relevant operations, we can write as follows ：

imfilter(A,h,'corr')

OpenCV As a powerful tool for image processing , Naturally, there is no lack of support for these two operations .
OpenCV Provides functions filter2D() Make image ( matrix ) Related operations , Note that it is a correlation operation , Instead of convolution .

Its formula is as follows ：

$\text{dst}(x,y)={\sum }_{\stackrel{0\le x^{\prime }<\text{kernel.cols},}{0\le y^{\prime }<\text{kernel.rows}}}\text{kernel}(x^{\prime },y^{\prime })\ast \text{src}(x+x^{\prime }-\text{anchor.x},y+y^{\prime }-\text{anchor.y})$

The above formula looks very complicated , In fact, it is a blog https://blog.csdn.net/wenhao_ir/article/details/124109222 The formulaic expression of the related operations introduced in . Formula anchor representative kernel Anchor point of core , Introduction to anchor points , You can refer to my blog https://blog.csdn.net/wenhao_ir/article/details/124173092
If you can understand the concepts of related operations and anchor points by reading the above two blog posts , Then this formula is not difficult to understand .

So what if we have to do convolution ？
According to the definition of convolution , We rotate the nucleus 180 The degree correlation operation is the convolution operation . So how to rotate the nucleus 180 Degree ？ According to the blog https://blog.csdn.net/wenhao_ir/article/details/51443330 We know that the matrix 180 Degree is equivalent to making a horizontal mirror image first , Make another vertical mirror image , We can use the function to mirror the matrix flip() complete , function flip() The prototype is as follows ：

void cv::flip(InputArray src, OutputArray dst, int flipCode)	

See the blog for an example of using this function https://blog.csdn.net/wenhao_ir/article/details/51442792
We just need to put the parameters flipCode The value of is written as a negative value , The matrix can be 180 The rotation of the degree of .

Next, let's look at the function filter2D() The prototype of the ：
C++ The prototype is as follows ：

void cv::filter2D(	InputArray 	src,
					OutputArray dst,
					int 	ddepth,
					InputArray 	kernel,
					Point 	anchor = Point(-1,-1),
					double 	delta = 0,
					int 	borderType = BORDER_DEFAULT)	

Python The prototype is as follows ：

dst	= cv.filter2D(src, ddepth, kernel[, dst[, anchor[, delta[, borderType]]]])

The meanings of the parameters are as follows ：
src— The input image
dst— Target image
ddepth— The data depth of the target image
kernel— The kernel of correlation operation
anchor—kernel The anchor point
delta— Offset processing of operation results , For example, the correlation result of a pixel is 1,delta=2, Then the final value of this pixel in the target image is 1+2=3.
borderType— Boundary extension flag bit , About boundary extension , You can refer to the blog https://blog.csdn.net/wenhao_ir/article/details/124177989

The sample code is as follows ：

#  Blogger WeChat /QQ 2487872782
#  If you have any questions, you can contact the blogger 
#  Please contact the blogger if you need image processing 
#  Image processing technology exchange QQ Group  271891601

# !/usr/bin/env python
# -*- coding: utf-8 -*-
# OpenCV The version is 4.1

import numpy as np
import cv2 as cv

A1 = np.array([[1, 1, 7, 3],
              [5, 5, 2, 7],
              [9, 9, 6, 1],
              [7, 7, 4, 9]], dtype='uint8')

kernel1 = np.array([[1, 1, 1],
                    [1, 1, 1],
                    [1, 1, 1]], dtype='uint8')

B1 = cv.filter2D(A1, cv.CV_8U, kernel1, anchor=(0, 0), borderType=cv.BORDER_CONSTANT)

B2 = cv.filter2D(A1, cv.CV_8U, kernel1, anchor=(-1, -1), borderType=cv.BORDER_CONSTANT)

The operation results are as follows ：



Result analysis ：B1 and B2 The difference is that the anchor points of the core are different ,B1 Using the dot in the upper left corner of the nucleus ,B2 Using the center point of the nucleus . The boundary expansion method is fill 0 Value processing .
The results of manual verification are as follows ：

B1[0,0]=1*1+1*1+7*1+5*1+5*1+2*1+9*1+9*1+6*1=45

B1[0,3]=0*1+0*1+0*1+7*1+3*1+0*1+2*1+7*1+0*1=11

so ,B1 The manual results are consistent with the results of the program running .

Look again. B2：

B2[0,0]=0*1+0*1+0*1+0*1+1*1+1*1+0*1+5*1+5*1=12

B2[0,3]=0*1+0*1+0*1+0*1+1*1+1*1+0*1+5*1+5*1=19

so ,B12 The manual result of is also consistent with the result of program running .

Additional explanation ：
function filter2D() And support in-place operation( Local operation ) Oh , For details about this operation, see the blog https://blog.csdn.net/wenhao_ir/article/details/125211437