Java OpenCV Sobel

最新推荐文章于 2024-06-12 22:29:40 发布

取名为猫的狗

最新推荐文章于 2024-06-12 22:29:40 发布

阅读量834

点赞数 1

分类专栏： opencv

本文链接：https://blog.csdn.net/wangwenjie1997/article/details/101123451

版权

opencv 专栏收录该内容

33 篇文章 5 订阅

订阅专栏

文章目录

Sobel算子介绍
OpenCV的Sobel函数介绍
函数使用
函数实现
OpenCV Sobel 参数说明
参考链接
扩展链接

Sobel算子介绍

索贝尔算子（Sobel operator）主要用作边缘检测，在技术上，它是一离散性差分算子，用来运算图像亮度函数的灰度之近似值。在图像的任何一点使用此算子，将会产生对应的灰度矢量或是其法矢量。

Sobel卷积因子为：
在这里插入图片描述
该算子包含两组3x3的矩阵，分别为横向及纵向，将之与图像作平面卷积，即可分别得出横向及纵向的亮度差分近似值。如果以A代表原始图像，Gx及Gy分别代表经横向及纵向边缘检测的图像灰度值，其公式如下：
在这里插入图片描述
具体运算为：

Gx = (-1)*f(x-1, y-1) + 0*f(x,y-1) + 1*f(x+1,y-1)
	+(-2)*f(x-1,y) + 0*f(x,y)+2*f(x+1,y)
	+(-1)*f(x-1,y+1) + 0*f(x,y+1) + 1*f(x+1,y+1)
	= [f(x+1,y-1)+2*f(x+1,y)+f(x+1,y+1)]-[f(x-1,y-1)+2*f(x-1,y)+f(x-1,y+1)]

Gy =1* f(x-1, y-1) + 2*f(x,y-1)+ 1*f(x+1,y-1)
	+0*f(x-1,y) 0*f(x,y) + 0*f(x+1,y)
	+(-1)*f(x-1,y+1) + (-2)*f(x,y+1) + (-1)*f(x+1, y+1)
	= [f(x-1,y-1) + 2f(x,y-1) + f(x+1,y-1)]-[f(x-1, y+1) + 2*f(x,y+1)+f(x+1,y+1)]

由上述公式计算得到Gy和Gx后，可以计算得到G的值，一个点的G的代表该点的梯度，如果大于某一设定范围则认为该点是边缘点。
在这里插入图片描述
为了提高效率使用不开平方的近似值：

如果梯度G大于某一阀值则认为该点(x,y)为边缘点

Sobel算子根据像素点上下、左右邻点灰度加权差，在边缘处达到极值这一现象检测边缘。对噪声具有平滑作用，提供较为精确的边缘方向信息，边缘定位精度不够高。当对精度要求不是很高时，是一种较为常用的边缘检测方法。

OpenCV的Sobel函数介绍

Imgproc.Sobel(Mat src, Mat dst, int ddepth, int dx, int dy, int ksize, double scale, double delta, int borderType)
src：图像
dst：目标图
ddepth：输出图像的深度。针对不同的输入图像，输出目标图像有不同的深度，具体组合如下：

若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

dx：x方向上的差分阶数
dy：y方向上的差分阶数
ksize：sobel核的大小，默认为3。具体说明在下面讲述
scale：缩放因子。是sobel过滤内核因子的缩放因子。而非对影像进行的缩放因子。具体说明在下面讲述
delta：额外加的数值,就是在卷积过程中该数值会添加到每个像素上。具体说明在下面讲述
borderType：边界填充模式，默认BORDER_DEFAULT。边界填充说明

函数使用

	public static void main(String[] args) {
        //读入图片
        Mat src = Imgcodecs.imread("G:\\opencvPhoto\\photo\\picture2.jpg");
        //灰度化
        Imgproc.cvtColor(src, src, Imgproc.COLOR_BGR2GRAY);
        //横向
        Mat gray_x = new Mat();
        Imgproc.Sobel(src, gray_x, -1, 1, 0, 3, 1, 0, Core.BORDER_DEFAULT);
        Imgcodecs.imwrite("G:\\opencvPhoto\\result\\gray_x.jpg", gray_x);
        //竖向
        Mat gray_y = new Mat();
        Imgproc.Sobel(src, gray_y, -1, 0, 1, 3, 1, 0, Core.BORDER_DEFAULT);
        Imgcodecs.imwrite("G:\\opencvPhoto\\result\\gray_y.jpg", gray_y);
        //横竖向图像融合
        Mat gray_xy = new Mat();
        Core.addWeighted(gray_x, 0.5, gray_y, 0.5, 0, gray_xy);
        Imgcodecs.imwrite("G:\\opencvPhoto\\result\\gray_xy.jpg", gray_xy);
    }

原图
在这里插入图片描述
横向

竖向

横竖融合

函数实现

以横向为例
filter2D原理

public static void main(String[] args) {
        OpencvTest opencvTest = new OpencvTest();
        //读入图片
        Mat src = Imgcodecs.imread("G:\\opencvPhoto\\photo\\picture2.jpg");
        //灰度化
        Imgproc.cvtColor(src, src, Imgproc.COLOR_BGR2GRAY);
        
        //对比图
        Mat temp = src.clone();

        //sobel横向内核
        Mat kernelX = new Mat(new Size(3,3), CvType.CV_32F, new Scalar(255));
        kernelX.put(0, 0, -1); kernelX.put(0, 1, 0); kernelX.put(0, 2, 1);
        kernelX.put(1, 0, -2); kernelX.put(1, 1, 0); kernelX.put(1, 2, 2);
        kernelX.put(2, 0, -1); kernelX.put(2, 1, 0); kernelX.put(2, 2, 1);

        //自己实现Sobel横向
        Mat dst = new Mat();
        Imgproc.filter2D(src, dst, -1, kernelX, new Point(-1, -1), 0, Core.BORDER_DEFAULT);
        Core.convertScaleAbs(dst, dst, 1, 0);

        //OpenCV Sobel横向
        Imgproc.Sobel(temp, temp, -1, 1, 0, 3, 1, 0, Core.BORDER_DEFAULT);

        //结果图对比
        boolean flag = true;
        for (int row = 0; row < src.rows(); row++) {
            for (int col = 0; col < src.cols(); col++) {
                if (dst.get(row, col)[0] != temp.get(row, col)[0]) {
                    flag = false;
                    break;
                }
            }
            if (!flag){

                break;
            }
        }
        System.out.println(flag);

    }

结果输出
true

OpenCV Sobel 参数说明

ksize

ksize<0：那么使用scharr内核过滤因子。scharr的内核过滤因子大小为3。dx大于等于0，dy大于等于0，并且dx+dy==1
X方向的内核因子为：
在这里插入图片描述
Y方向的内核因子为

ksize>0 : ksize必须为奇数，并且大小应该小于31
当 ( xorder = 1, yorder = 0, ksize = 3) 时，内核因子（即：X方向的检测因子）为：

当 ( xorder = 0, yorder = 1, ksize = 3) 时，内核因子（即Y方向上检测因子）为：
在这里插入图片描述
当 ( xorder = 1, yorder = 0, ksize = 5) 时，内核因子（即X方向上检测因子）为：

scale

	public static void main(String[] args) {

        //图片
        Mat src = new Mat(new Size(3, 3), CvType.CV_8UC1);
        src.put(0, 0, 1); src.put(0, 1, 2); src.put(0, 2, 3);
        src.put(1, 0, 1); src.put(1, 1, 2); src.put(1, 2, 3);
        src.put(2, 0, 1); src.put(2, 1, 2); src.put(2, 2, 3);


        Mat sobel1 = new Mat();
        Imgproc.Sobel(src, sobel1, -1, 1, 0, 3, 1, 0, Core.BORDER_DEFAULT);
        System.out.println("--------------scale=1---------------");
        for (int row = 0; row < sobel1.rows(); row++) {
            for (int col = 0; col < sobel1.cols(); col++) {
                System.out.print((int)sobel1.get(row, col)[0] + "   ");
            }
            System.out.println();
        }

        Mat sobel2 = new Mat();
        Imgproc.Sobel(src, sobel2, -1, 1, 0, 3, 2, 0, Core.BORDER_DEFAULT);
        System.out.println("--------------scale=2---------------");
        for (int row = 0; row < sobel2.rows(); row++) {
            for (int col = 0; col < sobel2.cols(); col++) {
                System.out.print((int)sobel2.get(row, col)[0] + "   ");
            }
            System.out.println();
        }
        //delta = 1
        Mat sobel3 = new Mat();
        Imgproc.Sobel(src, sobel3, -1, 1, 0, 3, 3, 0, Core.BORDER_DEFAULT);
        System.out.println("--------------scale=3---------------");
        for (int row = 0; row < sobel3.rows(); row++) {
            for (int col = 0; col < sobel3.cols(); col++) {
                System.out.print((int)sobel3.get(row, col)[0] + "   ");
            }
            System.out.println();
        }

    }

结果输出

--------------scale=1---------------
0   8   0   
0   8   0   
0   8   0   
--------------scale=2---------------
0   16   0   
0   16   0   
0   16   0   
--------------scale=3---------------
0   24   0   
0   24   0   
0   24   0

结论：scale为目标图片在计算后得出的结果上再翻scale倍

delta

测试代码
以横向为例

public static void main(String[] args) {

        //图片
        Mat src = new Mat(new Size(3, 3), CvType.CV_8UC1);
        src.put(0, 0, 1); src.put(0, 1, 2); src.put(0, 2, 3);
        src.put(1, 0, 1); src.put(1, 1, 2); src.put(1, 2, 3);
        src.put(2, 0, 1); src.put(2, 1, 2); src.put(2, 2, 3);

        //delta = -1
        Mat sobel1 = new Mat();
        Imgproc.Sobel(src, sobel1, -1, 1, 0, 3, 1, -1, Core.BORDER_DEFAULT);
        System.out.println("--------------delta = -1---------------");
        for (int row = 0; row < sobel1.rows(); row++) {
            for (int col = 0; col < sobel1.cols(); col++) {
                System.out.print((int)sobel1.get(row, col)[0] + "   ");
            }
            System.out.println();
        }
        //delta =0
        Mat sobel2 = new Mat();
        Imgproc.Sobel(src, sobel2, -1, 1, 0, 3, 1, 0, Core.BORDER_DEFAULT);
        System.out.println("--------------delta = 0---------------");
        for (int row = 0; row < sobel2.rows(); row++) {
            for (int col = 0; col < sobel2.cols(); col++) {
                System.out.print((int)sobel2.get(row, col)[0] + "   ");
            }
            System.out.println();
        }
        //delta = 1
        Mat sobel3 = new Mat();
        Imgproc.Sobel(src, sobel3, -1, 1, 0, 3, 1, 1, Core.BORDER_DEFAULT);
        System.out.println("--------------delta = 1---------------");
        for (int row = 0; row < sobel3.rows(); row++) {
            for (int col = 0; col < sobel3.cols(); col++) {
                System.out.print((int)sobel3.get(row, col)[0] + "   ");
            }
            System.out.println();
        }

    }

结果输出
为0是因为Mat的值>=0

--------------delta = -1---------------
0   7   0   
0   7   0   
0   7   0   
--------------delta = 0---------------
0   8   0   
0   8   0   
0   8   0   
--------------delta = 1---------------
1   9   1   
1   9   1   
1   9   1

结论：delta为目标图片在计算后得出的结果上再加delta

scale和delta综合验证

public static void main(String[] args) {
        //图片
        Mat src = new Mat(new Size(3, 3), CvType.CV_8UC1);
        src.put(0, 0, 1); src.put(0, 1, 2); src.put(0, 2, 3);
        src.put(1, 0, 1); src.put(1, 1, 2); src.put(1, 2, 3);
        src.put(2, 0, 1); src.put(2, 1, 2); src.put(2, 2, 3);

        Mat sobel1 = new Mat();
        Imgproc.Sobel(src, sobel1, -1, 1, 0, 3, 1, 0, Core.BORDER_DEFAULT);
        System.out.println("--------------scale=1,delta=0---------------");
        for (int row = 0; row < sobel1.rows(); row++) {
            for (int col = 0; col < sobel1.cols(); col++) {
                System.out.print((int)sobel1.get(row, col)[0] + "   ");
            }
            System.out.println();
        }

        Mat sobel2 = new Mat();
        Imgproc.Sobel(src, sobel2, -1, 1, 0, 3, 2, 3, Core.BORDER_DEFAULT);
        System.out.println("--------------scale=2,delta=3---------------");
        for (int row = 0; row < sobel2.rows(); row++) {
            for (int col = 0; col < sobel2.cols(); col++) {
                System.out.print((int)sobel2.get(row, col)[0] + "   ");
            }
            System.out.println();
        }

    }

结果输出

--------------scale=1,delta=0---------------
0   8   0   
0   8   0   
0   8   0   
--------------scale=2,delta=3---------------
3   19   3   
3   19   3   
3   19   3

过程说明

0*2+3   8*2+3  0*2+3
0*2+3   8*2+3  0*2+3
0*2+3   8*2+3  0*2+3

参考链接

https://blog.csdn.net/zhanggusheng/article/details/88936232
https://blog.csdn.net/m1109048058/article/details/77411373

扩展链接

核旋转效果

取名为猫的狗

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Java OpenCV Sobel

Sobel算子介绍索贝尔算子（Sobel operator）主要用作边缘检测，在技术上，它是一离散性差分算子，用来运算图像亮度函数的灰度之近似值。在图像的任何一点使用此算子，将会产生对应的灰度矢量或是其法矢量。Sobel卷积因子为：该算子包含两组3x3的矩阵，分别为横向及纵向，将之与图像作平面卷积，即可分别得出横向及纵向的亮度差分近似值。如果以A代表原始图像，Gx及Gy分别代表经横向及纵向...
复制链接

扫一扫