•  1.傅里叶变换与频域 ...比如,使用低通滤波可以将图像模糊,也有些许降噪的作用。这些都是在空间域内进行的滤波处理,这个处理主要是依靠卷积来进行计算的。首先,从连续的一维卷积入手,如下所示。

    转自http://blog.csdn.net/zhoufan900428/article/details/17194289

     1.傅里叶变换与频域

            在之前的文中,我们已经进行过一些基本的图像处理。比如,使用低通滤波可以将图像模糊,也有些许降噪的作用。这些都是在空间域内进行的滤波处理,这个处理主要是依靠卷积来进行计算的。首先,从连续的一维卷积入手,如下所示。


           将上式进行傅里叶变换,可以得到如下结果。


            从这个式子,我们可以得到一个重要的结论。也就是,函数卷积的傅里叶变换所得到的结果,是函数的傅里叶变换的乘积。再将其总结得简单易懂一些,有如下结论。


            在将其扩展到二维的形况下,假设尺寸为MxN的图像,如下关系是成立的。


           其实到这,基本的原理就明了的。我们所看到的图像,均为空间域内的表现形式,我们无法辨识出频域内的图像。要进行频域内的滤波器处理,首先就需要进行傅里叶变换,然后直接进行滤波处理,最后再用反傅里叶变换倒回到空间域内。

           到此,已经可以开始空间域内的滤波处理了。但是,还有一点需要注意的地方。使用某个一维信号来举例子,一维信号的傅里叶变换是以2π为周期的函数。所以,我们常常使用的范围[-π,π]来表示这个信号的傅里叶变换,如下所示。


            这样做的好处是,靠近0的成分就是低频,靠近-π与π的成分就表示高频。而对于图像而言,在Matlab中,我们使用fft2()这个函数来求取图像的傅里叶变换。

    [plain] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. g = fft2(f);     
            上面这个代码求取的,其实是范围[0,π]内的傅里叶变换。为了方便理解,下图画出了本行代码所求取的图像的傅里叶变换的范围(右)和与其等效的一维傅里叶变换的范围(左)。


           很显然,这并不是希望的范围,下面这个代码可以求取[0,2π]内的傅里叶变换。

    [plain] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. P = 2*M;  
    2. Q = 2*N;  
    3. F = fft2(f,P,Q);  
           下图画出了本行代码所求取的图像的傅里叶变换的范围(右)和与其等效的一维傅里叶变换的范围(左)。所得到的图像F(u,v)的尺寸为PxQ。


             我们需要对其移动一下,如下图所示,我们需要的是粉色范围的区域。


    下面,从数学上分析一下,如何获得这个部分的频谱。对于傅里叶变换,有如下性质。


    这个特性称为平移特性,粉色部分的频谱,将带入上式,我们可以得到如下式子。


    为次,我们已经得到了粉色范围的频谱。越靠近傅里叶频谱图像中间的成分,代表了低频成分。其Matlab代码如下所示。

    [plain] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. [M,N] = size(f);  
    2. P = 2*M;  
    3. Q = 2*N;  
    4. fc = zeros(M,N);  
    5.   
    6. for x = 1:1:M  
    7.     for y = 1:1:N  
    8.         fc(x,y) = f(x,y) * (-1)^(x+y);  
    9.     end  
    10. end  
    11.   
    12. F = fft2(fc,P,Q);  

            代码所得到的结果,如下图所示。


            接下来,我们总结一下频域滤波的步骤:

            ①:先将图像做频域内的水平移动,然后求原图像f(x,y)的DFT,得到其图像的傅里叶谱F(u,v)。


            ②:与频域滤波器做乘积,

            ③:求取G(u,v)的IDFT,然后再将图像做频域内的水平移动(移动回去),其结果可能存在寄生的虚数,此时忽略即可。


            ④:这里使用ifft2函数进行IDFT变换,得到的图像的尺寸为PxQ。切取左上角的MxN的图像,就能得到结果了。

            2.低通滤波器

            2.1理想的低通滤波器


           其中,D0表示通带的半径。D(u,v)的计算方式也就是两点间的距离,很简单就能得到。

           使用低通滤波器所得到的结果如下所示。低通滤波器滤除了高频成分,所以使得图像模糊。由于理想低通滤波器的过度特性过于急峻,所以会产生了振铃现象。


             

            2.2巴特沃斯低通滤波器

           同样的,D0表示通带的半径,n表示的是巴特沃斯滤波器的次数。随着次数的增加,振铃现象会越来越明显。

       


           2.3高斯低通滤波器


           D0表示通带的半径。高斯滤波器的过度特性非常平坦,因此是不会产生振铃现象的。

           3.实现代码

       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
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95
      96
      97
      98
      99
     100
    close all;
    clear all;
    %% ---------Butterworth Lowpass Filters (Fre. Domain)------------
    f = imread('characters_test_pattern.tif');
    f = mat2gray(f,[0 255]);
    [M,N] = size(f);
    P = 2*M;
    Q = 2*N;
    fc = zeros(M,N);
    for x = 1:1:M
    for y = 1:1:N
    fc(x,y) = f(x,y) * (-1)^(x+y);
    end
    end
    F = fft2(fc,P,Q);
    H_1 = zeros(P,Q);
    H_2 = zeros(P,Q);
    for x = (-P/2):1:(P/2)-1
    for y = (-Q/2):1:(Q/2)-1
    D = (x^2 + y^2)^(0.5);
    D_0 = 100;
    H_1(x+(P/2)+1,y+(Q/2)+1) = 1/(1+(D/D_0)^2);
    H_2(x+(P/2)+1,y+(Q/2)+1) = 1/(1+(D/D_0)^6);
    end
    end
    G_1 = H_1 .* F;
    G_2 = H_2 .* F;
    g_1 = real(ifft2(G_1));
    g_1 = g_1(1:1:M,1:1:N);
    g_2 = real(ifft2(G_2));
    g_2 = g_2(1:1:M,1:1:N);
    for x = 1:1:M
    for y = 1:1:N
    g_1(x,y) = g_1(x,y) * (-1)^(x+y);
    g_2(x,y) = g_2(x,y) * (-1)^(x+y);
    end
    end
    %% -----show-------
    figure();
    subplot(1,2,1);
    imshow(f,[0 1]);
    xlabel('a).Original Image');
    subplot(1,2,2);
    imshow(log(1 + abs(F)),[ ]);
    xlabel('b).Fourier spectrum of a');
    figure();
    subplot(1,2,1);
    imshow(H_1,[0 1]);
    xlabel('c)Butterworth Lowpass (D_{0}=100,n=1)');
    subplot(1,2,2);
    h = mesh(1:20:P,1:20:Q,H_1(1:20:P,1:20:Q));
    set(h,'EdgeColor','k');
    axis([0 P 0 Q 0 1]);
    xlabel('u');ylabel('v');
    zlabel('|H(u,v)|');
    figure();
    subplot(1,2,1);
    imshow(log(1 + abs(G_1)),[ ]);
    xlabel('d).Result of filtering using c');
    subplot(1,2,2);
    imshow(g_1,[0 1]);
    xlabel('e).Result image');
    figure();
    subplot(1,2,1);
    imshow(H_2,[0 1]);
    xlabel('f).Butterworth Lowpass (D_{0}=100,n=3)');
    subplot(1,2,2);
    h = mesh(1:20:P,1:20:Q,H_2(1:20:P,1:20:Q));
    set(h,'EdgeColor','k');
    axis([0 P 0 Q 0 1]);
    xlabel('u');ylabel('v');
    zlabel('|H(u,v)|');
    figure();
    subplot(1,2,1);
    imshow(log(1 + abs(G_2)),[ ]);
    xlabel('g).Result of filtering using e');
    subplot(1,2,2);
    imshow(g_2,[0 1]);
    xlabel('h).Result image');
     来自CODE的代码片
    Butterworth_Lowpass_Filters.m
       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
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      73
      74
      75
      76
      77
      78
      79
      80
      81
      82
      83
      84
      85
      86
      87
      88
      89
      90
      91
      92
      93
      94
      95
      96
      97
      98
      99
     100
     101
     102
     103
    close all;
    clear all;
    clc;
    %% ---------Gaussian Lowpass Filters (Fre. Domain)------------
    f = imread('characters_test_pattern.tif');
    f = mat2gray(f,[0 255]);
    [M,N] = size(f);
    P = 2*M;
    Q = 2*N;
    fc = zeros(M,N);
    for x = 1:1:M
    for y = 1:1:N
    fc(x,y) = f(x,y) * (-1)^(x+y);
    end
    end
    F = fft2(fc,P,Q);
    H_1 = zeros(P,Q);
    H_2 = zeros(P,Q);
    for x = (-P/2):1:(P/2)-1
    for y = (-Q/2):1:(Q/2)-1
    D = (x^2 + y^2)^(0.5);
    D_0 = 60;
    H_1(x+(P/2)+1,y+(Q/2)+1) = exp(-(D*D)/(2*D_0*D_0));
    D_0 = 160;
    H_2(x+(P/2)+1,y+(Q/2)+1) = exp(-(D*D)/(2*D_0*D_0));
    end
    end
    G_1 = H_1 .* F;
    G_2 = H_2 .* F;
    g_1 = real(ifft2(G_1));
    g_1 = g_1(1:1:M,1:1:N);
    g_2 = real(ifft2(G_2));
    g_2 = g_2(1:1:M,1:1:N);
    for x = 1:1:M
    for y = 1:1:N
    g_1(x,y) = g_1(x,y) * (-1)^(x+y);
    g_2(x,y) = g_2(x,y) * (-1)^(x+y);
    end
    end
    %% -----show-------
    close all;
    figure();
    subplot(1,2,1);
    imshow(f,[0 1]);
    xlabel('a).Original Image');
    subplot(1,2,2);
    imshow(log(1 + abs(F)),[ ]);
    xlabel('b).Fourier spectrum of a');
    figure();
    subplot(1,2,1);
    imshow(H_1,[0 1]);
    xlabel('c)Gaussian Lowpass (D_{0}=60)');
    subplot(1,2,2);
    h = mesh(1:20:P,1:20:Q,H_1(1:20:P,1:20:Q));
    set(h,'EdgeColor','k');
    axis([0 P 0 Q 0 1]);
    xlabel('u');ylabel('v');
    zlabel('|H(u,v)|');
    figure();
    subplot(1,2,1);
    imshow(log(1 + abs(G_1)),[ ]);
    xlabel('d).Result of filtering using c');
    subplot(1,2,2);
    imshow(g_1,[0 1]);
    xlabel('e).Result image');
    figure();
    subplot(1,2,1);
    imshow(H_2,[0 1]);
    xlabel('f).Gaussian Lowpass (D_{0}=160)');
    subplot(1,2,2);
    h = mesh(1:20:P,1:20:Q,H_2(1:20:P,1:20:Q));
    set(h,'EdgeColor','k');
    axis([0 P 0 Q 0 1]);
    xlabel('u');ylabel('v');
    zlabel('|H(u,v)|');
    figure();
    subplot(1,2,1);
    imshow(log(1 + abs(G_2)),[ ]);
    xlabel('g).Result of filtering using e');
    subplot(1,2,2);
    imshow(g_2,[0 1]);
    xlabel('h).Result image');
     来自CODE的代码片
    Gaussian_Lowpass_Filters.m
      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
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
    close all;
    clear all;
    %% ---------Ideal Lowpass Filters (Fre. Domain)------------
    f = imread('characters_test_pattern.tif');
    f = mat2gray(f,[0 255]);
    [M,N] = size(f);
    P = 2*M;
    Q = 2*N;
    fc = zeros(M,N);
    for x = 1:1:M
    for y = 1:1:N
    fc(x,y) = f(x,y) * (-1)^(x+y);
    end
    end
    F = fft2(fc,P,Q);
    H_1 = zeros(P,Q);
    H_2 = zeros(P,Q);
    for x = (-P/2):1:(P/2)-1
    for y = (-Q/2):1:(Q/2)-1
    D = (x^2 + y^2)^(0.5);
    if(D <= 60) H_1(x+(P/2)+1,y+(Q/2)+1) = 1; end
    if(D <= 160) H_2(x+(P/2)+1,y+(Q/2)+1) = 1; end
    end
    end
    G_1 = H_1 .* F;
    G_2 = H_2 .* F;
    g_1 = real(ifft2(G_1));
    g_1 = g_1(1:1:M,1:1:N);
    g_2 = real(ifft2(G_2));
    g_2 = g_2(1:1:M,1:1:N);
    for x = 1:1:M
    for y = 1:1:N
    g_1(x,y) = g_1(x,y) * (-1)^(x+y);
    g_2(x,y) = g_2(x,y) * (-1)^(x+y);
    end
    end
    %% -----show-------
    figure();
    subplot(1,2,1);
    imshow(f,[0 1]);
    xlabel('a).Original Image');
    subplot(1,2,2);
    imshow(log(1 + abs(F)),[ ]);
    xlabel('b).Fourier spectrum of a');
    figure();
    subplot(1,2,1);
    imshow(H_1,[0 1]);
    xlabel('c).Ideal Lowpass filter(D=60)');
    subplot(1,2,2);
    h = mesh(1:20:P,1:20:Q,H_1(1:20:P,1:20:Q));
    set(h,'EdgeColor','k');
    axis([0 P 0 Q 0 1]);
    xlabel('u');ylabel('v');
    zlabel('|H(u,v)|');
    figure();
    subplot(1,2,1);
    imshow(log(1 + abs(G_1)),[ ]);
    xlabel('d).Result of filtering using c');
    subplot(1,2,2);
    imshow(g_1,[0 1]);
    xlabel('e).Result image');
    figure();
    subplot(1,2,1);
    imshow(H_2,[0 1]);
    xlabel('f).Ideal Lowpass filter(D=160)');
    subplot(1,2,2);
    h = mesh(1:20:P,1:20:Q,H_2(1:20:P,1:20:Q));
    set(h,'EdgeColor','k');
    axis([0 P 0 Q 0 1]);
    xlabel('u');ylabel('v');
    zlabel('|H(u,v)|');
    figure();
    subplot(1,2,1);
    imshow(log(1 + abs(G_2)),[ ]);
    xlabel('g).Result of filtering using e');
    subplot(1,2,2);
    imshow(g_2,[0 1]);
    xlabel('h).Result image');

    展开全文
  • 1 理想低通滤波 %理想低通 I = imread('fig.png'); I=rgb2gray(I); figure(1); subplot(221),imshow(I); title('原图像'); I=imnoise(I,'gaussian');%%加入高斯白噪声 subplot(222),imshow(I); title('加入噪声后的...

    1 理想低通滤波

    %理想低通
    I = imread('fig.png');
    I=rgb2gray(I);
    figure(1);
    subplot(221),imshow(I);
    title('原图像');
    I=imnoise(I,'gaussian');%%加入高斯白噪声
    subplot(222),imshow(I);
    title('加入噪声后的图像');
    s=fftshift(fft2(I));
    subplot(223), imshow(log(abs(s)),[]); 
    title('图像傅里叶变换取对数所得频谱');
    [a,b]=size(s);
    a0=round(a/2);
    b0=round(b/2);
    d=50;
    for i=1:a 
        for j=1:b 
            distance=sqrt((i-a0)^2+(j-b0)^2);
            if distance<=d
                h=1;
            else
                h=0;
            end
            s(i,j)=h*s(i,j);
        end
    end
    s=uint8(real(ifft2(ifftshift(s))));
    subplot(224),imshow(s);
    title('理想低通滤波所得图像'); 
    

    2 高斯低通滤波

    %高斯低通
    I=rgb2gray(imread('fig.png'));
    IA=imnoise(I,'gaussian');%%加入高斯白噪声
    subplot(222),imshow(IA);
    title('加入噪声后的图像');
    [f1,f2]=freqspace(size(IA),'meshgrid');
    D=100/size(IA,1);
    r=f1.^2+f2.^2;
    Hd=ones(size(IA));
    for i=1:size(IA,1)
        for j=1:size(IA,2)
            t=r(i,j)/(D*D);
            Hd(i,j)=exp(-t);
        end
    end
    Y=fft2(double(IA));
    Y=fftshift(Y);
    Ya=Y.*Hd;
    Ya=ifftshift(Ya);
    Ia=real(ifft2(Ya));
    subplot(221),imshow(uint8(I));
    title('原图像');
    subplot(223),imshow(uint8(Ia));
    title('高斯低通滤波处理');
    

    3 巴特沃斯低通滤波

    clear all;
    %巴特沃斯低通
    figure(2);
    I=rgb2gray(imread('fig.png'));
    subplot(221),imshow(I);
    title('原始图像');
    I1=imnoise(I,'gaussian');%%加入高斯白噪声
    subplot(222),imshow(I1);
    title('加入噪声后的图像');
    f=double(I1);%数据类型转换
    g=fft2(f);%图像傅里叶转换 
    g=fftshift(g);%傅里叶变换平移
    F2=log(abs(g));%对傅里叶变换结果取绝对值,然后取对数
    [N1,N2]=size(g);%傅里叶变换图像尺寸
    n=2;%参数赋初始值
    d0=30;
    n1=fix(N1/2);%数据圆整
    n2=fix(N2/2);%数据圆整
    for i=1:N1%遍历图像像素
        for j=1:N2 
            d=sqrt((i-n1)^2+(j-n2)^2);
            if d==0 
                h=0; 
            else
                h=1/(1+(d/d0)^(2*n));
            end
            result(i,j)=h*g(i,j);%?图像矩阵计算处理
        end
    end
    F3=log(abs(result));%对傅里叶变换结果取绝对值,然后取对数
    result=ifftshift(result);
    X2=ifft2(result);
    X3=uint8(real(X2));
    subplot(223),imshow(uint8(X3))
    title('Butterworth低通滤波图像');
    

    展开全文
  • 理想低通滤波的MATLAB代码,可供学生数字图像处理实验参考
  • #理想低通滤波 import numpy as np import cv2 def convert_2d(r): r_ext = np.zeros((r.shape[0] * 2, r.shape[1] * 2)) for i in range(r.shape[0]): for j in range(r.shape[1]): r_ext[i...
    #理想低通滤波
    import numpy as np
    import cv2
    
    def convert_2d(r):
        r_ext = np.zeros((r.shape[0] * 2, r.shape[1] * 2))
        for i in range(r.shape[0]):
            for j in range(r.shape[1]):
                r_ext[i][j] = r[i][j]
        # 傅里叶变换
        r_ext_fu = np.fft.fft2(r_ext)
        # 将低频信号移至中间,等效于在时域上对f(x,y)乘以(-1)^(m+n)
        r_ext_fu = np.fft.fftshift(r_ext_fu)
    
        # 截止频率
        d0 = 100
        # 频率域中心坐标
        center = (r_ext_fu.shape[0] // 2, r_ext_fu.shape[1] // 2)
        h = np.empty(r_ext_fu.shape)
        # 绘制滤波器
        for u in range(h.shape[0]):
            for v in range(h.shape[1]):
                duv = ((u - center[0]) ** 2 + (v - center[1]) ** 2) ** 0.5
                h[u][v] = duv < d0
    
        s_ext_fu = r_ext_fu * h
        s_ext = np.fft.ifft2(np.fft.ifftshift(s_ext_fu))
        s_ext = np.abs(s_ext)
        s = s_ext[0:r.shape[0], 0:r.shape[1]]
    
        for i in range(s.shape[0]):
            for j in range(s.shape[1]):
                s[i][j] = min(max(s[i][j], 0), 255)
        return s.astype(np.uint8)
    
    def convert_3d(r):
        s_dsplit = []
        for d in range(r.shape[2]):
            rr = r[:, :, d]
            ss = convert_2d(rr)
            s_dsplit.append(ss)
        s = np.dstack(s_dsplit)
        return s
    
    im = cv2.imread('tetet.jpg')
    im_converted_mat = convert_3d(im)
    cv2.imshow('ditong', im_converted_mat)
    cv2.imwrite('ditong1.jpg', im_converted_mat)
    cv2.waitKey()
    
    
    #巴特沃斯低通滤波器
    import numpy as np
    import cv2
    
    def convert_2d(r):
        r_ext = np.zeros((r.shape[0] * 2, r.shape[1] * 2))
        for i in range(r.shape[0]):
            for j in range(r.shape[1]):
                r_ext[i][j] = r[i][j]
        # 傅里叶变换
        r_ext_fu = np.fft.fft2(r_ext)
        # 将低频信号移至中间,等效于在时域上对f(x,y)乘以(-1)^(m+n)
        r_ext_fu = np.fft.fftshift(r_ext_fu)
    
        # 截止频率
        d0 = 100
        n = 2
        # 频率域中心坐标
        center = (r_ext_fu.shape[0] // 2, r_ext_fu.shape[1] // 2)
        h = np.empty(r_ext_fu.shape)
        # 绘制滤波器
        for u in range(h.shape[0]):
            for v in range(h.shape[1]):
                duv = ((u - center[0]) ** 2 + (v - center[1]) ** 2) ** 0.5
                h[u][v] = 1 / ((1 + (duv / d0)) ** (2 * n))
    
        s_ext_fu = r_ext_fu * h
        s_ext = np.fft.ifft2(np.fft.ifftshift(s_ext_fu))
        s_ext = np.abs(s_ext)
        s = s_ext[0:r.shape[0], 0:r.shape[1]]
    
        for i in range(s.shape[0]):
            for j in range(s.shape[1]):
                s[i][j] = min(max(s[i][j], 0), 255)
        return s.astype(np.uint8)
    
    
    def convert_3d(r):
        s_dsplit = []
        for d in range(r.shape[2]):
            rr = r[:, :, d]
            ss = convert_2d(rr)
            s_dsplit.append(ss)
        s = np.dstack(s_dsplit)
        return s
    
    
    im = cv2.imread('tetet.jpg')
    im_converted_mat = convert_3d(im)
    cv2.imshow('ditong', im_converted_mat)
    cv2.imwrite('ditong2.jpg', im_converted_mat)
    cv2.waitKey()
    
    #高斯低通滤波器
    import numpy as np
    import cv2
    
    def convert_2d(r):
        r_ext = np.zeros((r.shape[0] * 2, r.shape[1] * 2))
        for i in range(r.shape[0]):
            for j in range(r.shape[1]):
                r_ext[i][j] = r[i][j]
        # 傅里叶变换
        r_ext_fu = np.fft.fft2(r_ext)
        # 将低频信号移至中间,等效于在时域上对f(x,y)乘以(-1)^(m+n)
        r_ext_fu = np.fft.fftshift(r_ext_fu)
    
        # 截止频率
        d0 = 100
        # 频率域中心坐标
        center = (r_ext_fu.shape[0] // 2, r_ext_fu.shape[1] // 2)
        h = np.empty(r_ext_fu.shape)
        # 绘制滤波器
        for u in range(h.shape[0]):
            for v in range(h.shape[1]):
                duv = ((u - center[0]) ** 2 + (v - center[1]) ** 2) ** 0.5
                h[u][v] = np.e ** (-duv ** 2 / d0 ** 2)
    
        s_ext_fu = r_ext_fu * h
        s_ext = np.fft.ifft2(np.fft.ifftshift(s_ext_fu))
        s_ext = np.abs(s_ext)
        s = s_ext[0:r.shape[0], 0:r.shape[1]]
    
        for i in range(s.shape[0]):
            for j in range(s.shape[1]):
                s[i][j] = min(max(s[i][j], 0), 255)
        return s.astype(np.uint8)
    
    def convert_3d(r):
        s_dsplit = []
        for d in range(r.shape[2]):
            rr = r[:, :, d]
            ss = convert_2d(rr)
            s_dsplit.append(ss)
        s = np.dstack(s_dsplit)
        return s
    
    
    im = cv2.imread('tetet.jpg')
    im_converted_mat = convert_3d(im)
    cv2.imshow('ditong', im_converted_mat)
    cv2.imwrite('ditong3.jpg', im_converted_mat)
    cv2.waitKey()
    

    原图
    在这里插入图片描述
    理想低通滤波器
    在这里插入图片描述
    巴特沃斯低通滤波器
    在这里插入图片描述
    高斯低通滤波器
    在这里插入图片描述

    展开全文
  • 理想低通滤波器 理想低通滤波器在以原点为圆心,D0D_0D0​为半径的圆内,通过所有的频率,而在圆外截断所有的频率。其中圆心的频率最低,为变换的直流(DC)分量,函数如下: H(u,v)={1,D(u,v)≤D00,D(u,v)>D0(6-...

    理想低通滤波器

    理想低通滤波器在以原点为圆心,D0D_0为半径的圆内,通过所有的频率,而在圆外截断所有的频率。其中圆心的频率最低,为变换的直流(DC)分量,函数如下:

    H(u,v)={1,D(u,v)D00,D(u,v)>D0(6-1) H(u,v) = \begin{cases} 1 &, D(u,v) \leq D_0 \\ 0 &, D(u,v) \gt D_0 \end{cases} \tag{6-1}

    式中的D(u,v)D(u,v)表达为:

    $$
    D(u,v) = \sqrt{(u - \frac{P}{2})^2+(v - \frac{Q}{2})^2}

    \tag{6-2}
    

    $$

    在这里插入图片描述

    理想低通滤波器的过渡非常急剧,会产生振铃现象。

    Python实现代码如下:

    def low_pass_kernel(img,cut_off):
        assert img.ndim == 2
        r,c = img.shape[1],img.shape[0]
        u = np.arange(r)
        v = np.arange(c)
        u, v = np.meshgrid(u, v)
        low_pass = np.sqrt( (u-r/2)**2 + (v-c/2)**2 )
        low_pass[low_pass <= cut_off] = 1
        low_pass[low_pass >= cut_off] = 0 
        return low_pass
    
    def ideal_low_pass_filter(src,D0=15):
        assert src.ndim == 2
        M,N = src.shape[0],src.shape[1]
        kernel = low_pass_kernel(src,D0)
        gray = src.copy()
        gray = np.float64(gray)
        gray_fft = np.fft.fft2(gray)
        gray_fftshift = np.fft.fftshift(gray_fft)
        dst = np.zeros_like(gray_fftshift)
        dst_filtered = kernel * gray_fftshift
        dst_ifftshift = np.fft.ifftshift(dst_filtered)
        dst_ifft = np.fft.ifft2(dst_ifftshift)
        dst = np.abs(np.real(dst_ifft))
        dst = np.clip(dst,0,255)
        return np.uint8(dst)
    

    程序运行结果:

    在这里插入图片描述

    展开全文
  • 数字图像处理,评语滤波理想低通滤波器,高斯滤波器,巴特沃斯滤波器
  • MATLAB图像处理中常用的低通滤波有三种。 第一种是理想的低通滤波器。即将设定范围圆半径内的所有频率都可以正常通过,圆以外的频率全部归零。 第二种是布特沃斯低通滤波器(BLPF) 相对平缓的过渡滤波 第三种是...

    MATLAB图像处理中常用的低通滤波有三种。

    第一种是理想的低通滤波器。即将设定范围圆半径内的所有频率都可以正常通过,圆以外的频率全部归零。

    在这里插入图片描述
    第二种是布特沃斯低通滤波器(BLPF)

    相对平缓的过渡滤波
    在这里插入图片描述

    第三种是高斯滤波

    在这里插入图片描述

    我的总结,在做相关的滤波操作以前,最好将频谱图ffshift将频谱中心化,低通滤波器可用来平滑图像,其中设置的圆半径越大,即截止频率越大,图中的类似柱状物越粗,即通过的频率分量越多。中心的频率一般越低,四边的频率一般越高。

    展开全文
  • 在前面我们对空间滤波做了重点的研究,但是如果不了解在图像滤波中如何应用傅里叶变换和频率域的基本知识,想要彻底理解这一领域也是不太可能的。下面我们来介绍一下傅里叶变换和频域率处理的要领。 ...
  • 因此,在频域中对图像采用滤波器函数衰减高频信息而使低频信息畅通无阻的过程称为低通滤波(Low-pass Filtering)。通过滤波可除去高频分量,消除噪声,起到平滑图像去噪声的增强作用。但是也可能滤除某些边界对应的...
  • 1、主要步骤:空域(傅里叶变换、卷积)&gt;&gt;&gt;频域(与转移函数相乘、处理、傅里叶反变换)&gt;&gt;...巴特沃斯滤波器:阶为n,截断频率为D0的...(1)低通滤波: 低通巴特沃斯滤波器在高低...
  • 巴特沃斯低通滤波 n阶巴特沃斯低通滤波器,传递函数为: $$ H(u,v) = \frac{1}{1 + (D(u,v) / D_0)^{2n}} \tag{7-1} $$ 其中,D(u,v)=(u−P2)2+(v−Q2)2D(u,v) = \sqrt{(u - \frac{P}{2})^2 + (v - \frac{Q}{2})^2}D...
  • 要求  可以使用 MATLAB 的傅里叶变换函数和反变换函数。 原理部分 低通滤波器指去除图像中的高频成分,而低通滤波器指...理想低通滤波器:以原点为圆心,D为半径的圆内, 无衰减地通过所有频率,在圆外截断所有频率。
  • 梯形低通滤波器 梯形低通滤波器(TLPF)的传递函数如下: $$ H(u,v) = \begin{cases} 1 & D(u,v) \lt D_0 \\ \frac{D(u,v) - D_1}{D_0-D_1} & D_0 \lt D(u,v) \leq D_1 \\ 0 &D(u,v) > D_1 \end{cases}...
  • 一、实验内容及原理 ...具体内容:利用 cvDFT 函数实现 DFT,在频域上利用理想高通和低通滤波 器进行滤波,并把滤波过后的图像显示在屏幕上(观察振铃现象),要求截止频 率可输入。 3、 利用布特沃斯高通和低...
  • 主要使用傅里叶变换,将空间域的图像转换到频域内,在频域内进行数字图像处理。这部分的内容及其重要,频域内的处理可以解决空间域内无法完成的图像增强。本文首先从数学角度,对图像的频域内的性质进行分析,然后在...
  • 频率域低通滤波

    2019-09-14 17:56:19
    introduction图像噪声在空间域通过相邻像素可以去除噪声,但有时效果不理想。典型的空域滤波有均值滤波,中值滤波,高斯滤波等。 将图像转换到频率域后,频率图像具有较高的‘规范性’,依据能量分布可以有效去除...
  • 频域滤波 频域滤波是在频率域对图像处理的一种方法。步骤如下: 滤波器大小和频谱大小相同,相乘即可得到新的频谱。...1.理想的高/低通滤波 顾名思义,高通滤波器为:让高频信息通过,过滤低频信...
1 2 3 4 5 ... 20
收藏数 1,775
精华内容 710