Python频率与时间图

Question

I am attempting to get a frequency vs. time graph of a .wav file using Python. At the moment I have code that is graphing Amplitude vs. Time as well as Frequency vs. Power (dB). I have attempted, unsuccessfully, to use the code for my Frequency vs. Power graph to instead plot Frequency vs. Time. I know that the Frequency data is symmetric, which means I have 1/2 of the data points compared to my time data. I can plot them both by keeping the duplicate frequency data, but I am skeptical as to whether or not this actually produces an accurate representation of the frequency vs. time.

I get the sense that the method will involve using a Short-time Fourier Transform on segments of the data and then plotting the results. That said, I have found some code that does something similar to this, but I am having a hard time understanding what is happening with the code and making any meaningful adjustments that would help me accomplish my goals.

In summary, I was hoping that someone would have some sample code or a method for creating a frequency vs. time graph of a .wav file in Python. Thanks a ton! Please let me know if I could post the code that I have been using thus far.

#Import the required functions
from scipy.io.wavfile import read
from scipy.fftpack import fft, fftfreq, fftshift
from scipy.signal import get_window
from math import ceil
from pylab import figure, imshow, clf, gray, xlabel, ylabel

# Read in a wav file 
#   returns sample rate (samples / sec) and data
rate, data = read('waveTest.wav')
data = data[:,0]
# Define the sample spacing and window size.
dT = 1.0/rate
T_window = 50e-3
N_window = int(T_window * rate)
N_data = len(data)

# 1. Get the window profile
window = get_window('hamming', N_window)

# 2. Set up the FFT
result = []
start = 0
while (start < N_data - N_window):
    end = start + N_window
    result.append(fftshift(fft(window*data[start:end])))
    start = end

result.append(fftshift(fft(window*data[-N_window:])))
result = array(result,result[0].dtype)

# Display results
freqscale = fftshift(fftfreq(N_window,dT))[150:-150]/1e3
figure(1)
clf()

s.imshow(abs(result[:,150:-150]), extent=(5,-5,(N_data*dT-T_window/2.0),T_window/2.0)) #19.04, -19.04, 6.41, 0.025 
s.xlabel('Frequency (kHz)')
s.ylabel('Time (sec.)')

s.show()

As requested, above is the code that I am trying to get working. I actually seem to have it working fine, but I have a couple of questions.

1) What exactly is abs(result[:,150:-150])? I realize that he is taking the absolute value of the Fourier Transform (in order to remove the complex component?). Is this then the frequency?

2) How would I swap the data to have the time on the X axis with frequency on the Y axis?

3) How does the image know which frequency corresponds to which time? If I understand correctly the extents takes the final two parameters which are the length of the file in time and the step that the file should make?

4) Is it possible to graph the data in a plot rather then on an image?

I hope these are not too many, and too specific of questions. Thanks again for any help that can be provided!

Answer 1

1) result[:,150:-150] gives a numpy.array containing all rows (each row corresponds to a frequency calculated by fft) and columns from 150 to number of columns - 150 . Each column corresponds to time. Yes, abs takes absolute value for given frequency which roughly corresponds to the frequency of the signal.

2) In abs(result[:,150:-150]) you need to transpose the matrix, like so: abs(result[:,150:-150]).transpose() .

3) The extent arguments specifies ranges in the final plot. Since each column corresponds to specific point in time it's a simple mapping.

4) The data that you get is how much given frequency contributes to the signal at given time (given a window of time, because frequency at specific point doesn't make sense). It's by nature a 2D data. You may try to find dominating frequency at given time and then plot it as a simple function.

Also your code as it is does not work. Perhaps you have missed some variable definitions and imports from the rest of you program.