二阶偏导 图像处理 - CSDN
  • 3. 上式以点(i+1,j)为中心,用i代换i+1可得以(i,j)为中心的二阶偏导数则有:   4. 同理:   5. 进而可推导:   6. 这样我们就可以很好的运用其他的一阶偏导的定义,如SIFT...

     1. 一阶差分:

     

    2. 二阶偏导数的推导和近似:

     

    3. 上式以点(i+1,j)为中心,用i代换i+1可得以(i,j)为中心的二阶偏导数则有:

     

    4. 同理:

     

    5. 进而可推导:

     

    6. 这样我们就可以很好的运用其他的一阶偏导的定义,如SIFT特征OpenCV实现版本中的一阶以及二阶偏导:

    [cpp] view plain copy
    1. /* 
    2. Computes the partial derivatives in x, y, and scale of a pixel in the DoG 
    3. scale space pyramid. 
    4.  
    5. @param dog_pyr DoG scale space pyramid 
    6. @param octv pixel's octave in dog_pyr 
    7. @param intvl pixel's interval in octv 
    8. @param r pixel's image row 
    9. @param c pixel's image col 
    10.  
    11. @return Returns the vector of partial derivatives for pixel I 
    12.     { dI/dx, dI/dy, dI/ds }^T as a CvMat* 
    13. */  
    14. static CvMat* deriv_3D( IplImage*** dog_pyr, int octv, int intvl, int r, int c )  
    15. {  
    16.     CvMat* dI;  
    17.     double dx, dy, ds;  
    18.   
    19.     dx = ( pixval32f( dog_pyr[octv][intvl], r, c+1 ) -  
    20.         pixval32f( dog_pyr[octv][intvl], r, c-1 ) ) / 2.0;  
    21.     dy = ( pixval32f( dog_pyr[octv][intvl], r+1, c ) -  
    22.         pixval32f( dog_pyr[octv][intvl], r-1, c ) ) / 2.0;  
    23.     ds = ( pixval32f( dog_pyr[octv][intvl+1], r, c ) -  
    24.         pixval32f( dog_pyr[octv][intvl-1], r, c ) ) / 2.0;  
    25.   
    26.     dI = cvCreateMat( 3, 1, CV_64FC1 );  
    27.     cvmSet( dI, 0, 0, dx );  
    28.     cvmSet( dI, 1, 0, dy );  
    29.     cvmSet( dI, 2, 0, ds );  
    30.   
    31.     return dI;  
    32. }  
    33.   
    34.   
    35.   
    36. /* 
    37. Computes the 3D Hessian matrix for a pixel in the DoG scale space pyramid. 
    38.  
    39. @param dog_pyr DoG scale space pyramid 
    40. @param octv pixel's octave in dog_pyr 
    41. @param intvl pixel's interval in octv 
    42. @param r pixel's image row 
    43. @param c pixel's image col 
    44.  
    45. @return Returns the Hessian matrix (below) for pixel I as a CvMat* 
    46.  
    47.     / Ixx  Ixy  Ixs / <BR> 
    48.     | Ixy  Iyy  Iys | <BR> 
    49.     / Ixs  Iys  Iss / 
    50. */  
    51. static CvMat* hessian_3D( IplImage*** dog_pyr, int octv, int intvl, int r, int c )  
    52. {  
    53.     CvMat* H;  
    54.     double v, dxx, dyy, dss, dxy, dxs, dys;  
    55.   
    56.     v = pixval32f( dog_pyr[octv][intvl], r, c );  
    57.     dxx = ( pixval32f( dog_pyr[octv][intvl], r, c+1 ) +   
    58.             pixval32f( dog_pyr[octv][intvl], r, c-1 ) - 2 * v );  
    59.     dyy = ( pixval32f( dog_pyr[octv][intvl], r+1, c ) +  
    60.             pixval32f( dog_pyr[octv][intvl], r-1, c ) - 2 * v );  
    61.     dss = ( pixval32f( dog_pyr[octv][intvl+1], r, c ) +  
    62.             pixval32f( dog_pyr[octv][intvl-1], r, c ) - 2 * v );  
    63.     dxy = ( pixval32f( dog_pyr[octv][intvl], r+1, c+1 ) -  
    64.             pixval32f( dog_pyr[octv][intvl], r+1, c-1 ) -  
    65.             pixval32f( dog_pyr[octv][intvl], r-1, c+1 ) +  
    66.             pixval32f( dog_pyr[octv][intvl], r-1, c-1 ) ) / 4.0;  
    67.     dxs = ( pixval32f( dog_pyr[octv][intvl+1], r, c+1 ) -  
    68.             pixval32f( dog_pyr[octv][intvl+1], r, c-1 ) -  
    69.             pixval32f( dog_pyr[octv][intvl-1], r, c+1 ) +  
    70.             pixval32f( dog_pyr[octv][intvl-1], r, c-1 ) ) / 4.0;  
    71.     dys = ( pixval32f( dog_pyr[octv][intvl+1], r+1, c ) -  
    72.             pixval32f( dog_pyr[octv][intvl+1], r-1, c ) -  
    73.             pixval32f( dog_pyr[octv][intvl-1], r+1, c ) +  
    74.             pixval32f( dog_pyr[octv][intvl-1], r-1, c ) ) / 4.0;  
    75.   
    76.     H = cvCreateMat( 3, 3, CV_64FC1 );  
    77.     cvmSet( H, 0, 0, dxx );  
    78.     cvmSet( H, 0, 1, dxy );  
    79.     cvmSet( H, 0, 2, dxs );  
    80.     cvmSet( H, 1, 0, dxy );  
    81.     cvmSet( H, 1, 1, dyy );  
    82.     cvmSet( H, 1, 2, dys );  
    83.     cvmSet( H, 2, 0, dxs );  
    84.     cvmSet( H, 2, 1, dys );  
    85.     cvmSet( H, 2, 2, dss );  
    86.   
    87.     return H;  
    88. }  

     

    参考:

    (1)http://hi.baidu.com/shareshow/blog/item/34abdf544725cf54d109069b.html

    (2)SIFT的OpenCV实现

    展开全文
  • Opencv--图像处理之一阶和二阶偏导

    千次阅读 2019-04-02 09:32:07
    3. 上式以点(i+1,j)为中心,用i代换i+1可得以(i,j)为中心的二阶偏导数则有:   4. 同理:   5. 进而可推导:   6. 这样我们就可以很好的运用其他的一阶偏导的定义,如SIFT特征...

     1. 一阶差分:

    2. 二阶偏导数的推导和近似:

    3. 上式以点(i+1,j)为中心,用i代换i+1可得以(i,j)为中心的二阶偏导数则有:

    4. 同理:

    5. 进而可推导:

    6. 这样我们就可以很好的运用其他的一阶偏导的定义,如SIFT特征OpenCV实现版本中的一阶以及二阶偏导:

    /*
    Computes the partial derivatives in x, y, and scale of a pixel in the DoG
    scale space pyramid.
    @param dog_pyr DoG scale space pyramid
    @param octv pixel's octave in dog_pyr
    @param intvl pixel's interval in octv
    @param r pixel's image row
    @param c pixel's image col
    @return Returns the vector of partial derivatives for pixel I
    	{ dI/dx, dI/dy, dI/ds }^T as a CvMat*
    */
    static CvMat* deriv_3D( IplImage*** dog_pyr, int octv, int intvl, int r, int c )
    {
    	CvMat* dI;
    	double dx, dy, ds;
    	dx = ( pixval32f( dog_pyr[octv][intvl], r, c+1 ) -
    		pixval32f( dog_pyr[octv][intvl], r, c-1 ) ) / 2.0;
    	dy = ( pixval32f( dog_pyr[octv][intvl], r+1, c ) -
    		pixval32f( dog_pyr[octv][intvl], r-1, c ) ) / 2.0;
    	ds = ( pixval32f( dog_pyr[octv][intvl+1], r, c ) -
    		pixval32f( dog_pyr[octv][intvl-1], r, c ) ) / 2.0;
    	dI = cvCreateMat( 3, 1, CV_64FC1 );
    	cvmSet( dI, 0, 0, dx );
    	cvmSet( dI, 1, 0, dy );
    	cvmSet( dI, 2, 0, ds );
    	return dI;
    }
    /*
    Computes the 3D Hessian matrix for a pixel in the DoG scale space pyramid.
    @param dog_pyr DoG scale space pyramid
    @param octv pixel's octave in dog_pyr
    @param intvl pixel's interval in octv
    @param r pixel's image row
    @param c pixel's image col
    @return Returns the Hessian matrix (below) for pixel I as a CvMat*
    	/ Ixx  Ixy  Ixs / &lt;BR&gt;
    	| Ixy  Iyy  Iys | &lt;BR&gt;
    	/ Ixs  Iys  Iss /
    */
    static CvMat* hessian_3D( IplImage*** dog_pyr, int octv, int intvl, int r, int c )
    {
    	CvMat* H;
    	double v, dxx, dyy, dss, dxy, dxs, dys;
    	v = pixval32f( dog_pyr[octv][intvl], r, c );
    	dxx = ( pixval32f( dog_pyr[octv][intvl], r, c+1 ) + 
    			pixval32f( dog_pyr[octv][intvl], r, c-1 ) - 2 * v );
    	dyy = ( pixval32f( dog_pyr[octv][intvl], r+1, c ) +
    			pixval32f( dog_pyr[octv][intvl], r-1, c ) - 2 * v );
    	dss = ( pixval32f( dog_pyr[octv][intvl+1], r, c ) +
    			pixval32f( dog_pyr[octv][intvl-1], r, c ) - 2 * v );
    	dxy = ( pixval32f( dog_pyr[octv][intvl], r+1, c+1 ) -
    			pixval32f( dog_pyr[octv][intvl], r+1, c-1 ) -
    			pixval32f( dog_pyr[octv][intvl], r-1, c+1 ) +
    			pixval32f( dog_pyr[octv][intvl], r-1, c-1 ) ) / 4.0;
    	dxs = ( pixval32f( dog_pyr[octv][intvl+1], r, c+1 ) -
    			pixval32f( dog_pyr[octv][intvl+1], r, c-1 ) -
    			pixval32f( dog_pyr[octv][intvl-1], r, c+1 ) +
    			pixval32f( dog_pyr[octv][intvl-1], r, c-1 ) ) / 4.0;
    	dys = ( pixval32f( dog_pyr[octv][intvl+1], r+1, c ) -
    			pixval32f( dog_pyr[octv][intvl+1], r-1, c ) -
    			pixval32f( dog_pyr[octv][intvl-1], r+1, c ) +
    			pixval32f( dog_pyr[octv][intvl-1], r-1, c ) ) / 4.0;
    	H = cvCreateMat( 3, 3, CV_64FC1 );
    	cvmSet( H, 0, 0, dxx );
    	cvmSet( H, 0, 1, dxy );
    	cvmSet( H, 0, 2, dxs );
    	cvmSet( H, 1, 0, dxy );
    	cvmSet( H, 1, 1, dyy );
    	cvmSet( H, 1, 2, dys );
    	cvmSet( H, 2, 0, dxs );
    	cvmSet( H, 2, 1, dys );
    	cvmSet( H, 2, 2, dss );
    	return H;
    }
    

    转载自:https://blog.csdn.net/xiaofengsheng/article/details/6023368

    展开全文
  • 图像二阶导数的推导

    千次阅读 多人点赞 2018-01-06 17:54:36
    前面我们介绍过了图像的梯度,以及图像的几个梯度算子。 这些本质上都是一阶导数,或一阶微分。就是求图像灰度变化的导数,能够突出图像中的对象边缘。那有一阶导数,有没有二阶导数呢?求导数的导数,这对灰度变化...

    前面我们介绍过了图像的梯度,以及图像的几个梯度算子。

    这些本质上都是一阶导数,或一阶微分。就是求图像灰度变化的导数,能够突出图像中的对象边缘。那有一阶导数,有没有二阶导数呢?求导数的导数,这对灰度变化强烈的地方会更敏感。

    在微积分中,一维函数的一阶微分的基本定义是这样的:

    dfdx=limϵ0f(x+ϵ)f(x)ϵ

    那么,二阶微分的基本定义就是这样的:

    d2fdx2=limϵ0f(x+ϵ)f(x)ϵ

    而图像是一个二维函数f(x,y),其二阶微分当然就是二阶偏微分。但为推导简单起见,我们先按x方向的一维函数来推导:

    fx=limϵ0f(x+ϵ)f(x)ϵ

    图像是按照像素来离散的,最小的ϵ就是1像素。因此有:

    fx=f(x)=f(x+1)f(x)

    那么二阶微分就是:

    2fx2=f(x)dx2=f(x+1)f(x)

    根据上面的一阶微分,则:

    2fx2=f(x)dx2=f(x+1)f(x)

    =f((x+1)+1)f((x+1))(f(x+1)f(x))

    =f(x+2)f(x+1)f(x+1)+f(x)

    =f(x+2)2f(x+1)+f(x)

    令x=x-1
    则:

    2fx2=f(x+1)+f(x1)2f(x)

    于是,在x和y方向上,有:

    2fx2=f(x+1,y)+f(x1,y)2f(x,y)

    2fy2=f(x,y+1)+f(x,y1)2f(x,y)

    我们把x方向和y方向的二阶导数结合在一起:

    2fx2+2fy2=f(x+1,y)+f(x1,y)+f(x,y+1)+f(x,y1)4f(x,y)

    这实质上就是著名的拉普拉斯二阶微分算子(Laplacian)。我们看一下实际效果。

    import cv2
    import numpy as np
    
    moon = cv2.imread("moon.tif", 0)
    row, column = moon.shape
    moon_f = np.copy(moon)
    moon_f = moon_f.astype("float")
    
    two = np.zeros((row, column))
    
    for x in range(1, row - 1):
        for y in range(1, column - 1):
            two[x, y] = moon_f[x + 1, y] \
                        + moon_f[x - 1, y] \
                        + moon_f[x, y + 1] \
                        + moon_f[x, y - 1] \
                        - 4 * moon_f[x, y]
    
    sharp = moon_f - two
    sharp = np.where(sharp < 0, 0, np.where(sharp > 255, 255, sharp))
    sharp = sharp.astype("uint8")
    
    cv2.imshow("moon", moon)
    cv2.imshow("sharp", sharp)
    cv2.waitKey()
    

    输出结果:
    这里写图片描述

    我们可以看到,图像增强的效果比前几篇文章介绍的一阶微分要好很多。

    需要注意,将原图像与拉普拉斯二阶导数图像合并的时候,必须考虑符号上的差别。注意上面的代码中用的是减号,而不是一阶导数中用的加号。到底用加号还是减号,与中心点f(x,y)的系数有关,这个定义的拉普拉斯二阶导数中,f(x,y)的系数是-4,是负的,原图像就要减去拉普拉斯二阶导数图像;拉普拉斯二阶导数还有其它的形式,例如:

    Laplacian=4f(x,y)f(x+1,y)f(x1,y)f(x,y+1)f(x,y1)

    这时f(x,y)的系数是正的,原图像就要加上拉普拉斯二阶导数图像。

    到这里,我们已经注意到,前面介绍图像一阶导数时,用的是绝对值,而二阶导数就没有使用绝对值,且需要考虑系数的正负符号问题,才能决定最后的图像合并是用原图像加上还是减去二阶导数图像,为什么是这样?这个下一篇再探讨。

    展开全文
  • 图像处理之高斯一阶及二阶导数计算

    万次阅读 多人点赞 2013-11-17 13:13:00
    演示图像中高斯一阶与二阶导数的计算方法,这个在图像的特征提取与处理中十分有用! 一阶导数可以反应出图像灰度梯度的变化情况 二阶导数可以提取出图像的细节同时双响应图像梯度变化情况

    图像处理之高斯一阶及二阶导数计算

     

    图像的一阶与二阶导数计算在图像特征提取与边缘提取中十分重要。一阶与二阶导数的

    作用,通常情况下:

    一阶导数可以反应出图像灰度梯度的变化情况

    二阶导数可以提取出图像的细节同时双响应图像梯度变化情况

    常见的算子有Robot, Sobel算子,二阶常见多数为拉普拉斯算子,如图所示:


    对于一个1D的有限集合数据f(x) = {1…N}, 假设dx的间隔为1则一阶导数计算公式如下:

    Df(x) = f(x+1) – f(x-1) 二阶导数的计算公式为:df(x)= f(x+1) + f(x-1) – 2f(x);

    稍微难一点的则是基于高斯的一阶导数与二阶导数求取,首先看一下高斯的1D与2D的

    公式。一维高斯对应的X阶导数公式:


    二维高斯对应的导数公式:


    二:算法实现

    1.      高斯采样,基于间隔1计算,计算mask窗口计算,这样就跟普通的卷积计算差不多

    2.      设置sigma的值,本例默认为10,首先计算高斯窗口函数,默认为3 * 3

    3.      根据2的结果,计算高斯导数窗口值

    4.      卷积计算像素中心点值。

    注意点计算高斯函数一定要以零为中心点, 如果窗口函数大小为3,则表达为-1, 0, 1

    三:程序实现关键点

    1.      归一化处理,由于高斯计算出来的窗口值非常的小,必须实现归一化处理。

    2.      亮度提升,对X,Y的梯度计算结果进行了亮度提升,目的是让大家看得更清楚。

    3.      支持一阶与二阶单一方向X,Y偏导数计算

    四:运行效果:

    高斯一阶导数X方向效果


    高斯一阶导数Y方向效果


    五:算法全部源代码:

    /*
     * @author: gloomyfish
     * @date: 2013-11-17
     * 
     * Title - Gaussian fist order derivative and second derivative filter
     */
    package com.gloomyfish.image.harris.corner;
    import java.awt.image.BufferedImage;
    
    import com.gloomyfish.filter.study.AbstractBufferedImageOp;
    
    public class GaussianDerivativeFilter extends AbstractBufferedImageOp {
    
    	public final static int X_DIRECTION = 0;
    	public final static int Y_DIRECTION = 16;
    	public final static int XY_DIRECTION = 2;
    	public final static int XX_DIRECTION = 4;
    	public final static int YY_DIRECTION = 8;
    	
    	// private attribute and settings
    	private int DIRECTION_TYPE = 0;
    	private int GAUSSIAN_WIN_SIZE = 1; // N*2 + 1
    	private double sigma = 10; // default
    
    	public GaussianDerivativeFilter()
    	{
    		System.out.println("高斯一阶及多阶导数滤镜");
    	}	
    	
    	public int getGaussianWinSize() {
    		return GAUSSIAN_WIN_SIZE;
    	}
    
    	public void setGaussianWinSize(int gAUSSIAN_WIN_SIZE) {
    		GAUSSIAN_WIN_SIZE = gAUSSIAN_WIN_SIZE;
    	}
    	public int getDirectionType() {
    		return DIRECTION_TYPE;
    	}
    
    	public void setDirectionType(int dIRECTION_TYPE) {
    		DIRECTION_TYPE = dIRECTION_TYPE;
    	}
    
    	@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, index2 = 0;
            double xred = 0, xgreen = 0, xblue = 0;
            // double yred = 0, ygreen = 0, yblue = 0;
            int newRow, newCol;
            double[][] winDeviationData = getDirectionData();
    
            for(int row=0; row<height; row++) {
            	int ta = 255, tr = 0, tg = 0, tb = 0;
            	for(int col=0; col<width; col++) {
            		index = row * width + col;
            		for(int subrow = -GAUSSIAN_WIN_SIZE; subrow <= GAUSSIAN_WIN_SIZE; subrow++) {
            			for(int subcol = -GAUSSIAN_WIN_SIZE; subcol <= GAUSSIAN_WIN_SIZE; subcol++) {
            				newRow = row + subrow;
            				newCol = col + subcol;
            				if(newRow < 0 || newRow >= height) {
            					newRow = row;
            				}
            				if(newCol < 0 || newCol >= width) {
            					newCol = col;
            				}
            				index2 = newRow * width + newCol;
                            tr = (inPixels[index2] >> 16) & 0xff;
                            tg = (inPixels[index2] >> 8) & 0xff;
                            tb = inPixels[index2] & 0xff;
                        	xred += (winDeviationData[subrow + GAUSSIAN_WIN_SIZE][subcol + GAUSSIAN_WIN_SIZE] * tr);
                        	xgreen +=(winDeviationData[subrow + GAUSSIAN_WIN_SIZE][subcol + GAUSSIAN_WIN_SIZE] * tg);
                        	xblue +=(winDeviationData[subrow + GAUSSIAN_WIN_SIZE][subcol + GAUSSIAN_WIN_SIZE] * tb);
            			}
            		}
            		
            		outPixels[index] = (ta << 24) | (clamp((int)xred) << 16) | (clamp((int)xgreen) << 8) | clamp((int)xblue);
            		
            		// clean up values for next pixel
                    newRow = newCol = 0;
                    xred = xgreen = xblue = 0;
                    // yred = ygreen = yblue = 0;
            	}
            }
    
            setRGB( dest, 0, 0, width, height, outPixels );
            return dest;
    	}
    	
    	private double[][] getDirectionData()
    	{
    		double[][] winDeviationData = null;
            if(DIRECTION_TYPE == X_DIRECTION)
            {
            	winDeviationData = this.getXDirectionDeviation();
            }
            else if(DIRECTION_TYPE == Y_DIRECTION)
            {
            	winDeviationData = this.getYDirectionDeviation();
            }
            else if(DIRECTION_TYPE == XY_DIRECTION)
            {
            	winDeviationData = this.getXYDirectionDeviation();
            }
            else if(DIRECTION_TYPE == XX_DIRECTION)
            {
            	winDeviationData = this.getXXDirectionDeviation();
            }
            else if(DIRECTION_TYPE == YY_DIRECTION)
            {
            	winDeviationData = this.getYYDirectionDeviation();
            }
            return winDeviationData;
    	}
    	
    	public int clamp(int value) {
    		// trick, just improve the lightness otherwise image is too darker...
    		if(DIRECTION_TYPE == X_DIRECTION || DIRECTION_TYPE == Y_DIRECTION)
    		{
    			value = value * 10 + 50;
    		}
    		return value < 0 ? 0 : (value > 255 ? 255 : value);
    	}
    	
    	// centered on zero and with Gaussian standard deviation
    	// parameter : sigma
    	public double[][] get2DGaussianData()
    	{
    		int size = GAUSSIAN_WIN_SIZE * 2 + 1;
    		double[][] winData = new double[size][size];
    		double sigma2 = this.sigma * sigma;
    		for(int i=-GAUSSIAN_WIN_SIZE; i<=GAUSSIAN_WIN_SIZE; i++)
    		{
    			for(int j=-GAUSSIAN_WIN_SIZE; j<=GAUSSIAN_WIN_SIZE; j++)
    			{
    				double r = i*1 + j*j;
    				double sum = -(r/(2*sigma2));
    				winData[i + GAUSSIAN_WIN_SIZE][j + GAUSSIAN_WIN_SIZE] = Math.exp(sum);
    			}
    		}
    		return winData;
    	}
    	
    	public double[][] getXDirectionDeviation()
    	{
    		int size = GAUSSIAN_WIN_SIZE * 2 + 1;
    		double[][] data = get2DGaussianData();
    		double[][] xDeviation = new double[size][size];
    		double sigma2 = this.sigma * sigma;
    		for(int x=-GAUSSIAN_WIN_SIZE; x<=GAUSSIAN_WIN_SIZE; x++)
    		{
    			double c = -(x/sigma2);
    			for(int i=0; i<size; i++)
    			{
    				xDeviation[i][x + GAUSSIAN_WIN_SIZE] = c * data[i][x + GAUSSIAN_WIN_SIZE];				
    			}
    		}
    		return xDeviation;
    	}
    	
    	public double[][] getYDirectionDeviation()
    	{
    		int size = GAUSSIAN_WIN_SIZE * 2 + 1;
    		double[][] data = get2DGaussianData();
    		double[][] yDeviation = new double[size][size];
    		double sigma2 = this.sigma * sigma;
    		for(int y=-GAUSSIAN_WIN_SIZE; y<=GAUSSIAN_WIN_SIZE; y++)
    		{
    			double c = -(y/sigma2);
    			for(int i=0; i<size; i++)
    			{
    				yDeviation[y + GAUSSIAN_WIN_SIZE][i] = c * data[y + GAUSSIAN_WIN_SIZE][i];				
    			}
    		}
    		return yDeviation;
    	}
    	
    	/***
    	 * 
    	 * @return
    	 */
    	public double[][] getXYDirectionDeviation()
    	{
    		int size = GAUSSIAN_WIN_SIZE * 2 + 1;
    		double[][] data = get2DGaussianData();
    		double[][] xyDeviation = new double[size][size];
    		double sigma2 = sigma * sigma;
    		double sigma4 = sigma2 * sigma2;
    		// TODO:zhigang
    		for(int x=-GAUSSIAN_WIN_SIZE; x<=GAUSSIAN_WIN_SIZE; x++)
    		{
    			for(int y=-GAUSSIAN_WIN_SIZE; y<=GAUSSIAN_WIN_SIZE; y++)
    			{
    				double c = -((x*y)/sigma4);
    				xyDeviation[x + GAUSSIAN_WIN_SIZE][y + GAUSSIAN_WIN_SIZE] = c * data[x + GAUSSIAN_WIN_SIZE][y + GAUSSIAN_WIN_SIZE];
    			}
    		}
    		return normalizeData(xyDeviation);
    	}
    	
    	private double[][] normalizeData(double[][] data)
    	{
    		// normalization the data
    		double min = data[0][0];
    		for(int x=-GAUSSIAN_WIN_SIZE; x<=GAUSSIAN_WIN_SIZE; x++)
    		{
    			for(int y=-GAUSSIAN_WIN_SIZE; y<=GAUSSIAN_WIN_SIZE; y++)
    			{
    				if(min > data[x + GAUSSIAN_WIN_SIZE][y + GAUSSIAN_WIN_SIZE])
    				{
    					min = data[x + GAUSSIAN_WIN_SIZE][y + GAUSSIAN_WIN_SIZE];
    				}
    			}
    		}
    		
    		for(int x=-GAUSSIAN_WIN_SIZE; x<=GAUSSIAN_WIN_SIZE; x++)
    		{
    			for(int y=-GAUSSIAN_WIN_SIZE; y<=GAUSSIAN_WIN_SIZE; y++)
    			{
    				data[x + GAUSSIAN_WIN_SIZE][y + GAUSSIAN_WIN_SIZE] = data[x + GAUSSIAN_WIN_SIZE][y + GAUSSIAN_WIN_SIZE] /min;
    			}
    		}
    		
    		return data;
    	}
    	
    	public double[][] getXXDirectionDeviation()
    	{
    		int size = GAUSSIAN_WIN_SIZE * 2 + 1;
    		double[][] data = get2DGaussianData();
    		double[][] xxDeviation = new double[size][size];
    		double sigma2 = this.sigma * sigma;
    		double sigma4 = sigma2 * sigma2;
    		for(int x=-GAUSSIAN_WIN_SIZE; x<=GAUSSIAN_WIN_SIZE; x++)
    		{
    			double c = -((x - sigma2)/sigma4);
    			for(int i=0; i<size; i++)
    			{
    				xxDeviation[i][x + GAUSSIAN_WIN_SIZE] = c * data[i][x + GAUSSIAN_WIN_SIZE];				
    			}
    		}
    		return xxDeviation;
    	}
    	
    	public double[][] getYYDirectionDeviation()
    	{
    		int size = GAUSSIAN_WIN_SIZE * 2 + 1;
    		double[][] data = get2DGaussianData();
    		double[][] yyDeviation = new double[size][size];
    		double sigma2 = this.sigma * sigma;
    		double sigma4 = sigma2 * sigma2;
    		for(int y=-GAUSSIAN_WIN_SIZE; y<=GAUSSIAN_WIN_SIZE; y++)
    		{
    			double c = -((y - sigma2)/sigma4);
    			for(int i=0; i<size; i++)
    			{
    				yyDeviation[y + GAUSSIAN_WIN_SIZE][i] = c * data[y + GAUSSIAN_WIN_SIZE][i];				
    			}
    		}
    		return yyDeviation;
    	}
    
    }
    

    国足都战胜亚洲强队印尼了,我还有什么理由不坚持写下去!

    转载请务必注明!!!
    展开全文
  • 图像处理中的一阶偏导和二阶偏导

    千次阅读 2015-02-11 15:40:20
    2. 二阶偏导数的推导和近似: 3. 上式以点(i+1,j)为中心,用i代换i+1可得以(i,j)为中心的二阶偏导数则有: 4. 同理: 5. 进而可推导: 6. 这样我们就可以很好的运用其他的一阶偏导的定义,...
  • 前面我们介绍过了图像的梯度,以及图像的几个梯度算子。 这些本质上都是一阶导数,或一阶微分。就是求图像灰度变化的导数,能够突出图像中的对象边缘。那有一阶导数,有没有二阶导数呢?求导数的导数,这对灰度变化...
  • 图像处理中的一阶导数与二阶导数

    千次阅读 2018-05-09 21:26:56
    一阶导数与二阶导数的计算 图像I可以看作(x,y)∈N2→N的映射: i=f(x,y). 其中N为正整数....不连续函数f(x,y)的导数, 严格来说不算能算作导数, 只是形式上与真正的导数相似.... 一阶与二阶偏导数分
  • In mathematics, the Hessian matrix is the square matrix of second-order partial derivatives of afunction; that is, it describes the local curvature of a function of many variables....
  • 1. 对每个像素点计算图像在X方向Y方向的二阶偏导数,计算图像的XY方向的导数 2. 根据第一步的计算结果,有Hessian Matrix计算D(h) = Ixx*Iyy - Ixy*Ixy 其中Ixx表示X方向的二阶偏导数 Iyy表示Y方向的二阶偏导数...
  • 二、矩阵二阶偏导数  1. X轴方向上二阶偏导  2. Y轴方向上二阶偏导  3.第一次在X轴方向上求偏导,第二次在Y轴方向上求偏导  4.第一次在Y轴方向上求偏导,第二次在X轴方向上求偏导  5.结论 三、拉普拉斯...
  • 图像的梯度(The Gradient of Image)

    千次阅读 2018-11-28 14:25:29
    图像的梯度(The Gradient of...后来在看到图像分割这一模块后才恍然大悟,其实图像的梯度可以用一阶导数和二阶偏导数来求解。但是图像以矩阵的形式存储的,不能像数学理论中对直线或者曲线求导一样,对一幅图像的求...
1 2 3 4 5 ... 20
收藏数 2,466
精华内容 986
热门标签
关键字:

二阶偏导 图像处理