| @@ -1,84 +1,84 @@ |
| 1 | 1 | #! /usr/bin/env python |
| 2 | 2 | |
| 3 | | −from numpy import random, sin, arange, ones, zeros |
| 4 | | −from math import pi |
| 5 | | −from aubio import fvec, onset |
| 3 | +import sys |
| 4 | +from aubio import fvec, source, pvoc, specdesc |
| 5 | +from numpy import hstack |
| 6 | 6 | |
| 7 | | −def build_sinusoid(length, freqs, samplerate): |
| 8 | | − return sin( 2. * pi * arange(length) * freqs / samplerate) |
| 7 | +win_s = 512 # fft size |
| 8 | +hop_s = win_s / 4 # hop size |
| 9 | 9 | |
| 10 | | −def run_onset(p, input_vec): |
| 11 | | − f = fvec (p.hop_size) |
| 12 | | − cands = [] |
| 13 | | − count = 0 |
| 14 | | − for vec_slice in input_vec.reshape((-1, p.hop_size)): |
| 15 | | − f[:] = vec_slice |
| 16 | | − cands.append(o(f)) |
| 17 | | − return cands |
| 10 | +if len(sys.argv) < 2: |
| 11 | + print "Usage: %s <filename> [samplerate]" % sys.argv[0] |
| 12 | + sys.exit(1) |
| 18 | 13 | |
| 19 | | −methods = ['default', |
| 20 | | − 'energy', |
| 21 | | − 'complex', |
| 22 | | − 'phase', |
| 23 | | − 'specdiff', |
| 24 | | − 'kl', |
| 25 | | − 'mkl', |
| 26 | | − 'specflux', |
| 27 | | − 'centroid', |
| 28 | | − 'spread', |
| 29 | | − 'skewness', |
| 30 | | − 'kurtosis', |
| 31 | | − 'slope', |
| 32 | | − 'decrease', |
| 33 | | − 'rolloff', |
| 34 | | − ] |
| 14 | +filename = sys.argv[1] |
| 35 | 15 | |
| 36 | | −cands = {} |
| 37 | | −buf_size = 2048 |
| 38 | | −hop_size = 512 |
| 39 | | −samplerate = 44100 |
| 40 | | −sin_length = (samplerate * 10) % 512 * 512 |
| 41 | | −freqs = zeros(sin_length) |
| 16 | +samplerate = 0 |
| 17 | +if len( sys.argv ) > 2: samplerate = int(sys.argv[2]) |
| 42 | 18 | |
| 43 | | −partition = sin_length / 8 |
| 44 | | −pointer = 0 |
| 19 | +s = source(filename, samplerate, hop_s) |
| 20 | +samplerate = s.samplerate |
| 45 | 21 | |
| 46 | | −pointer += partition |
| 47 | | −freqs[pointer: pointer + partition] = 440 |
| 22 | +pv = pvoc(win_s, hop_s) |
| 48 | 23 | |
| 49 | | −pointer += partition |
| 50 | | −pointer += partition |
| 51 | | −freqs[ pointer : pointer + partition ] = 740 |
| 24 | +methods = ['default', 'energy', 'hfc', 'complex', 'phase', 'specdiff', 'kl', 'mkl', |
| 25 | + 'specflux', 'centroid', 'spread', 'skewness', 'kurtosis', 'slope', 'decrease', |
| 26 | + 'rolloff', ] |
| 52 | 27 | |
| 53 | | −pointer += partition |
| 54 | | −freqs[ pointer : pointer + partition ] = 1480 |
| 55 | | − |
| 56 | | −pointer += partition |
| 57 | | −pointer += partition |
| 58 | | −freqs[ pointer : pointer + partition ] = 400 + 5 * random.random(sin_length/8) |
| 59 | | − |
| 60 | | −a = build_sinusoid(sin_length, freqs, samplerate) |
| 28 | +all_descs = {} |
| 29 | +o = {} |
| 61 | 30 | |
| 62 | 31 | for method in methods: |
| 63 | | − o = onset(method, buf_size, hop_size, samplerate) |
| 64 | | − cands[method] = run_onset(o, a) |
| 32 | + cands = [] |
| 33 | + all_descs[method] = fvec(0) |
| 34 | + o[method] = specdesc(method, win_s) |
| 35 | + |
| 36 | +total_frames = 0 |
| 37 | +downsample = 2 |
| 65 | 38 | |
| 66 | | −print "done computing" |
| 39 | +while True: |
| 40 | + samples, read = s() |
| 41 | + fftgrain = pv(samples) |
| 42 | + print "%f" % ( total_frames / float(samplerate) ), |
| 43 | + for method in methods: |
| 44 | + specdesc_val = o[method](fftgrain)[0] |
| 45 | + all_descs[method] = hstack ( [all_descs[method], specdesc_val] ) |
| 46 | + print "%f" % specdesc_val, |
| 47 | + print |
| 48 | + total_frames += read |
| 49 | + if read < hop_s: break |
| 67 | 50 | |
| 68 | 51 | if 1: |
| 69 | | − from pylab import plot, show, xlabel, ylabel, legend, ylim, subplot |
| 70 | | − subplot (211) |
| 71 | | − legend(methods+['ground truth'], 'upper right') |
| 72 | | − xlabel('time (s)') |
| 73 | | − ylabel('amplitude') |
| 74 | | − ramp = arange(0, sin_length).astype('float') / samplerate |
| 75 | | − plot(ramp, a, ':') |
| 76 | | − subplot (212) |
| 77 | | − ramp = arange(0, sin_length / hop_size).astype('float') * hop_size / samplerate |
| 78 | | − for method in methods: |
| 79 | | − plot(ramp, cands[method],'.-') |
| 80 | | − legend(methods, 'upper right') |
| 81 | | − xlabel('time (s)') |
| 82 | | − ylabel('spectral descriptor value') |
| 83 | | − show() |
| 52 | + print "done computing, now plotting" |
| 53 | + import matplotlib.pyplot as plt |
| 54 | + from demo_waveform_plot import get_waveform_plot |
| 55 | + fig = plt.figure() |
| 56 | + plt.rc('lines',linewidth='.8') |
| 57 | + wave = plt.axes([0.1, 0.75, 0.8, 0.19]) |
| 58 | + get_waveform_plot(filename, samplerate, ax = wave ) |
| 59 | + wave.yaxis.set_visible(False) |
| 60 | + wave.xaxis.set_visible(False) |
| 84 | 61 | |
| 62 | + all_desc_times = [ x * hop_s for x in range(len(all_descs["default"])) ] |
| 63 | + n_methods = len(methods) |
| 64 | + for i, method in enumerate(methods): |
| 65 | + #ax = fig.add_subplot (n_methods, 1, i) |
| 66 | + #plt2 = plt.axes([0.1, 0.1, 0.8, 0.65], sharex = plt1) |
| 67 | + ax = plt.axes ( [0.1, 0.75 - ((i+1) * 0.65 / n_methods), 0.8, 0.65 / n_methods], sharex = wave ) |
| 68 | + ax.plot(all_desc_times, all_descs[method], '-', label = method) |
| 69 | + #ax.set_ylabel(method, rotation = 0) |
| 70 | + ax.xaxis.set_visible(False) |
| 71 | + ax.yaxis.set_visible(False) |
| 72 | + ax.axis(xmax = all_desc_times[-1], xmin = all_desc_times[0]) |
| 73 | + ax.annotate(method, xy=(-10, 10), xycoords='axes points', |
| 74 | + horizontalalignment='right', verticalalignment='bottom', |
| 75 | + ) |
| 76 | + if all_desc_times[-1] / float(samplerate) > 60: |
| 77 | + plt.xlabel('time (mm:ss)') |
| 78 | + ax.set_xticklabels([ "%02d:%02d" % (t/float(samplerate)/60, (t/float(samplerate))%60) for t in ax.get_xticks()[:-1]], rotation = 50) |
| 79 | + else: |
| 80 | + plt.xlabel('time (ss.mm)') |
| 81 | + ax.set_xticklabels([ "%02d.%02d" % (t/float(samplerate), 100*((t/float(samplerate))%1) ) for t in ax.get_xticks()[:-1]], rotation = 50) |
| 82 | + #plt.ylabel('spectral descriptor value') |
| 83 | + ax.xaxis.set_visible(True) |
| 84 | + plt.show() |