spectrogram() - Signal Processing
examples = spectrogram(x) returns
the short-time Fourier transform of the input signal, x.
Each column of s contains an estimate of the
short-term, time-localized frequency content of x.
s = spectrogram(x,window) uses window to
divide the signal into sections and perform windowing.
examples = spectrogram(x,window,noverlap) uses noverlap samples
of overlap between adjoining sections.
examples = spectrogram(x,window,noverlap,nfft) uses nfft sampling
points to calculate the discrete Fourier transform.
[s,w,t]
= spectrogram(___) returns a vector of normalized
frequencies, w, and a vector of time instants, t,
at which the spectrogram is computed. This syntax can include any
combination of input arguments from previous syntaxes.
example[s,f,t]
= spectrogram(___,fs) returns
a vector of cyclical frequencies, f, expressed in
terms of the sample rate, fs.
[s,w,t]
= spectrogram(x,window,noverlap,w) returns
the spectrogram at the normalized frequencies specified in w.
[s,f,t]
= spectrogram(x,window,noverlap,f,fs) returns
the spectrogram at the cyclical frequencies specified in f.
[___,ps] = spectrogram(___) also
returns a matrix, ps, containing an estimate
of the power spectral density (PSD) or the power spectrum of each
section.
example[___] = spectrogram(___,'reassigned') reassigns
each PSD or power spectrum estimate to the location of its center
of energy. If your signal contains well-localized temporal or spectral
components, then this option generates a sharper spectrogram.
example[___,ps,fc,tc]
= spectrogram(___) also returns two matrices, fc and tc,
containing the frequency and time of the center of energy of each
PSD or power spectrum estimate.
[___] = spectrogram(___,freqrange) returns
the PSD or power spectrum estimate over the frequency range specified
by freqrange. Valid options for freqrange are 'onesided', 'twosided',
and 'centered'.
[___] = spectrogram(___,spectrumtype) returns
PSD estimates if spectrumtype is specified as 'psd' and
returns power spectrum estimates if spectrumtype is
specified as 'power'.
example[___] = spectrogram(___,'MinThreshold',thresh) sets
to zero those elements of ps such that 10 log10(ps) ≤ thresh.
Specify thresh in decibels.
examplespectrogram(___) with no output
arguments plots the spectrogram in the current figure window.
examplespectrogram(___,freqloc) specifies
the axis on which to plot the frequency.
Syntax
<![CDATA[s = spectrogram(x) examples = spectrogram(x,window)s = spectrogram(x,window,noverlap) examples = spectrogram(x,window,noverlap,nfft) example[s,w,t]
= spectrogram(___)[s,f,t]
= spectrogram(___,fs) example[s,w,t]
= spectrogram(x,window,noverlap,w)[s,f,t]
= spectrogram(x,window,noverlap,f,fs)[___,ps] = spectrogram(___)[___] = spectrogram(___,'reassigned') example[___,ps,fc,tc]
= spectrogram(___) example[___] = spectrogram(___,freqrange)[___] = spectrogram(___,spectrumtype)[___] = spectrogram(___,'MinThreshold',thresh) examplespectrogram(___) examplespectrogram(___,freqloc) example]]>
Example
<![CDATA[Default Values of SpectrogramOpen This Example
Generate
samples of a signal that consists of a sum of sinusoids. The normalized frequencies of the sinusoids are
rad/sample and
rad/sample. The higher frequency sinusoid has 10 times the amplitude of the other sinusoid.
N = 1024;
n = 0:N-1;
w0 = 2*pi/5;
x = sin(w0*n)+10*sin(2*w0*n);
Compute the short-time Fourier transform using the function defaults. Plot the spectrogram.s = spectrogram(x);
spectrogram(x,'yaxis')
Repeat the computation.Divide the signal into sections of length
.Window the sections using a Hamming window.Specify 50% overlap between contiguous sections.To compute the FFT, use
points, where
.Verify that the two approaches give identical results.Nx = length(x);
nsc = floor(Nx/4.5);
nov = floor(nsc/2);
nff = max(256,2^nextpow2(nsc));
t = spectrogram(x,hamming(nsc),nov,nff);
maxerr = max(abs(abs(t(:))-abs(s(:))))
maxerr =
0
Divide the signal into 8 sections of equal length, with 50% overlap between sections. Specify the same FFT length as in the preceding step. Compute the short-time Fourier transform and verify that it gives the same result as the previous two procedures.ns = 8;
ov = 0.5;
lsc = floor(Nx/(ns-(ns-1)*ov));
t = spectrogram(x,lsc,floor(ov*lsc),nff);
maxerr = max(abs(abs(t(:))-abs(s(:))))
maxerr =
0
Frequency Along x-AxisOpen This ExampleGenerate a quadratic chirp, x, sampled at 1 kHz for 2 seconds. The frequency of the chirp is 100 Hz initially and crosses 200 Hz at t = 1 s.t = 0:0.001:2;
x = chirp(t,100,1,200,'quadratic');
Compute and display the spectrogram of x.Divide the signal into sections of length 128, windowed with a Hamming window.Specify 120 samples of overlap between adjoining sections.Evaluate the spectrum at
frequencies and
time bins.spectrogram(x,128,120,128,1e3)
Replace the Hamming window with a Blackman window. Decrease the overlap to 60 samples. Plot the time axis so that its values increase from top to bottom.spectrogram(x,blackman(128),60,128,1e3)
ax = gca;
ax.YDir = 'reverse';
Power Spectral Densities of ChirpsOpen This Example
Compute and display the PSD of each segment of a quadratic chirp that starts at 100 Hz and crosses 200 Hz at t = 1 s. Specify a sample rate of 1 kHz, a segment length of 128 samples, and an overlap of 120 samples. Use 128 DFT points and the default Hamming window.
t = 0:0.001:2;
x = chirp(t,100,1,200,'quadratic');
spectrogram(x,128,120,128,1e3,'yaxis')
title('Quadratic Chirp')
Compute and display the PSD of each segment of a linear chirp that starts at DC and crosses 150 Hz at t = 1 s. Specify a sample rate of 1 kHz, a segment length of 256 samples, and an overlap of 250 samples. Use the default Hamming window and 256 DFT points.t = 0:0.001:2;
x = chirp(t,0,1,150);
spectrogram(x,256,250,256,1e3,'yaxis')
title('Linear Chirp')
Compute and display the PSD of each segment of a logarithmic chirp sampled at 1 kHz that starts at 20 Hz and crosses 60 Hz at t = 1 s. Specify a segment length of 256 samples and an overlap of 250 samples. Use the default Hamming window and 256 DFT points.t = 0:0.001:2;
x = chirp(t,20,1,60,'logarithmic');
spectrogram(x,256,250,[],1e3,'yaxis')
title('Logarithmic Chirp')
Use a logarithmic scale for the frequency axis. The spectrogram becomes a line.ax = gca;
ax.YScale = 'log';
Spectrogram and Instantaneous FrequencyOpen This ExampleUse the spectrogram function to measure and track the instantaneous frequency of a signal.Generate a quadratic chirp sampled at 1 kHz for two seconds. Specify the chirp so that its frequency is initially 100 Hz and increases to 200 Hz after one second.Fs = 1000;
t = 0:1/Fs:2-1/Fs;
y = chirp(t,100,1,200,'quadratic');
Estimate the spectrum of the chirp using the short-time Fourier transform implemented in the spectrogram function. Divide the signal into sections of length 100, windowed with a Hamming window. Specify 80 samples of overlap between adjoining sections and evaluate the spectrum at
frequencies. Suppress the default color bar.spectrogram(y,100,80,100,Fs,'yaxis')
view(-77,72)
shading interp
colorbar off
Track the chirp frequency by finding the maximum of the power spectral density at each of the
time points. View the spectrogram as a two-dimensional graphic. Restore the color bar.[s,f,t,p] = spectrogram(y,100,80,100,Fs);
[q,nd] = max(10*log10(p));
hold on
plot3(t,f(nd),q,'r','linewidth',4)
hold off
colorbar
view(2)
Reassigned Spectrogram of Quadratic ChirpOpen This Example
Generate a chirp signal sampled for 2 seconds at 1 kHz. Specify the chirp so that its frequency is initially 100 Hz and increases to 200 Hz after 1 second.
Fs = 1000;
t = 0:1/Fs:2;
y = chirp(t,100,1,200,'quadratic');
Estimate the reassigned spectrogram of the signal.Divide the signal into sections of length 128, windowed with a Kaiser window with shape parameter
.Specify 120 samples of overlap between adjoining sections.Evaluate the spectrum at
frequencies and
time bins.spectrogram(y,kaiser(128,18),120,128,Fs,'reassigned','yaxis')
Spectrogram with ThresholdOpen This Example
Generate a chirp signal sampled for 2 seconds at 1 kHz. Specify the chirp so that its frequency is initially 100 Hz and increases to 200 Hz after 1 second.
Fs = 1000;
t = 0:1/Fs:2;
y = chirp(t,100,1,200,'quadratic');
Estimate the time-dependent power spectral density (PSD) of the signal.Divide the signal into sections of length 128, windowed with a Kaiser window with shape parameter
.Specify 120 samples of overlap between adjoining sections.Evaluate the spectrum at
frequencies and
time bins.Output the frequency and time of the center of gravity of each PSD estimate. Set to zero those elements of the PSD smaller than
dB.[~,~,~,pxx,fc,tc] = spectrogram(y,kaiser(128,18),120,128,Fs, ...
'MinThreshold',-30);
Plot the nonzero elements as functions of the center-of-gravity frequencies and times.plot(tc(pxx>0),fc(pxx>0),'.')
Spectrogram Reassignment and ThresholdingOpen This Example
Generate a signal sampled at 1024 Hz for 2 seconds.
nSamp = 2048;
Fs = 1024;
t = (0:nSamp-1)'/Fs;
During the first second, the signal consists of a 400 Hz sinusoid and a concave quadratic chirp. Specify the chirp so that it is symmetric about the interval midpoint, starting and ending at a frequency of 250 Hz and attaining a minimum of 150 Hz.t1 = t(1:nSamp/2);
x11 = sin(2*pi*400*t1);
x12 = chirp(t1-t1(nSamp/4),150,nSamp/Fs,1750,'quadratic');
x1 = x11+x12;
The rest of the signal consists of two linear chirps of decreasing frequency. One chirp has an initial frequency of 250 Hz that decreases to 100 Hz. The other chirp has an initial frequency of 400 Hz that decreases to 250 Hz.t2 = t(nSamp/2+1:nSamp);
x21 = chirp(t2,400,nSamp/Fs,100);
x22 = chirp(t2,550,nSamp/Fs,250);
x2 = x21+x22;
Add white Gaussian noise to the signal. Specify a signal-to-noise ratio of 20 dB. Reset the random number generator for reproducible results.SNR = 20;
rng('default')
sig = [x1;x2];
sig = sig + randn(size(sig))*std(sig)/db2mag(SNR);
Compute and plot the spectrogram of the signal. Specify a Kaiser window of length 63 with a shape parameter
, 10 fewer samples of overlap between adjacent segments, and an FFT length of 256.nwin = 63;
wind = kaiser(nwin,17);
nlap = nwin-10;
nfft = 256;
spectrogram(sig,wind,nlap,nfft,Fs,'yaxis')
Threshold the spectrogram so that any elements with values smaller than the SNR are set to zero.spectrogram(sig,wind,nlap,nfft,Fs,'MinThreshold',-SNR,'yaxis')
Reassign each PSD estimate to the location of its center of energy.spectrogram(sig,wind,nlap,nfft,Fs,'reassign','yaxis')
Threshold the reassigned spectrogram so that any elements with values smaller than the SNR are set to zero.spectrogram(sig,wind,nlap,nfft,Fs,'reassign','MinThreshold',-SNR,'yaxis')
Track Chirps in Audio SignalOpen This ExampleLoad an audio signal that contains two decreasing chirps and a wideband splatter sound. Compute the short-time Fourier transform. Divide the waveform into 400-sample segments with 300-sample overlap. Plot the spectrogram.load splat
% To hear, type soundsc(y,Fs)
sg = 400;
ov = 300;
spectrogram(y,sg,ov,[],Fs,'yaxis')
colormap bone
Use the spectrogram function to output the power spectral density (PSD) of the signal.[s,f,t,p] = spectrogram(y,sg,ov,[],Fs);
Track the two chirps using the medfreq function. To find the stronger, low-frequency chirp, restrict the search to frequencies above 100 Hz and to times before the start of the wideband sound.f1 = f > 100;
t1 = t < 0.75;
m1 = medfreq(p(f1,t1),f(f1));
To find the faint high-frequency chirp, restrict the search to frequencies above 2500 Hz and to times between 0.3 seconds and 0.65 seconds.f2 = f > 2500;
t2 = t > 0.3 & t < 0.65;
m2 = medfreq(p(f2,t2),f(f2));
Overlay the result on the spectrogram. Divide the frequency values by 1000 to express them in kHz.hold on
plot(t(t1),m1/1000,'linewidth',4)
plot(t(t2),m2/1000,'linewidth',4)
hold off
3D Spectrogram VisualizationOpen This Example
Generate two seconds of a signal sampled at 10 kHz. Specify the instantaneous frequency of the signal as a triangular function of time.
fs = 10e3;
t = 0:1/fs:2;
x1 = vco(sawtooth(2*pi*t,0.5),[0.1 0.4]*fs,fs);
Compute and plot the spectrogram of the signal. Use a Kaiser window of length 256 and shape parameter
. Specify 220 samples of section-to-section overlap and 512 DFT points. Plot the frequency on the y-axis. Use the default colormap and view.spectrogram(x1,kaiser(256,5),220,512,fs,'yaxis')
Change the view to display the spectrogram as a waterfall plot. Set the colormap to bone.colormap bone
view(-45,65)
Related ExamplesFormant Estimation with LPC Coefficients]]>
Output / Return Value
Limitations
Alternatives / See Also
Reference