傅里叶级数、傅里叶变换

原创 已于 2024-06-20 20:04:31 修改 · 2.2k 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
-
标签
#算法
于 2021-07-01 23:59:20 首次发布
本文深入探讨傅里叶级数和傅里叶变换，包括周期为2π和T的傅里叶级数、傅里叶变换的性质、离散傅里叶变换（DFT）及其快速算法（FFT）。通过实例分析和代码演示，展示了傅里叶变换在连续和离散信号处理中的应用，以及在图像处理中的二维傅里叶变换。最后提到了OpenCV中的getOptimalDFTSize函数在最佳DFT尺寸计算中的作用。

目录

一，傅里叶级数

1，三角函数系

2，周期为2π的傅里叶级数

3，部分和数列

4，贝塞尔不等式（Bessel）

5，傅里叶级数的狄利克雷收敛定理

6，周期为T的傅里叶级数

7，傅里叶级数的复数形式

8，Demo1——连续周期信号

二，一维傅里叶变换

1，傅里叶级数的极限

2，傅里叶变换（FT）

（1）深入理解FT

（2）Demo2——连续非周期信号

（3）卷积定理

3，离散傅里叶变换（DFT）、快速傅里叶变换（FFT）

（1）离散傅里叶变换

（2）快速傅里叶变换

（3）Demo3——离散非周期信号

（4）深入理解FFT

（5）Demo4——更简单的离散非周期信号

4，可视化调试

5，离散信号转连续信号、采样定理

6，离散时间傅里叶变换（DTFT）

7，应用场景总结

三，二维傅里叶变换

1，傅里叶变换

2，离散傅里叶变换

3，图像傅里叶变换

4，傅里叶变换的性质

（1）平移

（2）分配律

（3）数乘

（4）旋转

（5）周期性

（6）共轭对称性

（7）分离性

（8）卷积定理

（9）相关定理

四，opencv 相关函数

1，getOptimalDFTSize

一，傅里叶级数

1，三角函数系

{1, cos x, sin x, cos 2x, sin 2x,......}在[-π，π]上正交

2，周期为2π的傅里叶级数

f在[-π，π]上按段光滑，f周期为2π

S(x)=\frac{a_0}{2}+\sum _{n>0}(a_ncos\, nx+b_nsin\, nx)

其中，a_n=\frac{1}{\pi}\int_{-\pi}^\pi f(x)cos\,nxdx,n\geq 0,   b_n=\frac{1}{\pi}\int_{-\pi}^\pi f(x)sin\,nxdx,n> 0

3，部分和数列

f在[-π，π]上按段光滑，f周期为2π，则

S_n(x)=\frac{1}{\pi}\int_{-\pi}^\pi f(x+t)\frac{sin(n+\frac{1}{2})t}{2sin\frac{1}{2}t}dt

证明：

4，贝塞尔不等式（Bessel）

5，傅里叶级数的狄利克雷收敛定理

任意x，f(x+0)+f(x-0)=2S(x)

6，周期为T的傅里叶级数

 S(x)=\frac{a_0}{2}+\sum _{n>0}(a_ncos\, \frac{2\pi}{T}nx+b_nsin\, \frac{2\pi}{T}nx)

其中，a_n=\frac{2}{T}\int_{0}^T f(x)cos\,\frac{2\pi}{T}nxdx,n\geq 0,   b_n=\frac{2}{T}\int_{0}^T f(x)sin\,\frac{2\pi}{T}nxdx,n>0

7，傅里叶级数的复数形式

其中c_n要么是实数要么是纯虚数

8，Demo1——连续周期信号

先构造函数：（周期为2pi）

f(x)=\left\{\begin{matrix} 1,-\pi<x<0 \\ -1,0<x<\pi \end{matrix}\right.

构造点阵，然后画图：

from numpy import *
from matplotlib.pyplot import *
from pylab import *
import math

pi = 3.1415926
x = linspace(-pi * 2, pi * 2, 1000)
y = [1 if int((i + pi * 2) / pi + 1) % 2 == 0 else -1 for i in x]
plot(x, y)
show()

运行结果：

 然后计算傅里叶级数：

S(x)=\sum _{n>0}(b_nsin\, nx)，其中   b_n=\frac{2((-1)^n-1)}{n\pi}

当n为偶数时，b_n = 0

然后画图显示傅里叶级数：

s = 0
for n in range(1,100,2):
    bn = ((-1)**n-1)*2/n/pi
    s1 = bn* sin(n*x)
    s += s1
    plot(x, y)
    plot(x, s)
    plot(x, s1)
    show()
    #time.sleep(2)

    

   

 蓝色的是原始函数，绿色的是傅里叶级数的第n项，橙色的是傅里叶级数的前n项和。

当n越来越大时，部分和数列越来越接近原始函数。

二，一维傅里叶变换

1，傅里叶级数的极限

对于非周期函数，可以理解为周期是无穷大。

对上面的式子，我给出了不是特别严谨的数学证明：

2，傅里叶变换（FT）

傅里叶变换：

F(\omega)=\frac{1}{2 \pi} \int_{-\infty}^{\infty} f(x) e^{-i \omega x} d x

逆变换：

f(x)=\int_{-\infty}^{\infty} F(\omega) e^{i \omega x}d\omega

（1）深入理解FT

把F按照实部和虚部分开表示：

 F(\omega)=F_1(\omega)-iF_2(\omega), F_1(\omega)=\frac{1}{2 \pi} \int_{-\infty}^{\infty} f(x) cos(\omega x) dx, F_2(\omega)=\frac{1}{2 \pi} \int_{-\infty}^{\infty} f(x) sin(\omega x) dx

即F1是F的实部，F2是F的虚部。

而实函数一定可以表示成奇函数和偶函数之和，不妨设f(x)=f_1(x)+f_2(x)，其中f1是偶函数，f2是奇函数，则F_1(\omega)=\frac{1}{2 \pi} \int_{-\infty}^{\infty} f_1(x) cos(\omega x) dx, F_2(\omega)=\frac{1}{2 \pi} \int_{-\infty}^{\infty} f_2(x) sin(\omega x) dx

所以f中的偶函数分量经过傅里叶变换之后会得到实部，奇函数分量经过傅里叶变换之后会得到虚部。

另一方面，F1显然是偶函数，F2显然是奇函数，所以也可以说，f中的偶函数分量经过傅里叶变换之后会得到偶函数，奇函数分量经过傅里叶变换之后会得到奇函数。

而对于逆变换：

 因为F1是偶函数，F2是奇函数，所以也能推导出f的虚部为0，最终得到：

 f(x)=\int_{-\infty}^{\infty} (F_1(\omega) cos(\omega x)+F_2(\omega) sin(\omega x))d\omega

即F中的偶函数分量经过逆变换之后会得到偶函数，奇函数分量经过逆变换之后会得到奇函数。

（2）Demo2——连续非周期信号

f(x)=\left\{\begin{matrix} 1,-\pi<x<0 \\ -1,0<x<\pi \end{matrix}\right.

import numpy
from pylab import *

x = numpy.linspace(-pi, pi - 0.00001, 1000)
f = [1 if i < 0 else -1 for i in x]
plot(x, f)
show()

可以算出F(\omega)=\frac{i(1-cos(\omega \pi))}{\omega \pi}

因为f是奇函数，所以F只有虚部。

画出虚部频谱：

w = numpy.linspace(-10,10,5000)
F = (1-cos(w*pi))/w/pi
plot(w, F)
show()

反算验证：

计算g(x)=\int_{-\infty}^{\infty} F(\omega) e^{i \omega x}d\omega，看看和f是否相等

根据F(\omega)=\frac{i(1-cos(\omega \pi))}{\omega \pi}可以算出，g(x)=\int_{-\infty}^{\infty} \frac{sin(\omega x)(cos(\omega \pi)-1)}{\omega\pi}d\omega

 然后画图：

x = numpy.linspace(-10,10,1000)
g = numpy.linspace(-10,10,1000)
for i in range(1000):
    xi = x[i]
    s = 0
    for wi in w:
        s += (cos(wi*pi)-1)/wi/pi*sin(wi*xi)*20/1001
    g[i] = s

plot(x, g)
show()

这里还是用离散的方法代替了积分计算，所以会有比较大的误差。

运行：

总体上和初始函数f是差不多的，但是还是有明显差异。 

把求积分的步骤加强，即把区间划分更细，可以得到：

完整代码：

import numpy
from pylab import *

x = numpy.linspace(-pi,pi-0.00001,1000)
f = [1 if int((i+pi*2)/pi+1)%2==0 else -1 for i in x]
plot(x, f)
show()

w = numpy.linspace(-50,50,5000)
F = (1-cos(w*pi))/w/pi
#plot(w, F)
#show()

x = numpy.linspace(-10,10,1000)
g = numpy.linspace(-10,10,1000)
for i in range(1000):
    xi = x[i]
    s = 0
    for wi in w:
        s += (cos(wi*pi)-1)/wi/pi*sin(wi*xi)*20/1001
    g[i] = s

plot(x, g)
show()
（3）卷积定理

卷积 卷积（Convolution）_nameofcsdn的博客-CSDN博客

时域卷积定理表明两信号在时域的卷积积分对应于在频域中该两信号的傅立叶变换的乘积。

f(x)*h(x)\Leftrightarrow F(x)H(x)

频域卷积定理表明两信号在时域的乘积对应于这两个信号傅立叶变换的卷积。

f(x)h(x)\Leftrightarrow F(x)*H(x)

PS：系数 2π 被省略掉了，因为不同版本的傅里叶变换描述不一样。

公式证明：

 

3，离散傅里叶变换（DFT）、快速傅里叶变换（FFT）

（1）离散傅里叶变换

H(k) = \sum_{n=0}^{N-1}f(n)e^{-i2\pi \frac{n}{N}k}

逆变换：

f(n)=\frac{1}{N}\sum_{k=0}^{N-1}H(k)e^{i2\pi \frac{k}{N}n}

显然，H[k]和H[N-k]是共轭复数，所以H的实部一定是左右对称，而虚部是左右对称处互为相反数。即实部是偶函数，虚部是奇函数。

（2）快速傅里叶变换

快速傅里叶变换是根据复数的性质，用分治算法来快速计算DFT的。

DFT的时间复杂度是O（n^2），FFT的时间复杂度是O（n log n）

python中有FFT的接口，可以直接调用。

（3）Demo3——离散非周期信号

首先构造原始信号：

num = 100
x = numpy.linspace(0,num-1,num)
f =  cos(pi/4*x)
plot(x, f)
show()

每个小周期内都采样了8个点，所以在该范围内振动了12.5个周期，介于12和13之间。

进行傅里叶变换：

H = fft(f)
plot(x, H.real)
plot(x, H.imag)
show()

显示频谱的实部和虚部：

 

蓝色的是实部，偶函数，橙色的是虚部，奇函数。

把实部单独画图：

H = fft(f)
plot(x, H.real)
print(H.real)
show()

 这个图的纵坐标单位是10的-13次方，再加1，也就是说频谱的实部全都是1，剩下的只是计算误差。

显示频谱的振幅：

H = fft(f)
print(numpy.abs(H))
plot(x, numpy.abs(H))
show()

 运行结果：

 

通过打印可以看出来，最高的那2个点就是x=12和13这2个点，这就验证了，离散傅里叶变换是表明信号在该范围内振动了多少个周期。

逆变换：

ift = ifft(H)
plot(x, ift)
show()

结果：

 和原图相同。

（4）深入理解FFT

不妨设f(N)=f(0)，这个只是让表达更简洁，并不影响实际计算。

和FT中类似，不妨设f(x)=f_1(x)+f_2(x)，其中f1是偶函数，f2是奇函数，

即f_1(N-x)=f_1(x),f_2(N-x)=-f_2(x)

则   H(k) = \sum_{n=0}^{N-1}f(n)e^{-i2\pi \frac{n}{N}k} =H_1(k)-iH_2(k)

其中  H_1(k)=\sum_{n=0}^{N-1}f_1(n)cos(2\pi \frac{n}{N}k),H_2(k)=\sum_{n=0}^{N-1}f_2(n)sin(2\pi \frac{n}{N}k)

所以f中的偶函数分量经过离散傅里叶变换之后会得到实部，奇函数分量经过傅里叶变换之后会得到虚部，这和傅里叶变换完全一致！

另一方面，H1显然是偶函数，H2显然是奇函数，所以也可以说，f中的偶函数分量经过离散傅里叶变换之后会得到偶函数，奇函数分量经过离散傅里叶变换之后会得到奇函数。

而对于逆变换：

f(n)=\frac{1}{N}\sum_{k=0}^{N-1}H(k)e^{i 2\pi \frac{k}{N}n}=\frac{1}{N}\sum_{k=0}^{N-1}\left ( H_1(k)cos(2\pi \frac{k}{N}n)+H_2(k)sin(2\pi \frac{k}{N}n) \right )

即H中的偶函数分量经过逆变换之后会得到偶函数，奇函数分量经过逆变换之后会得到奇函数。

回到上面的Demo，我们可以算出，

f_1(n)=0, (n>0), f_1(0)=1

所以频谱的实部是H_1(k)=\sum_{n=0}^{N-1}f_1(n)cos(2\pi \frac{n}{N}k)=1

（5）Demo4——更简单的离散非周期信号

把上面的demo稍微改一下，只需要把100改成96，即可得到最简单的离散信号：

import numpy
from pylab import *

num = 96
x = numpy.linspace(0,num-1,num)
f =  cos(pi/4*x)
plot(x, f)
show()

H = fft(f)
plot(x, H.real)
plot(x, H.imag)
show()

运行：

刚好12个周期。

频谱：

 蓝色的是实部，偶函数，橙色的是虚部，都是0。

如果把f =  cos(pi/4*x)改成f = cos(pi/4*(x-1.3))，1.3是个随意的数字，那么结果就是：

可以看出，实部和虚部都在12、84这2个频点。

4，可视化调试

如果频点不是很多（100之内），可以用这个函数查看如何把1个信号分解成若干信号的叠加：

def showFft(v):
    H = fft.fft(v)
    plot(H.real)
    show()

    plot(H.imag)
    show()

    s=H.copy()
    s2=H.copy()
    for id in range(0,len(H)):
        s[id]=0
        s2[id]=0

    for id in range(0,len(H)):
        s[id] = H[id]
        s2[id] = H[id]
        r = fft.ifft(s)
        plot(r)
        r2 = fft.ifft(s2)
        plot(r2)
        show()
        s[id] = 0
        time.sleep(1)

函数会输出很多图，示例：

蓝色的是一个频点的分量图，橙色的是当前的累加图，最终橙色线条会和输入信号很接近。

因为会输出很多图，对于每个频点都会输出分量图和当前累加图，所以如果频点太多，则需要把代码略改一下。

5，离散信号转连续信号、采样定理

根据离散傅里叶变换的逆变换：

f(n)=\frac{1}{N}\sum_{k=0}^{N-1}H(k)e^{i 2\pi \frac{k}{N}n}=\frac{1}{N}\sum_{k=0}^{N-1}\left ( H_1(k)cos(2\pi \frac{k}{N}n)+H_2(k)sin(2\pi \frac{k}{N}n) \right )

 如果把这个看成连续函数，能否直接得到一个连续信号，恰好包含了原始信号的所有点？

代码实现：

import numpy
from pylab import *

num = 16
x = numpy.linspace(0,15,16)
f = cos(pi/4*x)
plot(x, f)
show()

H = fft(f)

def my_ifft(x, H):
    s = 0
    H1 = H.real
    H2 = H.imag
    print(H1)
    for i in range(int(len(H1))):
        s += H1[i]*cos(pi*2*i*x/len(H1)) - H2[i]*sin(pi*2*i*x/len(H1))
    return s/len(H1)

x = numpy.linspace(0,num,num*10+1)
my_f = [my_ifft(xi,H) for xi in x]
plot(x, my_f)
show()

原始信号：

逆变换得到的连续信号：

 看得出来，这是2个信号的叠加，分别是2个周期的和14个周期的。

这确实包含了原始信号的所有点，但是和想象中的不太一样。

于是我修改函数：

def my_ifft(x, H):
    s = 0
    H1 = H.real
    H2 = H.imag
    for i in range(0,int(num/2),1):
        s += H1[i]*cos(pi*2*i*x/len(H1)) - H2[i]*sin(pi*2*i*x/len(H1))
    return s/len(H1)*2

是对称的，所以我只适用一半的频谱，算出来的模拟信号幅值乘以2即可，这样就只用到低频分量。

 如果原始信号是振动4个周期的，代码只需要修改一行，即f = cos(pi/2*x)

import numpy
from pylab import *

num = 16
x = numpy.linspace(0,15,16)
f = cos(pi/2*x)
plot(x, f)
show()

H = fft(f)

def my_ifft(x, H):
    s = 0
    H1 = H.real
    H2 = H.imag
    for i in range(0,int(num/2),1):
        s += H1[i]*cos(pi*2*i*x/len(H1)) - H2[i]*sin(pi*2*i*x/len(H1))
    return s/len(H1)*2

x = numpy.linspace(0,num,num*10+1)
my_f = [my_ifft(xi,H) for xi in x]
plot(x, my_f)
show()

 运行：

  

 如果原始信号是振动8个周期的，代码只需要修改一行，即f = cos(pi*x)

 运行结果：

  

 信息完全丢失，这是为什么？

因为采样频率刚好等于信号频率的2倍，根据采样定理，这是不够的。

6，离散时间傅里叶变换（DTFT）

离散时间傅里叶变换：

X(\omega )=\sum _{n=-\infty}^\infty x[n]e^{-j\omega n}

逆变换：

x[n] = \frac{1}{2\pi}\int_{-\pi}^\pi X(\omega)e^{j\omega n}d\omega

7，应用场景总结

如何通俗地解释什么是离散傅里叶变换？ - 知乎

（1）傅里叶级数

其中c_n要么是实数要么是纯虚数

（2）傅里叶变换（FT）

傅里叶变换：

F(\omega)=\frac{1}{2 \pi} \int_{-\infty}^{\infty} f(x) e^{-i \omega x} d x

逆变换：

f(x)=\int_{-\infty}^{\infty} F(\omega) e^{i \omega x}d\omega

（3）离散傅里叶变换（DFT）

离散傅里叶变换：

H(k) = \sum_{n=0}^{N-1}f(n)e^{-i2\pi \frac{n}{N}k}

逆变换：

f(n)=\frac{1}{N}\sum_{k=0}^{N-1}H(k)e^{i2\pi \frac{k}{N}n}

（4） 离散时间傅里叶变换（DTFT）

离散时间傅里叶变换：

X(\omega )=\sum _{n=-\infty}^\infty x[n]e^{-j\omega n}

逆变换：

x[n] = \frac{1}{2\pi}\int_{-\pi}^\pi X(\omega)e^{j\omega n}d\omega

三，二维傅里叶变换

1，傅里叶变换

F(u,v)=\int_{-\infty}^{+\infty}\int_{-\infty}^{+\infty}f(x,y)e^{-i2\pi (ux+vy)}dxdy

逆变换：

f(x,y)=\int_{-\infty}^{+\infty}\int_{-\infty}^{+\infty}F(u,v)e^{i2\pi (ux+vy)}dudv

二维傅里叶变换 - 百度文库

2，离散傅里叶变换

 逆变换：

3，图像傅里叶变换

随便读一个图，变成一个3*3的小图

from numpy.fft import *
import cv2

image = cv2.imread("D:/im.jpg", 0)
image = cv2.resize(image,(3,3))
print(image)

输出：

[[68 57 36]
 [51 43 19]
 [31 35 19]]

进行傅里叶变换：

fft2 = fft2(image)
print('fft2.real\n',fft2.real)
print('fft2.imag\n',fft2.imag)

输出：

fft2.real
 [[359.   45.5  45.5]
 [ 62.    3.5  15.5]
 [ 62.   15.5   3.5]]
fft2.imag
 [[  0.         -52.82754963  52.82754963]
 [-24.24871131 -14.72243186 -12.99038106]
 [ 24.24871131  12.99038106  14.72243186]]

可以看得出来是有对称性的，但是对称性不简洁。

于是我们有了 fftshift 函数，专门用来把下面一半放上去，右边一半放左边，使得原本的（0,0）处的元素变成最中心的元素。

fft2shift = fftshift(fft2)
print('fft2shift.real\n',fft2shift.real)
print('fft2shift.imag\n',fft2shift.imag)

输出：

fft2shift.real
 [[  3.5  62.   15.5]
 [ 45.5 359.   45.5]
 [ 15.5  62.    3.5]]
fft2shift.imag
 [[ 14.72243186  24.24871131  12.99038106]
 [ 52.82754963   0.         -52.82754963]
 [-12.99038106 -24.24871131 -14.72243186]]

这样规律就很明显了，实部是中心对称的偶函数，虚部是奇函数，这个规律也和一维离散傅里叶变换一致。

如果做周期延展，那么规律就比较简洁了：

对于实部，real(-x,-y) = real(x,y)，而虚部，imag(-x,-y) = -imag(x,y)

也就是说F(-x,-y)=F*(x,y)，其中F*表示共轭复数。

4，傅里叶变换的性质

（1）平移

公式（1）表明将f(x,y)与一个指数项相乘就相当于把其变换后的频域中心移动到新的位置

公式（2）表明将F(u,v)与一个指数项相乘就相当于把其变换后的空域中心移动到新的位置

公式（2）表明对f(x,y)的平移不影响其傅里叶变换的幅值 

（2）分配律

（3）数乘

（4）旋转

f(x,y)旋转一个角度 ，F(u,v)也将转过相同的角度，反之亦然。

（5）周期性

（6）共轭对称性

如果f是实函数，则F(u,v)和F(-u,-v)是共轭复数

（7）分离性

 其中F1 是一维傅里叶变换。

即，二维傅里叶变换可以看成逐行做傅里叶变换，再对结果列做一次傅里叶变换，

也可以看成逐列做傅里叶变换，再对结果行做一次傅里叶变换。

反之，逆变换亦然。

（8）卷积定理

示例：

	Mat img1(2, 2, CV_32F);
	img1.at<float>(0, 0) = 1, img1.at<float>(0, 1) = 2;
	img1.at<float>(1, 0) = 3, img1.at<float>(1, 1) = 4;
	Mat img2(2, 2, CV_32F);
	img2.at<float>(0, 0) = 1, img2.at<float>(0, 1) = 1;
	img2.at<float>(1, 0) = 1, img2.at<float>(1, 1) = 2;
	Mat F1(2, 2, CV_32F);
	Mat F2(2, 2, CV_32F);
	cv::dft(img1, F1, cv::DFT_REAL_OUTPUT);
	cv::dft(img2, F2, cv::DFT_REAL_OUTPUT);
	cout << F1.at<float>(0, 0) << " " << F1.at<float>(0, 1) << " " << F1.at<float>(1, 0) << " " << F1.at<float>(1, 1) << endl;
	cout << F2.at<float>(0, 0) << " " << F2.at<float>(0, 1) << " " << F2.at<float>(1, 0) << " " << F2.at<float>(1, 1) << endl;
	Mat F3 = F1.clone();
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 2; j++)F3.at<float>(i, j) = F1.at<float>(i, j)*F2.at<float>(i, j) / 4;
	}
	Mat img3;
	cv::idft(F3, img3);
	cout << F3.at<float>(0, 0) << " " << F3.at<float>(0, 1) << " " << F3.at<float>(1, 0) << " " << F3.at<float>(1, 1) << endl;
	cout << img3.at<float>(0, 0) << " " << img3.at<float>(0, 1) << " " << img3.at<float>(1, 0) << " " << img3.at<float>(1, 1) << endl;

输出：

10 -2 -4 0
5 -1 -1 1
12.5 0.5 1 0
14 13 12 11

空域表达式：

\begin{pmatrix} 1 &2 \\ 3 & 4 \end{pmatrix}\begin{pmatrix} 1 &1 \\ 1 & 2 \end{pmatrix}=\begin{pmatrix} 14 &13 \\ 12 & 11 \end{pmatrix}

这是循环卷积

频域表达式：

\begin{pmatrix} 10 &-2 \\ -4 & 0 \end{pmatrix}\begin{pmatrix} 5 &-1 \\ -1 & 1\end{pmatrix}=\begin{pmatrix} 12.5 &0.5 \\ 1 & 0 \end{pmatrix}

这个是各项相乘再除以4  (r*c=4)

不过这个例子比较特殊，这里面涉及的傅里叶变换的虚部都是0。

换成带虚部的：

	Mat img1(2, 2, CV_32F);
	img1 = 0;
	img1.at<float>(0, 0) = 1, img1.at<float>(0, 1) = 2;
	img1.at<float>(1, 0) = 3, img1.at<float>(1, 1) = 4;
	Mat img2(2, 2, CV_32F);
	img2 = 0;
	img2.at<float>(0, 0) = 1, img2.at<float>(0, 1) = 1;
	img2.at<float>(1, 0) = 1, img2.at<float>(1, 1) = 2;
	Mat F1;
	Mat F2;
	cv::dft(img1, F1, cv::DFT_COMPLEX_OUTPUT);
	cv::dft(img2, F2, cv::DFT_COMPLEX_OUTPUT);
	cout << F1.at<Vec2f>(0, 0) << " " << F1.at<Vec2f>(0, 1) << " " << F1.at<Vec2f>(1, 0) << " " << F1.at<Vec2f>(1, 1) << endl;
	cout << F2.at<Vec2f>(0, 0) << " " << F2.at<Vec2f>(0, 1) << " " << F2.at<Vec2f>(1, 0) << " " << F2.at<Vec2f>(1, 1) << endl;
	Mat F3 = F1.clone();
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 2; j++)F3.at<Vec2f>(i, j) = multi(F1.at<Vec2f>(i, j) ,F2.at<Vec2f>(i, j)) / 4;
	}
	Mat img3;
	cv::idft(F3, img3);
	cout << F3.at<Vec2f>(0, 0) << " " << F3.at<Vec2f>(0, 1) << " " << F3.at<Vec2f>(1, 0) << " " << F3.at<Vec2f>(1, 1) << endl;
	cout << img3.at<Vec2f>(0, 0) << " " << img3.at<Vec2f>(0, 1) << " " << img3.at<Vec2f>(1, 0) << " " << img3.at<Vec2f>(1, 1) << endl;
	Mat F4;
	cv::dft(img3, F4, cv::DFT_COMPLEX_OUTPUT);
	cout << F4.at<Vec2f>(0, 0) << " " << F4.at<Vec2f>(0, 1) << " " << F4.at<Vec2f>(1, 0) << " " << F4.at<Vec2f>(1, 1) << endl;

输出：

[10, 0] [-2, 0] [-4, 0] [0, 0]
[5, 0] [-1, 0] [-1, 0] [1, 0]
[12.5, 0] [0.5, -0] [1, -0] [0, 0]
[14, -0] [13, -0] [12, -0] [11, 0]
[50, 0] [2, 0] [4, -0] [0, 0]

改成3*3的：

	Mat img1(3, 3, CV_32F);
	img1 = 0;
	img1.at<float>(0, 0) = 1, img1.at<float>(0, 1) = 2;
	img1.at<float>(1, 0) = 3, img1.at<float>(1, 1) = 4;
	Mat img2(3, 3, CV_32F);
	img2 = 0;
	img2.at<float>(0, 0) = 1, img2.at<float>(0, 1) = 1;
	img2.at<float>(1, 0) = 1, img2.at<float>(1, 1) = 2;
	Mat F1;
	Mat F2;
	cv::dft(img1, F1, cv::DFT_COMPLEX_OUTPUT);
	cv::dft(img2, F2, cv::DFT_COMPLEX_OUTPUT);
	cout << F1.at<Vec2f>(0, 0) << " " << F1.at<Vec2f>(0, 1) << " " << F1.at<Vec2f>(1, 0) << " " << F1.at<Vec2f>(1, 1) << endl;
	cout << F2.at<Vec2f>(0, 0) << " " << F2.at<Vec2f>(0, 1) << " " << F2.at<Vec2f>(1, 0) << " " << F2.at<Vec2f>(1, 1) << endl;
	Mat F3 = F1.clone();
	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 3; j++)F3.at<Vec2f>(i, j) = multi(F1.at<Vec2f>(i, j) ,F2.at<Vec2f>(i, j)) / 9;
	}
	Mat img3;
	cv::idft(F3, img3);
	cout << F3.at<Vec2f>(0, 0) << " " << F3.at<Vec2f>(0, 1) << " " << F3.at<Vec2f>(1, 0) << " " << F3.at<Vec2f>(1, 1) << endl;
	cout << img3.at<Vec2f>(0, 0) << " " << img3.at<Vec2f>(0, 1) << " " << img3.at<Vec2f>(0, 2) << endl;
	cout << img3.at<Vec2f>(1, 0) << " " << img3.at<Vec2f>(1, 1) << " " << img3.at<Vec2f>(1, 2) << endl;
	cout << img3.at<Vec2f>(2, 0) << " " << img3.at<Vec2f>(2, 1) << " " << img3.at<Vec2f>(2, 2) << endl;
	Mat F4;
	cv::dft(img3, F4, cv::DFT_COMPLEX_OUTPUT);
	cout << F4.at<Vec2f>(0, 0) << " " << F4.at<Vec2f>(0, 1) << " " << F4.at<Vec2f>(1, 0) << " " << F4.at<Vec2f>(1, 1) << endl;

输出：

[10, 0] [1, -5.19615] [-0.5, -6.06218] [-3.5, -0.866025]
[5, 0] [0.5, -2.59808] [0.5, -2.59808] [-1, 0]
[5.55556, 0] [-1.44444, -0.57735] [-1.77778, -0.19245] [0.388889, 0.096225]
[1, -0] [3, -0] [2, -0]
[4, -0] [11, -0] [8, -0]
[3, -0] [10, -0] [8, 0]
[50, 0] [-13, -5.19615] [-16, -1.73205] [3.5, 0.866026]

即卷积\begin{pmatrix} 1 &2 &0 \\ 3 & 4& 0\\ 0& 0 & 0 \end{pmatrix} \begin{pmatrix} 1 &1 &0 \\ 1 & 2& 0\\ 0& 0 & 0 \end{pmatrix}= \begin{pmatrix} 1 &3 &2 \\ 4 & 11& 8\\ 3& 10 & 8 \end{pmatrix}

换成2*3的例子：

	Mat img1(2, 3, CV_32F);
	img1 = 0;
	img1.at<float>(0, 0) = 1, img1.at<float>(0, 1) = 2;
	img1.at<float>(1, 0) = 3, img1.at<float>(1, 1) = 4;
	Mat img2(2, 3, CV_32F);
	img2 = 0;
	img2.at<float>(0, 0) = 1, img2.at<float>(0, 1) = 2, img2.at<float>(1, 2) = 3;
	Mat img3(2, 3, CV_32F);
	img3 = 0;
	img3.at<float>(0, 0) = 13, img3.at<float>(0, 1) = 4, img3.at<float>(0, 2) = 13;
	img3.at<float>(1, 0) = 9, img3.at<float>(1, 1) = 10, img3.at<float>(1, 2) = 11;
	Mat F1;
	Mat F2;
	Mat F3;
	cv::dft(img1, F1, cv::DFT_COMPLEX_OUTPUT);
	cv::dft(img2, F2, cv::DFT_COMPLEX_OUTPUT);
	cv::dft(img3, F3, cv::DFT_COMPLEX_OUTPUT);
	for (int i = 0; i < 2; i++)for (int j = 0; j < 3; j++)cout << F1.at<Vec2f>(i, j) << " ";
	cout << endl;
	for (int i = 0; i < 2; i++)for (int j = 0; j < 3; j++)cout << F2.at<Vec2f>(i, j) << " ";
	cout << endl;
	for (int i = 0; i < 2; i++)for (int j = 0; j < 3; j++)cout << F3.at<Vec2f>(i, j) << " ";

输出：

[10, 0] [1, -5.19615] [1, 5.19615] [-4, 0] [-1, 1.73205] [-1, -1.73205]
[6, 0] [-1.5, 0.866025] [-1.5, -0.866025] [0, 0] [1.5, -4.33013] [1.5, 4.33013]
[60, 0] [3, 8.66025] [3, -8.66025] [0, 0] [6, 6.9282] [6, -6.9282]

（9）相关定理

相关性

相关定理

自相关

四，opencv 相关函数

1，getOptimalDFTSize

入参是图像的行或者列

函数功能：返回一个等于或稍大于入参的整数，这个数只有特别小的素因子。

函数意义：最佳DFT尺寸

函数实现：用二分法即可

源码：


static const int optimalDFTSizeTab[] = {
1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20, 24, 25, 27, 30, 32, 36, 40, 45, 48,
50, 54, 60, 64, 72, 75, 80, 81, 90, 96, 100, 108, 120, 125, 128, 135, 144, 150, 160,
162, 180, 192, 200, 216, 225, 240, 243, 250, 256, 270, 288, 300, 320, 324, 360, 375,
384, 400, 405, 432, 450, 480, 486, 500, 512, 540, 576, 600, 625, 640, 648, 675, 720,
729, 750, 768, 800, 810, 864, 900, 960, 972, 1000, 1024, 1080, 1125, 1152, 1200,
1215, 1250, 1280, 1296, 1350, 1440, 1458, 1500, 1536, 1600, 1620, 1728, 1800, 1875,
1920, 1944, 2000, 2025, 2048, 2160, 2187, 2250, 2304, 2400, 2430, 2500, 2560, 2592,
2700, 2880, 2916, 3000, 3072, 3125, 3200, 3240, 3375, 3456, 3600, 3645, 3750, 3840,
3888, 4000, 4050, 4096, 4320, 4374, 4500, 4608, 4800, 4860, 5000, 5120, 5184, 5400,
5625, 5760, 5832, 6000, 6075, 6144, 6250, 6400, 6480, 6561, 6750, 6912, 7200, 7290,
7500, 7680, 7776, 8000, 8100, 8192, 8640, 8748, 9000, 9216, 9375, 9600, 9720, 10000,
10125, 10240, 10368, 10800, 10935, 11250, 11520, 11664, 12000, 12150, 12288, 12500,
12800, 12960, 13122, 13500, 13824, 14400, 14580, 15000, 15360, 15552, 15625, 16000,
16200, 16384, 16875, 17280, 17496, 18000, 18225, 18432, 18750, 19200, 19440, 19683,
20000, 20250, 20480, 20736, 21600, 21870, 22500, 23040, 23328, 24000, 24300, 24576,
// 省略
1953125000, 1966080000, 1968300000, 1990656000, 1992903750, 2000000000, 2013265920,
2015539200, 2025000000, 2038431744, 2040733440, 2048000000, 2050312500, 2073600000,
2097152000, 2099520000, 2109375000, 2123366400, 2125764000
};

}

int cv::getOptimalDFTSize( int size0 )
{
    int a = 0, b = sizeof(optimalDFTSizeTab)/sizeof(optimalDFTSizeTab[0]) - 1;
    if( (unsigned)size0 >= (unsigned)optimalDFTSizeTab[b] )
        return -1;

    while( a < b )
    {
        int c = (a + b) >> 1;
        if( size0 <= optimalDFTSizeTab[c] )
            b = c;
        else
            a = c+1;
    }

    return optimalDFTSizeTab[b];
}

做DFT时，先计算最佳尺寸，然后把图像扩充到这个尺寸，边界扩充：https://blog.csdn.net/nameofcsdn/article/details/118281568

csuzhucong
关注
信号与系统学习：傅里叶级数
2301_80094394的博客
10-24 5017
傅里叶级数是一种数学。
傅里叶级数和傅里叶变换之间的关系推理及应用
目前在做 ROS相关的工作，主要是写ROS相关和C++的学习心得
05-24 1万+
傅里叶级数和傅立叶变换是傅里叶分析的两种表示方法，它们可以相互转换，但适用于不同的函数类别和分析需求。傅里叶级数适用于周期函数的频谱分析，而傅立叶变换适用于非周期函数的频谱分析。傅里叶级数是将一个周期函数分解为一系列正弦和余弦函数的和。它适用于周期性信号，可以将周期函数表示为一组振幅和相位不同的谐波分量的和。傅立叶变换则是将非周期性函数或信号分解为一组连续的正弦和余弦函数（复指数函数）的积分。傅里叶级数和傅立叶变换是傅里叶分析的两个主要工具，它们之间有密切的关系。的正弦和余弦函数的振幅。
傅里叶级数：一篇文章带你看清“万物皆波“的数学魔法
最新发布
本博客聚焦游戏开发技巧、创业实战心得及大学热门课程干货。这里既有技术深度，也有思维广度，无论你是开发者、创业者还是高校学子，都能在这里找到适合自己的成长之路！
05-20 524
傅里叶级数——是数学送给人类最美丽的礼物之一。它告诉我们——再复杂的事物——都可以由最简单的元素组合而成。再混乱的信号——都隐藏着规律和秩序。换个角度看世界——你会发现完全不同的风景。它在你的手机里、在你的耳机里、在你的相机里、在你的 WiFi 信号里、在医院的 CT 机里、在天文望远镜里——无处不在——它默默运转——让现代世界成为可能。最后送你三句心里话——第一句——不要害怕公式。傅里叶级数的公式看起来吓人——但它讲的是一件非常浪漫、非常直观的事——复杂可以拆成简单。
matlab算法(二维傅立叶级数变换)
qq_71391523的博客
12-07 3427
图像处理
傅里叶级数（Fourier）
2302_78846666的博客
01-21 8803
一、傅里叶展开的意义1、泰勒(Tarlor展开的基本形式2、傅里叶(fourier)展开的基本形式二、三角函数系1、三角函数系2、性质3、积化和差公式4、例题讲解三、如何求解傅里叶级数中的a0、an、bn四、傅里叶级数1的展开方法和狄利克雷(Dirichlet)收敛定理1、展开方法傅里叶图像要求有周期性，进行周期延拓2、狄利克雷收敛证明图像五、正弦级数和余弦级数1、正弦级数和余弦级数的介绍2、奇延拓和偶延拓。
傅里叶级数
热门推荐
月光下的麦田的博客
04-20 8万+
一、理论基础   任何周期函数都可以看成是不同振幅，不同相位的正弦波的叠加。 1. 三角函数系的正交性：    三角函数系：          三角函数系中任意两个不同的函数之积在[-π,π]上的积分为0。 2. 将周期函数展开为三角级数    假设有周期函数 f(x)=f(x+2π)，周期为2*PI；则函数可以展开为下面的三角级数：        书中展示的公式为： 以上两个公式本质...
傅里叶级数与傅里叶变换
贾路飞的博客
07-19 2万+
傅里叶级数：任何周期函数，只要满足一定条件都可以表示为不同频率的正弦和/或余弦之和的形式，该和成为傅里叶级数。 傅里叶变换：任何非周期函数（但该曲线下的面积是有限的），也可以用正弦和/或余弦乘以加权函数的积分来表示，在这种情况下的公式就是傅里叶变换。 傅里叶级数与傅里叶变换的关系：周期函数的周期可以趋向无穷大，这样就可以将傅里叶变换看成是傅里叶级数的推广。 一、傅里叶级数 1....
傅里叶级数、一维傅里叶变换到二维傅里叶变换数理推导
gactyxc的博客
12-18 1万+
傅里叶级数、一维傅里叶变换到二维傅里叶变换数理推导 参考资料： 如何理解傅里叶级数公式 从傅里叶级数到傅里叶变换 高维傅里叶变换的推导 IDL实现傅里叶变换 傅里叶级数 一维傅里叶变换 二维傅里叶变换 ...
傅里叶级数和傅里叶变换简介和推导
crj0926的博客
10-06 1万+
一.傅里叶变换简介 在数学上，对任意函数 f(x)，可按某一点进行展开，常见的有泰勒展开和傅里叶展开。 泰勒展开为各阶次幂函数的线性组合形式， 本质上自变量未改变，仍为 x。但是傅里叶变换有： 傅里叶展开为三角函数的线性组合。 将自变量由x变成 ω。 由时域分析变换到频域分析。 由于这些特点，所以信号处理上经常使用傅里叶变换。 信号分析与处理中常见的有： 简称 全称 CFS（C...
从傅里叶级数到傅里叶变换
znculee的博客
03-22 1万+
傅里叶级数与傅里叶变换
傅里叶级数和傅里叶变换
Monkey&Penguin的博客
08-17 3144
最近在课堂中再次接触了傅里叶级数（FS——Fourier Series）和傅里叶变换（FT——Fourier Transform），这里写一点粗浅的笔记来帮助自己理解。 一、傅里叶级数的意义 首先傅里叶级数是伟大的，它成功的给我们描绘了另一个看待世界的角度，纷纷扰扰变幻莫测的世间万物也许只是上帝早已谱写好的乐章。一切看似无常的变化在傅里叶看来不过是无数个齿轮固定运动的叠加。 为何这么说呢，因为通过傅里叶级数，我们发现一切周期性运动都可以用简单的震荡波叠加而得。当然，更正式的说法是满足对于满足狄利克雷定
傅里叶级数详解
weixin_44378835的博客
07-16 1万+
文章目录函数分解为正交函数1 向量的正交分解2 函数的正交分解周期函数的傅里叶级数1 周期函数三角形式的傅里叶级数1.1 三角形式的傅里叶级数1.2 余弦形式的傅里叶级数2 复指数形式的傅里叶级数3 三种展开方式关系总结附 ：狄里赫利(Dirichlet)条件 首先，推荐一个有意思的视频：【谜之舒适】12分钟的傅立叶级数动画 下面进入正文。 周期为2π2\pi2π的方波函数： z(t)={−1，−π≤t<01，0≤t<πz(t)=\begin{cases}-1，-\pi\le t\lt 0\
傅里叶级数(FS)
DGY_ChenYong的博客
08-11 3372
当函数f(x)的周期为2l，ω = 2π/T，即有ω = 2π/2l = π/l，复指数形式傅里叶级数中出现的负频率分量只是一种数学表达形式，没有确切的物理含义。当函数f(x)的周期为2π，ω = 2π/T，即有ω = 2π/2π = 1，，且满足狄利克雷条件的周期信号f(t)，展开成三角函数形式的傅里叶级数为。当k=n时,根据和差化积公式，当k≠n时,根据和差化积公式，为了简化书写和好理解，令。对于周期为T、角频率。代入上边的式子，可得。
一文搞懂傅里叶级数与变换
weixin_42156097的博客
11-25 5039
这篇文章的目标：以最简单易懂的方式，让大家学会傅里叶变换！为什么要写一篇关于傅里叶变换相关知识的文章呢。有两个原因：一、这个知识很有趣，可以理解它是一件炫酷的事情。在工作中，一次分享会同事站在很高的角度，重新分析了傅里叶变换。二、曾经的经历与傅里叶相关，之前有一年的宿舍号码是553，数字英文是FiveFiveThree，而FFT正是快速傅里叶变换的缩写。学生时代一次短短的创业尝试，团队的名字就命名为了FFT。这让我对傅里叶变换有了一种特殊的情感。
【超详细~】手把手带你推导傅里叶级数~
qq_45957458的博客
11-09 7433
超级详细的傅里叶级数推导、傅立叶级数意义、傅立叶级数例子，即使没有基础也没有关系~
傅里叶级数系数的完整详细算法
weixin_42550185的博客
10-26 3万+
傅里叶级数系数的完整详细算法
函数、函数的傅里叶级数展开、傅里叶级数的和函数之间的关系
一个搬运知识的笨小孩
10-03 9079
函数、函数的傅里叶级数展开、傅里叶级数的和函数之间的关系
提出、推导、结论——一文了解傅里叶级数&变换
weixin_73925063的博客
10-17 5831
不管是傅里叶级数还是傅里叶变换，使用这种方法的目的就是将时域描述转化为频域描述，从而分析复杂信号中有多少种频率成分。（本质上就是两个不同角度看待问题）
【高数+复变函数】傅里叶级数
小白有颗大白梦的博客
05-07 3493
傅里叶级数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值