Java OpenCV Laplacian算子

最新推荐文章于 2023-08-07 11:44:51 发布
最新推荐文章于 2023-08-07 11:44:51 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangwenjie1997/article/details/101172186
版权

文章目录

Laplacian算子说明

普拉斯算子是最简单的各向同性微分算子，具有旋转不变性。一个二维图像函数 的拉普拉斯变换是各向同性的二阶导数，定义为：
在这里插入图片描述
在一个二维函数f(x,y)中，x,y两个方向的二阶差分分别为，
在这里插入图片描述
在这里插入图片描述
为了更适合于数字图像处理，将该方程表示为离散形式：
在这里插入图片描述
写成filter mask的形式如下，
在这里插入图片描述
       注意该(a)的mask的特点，mask在上下左右四个90度的方向上结果相同，也就是说在90度方向上无方向性。为了让该mask在45度的方向上也具有该性质，对该filter mask进行扩展定义为（b)。
       将Laplace算子写成filter mask后，其操作大同小异于其他的空间滤波操作。将filter mask在原图上逐行移动，然后mask中数值与其重合的像素相乘后求和，赋给与mask中心重合的像素，对图像的第一，和最后的行和列无法做上述操作的像素赋值零，就得到了拉普拉斯操作结果。

OpenCV Laplacian函数说明

函数介绍

Imgproc.Laplacian(Mar src, Mat dst, int ddepth, int ksize, double scale, double delta, int borderType);
src ：图片
dst ：目标图
ddepth ：目标图像的深度。因为输入图像一般为CV_8U，为了避免数据溢出，输出图像深度应该设置为CV_16S
ksize ： 内核尺寸
scale ： 计算Laplacian的时候可选的比例因子，默认为1。具体说明在下面讲述
delta ： 额外加的数值,就是在卷积过程中该数值会添加到每个像素上。具体说明在下面讲述
borderType ： 边界填充方式。默认BORDER_DEFAULT。边界填充说明

OpenCV Laplacian源码

下面的代码选自Opencv2.4.9源码文件opencv\sources\modules\imgproc\src文件夹下的deriv.cpp文件，该cpp文件中的Laplacian(…)函数源码，下面只显示了ksize=1or3的情况，

void cv::Laplacian( InputArray _src, OutputArray _dst, int ddepth, int ksize,
                    double scale, double delta, int borderType )
{
    Mat src = _src.getMat();
    if (ddepth < 0)
        ddepth = src.depth();
    _dst.create( src.size(), CV_MAKETYPE(ddepth, src.channels()) );
    Mat dst = _dst.getMat();

    if( ksize == 1 || ksize == 3 )
    {
        float K[2][9] =
        {{0, 1, 0, 1, -4, 1, 0, 1, 0},
         {2, 0, 2, 0, -8, 0, 2, 0, 2}};
        Mat kernel(3, 3, CV_32F, K[ksize == 3]);
        if( scale != 1 )
            kernel *= scale;
        filter2D( src, dst, ddepth, kernel, Point(-1,-1), delta, borderType );
    }else
    {
	    //ksize等于其他值的情况
    }
}

函数效果

代码

	public static void main(String[] args) {
	
        //读入图片
        Mat src = Imgcodecs.imread("G:\\opencvPhoto\\photo\\timg.jpg");
        //Laplacian算子对噪音敏感，事先去噪
        Imgproc.GaussianBlur(src, src, new Size(3, 3), 0);
        //灰度化
        Imgproc.cvtColor(src, src, Imgproc.COLOR_BGR2GRAY);
		Mat dst = new Mat();
        Imgproc.Laplacian(src, dst, CvType.CV_16S, 3, 1, 0, Core.BORDER_DEFAULT);
        Imgcodecs.imwrite("G:\\opencvPhoto\\result\\dst.jpg", dst);

    }

原图
在这里插入图片描述
效果
在这里插入图片描述

运行原理

  1. 以OpenCV的Laplacian内核大小为3时的内核为例
  2. filter2D函数说明
	public static void main(String[] args) {

        //读入图片
        Mat src = Imgcodecs.imread("G:\\opencvPhoto\\photo\\picture2.jpg");
        //Laplacian算子对噪音敏感，事先去噪
        Imgproc.GaussianBlur(src, src, new Size(3, 3), 0);
        //灰度化
        Imgproc.cvtColor(src, src, Imgproc.COLOR_BGR2GRAY);
		//OpenCV自带的Laplacian函数
        Mat temp = new Mat();
        Imgproc.Laplacian(src, temp, CvType.CV_16S, 3, 1, 0, Core.BORDER_DEFAULT);
  
		//手动实现
        //内核
        Mat kernel = new Mat(new Size(3,3), CvType.CV_32F, new Scalar(255));
        kernel.put(0, 0, 2); kernel.put(0, 1, 0); kernel.put(0, 2, 2);
        kernel.put(1, 0, 0); kernel.put(1, 1, -8); kernel.put(1, 2, 0);
        kernel.put(2, 0, 2); kernel.put(2, 1, 0); kernel.put(2, 2, 2);

        Mat dst = new Mat();
        Imgproc.filter2D(src, dst, CvType.CV_16S, kernel, new Point(-1, -1), 0, Core.BORDER_DEFAULT);
		
		//验证图片是否相同
        boolean flag = true;
        for (int row = 0; row < dst.rows(); row++) {
            for (int col = 0; col < dst.cols(); col++) {
                if (temp.get(row, col)[0] != dst.get(row, col)[0]) {
                    flag = false;
                    break;
                }
            }
            if (!flag) {
                break;
            }
        }
        System.out.println(flag);

    }

结果输出
在这里插入图片描述

OpenCV Laplacian 参数说明

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, 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 dst1 = new Mat();
        Imgproc.Laplacian(src, dst1, CvType.CV_16S, 1, 1, 0, Core.BORDER_DEFAULT);
        System.out.println("------------------scale=1---------------------");
        for (int row = 0; row < dst1.rows(); row++) {
            for (int col = 0; col < dst1.cols(); col++) {
                System.out.print(dst1.get(row, col)[0] + "   ");
            }
            System.out.println();
        }

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

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

    }

结果输出

------------------scale=1---------------------
8.0   6.0   4.0   
2.0   0.0   -2.0   
-4.0   -6.0   -8.0   
------------------scale=2---------------------
16.0   12.0   8.0   
4.0   0.0   -4.0   
-8.0   -12.0   -16.0   
------------------scale=3---------------------
24.0   18.0   12.0   
6.0   0.0   -6.0   
-12.0   -18.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, 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 dst1 = new Mat();
        Imgproc.Laplacian(src, dst1, CvType.CV_16S, 1, 1, 0, Core.BORDER_DEFAULT);
        System.out.println("------------------delta=0---------------------");
        for (int row = 0; row < dst1.rows(); row++) {
            for (int col = 0; col < dst1.cols(); col++) {
                System.out.print(dst1.get(row, col)[0] + "   ");
            }
            System.out.println();
        }

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

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

    }

结果输出

------------------delta=0---------------------
8.0   6.0   4.0   
2.0   0.0   -2.0   
-4.0   -6.0   -8.0   
------------------delta=1---------------------
9.0   7.0   5.0   
3.0   1.0   -1.0   
-3.0   -5.0   -7.0   
------------------delta=2---------------------
10.0   8.0   6.0   
4.0   2.0   0.0   
-2.0   -4.0   -6.0

结论：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, 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);

        //OpenCV自带的Laplacian函数
        Mat dst1 = new Mat();
        Imgproc.Laplacian(src, dst1, CvType.CV_16S, 1, 1, 0, Core.BORDER_DEFAULT);

        System.out.println("------------------scale=1,delta=0---------------------");
        for (int row = 0; row < dst1.rows(); row++) {
            for (int col = 0; col < dst1.cols(); col++) {
                System.out.print(dst1.get(row, col)[0] + "   ");
            }
            System.out.println();
        }

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

结果输出

------------------scale=1,delta=0---------------------
8.0   6.0   4.0   
2.0   0.0   -2.0   
-4.0   -6.0   -8.0   
------------------scale=2,delta=3---------------------
19.0   15.0   11.0   
7.0   3.0   -1.0   
-5.0   -9.0   -13.0

过程说明

8*2+3    6*2+3     4*2+3 
2*2+3    0*2+3    -2*2+3
-4*2+3   -6*2+3   -8*2+3

参考链接

https://www.cnblogs.com/polly333/p/7269843.html
https://blog.csdn.net/u010551600/article/details/80357267

取名为猫的狗
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
拉普拉斯差分隐私java实现
08-31
拉普拉斯差分隐私java实现
java opencv 清晰_Java Opencv 实现锐化
weixin_39979215的博客
02-26 299
§ Laplacian()void cv::Laplacian ( InputArray src,OutputArray dst,int ddepth,int ksize = 1,double scale = 1,double delta = 0,int borderType = BORDER_DEFAULT)参数：src...
Laplacian算子（拉普拉斯算子）
u013250861的博客
06-06 4209
定义：拉普拉斯算子是n维欧几里德空间中的一个二阶微分算子，是用二阶差分来计算图像的边缘。 拉普拉斯算子是一种各向同性微分算子，它具有旋转不变性。laplace算子是一种高通滤波器，用来保留图像的高频分量（变化剧烈的部分），抑制图像的低频分量（变化缓慢的部分），所以可以用来检测边缘。拉普拉斯算子 (Laplace) 作用：参考资料： 拉普拉斯算子Laplace 5.4.4 边缘检测-拉普拉斯算子 传统经典CV算法_拉普拉斯算子详解...
java 拉普拉斯_opencv3_java 图形图像的拉普拉斯平滑Laplacian Laplacian
weixin_30072693的博客
02-28 123
图形图像的拉普拉斯平滑Laplacian Laplacianpackage opencv_java_demo;import org.opencv.core.*;import org.opencv.imgcodecs.*;import org.opencv.imgproc.Imgproc;public class Laplacian {public static void main(String[]...
[OpenCV学习日记-java]-09-梯度计算和拉普拉斯算子
Timeless小帅的博客
01-23 827
梯度计算和拉普拉斯算子 计算机图像梯度是很多重要特征提取的关键步骤之一,OpenCV提供了两个非常重要的计算梯度函数Sobel与Scharr 对于图像边缘部分,梯度值会比较大,对于图像的平坦区域梯度值一般比较小 Sobel梯度 Sobel梯度算子可以计算X方向和Y方向Api如下: Sobel(Mat src, Mat dst, int ddepth, int dx, int dy) src：...
opencv基础43- 图像梯度-Laplacian 算子（ cv2.Laplacian）边缘检测基础
小海聊智造
08-07 1918
Sobel 算子、Scharr 算子、Laplacian 算子都可以用作边缘检测，它们的核如图 9-29 所示。Sobel 算子和 Scharr 算子计算的都是一阶近似导数的值。Sobel 算子= |左-右| / |下-上|Scharr 算子= |左-右| / |下-上|式中“|左-右|”表示左侧像素值减右侧像素值的结果的绝对值，“|下-上|”表示下方像素值减上方像素值的结果的绝对值。像素值的结果的绝对值。Laplacian 算子= |左-右| + |左-右| + |下-上| + |下-上|
Opencv之图像边缘检测：3.Laplacian算子（cv2.Laplacian）
热门推荐
qq_49478668的博客
03-29 2万+
Laplacian（拉普拉斯）算子是一种二阶导数算子，其具有旋转不变性，可以满足不同 方向的图像边缘锐化（边缘检测）的要求。
06 Laplacian算法
CSDN_Yangk的博客
03-30 1923
实现laplician算子
（七）图像处理中常用算子Laplacian\Sobel\Roberts\Prewitt\Kirsch
机器人视觉感知
01-28 6388
1.拉普拉斯(Laplacian)算子 1.1基础介绍 最简单的各向同性导数算子是拉普赖斯算子，其具有旋转不变性，对于两个变量的函数f(x,y)f(x,y)f(x,y),其定义为 ▽2f=∂2f∂x2+∂2f∂y2\triangledown^2f=\frac{\partial ^2f}{\partial x ^2} + \frac{\partial ^2f}{\partial y ^2}▽2f=∂x2∂2f​+∂y2∂2f​,以离散形式表示上述公式为： <br/>x方向有：$\frac{\par
9.5 laplacian算子及使用
liupc的学习笔记
08-18 5108
点击此处返回总目录 一、laplacian算子介绍 首先我们回顾一下前面讲的sobel和scharr算子。 sobel和scharr都是下面减上面或者右边减左边。实际上他们都是计算的一次，也就是下面...
OpenCV之Laplacian算子
01-07
Laplacian算子也是计算图像梯度的一个利器。它相当于二阶Sobel算子的导数。咋来的不再从这里做解释，我们知道怎么用就行了。 Laplacian算子的卷积核是这样的： 其构造函数如下： cv2.Laplacian(src,ddepth) src：...
Laplacian算子 OpenCV
01-26
算法
opencv snake算子子源码
08-31
opencv cvSnakeImage算子使用方法实列，可以实现轮廓的毕竟提取
OpenCV边缘检测算子
12-18
基于opencv2.4.7和vs2010开发环境的图像处理，用于图像处理的边缘检测，其中用到了拉普拉斯算子，Scharr算子，检测所得图像为彩色。
(一)OpenCV图像处理基础_17_Laplacian算子
01-06
Laplacian算子 二阶导数的时候，最大变化处的值为零即边缘是零值。 通过二阶导数计算，依据此理论我们可以计算图像二阶导数，提取边缘。 #include #include using namespace std; using namespace cv; int main(int...
二值化-大津法（OTSU）
取名为猫的狗的博客
09-20 8809
论文 Otsu N . A Threshold Selection Method from Gray-Level Histograms[J]. IEEE Transactions on Systems, Man, and Cybernetics, 1979, 9(1):62-66. 算法介绍 OTSU算法也称最大类间差法，有时也称之为大津算法，由大津于1979年提出，被认为是图像分割中阈值选取的最...
java IDEA配置OpenCV
取名为猫的狗的博客
03-24 7223
OpenCV下载 下载地址：https://www.opencv.org/releases.html 选择版本和对应的操作系统进行下载 下载完成后选择目录解压 IDEA配置 1.创建一个java项目获得如下目录结构 2.创建一个文件夹opencv并将解压的OpenCV中\opencv\build\java中的文件复制进去获得如下目录结构 3.导入jar包 ，按下图顺序点击选择选择OpenCV的...
Java OpenCV findContours函数RETR_EXTERNAL轮廓顺序
取名为猫的狗的博客
08-30 5345
findContours函数说明 https://blog.csdn.net/marooon/article/details/81332487 RETR_EXTERNAL：只检测最外围的轮廓 坐标系说明 以屏幕左上角为坐标原点，左右为X轴，上下为Y轴，其中自左向右X坐标逐渐增大，自上向下Y坐标逐渐增大，如下图所示。 坐标系说明图 测试代码 //读入图片 Mat src = Imgcodecs...
Java OpenCV findContours函数RETR_CCOMP轮廓顺序
取名为猫的狗的博客
08-30 5073
findContours函数说明 https://blog.csdn.net/marooon/article/details/81332487 https://blog.csdn.net/tanmx219/article/details/84973542 RETR_CCOMP：检测所有轮廓，但所有轮廓都只建立两个等级关系（简单的说就是检测双层轮廓） 坐标系说明 以屏幕左上角为坐标原点，左右为X轴，...
opencv laplacian算子
最新发布
02-21
OpenCV中的Laplacian算子是一种常用的图像处理算法，用于检测图像中的边缘和纹理信息。它是一种二阶微分算子，可以通过计算图像的二阶导数来实现。 Laplacian算子可以通过以下方式在OpenCV中使用： 1. 首先，导入OpenCV库：`import cv2` 2. 读取图像：`image = cv2.imread('image.jpg', 0)`，其中参数0表示以灰度图像的形式读取。 3. 对图像应用Laplacian算子：`laplacian = cv2.Laplacian(image, ddepth, ksize)`，其中`ddepth`表示输出图像的深度，通常设置为-1以保持与输入图像相同的深度。`ksize`表示Laplacian算子的卷积核大小，常用的取值为1、3、5等。 4. 可选地，对输出图像进行阈值处理或其他后处理操作。 下面是一些相关问题：

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值