Java OpenCV filter2D

函数说明

该函数使用于任意线性滤波器的图像，支持就地操作。当其中心移动到图像外，函数可以根据指定的边界模式进行插值运算。函数实质上是计算kernel与图像的相关性而不是卷积：

也就是说kernel并不是中心点的镜像，如果需要一个正真的卷积，使用函数flip()并将中心点设置为(kernel.cols - anchor.x - 1, kernel.rows - anchor.y -1)

参数说明

Imgproc.filter2D(Mat src, Mat dst, int ddepth, Mat kernel, Point anchor, delta, int borderType);
src – 原图
dst – 目标图
ddepth – 目标图像深度，如果没写将生成与原图像深度相同的图像，ddepth为-1时,图像深度与源图像深度保持一致。原图像和目标图像支持的图像深度如下:

src.depth() = CV_8U, ddepth = -1/CV_16S/CV_32F/CV_64F
src.depth() = CV_16U/CV_16S, ddepth = -1/CV_32F/CV_64F
src.depth() = CV_32F, ddepth = -1/CV_32F/CV_64F
src.depth() = CV_64F, ddepth = -1/CV_64F

kernel – 卷积核（或者是相关核）,一个单通道浮点型矩阵。如果想在图像不同的通道使用不同的kernel，可以先使用split()函数将图像通道事先分开
anchor – 卷积核锚点。其默认值为(-1,-1)说明位于kernel的中心位置==>查看源码opencv-2.4.9/modules/imgproc/src/precomp.hpp

static inline Point normalizeAnchor( Point anchor, Size ksize )
{
	if( anchor.x == -1 )
	    anchor.x = ksize.width/2;
	if( anchor.y == -1 )
	    anchor.y = ksize.height/2;
	CV_Assert( anchor.inside(Rect(0, 0, ksize.width, ksize.height)) );
	return anchor;
}

很容易看到,(-1,-1)的时候,其实对应的是(ksize.width/2,ksize.height/2),也就是kernel的中心,所以默认情况为(-1,-1)时,是kernel center.
最后一句是判断语句,CV_Assert(val),若val为假则报错,inside函数是判断anchor是否在矩形内部,即anchor是不是within the kernel
delta – 额外加的数值,就是在卷积过程中该数值会添加到每个像素上，默认为0
borderType – 表示对边界的处理方式，默认值是BORDER_DEFAULT,即对全部边界进行计算
边界填充详细说明

/*
 Various border types, image boundaries are denoted with '|'
 * BORDER_REPLICATE:     aaaaaa|abcdefgh|hhhhhhh
 * BORDER_REFLECT:       fedcba|abcdefgh|hgfedcb
 * BORDER_REFLECT_101:   gfedcb|abcdefgh|gfedcba
 * BORDER_WRAP:          cdefgh|abcdefgh|abcdefg
 * BORDER_CONSTANT:      iiiiii|abcdefgh|iiiiiii  with some specified 'i'
 * 
 */

函数计算过程

内核（锚点设为中心，即图片的像素点与内核kernel(1,1)点对齐）
锚点位置作用

图像

边界处理
选用BORDER_DEFAULT，按上文介绍的填充规则填充：

计算过程
为方便说明这里先给出函数运算结果并用3x3的二维数组resultArr指代结果

首先看第resultArr[0][0],红色数字为内核

即resultArr[0][0] = 5*1 + 4*2 + 5*3 +
                             2*1 + 1*2 + 2*3 +
                             5*1 + 4*2 + 5*3
                             = 66
剩下的运算过程与上述步骤一样，使用代码来验证

import org.opencv.core.*;
import org.opencv.imgproc.Imgproc;

import java.util.Arrays;
import java.util.Stack;

public class OpencvTest {

    static{ System.loadLibrary(Core.NATIVE_LIBRARY_NAME); }
    
    	//内核
        Mat kernel = new Mat(new Size(3,3), CvType.CV_16SC1, new Scalar(255));
        kernel.put(0, 0, 1); kernel.put(0, 1, 2); kernel.put(0, 2, 3);
        kernel.put(1, 0, 1); kernel.put(1, 1, 2); kernel.put(1, 2, 3);
        kernel.put(2, 0, 1); kernel.put(2, 1, 2); kernel.put(2, 2, 3);

        //图片
        Mat src = new Mat(new Size(3,3), CvType.CV_8UC1, new Scalar(255));
        src.put(0, 0, 1); src.put(0, 1, 2); src.put(0, 2, 3);
        src.put(1, 0, 4); src.put(1, 1, 5); src.put(1, 2, 6);
        src.put(2, 0, 7); src.put(2, 1, 8); src.put(2, 2, 9);

        Mat dst = new Mat();
        Imgproc.filter2D(src, dst, -1, kernel, new Point(-1, -1), 0, Core.BORDER_DEFAULT);

        System.out.println("-------------filter2D结果------------------");
        for (int row = 0; row < dst.rows(); row++) {
            for (int col = 0; col < dst.cols(); col++) {
                System.out.print(dst.get(row, col)[0] + "    ");
            }
            System.out.println();
        }

        /*****************************************************************************************/

        //模拟内核
        int[][] kArr = {{1, 2, 3},
                        {1, 2, 3},
                        {1, 2, 3}};
        //模拟边界扩展后的图片
        int[][] sArr = {{5, 4, 5, 6, 5},
                        {2, 1, 2, 3, 2},
                        {5, 4, 5, 6, 5},
                        {8, 7, 8, 9, 8},
                        {5, 4, 5, 6, 5}};
        int[][] resultArr = new int[3][3];

        for (int i = 1; i < 4; i++) {
            for (int j = 1; j < 4; j++) {
                int sum = kArr[0][0] * sArr[i - 1][j -1] + kArr[0][1] * sArr[i - 1][j] + kArr[0][2] * sArr[i - 1][j + 1]
                        + kArr[1][0] * sArr[i][j - 1] + kArr[1][1] * sArr[i][j] + kArr[1][2] * sArr[i][j + 1]
                        + kArr[2][0] * sArr[i + 1][j - 1] + kArr[2][1] * sArr[i + 1][j] + kArr[2][2] * sArr[i + 1][j + 1];
                if (sum < 0) {
                    sum = 0;
                }
                else if (sum > 255){
                    sum = 255;
                }
                resultArr[i - 1][j - 1] = sum;
            }
        }

        System.out.println("-------------对比结果------------------");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(resultArr[i][j] + "   ");
            }
            System.out.println();
        }

    }

}

输出结果

-------------filter2D结果------------------
66.0    78.0    78.0    
84.0    96.0    96.0    
102.0    114.0    114.0    
-------------对比结果------------------
66   78   78   
84   96   96   
102   114   114   

注意点

内核的Mat的CvType的不同类型可能会导致结果不同。上述代码中使用的是CV_16SC1。
CvType说明

参考文章

https://blog.csdn.net/keith_bb/article/details/53103026

https://blog.csdn.net/u011028771/article/details/80160428

https://blog.csdn.net/qq_32846595/article/details/79057040

https://blog.csdn.net/qq_24946843/article/details/82429768