一阶微分 图像处理_数字图像处理 一阶微分与二阶微分 - CSDN
精华内容
参与话题
  • 图像处理------ 一阶微分应用

    千次阅读 2015-07-24 10:07:43
    一:数学背景首先看一下一维的微分公式Δf ...对于离散的图像来说,一阶微分的数学表达相当于两个相邻像素的差值,根据选择的梯度算子不同,效果可能有所不同,但是基本原理不会变化。最常见的算子为Roberts算子,其它常

    一:数学背景

    首先看一下一维的微分公式Δf = f(x+1) – f(x), 对于一幅二维的数字图像f(x,y)而言,需要完

    成XY两个方向上的微分,所以有如下的公式:

    分别对X,Y两个方向上求出它们的偏微分,最终得到梯度Delta F.

    对于离散的图像来说,一阶微分的数学表达相当于两个相邻像素的差值,根据选择的梯度算

    子不同,效果可能有所不同,但是基本原理不会变化。最常见的算子为Roberts算子,其它

    常见还有Sobel,Prewitt等算子。以Roberts算子为例的X,Y的梯度计算演示如下图:


    二:图像微分应用

    图像微分(梯度计算)是图像边缘提取的重要的中间步骤,根据X,Y方向的梯度向量值,可以

    得到如下两个重要参数振幅magnitude, 角度theta,计算公式如下:


    Theta = tan-1(yGradient/xGradient)

    magnitude表示边缘强度信息

    theta预言边缘的方向走势。

    假如对一幅数字图像,求出magnitude之后与原来每个像素点对应值相加,则图像边缘将被

    大大加强,轮廓更加明显,是一个很典型的sharp filter的效果。

     

    三:程序效果

    X, Y梯度效果,及magnitude效果


    图像微分的Sharp效果:


    四:程序源代码

    1. package com.process.blur.study;  
    2.   
    3. import java.awt.image.BufferedImage;  
    4.   
    5. // roberts operator  
    6. // X direction 1, 0  
    7. //             0,-1  
    8. // Y direction 0, 1  
    9. //            -1, 0  
    10.   
    11. public class ImageGradientFilter extends AbstractBufferedImageOp {  
    12.     public final static int X_DIRECTION = 0;  
    13.     public final static int Y_DIRECTION = 2;  
    14.     public final static int XY_DIRECTION = 4;  
    15.       
    16.     private boolean sharp;  
    17.     private int direction;  
    18.       
    19.     public ImageGradientFilter() {  
    20.         direction = XY_DIRECTION; // default;  
    21.         sharp = false;  
    22.     }  
    23.       
    24.     public boolean isSharp() {  
    25.         return sharp;  
    26.     }  
    27.   
    28.     public void setSharp(boolean sharp) {  
    29.         this.sharp = sharp;  
    30.     }  
    31.   
    32.     public int getDirection() {  
    33.         return direction;  
    34.     }  
    35.   
    36.     public void setDirection(int direction) {  
    37.         this.direction = direction;  
    38.     }  
    39.   
    40.     @Override  
    41.     public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
    42.         int width = src.getWidth();  
    43.         int height = src.getHeight();  
    44.   
    45.         if (dest == null )  
    46.             dest = createCompatibleDestImage( src, null );  
    47.   
    48.         int[] inPixels = new int[width*height];  
    49.         int[] outPixels = new int[width*height];  
    50.         getRGB( src, 00, width, height, inPixels );  
    51.         int index = 0;  
    52.         double mred, mgreen, mblue;  
    53.         int newX, newY;  
    54.         int index1, index2, index3;  
    55.         for(int row=0; row<height; row++) {  
    56.             int ta = 0, tr = 0, tg = 0, tb = 0;  
    57.             for(int col=0; col<width; col++) {  
    58.                 index = row * width + col;  
    59.                   
    60.                 // base on roberts operator  
    61.                 newX = col + 1;  
    62.                 newY = row + 1;  
    63.                 if(newX > 0 && newX < width) {  
    64.                     newX = col + 1;  
    65.                 } else {  
    66.                     newX = 0;  
    67.                 }  
    68.                   
    69.                 if(newY > 0 && newY < height) {  
    70.                     newY = row + 1;  
    71.                 } else {  
    72.                     newY = 0;  
    73.                 }  
    74.                 index1 = newY * width + newX;  
    75.                 index2 = row * width + newX;  
    76.                 index3 = newY * width + col;  
    77.                 ta = (inPixels[index] >> 24) & 0xff;  
    78.                 tr = (inPixels[index] >> 16) & 0xff;  
    79.                 tg = (inPixels[index] >> 8) & 0xff;  
    80.                 tb = inPixels[index] & 0xff;  
    81.                   
    82.                 int ta1 = (inPixels[index1] >> 24) & 0xff;  
    83.                 int tr1 = (inPixels[index1] >> 16) & 0xff;  
    84.                 int tg1 = (inPixels[index1] >> 8) & 0xff;  
    85.                 int tb1 = inPixels[index1] & 0xff;  
    86.                   
    87.                 int xgred = tr -tr1;  
    88.                 int xggreen = tg - tg1;  
    89.                 int xgblue = tb - tb1;  
    90.                   
    91.                 int ta2 = (inPixels[index2] >> 24) & 0xff;  
    92.                 int tr2 = (inPixels[index2] >> 16) & 0xff;  
    93.                 int tg2 = (inPixels[index2] >> 8) & 0xff;  
    94.                 int tb2 = inPixels[index2] & 0xff;  
    95.                   
    96.                 int ta3 = (inPixels[index3] >> 24) & 0xff;  
    97.                 int tr3 = (inPixels[index3] >> 16) & 0xff;  
    98.                 int tg3 = (inPixels[index3] >> 8) & 0xff;  
    99.                 int tb3 = inPixels[index3] & 0xff;  
    100.                   
    101.                 int ygred = tr2 - tr3;  
    102.                 int yggreen = tg2 - tg3;  
    103.                 int ygblue = tb2 - tb3;  
    104.                   
    105.                 mred = Math.sqrt(xgred * xgred + ygred * ygred);  
    106.                 mgreen = Math.sqrt(xggreen * xggreen + yggreen * yggreen);  
    107.                 mblue = Math.sqrt(xgblue * xgblue + ygblue * ygblue);  
    108.                 if(sharp) {  
    109.                     tr = (int)(tr + mred);  
    110.                     tg = (int)(tg + mgreen);  
    111.                     tb = (int)(tb + mblue);  
    112.                     outPixels[index] = (ta << 24) | (clamp(tr) << 16) | (clamp(tg) << 8) | clamp(tb);  
    113.                 } else {  
    114.                     outPixels[index] = (ta << 24) | (clamp((int)mred) << 16) | (clamp((int)mgreen) << 8) | clamp((int)mblue);  
    115.                     // outPixels[index] = (ta << 24) | (clamp((int)ygred) << 16) | (clamp((int)yggreen) << 8) | clamp((int)ygblue);  
    116.                     // outPixels[index] = (ta << 24) | (clamp((int)xgred) << 16) | (clamp((int)xggreen) << 8) | clamp((int)xgblue);  
    117.                 }  
    118.                   
    119.                   
    120.             }  
    121.         }  
    122.         setRGB(dest, 00, width, height, outPixels );  
    123.         return dest;  
    124.     }  
    125.   
    126.     public static int clamp(int c) {  
    127.         if (c < 0)  
    128.             return 0;  
    129.         if (c > 255)  
    130.             return 255;  
    131.         return c;  
    132.     }  
    133. }  
    展开全文
  • 首先要知道梯度是个什么概念,在数学中我们知道梯度是一个向量,函数在一点的梯度在数学上它是这么定义的:它的... 梯度经常应用在图像的边缘检测和边缘增强上面,这和它的一阶微分性质有关。  梯度赋值具有旋转

         首先要知道梯度是个什么概念,在数学中我们知道梯度是一个向量,函数在一点的梯度在数学上它是这么定义的:它的方向是函数在这点的方向导数取得最大值的方向,它的模就等于方向导数的最大值。


       梯度经常用robert交叉微分算子,Prewitt微分算子,sobel算子来实现。


       梯度经常应用在图像的边缘检测和边缘增强上面,这和它的一阶微分性质有关。


       梯度赋值具有旋转不变性。


       下面实现一个sobel实现边缘检测:

    close all;clear all;clc;
    %input = [1 1 1 1 1; 1 1 1 1 2 ;1 1 1 1 1 ];
    input = imread('lena.bmp');
    % mask = 1 / 16 * [1 2 1; 2 4 2; 1 2 1];  % 考虑3*3的滤波模板
    mask = [1 2 1;0 0 0 ;-1 -2 -1]; % sobel算法(注意需要求两个边缘)
    
    % 使用库函数实现(在对sobel求取边缘的时候貌似也得分别求水平和垂直边缘)
    img_h = imfilter(double(input), mask, 'conv', 0, 'full');     %求竖边缘
    img_w = imfilter(double(input), mask','conv', 0, 'full');     %求横边缘
    output1 = sqrt(img_w.^2 + img_h.^2);        % 注意这里不是简单的求平均,而是平方和在开方
    
    % 下面自己实现
    [m, n] = size(input);
    % 先填充输入图像,这里依旧通过0来填充外边界
    input_temp = zeros(m + 4, n + 4);
    
    % 初始化输入图像
    input_temp(3: m + 3 - 1, 3: n + 3 - 1) = input;
    
    % 让模板滑过扩展的输入向量
    xx = size(input_temp, 1) - 3 + 1;
    yy = size(input_temp, 2) - 3 + 1;
    output = zeros(xx,yy);
    
    for i = 1: xx
        for j = 1: yy
            output(i, j) = sum( sum( input_temp(i: i + 3 - 1 , j : j + 3 - 1) .* mask ) ) ;    % 求竖边缘
        end
    end
    for i = 1: xx
        for j = 1: yy
            %注意这里不是简单的求平均,而是平方和在开方。
            output(i, j) = sqrt( output(i,j)^2 + sum( sum( input_temp(i: i + 3 - 1 , j : j + 3 - 1) .* mask' ) )^2 ); % 求横边缘
        end
    end
    fprintf('调用库函数imfilter完成相关运算');
    % output1
    % output
    subplot(131);imshow( uint8(input) );  title('原图像');
    subplot(132);imshow( uint8(output1) );title('调用库函数实现sobel边缘检测');
    subplot(133);imshow( uint8(output) ); title('自己实现sobel边缘检测');
    
    % 看自己的滤波函数是否有问题
    equal = sum(sum(output1 ~= output))   % equal = 0 表示处理后的结果一样

    运行结果图:


    调用库函数imfilter完成相关运算
    equal =
    
           0    

    equal等于0,表明自己实现的均值滤波和库函数得到同样的结果。


    ok,搞定!!!!



    展开全文
  • 图像的二阶微分中,主要是需要掌握图像的拉普拉斯算子。  拉普拉斯是个线性的算子... 二阶微分在增强图像细节方面要比一阶微分好得多。 可通过如下代码产生: fspecial('laplacian', 0) ans = 0 1 0

         在图像的二阶微分中,主要是需要掌握图像的拉普拉斯算子。


         拉普拉斯是个线性的算子。


         具有旋转不变性。


         二阶微分在增强图像细节方面要比一阶微分好得多。


    可通过如下代码产生:

     fspecial('laplacian', 0)
    
    ans =
    
           0              1              0       
           1             -4              1       
           0              1              0      


    展开全文
  • 图像处理之一阶微分应用

    万次阅读 多人点赞 2012-05-13 13:18:45
    图像处理之一阶微分应用 一:数学背景 首先看一下一维的微分公式Δf = f(x+1) – f(x), 对于一幅二维的数字图像f(x,y)而言,需要完 成XY两个方向上的微分,所以有如下的公式: 分别对X,Y两个方向上求出它们的...

    图像处理之一阶微分应用

    一:数学背景

    首先看一下一维的微分公式Δf = f(x+1) – f(x), 对于一幅二维的数字图像f(x,y)而言,需要完

    成XY两个方向上的微分,所以有如下的公式:

    分别对X,Y两个方向上求出它们的偏微分,最终得到梯度Delta F.

    对于离散的图像来说,一阶微分的数学表达相当于两个相邻像素的差值,根据选择的梯度算

    子不同,效果可能有所不同,但是基本原理不会变化。最常见的算子为Roberts算子,其它

    常见还有Sobel,Prewitt等算子。以Roberts算子为例的X,Y的梯度计算演示如下图:


    二:图像微分应用

    图像微分(梯度计算)是图像边缘提取的重要的中间步骤,根据X,Y方向的梯度向量值,可以

    得到如下两个重要参数振幅magnitude, 角度theta,计算公式如下:


    Theta = tan-1(yGradient/xGradient)

    magnitude表示边缘强度信息

    theta预言边缘的方向走势。

    假如对一幅数字图像,求出magnitude之后与原来每个像素点对应值相加,则图像边缘将被

    大大加强,轮廓更加明显,是一个很典型的sharp filter的效果。

     

    三:程序效果

    X, Y梯度效果,及magnitude效果


    图像微分的Sharp效果:


    四:程序源代码

    package com.process.blur.study;
    
    import java.awt.image.BufferedImage;
    
    // roberts operator
    // X direction 1, 0
    //             0,-1
    // Y direction 0, 1
    //			  -1, 0
    
    public class ImageGradientFilter extends AbstractBufferedImageOp {
    	public final static int X_DIRECTION = 0;
    	public final static int Y_DIRECTION = 2;
    	public final static int XY_DIRECTION = 4;
    	
    	private boolean sharp;
    	private int direction;
    	
    	public ImageGradientFilter() {
    		direction = XY_DIRECTION; // default;
    		sharp = false;
    	}
    	
    	public boolean isSharp() {
    		return sharp;
    	}
    
    	public void setSharp(boolean sharp) {
    		this.sharp = sharp;
    	}
    
    	public int getDirection() {
    		return direction;
    	}
    
    	public void setDirection(int direction) {
    		this.direction = direction;
    	}
    
    	@Override
    	public BufferedImage filter(BufferedImage src, BufferedImage dest) {
    		int width = src.getWidth();
            int height = src.getHeight();
    
            if (dest == null )
            	dest = createCompatibleDestImage( src, null );
    
            int[] inPixels = new int[width*height];
            int[] outPixels = new int[width*height];
            getRGB( src, 0, 0, width, height, inPixels );
            int index = 0;
            double mred, mgreen, mblue;
            int newX, newY;
            int index1, index2, index3;
            for(int row=0; row<height; row++) {
            	int ta = 0, tr = 0, tg = 0, tb = 0;
            	for(int col=0; col<width; col++) {
            		index = row * width + col;
            		
            		// base on roberts operator
            		newX = col + 1;
            		newY = row + 1;
            		if(newX > 0 && newX < width) {
            			newX = col + 1;
            		} else {
            			newX = 0;
            		}
            		
            		if(newY > 0 && newY < height) {
            			newY = row + 1;
            		} else {
            			newY = 0;
            		}
            		index1 = newY * width + newX;
            		index2 = row * width + newX;
            		index3 = newY * width + col;
            		ta = (inPixels[index] >> 24) & 0xff;
                    tr = (inPixels[index] >> 16) & 0xff;
                    tg = (inPixels[index] >> 8) & 0xff;
                    tb = inPixels[index] & 0xff;
                    
            		int ta1 = (inPixels[index1] >> 24) & 0xff;
                    int tr1 = (inPixels[index1] >> 16) & 0xff;
                    int tg1 = (inPixels[index1] >> 8) & 0xff;
                    int tb1 = inPixels[index1] & 0xff;
                    
                    int xgred = tr -tr1;
                    int xggreen = tg - tg1;
                    int xgblue = tb - tb1;
                    
            		int ta2 = (inPixels[index2] >> 24) & 0xff;
                    int tr2 = (inPixels[index2] >> 16) & 0xff;
                    int tg2 = (inPixels[index2] >> 8) & 0xff;
                    int tb2 = inPixels[index2] & 0xff;
                    
            		int ta3 = (inPixels[index3] >> 24) & 0xff;
                    int tr3 = (inPixels[index3] >> 16) & 0xff;
                    int tg3 = (inPixels[index3] >> 8) & 0xff;
                    int tb3 = inPixels[index3] & 0xff;
                    
                    int ygred = tr2 - tr3;
                    int yggreen = tg2 - tg3;
                    int ygblue = tb2 - tb3;
                    
                    mred = Math.sqrt(xgred * xgred + ygred * ygred);
                    mgreen = Math.sqrt(xggreen * xggreen + yggreen * yggreen);
                    mblue = Math.sqrt(xgblue * xgblue + ygblue * ygblue);
                    if(sharp) {
                    	tr = (int)(tr + mred);
                    	tg = (int)(tg + mgreen);
                    	tb = (int)(tb + mblue);
                    	outPixels[index] = (ta << 24) | (clamp(tr) << 16) | (clamp(tg) << 8) | clamp(tb);
                    } else {
                        outPixels[index] = (ta << 24) | (clamp((int)mred) << 16) | (clamp((int)mgreen) << 8) | clamp((int)mblue);
                        // outPixels[index] = (ta << 24) | (clamp((int)ygred) << 16) | (clamp((int)yggreen) << 8) | clamp((int)ygblue);
                        // outPixels[index] = (ta << 24) | (clamp((int)xgred) << 16) | (clamp((int)xggreen) << 8) | clamp((int)xgblue);
                    }
                    
                    
            	}
            }
            setRGB(dest, 0, 0, width, height, outPixels );
            return dest;
    	}
    
    	public static int clamp(int c) {
    		if (c < 0)
    			return 0;
    		if (c > 255)
    			return 255;
    		return c;
    	}
    }
    
    转载时请务必注明

    展开全文
  • 数字图像一阶微分和二阶微分

    千次阅读 2018-09-23 15:35:28
    一阶微分:(1)在恒定灰度区域的微分值为零;  (2)在灰度台阶或斜坡处微分值非零;  (3)沿着斜坡的微分值非零; 二阶微分:(1)在恒定灰度区域的微分值为零;  (2)在灰度台阶或斜坡起点处微分值非...
  • 1,斜坡面上,一阶微分一直不为0 ;二阶微分只有终点和起点不为02,一阶微分产生较粗的边缘,二阶微分则细得多3,一阶微分处理一般对灰度阶梯有较强的响应;二阶微分处理细节有较强的响应
  • 数字图像处理--锐化空间滤波器

    千次阅读 2014-12-28 16:42:15
    一阶微分和二阶微分: 人眼更敏感的地方往往是图像细节,因此我们感兴趣的是图像灰度突变的开始点与结束点以及沿着灰度斜坡处的微分性质。 一阶微分的性质: 1) 在恒定灰度区域的微分值为零 2) 在灰度台阶或斜坡...
  • 图像锐化处理的目的是为了使图像的边缘、轮廓线以及图像的细节变得清晰,经过平滑的图像变得模糊的根本原因是因为图像受到了平均或积分运算,因此可以对其进行逆运算(如微分运算,其实这里用的是差分)就可以使图像变...
  • 图像运算中的一阶导与二阶导

    千次阅读 2019-07-04 15:46:40
    首先,图像是离散的数据,若求其导数就要用差分的方法,常用的差分方法是前向差分(forward differencing)与中心差分(central differencing)。一阶导本质上求的是斜率,二阶导求的是拐点。 一阶导 连续函数,其...
  • 图像处理之图像梯度效果

    千次阅读 2017-07-12 15:54:35
    图像处理之图像梯度效果 基本思想: 利用X方向与Y方向分别实现一阶微分,求取振幅,实现图像梯度效果。关于如何计算图像 一阶微分参见这里:http://blog.csdn.net/jia20003/article/details/7562092 ...
  • 图像梯度(微分)及其MATLAB求解

    千次阅读 2016-11-29 10:53:05
    1.一阶梯度 MATLAB中的gradient()函数,实现的是中心梯度。2.二阶梯度 h=fspecial(‘laplacian’)获得的模板是: h = 0.1667 0.6667 0.1667 0.6667 -3.3333 0.6667 0.1667 0.6667 0.1667 不同于常用的模板...
  • 微分滤波器总结

    千次阅读 2019-01-11 20:42:09
    微分滤波器 本质:逻辑上,平滑使用的是积分,锐化则应使用微分。...本质:求得图像一阶或二阶近似梯度图像。 void Sobel( InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize = ...
  • 拉普拉斯的原理

    万次阅读 2014-12-01 22:12:32
    拉普拉斯是一种二阶导数算子,是一个与方向无关的各向同性(旋转轴对称)...一般是将高斯滤波和拉普拉斯边缘检测结合在一起,即log算子优化而成的-----先用高斯算子对图像进行平滑,然后采用拉普拉斯算子根据二阶微分
  • 图像处理中应用微分最常用的方法是计算梯度。对于图像f(x,y),在点(x,y)处的梯度定义为: 梯度是一个向量,其大小和方向为 离散图像处理时,常用到梯度的大小,因此习惯称梯度的大小为“梯度”。并且一阶偏...
  • 图像中的微分运算总结

    千次阅读 2015-08-27 20:16:50
    图像处理中的微分主要应用的是一阶微分和二阶微分两种。这里我们介绍一下图像中微分(求导) 的概念。 1,高数中的导数 2,图像中的导数  上面针对一二阶导数进行了详细讲解,希望对大家有所帮助!
  • 如果图像灰度变化剧烈,进行一阶微分则会形成一个局部的极值,由数学上的知识,对图像进行二阶微分则会形成一个过零点,并且在零点两边产生一个波峰和波谷,我们要设定一个阈值,检测到这个过零点,如下图所示: ...
  • 数字图像处理--图像锐化和边缘检测

    万次阅读 2016-01-24 19:47:51
    本文内容构成:  1、图像锐化和边缘检测的基本概念,微分梯度已经差分的定义  2、锐化和边缘检测的像素... 3、单方向一阶微分锐化,包括:  水平方向  垂直方向  Kirsch算子  4、无方向微分锐化,包括:
  • 图像锐化(增强)和边缘检测

    万次阅读 2014-07-15 17:42:42
    图像锐化和边缘检测 ...3、单方向一阶微分锐化,包括: 水平方向 垂直方向 Kirsch算子 4、无方向微分锐化,包括: Roberts算子 Sobel算子 Prewitt算子 Laplacian算子(二阶微分)
  • 图像边缘一般指图像的灰度变化率最大的位置。成因主要如下: 1.图像灰度在表面法向变化不连续
  • Matlab图像处理—锐化滤波器

    千次阅读 2019-09-03 12:48:06
    锐化滤波器 锐化处理的主要目的是,突出灰度的过渡部分,增强图像中的细节。空间域像素邻域平均法可以使图像变模糊,均值处理与积分类似
1 2 3 4 5 ... 20
收藏数 3,342
精华内容 1,336
关键字:

一阶微分 图像处理