public/ThinkDSP
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Upload files to 'test_code'

Browse Source
This commit is contained in:
Charlie 2020-02-16 11:00:02 +00:00
parent f800fdf423
commit 1f51c2e7b4
3 changed files with 482 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
test_code/aliasing.py Normal file
View File

@ -0,0 +1,104 @@
"""This file contains code used in "Think DSP",
by Allen B. Downey, available from greenteapress.com
Copyright 2013 Allen B. Downey
License: GNU GPLv3 http://www.gnu.org/licenses/gpl.html
"""
from __future__ import print_function, division
import thinkdsp
import thinkplot
FORMATS = ['pdf', 'png']
def triangle_example(freq):
"""Makes a figure showing a triangle wave.
freq: frequency in Hz
"""
framerate = 10000
signal = thinkdsp.TriangleSignal(freq)
duration = signal.period*3
segment = signal.make_wave(duration, framerate=framerate)
segment.plot()
thinkplot.save(root='triangle-%d-1' % freq,
xlabel='Time (s)',
axis=[0, duration, -1.05, 1.05])
wave = signal.make_wave(duration=0.5, framerate=framerate)
spectrum = wave.make_spectrum()
thinkplot.preplot(cols=2)
spectrum.plot()
thinkplot.config(xlabel='Frequency (Hz)',
ylabel='Amplitude')
thinkplot.subplot(2)
spectrum.plot()
thinkplot.config(ylim=[0, 500],
xlabel='Frequency (Hz)')
thinkplot.save(root='triangle-%d-2' % freq)
def square_example(freq):
"""Makes a figure showing a square wave.
freq: frequency in Hz
"""
framerate = 10000
signal = thinkdsp.SquareSignal(freq)
duration = signal.period*3
segment = signal.make_wave(duration, framerate=framerate)
segment.plot()
thinkplot.save(root='square-%d-1' % freq,
xlabel='Time (s)',
axis=[0, duration, -1.05, 1.05])
wave = signal.make_wave(duration=0.5, framerate=framerate)
spectrum = wave.make_spectrum()
spectrum.plot()
thinkplot.save(root='square-%d-2' % freq,
xlabel='Frequency (Hz)',
ylabel='Amplitude')
def aliasing_example(offset=0.000003):
"""Makes a figure showing the effect of aliasing.
"""
framerate = 10000
def plot_segment(freq):
signal = thinkdsp.CosSignal(freq)
duration = signal.period*4
thinkplot.Hlines(0, 0, duration, color='gray')
segment = signal.make_wave(duration, framerate=framerate*10)
segment.plot(linewidth=0.5, color='gray')
segment = signal.make_wave(duration, framerate=framerate)
segment.plot_vlines(label=freq, linewidth=4)
thinkplot.preplot(rows=2)
plot_segment(4500)
thinkplot.config(axis=[-0.00002, 0.0007, -1.05, 1.05])
thinkplot.subplot(2)
plot_segment(5500)
thinkplot.config(axis=[-0.00002, 0.0007, -1.05, 1.05])
thinkplot.save(root='aliasing1',
xlabel='Time (s)',
formats=FORMATS)
def main():
triangle_example(freq=200)
# triangle_example(freq=1100)
square_example(freq=100)
# aliasing_example()
if __name__ == '__main__':
main()

224
test_code/chirp.py Normal file
View File

@ -0,0 +1,224 @@
"""This file contains code used in "Think DSP",
by Allen B. Downey, available from greenteapress.com
Copyright 2015 Allen B. Downey
License: GNU GPLv3 http://www.gnu.org/licenses/gpl.html
"""
from __future__ import print_function, division
import math
import numpy as np
import thinkdsp
import thinkplot
import matplotlib.pyplot as pyplot
import warnings
warnings.filterwarnings('ignore')
PI2 = math.pi * 2
def linear_chirp_evaluate(ts, low=440, high=880, amp=1.0):
"""Computes the waveform of a linear chirp and prints intermediate values.
low: starting frequency
high: ending frequency
amp: amplitude
"""
print('ts', ts)
freqs = np.linspace(low, high, len(ts)-1)
print('freqs', freqs)
dts = np.diff(ts)
print('dts', dts)
dphis = np.insert(PI2 * freqs * dts, 0, 0)
print('dphis', dphis)
phases = np.cumsum(dphis)
print('phases', phases)
ys = amp * np.cos(phases)
print('ys', ys)
return ys
def discontinuity(num_periods=30, hamming=False):
"""Plots the spectrum of a sinusoid with/without windowing.
num_periods: how many periods to compute
hamming: boolean whether to apply Hamming window
"""
signal = thinkdsp.SinSignal(freq=440)
duration = signal.period * num_periods
wave = signal.make_wave(duration)
if hamming:
wave.hamming()
print(len(wave.ys), wave.ys[0], wave.ys[-1])
spectrum = wave.make_spectrum()
spectrum.plot(high=880)
def three_spectrums():
"""Makes a plot showing three spectrums for a sinusoid.
"""
thinkplot.preplot(rows=1, cols=3)
pyplot.subplots_adjust(wspace=0.3, hspace=0.4,
right=0.95, left=0.1,
top=0.95, bottom=0.1)
xticks = range(0, 900, 200)
thinkplot.subplot(1)
thinkplot.config(xticks=xticks)
discontinuity(num_periods=30, hamming=False)
thinkplot.subplot(2)
thinkplot.config(xticks=xticks, xlabel='Frequency (Hz)')
discontinuity(num_periods=30.25, hamming=False)
thinkplot.subplot(3)
thinkplot.config(xticks=xticks)
discontinuity(num_periods=30.25, hamming=True)
# thinkplot.save(root='windowing1')
thinkplot.show()
def window_plot():
"""Makes a plot showing a sinusoid, hamming window, and their product.
"""
signal = thinkdsp.SinSignal(freq=440)
duration = signal.period * 10.25
wave1 = signal.make_wave(duration)
wave2 = signal.make_wave(duration)
ys = np.hamming(len(wave1.ys))
ts = wave1.ts
window = thinkdsp.Wave(ys, ts, wave1.framerate)
wave2.hamming()
thinkplot.preplot(rows=3, cols=1)
pyplot.subplots_adjust(wspace=0.3, hspace=0.3,
right=0.95, left=0.1,
top=0.95, bottom=0.05)
thinkplot.subplot(1)
wave1.plot()
thinkplot.config(axis=[0, duration, -1.07, 1.07])
thinkplot.subplot(2)
window.plot()
thinkplot.config(axis=[0, duration, -1.07, 1.07])
thinkplot.subplot(3)
wave2.plot()
thinkplot.config(axis=[0, duration, -1.07, 1.07],
xlabel='Time (s)')
# thinkplot.save(root='windowing2')
thinkplot.show()
def chirp_spectrum():
"""Plots the spectrum of a one-second one-octave linear chirp.
"""
signal = thinkdsp.Chirp(start=220, end=440)
wave = signal.make_wave(duration=1)
thinkplot.preplot(3, cols=3)
duration = 0.01
wave.segment(0, duration).plot(xfactor=1000)
thinkplot.config(ylim=[-1.05, 1.05])
thinkplot.subplot(2)
wave.segment(0.5, duration).plot(xfactor=1000)
thinkplot.config(yticklabels='invisible',
xlabel='Time (ms)')
thinkplot.subplot(3)
wave.segment(0.9, duration).plot(xfactor=1000)
thinkplot.config(yticklabels='invisible')
# thinkplot.save('chirp3')
thinkplot.show()
spectrum = wave.make_spectrum()
spectrum.plot(high=700)
# thinkplot.save('chirp1',
# xlabel='Frequency (Hz)',
# ylabel='Amplitude')
thinkplot.show()
def chirp_spectrogram():
"""Makes a spectrogram of a one-second one-octave linear chirp.
"""
signal = thinkdsp.Chirp(start=220, end=440)
wave = signal.make_wave(duration=1, framerate=11025)
spectrogram = wave.make_spectrogram(seg_length=512)
print('time res', spectrogram.time_res)
print('freq res', spectrogram.freq_res)
print('product', spectrogram.time_res * spectrogram.freq_res)
spectrogram.plot(high=700)
# thinkplot.save('chirp2',
# xlabel='Time (s)',
# ylabel='Frequency (Hz)')
thinkplot.show()
def overlapping_windows():
"""Makes a figure showing overlapping hamming windows.
"""
n = 256
window = np.hamming(n)
thinkplot.preplot(num=5)
start = 0
for i in range(5):
xs = np.arange(start, start+n)
thinkplot.plot(xs, window)
start += n/2
# thinkplot.save(root='windowing3',
# xlabel='Index',
# axis=[0, 800, 0, 1.05])
thinkplot.show()
def invert_spectrogram():
"""Tests Spectrogram.make_wave.
"""
signal = thinkdsp.Chirp(start=220, end=440)
wave = signal.make_wave(duration=1, framerate=11025)
spectrogram = wave.make_spectrogram(seg_length=512)
wave2 = spectrogram.make_wave()
for i, (y1, y2) in enumerate(zip(wave.ys, wave2.ys)):
if abs(y1 - y2) > 1e-14:
print(i, y1, y2)
def main():
chirp_spectrum()
chirp_spectrogram()
overlapping_windows()
window_plot()
three_spectrums()
if __name__ == '__main__':
main()

154
test_code/noise.py Normal file
View File

@ -0,0 +1,154 @@
"""This file contains code used in "Think DSP",
by Allen B. Downey, available from greenteapress.com
Copyright 2014 Allen B. Downey
License: GNU GPLv3 http://www.gnu.org/licenses/gpl.html
"""
from __future__ import print_function, division
import numpy
import thinkstats2
import thinkdsp
import thinkplot
def process_noise(signal, root='white'):
"""Plots wave and spectrum for noise signals.
signal: Signal
root: string used to generate file names
"""
framerate = 11025
wave = signal.make_wave(duration=0.5, framerate=framerate)
# 0: waveform
segment = wave.segment(duration=0.1)
segment.plot(linewidth=1, alpha=0.5)
# thinkplot.save(root=root+'noise0',
# xlabel='Time (s)',
# ylim=[-1.05, 1.05])
thinkplot.show()
spectrum = wave.make_spectrum()
# 1: spectrum
spectrum.plot_power(linewidth=1, alpha=0.5)
# thinkplot.save(root=root+'noise1',
# xlabel='Frequency (Hz)',
# ylabel='Power',
# xlim=[0, spectrum.fs[-1]])
thinkplot.show()
slope, _, _, _, _ = spectrum.estimate_slope()
print('estimated slope', slope)
# 2: integrated spectrum
integ = spectrum.make_integrated_spectrum()
integ.plot_power()
# thinkplot.save(root=root+'noise2',
# xlabel='Frequency (Hz)',
# ylabel='Cumulative fraction of total power',
# xlim=[0, framerate/2])
thinkplot.show()
# 3: log-log power spectrum
spectrum.hs[0] = 0
thinkplot.preplot(cols=2)
spectrum.plot_power(linewidth=1, alpha=0.5)
thinkplot.config(xlabel='Frequency (Hz)',
ylabel='Power',
xlim=[0, framerate/2])
thinkplot.subplot(2)
spectrum.plot_power(linewidth=1, alpha=0.5)
thinkplot.config(xlabel='Frequency (Hz)',
xscale='log',
yscale='log',
xlim=[0, framerate/2])
# thinkplot.save(root=root+'noise3')
thinkplot.show()
def plot_gaussian_noise():
"""Shows the distribution of the spectrum of Gaussian noise.
"""
thinkdsp.random_seed(18)
signal = thinkdsp.UncorrelatedGaussianNoise()
wave = signal.make_wave(duration=0.5, framerate=11025)
spectrum = wave.make_spectrum()
thinkplot.preplot(2, cols=2)
thinkstats2.NormalProbabilityPlot(spectrum.real, label='real')
thinkplot.config(xlabel='Normal sample',
ylabel='Amplitude',
ylim=[-250, 250],
loc='lower right')
thinkplot.subplot(2)
thinkstats2.NormalProbabilityPlot(spectrum.imag, label='imag')
thinkplot.config(xlabel='Normal sample',
ylim=[-250, 250],
loc='lower right')
# thinkplot.save(root='noise1')
thinkplot.show()
def plot_pink_noise():
"""Makes a plot showing power spectrums for pink noise.
"""
thinkdsp.random_seed(20)
duration = 1.0
framerate = 512
def make_spectrum(signal):
wave = signal.make_wave(duration=duration, framerate=framerate)
spectrum = wave.make_spectrum()
spectrum.hs[0] = 0
return spectrum
signal = thinkdsp.UncorrelatedUniformNoise()
white = make_spectrum(signal)
signal = thinkdsp.PinkNoise()
pink = make_spectrum(signal)
signal = thinkdsp.BrownianNoise()
red = make_spectrum(signal)
linewidth = 2
# colorbrewer2.org 4-class sequential OrRd
white.plot_power(label='white', color='#fdcc8a', linewidth=linewidth)
pink.plot_power(label='pink', color='#fc8d59', linewidth=linewidth)
red.plot_power(label='red', color='#d7301f', linewidth=linewidth)
# thinkplot.save(root='noise-triple',
# xlabel='Frequency (Hz)',
# ylabel='Power',
# xscale='log',
# yscale='log',
# xlim=[1, red.fs[-1]])
thinkplot.show()
def main():
thinkdsp.random_seed(17)
plot_pink_noise()
thinkdsp.random_seed(17)
plot_gaussian_noise()
thinkdsp.random_seed(20)
signal = thinkdsp.UncorrelatedUniformNoise()
process_noise(signal, root='white')
thinkdsp.random_seed(20)
signal = thinkdsp.PinkNoise(beta=1.0)
process_noise(signal, root='pink')
thinkdsp.random_seed(17)
signal = thinkdsp.BrownianNoise()
process_noise(signal, root='red')
if __name__ == '__main__':
main()