def handle_new_data(self, floatdata): # the behaviour of the filters functions is sometimes # unexpected when they are called on empty arrays if floatdata.shape[1] == 0: return # for now, take the first channel only floatdata = floatdata[0, :] # compute the filters' output y, decs_unused = self.filters.filter(floatdata) # compute the widget data sp = [pyx_exp_smoothed_value(kernel, alpha, bankdata ** 2, old) for bankdata, kernel, alpha, old in zip(y, self.kernels, self.alphas, self.dispbuffers)] # store result for next computation self.dispbuffers = sp sp = array(sp) if self.weighting is 0: w = 0. elif self.weighting is 1: w = self.filters.A elif self.weighting is 2: w = self.filters.B else: w = self.filters.C epsilon = 1e-30 db_spectrogram = 10 * log10(sp + epsilon) + w self.PlotZoneSpect.setdata(self.filters.flow, self.filters.fhigh, self.filters.f_nominal, db_spectrogram)
def handle_new_data(self, floatdata): if floatdata.shape[0] > 1 and not self.two_channels: self.meter.setPortCount(2) self.two_channels = True elif floatdata.shape[0] == 1 and self.two_channels: self.meter.setPortCount(1) self.two_channels = False # first channel y1 = floatdata[0, :] # exponential smoothing for max if len(y1) > 0: value_max = np.abs(y1).max() if value_max > self.old_max * (1. - self.alpha2): self.old_max = value_max else: # exponential decrease self.old_max *= (1. - self.alpha2) # exponential smoothing for RMS value_rms = pyx_exp_smoothed_value(self.kernel, self.alpha, y1 ** 2, self.old_rms) self.old_rms = value_rms self.level_rms = 10. * np.log10(value_rms + 0. * 1e-80) self.level_max = 20. * np.log10(self.old_max + 0. * 1e-80) if self.two_channels: # second channel y2 = floatdata[1, :] # exponential smoothing for max if len(y2) > 0: value_max = np.abs(y2).max() if value_max > self.old_max_2 * (1. - self.alpha2): self.old_max_2 = value_max else: # exponential decrease self.old_max_2 *= (1. - self.alpha2) # exponential smoothing for RMS value_rms = pyx_exp_smoothed_value(self.kernel, self.alpha, y2 ** 2, self.old_rms_2) self.old_rms_2 = value_rms self.level_rms_2 = 10. * np.log10(value_rms + 0. * 1e-80) self.level_max_2 = 20. * np.log10(self.old_max_2 + 0. * 1e-80)
def update(self): if not self.isVisible(): return self.i += 1 # get the fresh data floatdata = self.audiobuffer.newdata() if floatdata.shape[0] > 1 and self.two_channels == False: self.meter.setPortCount(2) self.two_channels = True elif floatdata.shape[0] == 1 and self.two_channels == True: self.meter.setPortCount(1) self.two_channels = False # first channel y1 = floatdata[0,:] # exponential smoothing for max if len(y1) > 0: value_max = abs(y1).max() if value_max > self.old_max*(1.-self.alpha2): self.old_max = value_max else: # exponential decrease self.old_max *= (1.-self.alpha2) # exponential smoothing for RMS value_rms = pyx_exp_smoothed_value(self.kernel, self.alpha, y1**2, self.old_rms) self.old_rms = value_rms level_rms = 10.*log10(value_rms + 0.*1e-80) level_max = 20.*log10(self.old_max + 0.*1e-80) if self.i == LEVEL_TEXT_LABEL_STEPS: if level_rms > -150.: string_rms = "%.01f" % level_rms else: string_rms = "-Inf" if level_max > -150.: string_peak = "%.01f" % level_max else: string_peak = "-Inf" if not self.two_channels: self.meter.setValue(0, level_rms, level_max) if self.i == LEVEL_TEXT_LABEL_STEPS: self.label_rms.setText(string_rms) self.label_peak.setText(string_peak) else: # second channel y2 = floatdata[1,:] # exponential smoothing for max if len(y2) > 0: value_max = abs(y2).max() if value_max > self.old_max_2*(1.-self.alpha2): self.old_max_2 = value_max else: # exponential decrease self.old_max_2 *= (1.-self.alpha2) # exponential smoothing for RMS value_rms = pyx_exp_smoothed_value(self.kernel, self.alpha, y2**2, self.old_rms_2) self.old_rms_2 = value_rms level_rms_2 = 10.*log10(value_rms + 0.*1e-80) level_max_2 = 20.*log10(self.old_max_2 + 0.*1e-80) #self.meter.m_iPortCount = 3 self.meter.setValue(0, level_rms, level_max) self.meter.setValue(1, level_rms_2, level_max_2) if self.i == LEVEL_TEXT_LABEL_STEPS: if level_rms_2 > -150.: string_rms_2 = "%.01f" % level_rms_2 else: string_rms_2 = "-Inf" if level_max > -150.: string_peak_2 = "%.01f" % level_max_2 else: string_peak_2 = "-Inf" self.label_rms.setText("Ch1:\n%s\n\nCh2:\n%s" %(string_rms, string_rms_2)) self.label_peak.setText("Ch1:\n%s\n\nCh2:\n%s" %(string_peak, string_peak_2)) if self.i == LEVEL_TEXT_LABEL_STEPS: self.i = 0 if 0: fft_size = time*SAMPLING_RATE #1024 maxfreq = SAMPLING_RATE/2 sp, freq, A, B, C = self.proc.analyzelive(floatdata, fft_size, maxfreq) print level_rms, 10*log10((sp**2).sum()*2.), freq.max()
def handle_new_data(self, floatdata): #the behaviour of the filters functions is sometimes #unexpected when they are called on empty arrays if floatdata.shape[1] == 0: return # for now, take the first channel only floatdata = floatdata[0,:] #compute the filters' output y, decs_unused = self.filters.filter(floatdata) #push to the ring buffer #for bankbuffer, bankdata in zip(self.bankbuffers, y): # bankbuffer.push(bankdata**2) #for bankbuffer, bankdata, dec in zip(self.bankbuffers, y, decs): #bankbuffer.push(bankdata**2) ##an exponential smoothing filter is a simple IIR filter ##s_i = alpha*x_i + (1-alpha)*s_{i-1} ##we compute alpha so that the N most recent samples represent 100*w percent of the output #w = 0.65 #N = time*SAMPLING_RATE/dec #alpha = 1. - (1.-w)**(1./(N+1)) ##filter coefficient #forward = [alpha] #feedback = [1., -(1. - alpha)] #filt, zf = lfilter(forward, feedback, bankdata**2, zi=bankbuffer.data(1)) #bankbuffer.push(filt) #sp += [bankbuffer.data(1)[0]] #bankbuffer.push(bankdata**2) #sp += [self.exp_smoothed_value(time, dec, bankbuffer)] #compute the widget data #sp = [self.exp_smoothed_value(kernel, alpha, bankdata**2, old) for bankdata, kernel, alpha, old in zip(y, self.kernels, self.alphas, self.dispbuffers)] sp = [pyx_exp_smoothed_value(kernel, alpha, bankdata**2, old) for bankdata, kernel, alpha, old in zip(y, self.kernels, self.alphas, self.dispbuffers)] #store result for next computation self.dispbuffers = sp #un-weighted moving average #sp = [bankbuffer.data(time*SAMPLING_RATE/dec).mean() for bankbuffer, dec in zip(self.bankbuffers, decs)] sp = array(sp) # Note: the following is largely suboptimal since the filter outputs # are computed several times on the same signal... #floatdata = self.audiobuffer.data(time*SAMPLING_RATE) #y, dec = self.filters.filter(floatdata) #sp = [(bank**2).mean() for bank in y] #sp = array(sp)[::-1] #brute force without decimation #y_nodec = octave_filter_bank(self.b, self.a, floatdata) #sp_nodec = (y_nodec**2).mean(axis=1) if self.weighting is 0: w = 0. elif self.weighting is 1: w = self.filters.A elif self.weighting is 2: w = self.filters.B else: w = self.filters.C epsilon = 1e-30 db_spectrogram = 10*log10(sp + epsilon) + w self.PlotZoneSpect.setdata(self.filters.flow, self.filters.fhigh, self.filters.f_nominal, db_spectrogram)
def update(self): if not self.isVisible(): return #get the fresh data floatdata = self.audiobuffer.newdata() #the behaviour of the filters functions is sometimes #unexpected when they are called on empty arrays if floatdata.shape[1] == 0: return # for now, take the first channel only floatdata = floatdata[0, :] #compute the filters' output y, decs_unused = self.filters.filter(floatdata) #push to the ring buffer #for bankbuffer, bankdata in zip(self.bankbuffers, y): # bankbuffer.push(bankdata**2) #for bankbuffer, bankdata, dec in zip(self.bankbuffers, y, decs): #bankbuffer.push(bankdata**2) ##an exponential smoothing filter is a simple IIR filter ##s_i = alpha*x_i + (1-alpha)*s_{i-1} ##we compute alpha so that the N most recent samples represent 100*w percent of the output #w = 0.65 #N = time*SAMPLING_RATE/dec #alpha = 1. - (1.-w)**(1./(N+1)) ##filter coefficient #forward = [alpha] #feedback = [1., -(1. - alpha)] #filt, zf = lfilter(forward, feedback, bankdata**2, zi=bankbuffer.data(1)) #bankbuffer.push(filt) #sp += [bankbuffer.data(1)[0]] #bankbuffer.push(bankdata**2) #sp += [self.exp_smoothed_value(time, dec, bankbuffer)] #compute the widget data #sp = [self.exp_smoothed_value(kernel, alpha, bankdata**2, old) for bankdata, kernel, alpha, old in zip(y, self.kernels, self.alphas, self.dispbuffers)] sp = [ pyx_exp_smoothed_value(kernel, alpha, bankdata**2, old) for bankdata, kernel, alpha, old in zip( y, self.kernels, self.alphas, self.dispbuffers) ] #store result for next computation self.dispbuffers = sp #un-weighted moving average #sp = [bankbuffer.data(time*SAMPLING_RATE/dec).mean() for bankbuffer, dec in zip(self.bankbuffers, decs)] sp = array(sp) # Note: the following is largely suboptimal since the filter outputs # are computed several times on the same signal... #floatdata = self.audiobuffer.data(time*SAMPLING_RATE) #y, dec = self.filters.filter(floatdata) #sp = [(bank**2).mean() for bank in y] #sp = array(sp)[::-1] #brute force without decimation #y_nodec = octave_filter_bank(self.b, self.a, floatdata) #sp_nodec = (y_nodec**2).mean(axis=1) if self.weighting is 0: w = 0. elif self.weighting is 1: w = self.filters.A elif self.weighting is 2: w = self.filters.B else: w = self.filters.C epsilon = 1e-30 db_spectrogram = 10 * log10(sp + epsilon) + w self.PlotZoneSpect.setdata(self.filters.flow, self.filters.fhigh, self.filters.f_nominal, db_spectrogram)
def update(self): if not self.isVisible(): return self.i += 1 # get the fresh data floatdata = self.audiobuffer.newdata() if floatdata.shape[0] > 1 and self.two_channels == False: self.meter.setPortCount(2) self.two_channels = True elif floatdata.shape[0] == 1 and self.two_channels == True: self.meter.setPortCount(1) self.two_channels = False # first channel y1 = floatdata[0, :] # exponential smoothing for max if len(y1) > 0: value_max = abs(y1).max() if value_max > self.old_max * (1. - self.alpha2): self.old_max = value_max else: # exponential decrease self.old_max *= (1. - self.alpha2) # exponential smoothing for RMS value_rms = pyx_exp_smoothed_value(self.kernel, self.alpha, y1**2, self.old_rms) self.old_rms = value_rms level_rms = 10. * log10(value_rms + 0. * 1e-80) level_max = 20. * log10(self.old_max + 0. * 1e-80) if self.i == LEVEL_TEXT_LABEL_STEPS: if level_rms > -150.: string_rms = "%+05.01f" % level_rms else: string_rms = "-Inf" if level_max > -150.: string_peak = "%+05.01f" % level_max else: string_peak = "-Inf" if not self.two_channels: self.meter.setValue(0, level_rms, level_max) if self.i == LEVEL_TEXT_LABEL_STEPS: self.label_rms.setText(string_rms) self.label_peak.setText(string_peak) else: # second channel y2 = floatdata[1, :] # exponential smoothing for max if len(y2) > 0: value_max = abs(y2).max() if value_max > self.old_max_2 * (1. - self.alpha2): self.old_max_2 = value_max else: # exponential decrease self.old_max_2 *= (1. - self.alpha2) # exponential smoothing for RMS value_rms = pyx_exp_smoothed_value(self.kernel, self.alpha, y2**2, self.old_rms_2) self.old_rms_2 = value_rms level_rms_2 = 10. * log10(value_rms + 0. * 1e-80) level_max_2 = 20. * log10(self.old_max_2 + 0. * 1e-80) #self.meter.m_iPortCount = 3 self.meter.setValue(0, level_rms, level_max) self.meter.setValue(1, level_rms_2, level_max_2) if self.i == LEVEL_TEXT_LABEL_STEPS: if level_rms_2 > -150.: string_rms_2 = "%+05.01f" % level_rms_2 else: string_rms_2 = "-Inf" if level_max > -150.: string_peak_2 = "%+05.01f" % level_max_2 else: string_peak_2 = "-Inf" self.label_rms.setText("1: %s\n2: %s" % (string_rms, string_rms_2)) self.label_peak.setText("1: %s\n2: %s" % (string_peak, string_peak_2)) if self.i == LEVEL_TEXT_LABEL_STEPS: self.i = 0 if 0: fft_size = time * SAMPLING_RATE #1024 maxfreq = SAMPLING_RATE / 2 sp, freq, A, B, C = self.proc.analyzelive(floatdata, fft_size, maxfreq) print(level_rms, 10 * log10((sp**2).sum() * 2.), freq.max())