拉普拉斯算子

目录

• 目标
• 理论
  • 拉普拉斯算子
• 代码
• 解释
  • 声明变量
  • 加载源图像
  • 降噪
  • 灰度化
  • 拉普拉斯算子
  • 将输出转换为 <em>CV_8U</em> 图像
  • 显示结果
• 结果

上一个教程： Sobel 导数
下一个教程： Canny 边缘检测器

原始作者	Ana Huamán
兼容性	OpenCV >= 3.0

目标

在本教程中，您将学习如何

• 使用 OpenCV 函数 Laplacian() 实现 *拉普拉斯算子* 的离散模拟。

理论

1. 在上一教程中，我们学习了如何使用 *Sobel 算子*。其原理是，在边缘区域，像素强度会显示出“跳跃”或剧烈变化。获取强度的第一个导数时，我们观察到边缘的特征是出现最大值，如下图所示

1. 那么……如果我们取二阶导数会发生什么呢？

您会发现二阶导数为零！因此，我们也可以使用此标准来尝试检测图像中的边缘。但是，请注意零点不仅会出现在边缘（它们实际上也可能出现在其他无意义的位置）；这可以通过在需要时应用滤波来解决。

拉普拉斯算子

1. 从上面的解释中，我们可以推断出二阶导数可以用于 *检测边缘*。由于图像是“2D”的，我们需要在两个维度上取导数。在这里，拉普拉斯算子就派上用场了。

2. 拉普拉斯算子 定义为

   \[Laplace(f) = \dfrac{\partial^{2} f}{\partial x^{2}} + \dfrac{\partial^{2} f}{\partial y^{2}}\]

3. 拉普拉斯算子在 OpenCV 中通过函数 Laplacian() 实现。事实上，由于拉普拉斯算子使用了图像的梯度，它在内部调用 *Sobel* 算子来执行其计算。

代码

1. 此程序的作用是什么？
   • 加载图像
   • 通过应用高斯模糊来去除噪声，然后将原始图像转换为灰度图
   • 将拉普拉斯算子应用于灰度图像并存储输出图像
   • 在窗口中显示结果

C++

1. 教程代码如下所示。您也可以从此处下载。

    
   #include "opencv2/imgproc.hpp"
   #include "opencv2/imgcodecs.hpp"
   #include "opencv2/highgui.hpp"
    
   using namespace cv;
    
   int main( int argc, char** argv )
   {
       // Declare the variables we are going to use
       Mat src, src_gray, dst;
       int kernel_size = 3;
       int scale = 1;
       int delta = 0;
       int ddepth = CV_16S;
       const char* window_name = "Laplace Demo";
    
       const char* imageName = argc >=2 ? argv[1] : "lena.jpg";
    
   src = imread( samples::findFile( imageName ), IMREAD_COLOR ); // Load an image
    
       // 检查图像是否加载成功
       if(src.empty()){
   printf(" Error opening image\n");
   printf(" Program Arguments: [image_name -- default lena.jpg] \n");
           return -1;
       }
    
       // Reduce noise by blurring with a Gaussian filter ( kernel size = 3 )
   GaussianBlur( src, src, Size(3, 3), 0, 0, BORDER_DEFAULT );
    
   cvtColor( src, src_gray, COLOR_BGR2GRAY ); // Convert the image to grayscale
    
       Mat abs_dst;
   Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, BORDER_DEFAULT );
    
       // 转换回 CV_8U
   convertScaleAbs( dst, abs_dst );
    
   imshow( window_name, abs_dst );
   waitKey(0);
    
       return 0;
   }

Java

1. 教程代码如下所示。您也可以从此处下载。

    
   import org.opencv.core.*;
   import org.opencv.highgui.HighGui;
   import org.opencv.imgcodecs.Imgcodecs;
   import org.opencv.imgproc.Imgproc;
    
   class LaplaceDemoRun {
    
       public void run(String[] args) {
           // Declare the variables we are going to use
   Mat src, src_gray = new Mat(), dst = new Mat();
           int kernel_size = 3;
           int scale = 1;
           int delta = 0;
           int ddepth = CvType.CV_16S;
   String window_name = "Laplace Demo";
    
   String imageName = ((args.length > 0) ? args[0] : "../data/lena.jpg");
    
   src = Imgcodecs.imread(imageName, Imgcodecs.IMREAD_COLOR); // Load an image
    
           // 检查图像是否加载成功
           if( src.empty() ) {
   System.out.println("Error opening image");
   System.out.println("Program Arguments: [image_name -- default ../data/lena.jpg] \n");
   System.exit(-1);
           }
    
           // Reduce noise by blurring with a Gaussian filter ( kernel size = 3 )
   Imgproc.GaussianBlur( src, src, new Size(3, 3), 0, 0, Core.BORDER_DEFAULT );
    
           // 将图像转换为灰度
   Imgproc.cvtColor( src, src_gray, Imgproc.COLOR_RGB2GRAY );
    
   Mat abs_dst = new Mat();
   Imgproc.Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, Core.BORDER_DEFAULT );
    
           // 转换回 CV_8U
   Core.convertScaleAbs( dst, abs_dst );
    
   HighGui.imshow( window_name, abs_dst );
   HighGui.waitKey(0);
    
   System.exit(0);
       }
   }
    
   public class LaplaceDemo {
       public static void main(String[] args) {
           // 加载本地库。
   System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
           new LaplaceDemoRun().run(args);
       }
   }

Python

1. 教程代码如下所示。您也可以从此处下载。

   """
   @file laplace_demo.py
   @brief Sample code showing how to detect edges using the Laplace operator
   """
   import sys
   import cv2 as cv
    
   def main(argv)
       # [variables]
       # Declare the variables we are going to use
   ddepth = cv.CV_16S
   kernel_size = 3
   window_name = "Laplace Demo"
       # [variables]
    
       # [load]
   imageName = argv[0] if len(argv) > 0 else 'lena.jpg'
    
   src = cv.imread(cv.samples.findFile(imageName), cv.IMREAD_COLOR) # Load an image
    
       # Check if image is loaded fine
       if src is None
           print ('Error opening image')
           print ('Program Arguments: [image_name -- default lena.jpg]')
           return -1
       # [load]
    
       # [reduce_noise]
       # Remove noise by blurring with a Gaussian filter
   src = cv.GaussianBlur(src, (3, 3), 0)
       # [reduce_noise]
    
       # [convert_to_gray]
       # Convert the image to grayscale
   src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
       # [convert_to_gray]
    
       # Create Window
       cv.namedWindow(window_name, cv.WINDOW_AUTOSIZE)
    
       # [laplacian]
       # Apply Laplace function
   dst = cv.Laplacian(src_gray, ddepth, ksize=kernel_size)
       # [laplacian]
    
       # [convert]
       # converting back to uint8
   abs_dst = cv.convertScaleAbs(dst)
       # [convert]
    
       # [display]
       cv.imshow(window_name, abs_dst)
       cv.waitKey(0)
       # [display]
    
       return 0
    
   if __name__ == "__main__"
       main(sys.argv[1:])

解释

声明变量

C++

    // Declare the variables we are going to use
    Mat src, src_gray, dst;
    int kernel_size = 3;
    int scale = 1;
    int delta = 0;
    int ddepth = CV_16S;
    const char* window_name = "Laplace Demo";

Java

        // Declare the variables we are going to use
Mat src, src_gray = new Mat(), dst = new Mat();
        int kernel_size = 3;
        int scale = 1;
        int delta = 0;
        int ddepth = CvType.CV_16S;
        String window_name = "Laplace Demo";

Python

    # Declare the variables we are going to use
ddepth = cv.CV_16S
kernel_size = 3
window_name = "Laplace Demo"

加载源图像

C++

    const char* imageName = argc >=2 ? argv[1] : "lena.jpg";
 
src = imread( samples::findFile( imageName ), IMREAD_COLOR ); // Load an image
 
    // 检查图像是否加载成功
    if(src.empty()){
printf(" Error opening image\n");
printf(" Program Arguments: [image_name -- default lena.jpg] \n");
        return -1;
    }

Java

        String imageName = ((args.length > 0) ? args[0] : "../data/lena.jpg");
 
src = Imgcodecs.imread(imageName, Imgcodecs.IMREAD_COLOR); // Load an image
 
        // 检查图像是否加载成功
        if( src.empty() ) {
System.out.println("Error opening image");
System.out.println("Program Arguments: [image_name -- default ../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) # Load an image
 
    # Check if image is loaded fine
    if src is None
        print ('Error opening image')
        print ('Program Arguments: [image_name -- default lena.jpg]')
        return -1

降噪

C++

    // Reduce noise by blurring with a Gaussian filter ( kernel size = 3 )
    GaussianBlur( src, src, Size(3, 3), 0, 0, BORDER_DEFAULT );

Java

        // Reduce noise by blurring with a Gaussian filter ( kernel size = 3 )
Imgproc.GaussianBlur( src, src, new Size(3, 3), 0, 0, Core.BORDER_DEFAULT );

Python

    # Remove noise by blurring with a Gaussian filter
src = cv.GaussianBlur(src, (3, 3), 0)

灰度化

C++

    cvtColor( src, src_gray, COLOR_BGR2GRAY ); // Convert the image to grayscale

Java

        // 将图像转换为灰度
Imgproc.cvtColor( src, src_gray, Imgproc.COLOR_RGB2GRAY );

Python

    # Convert the image to grayscale
src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)

拉普拉斯算子

C++

    Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, BORDER_DEFAULT );

Java

Imgproc.Laplacian( src_gray, dst, ddepth, kernel_size, scale, delta, Core.BORDER_DEFAULT );

Python

    # Apply Laplace function
dst = cv.Laplacian(src_gray, ddepth, ksize=kernel_size)

• 参数为
  • src_gray：输入图像。
  • dst: 目标（输出）图像
  • ddepth：目标图像的深度。由于我们的输入是 CV_8U，我们将 ddepth 定义为 CV_16S 以避免溢出。
  • kernel_size：内部应用的 Sobel 算子的核大小。在此示例中我们使用 3。
  • scale、delta 和 BORDER_DEFAULT：我们保留其默认值。

将输出转换为 CV_8U 图像

C++

    // 转换回 CV_8U
    convertScaleAbs( dst, abs_dst );

Java

        // 转换回 CV_8U
Core.convertScaleAbs( dst, abs_dst );

Python

    # converting back to uint8
abs_dst = cv.convertScaleAbs(dst)

显示结果

C++

    imshow( window_name, abs_dst );
    waitKey(0);

Java

HighGui.imshow( window_name, abs_dst );
HighGui.waitKey(0);

Python

    cv.imshow(window_name, abs_dst)
    cv.waitKey(0)

结果

1. 编译上述代码后，我们可以通过提供图像路径作为参数来运行它。例如，使用以下输入：

1. 我们得到以下结果。请注意，树木和奶牛的轮廓近似清晰（除了强度非常相似的区域，例如奶牛头部周围）。此外，请注意树木后面（右侧）房屋的屋顶被显著标记。这是因为该区域的对比度较高。