Python thinkdsp.read_wave函数代码示例

def plot_response():
    thinkplot.preplot(cols=2)

    response = thinkdsp.read_wave("180961__kleeb__gunshots.wav")
    response = response.segment(start=0.26, duration=5.0)
    response.normalize()
    response.plot()
    thinkplot.config(xlabel="time", xlim=[0, 5.0], ylabel="amplitude", ylim=[-1.05, 1.05])

    thinkplot.subplot(2)
    transfer = response.make_spectrum()
    transfer.plot()
    thinkplot.config(xlabel="frequency", xlim=[0, 22500], ylabel="amplitude")

    thinkplot.save(root="systems6")

    wave = thinkdsp.read_wave("92002__jcveliz__violin-origional.wav")
    wave.ys = wave.ys[: len(response)]
    wave.normalize()
    spectrum = wave.make_spectrum()

    output = (spectrum * transfer).make_wave()
    output.normalize()

    wave.plot(color="0.7")
    output.plot(alpha=0.4)
    thinkplot.config(xlabel="time", xlim=[0, 5.0], ylabel="amplitude", ylim=[-1.05, 1.05])
    thinkplot.save(root="systems7")

def plot_bass():
    wave = thinkdsp.read_wave('328878__tzurkan__guitar-phrase-tzu.wav')
    wave.normalize()
    wave.plot()

    wave.make_spectrum(full=True).plot()


    sampled = sample(wave, 4)
    sampled.make_spectrum(full=True).plot()

    spectrum = sampled.make_spectrum(full=True)
    boxcar = make_boxcar(spectrum, 4)
    boxcar.plot()

    filtered = (spectrum * boxcar).make_wave()
    filtered.scale(4)
    filtered.make_spectrum(full=True).plot()

    plot_segments(wave, filtered)


    diff = wave.ys - filtered.ys
    #thinkplot.plot(diff)
    np.mean(abs(diff))

    sinc = boxcar.make_wave()
    ys = np.roll(sinc.ys, 50)
    thinkplot.plot(ys[:100])

def main():
    wave = thinkdsp.read_wave('328878__tzurkan__guitar-phrase-tzu.wav')
    wave.normalize()

    plot_sampling3(wave, 'sampling5')
    plot_sincs(wave)

    plot_beeps()
    plot_am()

    wave = thinkdsp.read_wave('263868__kevcio__amen-break-a-160-bpm.wav')
    wave.normalize()
    plot_impulses(wave)

    plot_sampling(wave, 'sampling3')
    plot_sampling2(wave, 'sampling4')

def plot_convolution():
    response = thinkdsp.read_wave("180961__kleeb__gunshots.wav")
    response = response.segment(start=0.26, duration=5.0)
    response.normalize()

    dt = 1
    shift = dt * response.framerate
    factor = 0.5

    gun2 = response + shifted_scaled(response, shift, factor)
    gun2.plot()
    thinkplot.config(xlabel="time (s)", ylabel="amplitude", ylim=[-1.05, 1.05], legend=False)
    thinkplot.save(root="systems8")

    signal = thinkdsp.SawtoothSignal(freq=410)
    wave = signal.make_wave(duration=0.1, framerate=response.framerate)

    total = 0
    for j, y in enumerate(wave.ys):
        total += shifted_scaled(response, j, y)

    total.normalize()

    wave.make_spectrum().plot(high=500, color="0.7", label="original")
    segment = total.segment(duration=0.2)
    segment.make_spectrum().plot(high=1000, label="convolved")
    thinkplot.config(xlabel="frequency (Hz)", ylabel="amplitude")
    thinkplot.save(root="systems9")

    def __init__(self,filename = "flesh_wound.wav", signal_type = "saw", pitch = 240, num_channel = 1024, num_band = 32):
        
        self.num_bands = num_band
        self.num_channels = num_channel

        if filename == 'record':
            chunk = 1024
            self.framerate = 41000
            self.pya = pyaudio.PyAudio() # initialize pyaudio
            self.stream = self.pya.open(format = pyaudio.paInt16,
               channels = 1,
               rate = self.framerate,
               input = True,
               output = True,
               frames_per_buffer = chunk)
            data = get_samples_from_mic(self.framerate,300,chunk)
            self.voice_wave = thinkdsp.Wave(data,self.framerate)
            self.stream.close()
            self.pya.terminate()
        else:
            self.voice_wave = thinkdsp.read_wave(filename) # read in recording
            self.framerate= self.voice_wave.framerate # determine framerate
            self.duration = self.voice_wave.duration # determine duration
        self.voice_wave.normalize
        self.signal_type = signal_type # list of the type of signals to generate
        self.pitch = pitch # list of fundementals for the generated waves        
        
        seg_voi = self.segmentor(self.voice_wave)        
        
        self.sig_wave = self.Sig_generate()
        seg_sig = self.segmentor(self.sig_wave)
        
        voded_wave = self.vocode(seg_voi,seg_sig)
        
        self.vocoded_wave = voded_wave

def segment_violin(start=1.2, duration=0.6):
    wave = thinkdsp.read_wave('92002__jcveliz__violin-origional.wav')

    # extract a segment
    segment = wave.segment(start, duration)
    segment.normalize()
    segment.apodize()
    segment.write('violin_segment1.wav')

    # plot the spectrum
    spectrum = segment.make_spectrum()
    n = len(spectrum.hs)
    spectrum.plot(high=n/2)
    thinkplot.Save(root='violin2',
                   xlabel='frequency (Hz)',
                   ylabel='amplitude density')

    # print the top 5 peaks
    peaks = spectrum.peaks()
    for amp, freq in peaks[:10]:
        print freq, amp

    # compare the segments to a 440 Hz Triangle wave
    note = thinkdsp.make_note(69, 0.6, 
                              sig_cons=thinkdsp.TriangleSignal, 
                              framerate=segment.framerate)

    wfile = thinkdsp.WavFileWriter('violin_segment2.wav', note.framerate)
    wfile.write(note)
    wfile.write(segment)
    wfile.write(note)
    wfile.close()

def segment_violin(start=1.2, duration=0.6):
    """Load a violin recording and plot its spectrum.

    start: start time of the segment in seconds
    duration: in seconds
    """
    wave = thinkdsp.read_wave('92002__jcveliz__violin-origional.wav')

    # extract a segment
    segment = wave.segment(start, duration)
    segment.normalize()

    # plot the spectrum
    spectrum = segment.make_spectrum()

    thinkplot.preplot(1)
    spectrum.plot(high=10000)
    thinkplot.Save(root='sounds3',
                   xlabel='Frequency (Hz)',
                   ylabel='Amplitude',
                   formats=FORMATS,
                   legend=False)

    # print the top 5 peaks
    peaks = spectrum.peaks()
    for amp, freq in peaks[:10]:
        print(freq, amp)

def segment_spectrum(filename, start, duration=1.0):
    """Plots the spectrum of a segment of a WAV file.

    Output file names are the given filename plus a suffix.

    filename: string
    start: start time in s
    duration: segment length in s
    """
    wave = thinkdsp.read_wave(filename)
    plot_waveform(wave)

    # extract a segment
    segment = wave.segment(start, duration)
    segment.ys = segment.ys[:1024]
    print len(segment.ys)

    segment.normalize()
    segment.apodize()
    spectrum = segment.make_spectrum()

    segment.play()

    # plot the spectrum
    n = len(spectrum.hs)
    spectrum.plot()

    thinkplot.save(root=filename,
                   xlabel='frequency (Hz)',
                   ylabel='amplitude density')

def violin_example(start=1.2, duration=0.6):
    """Demonstrates methods in the thinkdsp module.
    """
    # read the violin recording
    wave = thinkdsp.read_wave('92002__jcveliz__violin-origional.wav')

    # extract a segment
    segment = wave.segment(start, duration)

    # make the spectrum
    spectrum = segment.make_spectrum()

    # apply a filter
    spectrum.low_pass(600)

    # invert the spectrum
    filtered = spectrum.make_wave()

    # prepare the original and filtered segments
    filtered.normalize()
    filtered.apodize()
    segment.apodize()

    # write the original and filtered segments to a file
    filename = 'filtered.wav'
    wfile = thinkdsp.WavFileWriter(filename, segment.framerate)
    wfile.write(segment)
    wfile.write(filtered)
    wfile.close()

    thinkdsp.play_wave(filename)

def main():
    
    # make_figures()

    wave = thinkdsp.read_wave('28042__bcjordan__voicedownbew.wav')
    wave.unbias()
    wave.normalize()
    track_pitch(wave)

    
    return


    thinkplot.preplot(rows=1, cols=2)
    plot_shifted(wave, 0.0003)
    thinkplot.config(xlabel='time (s)',
                     ylabel='amplitude',
                     ylim=[-1, 1])

    thinkplot.subplot(2)
    plot_shifted(wave, 0.00225)
    thinkplot.config(xlabel='time (s)',
                     ylim=[-1, 1])

    thinkplot.save(root='autocorr3')

def plot_amen2():
    wave = thinkdsp.read_wave('263868__kevcio__amen-break-a-160-bpm.wav')
    wave.normalize()

    ax1 = thinkplot.preplot(6, rows=4)
    wave.make_spectrum(full=True).plot(label='spectrum')
    xlim = [-22050-250, 22050]
    thinkplot.config(xlim=xlim, xticklabels='invisible')

    ax2 = thinkplot.subplot(2)
    impulses = make_impulses(wave, 4)
    impulses.make_spectrum(full=True).plot(label='impulses')
    thinkplot.config(xlim=xlim, xticklabels='invisible')

    ax3 = thinkplot.subplot(3)
    sampled = wave * impulses
    spectrum = sampled.make_spectrum(full=True)
    spectrum.plot(label='sampled')
    thinkplot.config(xlim=xlim, xticklabels='invisible')

    ax4 = thinkplot.subplot(4)
    spectrum.low_pass(5512.5)
    spectrum.plot(label='filtered')
    thinkplot.config(xlim=xlim, xlabel='Frequency (Hz)')

    thinkplot.save(root='sampling4',
                   formats=FORMATS)

def plot_beeps():
    wave = thinkdsp.read_wave('253887__themusicalnomad__positive-beeps.wav')
    wave.normalize()

    thinkplot.preplot(3)

    # top left
    ax1 = plt.subplot2grid((4, 2), (0, 0), rowspan=2)
    plt.setp(ax1.get_xticklabels(), visible=False)

    wave.plot()
    thinkplot.config(title='Input waves', legend=False)

    # bottom left
    imp_sig = thinkdsp.Impulses([0.01, 0.4, 0.8, 1.2], 
                                amps=[1, 0.5, 0.25, 0.1])
    impulses = imp_sig.make_wave(start=0, duration=1.3, 
                                 framerate=wave.framerate)

    ax2 = plt.subplot2grid((4, 2), (2, 0), rowspan=2, sharex=ax1)
    impulses.plot()
    thinkplot.config(xlabel='Time (s)')

    # center right
    convolved = wave.convolve(impulses)

    ax3 = plt.subplot2grid((4, 2), (1, 1), rowspan=2)
    plt.title('Convolution')
    convolved.plot()
    thinkplot.config(xlabel='Time (s)')

    thinkplot.save(root='sampling1',
                   formats=FORMATS,
                   legend=False)

def read_response():
    """Reads the impulse response file and removes the initial silence.
    """
    response = thinkdsp.read_wave('180960__kleeb__gunshot.wav')
    start = 0.26
    response = response.segment(start=start)
    response.shift(-start)
    response.normalize()
    return response

def getSpectrum(start=0, duration=1, input_file="raw-epdf.wav", low_pass=22000, high_pass=20):
	# read the recording
	wave = thinkdsp.read_wave(input_file)

	segment = wave.segment(start, duration)
	spectrum = segment.make_spectrum()

	spectrum.low_pass(low_pass)
	spectrum.high_pass(high_pass)

	return spectrum

def violin_spectrogram():
    """Makes a spectrogram of a violin recording.
    """
    wave = thinkdsp.read_wave("92002__jcveliz__violin-origional.wav")

    seg_length = 2048
    spectrogram = wave.make_spectrogram(seg_length)
    spectrogram.plot(high=seg_length / 8)

    # TODO: try imshow?

    thinkplot.save("spectrogram1", xlabel="time (s)", ylabel="frequency (Hz)", formats=["pdf"])