def plot(input_filename, output_filename, scale=None, dim=0, size=(3.45, 2.0)): """Plots the a spectrogram to an output file """ s = feature_track.FeatureTrack().load(input_filename) if s.data.ndim > 1: d = s.data[:, dim] else: d = s.data min_y = numpy.min(d) max_y = numpy.max(d) min_time = 0 max_time = float(len(d)) / s.metadata.sampling_configuration.ofs ylabel = s.metadata.feature.split()[dim] if scale is not None: ylabel += ' (' ylabel += str(scale) ylabel += ')' x_axis = numpy.array(range(len(d))) / \ float(s.metadata.sampling_configuration.ofs) im = plt.plot(x_axis, d) plt.xlabel('Time (s)') plt.ylabel(ylabel) fig = plt.gcf() width_inches = size[0] #/80.0 height_inches = size[1] #/80.0 fig.set_size_inches((width_inches, height_inches)) plt.savefig(output_filename, bbox_inches='tight')
def run(self, args): a = track.FeatureTrack().load(args.infile) t = 0 if args.filename is True: print "Stored ", len(a.metadata.filename), " files" print a.metadata.filename exit() b = a.data if b.ndim == 1: b.shape = (b.size, 1) if args.norm: b = (b - b.mean(axis=0)) / numpy.maximum(0.00001, b.std(axis=0)) for n in xrange(b.shape[0]): # TODO: update to use metadata if args.time: print t, t += (1.0 / a.metadata.sampling_configuration.ofs) for k in xrange(b.shape[1]): print b[n, k], print "" print b.shape print a.metadata.feature
def calc_track(self, data, frame_length, window_size, rate=44100): t = track.FeatureTrack() t.data = td_feats.zero_crossings(data, frame_length, window_size) t.metadata.sampling_configuration.fs = rate t.metadata.sampling_configuration.ofs = rate / window_size t.metadata.sampling_configuration.window_length = frame_length t.metadata.feature = "TDZeroCrossings" return t
def calc_track_band(self, spectrum, min_freq_bin, max_freq_bin): t = track.FeatureTrack() t.data = feats.centroid(spectrum.data[min_freq_bin:max_freq_bin]) t.metadata.sampling_configuration = spectrum.metadata.sampling_configuration t.metadata.feature = "Centroid_" + str(min_freq_bin) + "_" +\ str(max_freq_bin) t.metadata.filename = spectrum.metadata.input.name t.metadata.input_metadata = copy.deepcopy(spectrum.metadata) return t
def load_feature_files(feature_files): features = [] for i in feature_files: t = track.FeatureTrack() f = open(i, "r") t = t.load(f) features.append(t) f.close() return features
def calc_track(self, spectrum): t = track.FeatureTrack() t.data = spectrum.data.T t.metadata.sampling_configuration = spectrum.metadata.sampling_configuration t.metadata.feature = "" for f in xrange(spectrum.data.shape[0]): t.metadata.feature += "DFT_" + str(spectrum.freq_bin(f)) + "Hz " t.metadata.filename = spectrum.metadata.input.name return t
def run(self, args): s = spectrogram.Spectrogram().load(args.infile) t = track.FeatureTrack() t.data = feats.centroid(s.data) * \ s.metadata.sampling_configuration.ofs t.metadata.sampling_configuration = s.metadata.sampling_configuration t.metadata.feature = "Centroid" t.metadata.filename = s.metadata.input.name t.save(args.outfile)
def run(self, args): print "Joining features" features = [] for a in args.input: t = track.FeatureTrack() t = t.load(a) features.append(t) print a.name, t.metadata.feature, t.data.shape o = self.join(features) o.save(args.output)
def run(self, args): print "Calculating stats..." feature_tracks = [] for a in args.infiles: f = track.FeatureTrack() f = f.load(a) feature_tracks.append(f) p = self.stats(feature_tracks, args.mean, args.variance, args.slope, args.limits, args.csv, args.normalize) p.save(args.outfile)
def calc_track_band(self, spectrum, texture_length, min_freq_bin, max_freq_bin): t = track.FeatureTrack() t.data = feats.low_energy(spectrum.data[min_freq_bin:max_freq_bin], texture_length) t.metadata.sampling_configuration = spectrum.metadata.sampling_configuration t.metadata.feature = "LowEnergy_" + str(min_freq_bin) + "_" +\ str(max_freq_bin) t.metadata.filename = spectrum.metadata.input.name t.metadata.input_metadata = copy.deepcopy(spectrum.metadata) return t
def run(self, args): s = spectrogram.Spectrogram().load(args.infile) t = track.FeatureTrack() H = self.build_filterbank(args.central_frequencies, s) t.data = numpy.dot(H, s.data).T t.metadata.sampling_configuration = s.metadata.sampling_configuration t.metadata.feature = "" for f in args.central_frequencies: t.metadata.feature += "FB_" + str(f) + "Hz " t.metadata.filename = s.metadata.input.name t.save(args.outfile)
def run(self, args): o = track.FeatureTrack() o = o.load(args.infile) p = self_similarity_matrix.SelfSimilarityMatrix() data = o.data if args.normalize: std_p = data.std(axis=0) data = (data - data.mean(axis=0))/\ numpy.maximum(10**(-6), std_p) p.data = self_similarity.self_similarity_euclidean(data) p.metadata.feature = o.metadata.feature p.metadata.sampling_configuration = o.metadata.sampling_configuration p.metadata.filename = o.metadata.filename p.save(args.outfile)
def calc_track(self, t): o = track.FeatureTrack() if t.data.ndim == 1: t.data.shape = (t.data.size, 1) pad = numpy.zeros((1, t.data.shape[1])) o.data = numpy.vstack((pad, numpy.diff(t.data, axis=0))) # Dealing with feature metadata: o.metadata = copy.deepcopy(t.metadata) o.metadata.input_metadata = copy.deepcopy(t.metadata) my_features = t.metadata.feature.split() new_features = "" for feat in my_features: if (len(new_features) > 2) and (new_features[-1] != " "): new_features += " " new_features = new_features + "diff_" + feat o.metadata.feature = new_features return o
def join(self, feature_tracks): data = [] features = [] o = track.FeatureTrack() o.metadata.input_metadata = [] for t in feature_tracks: if t is None: continue if t.data.ndim == 1: t.data.shape = (t.data.size, 1) data.append(t.data) features.append(t.metadata.feature) o.metadata.input_metadata.append(copy.deepcopy(t.metadata)) #print a.name, t.metadata.feature, t.data.shape o.data = numpy.hstack(data) o.metadata.feature = ' '.join(features) o.metadata.filename = t.metadata.filename o.metadata.sampling_configuration = t.metadata.sampling_configuration return o
def run(self, args): t = track.FeatureTrack().load(args.infile) o = self.calc_track(t) o.save(args.outfile)
def to_texture(self, analysis_track, texture_size): window_track = ft.FeatureTrack() window_track.metadata.sampling_configuration = analysis_track.metadata.sampling_configuration feats = analysis_track.metadata.feature.strip().split() window_track.metadata.feature = "" #ta certo manter esse nome? window_track.metadata.filename = analysis_track.metadata.filename w = texture_size N = len(analysis_track.data) begin = 0 begin + w ret = numpy.array(()) ret.shape = (0,0) dT = analysis_track.data.T it = 1 if dT.ndim == 1 else dT.shape[0] #print feats, len(feats) ts = "" ts2 = "" for f in feats: ts += " tx_mean_" + f ts2 += " tx_var_" + f ts = (ts + ts2).strip() #print ts, len(ts.split(" ")) window_track.metadata.feature = ts window_track.metadata.input_metadata =\ copy.deepcopy(analysis_track.metadata) #print feats #print ts #print dT.shape, dT[0], N n = 0 S = numpy.array([0.0] * it) m = numpy.array([0.0] * it) saida = numpy.zeros((analysis_track.data.shape[0], analysis_track.data.shape[1]*2)) #print "shape da saida:", saida.shape #window_track.metadata.feature += " tx_mean_" + feats[i] +\ # " tx_var_" + feats[i] # print "dT[:,:w].shape: ", dT[:,:w].shape # print "dT[:,:w]: ", dT[:,:w] # print dT[:,:w][0] for x in dT[:,:w].T: n = n + 1 n_m = m + (x - m)/n n_s = S + (x - m)*(x - n_m) m = n_m S = n_s #print m.shape, (S/n).shape y = numpy.concatenate((m, S/n), axis=0) saida[n] = y # print n # print "average: ", numpy.average(dT[:,:n], axis=1), m # print "S:", S # print "variance: ", S/n, numpy.var(dT[:,:n], axis=1) # print "boo" for i in range(w, N): m = n_m n_m = m + (dT[:,i]-m)/n - (dT[:,i-w]-m)/n S = S + ( (dT[:,i] - n_m) * (dT[:,i] - m) ) - ( ( dT[:,i-w] - m )*( dT[:,i-w] - n_m ) ) # print i # print "average: ", numpy.average(dT[:,i-w+1:i+1], axis=1), n_m # print "S:", S # print "variance: ", S/(n), numpy.var(dT[:,i-w+1:i+1], axis=1) y = numpy.concatenate((m, S/n), axis=0) saida[i] = y #print saida.shape ret = saida[w:,:] #print saida.shape # def to_texture(self, analysis_track, texture_size): # window_track = ft.FeatureTrack() # window_track.metadata.sampling_configuration = analysis_track.metadata.sampling_configuration # feats = analysis_track.metadata.feature.split(" ") # window_track.metadata.feature = "" # #ta certo manter esse nome? # window_track.metadata.filename = analysis_track.metadata.filename # step = texture_size # total_aw = len(analysis_track.data) # begin = 0 # end = begin + step # ret = numpy.array(()) # ret.shape = (0,0) # dT = analysis_track.data.T # it = 1 if dT.ndim == 1 else dT.shape[0] # for i in range(it): # a = numpy.array(()) # a.shape = (2,0) # begin = 0 # end = begin + step # window_track.metadata.feature += " tx_mean_" + feats[i] +\ # " tx_var_" + feats[i] # while end <= total_aw: # b = numpy.mean(dT[begin:end]) if dT.ndim == 1 else numpy.mean(dT[i,begin:end]) # c = numpy.var(dT[begin:end]) if dT.ndim == 1 else numpy.var(dT[i,begin:end]) # d = numpy.vstack( (b, c) ) # #print d.shape, a.shape # a = numpy.hstack((a, d)) # begin+=1 # end+=1 # #print "Ficou assim:", a.shape # if ret.shape == (0,0): # ret.shape = (a.shape[1], 0) # ret = numpy.hstack((ret, a.T)) # #print "E agora, assim:", ret.shape # for i in range(it): # buff = [] # lastsum = 0 # a = numpy.array(()) # a.shape = (2,0) # window_track.metadata.feature += "tx_mean_" + feats[i] + "tx_var_" + feats[i] # # for cur in range(0, texture_size): # buff.append(dT[cur] if dT.ndim == 1 else dT[i, cur]) # lastsum += dT[cur] if dT.ndim == 1 else dT[i, cur] # # mean = lastsum / texture_size # accum = 0 # for k in range(0, texture_size): # accum += (buff[k] - mean)**2 # var = (accum / texture_size) # temp = numpy.vstack((mean,var)) # a = numpy.hstack((a,temp)) # # for cur in range(texture_size, total_aw): # buff.append(dT[cur] if dT.ndim == 1 else dT[i, cur]) # lastsum += -buff[cur-texture_size] + buff[cur] # mean = lastsum / texture_size # accum = 0 # for k in range(cur - texture_size+1, cur): # accum += (buff[k] - mean)**2 # var = (accum / texture_size) # temp = numpy.vstack((mean,var)) # a = numpy.hstack((a,temp)) # # if ret.shape == (0,0): # ret.shape = (a.shape[1], 0) # ret = numpy.hstack((ret, a.T)) window_track.data = ret return window_track
def run(self, args): analysis_track = ft.FeatureTrack().load(args.infile) texture_size = args.texture_window_size window_track = self.to_texture(analysis_track, texture_size) window_track.save(args.outfile)
def run(self, args): o = track.FeatureTrack() o = o.load(args.trackfile) #print o.metadata #print o.data # Read label file onsets = [] offsets = [] labels = [] with open(args.labelfile) as f: content = f.readlines() for line in content: L = line.split() #print L onsets.append(float(L[0])) offsets.append(float(L[1])) L[2] = L[2].replace('_', '-') L[2] = L[2].replace('-', '+') labels.append(str(L[2].split('+')[0])) #print onsets[-1], offsets[-1], labels[-1] #exit() final_output = None final_filenames = [] final_filenames.append(o.metadata.filename) if o.data.ndim == 1: o.data.shape = (o.data.size, 1) feats = o.metadata.feature.split() a = numpy.array(feats) i = a.argsort() ofs = o.metadata.sampling_configuration.ofs #print offsets[-1], o.data.shape, o.data.shape[0] / float(ofs) #print i my_features = o.metadata.feature.split() my_features.sort() new_features = "" if args.mean is True: for feat in my_features: new_features = new_features + " " + "mean_" + feat if args.variance is True: for feat in my_features: new_features = new_features + " " + "var_" + feat if args.slope is True: for feat in my_features: new_features = new_features + " " + "slope_" + feat if args.limits is True: for feat in my_features: new_features = new_features + " " + "max_" + feat for feat in my_features: new_features = new_features + " " + "argmax_" + feat for feat in my_features: new_features = new_features + " " + "min_" + feat for feat in my_features: new_features = new_features + " " + "argmin_" + feat new_features = new_features.strip() if args.csv is True: sys.stdout.write(new_features.replace(' ', ',')) sys.stdout.write(',LABEL') sys.stdout.write('\n') #exit() for d in xrange(len(onsets)): out = numpy.array([]) i = a.argsort() minN = int(onsets[d] * float(ofs)) maxN = int(offsets[d] * float(ofs)) if maxN <= (minN + 1): maxN = minN + 2 #print minN, maxN, onsets[d], offsets[d], o.data.shape[0], ofs if args.mean is True: out = numpy.hstack((out, o.data[minN:maxN, :].mean(axis=0)[i])) #print out.shape, o.data[minN:maxN,:].mean(axis=0).shape if args.variance is True: out = numpy.hstack((out, o.data[minN:maxN, :].var(axis=0)[i])) if args.slope is True: variance = o.data[minN:maxN, :].var(axis=0)[i] lindata = numpy.zeros(variance.shape) for i in xrange(o.data[minN:maxN, i].shape[1]): lindata[i] = scipy.stats.linregress(o.data[minN:maxN,i],\ range(o.data[minN:maxN,:].shape[0]))[0] out = numpy.hstack((out, lindata)) if args.csv is True: for i in xrange(len(out)): sys.stdout.write(str(out[i])) sys.stdout.write(",") sys.stdout.write(labels[d]) sys.stdout.write('\n') if final_output is None: final_output = out else: final_output = numpy.vstack((final_output, out)) p = feature_matrix.FeatureMatrix() p.data = final_output.copy() if args.normalize: std_p = p.data.std(axis=0) p.data = (p.data - p.data.mean(axis=0))/\ numpy.maximum(10**(-6), std_p) p.metadata.sampling_configuration = o.metadata.sampling_configuration p.metadata.feature = new_features p.metadata.filename = final_filenames p.save(args.outfile)
def calculate_features_per_band(self, frequency_band, also_one_band=False, discard_bin_zero=False): """ :param frequency_band: FrequencyBand :param also_one_band: boolean :param discard_bin_zero: boolean :return: list[FeatureTrack] """ flatness = feat_flat.Flatness() energy = feat_energy.Energy() flux = feat_flux.Flux() centroid = feat_centroid.Centroid() rolloff = feat_rolloff.Rolloff() lowenergy = feat_lowenergy.LowEnergy() bands = [b for b in frequency_band.bands()] if also_one_band: bands.append((int(frequency_band.low), int(frequency_band.high))) for b in bands: lowbin = self.spectrogram.freq_bin(b[0]) if lowbin == 0: if discard_bin_zero: lowbin = 1 highbin = self.spectrogram.freq_bin(b[1]) #print "calculating features for band in bin range: ", lowbin, highbin features = [] flatness_feature = flatness.calc_track_band( self.spectrogram, lowbin, highbin) flatness_feature.metadata.feature += ("_" + str(b[0])) + ( "_" + str(b[1])) features.append(flatness_feature) energy_feature = energy.calc_track_band(self.spectrogram, lowbin, highbin) energy_feature.metadata.feature += ("_" + str(b[0])) + ("_" + str(b[1])) features.append(energy_feature) flux_feature = flux.calc_track_band(self.spectrogram, lowbin, highbin) flux_feature.metadata.feature += ("_" + str(b[0])) + ("_" + str(b[1])) features.append(flux_feature) centroid_feature = centroid.calc_track_band( self.spectrogram, lowbin, highbin) centroid_feature.metadata.feature += ("_" + str(b[0])) + ( "_" + str(b[1])) features.append(centroid_feature) rolloff_feature = rolloff.calc_track_band(self.spectrogram, lowbin, highbin) rolloff_feature.metadata.feature += ("_" + str(b[0])) + ("_" + str(b[1])) features.append(rolloff_feature) lowenergy_feature = lowenergy.calc_track_band( self.spectrogram, 10, lowbin, highbin) lowenergy_feature.metadata.feature += ("_" + str(b[0])) + ( "_" + str(b[1])) features.append(lowenergy_feature) self.features_per_band = len(features) self.band_features = np.hstack((self.band_features, features)) #MFCC hack t = track.FeatureTrack() t.data = mfcc.mfcc(self.spectrogram, 13) t.metadata.sampling_configuration = self.spectrogram.metadata.sampling_configuration feature = "" for i in range(13): feature = feature + "MFCC_" + str(i) + " " t.metadata.feature = feature t.metadata.filename = self.spectrogram.metadata.input.name self.band_features = np.hstack((self.band_features, t)) #Zero crossings t = track.FeatureTrack() t.data = tdomf.zero_crossings(self.audio_data, 1024, 512) t.metadata.sampling_configuration.fs = self.samplingrate t.metadata.sampling_configuration.ofs = self.samplingrate / 1024 t.metadata.sampling_configuration.window_length = 512 t.metadata.feature = "TDZeroCrossings" t.metadata.filename = self.spectrogram.metadata.input.name self.band_features = np.hstack((self.band_features, t))