标签: fft

我有一个二维数组的复数,表示沿真实空间中的平面测量的潜在场.假设该阵列是128个单元乘128个单元,并且该平面的总面积是500m×500m.该数组中的每个单元代表空间域中的一个点,坐标以x和y给出.

当我在这个2d阵列上使用scipy.fftpack的2d FFT时,我得到了波域中表示的相同信息.如何为输出数组的点计算波域坐标kx和ky？

我正在尝试为学校项目实施高斯模糊.我需要制作CPU和GPU实现来比较性能.

我不太清楚我是否理解高斯模糊是如何工作的.所以我的一个问题是我是否理解正确？

以下是我现在所做的事情:我使用维基百科http://en.wikipedia.org/wiki/Gaussian_blur中的等式来计算过滤器.对于2D,我采用图像中每个像素的RGB,并通过将像素的RGB和周围像素与相关的滤波器位置相乘来应用滤波器.然后将它们相加为新的像素RGB值.对于1d我首先水平地应用滤波器,然后是静态地应用滤波器,如果我理解正确的话,这应该给出相同的结果.这个结果与应用2d滤波器的结果完全相同吗？

我的另一个问题是如何优化算法.我已经读过快速傅立叶变换适用于高斯模糊.但我无法弄清楚如何联系它.有人能给我一个正确方向的暗示吗？

谢谢.

我将使用光谱能量和光谱熵作为基于窗口的时间序列数据的特征。但是，我对在线使用的公式有些困惑，尤其是关于特殊熵。

我使用了 Matlab 中的熵，但这不适用于时间序列数据。它只是给我所有的零。http://www.mathworks.nl/help/images/ref/entropy.html 此版本的测试窗口熵结果 = 0

然后我用了这个版本。 http://www.mathworks.com/matlabcentral/fileexchange/28692-entropy 测试窗口此版本的熵结果 = 4.3219

在将 imhist 应用于数据窗口（p = imhist(aw1(:));）后，我还尝试了 -sum(p.*log2(p))。这是从在线帮助中得到的。
此版本的测试窗口熵结果 = 0.0369

他们都报告了不同的值。

对于光谱能量，我使用的是 fft 系数的平方和。sum(abs(fft(data-window)).^2)

任何机构都可以给我任何正确版本的建议吗？

首先我知道在这里有一个相同的问题答案:Matlab中的FFT和numpy/scipy给出不同的结果, 但那里给出的答案对我做的测试不起作用:

当我从numpy.fft做一个fft我得到以下结果:

In [30]: numpy.fft.fft(numpy.array([1+0.5j, 3+0j, 2+0j, 8+3j]))
Out[30]: array([ 14.+3.5j,  -4.+5.5j,  -8.-2.5j,   2.-4.5j])

这与我的八度音程的输出完全相同)

octave:39> fft([1+0.5j,3+0j,2+0j,8+3j])
ans =
Columns 1 through 3:
14.0000 +  3.5000i   -4.0000 +  5.5000i   -8.0000 -  2.5000i
Column 4:
2.0000 -  4.5000i

但如果我将列表转换为octave和python我得到:

In [9]: numpy.fft.fft(numpy.array([1+0.5j, 3+0j, 2+0j, 8+3j]).transpose())
Out[9]: array([ 14.+3.5j,  -4.+5.5j,  -8.-2.5j,   2.-4.5j])

和八度:

octave:40> fft([1+0.5j,3+0j,2+0j,8+3j]')
ans =

14.0000 -  3.5000i
2.0000 +  4.5000i
-8.0000 +  2.5000i
-4.0000 -  5.5000i

我也尝试在python中重塑,但这会导致:

In [33]: numpy.fft.fft(numpy.reshape(numpy.array([1+0.5j,3+0j,2+0j,8+3j]), (4,1)))
Out[33]: 
array([[ 1.+0.5j],
   [ 3.+0.j ], …

我正在使用 Radix-2 Cooley-Tukey FFT/FFT-inverse 实现卷积，我的输出是正确的，但在完成时发生了偏移。

我的解决方案是将输入大小和内核大小都零填充到 2^m 以获得最小可能的 m，使用 FFT 转换输入和内核，然后将两个元素相乘并使用 FFT 逆将结果转换回。

作为由此产生的问题的示例：

 0  1  2  3  0  0  0  0
 4  5  6  7  0  0  0  0
 8  9 10 11  0  0  0  0
12 13 14 15  0  0  0  0
 0  0  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
 0  0  0  0  0  0  0  0
 0  0  0  0  0  0  0  0

带有身份核

0 …

给定一个二维数组,其中每一行代表一个粒子的位置矢量,如何有效地计算均方位移(使用FFT)？均方位移定义为

其中r(m)是行m的位置矢量,N是行数.

我刚刚开始将TarsosDSP用于Android，但我不知道如何使用FFT。谁能提供样品给我？我只是想读取一个文件并获取其FFT输出。

我想在tensorflow中使用fft。但是我发现分别在numpy和tensorflow中使用FFT函数时结果不同。特别是当输入数组的大小很大时

import tensorflow as tf
import numpy as np

aa = tf.lin_space(1.0, 10000.0, 10000)
bb = tf.lin_space(1.0, 10000.0, 10000)
dd = tf.concat([[aa],[bb]],axis = 0)
c_input = tf.complex(dd[0,:], dd[1,:])
Spec = tf.fft(c_input)
sess = tf.Session()
uuu = sess.run(Spec)
print(uuu)

aaa = np.linspace(1.0, 10000.0, 10000)
bbb = aaa + 1j*aaa
ccc = np.fft.fft(bbb)
print(ccc)

结果是

[ 11645833.000000+11645826.j         -544529.875000 -6242453.5j
   -913097.437500  -781089.0625j   ...,     78607.218750  -108219.109375j
    103245.156250  -182935.3125j      214871.765625  -790986.0625j  ]
[ 50005000.00000000+50005000.j         -15920493.78559075+15910493.78559076j
  -7962746.10739718 +7952746.10739719j ...,
   5300163.19893340 -5310163.19893345j
   7952746.10739715 -7962746.10739723j
  15910493.78559067-15920493.78559085j]

所以，当我在tensorflow中使用fft函数时，我该怎么办才能获得相同的结果？谢谢你的答案

我发现tf.fft输出的数据类型为complex64。但是np.fft.fft的输出是complex128。这是这个问题的关键吗？我怎么解决这个问题？

我正在测试Matlab中FFT和IFFT函数的有效性.

我可以将这些函数的输出与一个众所周知的数学事实进行比较:偶数,实数函数的傅里叶变换(如以0为中心的高斯),是另一个偶数,实数函数(FFT [真实,0居中高斯] =真实,0居中的高斯).这个事实应该适用于FFT和IFFT.

首先我制作网格:

nx = 256; % grid total pixel count
X = 500; % grid size (um)
dx = X/nx; %  grid spacing (um)
x = linspace(-nx/2,nx/2-1,nx)*dx; % x grid (um)

df = 1/(nx*dx); % spectral grid spacing (1/um)
f = linspace(-nx/2,nx/2-1,nx)*df; % f grid (1/um)

我制作了高斯:

A = 1; % magnitude (arbitrary units) 
x_fwhm = 7; % Full width at half maximum diameter (um)

x0 = x_fwhm/sqrt(2*log(2)); % 1/e^2 radius (um)
y = A*exp(-2*x.^2./(x0)^2); % Gaussian …

我使用本机Apple类在FFT算法中实现。我直接从他们的网站上删除了代码：

https://developer.apple.com/documentation/accelerate/vdsp/fast_fourier_transforms/finding_the_component_frequencies_in_a_composite_sine_wave

但是，当我运行代码时，每次都会提供不同的结果。我创建了一个重复运行的单元测试，并比较在单元测试失败时结果是否相同。我唯一的猜测是这是一个内存问题。这是我可以想象每次结果都可能不同的唯一方法。

import Foundation
import Accelerate

class AppleFFT{
    var windowSize = 512
    var n = vDSP_Length(512)
    var halfN = Int(512 / 2)
    var fftSetUp : FFTSetup?
    var log2n : vDSP_Length?
    init(windowSize: Int){
        self.windowSize = windowSize 
        n = vDSP_Length(windowSize)
        halfN = Int(n / 2)
        initialize()
    }
    private init(){
        initialize()
    }
    func initialize(){
        log2n = vDSP_Length(log2(Float(n)))
        if log2n == nil { return }
        fftSetUp = vDSP_create_fftsetup(log2n!, FFTRadix(kFFTRadix2))

    }
    func process(signal : [Float], n: vDSP_Length) ->DSPSplitComplex{
        let window = vDSP.window(ofType: Float.self,
                                 usingSequence: …