def get_filter_banks(filters_num, NFFT, samplerate, low_freq=0, high_freq=None): ''' Mel Bank filers_num: filter numbers NFFT:points of your FFT samplerate:sample rate low_freq: the lowest frequency that mel frequency include high_freq:the Highest frequency that mel frequency include ''' #turn the hz scale into mel scale low_mel = hz2mel(low_freq) high_mel = hz2mel(high_freq) #in the mel scale, you should put the position of your filter number mel_points = np.linspace(low_mel, high_mel, filters_num + 2) #get back the hzscale of your filter position hz_points = mel2hz(mel_points) #Mel triangle bank design center = np.floor((NFFT + 1) * hz_points / samplerate) fbank = np.zeros([filters_num, int(NFFT / 2 + 1)]) for i in range(0, filters_num): start = int(center[i]) end = int(center[i + 2]) tri_wid = end - start tri_fil = sg.bartlett(tri_wid, sym=False) fbank[i][start:end] = tri_fil return fbank
def Bartlett (N,x): ventana = sig.bartlett(N) salida = np.multiply(x,ventana) return salida
def __window_data(data): # Apply window function to the decoded data & store as new key:value pair in dictionary # Parameters: data: [{'frame_data': string, # 'frame_count': int, # 'frame_time': float, # 'frame_position': int, # 'frame_decoded': numpy.ndarray}, ...] # cache window function if 'hann' == config_analysis.frame_window: window = signal.hann(config_audio.frames_per_buffer) elif 'hamming' == config_analysis.frame_window: window = signal.hamming(config_audio.frames_per_buffer) elif 'blackman' == config_analysis.frame_window: window = signal.blackman(config_audio.frames_per_buffer) elif 'bartlett' == config_analysis.frame_window: window = signal.bartlett(config_audio.frames_per_buffer) elif 'barthann' == config_analysis.frame_window: window = signal.barthann(config_audio.frames_per_buffer) else: # window function unavailable return # apply specified window function in config for i in range(len(data)): data[i]['frame_windowed'] = data[i]['frame_decoded'][:] * window
def plot_specgram(ax, data, fs, nfft=256, noverlap=128, window='hann', cmap='jet', interpolation='bilinear', rasterized=True): if window not in SPECGRAM_WINDOWS: raise ValueError("Window not supported") elif window == "boxcar": mwindow = signal.boxcar(nfft) elif window == "hamming": mwindow = signal.hamming(nfft) elif window == "hann": mwindow = signal.hann(nfft) elif window == "bartlett": mwindow = signal.bartlett(nfft) elif window == "blackman": mwindow = signal.blackman(nfft) elif window == "blackmanharris": mwindow = signal.blackmanharris(nfft) specgram, freqs, time = mlab.specgram(data, NFFT=nfft, Fs=fs, window=mwindow, noverlap=noverlap) specgram = 10 * np.log10(specgram[1:, :]) specgram = np.flipud(specgram) freqs = freqs[1:] halfbin_time = (time[1] - time[0]) / 2.0 halfbin_freq = (freqs[1] - freqs[0]) / 2.0 extent = (time[0] - halfbin_time, time[-1] + halfbin_time, freqs[0] - halfbin_freq, freqs[-1] + halfbin_freq) ax.imshow(specgram, cmap=cmap, interpolation=interpolation, extent=extent, rasterized=rasterized) ax.axis('tight')
def win_sel(win_str, win_size): """ Function returns a window vector based on window name. Note class can only use windows found in scipy.signal library. """ overlap = 0 if (win_str == 'blackmanharris'): win = sig.blackmanharris(win_size) overlap = .75 elif (win_str == 'blackman'): win = sig.blackman(win_size) elif (win_str == 'bartlett'): win = sig.bartlett(win_size) elif (win_str == 'hamming'): win = sig.hamming(win_size) elif (win_str == 'hanning'): win = sig.hanning(win_size) elif (win_str == 'hann'): win = sig.hann(win_size) elif (win_str == 'barthann'): win = sig.barthann(win_size) elif (win_str == 'triang'): win = sig.triang(win_size) elif (win_str == 'rect' or win_str == None): win = np.ones(win_size) else: print('Invalid Window Defined') return -1 return win, overlap
def td_dft(dat, winlen=4096, winoverlap=2048, dftsize=4096, winty='blackman'): # calculate the views views = view_as_windows(dat,winlen,winlen-winoverlap) # generate desired window if winty == 'rect': win = np.ones(winlen) elif winty == 'bartlett': win = bartlett(winlen) elif winty == 'hann': win = hanning(winlen) elif winty == 'hamming': win = hamming(winlen) elif winty == 'blackman': win = blackman(winlen) else: assert False # invalid winty # apply window sequence to views views = [ v*win for v in views ] # computes time aliasing to input sequences if needed if winlen > dftsize: views = [ time_alias(v,dftsize) for v in views ] # apply fft and fftshift to all views dfts = [ fftshift(fft(v,dftsize)) for v in views ] return np.array(dfts)
def spectrum_wwind(array, time, window='hanning'): # time should be in seconds # Size of array Nw = array.shape[0] # Calculate time step (assumed to be in seconds) dt = time[1] - time[0] # prefactor # print 'dt = ',dt prefactor = dt # Calculate array of frequencies, shift w = np.fft.fftfreq(Nw, dt) w0 = np.fft.fftshift(w) # make window # blackman window if window == 'blackman': bwin = blackman(Nw) # pretty good if window == 'hanning': bwin = hanning(Nw) # pretty good if window == 'hamming': bwin = hamming(Nw) # not as good if window == 'bartlett': bwin = bartlett(Nw) # pretty good if window == 'kaiser': bwin = kaiser(Nw, 6) if window == 'None': bwin = 1.0 # Calculate FFT aw = prefactor * np.fft.fft(array * bwin) aw0 = np.fft.fftshift(aw) # Calcuate Phase phase = np.angle(aw) phase0 = np.fft.fftshift(phase) # Adjust arrays if not div by 2 if not np.mod(Nw, 2): w0 = np.append(w0, -w0[0]) aw0 = np.append(aw0, -aw0[0]) phase0 = np.append(phase0, -phase0[0]) # Cut FFTs in half Nwi = Nw // 2 w2 = w0[Nwi:] aw2 = aw0[Nwi:] phase2 = phase0[Nwi:] comp = aw pwr = (np.abs(aw2))**2 pwr2 = (np.abs(aw))**2 mag = np.sqrt(pwr) cos_phase = np.cos(phase2) freq = w2 freq2 = w return freq, freq2, comp, pwr, mag, phase2, cos_phase, dt
def filtering_bartlett(sig, win_size): win = signal.bartlett(win_size) win = map(lambda x: float(x), win) sig = map(lambda x: float(x), sig) win = list(win) sig = list(sig) filtered = signal.convolve(sig, win, mode='same') / sum(win) return filtered
def recompute_window(self): zoom = int(self.width * (self.get_eff_sample_rate()) / self.zoom_fac) if self.filter == 'kaiser': self.window = signal.kaiser( freqshow.SDR_SAMPLE_SIZE, self.kaiser_beta, False, )[0:zoom + 2] # for every bin there is a window the same exact size as the read samples. elif self.filter == 'boxcar': self.window = signal.boxcar( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'hann': self.window = signal.hann( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'hamming': self.window = signal.hamming( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'blackman': self.window = signal.blackman( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'blackmanharris': self.window = signal.blackmanharris( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'bartlett': self.window = signal.bartlett( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'barthann': self.window = signal.barthann( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'nuttall': self.window = signal.nuttall( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] else: self.window = 1
def mkWindow(com,N): if com == "hm": win = sg.hamming(N) elif com == "hn": win = sg.hann(N) elif com == "bk": win = sg.blackman(N) elif com == "ga": win = sg.gaussian(N,N/16) elif com == "bar": win = sg.bartlett(N) elif com == "rect": win = np.ones(N) else : usage() return win
# plt.plot(T,Lt+Zt,color=crta[j],alpha = 0.95,label=r'skupaj $\Delta t=$'+str(dt))#+'{:.{}f}'.format(SHfi, 3 )) # plt.xscale('log') plt.yscale('log') plt.ylabel('PSD($\omega$)', fontsize=16) plt.xlabel(r'$\omega$', fontsize=16) plt.xlim([0, len(SIG) / 2]) # plt.ylim([0,250]) # plt.title('Umiranje populacije za različne korake in razlicno velika vzorca')#+'(N='+str(N)+',M='+str(M)+')') plt.legend(loc=0) ############################################################################### ################ okenske funkcije in odzivi ################################# ############################################################################### windowGauss = signal.gaussian(51, std=6) windowBartt = signal.bartlett(51) windowHann = signal.hann(51) windowCH = signal.chebwin(51, at=100) windowTuR = signal.tukey(51) AGauss = np.fft.fft(windowGauss, 2048) / (len(windowGauss) / 2.0) ABartt = np.fft.fft(windowBartt, 2048) / (len(windowBartt) / 2.0) AHann = np.fft.fft(windowHann, 2048) / (len(windowHann) / 2.0) ACH = np.fft.fft(windowCH, 2048) / (len(windowCH) / 2.0) ATuR = np.fft.fft(windowTuR, 2048) / (len(windowTuR) / 2.0) freqGauss = np.linspace(-0.5, 0.5, len(AGauss)) freqBartt = np.linspace(-0.5, 0.5, len(ABartt)) freqHann = np.linspace(-0.5, 0.5, len(AHann)) freqCH = np.linspace(-0.5, 0.5, len(ACH)) freqTuR = np.linspace(-0.5, 0.5, len(ATuR))
example demonstrates the spectral leakage for several different windows (including the boxcar): """ fig02 = plt.figure() # Boxcar with zeroed out fraction b = sig.boxcar(npts) zfrac = 0.15 zi = int(npts * zfrac) b[:zi] = b[-zi:] = 0 name = "Boxcar - zero fraction=%.2f" % zfrac winspect(b, fig02, name) winspect(sig.hanning(npts), fig02, "Hanning") winspect(sig.bartlett(npts), fig02, "Bartlett") winspect(sig.barthann(npts), fig02, "Modified Bartlett-Hann") """ .. image:: fig/multi_taper_spectral_estimation_02.png As before, the left figure displays the windowing function in the temporal domain and the figure on the left displays the attentuation of spectral leakage in the other frequency bands in the spectrum. Notice that though different windowing functions have different spectral attenuation profiles, trading off attenuation of leakage from frequency bands near the frequency of interest (narrow-band leakage) with leakage from faraway frequency bands (broad-band leakage) they are all superior in both of these respects to the boxcar window used in the naive periodogram.
# Plot the window and its frequency response: from scipy import signal from scipy.fftpack import fft, fftshift import matplotlib.pyplot as plt window = signal.bartlett(51) plt.plot(window) plt.title("Bartlett window") plt.ylabel("Amplitude") plt.xlabel("Sample") plt.figure() A = fft(window, 2048) / (len(window)/2.0) freq = np.linspace(-0.5, 0.5, len(A)) response = 20 * np.log10(np.abs(fftshift(A / abs(A).max()))) plt.plot(freq, response) plt.axis([-0.5, 0.5, -120, 0]) plt.title("Frequency response of the Bartlett window") plt.ylabel("Normalized magnitude [dB]") plt.xlabel("Normalized frequency [cycles per sample]")
def test_basic(self): assert_allclose(signal.bartlett(6), [0, 0.4, 0.8, 0.8, 0.4, 0]) assert_allclose(signal.bartlett(7), [0, 1/3, 2/3, 1.0, 2/3, 1/3, 0]) assert_allclose(signal.bartlett(6, False), [0, 1/3, 2/3, 1.0, 2/3, 1/3])
from scipy import signal from matplotlib import pyplot as plt from matplotlib import style import mysignals as sigs import numpy as np from scipy.fftpack import fft, fftshift window = signal.bartlett(51) plt.plot(window) plt.title("Bartlett Window") plt.ylabel("Amplitude") plt.xlabel("Sample") plt.show() #frequency response plt.figure() A = fft(window, 2048) / (len(window) / 2.0) freq = np.linspace(-0.5, 0.5, len(A)) response = 20 * np.log10(np.abs(fftshift(A / abs(A).max()))) plt.plot(freq, response) plt.axis([-0.5, 0.5, -120, 0]) plt.title("Frequency Response of Bartlett Window") plt.ylabel("Normalized Magnitude(dB)") plt.xlabel("Normalized Frequency in cycles/sample") plt.show()
(including the boxcar): """ fig02 = plt.figure() # Boxcar with zeroed out fraction b = sig.boxcar(npts) zfrac = 0.15 zi = int(npts * zfrac) b[:zi] = b[-zi:] = 0 name = 'Boxcar - zero fraction=%.2f' % zfrac winspect(b, fig02, name) winspect(sig.hanning(npts), fig02, 'Hanning') winspect(sig.bartlett(npts), fig02, 'Bartlett') winspect(sig.barthann(npts), fig02, 'Modified Bartlett-Hann') """ .. image:: fig/multi_taper_spectral_estimation_02.png As before, the left figure displays the windowing function in the temporal domain and the figure on the left displays the attentuation of spectral leakage in the other frequency bands in the spectrum. Notice that though different windowing functions have different spectral attenuation profiles, trading off attenuation of leakage from frequency bands near the frequency of interest (narrow-band leakage) with leakage from faraway frequency bands (broad-band leakage) they are all superior in both of these respects to the boxcar window used in the naive periodogram. Another approach which deals with both the inefficiency problem and with the
f0 = fs / 4 p0 = 0 # radianes a0 = 2 # Volts df = np.random.uniform(-2, 2, k) fn = f0 + df * fs / N Ts = 1 / fs tt = np.linspace(0, (N - 1) * Ts, N) x = np.transpose(np.vstack([a0 * np.sin(2 * np.pi * ff * tt) for ff in fn])) ventana = [ sig.boxcar(N), sig.bartlett(N), sig.hann(N), sig.blackman(N), sig.flattop(N) ] V = len(ventana) sesgo = np.zeros(V) var = np.zeros(V) prom = np.zeros(V) dist = np.zeros((k, V)) for (vv, this_win) in zip(range(V), ventana): X = np.transpose(np.vstack([x[:, kk] * this_win for kk in range(0, k)])) X = fft(X, axis=0)
barva = ['r', 'b', 'g', 'k', 'm', 'y', 'c'] DIR = '/home/jernej/Desktop/ModelskaAn/MOJEDELLO/dvanajsta/' val = ["val2", "val3"] V = 1 SIG = loadtxt(DIR + val[V] + ".dat") # branje LS = len(SIG) # dolžina signala SIG_256 = SIG[0:LS // 2] SIG_128 = SIG[0:LS // 4] SIG_64 = SIG[0:LS // 8] STD = 7 windowGauss = signal.gaussian(LS, std=STD) windowBartt = signal.bartlett(LS) windowHann = signal.hann(LS) windowCH = signal.chebwin(LS, at=100) windowTuR = signal.tukey(LS) FTSIG = 2 * abs(np.fft.fft(SIG))**2 FTfreq = np.fft.fftfreq(LS, 1 / len(SIG)) FTSIG_G = 2 * abs(np.fft.fft(SIG * signal.gaussian(LS, std=STD)))**2 FTSIG_B = 2 * abs(np.fft.fft(SIG * signal.bartlett(LS)))**2 FTSIG_H = 2 * abs(np.fft.fft(SIG * signal.hann(LS)))**2 FTSIG_CH = 2 * abs(np.fft.fft(SIG * signal.chebwin(LS, at=100)))**2 FTSIG_T = 2 * abs(np.fft.fft(SIG * signal.tukey(LS)))**2 FTSIG_HCH = 2 * abs(np.fft.fft(SIG * signal.tukey(LS) * signal.hann(LS)))**2 FTSIG_256 = 2 * abs(np.fft.fft(SIG_256))**2 FTfreq_256 = np.fft.fftfreq(LS // 2, 1 / len(SIG_256))
def remix_solo(x): """ The core method to analyse, separate, estimate, remix and reconstruct audio mixtures and sources. Args: x : (2D ndarray) The two-channel mixture time domain waveform Returns: x : (2D ndarray) The two-channel mixture time domain waveform yhat : (array) Single channel solo instrument time domain waveform yhatb : (2D ndarray) The two-channel accompanying instruments time domain waveform ymix : (2D ndarray) The two-channel remixed time domain waveform """ # Load models using pickle print('Loading models') # Check for os, to avoid some windows crushes plat = sys.platform if plat == 'linux' or plat == 'linux2' or plat == 'darwin': ww = pickle.load(open('solo_suppression_mag.p', 'rb'), encoding='latin1') # ww = pickle.load(open('solo_suppression_mag.p', 'rb')) wwpan = pickle.load(open('pannet_mag.p', 'rb'), encoding='latin1') # wwpan = pickle.load(open('pannet_mag.p', 'rb')) else: fileA = open('solo_suppression_mag.p', 'rb') ww = pickle.load(fileA, encoding='latin1') fileB = open('pannet_mag.p', 'rb') wwpan = pickle.load(fileB, encoding='latin1') del fileA, fileB hop = 512 N = 4096 wsz = 2049 # Left/Right/Mid Analysis xL = x[:, 0] xR = x[:, 1] MmX, MpX = TF.STFT((xL + xR) * 0.5, sig.bartlett(wsz, True), N, hop) LmX, LpX = TF.STFT(xL, sig.bartlett(wsz, True), N, hop) RmX, RpX = TF.STFT(xR, sig.bartlett(wsz, True), N, hop) print('Extracting Solo Information') ### Hidden Layer Representation 1 Trs = sigmoid(np.dot(MmX, ww[2]) + ww[3]) act = relu(np.dot(MmX, ww[0]) + ww[1]) act *= Trs hl = act + (1. - Trs) * MmX ### Hidden Layer Representation 2 Trs = sigmoid(np.dot(hl, ww[6]) + ww[7]) act = relu(np.dot(hl, ww[4]) + ww[5]) act *= Trs hl = act + (1. - Trs) * hl ### Hidden Layer Representation 3 Trs = sigmoid(np.dot(hl, ww[10]) + ww[11]) act = relu(np.dot(hl, ww[8]) + ww[9]) act *= Trs hl = act + (1. - Trs) * hl ### Hidden Layer Representation 4 Trs = sigmoid(np.dot(hl, ww[14]) + ww[15]) act = relu(np.dot(hl, ww[12]) + ww[13]) act *= Trs hl = act + (1. - Trs) * hl ### Output Layer Trs = sigmoid(np.dot(hl, ww[18]) + ww[19]) act = relu(np.dot(hl, ww[16]) + ww[17]) act *= Trs hl = ((act + (1. - Trs) * hl) + eps) # Monophonic Solo yhat = TF.iSTFT(hl, MpX, wsz, hop) # Stereo instrumentation print('Estimating accompaniment instrumentation') mask = fm(LmX, hl, [(LmX - hl).clip(0.)], [], [], alpha=1.3, method='alphaWiener') mshatL = mask(reverse=True) mask = fm(RmX, hl, [(RmX - hl).clip(0.)], [], [], alpha=1.3, method='alphaWiener') mshatR = mask(reverse=True) # Time-domain reconstruction yhatbL = TF.iSTFT(mshatL, LpX, wsz, hop) yhatbR = TF.iSTFT(mshatR, RpX, wsz, hop) yhatb = np.vstack((yhatbL, yhatbR)).T # Mixing coefficients Estimation print('Estimating Mixing Coefficients') ### Hidden Layer Representation 1 Trs = sigmoid(np.dot(hl, wwpan[2]) + wwpan[3]) act = relu(np.dot(hl, wwpan[0]) + wwpan[1]) act *= Trs hl = act + (1. - Trs) * hl ### Hidden Layer Representation 2 Trs = sigmoid(np.dot(hl, wwpan[6]) + wwpan[7]) act = relu(np.dot(hl, wwpan[4]) + wwpan[5]) act *= Trs hl = act + (1. - Trs) * hl mix_vec = softmax(np.dot(hl, wwpan[8]) + wwpan[9]) mix_vec = np.sum(mix_vec, axis=0) # Acquiring locations degloc = np.argmax(mix_vec[19:]) gloc = np.argmax(mix_vec[:19]) mix_vec = np.zeros((40, 1), dtype=np.float32) mix_vec[degloc + 19] = 1. mix_vec[gloc] = 1. print('Performing Mixing') degrees, gain = vec2val(mix_vec) LGenv, RGenv = pan_gain_env(yhat, degrees, gain) ymix = np.vstack((yhat * LGenv, yhat * RGenv)).T + yhatb return x, yhat[:x.shape[0]], yhatb[:x.shape[0], :], ymix[:x.shape[0], :]
# -*- coding: utf-8 -*- """ Created on Tue Oct 22 00:54:03 2019 @author: fede """ import matplotlib as mpl import matplotlib.pyplot as plt import numpy as np from numpy.fft import fft, fftshift import scipy.signal as sig N = 60 # muestras fftSize = 2048 ventanas = [sig.boxcar(N), sig.bartlett(N), sig.hann(N), sig.blackman(N), sig.flattop(N)] ventanas_names = ["rectangular", "bartlett", "hanning", "blackman", "flattop"] V = len(ventanas_names) plt.figure("Ventanas", figsize = (10,10)) for (vv, this_win) in zip(ventanas_names, ventanas): plt.plot(this_win, label=vv) plt.legend() plt.grid() plt.xlabel("Numero de muestra") plt.ylabel("Amplitud de la ventana") plt.title("Forma de ventanas") complexMat = np.transpose(np.vstack([fft(thisWin,fftSize, axis=0) for thisWin in ventanas])) #fft(signal, size) Si size > len(signal) la FFT le hace zero padding automaticamente :)
def bartlett(self, delta_w): m = int(np.ceil((8 * np.pi) / (2 * delta_w))) + 1 if m % 2 == 0: m = m + 1 w = signal.bartlett(m) return w
center = int(np.floor(N / 2)) modX = modX[center:N] modX = 20 * np.log10(modX) freq = np.linspace(0, 0.5, len(modX)) plt.plot(freq, modX) plt.title("Rectangular", fontsize=20) plt.xlim(0.2, 0.3) plt.xlabel("Frecuencia normalizada", fontsize=20) plt.ylabel("Amplitud en dB", fontsize=20) plt.grid() ######################### ###ventana bartlett### ######################### plt.figure("Bartlett") rectWindow = sig.bartlett(N) a2dB = -40 a2 = 10**(a2dB / 20) x1 = np.sin(2 * np.pi * f1 * tt) x2 = a2 * np.sin(2 * np.pi * f2 * tt) x = x1 + x2 x = x * rectWindow X = fft(x) modX = np.abs(fftshift(X)) * 2 / N center = int(np.floor(N / 2)) modX = modX[center:N] modX = 20 * np.log10(modX) freq = np.linspace(0, 0.5, len(modX)) plt.plot(freq, modX) plt.title("Bartlett", fontsize=20)
def get_data(self): """Get spectrogram data from the tuner. Will return width number of values which are the intensities of each frequency bucket (i.e. FFT of radio samples). """ # Get width number of raw samples so the number of frequency bins is # the same as the display width. Add two because there will be mean/DC # values in the results which are ignored. Increase by 1/self.zoom_fac if needed if self.zoom_fac < (self.sdr.sample_rate / 1000000): zoom = int(self.width * ((self.sdr.sample_rate / 1000000) / self.zoom_fac)) else: zoom = self.width self.zoom_fac = self.get_sample_rate() if zoom < freqshow.SDR_SAMPLE_SIZE: freqbins = self.sdr.read_samples(freqshow.SDR_SAMPLE_SIZE)[0:zoom + 2] else: zoom = self.width self.zoom_fac = self.get_sample_rate() freqbins = self.sdr.read_samples(freqshow.SDR_SAMPLE_SIZE)[0:zoom + 2] # Apply a window function to the sample to remove power in sample sidebands before the fft. if self.filter == 'kaiser': window = signal.kaiser( freqshow.SDR_SAMPLE_SIZE, self.kaiser_beta, False, )[0:zoom + 2] # for every bin there is a window the same exact size as the read samples. elif self.filter == 'boxcar': window = signal.boxcar( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'hann': window = signal.hann( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'hamming': window = signal.hamming( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'blackman': window = signal.blackman( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'blackmanharris': window = signal.blackmanharris( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'bartlett': window = signal.bartlett( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'barthann': window = signal.barthann( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] elif self.filter == 'nuttall': window = signal.nuttall( freqshow.SDR_SAMPLE_SIZE, False, )[0:zoom + 2] else: window = 1 samples = freqbins * window # Run an FFT and take the absolute value to get frequency magnitudes. freqs = np.absolute(fft(samples)) # Ignore the mean/DC values at the ends. freqs = freqs[1:-1] # Reverse the order of the freqs array if swaping I and Q if self.swap_iq == True: freqs = freqs[::-1] # Shift FFT result positions to put center frequency in center. freqs = np.fft.fftshift(freqs) # Truncate the freqs array to the width of the screen if neccesary. if freqs.size > self.width: freq_step = self.get_freq_step( ) # Get the frequency step in Hz between pixels. shiftsweep = int(self.get_lo_offset() * 1000000 / freq_step) # LO offset in pixels. extra_samples = int( (freqs.size - self.width) / 2 ) # The excess samples either side of the display width in pixels. if extra_samples > abs( shiftsweep ): # check if there is room to shift the array by the LO offset. if self.get_swap_iq() == True: lextra = extra_samples + shiftsweep elif self.get_swap_iq() == False: lextra = extra_samples - shiftsweep else: lextra = extra_samples rextra = freqs.size - (lextra + self.width) freqs = freqs[lextra:-rextra] # Convert to decibels. freqs = 20.0 * np.log10(freqs) # Get signal strength of the center frequency. # for i in range ( 1, 11): # self.sig_strength = (self.get_sig_strength() + freqs[((zoom+2)/2)+i-5]) # self.sig_strength = self.get_sig_strength()/10 # Update model's min and max intensities when auto scaling each value. if self.min_auto_scale: min_intensity = np.min(freqs) self.min_intensity = min_intensity if self.min_intensity is None \ else min(min_intensity, self.min_intensity) if self.max_auto_scale: max_intensity = np.max(freqs) self.max_intensity = max_intensity if self.max_intensity is None \ else max(max_intensity, self.max_intensity) # Update intensity range (length between min and max intensity). self.range = self.max_intensity - self.min_intensity # Return frequency intensities. return freqs
def remix_solo(x): """ The core method to analyse, separate, estimate, remix and reconstruct audio mixtures and sources. Args: x : (2D ndarray) The two-channel mixture time domain waveform Returns: x : (2D ndarray) The two-channel mixture time domain waveform yhat : (array) Single channel solo instrument time domain waveform yhatb : (2D ndarray) The two-channel accompanying instruments time domain waveform ymix : (2D ndarray) The two-channel remixed time domain waveform """ # Load models using pickle print('Loading models') # Check for os, to avoid some windows crushes plat = sys.platform if plat == 'linux' or plat == 'linux2' or plat == 'darwin' : ww = pickle.load(open('solo_suppression_mag.p', 'rb')) wwpan = pickle.load(open('pannet_mag.p', 'rb')) else : fileA = open('solo_suppression_mag.p', 'rb') ww = pickle.load(fileA,encoding='latin1') fileB = open('pannet_mag.p', 'rb') wwpan = pickle.load(fileB,encoding='latin1') del fileA, fileB hop = 512 N = 4096 wsz = 2049 # Left/Right/Mid Analysis xL = x[:, 0] xR = x[:, 1] MmX, MpX = TF.STFT((xL+xR) * 0.5, sig.bartlett(wsz, True), N, hop) LmX, LpX = TF.STFT(xL, sig.bartlett(wsz, True), N, hop) RmX, RpX = TF.STFT(xR, sig.bartlett(wsz, True), N, hop) print('Extracting Solo Information') ### Hidden Layer Representation 1 Trs = sigmoid(np.dot(MmX, ww[2]) + ww[3]) act = relu(np.dot(MmX, ww[0]) + ww[1]) act *= Trs hl = act + (1. - Trs) * MmX ### Hidden Layer Representation 2 Trs = sigmoid(np.dot(hl, ww[6]) + ww[7]) act = relu(np.dot(hl, ww[4]) + ww[5]) act *= Trs hl = act + (1. - Trs) * hl ### Hidden Layer Representation 3 Trs = sigmoid(np.dot(hl, ww[10]) + ww[11]) act = relu(np.dot(hl, ww[8]) + ww[9]) act *= Trs hl = act + (1. - Trs) * hl ### Hidden Layer Representation 4 Trs = sigmoid(np.dot(hl, ww[14]) + ww[15]) act = relu(np.dot(hl, ww[12]) + ww[13]) act *= Trs hl = act + (1. - Trs) * hl ### Output Layer Trs = sigmoid(np.dot(hl, ww[18]) + ww[19]) act = relu(np.dot(hl, ww[16]) + ww[17]) act *= Trs hl = ((act + (1. - Trs) * hl) + eps) # Monophonic Solo yhat = TF.iSTFT(hl, MpX, wsz, hop) # Stereo instrumentation print('Estimating accompaniment instrumentation') mask = fm(LmX, hl, [(LmX-hl).clip(0.)], [], [], alpha = 1.3, method = 'alphaWiener') mshatL = mask(reverse = True) mask = fm(RmX, hl, [(RmX-hl).clip(0.)], [], [], alpha = 1.3, method = 'alphaWiener') mshatR = mask(reverse = True) # Time-domain reconstruction yhatbL = TF.iSTFT(mshatL, LpX, wsz, hop) yhatbR = TF.iSTFT(mshatR, RpX, wsz, hop) yhatb = np.vstack((yhatbL, yhatbR)).T # Mixing coefficients Estimation print('Estimating Mixing Coefficients') ### Hidden Layer Representation 1 Trs = sigmoid(np.dot(hl, wwpan[2]) + wwpan[3]) act = relu(np.dot(hl, wwpan[0]) + wwpan[1]) act *= Trs hl = act + (1. - Trs) * hl ### Hidden Layer Representation 2 Trs = sigmoid(np.dot(hl, wwpan[6]) + wwpan[7]) act = relu(np.dot(hl, wwpan[4]) + wwpan[5]) act *= Trs hl = act + (1. - Trs) * hl mix_vec = softmax(np.dot(hl, wwpan[8]) + wwpan[9]) mix_vec = np.sum(mix_vec, axis=0) # Acquiring locations degloc = np.argmax(mix_vec[19:]) gloc = np.argmax(mix_vec[:19]) mix_vec = np.zeros((40,1), dtype = np.float32) mix_vec[degloc + 19] = 1. mix_vec[gloc] = 1. print('Performing Mixing') degrees, gain = vec2val(mix_vec) LGenv, RGenv = pan_gain_env(yhat, degrees, gain) ymix = np.vstack((yhat * LGenv, yhat * RGenv)).T + yhatb return x, yhat[:x.shape[0]], yhatb[:x.shape[0], :], ymix[:x.shape[0], :]
example demonstrates the spectral leakage for several different windows (including the boxcar): """ fig02 = plt.figure() # Boxcar with zeroed out fraction b = sig.boxcar(npts) zfrac = 0.15 zi = int(npts*zfrac) b[:zi] = b[-zi:] = 0 name = 'Boxcar - zero fraction=%.2f' % zfrac winspect(b, fig02, name) winspect(sig.hanning(npts), fig02, 'Hanning') winspect(sig.bartlett(npts), fig02, 'Bartlett') winspect(sig.barthann(npts), fig02, 'Modified Bartlett-Hann') """ .. image:: fig/multi_taper_spectral_estimation_02.png As before, the left figure displays the windowing function in the temporal domain and the figure on the left displays the attentuation of spectral leakage in the other frequency bands in the spectrum. Notice that though different windowing functions have different spectral attenuation profiles, trading off attenuation of leakage from frequency bands near the frequency of interest (narrow-band leakage) with leakage from faraway frequency bands (broad-band leakage) they are all superior in both of these respects to the boxcar window used in the naive periodogram.
""" import matplotlib.pyplot as plt import numpy as np import scipy.signal as sig from scipy.fftpack import fft, fftshift N = 1000 fs = 1000 Ts = 1 / fs tt = np.linspace(0, (N - 1) * Ts, N) ventanas = [ 1, sig.boxcar(N), sig.bartlett(N), sig.hann(N), sig.blackman(N), sig.flattop(N) ] ##Rect d = 2.8 f1 = fs / 4 + 0.5 * fs / N f2 = f1 + d * (fs / N) a2 = 1 x1 = np.sin(2 * np.pi * f1 * tt) x2 = a2 * np.sin(2 * np.pi * f2 * tt) x = x1 + x2 xw = x * sig.boxcar(N) X = fft(xw)