2016-04-03 20:32:14 u011483307 阅读数 269

预备知识:
泰勒公式:如果函数f(x)在含有x0的某个开区间(a,b)内有直到(n+1)阶的导数,则对任一x(a,b),有

f(x)=f(x0)+f(x0)(xx0)+f′′(x0)2!(xx0)2++f(n)(x0)n!(xx0)n+Rn(x)

其中
Rn(x)=f(n+1)(ξ)(n+1)!(xx0)n+1

这里ξx0x之间的某个值.

问题:
证明:图像处理中,一阶微分的基本定义是差值,

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

解:

f(x+1)=f(x0)+f(x0)(x+1x0)+f′′(x0)2!(x+1x0)2+

f(x)=f(x0)+f(x0)(xx0)+f′′(x0)2!(xx0)2+

将上面的两个式子进行相减,保留式子的线性项,即可得:
fx=f(x+1)f(x)

2015-07-24 10:07:43 mao0514 阅读数 2150

一:数学背景

首先看一下一维的微分公式Δ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. }  
2014-12-26 08:41:58 hh555800 阅读数 2471

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


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


     具有旋转不变性。


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


可通过如下代码产生:

 fspecial('laplacian', 0)

ans =

       0              1              0       
       1             -4              1       
       0              1              0      


2014-12-25 11:38:49 hh555800 阅读数 4183

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


   梯度经常用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,搞定!!!!



2013-12-02 21:19:02 zhangpinghao 阅读数 2937

更复杂些的滤波算子一般是先利用高斯滤波来平滑,然后计算其1阶和2阶微分。由于它们滤除高频和低频,因此称为带通滤波器(band-pass filters)。

在介绍具体的带通滤波器前,先介绍必备的图像微分知识。

1 一阶导数

连续函数,其微分可表达为image ,或image                         (1.1)

对于离散情况(图像),其导数必须用差分方差来近似,有

                                   image,前向差分 forward differencing                  (1.2)

                                   image ,中心差分 central differencing                     (1.3)

1)前向差分的Matlab实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
function dimg = mipforwarddiff(img,direction)
% MIPFORWARDDIFF     Finite difference calculations
%
%   DIMG = MIPFORWARDDIFF(IMG,DIRECTION)
%
%  Calculates the forward-difference for a given direction
%  IMG       : input image
%  DIRECTION : 'dx' or'dy'
%  DIMG      : resultant image
%
%   See also MIPCENTRALDIFF MIPBACKWARDDIFF MIPSECONDDERIV
%   MIPSECONDPARTIALDERIV
 
%   Omer Demirkaya, Musa Asyali, Prasana Shaoo, ... 9/1/06
%   Medical Image Processing Toolbox
 
imgPad = padarray(img,[1 1],'symmetric','both');%将原图像的边界扩展
[row,col] = size(imgPad);
dimg = zeros(row,col);
switch (direction)  
case 'dx',
   dimg(:,1:col-1) = imgPad(:,2:col)-imgPad(:,1:col-1);%x方向差分计算,
case 'dy',
   dimg(1:row-1,:) = imgPad(2:row,:)-imgPad(1:row-1,:);
otherwise, disp('Direction is unknown');
end;
dimg = dimg(2:end-1,2:end-1);

2)中心差分的Matlab实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
function dimg = mipcentraldiff(img,direction)
% MIPCENTRALDIFF     Finite difference calculations
%
%   DIMG = MIPCENTRALDIFF(IMG,DIRECTION)
%
%  Calculates the central-difference for a given direction
%  IMG       : input image
%  DIRECTION : 'dx' or'dy'
%  DIMG      : resultant image
%
%   See also MIPFORWARDDIFF MIPBACKWARDDIFF MIPSECONDDERIV
%   MIPSECONDPARTIALDERIV
 
%   Omer Demirkaya, Musa Asyali, Prasana Shaoo, ... 9/1/06
%   Medical Image Processing Toolbox
 
img = padarray(img,[1 1],'symmetric','both');
[row,col] = size(img);
dimg = zeros(row,col);
switch (direction)
    case 'dx',
        dimg(:,2:col-1) = (img(:,3:col)-img(:,1:col-2))/2;
    case 'dy',
        dimg(2:row-1,:) = (img(3:row,:)-img(1:row-2,:))/2;
    otherwise,
        disp('Direction is unknown');
end
dimg = dimg(2:end-1,2:end-1);
1
  

实例:技术图像x方向导数

1
2
I = imread('coins.png'); figure; imshow(I);
Id = mipforwarddiff(I,'dx'); figure, imshow(Id);

      image image

    原图像                                                   x方向1阶导数

 

2 图像梯度(Image Gradient)

图像I的梯度定义为image  ,其幅值为image 。出于计算性能考虑,幅值也可用image 来近似。

Matlab函数

1)gradient:梯度计算

2)quiver:以箭头形状绘制梯度。注意放大下面最右侧图可看到箭头,由于这里计算横竖两个方向的梯度,因此箭头方向都是水平或垂直的。

实例:仍采用上面的原始图像

1
2
3
4
5
I = double(imread('coins.png'));
[dx,dy]=gradient(I);
magnitudeI=sqrt(dx.^2+dy.^2);
figure;imagesc(magnitudeI);colormap(gray);%梯度幅值
holdon;quiver(dx,dy);%叠加梯度方向

        image image

                         梯度幅值                                   梯度幅值+梯度方向

 

3 二阶导数

对于一维函数,其二阶导数image ,即image 。它的差分函数为

                                 image                  (3.1)

 

3.1 普拉斯算子(laplacian operator)

3.1.2 概念

拉普拉斯算子是n维欧式空间的一个二阶微分算子。它定义为两个梯度向量算子的内积

                           image       (3.2)

其在二维空间上的公式为:    image                (3.3)

 

对于1维离散情况,其二阶导数变为二阶差分

1)首先,其一阶差分为image

2)因此,二阶差分为

           image

3)因此,1维拉普拉斯运算可以通过1维卷积核image 实现

 

对于2维离散情况(图像),拉普拉斯算子是2个维上二阶差分的和(见式3.3),其公式为:

image   (3.4)

上式对应的卷积核为

                       image

常用的拉普拉斯核有:

                      image

3.1.2 应用

拉普拉斯算子会突出像素值快速变化的区域,因此常用于边缘检测。

 

 

Matlab里有两个函数

1)del2

计算公式:image ,image  

2)fspecial:图像处理中一般利用Matlab函数fspecial

h = fspecial('laplacian', alpha) returns a 3-by-3 filter approximating the shape of the two-dimensional Laplacian operator.
The parameter alpha controls the shape of the Laplacian and must be in the range 0.0 to 1.0. The default value for alpha is 0.2.



图像处理之一阶微分应用

一:数学背景

首先看一下一维的微分公式Δ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效果:


没有更多推荐了,返回首页