精华内容
下载资源
问答
  • 拉普拉斯算子模板
    千次阅读
    2020-11-17 16:16:21

    概述

    定义:拉普拉斯算子是n维欧几里德空间中的一个二阶微分算子,是用二阶差分来计算图像的边缘。
    拉普拉斯算子是一种各向同性微分算子,它具有旋转不变性。

    laplace算子是一种高通滤波器,用来保留图像的高频分量(变化剧烈的部分),抑制图像的低频分量(变化缓慢的部分),所以可以用来检测边缘。

    拉普拉斯算子 (Laplace) 作用:
    1.对图像进行边缘检测;
    2.锐化图像;
    3.判断模糊。

    二阶差分

    一阶差分可以检测边缘存在的可能性,是把灰度变化的区域找出来,检测边缘是否存在。
    二阶差分能确定边缘的存在性,是把灰度值变化的拐点找出来,确定边缘的位置。
    在这里插入图片描述

    算子模板

    在这里插入图片描述

    应用原理

    利用函数模板可以把图像中的奇异点如亮点变得更亮,对于图像中灰度变化剧烈的区域,该算子能实现其边缘检测。

    该算子利用二阶微分特性和峰值间的过零点来判断边缘位置,对边界点更为敏感,常用于锐化图像。

    锐化:产生的灰度突变的图像和原始图像叠加,既能产生锐化突变的边缘,又能保留背景信息。

    python代码实现

    def laplace(img):
      h, w = img.shape
      new_image = np.zeros((h, w))
      # operator = np.array([[0, -1, 0], [-1, 4, -1], [0, -1, 0]])
      operator = np.array([[1,1,1],[1,-8,1],[1,1,1]])
      for i in range(1, h-1):
        for j in range(1, w-1):
          new_image[i, j] = abs(np.sum(img[i-1:i+2, j-1:j+2] * operator))
      return np.uint8(new_image)
    

    opencv代码

    gray_lap = cv2.Laplacian(img,cv2.CV_16S,ksize = 3)    
    # 转回uint8
    dst = cv2.convertScaleAbs(gray_lap) 
    

    效果展示

    在这里插入图片描述

    更多相关内容
  • Sobel,拉普拉斯算子

    千次阅读 2019-03-23 11:41:30
    小白目前经手的科研课题涉及到在编码解码过程中增加各类噪声和相关滤波的处理,涉及到了一些算子处理,所以一边学习一边记录:若博文有不妥之处,望加以指点,笔者一定及时修正。 文章目录① Sobel算子② Laplace...

    小白目前经手的科研课题涉及到在编码解码过程中增加各类噪声和相关滤波的处理,涉及到了一些算子处理,所以一边学习一边记录:若博文有不妥之处,望加以指点,笔者一定及时修正。


    ① Sobel算子

    边缘图像上灰度级变化很快的点的集合。那如何在图像上找到这些点呢?

    高数中,我们知道如果函数点变化很快,其导数越大。也就是导数越大的地方越有可能是边缘。但是计算机不常用,因为存在导数无穷大的情况,计算机难以表达。所以,计算机就采用微分的形式。连续函数 x x x变化了 d x dx dx,导致 y y y变化了 d y dy dy d y dy dy值越大表示变化的越大,那么计算整幅图像的微分, d y dy dy的大小就是边缘的强弱了。微分与导数的关系: d y = f ′ ( x ) d x dy = f '(x) dx dy=f(x)dx

    举个例子:
    在这里插入图片描述在这里插入图片描述
    经过微分之后,平缓的地方 d y dy dy几乎为0,而边缘的地方绝对值很大,真实值有正负情况。连续函数里面有微分,离散里面是差分,也是求变化率。差分的定义 f ′ ( x ) = f ( x + 1 ) − f ( x ) f^{'}(x)=f(x+1)-f(x) f(x)=f(x+1)f(x),后一项减去前一项。 Sobel算子是一阶微分的边缘检测算子,该算子引入了类似局部平均的运算,因此对噪声具有平滑作用,能很好的消除噪声的影响

    模板运算基本思路:将原图像中某个像素的值,作为它本身灰度值和其相邻像素灰度值进行运算的函数。模板中有一个锚点,通常是矩阵中心点,和原图像中待计算点对应;整个模板对应的区域,就是原图像中像素点的相邻区域,模板运算目的是让图像变好。

    Sobel算子包含两组 3 ∗ 3 3*3 33 的矩阵,分别为横向纵向模板,将之与图像作平面卷积,即可分别得出横向及纵向的亮度差分近似值。下面是 G x G_x Gx G y G_y Gy 的相关模板,但是实用卷积的时候,需要把相关模板旋转180度再与图像做卷积的操作。

    G x = [ − 1 0 + 1 − 2 0 + 2 − 1 0 + 1 ] G_x = \left[ \begin{matrix} -1 & 0 & +1 \\ -2 & 0 & +2 \\ -1 & 0 & +1 \end{matrix} \right] Gx=121000+1+2+1 G y = [ − 1 − 2 − 1 0 0 0 + 1 + 2 + 1 ] G_y = \left[ \begin{matrix} -1 & -2 & -1 \\ 0 & 0 & 0 \\ +1 & +2 & +1 \end{matrix} \right] Gy=10+120+210+1卷积的时候运用的是: G x G_x Gx是对原图 x x x方向上的卷积, G y G_y Gy是对原图 y y y方向上的卷积(卷积:卷积可以理解为一个过程:元素对应相乘,乘积累加,是一个线性操作): G x = [ + 1 0 − 1 + 2 0 − 2 + 1 0 − 1 ] G_x = \left[ \begin{matrix} +1 & 0 & -1 \\ +2 & 0 & -2 \\ +1 & 0 & -1 \end{matrix} \right] Gx=+1+2+1000121 G y = [ + 1 + 2 + 1 0 0 0 − 1 − 2 − 1 ] G_y = \left[ \begin{matrix} +1 & +2 & +1 \\ 0 & 0 & 0 \\ -1 & -2 & -1 \end{matrix} \right] Gy=+101+202+101
    具体计算为:图像上的每一个像素点的横向和纵向灰度值结合起来计算该点灰度的大小:
    G = G x 2 + G y 2 2 G=\sqrt[2]{{G_x}^2+{G_y}^2} G=2Gx2+Gy2 然后计算梯度方向:
    Θ = a r c t a n ( G y G x ) \Theta = arctan(\frac{G_y}{G_x}) Θ=arctan(GxGy)

    这个相关模板一般都是奇数:因为模板是偶数的话,卷积出来的结果应该是放在中间的,不方便表示。使用奇数保证锚点(卷积核的中心)刚好在中间,方便以模块中心为标准进行滑动卷积。同时保证了padding时,图像的两边依然相对称

    缺点:

    Sobel算子并没有将图像的主题与背景严格地区分开来,所以提取的图像轮廓有时并不能令人满意。

    当然还有另外一个比Sobel函数的近似效果更好的 Scharr函数,其内核矩阵如下:

    在这里插入图片描述


    ② Laplace算子

    拉普拉斯算子是一个二阶微分算子,定义为梯度 ∇ f \nabla{f} f和散度 ∇ f ′ \nabla{f^{'}} f对图像求二阶导数,因为图像是二维的,所以不用分开求横向和纵向的导数,然后相加。

    在这里插入图片描述

    离散形式,在一个二维函数 f ( x , y ) f(x,y) f(x,y) 中, x , y x,y x,y 两个方向的二阶差分分别为:
    ∂ 2 f ∂ x 2 = f ( x + 1 , y ) + f ( x − 1 , y ) − 2 f ( x , y ) \frac{\partial ^{2}f}{\partial x^2}=f(x+1,y)+f(x-1,y)-2f(x,y) x22f=f(x+1,y)+f(x1,y)2f(x,y) ∂ 2 f ∂ y 2 = f ( x , y + 1 ) + f ( x , y − 1 ) − 2 f ( x , y ) \frac{\partial ^{2}f}{\partial y^2}=f(x,y+1)+f(x,y-1)-2f(x,y) y22f=f(x,y+1)+f(x,y1)2f(x,y)所以拉普拉斯算子的差分形式为:
    ∇ 2 f ( x , y ) = f ( x + 1 , y ) + f ( x − 1 , y ) + f ( x , y + 1 ) + f ( x , y − 1 ) − 4 f ( x , y ) \nabla^2f(x,y)=f(x+1,y)+f(x-1,y)+f(x,y+1)+f(x,y-1)-4f(x,y) 2f(x,y)=f(x+1,y)+f(x1,y)+f(x,y+1)+f(x,y1)4f(x,y)

    图像锐化:使灰度反差增强,从而使模糊图像变得更加清晰。
    图像模糊:图像受到平均运算或积分运算,对图像进行逆运算,如微分运算能够突出图像细节,使图像变得更为清晰。
    拉普拉斯是一种微分算子,它的应用可增强图像中灰度突变的区域,减弱灰度的缓慢变化区域。
    因此,锐化处理可选择拉普拉斯算子对原图像进行处理,产生描述灰度突变的图像,再将拉普拉斯图像与原始图像叠加而产生锐化图像!

    拉普拉斯算子模板:
    G = [ 0 1 0 1 − 4 1 0 1 0 ] G= \left[ \begin{matrix} 0 & 1 & 0 \\ 1 & -4 & 1 \\ 0 & 1 & 0 \end{matrix} \right] G=010141010该模板在上下左右四个90度的方向上结果相同,也就是说在90度方向上无方向性
    其他常用的模板还有:
    目的:在45度的方向上也具有无方向,对该模板进行扩展定义为 G = [ 1 1 1 1 − 8 1 1 1 1 ] G= \left[ \begin{matrix} 1 & 1 & 1 \\ 1 & -8 & 1 \\ 1 & 1 & 1 \end{matrix} \right] G=111181111缺点:
    1、没有了边缘的方向信息;
    2、双倍加强了噪声的影响。


    ③ 参考博客

    这几位的博客十分好,隆重推荐!

    1. https://www.jianshu.com/p/2334bee37de5
    2. https://blog.csdn.net/xddwz/article/details/78006655
    展开全文
  • 拉普拉斯算子

    千次阅读 2021-04-16 14:46:45
    首先,拉普拉斯算子是最简单的各向同性微分算子,它具有旋转不变性。一个二维图像函数的拉普拉斯变换是各向同性的二阶导数,定义为: 用更加形象的图像来解释,假设我们有一张一维图形。下图(a)中灰度值的”跃升”...

    背景简述

    在图像处理,我们知道经常把Laplace算子作为边缘检测之一,也是工程数学中常用的一种积分变换。本节主要介绍Laplacian 算子相关的知识。

    基本理论

    首先,拉普拉斯算子是最简单的各向同性微分算子,它具有旋转不变性。一个二维图像函数的拉普拉斯变换是各向同性的二阶导数,定义为:

    用更加形象的图像来解释,假设我们有一张一维图形。下图(a)中灰度值的”跃升”表示边缘的存在.如果使用一阶微分求导我们可以更加清晰的看到边缘”跃升”的存在(这里显示为高峰值)图(b); 如果在边缘部分求二阶导数会出现什么情况?,图(c)所示。(其图片和定义公式来源于http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/imgproc/imgtrans/laplace_operator/laplace_operator.html)。

      

    (a)                                                                                                          (b)

    (c)

    你会发现在一阶导数的极值位置,二阶导数为0。所以我们也可以用这个特点来作为检测图像边缘的方法。 但是, 二阶导数的0值不仅仅出现在边缘(它们也可能出现在无意义的位置),但是我们可以过滤掉这些点。

    为了更适合于数字图像处理,将该方程表示为离散形式:

    另外,拉普拉斯算子还可以表示成模板的形式,以便更好编程需要。如图1所示。

    图1(a)表示离散拉普拉斯算子的模板,图1(b)表示其扩展模板,图1(c)则分别表示其他两种拉普拉斯的实现模板。从模板形式容易看出,如果在图像中一个较暗的区域中出现了一个亮点,那么用拉普拉斯运算就会使这个亮点变得更亮。因为图像中的边缘就是那些灰度发生跳变的区域,所以拉普拉斯锐化模板在边缘检测中很有用。一般增强技术对于陡峭的边缘和缓慢变化的边缘很难确定其边缘线的位置。但此算子却可用二次微分正峰和负峰之间的过零点来确定,对孤立点或端点更为敏感,因此特别适用于以突出图像中的孤立点、孤立线或线端点为目的的场合。同梯度算子一样,拉普拉斯算子也会增强图像中的噪声,有时用拉普拉斯算子进行边缘检测时,可将图像先进行平滑处理。

    图像锐化处理的作用是使灰度反差增强,从而使模糊图像变得更加清晰。图像模糊的实质就是图像受到平均运算或积分运算,因此可以对图像进行逆运算,如微分运算能够突出图像细节,使图像变得更为清晰。由于拉普拉斯是一种微分算子,它的应用可增强图像中灰度突变的区域,减弱灰度的缓慢变化区域。因此,锐化处理可选择拉普拉斯算子对原图像进行处理,产生描述灰度突变的图像,再将拉普拉斯图像与原始图像叠加而产生锐化图像。拉普拉斯锐化的基本方法可以由下式表示:

    这种简单的锐化方法既可以产生拉普拉斯锐化处理的效果,同时又能保留背景信息,将原始图像叠加到拉普拉斯变换的处理结果中去,可以使图像中的各灰度值得到保留,使灰度突变处的对比度得到增强,最终结果是在保留图像背景的前提下,突现出图像中小的细节信息。但其缺点是对图像中的某些边缘产生双重响应。

    参考代码

    OpenCV版Laplace算子

    [cpp]  view  plain  copy 

    1. #include "cv.h"  
    2. #include "highgui.h"  
    3.   
    4. using namespace cv;  
    5.   
    6. int main(int argc, char* argv[])  
    7. {  
    8.         Mat src = imread("test.jpg");  
    9.         Mat dst;  
    10.       
    11.         Laplacian(src,dst,src.depth());  
    12.         imwrite("laplacian.jpg",dst);  
    13.   
    14.         imshow("dst",dst);  
    15.         waitKey();  
    16.   
    17.         return 0;  
    18. }  

    OpenCV-Python版Laplacian

    [cpp]  view  plain  copy 

    1. #coding=utf-8    
    2. import cv2    
    3. import numpy as np      
    4.     
    5. img = cv2.imread("test.jpg", 0)    
    6. gray_lap = cv2.Laplacian(img,cv2.CV_16S,ksize = 3)    
    7. dst = cv2.convertScaleAbs(gray_lap)    
    8.     
    9. cv2.imshow('laplacian',dst)    
    10. cv2.waitKey(0)    
    11. cv2.destroyAllWindows()   

    OpenCV-Python版LaplaceOperater

    [cpp]  view  plain  copy 

    1. import cv2    
    2. import numpy as np    
    3.         
    4. kernel_size = 3    
    5. scale = 1    
    6. delta = 0    
    7. ddepth = cv2.CV_16S    
    8.         
    9. img = cv2.imread('test.jpg')    
    10. img = cv2.GaussianBlur(img,(3,3),0)    
    11. gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)    
    12.         
    13. gray_lap = cv2.Laplacian(gray,ddepth,ksize = kernel_size,scale = scale,delta = delta)    
    14. dst = cv2.convertScaleAbs(gray_lap)    
    15.         
    16. cv2.imshow('laplaceOperater',dst)  
    17. cv2.waitKey(0)    
    18. cv2.destroyAllWindows()    

    输出测试

    原始图像所示:

    OpenCV-Python版Laplacian输出图像所示:

    OpenCV-Python版LaplaceOperater输出图像所示:

    由图可以看出,将原始图像通过拉普拉斯变换后增强了图像中灰度突变处的对比度,使图像中小的细节部分得到增强并保留了图像的背景色调,使图像的细节比原始图像更加清晰。基于拉普拉斯变换的图像增强已成为图像锐化处理的基本工具。

    参考文献

    [1] Milan Sonka ,Vaclav Hlavac, Roger Boyle, "Image Procssing ,analysis and Machine Vision".

    [2] Richard Szelisi,"Computer Vision Algorithms and Applications".

     

    关于Image Engineering & Computer Vision的更多讨论与交流,敬请关注本博和新浪微博songzi_tea.

     

    文章转自:http://blog.csdn.net/songzitea/article/details/12842825

     

    展开全文
  • 五、 卷积模板 结合上面的推导过程,我们可以得出拉普拉斯算子的标准卷积模板: 根据该卷积模板,我们还可以进一步扩展,如下: 至此,我们基本可以根据该卷积模板进行代码的编写了。 六、 边缘提取代码展示 //...

    一、 什么是图像边缘

    图像边缘简单理解就是一张照片中,物体的边缘线。例如:一个人站在绿幕中拍一张照片,那么这个人的衣服和背景绿幕在图片中交界的部分我们就称之为边缘。

    二、 边缘的基本特征

    要理解边缘的基本特征,我们需要先明白边缘出现的两种情况,以及分别对应的函数图像。
    1) 阶跃变化
    原图:
    在这里插入图片描述函数图像:
    在这里插入图片描述注:虚线即代表边缘出现的位置,横轴代表位置,纵轴代表灰度值。此函数图像仅代表类似原图边缘的一般情况,非严格对照。
    2) 屋顶变化
    原图:
    在这里插入图片描述函数图像:
    在这里插入图片描述注:虚线即代表边缘出现的位置,横轴代表位置,纵轴代表灰度值。此函数图像仅代表类似原图边缘的一般情况,非严格对照。

    三、 图像边缘特征总结

    从上述图像我们不难看出,边缘大致分为两种,其对应的函数图像也就大致分为两种。
    第一种:一阶导数在边缘处达峰值,二阶导数在边缘处达零值;
    第二种:一阶导数在边缘处达零值,二阶导数在边缘处达峰值。
    至此我们的边缘特征基本总结完毕,下面开始介绍拉普拉斯算子以及其在图像上的作用。

    四、 拉普拉斯算子

    拉普拉斯算子是一个二阶微分算子。在二维空间中,x,y表示该点的二维坐标,利用拉普拉斯算子代表的笛卡尔坐标: 在这里插入图片描述
    这里,我们将一张图像看成是一个二维空间,而各个点的像素值则表示该位置的函数值大小,即f(x,y)。我们再利用拉普拉斯算子表达式,计算某一点的△ f。如此我们便可以求出上面第二种边缘的二阶导数,从而轻易得出边缘。
    现在我们来看一下拉普拉斯算子推导出图像的卷积模板的过程:
    1) 根据公式,我们先求出对x的二阶导,而后对y的二阶导也是依次类推即可。
    2) 根据导数公式,我们可以先计算出点(x,y)右侧的一阶导数,即:f(x,y)的右一阶导数等于[f(x+1,y)-f(x,y)]/[(x+1)-x]即等于f(x+1,y)-f(x,y);同理f(x,y)的左一阶导数等于f(x,y)-f(x-1,y);
    3) 而后我们再根据f(x,y)的两侧一阶导数可求出x轴的二阶导为:f(x+1,y)+f(x-1,y)-2f(x,y);至此,我们的像素值函数对x轴的二阶导求得完毕;
    4) 以此类推,我们可得出f(x,y)对y的二阶导为
    f(x,y+1)+f(x,y-1)-2
    f(x,y);
    5) 综上,我们可得出拉普拉斯算子运算结果△f为
    f(x,y+1)+f(x,y-1)+ f(x+1,y)+f(x-1,y)- 4*f(x,y);

    五、 卷积模板
    结合上面的推导过程,我们可以得出拉普拉斯算子的标准卷积模板:
    拉普拉斯卷积模板根据该卷积模板,我们还可以进一步扩展,如下:
    拉普拉斯卷积模板至此,我们基本可以根据该卷积模板进行代码的编写了。

    六、 边缘提取代码展示

    //拉普拉斯算子边缘提取
    	public static BufferedImage LaplaceEdge(BufferedImage leftImage) {
    		int width = leftImage.getWidth();
    		int height = leftImage.getHeight();
    		int srcRGBs[] = leftImage.getRGB(0, 0, width, height, null, 0, width);
    		//BufferedImage destImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
    	
    		int rgb[]=new int[3];
    		int rs[][]=new int[width+2][ height+2]; //
    		int gs[][]=new int[width+2][ height+2];
    		int bs[][]=new int[width+2][ height+2];
    
    		for(int j=1; j<height+1; j++) {
    			for (int i = 1; i < width+1; i++) {
    				ImageUtil.decodeColor(srcRGBs[(j-1)*width+i-1],rgb); //rgb[0]=R,rgb[1]=G,rgb[2]=B
    				rs[i][j]=rgb[0];   //Rֵ
    				gs[i][j]=rgb[1];   //Gֵ
    				bs[i][j]=rgb[2];   //bֵ
    			}
    		}
    		BufferedImage destImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
    
    		for (int j = 1; j < height+1; j++) {
    			for(int i=1; i<width+1; i++) {
    				try {
    					ImageUtil.decodeColor(srcRGBs[(j-1)*width+i-1],rgb); //rgb[0]=R,rgb[1]=G,rgb[2]=B
    				} catch (Exception e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    
    				}
    					rgb[0]=(int)((rs[i-1][j-1]*(-1)+rs[i][j-1]*(-1)+rs[i+1][j-1]*(-1)+
    							rs[i-1][j]*(-1)+rs[i][j]*8+rs[i+1][j]*(-1)+
    							rs[i-1][j+1]*(-1)+rs[i][j+1]*(-1)+rs[i+1][j+1]*(-1))/9);
    					rgb[1]=(int)((gs[i-1][j-1]*(-1)+gs[i][j-1]*(-1)+gs[i+1][j-1]*(-1)+
    							gs[i-1][j]*(-1)+gs[i][j]*8+gs[i+1][j]*(-1)+
    							gs[i-1][j+1]*(-1)+gs[i][j+1]*(-1)+gs[i+1][j+1]*(-1))/9);
    					rgb[2]=(int)((bs[i-1][j-1]*(-1)+bs[i][j-1]*(-1)+bs[i+1][j-1]*(-1)+
    							bs[i-1][j]*(-1)+bs[i][j]*(8)+bs[i+1][j]*(-1)+
    							bs[i-1][j+1]*(-1)+bs[i][j+1]*(-1)+bs[i+1][j+1]*(-1))/9);
    					if(rgb[0]<0){
    						rgb[0]=0;
    					}
    					if(rgb[0]>255){
    						rgb[0]=255;
    						}
    					if(rgb[1]<0){
    						rgb[1]=0;
    					}
    					if(rgb[1]>255){
    						rgb[1]=255;
    					}
    					if(rgb[2]<0){
    						rgb[2]=0;
    					}
    					if(rgb[2]>255){
    						rgb[2]=255;
    					}
    				destImage.setRGB(i-1,j-1, ImageUtil.encodeColor(rgb));
    			}
    		}
    
    		return destImage;
    	}
    
    

    细心的同学可能,我使用的卷积模板是拓展的模板,并且我对最后的结果进行了除以9,这里我是希望可以提取更加突出明显的边缘。

    七、 边缘提取效果展示

    拉普拉斯算子边缘提取效果展示

    八、 边缘锐化原理与展示

    现在我们再来简单总结一下拉普拉斯算子边缘锐化的简单原理。稍稍总结一下边缘提取的卷积模板,我们不难得出可以使用一下的卷积模板进行边缘锐化:
    在这里插入图片描述因此代码如下:

    //拉普拉斯算子边缘锐化
    	public static BufferedImage LaplaceSharpen(BufferedImage leftImage) {
    		int width = leftImage.getWidth();
    		int height = leftImage.getHeight();
    		int srcRGBs[] = leftImage.getRGB(0, 0, width, height, null, 0, width);
    		//BufferedImage destImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
    
    		int rgb[]=new int[3];
    		int rs[][]=new int[width][ height]; //
    		int gs[][]=new int[width][ height];
    		int bs[][]=new int[width][ height];
    
    		for(int j=0; j<height; j++) {
    			for (int i = 0; i < width; i++) {
    				ImageUtil.decodeColor(srcRGBs[j*width+i],rgb); //rgb[0]=R,rgb[1]=G,rgb[2]=B
    				rs[i][j]=rgb[0];   //Rֵ
    				gs[i][j]=rgb[1];   //Gֵ
    				bs[i][j]=rgb[2];   //bֵ
    				//System.out.println("i="+i+" j="+j+"  rs="+rs[i][j]+"  gs="+gs[i][j]+"  bs="+bs[i][j]);
    			}
    		}
    		BufferedImage destImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
    
    		int r=0,g=0,b=0;
    		for (int j = 0; j < height; j++) {
    			for(int i=0; i<width; i++) {
    				try {
    					ImageUtil.decodeColor(srcRGBs[j*width+i],rgb); //rgb[0]=R,rgb[1]=G,rgb[2]=B
    				} catch (Exception e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    					System.out.println(i);
    				}
    				if (j>=1&&i>=1&&j<height-1&&i<width-1){
    					rgb[0]=(int)((rs[i+1][j]*(-1)+
    							rs[i-1][j]*(-1)+rs[i][j]*5+
    							rs[i][j+1]*(-1)+rs[i][j-1]*(-1)));
    					if (rgb[0]<0){
    						rgb[0]=0;
    					}
    					if (rgb[0]>255){
    						rgb[0]=255;
    					}
    					rgb[1]=(int)((gs[i][j-1]*(-1)+
    							gs[i-1][j]*(-1)+gs[i][j]*5+gs[i+1][j]*(-1)+
    							gs[i][j+1]*(-1)));
    					if (rgb[1]<0){
    						rgb[1]=0;
    					}
    					if (rgb[1]>255){
    						rgb[1]=255;
    					}
    					rgb[2]=(int)((bs[i][j-1]*(-1)+
    							bs[i-1][j]*(-1)+bs[i][j]*5+bs[i+1][j]*(-1)+
    							bs[i][j+1]*(-1)));
    					if (rgb[2]<0){
    						rgb[2]=0;
    					}
    					if (rgb[2]>255){
    						rgb[2]=255;
    					}
    				}else {
    					rgb[0]=rs[i][j];
    					rgb[1]=gs[i][j];
    					rgb[2]=bs[i][j];
    				}
    				destImage.setRGB(i,j, ImageUtil.encodeColor(rgb));
    			}
    		}
    
    		return destImage;
    	}
    	
    

    效果展示如下:
    拉普拉斯算子边缘锐化综上,我们对于拉普拉斯算子进行边缘提取和锐化的简单原理基本已经介绍完毕,其实出了拉普拉斯算子外,还有多种算子可进行边缘提取,且均大同小异。

    总代码包下载:https://download.csdn.net/download/yiyexy/12323645

    展开全文
  • 拉普拉斯算子(Laplace Operator)是n维欧几里德空间中的一个二阶微分算子,定义为梯度(▽f)的散度(▽·f)。(摘自百度百科) 如果f是二阶可微的实函数,则f的拉普拉斯算子定义为: f的拉普拉斯算子也是...
  • 传统经典CV算法_拉普拉斯算子详解

    千次阅读 2020-10-04 15:49:05
    拉普拉斯算子是一个二阶算子,比起一阶微分算子,二阶微分算子的边缘定位能力更强,锐化效果更好。 使用二阶微分算子的基本方法是定义一种二阶微分的离散形式,然后根据这个形式生成一个滤波模版,与图像进行卷积。 ...
  • 请用MATLAB或其它语言编写相关程序,输入一幅灰度图像,分别采用梯度算子、拉普拉斯算子、Sobel算子、Prewitt算子对图像进行锐化,在同一个窗口输出显示原始图像和4种结果图像。
  • 了解拉普拉斯算子

    千次阅读 2020-07-05 12:30:22
    了解拉普拉斯算子1. Laplace算子的定义2. 转换成离散形式 1. Laplace算子的定义        直奔主题:Laplace算子被定义为函数梯度的散度,即:      &...
  • 数字图像处理之拉普拉斯算子

    千次阅读 2018-09-21 09:00:13
    OpenCV-跟我一起学数字图像处理之拉普拉斯算子 Laplace算子和Sobel算子一样,属于空间锐化滤波操作。起本质与前面的Spatial Filter操作大同小异,下面就通过Laplace算子来介绍一下空间锐化滤波,并对OpenCV中提供...
  • matlab拉普拉斯算子锐化滤波

    千次阅读 2021-04-18 10:38:28
    拉普拉斯算子是最简单的各向同性微分算子,有几种常用的滤波模板,本文使用的是八邻域模板,如下所示image.png其对应的计算公式为:image.png因此最后得到的锐化后的图像表示为:image.png其中,g(x,y)是输出图像,f...
  • 1、拉普拉斯算子 首先是散度与梯度的概念:散度和旋度的物理意义是什么? 贴一下原文回答作者的总结:通过物理来理解这四个概念还是比较容易的。 通量是单位时间内通过的某个曲面的量; 散度是通量强度(求解任一点...
  • 二阶微分锐化图像–拉普拉斯算子 拉普拉斯算子的定义 着重于图像中的灰度突变区域,而非灰度级缓慢变化的区域,会产生暗色背景中叠加有浅辉边界线和突变点(轮廓)。 原图加拉普拉斯算子计算后的图像可以使图像锐化...
  • 使用拉普拉斯算子锐化图像

    千次阅读 2021-02-23 17:33:13
    拉普拉斯算子锐化图像 [f,map] = imread('E:\code\matlab\ImageDatabase\dipum_images_ch03\Fig0316(a)(moon).tif'); w = [0 1 0 ; 1 -4 1; 0 1 0]; w = 0 1 0 1 -4 1 0 1 0 f2 = im2double(f); g2 = ...
  • LOG高斯-拉普拉斯算子

    万次阅读 多人点赞 2017-03-15 20:55:17
    1、拉普拉斯算子的出发点 在图像中,边缘可以看做是位于一阶导数较大的像素处,因此,我们可以求图像的一阶导数来确定图像的边缘,像sobel算子等一系列算子都是基于这个思想的。如下图a表示函数在边沿的时候关系,...
  • 拉普拉斯算子2. 月球图像3. 代码实现4. 遇到问题5. 附代码: 1. 拉普拉斯算子 Laplace算子是一种各向同性算子,二阶微分算子,在只关心边缘的位置而不考虑其周围的象素灰度差值时比较合适。Laplace算子对孤立象素的...
  • 为了离散地表达这个共识,我们套用上一章的一个公式变换: X方向: Y方向: 综合一下: 有了公式,就容易得到基于拉普拉斯算子模板: 因为拉普拉斯是一种二阶微分算子,因此其强调的是图像中灰度的突变,并不强调...
  • 拉普拉斯算子——matlab

    万次阅读 多人点赞 2019-12-05 12:42:23
    拉普拉斯变换所对应的滤波器模板为: close all;clear all;clc; I=imread('2.png'); I=im2double(I); [M,N]=size(I); B=zeros(size(I)); for x=2:M-1 for y=2:N-1 B(x,y)=I(x+1,y)+I(x-1,y)+I(x,y+1)+I(x,y-1)-4*...
  • OpenCV-Python系列之拉普拉斯算子

    千次阅读 2020-12-20 06:07:40
    们在上一个教程中前面的例子学习了使用Sobel边缘检测。原理是利用边缘区域像素值的跳变。通过求一阶导数,可以使边缘值最大化。如下图所示:那么,如果...二阶微分现在我们来讨论二阶微分,它是拉普拉斯算子的基础,...
  • 二阶微分算子-拉普拉斯算子

    千次阅读 2019-08-03 15:04:00
    在前面博客结尾,我们简要谈了一下二阶微分算子;对于图像; 从上面可以看出 一阶微分算子,就是求图像灰度变化曲线的导数,能够突出图像中的对象... 图(a)表示离散拉普拉斯算子模板,图(b)表示其扩展...
  • 关于拉普拉斯算子的一些解答

    千次阅读 2019-01-12 11:08:17
    已经有一年多没有写过博客了,最近好多新同事在学习计算机视觉的时候经常会问一些基础的问题,比如拉普拉斯算子等。因此打算重拾旧业写一些博客,以供大家参考。以前在国外的时候跟风(因为师兄弟们都是老外--貌似我...
  • 我们在上一个教程中前面的例子学习了使用Sobel边缘检测。...现在我们来讨论二阶微分,它是拉普拉斯算子的基础,与微积分中定义的微分略有不同,数字图像中处理的是离散的值,因此对于一维函数的一阶微分的基本定义是差
  • 由于拉普拉斯算子是一种微分算子,因此强调的是图像中灰度的突变,并不强调灰度缓慢变化的区域。这将产生把浅灰色边线和突变点叠加到暗色背景中的图像。将原图像和拉普拉斯图像叠加在一起的简单方法,可以复原背景...
  • (3)在应用上述3种拉普拉斯算子的前提下,分别生成增强后的结果图像,并简要分析不同模板对图像增强的影响。 直方图均衡化用opencv库的 cv2.equalizeHist()函数 拉普拉斯算子提取图像边缘可以通过修改第九行...
  • 5.4.4 边缘检测-拉普拉斯算子

    千次阅读 2018-11-01 22:06:48
    拉普拉斯算子的实现也是通过模板实现。常用的拉普拉斯模板定义如下:   拉普拉斯算子计算图像的二阶导数,对于图像噪声比较敏感。拉普拉斯算子的结果为标量,表示边缘的宽度。但是它常产生双像素宽边缘,而且不能...
  • [转] 图像处理中的拉普拉斯算子

    千次阅读 2018-07-30 10:32:54
    http://book.51cto.com/art/200808/84592.htm 5.5.2 拉普拉斯掩模锐化(1) 1.基本理论 拉普拉斯算子是最简单的各向同性微分算子,具有旋转不变性
  • 10.1 Python图像处理之边缘算子-Sobel算子、Roberts算子、拉普拉斯算子、Canny算子、Prewitt算子、高斯拉普拉斯算子 文章目录10.1 Python图像处理之边缘算子-Sobel算子、Roberts算子、拉普拉斯算子、Canny算子、...
  • 目录一、拉普拉斯算子二、高斯拉普拉斯算子​​​​​​三、一阶、二阶导数的区别拉普拉斯算子相当于对像素进行二阶导数。 ​​​一阶求导 (1) (2) 二阶求导

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,877
精华内容 1,550
关键字:

拉普拉斯算子模板

友情链接: iOS-VideoEditor-master.zip